diff --git a/CHANGES.md b/CHANGES.md --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,96 @@ * Hackage: * GitHub: +### Version 14.8, 2026-09-25 + + * The main change in this release is a new C backend, with much broader + support for SBV programs, including arbitrary-width bit-vectors, recursive + functions, ADTs, and higher-order specializations. This was largely developed + with LLM assistance. The original backend remains available through + `Data.SBV.Tools.CodeGen.Legacy`, but we recommend the new backend and welcome + reports of any issues. See below for specific changes. + + * [BACKWARDS COMPATIBILITY] `Data.SBV.Tools.CodeGen` now selects a new C compiler. + Import `Data.SBV.Tools.CodeGen.Legacy` to keep using the original one, including + its low-level compilation functions. + + The new compiler supports standalone programs and static libraries using + arbitrary-width bit-vectors, native and arbitrary-format floating point, exact + integers and rational-valued reals, strings, lists, sets, tuples, ADTs, arrays, + recursive function definitions, closed array lambdas, and SBV's firstified + higher-order functions. Unsupported constructs, including solver-only features + and captured array lambdas, produce explicit errors. + + Unmapped `SInteger` and rational-valued `SReal` now use GMP instead of being + rejected. Keep `cgIntegerSize` or `cgSRealType` if native, precision-losing + representations are intentional. Arbitrary-format floats and rounding-sensitive + floating operations require LibBF; native bit-vector programs need neither. + + Regenerate C sources and headers together; generated type and helper names + have changed. + Detected runtime failures terminate the process; there is no error-return API. + See `Data.SBV.Tools.CodeGen` for supported features, dependencies, and the + ownership rules for composite values. + + * Generated floating-point code supports all five SBV rounding modes, including + conversions and fused operations. Ordinary `SFloat` and `SDouble` arithmetic + retains native C types. Callers and callbacks must preserve `FE_TONEAREST`; + builds must disable implicit contraction and fast-math. Generated Makefiles + supply the contraction flag. These restrictions do not apply to integer-only + programs. `CgLongDouble` conversions support binary64, x87 extended, and + binary128 target formats. + + * The new C compiler supports regex matching without an additional dependency. + `cgSetRegexLimits` (named settings) and `cgRegexLimits` control generation + budgets without limiting runtime string length. Direct array equality is + supported for finite key domains, with a configurable `cgArrayEqualityLimit`. + Exceeding these limits produces a generation error, not an approximation. + + * Generated C libraries rebuild correctly after component or header changes. + Required libraries and `cgAddLDFlags` settings are kept in `SBV_LIBS`, so + caller-supplied `LDFLAGS` no longer discard them. Use `SBV_LIBS` to override + dependency discovery when integrating a custom installation. + + * Fix incorrect C results for pseudo-Boolean comparisons with large totals and + native-mapped real-to-integer flooring. Generated diagnostic labels and + assertion messages safely handle special characters. + + * ADTs containing other ADTs inside tuples, lists, sets, or arrays no longer + need unrelated uses or explicit type registration to work reliably. + This also applies to literal-only computations and to named and unnamed + query-mode fresh variables. + + * Functions defined with `smtFunction` and its variants can now be first used + in query mode without calling `registerFunction` beforehand. + Thanks to David Van Balen for reporting [issue #815](https://github.com/LeventErkok/sbv/issues/815). + + * Fix constant folding of integral literals converted with `toSFloatingPoint` + under non-default rounding modes, including overflow. Integral conversions + with `toSFloat` and `toSDouble` now also fold in all five rounding modes. + + * Fix literal regex matching involving universal, complement, difference, and + intersection expressions inside concatenations and repetitions. Empty + concatenations (`Conc []`) now serialize correctly; invalid `Loop` and + `Power` bounds are rejected consistently. + + * Fix first use of rational types in query mode, including rational fields + nested in other types. `registerType` now works inside queries and can + be safely repeated. + + * `registerFunction` no longer rules out NaN results for floating-point + functions. + + * `getFunction` now preserves the current model and handles + uninterpreted argument sorts and quoted function names correctly. + + * [BACKWARDS COMPATIBILITY] `getFunction` now rejects unregistered functions. + Use the function in a constraint or call `registerFunction` before checking + satisfiability. Custom `SMTFunction` instances overriding `sexprToFun` must + accept an additional function-name argument. + + * New example: `Documentation.SBV.Examples.ADT.Shapes` demonstrates symbolic + pattern matching and enumerating datatype values with `allSat` and query mode. + ### Version 14.7, 2026-08-31 * Fix https://github.com/LeventErkok/sbv/issues/813. Thanks to David van Balen for reporting. diff --git a/Data/SBV.hs b/Data/SBV.hs --- a/Data/SBV.hs +++ b/Data/SBV.hs @@ -1175,6 +1175,9 @@ These types can also be parameterized, per usual Haskell usage. +For a complete example of constraining and enumerating datatype values, see +"Documentation.SBV.Examples.ADT.Shapes". + We also support a symbolic case-expression quasi-quoter, allowing us to write: @ diff --git a/Data/SBV/Client.hs b/Data/SBV/Client.hs --- a/Data/SBV/Client.hs +++ b/Data/SBV/Client.hs @@ -56,9 +56,9 @@ import Data.SBV.Core.Concrete (cvRank) import Data.SBV.Core.Data +import Data.SBV.Core.Kind (withADTDependencies) import Data.SBV.Core.Model import Data.SBV.Core.SizedFloats -import Data.SBV.Core.Symbolic (registerKind) import Data.SBV.Provers.Prover import qualified Data.SBV.List as SL @@ -109,9 +109,6 @@ deriving instance TH.Lift TH.TyLit #endif --- A few other things we need to TH lift -deriving instance TH.Lift Kind - data ADTKind = ADTUninterpreted -- Completely uninterpreted | ADTEnum -- Enumeration | ADTFull -- A full datatype @@ -274,28 +271,15 @@ in [| Just ($minb, $maxb) |] else [| Nothing |] - -- make the initializer to get the subtypes registered - st <- TH.newName "_st" -- Get an underscored name here, since st might go unused if there're no subtypes - register <- do let concretize b@TH.ConT{} = b - concretize TH.VarT{} = TH.ConT ''Integer - concretize (TH.AppT l arg) = TH.AppT (concretize l) (concretize arg) - concretize r = r - - end <- TH.noBindS [| pure () |] - pure $ TH.DoE Nothing $ [TH.NoBindS (TH.AppE (TH.AppE (TH.VarE 'registerKind) (TH.VarE st)) - (TH.AppE (TH.VarE 'kindOf) - (TH.AppTypeE (TH.ConE 'Proxy) (concretize t)))) - | (_, fts) <- cstrs, (_, t, KApp n _) <- fts, n /= TH.nameBase typeName - ] ++ [end] - - let regFun = TH.FunD 'mkSymValInit [TH.Clause [TH.VarP st, TH.WildP] (TH.NormalB register) []] + -- Retain declarations on the kind so literals and symbolic variables take + -- the same registration path, including beneath containers. + dependencies <- adtRegistrationTypes typeName let symVal = TH.InstanceD Nothing symCtx (TH.AppT (TH.ConT ''SymVal) typeCon) [ litFun - , regFun , TH.FunD 'minMaxBound [TH.Clause [] (TH.NormalB mmBound) []] , TH.FunD 'fromCV [TH.Clause [] (TH.NormalB getFromCV) []] ] @@ -318,8 +302,12 @@ Nothing kindCtx (TH.AppT (TH.ConT ''HasKind) typeCon) - [TH.FunD 'kindOf [TH.Clause [TH.WildP] (TH.NormalB kindDef) []]] + [TH.FunD 'kindOf [TH.Clause [TH.WildP] (TH.NormalB completeKindDef) []]] + completeKindDef = TH.AppE (TH.AppE (TH.VarE 'withADTDependencies) + (TH.ListE [TH.AppE (TH.VarE 'kindOf) (TH.AppTypeE (TH.ConE 'Proxy) t) | t <- dependencies])) + kindDef + hasArbitrary <- TH.isInstance ''Arbitrary [typeCon] arbDecl <- case () of () | hasArbitrary -> pure [] @@ -590,6 +578,46 @@ | True = ADTFull pure (k, args, cs) + +-- | Find all ADT definitions needed by a generated kind, including +-- references nested in containers and dependencies of those references. Visit each +-- type constructor once so recursive and mutually recursive declarations terminate. +-- Registration needs only the datatype schema: replace free type variables with +-- Integer, retaining concrete arguments and the declaration's own type variables. +adtRegistrationTypes :: TH.Name -> TH.Q [TH.Type] +adtRegistrationTypes root = dependencies root >>= collect [root] + where collect _ [] = pure [] + collect seen ((nm, ty) : pending) + | nm `elem` seen = collect seen pending + | True = do nested <- dependencies nm + rest <- collect (nm : seen) (pending ++ nested) + pure (concretize ty : rest) + + -- Integer is only a registration placeholder used to obtain a schema, + -- not the program's instantiation; actual type arguments are substituted + -- separately when the schema is used. + concretize TH.VarT{} = TH.ConT ''Integer + concretize (TH.AppT l arg) = TH.AppT (concretize l) (concretize arg) + concretize ty = ty + + dependencies nm = do (_, _, constructors) <- dissect nm + concat <$> sequence [field nm constructor ty | (constructor, fields) <- constructors, (_, ty, _) <- fields] + + field owner constructor original = do + ty <- expandSyns original + kind <- toSBV owner constructor ty + let (headType, arguments) = applications ty [] + nested = concat <$> mapM (field owner constructor) arguments + case kind of + KApp{} | TH.ConT nm <- headType -> ((nm, ty) :) <$> nested + KTuple{} -> nested + KList{} -> nested + KSet{} -> nested + KArray{} -> nested + _ -> pure [] + + applications (TH.AppT fun arg) arguments = applications fun (arg : arguments) + applications fun arguments = (fun, arguments) -- | Find the SBV kind for this type toSBV :: TH.Name -> TH.Name -> TH.Type -> TH.Q Kind diff --git a/Data/SBV/Compilers/C.hs b/Data/SBV/Compilers/C.hs --- a/Data/SBV/Compilers/C.hs +++ b/Data/SBV/Compilers/C.hs @@ -6,1079 +6,64 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental -- --- Compilation of symbolic programs to C ------------------------------------------------------------------------------ - -{-# LANGUAGE TupleSections #-} - -{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-} - -module Data.SBV.Compilers.C(compileToC, compileToCLib, compileToC', compileToCLib') where - -import Control.DeepSeq (rnf) -import Data.Char (isSpace) -import Data.List (nub, intercalate, intersperse) -import Data.Maybe (isJust, isNothing, fromJust) -import qualified Data.Foldable as F (toList) -import qualified Data.Set as Set (member, union, unions, empty, toList, singleton, fromList) -import qualified Data.Text as T -import System.FilePath (takeBaseName, replaceExtension) -import System.Random - -import Data.SBV.Core.Symbolic (ResultInp(..), ProgInfo(..)) - --- Work around the fact that GHC 8.4.1 started exporting <>.. Hmm.. -import Text.PrettyPrint.HughesPJ -import qualified Text.PrettyPrint.HughesPJ as P ((<>)) - -import Data.SBV.Core.Data -import Data.SBV.Core.Kind (kRoundingMode) -import Data.SBV.Compilers.CodeGen - -import Data.SBV.Utils.PrettyNum (chex, showCFloat, showCDouble) - -import GHC.Stack - ---------------------------------------------------------------------------- --- * 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. As a --- result, we return whatever the code-gen function returns. Most uses should simply have @()@ as --- the return type here, but the value can be useful if you want to chain the result of --- one compilation act to the next. -compileToC :: Maybe FilePath -> String -> SBVCodeGen a -> IO a -compileToC mbDirName nm f = do (retVal, cfg, bundle) <- compileToC' nm f - renderCgPgmBundle mbDirName (cfg, bundle) - pure retVal - --- | Lower level version of 'compileToC', producing a t'CgPgmBundle' -compileToC' :: String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle) -compileToC' nm f = do rands <- randoms <$> newStdGen - 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 a)] -> IO [a] -compileToCLib mbDirName libName comps = do (retVal, cfg, pgm) <- compileToCLib' libName comps - renderCgPgmBundle mbDirName (cfg, pgm) - pure retVal - --- | Lower level version of 'compileToCLib', producing a t'CgPgmBundle' -compileToCLib' :: String -> [(String, SBVCodeGen a)] -> IO ([a], CgConfig, CgPgmBundle) -compileToCLib' libName comps = do resCfgBundles <- mapM (uncurry compileToC') comps - let (finalCfg, finalPgm) = mergeToLib libName [(c, b) | (_, c, b) <- resCfgBundles] - pure ([r | (r, _, _) <- resCfgBundles], finalCfg, finalPgm) - ---------------------------------------------------------------------------- --- * 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 :: CgConfig -> String -> CgState -> Result -> CgPgmBundle -cgen cfg nm st sbvProg - -- we rnf the main pg and the sig to make sure any exceptions in type conversion pop-out early enough - -- this is purely cosmetic, of course.. - = rnf (render sig) `seq` rnf (render (vcat body)) `seq` result - where result = CgPgmBundle bundleKind - $ filt [ ("Makefile", (CgMakefile flags, [genMake (cgGenDriver cfg) nm nmd flags])) - , (nm ++ ".h", (CgHeader [sig], [genHeader bundleKind nm [sig] extProtos])) - , (nmd ++ ".c", (CgDriver, genDriver cfg randVals nm ins outs mbRet)) - , (nm ++ ".c", (CgSource, body)) - ] - - (body, flagsNeeded) = genCProg cfg nm sig sbvProg ins outs mbRet extDecls - - bundleKind = (cgInteger cfg, cgReal cfg) - - randVals = cgDriverVals cfg - - filt xs = [c | c@(_, (k, _)) <- xs, need k] - where need k | isCgDriver k = cgGenDriver cfg - | isCgMakefile k = cgGenMakefile cfg - | True = True - - 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" - extProtos = case cgPrototypes st of - [] -> empty - xs -> vcat $ text "/* User given prototypes: */" : map text xs - extDecls = case cgDecls st of - [] -> empty - xs -> vcat $ text "/* User given declarations: */" : map text xs - flags = flagsNeeded ++ cgLDFlags st - --- | 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 SV -> Doc -pprCFunHeader fn ins outs mbRet = retType <+> text fn P.<> parens (fsep (punctuate comma (map mkParam ins ++ map mkPParam outs))) - where retType = case mbRet of - Nothing -> text "void" - Just sv -> pprCWord False sv - -mkParam, mkPParam :: (String, CgVal) -> Doc -mkParam (n, CgAtomic sv) = pprCWord True sv <+> text n -mkParam (_, CgArray []) = die "mkParam: CgArray with no elements!" -mkParam (n, CgArray (sv:_)) = pprCWord True sv <+> text "*" P.<> text n -mkPParam (n, CgAtomic sv) = pprCWord False sv <+> text "*" P.<> text n -mkPParam (_, CgArray []) = die "mPkParam: CgArray with no elements!" -mkPParam (n, CgArray (sv:_)) = pprCWord False sv <+> text "*" P.<> text n - --- | Renders as "const SWord8 s0", etc. the first parameter is the width of the typefield -declSV :: Int -> SV -> Doc -declSV w sv = text "const" <+> pad (showCType sv) <+> text (show sv) - where pad s = text $ s ++ replicate (w - length s) ' ' - --- | Return the proper declaration and the result as a pair. No consts -declSVNoConst :: Int -> SV -> (Doc, Doc) -declSVNoConst w sv = (text " " <+> pad (showCType sv), text (show sv)) - where pad s = text $ s ++ replicate (w - length s) ' ' - --- | Renders as "s0", etc, or the corresponding constant -showSV :: CgConfig -> [(SV, CV)] -> SV -> Doc -showSV cfg consts sv - | sv == falseSV = text "false" - | sv == trueSV = text "true" - | Just cv <- sv `lookup` consts = mkConst cfg cv - | True = text $ show sv - --- | Words as it would map to a C word -pprCWord :: HasKind a => Bool -> a -> Doc -pprCWord cnst v = (if cnst then text "const" else empty) <+> text (showCType v) - --- | Almost a "show", but map "SWord1" to "SBool" --- which is used for extracting one-bit words. This is OK since C's bool type --- handles arithmetic fine, and maps nicely to our `SWord 1`. (Same isn't true for `SInt 1`, which --- doesn't have an easy counter-part on the C side. -showCType :: HasKind a => a -> String -showCType i = case kindOf i of - KBounded False 1 -> "SBool" - k -> show k - --- | The printf specifier for the type -specifier :: CgConfig -> SV -> Doc -specifier cfg sv = case kindOf sv of - KVar{} -> die $ "variable sort: " ++ show (kindOf sv) - KBool -> spec (False, 1) - KBounded b i -> spec (b, i) - KUnbounded -> spec (True, fromJust (cgInteger cfg)) - KReal -> specF (fromJust (cgReal cfg)) - KFloat -> specF CgFloat - KDouble -> specF CgDouble - KString -> text "%s" - KChar -> text "%c" - KRational -> die "rational sort" - KFP{} -> die "arbitrary float sort" - KList k -> die $ "list sort: " ++ show k - KSet k -> die $ "set sort: " ++ show k - KApp s _ -> die $ "ADT app: " ++ s - KADT s _ _ -> die $ "ADT: " ++ s - KTuple k -> die $ "tuple sort: " ++ show k - KArray k1 k2 -> die $ "array sort: " ++ show (k1, k2) - where u8InHex = cgShowU8InHex cfg - - spec :: (Bool, Int) -> Doc - spec (False, 1) = text "%d" - spec (False, 8) - | u8InHex = text "0x%02\"PRIx8\"" - | True = text "%\"PRIu8\"" - spec (True, 8) = text "%\"PRId8\"" - spec (False, 16) = text "0x%04\"PRIx16\"U" - spec (True, 16) = text "%\"PRId16\"" - spec (False, 32) = text "0x%08\"PRIx32\"UL" - spec (True, 32) = text "%\"PRId32\"L" - spec (False, 64) = text "0x%016\"PRIx64\"ULL" - spec (True, 64) = text "%\"PRId64\"LL" - spec (s, sz) = die $ "Format specifier at type " ++ (if s then "SInt" else "SWord") ++ show sz - - specF :: CgSRealType -> Doc - specF CgFloat = text "%a" - specF CgDouble = text "%a" - specF CgLongDouble = text "%Lf" - --- | 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 use decimal for values 8-bits or less, --- and hex otherwise. -mkConst :: CgConfig -> CV -> Doc -mkConst cfg (CV KReal (CAlgReal (AlgRational _ r))) = double (fromRational r :: Double) P.<> sRealSuffix (fromJust (cgReal cfg)) - where sRealSuffix CgFloat = text "F" - sRealSuffix CgDouble = empty - sRealSuffix CgLongDouble = text "L" -mkConst cfg (CV KUnbounded (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (True, fromJust (cgInteger cfg)) -mkConst cfg (CV (KBounded sg sz) (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (sg, sz) -mkConst cfg (CV KBool (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (False, 1) -mkConst _ (CV KFloat (CFloat f)) = text $ showCFloat f -mkConst _ (CV KDouble (CDouble d)) = text $ showCDouble d -mkConst _ (CV KString (CString s)) = text $ show s -mkConst _ (CV KChar (CChar c)) = text $ show c -mkConst _ cv = die $ "mkConst: " ++ show cv - -showSizedConst :: Bool -> Integer -> (Bool, Int) -> Doc -showSizedConst _ i (False, 1) = text (if i == 0 then "false" else "true") -showSizedConst u8h i t@(False, 8) - | u8h = text $ T.unpack (chex False True t i) - | True = integer i -showSizedConst _ i (True, 8) = integer i -showSizedConst _ i t@(False, 16) = text $ T.unpack $ chex False True t i -showSizedConst _ i t@(True, 16) = text $ T.unpack $ chex False True t i -showSizedConst _ i t@(False, 32) = text $ T.unpack $ chex False True t i -showSizedConst _ i t@(True, 32) = text $ T.unpack $ chex False True t i -showSizedConst _ i t@(False, 64) = text $ T.unpack $ chex False True t i -showSizedConst _ i t@(True, 64) = text $ T.unpack $ chex False True t i -showSizedConst _ i (s, sz) = die $ "Constant " ++ show i ++ " at type " ++ (if s then "SInt" else "SWord") ++ show sz - --- | Generate a makefile. The first argument is True if we have a driver. -genMake :: Bool -> String -> String -> [String] -> Doc -genMake ifdr fn dn ldFlags = foldr1 ($$) [l | (True, l) <- lns] - where ifld = not (null ldFlags) - ld | ifld = text "${LDFLAGS}" - | True = empty - lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") - , (True, text "") - , (True, text "# include any user-defined .mk file in the current directory.") - , (True, text "-include *.mk") - , (True, text "") - , (True, text "CC?=gcc") - , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") - , (ifld, text "LDFLAGS?=" P.<> text (unwords ldFlags)) - , (True, text "") - , (ifdr, text "all:" <+> nmd) - , (ifdr, text "") - , (True, nmo P.<> text (": " ++ ppSameLine (hsep [nmc, nmh]))) - , (True, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") - , (True, text "") - , (ifdr, nmdo P.<> text ":" <+> nmdc) - , (ifdr, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") - , (ifdr, text "") - , (ifdr, nmd P.<> text (": " ++ ppSameLine (hsep [nmo, nmdo]))) - , (ifdr, text "\t${CC} ${CCFLAGS}" <+> text "$^ -o $@" <+> ld) - , (ifdr, text "") - , (True, text "clean:") - , (True, text "\trm -f *.o") - , (True, text "") - , (ifdr, text "veryclean: clean") - , (ifdr, text "\trm -f" <+> nmd) - , (ifdr, text "") - ] - nm = text fn - nmd = text dn - nmh = nm P.<> text ".h" - nmc = nm P.<> text ".c" - nmo = nm P.<> text ".o" - nmdc = nmd P.<> text ".c" - nmdo = nmd P.<> text ".o" - --- | Generate the header -genHeader :: (Maybe Int, Maybe CgSRealType) -> String -> [Doc] -> Doc -> Doc -genHeader (ik, rk) fn sigs protos = - text "/* Header file for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit! */" - $$ text "" - $$ text "#ifndef" <+> tag - $$ text "#define" <+> tag - $$ text "" - $$ text "#include " - $$ text "#include " - $$ text "#include " - $$ text "#include " - $$ text "#include " - $$ text "#include " - $$ text "#include " - $$ text "" - $$ text "/* The boolean type */" - $$ text "typedef bool SBool;" - $$ text "" - $$ text "/* The float type */" - $$ text "typedef float SFloat;" - $$ text "" - $$ text "/* The double type */" - $$ text "typedef double SDouble;" - $$ text "" - $$ text "/* Unsigned bit-vectors */" - $$ 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 "" - $$ imapping - $$ rmapping - $$ text ("/* Entry point prototype" ++ plu ++ ": */") - $$ vcat (map (P.<> semi) sigs) - $$ text "" - $$ protos - $$ text "#endif /*" <+> tag <+> text "*/" - $$ text "" - where nm = text fn - tag = text "__" P.<> nm P.<> text "__HEADER_INCLUDED__" - plu = if length sigs /= 1 then "s" else "" - imapping = case ik of - Nothing -> empty - Just i -> text "/* User requested mapping for SInteger. */" - $$ text "/* NB. Loss of precision: Target type is subject to modular arithmetic. */" - $$ text ("typedef SInt" ++ show i ++ " SInteger;") - $$ text "" - rmapping = case rk of - Nothing -> empty - Just t -> text "/* User requested mapping for SReal. */" - $$ text "/* NB. Loss of precision: Target type is subject to rounding. */" - $$ text ("typedef " ++ show t ++ " SReal;") - $$ text "" - -sepIf :: Bool -> Doc -sepIf b = if b then text "" else empty - --- | Generate an example driver program -genDriver :: CgConfig -> [Integer] -> String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> [Doc] -genDriver cfg randVals fn inps outs mbRet = [pre, header, body, post] - where pre = text "/* Example driver program for" <+> nm P.<> text ". */" - $$ text "/* Automatically generated by SBV. Edit as you see fit! */" - $$ text "" - $$ text "#include " - header = text "#include" <+> doubleQuotes (nm P.<> 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 sv -> text "printf" P.<> parens (printQuotes (fcall <+> text "=" <+> specifier cfg sv P.<> text "\\n") - P.<> comma <+> resultVar) P.<> semi - Nothing -> text "printf" P.<> parens (printQuotes (fcall <+> text "->\\n")) P.<> semi) - $$ vcat (map display outs) - ) - post = text "" - $+$ nest 2 (text "return 0" P.<> semi) - $$ text "}" - $$ text "" - nm = text fn - pairedInputs = matchRands randVals inps - matchRands _ [] = [] - matchRands [] _ = die "Run out of driver values!" - matchRands (r:rs) ((n, CgAtomic sv) : cs) = ([mkRVal sv r], n, CgAtomic sv) : matchRands rs cs - matchRands _ ((n, CgArray []) : _ ) = die $ "Unsupported empty array input " ++ show n - matchRands rs ((n, a@(CgArray sws@(sv:_))) : cs) - | length frs /= l = die "Run out of driver values!" - | True = (map (mkRVal sv) frs, n, a) : matchRands srs cs - where l = length sws - (frs, srs) = splitAt l rs - mkRVal sv r = mkConst cfg $ mkConstCV (kindOf sv) r - mkInp (_, _, CgAtomic{}) = empty -- constant, no need to declare - mkInp (_, n, CgArray []) = die $ "Unsupported empty array value for " ++ show n - mkInp (vs, n, CgArray sws@(sv:_)) = pprCWord True sv <+> text n P.<> brackets (int (length sws)) <+> text "= {" - $$ nest 4 (fsep (punctuate comma (align vs))) - $$ text "};" - $$ text "" - $$ text "printf" P.<> parens (printQuotes (text "Contents of input array" <+> text n P.<> text ":\\n")) P.<> semi - $$ display (n, CgArray sws) - $$ text "" - mkOut (v, CgAtomic sv) = pprCWord False sv <+> text v P.<> semi - mkOut (v, CgArray []) = die $ "Unsupported empty array value for " ++ show v - mkOut (v, CgArray sws@(sv:_)) = pprCWord False sv <+> text v P.<> brackets (int (length sws)) P.<> semi - resultVar = text "__result" - call = case mbRet of - Nothing -> fcall P.<> semi - Just sv -> pprCWord True sv <+> resultVar <+> text "=" <+> fcall P.<> semi - fcall = nm P.<> 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 "&" P.<> text n - mkOVal (n, CgArray{}) = text n - display (n, CgAtomic sv) = text "printf" P.<> parens (printQuotes (text " " <+> text n <+> text "=" <+> specifier cfg sv - P.<> text "\\n") P.<> comma <+> text n) P.<> semi - display (n, CgArray []) = die $ "Unsupported empty array value for " ++ show n - display (n, CgArray sws@(sv:_)) = text "int" <+> nctr P.<> semi - $$ text "for(" P.<> nctr <+> text "= 0;" <+> nctr <+> text "<" <+> int len <+> text "; ++" P.<> nctr P.<> text ")" - $$ nest 2 (text "printf" P.<> parens (printQuotes (text " " <+> entrySpec <+> text "=" <+> spec P.<> text "\\n") - P.<> comma <+> nctr <+> comma P.<> entry) P.<> semi) - where nctr = text n P.<> text "_ctr" - entry = text n P.<> text "[" P.<> nctr P.<> text "]" - entrySpec = text n P.<> text "[%" P.<> int tab P.<> text "d]" - spec = specifier cfg sv - len = length sws - tab = length $ show (len - 1) - --- | Generate the C program -genCProg :: CgConfig -> String -> Doc -> Result -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> Doc -> ([Doc], [String]) -genCProg cfg fn proto (Result pinfo kindInfo _tvals _ovals cgs topInps (_, preConsts) tbls _uis axioms (SBVPgm asgns) cstrs origAsserts _) inVars outVars mbRet extDecls - | isNothing (cgInteger cfg) && KUnbounded `Set.member` kindInfo - = error $ "SBV->C: Unbounded integers are not supported by the C compiler." - ++ "\nUse 'cgIntegerSize' to specify a fixed size for SInteger representation." - | KString `Set.member` kindInfo - = notyet "Strings" - | KChar `Set.member` kindInfo - = notyet "Characters" - | any isSet kindInfo - = notyet "Sets (SSet)" - | any isList kindInfo - = notyet "Lists (SList)" - | any isTuple kindInfo - = notyet "Tuples (STupleN)" - | isNothing (cgReal cfg) && KReal `Set.member` kindInfo - = error $ "SBV->C: SReal values are not supported by the C compiler." - ++ "\nUse 'cgSRealType' to specify a custom type for SReal representation." - | not (null unsupportedBVs) - = error $ "SBV->C: Unsupported bit-vector type(s): " ++ intercalate ", " (map show unsupportedBVs) - | not (null usorts) - = error $ "SBV->C: Cannot compile functions with uninterpreted sorts: " ++ intercalate ", " usorts - | hasQuants pinfo - = error "SBV->C: Cannot compile in the presence of quantified variables." - | not $ null (progSpecialRels pinfo) - = error "SBV->C: Cannot compile in the presence of special relations." - | not (null axioms) - = error "SBV->C: Cannot compile in the presence of 'smtFunction' definitions, use 'compileToCLib' instead." - | not (null cstrs) - = tbd "Explicit constraints" - | True - = ([pre, header, post], flagsNeeded) - where notyet m = error $ "SBV->C: " ++ m ++ " are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!" - - asserts | cgIgnoreAsserts cfg = [] - | True = origAsserts - - usorts = [s | k@(KADT s _ _) <- Set.toList kindInfo, isADT k && not (isRoundingMode k)] -- No support for any sorts other than RoundingMode! - - pre = text "/* File:" <+> doubleQuotes (nm P.<> text ".c") P.<> text ". Automatically generated by SBV. Do not edit! */" - $$ text "" - - header = text "#include" <+> doubleQuotes (nm P.<> text ".h") - - unsupportedBVs = [k | k@(KBounded sg sz) <- Set.toList kindInfo, (not . supported) (sg, sz)] - where supported (False, sz) = sz `elem` [1, 8, 16, 32, 64] - supported (True, sz) = sz `elem` [ 8, 16, 32, 64] - - post = text "" - $$ vcat (map codeSeg cgs) - $$ extDecls - $$ proto - $$ text "{" - $$ text "" - $$ nest 2 ( vcat (concatMap (genIO True . (\v -> (isAlive v, v))) inVars) - $$ vcat (merge (map genTbl tbls) (map genAsgn assignments) (map genAssert asserts)) - $$ sepIf (not (null assignments) || not (null tbls)) - $$ vcat (concatMap (genIO False . (True,)) outVars) - $$ maybe empty mkRet mbRet - ) - $$ text "}" - $$ text "" - - nm = text fn - - assignments = F.toList asgns - - -- Do we need any linker flags for C? - flagsNeeded = nub $ concatMap (getLDFlag . opRes) assignments - where opRes (sv, SBVApp o _) = (o, kindOf sv) - - codeSeg (fnm, ls) = text "/* User specified custom code for" <+> doubleQuotes (text fnm) <+> text "*/" - $$ vcat (map text ls) - $$ text "" - - ins = case topInps of - ResultTopInps (is, []) -> is - ResultTopInps is -> die $ "Unexpected trackers: " ++ show is - ResultLamInps is -> die $ "Unexpected inputs : " ++ show is - - typeWidth = getMax 0 $ [len (kindOf s) | (s, _) <- assignments] ++ [len (kindOf s) | NamedSymVar s _ <- ins] - where len (KVar s) = die $ "Variable: " ++ s - len KReal{} = 5 - len KFloat{} = 6 -- SFloat - len KDouble{} = 7 -- SDouble - len KString{} = 7 -- SString - len KChar{} = 5 -- SChar - len KUnbounded{} = 8 - len KBool = 5 -- SBool - len (KBounded False n) = 5 + length (show n) -- SWordN - len (KBounded True n) = 4 + length (show n) -- SIntN - len KRational{} = die "Rational." - len KFP{} = die "Arbitrary float." - len (KList s) = die $ "List sort: " ++ show s - len (KSet s) = die $ "Set sort: " ++ show s - len (KTuple s) = die $ "Tuple sort: " ++ show s - len (KArray k1 k2) = die $ "Array sort: " ++ show (k1, k2) - len (KApp s _) = die $ "Uninterpreted ADT app: " ++ s - len (KADT s _ _) = die $ "Uninterpreted ADT: " ++ s - - getMax 8 _ = 8 -- 8 is the max we can get with SInteger, so don't bother looking any further - getMax m [] = m - getMax m (x:xs) = getMax (m `max` x) xs - - consts = (falseSV, falseCV) : (trueSV, trueCV) : preConsts - - isConst s = isJust (lookup s consts) - - -- TODO: The following is brittle. We should really have a function elsewhere - -- that walks the SBVExprs and collects the SWs together. - usedVariables = Set.unions (retSWs : map usedCgVal outVars ++ map usedAsgn assignments) - where retSWs = maybe Set.empty Set.singleton mbRet - - usedCgVal (_, CgAtomic s) = Set.singleton s - usedCgVal (_, CgArray ss) = Set.fromList ss - usedAsgn (_, SBVApp o ss) = Set.union (opSWs o) (Set.fromList ss) - - opSWs (LkUp _ a b) = Set.fromList [a, b] - opSWs (IEEEFP (FP_Cast _ _ s)) = Set.singleton s - opSWs _ = Set.empty - - isAlive :: (String, CgVal) -> Bool - isAlive (_, CgAtomic sv) = sv `Set.member` usedVariables - isAlive (_, _) = True - - genIO :: Bool -> (Bool, (String, CgVal)) -> [Doc] - genIO True (alive, (cNm, CgAtomic sv)) = [declSV typeWidth sv <+> text "=" <+> text cNm P.<> semi | alive] - genIO False (alive, (cNm, CgAtomic sv)) = [text "*" P.<> text cNm <+> text "=" <+> showSV cfg consts sv P.<> semi | alive] - genIO isInp (_, (cNm, CgArray sws)) = zipWith genElt sws [(0::Int)..] - where genElt sv i - | isInp = declSV typeWidth sv <+> text "=" <+> text entry P.<> semi - | True = text entry <+> text "=" <+> showSV cfg consts sv P.<> semi - where entry = cNm ++ "[" ++ show i ++ "]" - - mkRet sv = text "return" <+> showSV cfg consts sv P.<> semi - - genTbl :: ((Int, Kind, Kind), [SV]) -> (Int, Doc) - genTbl ((i, _, k), elts) = (location, static <+> text "const" <+> text (show k) <+> text ("table" ++ show i) P.<> text "[] = {" - $$ nest 4 (fsep (punctuate comma (align (map (showSV cfg consts) elts)))) - $$ text "};") - where static = if location == -1 then text "static" else empty - location = maximum (-1 : map getNodeId elts) - - getNodeId s@(SV _ (NodeId (_, _, n))) | isConst s = -1 - | True = n - - genAsgn :: (SV, SBVExpr) -> (Int, Doc) - genAsgn (sv, n) = (getNodeId sv, ppExpr cfg consts n (declSV typeWidth sv) (declSVNoConst typeWidth sv) P.<> semi) - - -- merge tables intermixed with assignments and assertions, paying attention to putting tables as - -- early as possible and tables right after.. Note that the assignment list (second argument) is sorted on its order - merge :: [(Int, Doc)] -> [(Int, Doc)] -> [(Int, Doc)] -> [Doc] - merge tables asgnments asrts = map snd $ merge2 asrts (merge2 tables asgnments) - where merge2 [] as = as - merge2 ts [] = ts - merge2 ts@((i, t):trest) as@((i', a):arest) - | i < i' = (i, t) : merge2 trest as - | True = (i', a) : merge2 ts arest - - genAssert (msg, cs, sv) = (getNodeId sv, doc) - where doc = text "/* ASSERTION:" <+> text msg - $$ maybe empty (vcat . map text) (locInfo (getCallStack <$> cs)) - $$ text " */" - $$ text "if" P.<> parens (showSV cfg consts sv) - $$ text "{" - $+$ nest 2 (vcat [errOut, text "exit(-1);"]) - $$ text "}" - $$ text "" - errOut = text $ "fprintf(stderr, \"%s:%d:ASSERTION FAILED: " ++ msg ++ "\\n\", __FILE__, __LINE__);" - locInfo (Just ps) = let loc (f, sl) = concat [srcLocFile sl, ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f ] - in case map loc ps of - [] -> Nothing - (f:rs) -> Just $ (" * SOURCE : " ++ f) : map (" * " ++) rs - locInfo _ = Nothing - -handlePB :: PBOp -> [Doc] -> Doc -handlePB o args = case o of - PB_AtMost k -> addIf (repeat 1) <+> text "<=" <+> int k - PB_AtLeast k -> addIf (repeat 1) <+> text ">=" <+> int k - PB_Exactly k -> addIf (repeat 1) <+> text "==" <+> int k - PB_Le cs k -> addIf cs <+> text "<=" <+> int k - PB_Ge cs k -> addIf cs <+> text ">=" <+> int k - PB_Eq cs k -> addIf cs <+> text "==" <+> int k - - where addIf :: [Int] -> Doc - addIf cs = parens $ fsep $ intersperse (text "+") [parens (a <+> text "?" <+> int c <+> text ":" <+> int 0) | (a, c) <- zip args cs] - -handleIEEE :: FPOp -> [(SV, CV)] -> [(SV, Doc)] -> Doc -> Doc -handleIEEE w consts as var = cvt w - where same f = (f, f) - named fnm dnm f = (f fnm, f dnm) - - cvt (FP_Cast from to m) = case checkRM (m `lookup` consts) of - Nothing -> cast $ \[a] -> parens (text (show to)) <+> rnd a - Just (Left msg) -> die msg - Just (Right msg) -> tbd msg - where -- if we're converting from float to some integral like; first use rint/rintf to do the internal conversion and then cast. - rnd a - | (isFloat from || isDouble from) && (isBounded to || isUnbounded to) - = let f = if isFloat from then "rintf" else "rint" - in text f P.<> parens a - | True - = a - - cvt (FP_Reinterpret f t) = case (f, t) of - (KBounded False 32, KFloat) -> cast $ cpy "sizeof(SFloat)" - (KBounded False 64, KDouble) -> cast $ cpy "sizeof(SDouble)" - (KFloat, KBounded False 32) -> cast $ cpy "sizeof(SWord32)" - (KDouble, KBounded False 64) -> cast $ cpy "sizeof(SWord64)" - _ -> die $ "Reinterpretation from : " ++ show f ++ " to " ++ show t - where cpy sz = \[a] -> let alhs = text "&" P.<> var - arhs = text "&" P.<> a - in text "memcpy" P.<> parens (fsep (punctuate comma [alhs, arhs, text sz])) - cvt FP_Abs = dispatch $ named "fabsf" "fabs" $ \nm _ [a] -> text nm P.<> parens a - cvt FP_Neg = dispatch $ same $ \_ [a] -> text "-" P.<> a - cvt FP_Add = dispatch $ same $ \_ [a, b] -> a <+> text "+" <+> b - cvt FP_Sub = dispatch $ same $ \_ [a, b] -> a <+> text "-" <+> b - cvt FP_Mul = dispatch $ same $ \_ [a, b] -> a <+> text "*" <+> b - cvt FP_Div = dispatch $ same $ \_ [a, b] -> a <+> text "/" <+> b - cvt FP_FMA = dispatch $ named "fmaf" "fma" $ \nm _ [a, b, c] -> text nm P.<> parens (fsep (punctuate comma [a, b, c])) - cvt FP_Sqrt = dispatch $ named "sqrtf" "sqrt" $ \nm _ [a] -> text nm P.<> parens a - cvt FP_Rem = dispatch $ named "fmodf" "fmod" $ \nm _ [a, b] -> text nm P.<> parens (fsep (punctuate comma [a, b])) - cvt FP_RoundToIntegral = dispatch $ named "rintf" "rint" $ \nm _ [a] -> text nm P.<> parens a - cvt FP_Min = dispatch $ named "fminf" "fmin" $ \nm k [a, b] -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) - cvt FP_Max = dispatch $ named "fmaxf" "fmax" $ \nm k [a, b] -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) - cvt FP_ObjEqual = let mkIte x y z = x <+> text "?" <+> y <+> text ":" <+> z - chkNaN x = text "isnan" P.<> parens x - signbit x = text "signbit" P.<> parens x - eq x y = parens (x <+> text "==" <+> y) - eqZero x = eq x (text "0") - negZero x = parens (signbit x <+> text "&&" <+> eqZero x) - in dispatch $ same $ \_ [a, b] -> mkIte (chkNaN a) (chkNaN b) (mkIte (negZero a) (negZero b) (mkIte (negZero b) (negZero a) (eq a b))) - cvt FP_IsNormal = dispatch $ same $ \_ [a] -> text "isnormal" P.<> parens a - cvt FP_IsSubnormal = dispatch $ same $ \_ [a] -> text "FP_SUBNORMAL == fpclassify" P.<> parens a - cvt FP_IsZero = dispatch $ same $ \_ [a] -> text "FP_ZERO == fpclassify" P.<> parens a - cvt FP_IsInfinite = dispatch $ same $ \_ [a] -> text "isinf" P.<> parens a - cvt FP_IsNaN = dispatch $ same $ \_ [a] -> text "isnan" P.<> parens a - cvt FP_IsNegative = dispatch $ same $ \_ [a] -> text "!isnan" P.<> parens a <+> text "&&" <+> text "signbit" P.<> parens a - cvt FP_IsPositive = dispatch $ same $ \_ [a] -> text "!isnan" P.<> parens a <+> text "&&" <+> text "!signbit" P.<> parens a - - -- grab the rounding-mode, if present, and make sure it's RoundNearestTiesToEven. Otherwise skip. - fpArgs = case as of - [] -> [] - ((m, _):args) - | isRoundingMode m -> case checkRM (m `lookup` consts) of - Nothing -> args - Just (Left msg) -> die msg - Just (Right msg) -> tbd msg - | True -> as - - -- Check that the RM is RoundNearestTiesToEven. - -- If we start supporting other rounding-modes, this would be the point where we'd insert the rounding-mode set/reset code - -- instead of merely returning OK or not - checkRM (Just cv@(CV k v)) - | k == kRoundingMode = case v of - CADT ("RoundNearestTiesToEven", []) -> Nothing - CADT (s, []) -> Just (Right $ "handleIEEE: Unsupported rounding-mode: " ++ show s ++ " for: " ++ show w) - _ -> Just (Left $ "handleIEEE: Unexpected value for rounding-mode: " ++ show cv ++ " for: " ++ show w) - checkRM (Just cv) = Just (Left $ "handleIEEE: Expected rounding-mode, but got: " ++ show cv ++ " for: " ++ show w) - checkRM Nothing = Just (Right $ "handleIEEE: Non-constant rounding-mode for: " ++ show w) - - pickOp _ [] = die $ "Cannot determine float/double kind for op: " ++ show w - pickOp (fOp, dOp) args@((a,_):_) = case kindOf a of - KFloat -> fOp KFloat (map snd args) - KDouble -> dOp KDouble (map snd args) - k -> die $ "handleIEEE: Expected double/float args, but got: " ++ show k ++ " for: " ++ show w - - dispatch (fOp, dOp) = pickOp (fOp, dOp) fpArgs - cast f = f (map snd fpArgs) - - -- In SMT-Lib, fpMin/fpMax is underspecified when given +0/-0 as the two arguments. (In any order.) - -- In C, the second argument is returned. (I think, might depend on the architecture, optimizations etc.). - -- We'll translate it so that we deterministically return +0. - -- There's really no good choice here. - wrapMinMax k a b s = parens cond <+> text "?" <+> fzero <+> text ":" <+> s - where fzero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 - cond = parens (text "FP_ZERO == fpclassify" P.<> parens a) -- a is zero - <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" P.<> parens b) -- b is zero - <+> text "&&" <+> parens (text "signbit" P.<> parens a <+> text "!=" <+> text "signbit" P.<> parens b) -- a and b differ in sign - -ppExpr :: CgConfig -> [(SV, CV)] -> SBVExpr -> Doc -> (Doc, Doc) -> Doc -ppExpr cfg consts (SBVApp op opArgs) lhs (typ, var) - | doNotAssign op - = typ <+> var P.<> semi <+> rhs - | True - = lhs <+> text "=" <+> rhs - where doNotAssign (IEEEFP FP_Reinterpret{}) = True -- generates a memcpy instead; no simple assignment - doNotAssign _ = False -- generates simple assignment - - rhs = p op (map (showSV cfg consts) opArgs) - - rtc = cgRTC cfg - - cBinOps = [ (Plus, "+"), (Times, "*"), (Minus, "-") - , (Equal False, "==") -- no strong equality! - , (NotEqual, "!="), (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=") - , (And, "&"), (Or, "|"), (XOr, "^") - ] - - -- see if we can find a constant shift; makes the output way more readable - getShiftAmnt def [_, sv] = case sv `lookup` consts of - Just (CV _ (CInteger i)) -> integer i - _ -> def - getShiftAmnt def _ = def - - hd _ (h:_) = h - hd w [] = error $ "Data.SBV.C.ppExpr: Impossible happened: " ++ w ++ ", received empty list!" - - p :: Op -> [Doc] -> Doc - p ReadArray{} _ = tbd "User specified arrays (ReadArray)" - p WriteArray{} _ = tbd "User specified arrays (WriteArray)" - p (Label s) [a] = a <+> text "/*" <+> text s <+> text "*/" - p (IEEEFP w) as = handleIEEE w consts (zip opArgs as) var - p (PseudoBoolean pb) as = handlePB pb as - p (OverflowOp o) _ = tbd $ "Overflow operations" ++ show o - p (KindCast _ to) [a] = parens (text (show to)) <+> a - p (Uninterpreted s) [] = text "/* Uninterpreted constant */" <+> text (T.unpack s) - p (Uninterpreted s) as = text "/* Uninterpreted function */" <+> text (T.unpack s) P.<> parens (fsep (punctuate comma as)) - p (Extract i j) [a] = extract i j (hd "Extract" opArgs) a - p Join [a, b] = join (let (s1 : s2 : _) = opArgs in (s1, s2, a, b)) - p (Rol i) [a] = rotate True i a (hd "Rol" opArgs) - p (Ror i) [a] = rotate False i a (hd "Ror" opArgs) - p Shl [a, i] = shift True (getShiftAmnt i opArgs) a -- The order of i/a being reversed here is - p Shr [a, i] = shift False (getShiftAmnt i opArgs) a -- intentional and historical (from the days when Shl/Shr had a constant parameter.) - p Not [a] = case kindOf (hd "Not" opArgs) of - -- be careful about booleans, bitwise complement is not correct for them! - KBool -> text "!" P.<> a - _ -> text "~" P.<> a - p Ite [a, b, c] = a <+> text "?" <+> b <+> text ":" <+> c - p (LkUp (t, k, _, 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 (showSV cfg consts) [ind, def] - - lkUp = text "table" P.<> int t P.<> brackets (showSV cfg consts ind) - cndLkUp cnd = cnd <+> text "?" <+> defVal <+> text ":" <+> lkUp - - checkLeft = index <+> text "< 0" - checkRight = index <+> text ">=" <+> int len - checkBoth = parens (checkLeft <+> text "||" <+> checkRight) - - canOverflow True sz = (2::Integer)^(sz-1)-1 >= fromIntegral len - canOverflow False sz = (2::Integer)^sz -1 >= fromIntegral len - - (needsCheckL, needsCheckR) = case k of - KVar{} -> die $ "array index with variable: " ++ show k - KBool -> (False, canOverflow False (1::Int)) - KBounded sg sz -> (sg, canOverflow sg sz) - KReal -> die "array index with real value" - KFloat -> die "array index with float value" - KDouble -> die "array index with double value" - KFP{} -> die "array index with arbitrary float value" - KRational -> die "array index with rational value" - KString -> die "array index with string value" - KChar -> die "array index with character value" - KUnbounded -> case cgInteger cfg of - Nothing -> (True, True) -- won't matter, it'll be rejected later - Just i -> (True, canOverflow True i) - KList s -> die $ "List sort " ++ show s - KSet s -> die $ "Set sort " ++ show s - KTuple s -> die $ "Tuple sort " ++ show s - KArray k1 k2 -> die $ "Array sort " ++ show (k1, k2) - KApp s _ -> die $ "ADT app: " ++ s - KADT s _ _ -> die $ "ADT: " ++ s - - -- Div/Rem should be careful on 0, in the SBV world x `div` 0 is 0, x `rem` 0 is x - -- NB: Quot is supposed to truncate toward 0; Not clear to me if C guarantees this behavior. - -- Brief googling suggests C99 does indeed truncate toward 0, but other C compilers might differ. - p Quot [a, b] = let k = kindOf (hd "Quot" opArgs) - z = mkConst cfg $ mkConstCV k (0::Integer) - in protectDiv0 k "/" z a b - p Rem [a, b] = protectDiv0 (kindOf (hd "Rem" opArgs)) "%" a a b - p UNeg [a] = parens (text "-" <+> a) - p Abs [a] = let f KFloat = text "fabsf" P.<> parens a - f KDouble = text "fabs" P.<> parens a - f (KBounded False _) = text "/* unsigned, skipping call to abs */" <+> a - f (KBounded True 32) = text "labs" P.<> parens a - f (KBounded True 64) = text "llabs" P.<> parens a - f KUnbounded = case cgInteger cfg of - Nothing -> f $ KBounded True 32 -- won't matter, it'll be rejected later - Just i -> f $ KBounded True i - f KReal = case cgReal cfg of - Nothing -> f KDouble -- won't matter, it'll be rejected later - Just CgFloat -> f KFloat - Just CgDouble -> f KDouble - Just CgLongDouble -> text "fabsl" P.<> parens a - f _ = text "abs" P.<> parens a - in f (kindOf (hd "Abs" opArgs)) - -- for And/Or, translate to boolean versions if on boolean kind - p And [a, b] | kindOf (hd "And" opArgs) == KBool = a <+> text "&&" <+> b - p Or [a, b] | kindOf (hd "Or" opArgs) == KBool = a <+> text "||" <+> b - p o [a, b] - | Just co <- lookup o cBinOps - = a <+> text co <+> b - - p Implies [a, b] | kindOf (hd "Implies" opArgs) == KBool = parens (text "!" P.<> a <+> text "||" <+> b) - - p NotEqual xs = mkDistinct xs - p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args - - -- generate a pairwise inequality check - mkDistinct args = fsep $ andAll $ walk args - where walk [] = [] - walk (e:es) = map (pair e) es ++ walk es - - pair e1 e2 = parens (e1 <+> text "!=" <+> e2) - - -- like punctuate, but more spacing - andAll [] = [] - andAll (d:ds) = go d ds - where go d' [] = [d'] - go d' (e:es) = (d' <+> text "&&") : go e es - - -- Div0 needs to protect, but only when the arguments are not float/double. (Div by 0 for those are well defined to be Inf/NaN etc.) - protectDiv0 k divOp def a b = case k of - KFloat -> res - KDouble -> res - _ -> wrap - where res = a <+> text divOp <+> b - wrap = parens (b <+> text "== 0") <+> text "?" <+> def <+> text ":" <+> parens res - - shift toLeft i a = a <+> text cop <+> i - where cop | toLeft = "<<" - | True = ">>" - - rotate toLeft i a s - | i < 0 = rotate (not toLeft) (-i) a s - | i == 0 = a - | True = case kindOf s of - KBounded True _ -> tbd $ "Rotation of signed quantities: " ++ show (toLeft, i, s) - KBounded False sz | i >= sz -> rotate toLeft (i `mod` sz) a s - KBounded False sz -> parens (a <+> text cop <+> int i) - <+> text "|" - <+> parens (a <+> text cop' <+> int (sz - i)) - KUnbounded -> shift toLeft (int i) a -- For SInteger, rotate is the same as shift in Haskell - _ -> tbd $ "Rotation for unbounded quantity: " ++ show (toLeft, i, s) - where (cop, cop') | toLeft = ("<<", ">>") - | True = (">>", "<<") - - -- TBD: below we only support the values for extract that are "easy" to implement. These should cover - -- almost all instances actually generated by SBV, however. - extract hi lo i a -- Isolate the bit-extraction case - | hi == lo, KBounded _ sz <- kindOf i, hi < sz, hi >= 0 - = if hi == 0 - then text "(SBool)" <+> parens (a <+> text "& 1") - else text "(SBool)" <+> parens (parens (a <+> text ">>" <+> int hi) <+> text "& 1") - extract hi lo i a - | srcSize `notElem` [64, 32, 16] - = bad "Unsupported source size" - | (hi + 1) `mod` 8 /= 0 || lo `mod` 8 /= 0 - = bad "Unsupported non-byte-aligned extraction" - | tgtSize < 8 || tgtSize `mod` 8 /= 0 - = bad "Unsupported target size" - | True - = text cast <+> shifted - where bad why = tbd $ "extract with " ++ show (hi, lo, k, i) ++ " (Reason: " ++ why ++ ".)" - - k = kindOf i - srcSize = intSizeOf k - tgtSize = hi - lo + 1 - signChange = srcSize == tgtSize - - cast - | signChange && hasSign k = "(SWord" ++ show srcSize ++ ")" - | signChange = "(SInt" ++ show srcSize ++ ")" - | True = "(SWord" ++ show tgtSize ++ ")" - - shifted - | lo == 0 = a - | True = parens (a <+> text ">>" <+> int lo) - - -- TBD: ditto here for join, just like extract above - join (i, j, a, b) = case (kindOf i, kindOf j) of - (KBounded False 8, KBounded False 8) -> parens (parens (text "(SWord16)" <+> a) <+> text "<< 8") <+> text "|" <+> parens (text "(SWord16)" <+> b) - (KBounded False 16, KBounded False 16) -> parens (parens (text "(SWord32)" <+> a) <+> text "<< 16") <+> text "|" <+> parens (text "(SWord32)" <+> b) - (KBounded False 32, KBounded False 32) -> parens (parens (text "(SWord64)" <+> a) <+> text "<< 32") <+> text "|" <+> parens (text "(SWord64)" <+> b) - (k1, k2) -> tbd $ "join with " ++ show ((k1, i), (k2, j)) - --- 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 = replicate (l - length s) ' ' ++ s - --- | Merge a bunch of bundles to generate code for a library. For the final --- config, we simply return the first config we receive, or the default if none. -mergeToLib :: String -> [(CgConfig, CgPgmBundle)] -> (CgConfig, CgPgmBundle) -mergeToLib libName cfgBundles - | length nubKinds /= 1 - = error $ "Cannot merge programs with differing SInteger/SReal mappings. Received the following kinds:\n" - ++ unlines (map show nubKinds) - | True - = (finalCfg, CgPgmBundle bundleKind $ sources ++ libHeader : [libDriver | anyDriver] ++ [libMake | anyMake]) - where bundles = map snd cfgBundles - kinds = [k | CgPgmBundle k _ <- bundles] - nubKinds = nub kinds - bundleKind = case nubKinds of - bk:_ -> bk - [] -> error "Data.SBV.C: Impossible happened: mergeLibs: kinds ended up being empty!" - files = concat [fs | CgPgmBundle _ fs <- bundles] - sigs = concat [ss | (_, (CgHeader ss, _)) <- files] - anyMake = not (null [() | (_, (CgMakefile{}, _)) <- files]) - drivers = [ds | (_, (CgDriver, ds)) <- files] - anyDriver = not (null drivers) - mkFlags = nub (concat [xs | (_, (CgMakefile xs, _)) <- files]) - sources = [(f, (CgSource, [pre, libHInclude, post])) | (f, (CgSource, [pre, _, post])) <- files] - sourceNms = map fst sources - libHeader = (libName ++ ".h", (CgHeader sigs, [genHeader bundleKind libName sigs empty])) - libHInclude = text "#include" <+> text (show (libName ++ ".h")) - libMake = ("Makefile", (CgMakefile mkFlags, [genLibMake anyDriver libName sourceNms mkFlags])) - libDriver = (libName ++ "_driver.c", (CgDriver, mergeDrivers libName libHInclude (zip (map takeBaseName sourceNms) drivers))) - finalCfg = case cfgBundles of - [] -> defaultCgConfig - ((c, _):_) -> c - --- | Create a Makefile for the library -genLibMake :: Bool -> String -> [String] -> [String] -> Doc -genLibMake ifdr libName fs ldFlags = foldr1 ($$) [l | (True, l) <- lns] - where ifld = not (null ldFlags) - ld | ifld = text "${LDFLAGS}" - | True = empty - lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") - , (True, text "") - , (True, text "# include any user-defined .mk file in the current directory.") - , (True, text "-include *.mk") - , (True, text "") - , (True, text "CC?=gcc") - , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") - , (ifld, text "LDFLAGS?=" P.<> text (unwords ldFlags)) - , (True, text "AR?=ar") - , (True, text "ARFLAGS?=cr") - , (True, text "") - , (not ifdr, text ("all: " ++ liba)) - , (ifdr, text ("all: " ++ unwords [liba, libd])) - , (True, text "") - , (True, text liba P.<> text (": " ++ unwords os)) - , (True, text "\t${AR} ${ARFLAGS} $@ $^") - , (True, text "") - , (ifdr, text libd P.<> text (": " ++ unwords [libd ++ ".c", libh])) - , (ifdr, text ("\t${CC} ${CCFLAGS} $< -o $@ " ++ liba) <+> ld) - , (ifdr, text "") - , (True, vcat (zipWith mkObj os fs)) - , (True, text "clean:") - , (True, text "\trm -f *.o") - , (True, text "") - , (True, text "veryclean: clean") - , (not ifdr, text "\trm -f" <+> text liba) - , (ifdr, text "\trm -f" <+> text (unwords [liba, libd])) - , (True, text "") - ] - nm = text libName - liba = libName ++ ".a" - libh = libName ++ ".h" - libd = libName ++ "_driver" - os = map (`replaceExtension` ".o") fs - mkObj o f = text o P.<> 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 P.<> text ". */" - $$ text "/* Automatically generated by SBV. Edit as you see fit! */" - $$ text "" - $$ text "#include " - $$ 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 = replicate (length tag) '=' - psep = "printf(\"" ++ lsep ++ "\\n\");" - --- Does this operation with this result kind require an LD flag? -getLDFlag :: (Op, Kind) -> [String] -getLDFlag (o, k) = flag o - where math = ["-lm"] - - flag (IEEEFP FP_Cast{}) = math - flag (IEEEFP fop) | fop `elem` requiresMath = math - flag Abs | k `elem` [KFloat, KDouble, KReal] = math - flag _ = [] - - requiresMath = [ FP_Abs - , FP_FMA - , FP_Sqrt - , FP_Rem - , FP_Min - , FP_Max - , FP_RoundToIntegral - , FP_ObjEqual - , FP_IsSubnormal - , FP_IsInfinite - , FP_IsNaN - , FP_IsNegative - , FP_IsPositive - , FP_IsNormal - , FP_IsZero - ] - -{- HLint ignore module "Redundant lambda" -} +-- Default SBV-to-C compiler. This module deliberately remains a thin facade +-- so the implementation can coexist with the compatibility backend in +-- "Data.SBV.Compilers.C.Legacy". +-- +-- == Execution model and supported values +-- +-- The compiler evaluates a finite symbolic expression graph; it does not +-- invoke an SMT solver at run time. Generated standalone programs and static +-- libraries support: +-- +-- * Booleans and signed or unsigned bit-vectors of any positive width. +-- * Exact GMP-backed integers, rational-valued reals, and rationals. The +-- historical bounded integer and native floating-point real mappings remain +-- available through @cgIntegerSize@ and @cgSRealType@. +-- * Native and arbitrary-format IEEE floating point. Arbitrary formats and +-- directed native rounding use LibBF. +-- * Characters, strings, lists, finite or cofinite sets, tuples, and concrete +-- algebraic datatypes, including recursive datatypes. +-- * Finite lookup tables and persistent arrays created from constants, +-- writes, retained lambdas, or caller-provided lookup callbacks. Direct +-- array equality enumerates supported finite key domains, subject to +-- @cgArrayEqualityLimit@ (256 keys by default). +-- * First-order @smtFunction@ definitions and SBV's firstified +-- @smtHOFunction@ specializations, including recursive and mutually +-- recursive groups, closed nested array lambdas, explicit closure +-- environments, hard constraints as executable preconditions, scalar and +-- grouped results, and multi-function static libraries. +-- * Regular-expression membership and language equality, compiled using bounded +-- automata without additional dependencies. Generation budgets are configurable; +-- successfully generated matchers accept strings of arbitrary length. +-- +-- Numeric lowering includes exact-width arithmetic, comparisons, shifts, +-- rotations, joins and extractions, overflow predicates, conversions, +-- divisibility, and integer exponentiation. Mapped reals additionally support +-- the C @libm@ transcendental operations. Exact rational reals reject those +-- operations because their results cannot in general be represented by GMP +-- rationals; select @cgSRealType@ when an approximation is acceptable. +-- +-- == Deliberate boundaries +-- +-- Quantifiers, special solver relations, uninterpreted sorts, and soft +-- constraints are rejected. General extensional array equality and arrays nested +-- in compared values remain unsupported. Array lambdas must be closed; capturing +-- outer symbolic values is rejected during generation. The C backend compiles +-- higher-order uses after SBV has firstified them; it does not expose symbolic +-- functions as runtime C values. +-- +-- Import "Data.SBV.Compilers.C.Legacy" to retain the previous compiler while +-- migrating code that encounters one of these boundaries. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C + ( compileToC + , compileToCLib + , compileToC' + , compileToCLib' + ) where + +import Data.SBV.Compilers.C.Backend (compileToC, compileToC', compileToCLib, compileToCLib') diff --git a/Data/SBV/Compilers/C/ADT.hs b/Data/SBV/Compilers/C/ADT.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/ADT.hs @@ -0,0 +1,1083 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.ADT +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Algebraic-data-type lowering for the SBV-to-C compiler. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.ADT + ( adtKinds + , resolveADTReferences + , adtCType + , adtForwardTypeDecls + , adtTypeDecls + , adtTypeDeclsFor + , adtDeclarationDependencies + , adtEqualityRuntimeDecls + , adtEqualityRuntime + , adtOwnershipTypePrototypes + , adtOwnershipTypeDecls + , adtOwnedCloneName + , adtOwnedReleaseName + , adtDriverInit + , adtValue + , adtConst + , adtExpr + , adtUsesExact + , adtNeedsOwnership + , adtIsRecursive + , adtDriverValue + , adtPrint + , adtPrintHelpers + , adtConstructors + ) where + +import qualified Data.Graph as DG +import Data.List (find, nub) +import qualified Data.Set as Set +import qualified Data.Text as T + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Array (arrayStoredLoad, arrayStoredValue) +import Data.SBV.Compilers.C.BV (isWideBV, wideBVEqual) +import Data.SBV.Compilers.C.FP (arbitraryFPEqual, arbitraryFPObjectEqual, nativeFPObjectEqual) +import Data.SBV.Compilers.C.GMP (gmpDriverAssign, gmpFunctionName, gmpOutputType, isExactGMPKind) +import Data.SBV.Compilers.C.List ( listClone + , listDriverClear + , listDriverInit + , listEqual + , listNeedsDriverInit + , listRelease + ) +import Data.SBV.Compilers.C.Lowering (CLowering(..), expressionLowering) +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute, cCommentText) +import Data.SBV.Compilers.C.Set ( setClone + , setDriverClear + , setDriverInit + , setEqual + , setNeedsDriverInit + , setRelease + ) +import Data.SBV.Compilers.C.Tuple ( tupleOwnedInitName + , tupleOwnedReleaseName + , tupleOwnedSetName + , tupleNeedsOwnership + ) +import Data.SBV.Compilers.C.Types (isConcreteADT, adtCType, elementCType, tupleFieldName, adtOwnedInitName, adtOwnedSetName, adtOwnedCloneName, adtOwnedReleaseName, adtEqualName) +import Data.SBV.Compilers.C.Value (byValueEqual, managedValueClone, managedValueRelease, valueNeedsOwnership) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds, substituteADTVars) +import Data.SBV.Core.Symbolic (ADTOp(..)) + +-- | A concrete ADT field and whether its declaration is a recursive pointer +-- edge within the same strongly connected component. +data ADTField = ADTField Kind Bool + +-- | Return the used concrete, non-built-in ADT kinds in dependency order. +-- The first set supplies every registered ADT template and the second supplies +-- the kinds actually reached by the program. References through 'KApp' are +-- accepted for both acyclic and recursive declarations. Recursive components +-- are kept adjacent so their C layouts can use forward-declared pointer edges. +adtKinds :: Set.Set Kind -> Set.Set Kind -> [Kind] +adtKinds registeredKinds usedKinds = concatMap orderedComponent (DG.stronglyConnComp dependencyNodes) + where registeredADTs = nub (filter isConcreteADT (Set.toAscList registeredKinds)) + usedADTs = nub (filter isConcreteADT (Set.toAscList usedKinds)) + adts = closeRegistry usedADTs + + dependencyNodes = [(kind, adtKey kind, dependencies kind) | kind <- adts] + + closeRegistry current + | length expanded == length current = current + | True = closeRegistry expanded + where referenced = [ application + | kind <- current + , application@KApp{} <- referenceApplications kind + ] + expanded = nub (current ++ map (resolveADTReferences registeredADTs) referenced) + + referenceApplications (KADT typeName parameters constructors) = + [ application + | (_, fields) <- constructors + , field <- fields + , application@KApp{} <- expandKinds (substituteADTVars typeName parameters field) + ] + referenceApplications kind = error $ "SBV->C: Expected an ADT kind, received " ++ show kind + + dependencies kind = + [ (referencedName, referencedArguments) + | KApp referencedName referencedArguments <- referenceApplications kind + ] + + orderedComponent (DG.AcyclicSCC kind) = [kind] + orderedComponent (DG.CyclicSCC recursiveKinds) = recursiveKinds + + adtKey (KADT typeName parameters _) = (typeName, map snd parameters) + adtKey kind = error $ "SBV->C: Expected an ADT kind, received " ++ show kind + +-- | Emit forward declarations that permit collection descriptors to refer to +-- ADT element types before their tagged-union layouts are complete. +adtForwardTypeDecls :: [Kind] -> Doc +adtForwardTypeDecls [] = empty +adtForwardTypeDecls adts = text . unlines $ concatMap forwardDeclaration adts + where forwardDeclaration kind = + [ "#ifndef " ++ adtForwardGuard kind + , "#define " ++ adtForwardGuard kind + , "typedef struct " ++ adtCType kind ++ " " ++ adtCType kind ++ ";" + , "#endif" + , "" + ] + +-- | Emit public tagged-union declarations for all ADT kinds used by a program. +adtTypeDecls :: CgConfig -> [Kind] -> Doc +adtTypeDecls cfg adts = adtTypeDeclsFor cfg adts adts + +-- | Emit selected public tagged-union declarations using the complete ADT +-- registry to resolve constructor fields. This supports dependency-ordered +-- interleaving with tuple declarations. +adtTypeDeclsFor :: CgConfig -> [Kind] -> [Kind] -> Doc +adtTypeDeclsFor _ _ [] = empty +adtTypeDeclsFor _ registry declarations = text . unlines $ + [ "/* Algebraic data types. Recursive fields form finite, acyclic pointer graphs. */" + , "/* Inputs borrow these graphs; owned outputs and returns must be released. */" + , cUnusedAttribute + , "" + ] + ++ concatMap forwardDeclaration declarations + ++ concatMap declaration declarations + ++ dereferenceDeclarations + where forwardDeclaration kind = + [ "#ifndef " ++ adtForwardGuard kind + , "#define " ++ adtForwardGuard kind + , "typedef struct " ++ adtCType kind ++ " " ++ adtCType kind ++ ";" + , "#endif" + , "" + ] + + declaration kind = + [ "#ifndef " ++ adtGuard kind + , "#define " ++ adtGuard kind + , "typedef enum {" + ] + ++ zipWith (enumEntry kind) [1 :: Int ..] constructors + ++ [ "} " ++ adtTagCType kind ++ ";" + , "struct " ++ adtCType kind ++ " {" + , " " ++ adtTagCType kind ++ " tag;" + ] + ++ payloadDeclaration kind + ++ [ "};" + , "#endif" + , "" + ] + where constructors = adtConstructorFields registry kind + + enumEntry kind index _ = " " ++ adtTagName kind index ++ " = " ++ show (index - 1) + ++ if index == length (adtConstructorFields registry kind) then "" else "," + + payloadDeclaration kind + | null populated = [] + | True = [" union {"] ++ concatMap constructorPayload populated ++ [" } payload;"] + where populated = [ (index, fields) + | (index, (_, fields)) <- zip [1 :: Int ..] (adtConstructorFields registry kind) + , not (null fields) + ] + constructorPayload (constructorIndex, fields) = + [" struct {"] + ++ zipWith fieldDeclaration [1 :: Int ..] fields + ++ [" } " ++ adtConstructorMember constructorIndex ++ ";"] + fieldDeclaration fieldIndex field = " " ++ adtFieldCType field ++ " " ++ adtFieldName fieldIndex ++ ";" + + recursiveKinds = filter (adtIsRecursive registry) declarations + + dereferenceDeclarations = concatMap dereferenceDeclaration recursiveKinds + + dereferenceDeclaration kind = + [ "#ifndef " ++ dereferenceGuard kind + , "#define " ++ dereferenceGuard kind + , "static inline SBV_CGEN_UNUSED " ++ adtCType kind ++ " " ++ adtDereferenceName kind + ++ "(const " ++ adtCType kind ++ " *value)" + , "{" + , " if (value == NULL) abort();" + , " return *value;" + , "}" + , "#endif" + , "" + ] + +-- | Return complete by-value tuple and ADT dependencies of one ADT layout. +-- Recursive pointer fields need only a forward declaration and are excluded. +adtDeclarationDependencies :: [Kind] -> Kind -> [Kind] +adtDeclarationDependencies adts kind = nub + [ fieldKind + | (_, fields) <- adtConstructorFields adts kind + , ADTField fieldKind recursive <- fields + , not recursive + , isTuple fieldKind || isConcreteADT fieldKind + ] + +-- | Emit forward declarations for the ADT equality helpers used by collection +-- element comparisons. +adtEqualityRuntimeDecls :: [Kind] -> Doc +adtEqualityRuntimeDecls [] = empty +adtEqualityRuntimeDecls adts = text . unlines $ concatMap prototypes [False, True] + where prototypes strong = + [ "static SBV_CGEN_UNUSED bool " ++ adtEqualName strong kind + ++ "(" ++ adtCType kind ++ " left, " ++ adtCType kind ++ " right);" + | kind <- adts + ] ++ [""] + +-- | Emit private structural-equality helpers for concrete ADTs. These +-- definitions follow the collection runtimes so managed fields can reuse the +-- same list and set equality semantics as top-level expressions. +adtEqualityRuntime :: CgConfig -> [Kind] -> Doc +adtEqualityRuntime cfg adts + | null adts = empty + | True = text . unlines $ concatMap definitions [False, True] + where definitions strong = concatMap (definition strong) adts + + definition strong kind = + [ "static SBV_CGEN_UNUSED bool " ++ adtEqualName strong kind + ++ "(" ++ adtCType kind ++ " left, " ++ adtCType kind ++ " right)" + , "{" + , " if (left.tag != right.tag) return false;" + , " switch (left.tag) {" + ] + ++ concatMap (equalityCase strong kind) (zip [1 :: Int ..] (adtConstructorFields adts kind)) + ++ [ " default: abort();" + , " }" + , "}" + , "" + ] + + equalityCase strong kind (constructorIndex, (_, fields)) = + [" case " ++ adtTagName kind constructorIndex ++ ":"] + ++ concatMap (nullChecks constructorIndex) (zip [1 :: Int ..] fields) + ++ [" return " ++ render (andExpressions comparisons) ++ ";"] + where comparisons = zipWith (compareField strong constructorIndex) [1 :: Int ..] fields + + nullChecks constructorIndex (fieldIndex, ADTField _ True) = + [ " if (" ++ render (adtField (text "left") constructorIndex fieldIndex) ++ " == NULL" + ++ " || " ++ render (adtField (text "right") constructorIndex fieldIndex) ++ " == NULL) abort();" + ] + nullChecks _ _ = [] + + compareField strong constructorIndex fieldIndex (ADTField fieldKind recursive) + | recursive = text (adtEqualName strong fieldKind) + P.<> parens (fsep (punctuate comma [deref "left", deref "right"])) + | True = adtFieldEqual cfg adts strong fieldKind + (adtField (text "left") constructorIndex fieldIndex) + (adtField (text "right") constructorIndex fieldIndex) + where deref side = text "*" P.<> parens (adtField (text side) constructorIndex fieldIndex) + +-- | Emit forward declarations for the uniform ADT ownership helpers. These +-- precede tuple helper definitions so tuples and ADTs can contain one another +-- without imposing an ownership-definition order. +adtOwnershipTypePrototypes :: [Kind] -> Doc +adtOwnershipTypePrototypes [] = empty +adtOwnershipTypePrototypes adts = text . unlines $ concatMap prototypes adts + where prototypes kind = + [ "static inline SBV_CGEN_UNUSED void " ++ adtOwnedInitName kind + ++ "(" ++ adtCType kind ++ " *value, " ++ adtTagCType kind ++ " tag);" + , "static inline SBV_CGEN_UNUSED void " ++ adtOwnedReleaseName kind + ++ "(" ++ adtCType kind ++ " *value);" + , "static inline SBV_CGEN_UNUSED void " ++ adtOwnedSetName kind + ++ "(" ++ adtCType kind ++ " *target, " ++ adtCType kind ++ " source);" + , "static inline SBV_CGEN_UNUSED " ++ adtCType kind ++ " " ++ adtOwnedCloneName kind + ++ "(" ++ adtCType kind ++ " source);" + , "" + ] + +-- | Emit public ownership-helper definitions for concrete ADTs. Inputs borrow +-- their field storage. Cloned values own all managed fields of the active +-- constructor and must be released with 'adtOwnedReleaseName'; by-value ADTs +-- use the same uniform protocol so collections need no representation-specific +-- branch. +adtOwnershipTypeDecls :: CgConfig -> [Kind] -> Doc +adtOwnershipTypeDecls cfg adts + | null adts = empty + | True = text . unlines $ concatMap declaration adts + where declaration kind = + [ "#ifndef " ++ ownershipGuard + , "#define " ++ ownershipGuard + , "/* Deep-ownership helpers for " ++ adtCType kind ++ ". */" + , "/* Owned values have unique ownership; clone before copying and release every owner. */" + , initSignature + , "{" + , " if (value == NULL) abort();" + , " memset(value, 0, sizeof *value);" + , " value->tag = tag;" + , " switch (tag) {" + ] + ++ concatMap (constructorCase initializeField kind) indexedConstructors + ++ [ " default: abort();" + , " }" + , "}" + , "" + , releaseSignature + , "{" + , " if (value == NULL) return;" + , " switch (value->tag) {" + ] + ++ concatMap (constructorCase releaseField kind) indexedConstructors + ++ [ " default: abort();" + , " }" + , " memset(value, 0, sizeof *value);" + , "}" + , "" + , setSignature + , "{" + , " if (target == NULL) abort();" + , " if (target->tag != source.tag) {" + , " " ++ adtOwnedReleaseName kind ++ "(target);" + , " " ++ adtOwnedInitName kind ++ "(target, source.tag);" + , " }" + , " switch (source.tag) {" + ] + ++ concatMap (constructorCase setField kind) indexedConstructors + ++ [ " default: abort();" + , " }" + , "}" + , "" + , cloneSignature + , "{" + , " " ++ adtCType kind ++ " result;" + , " " ++ adtOwnedInitName kind ++ "(&result, source.tag);" + , " " ++ adtOwnedSetName kind ++ "(&result, source);" + , " return result;" + , "}" + , "#endif" + , "" + ] + where ownershipGuard = adtCType kind ++ "_OWNERSHIP_DEFINED" + + initSignature = "static inline SBV_CGEN_UNUSED void " + ++ adtOwnedInitName kind + ++ "(" ++ adtCType kind ++ " *value, " ++ adtTagCType kind ++ " tag)" + + releaseSignature = "static inline SBV_CGEN_UNUSED void " + ++ adtOwnedReleaseName kind + ++ "(" ++ adtCType kind ++ " *value)" + + setSignature = "static inline SBV_CGEN_UNUSED void " + ++ adtOwnedSetName kind + ++ "(" ++ adtCType kind ++ " *target, " ++ adtCType kind ++ " source)" + + cloneSignature = "static inline SBV_CGEN_UNUSED " + ++ adtCType kind ++ " " ++ adtOwnedCloneName kind + ++ "(" ++ adtCType kind ++ " source)" + + indexedConstructors = zip [1 :: Int ..] (adtConstructorFields adts kind) + + constructorCase renderField kind (constructorIndex, (_, fields)) = + [ " case " ++ adtTagName kind constructorIndex ++ ": {" ] + ++ concat (zipWith (renderField constructorIndex) [1 :: Int ..] fields) + ++ [ " break;" + , " }" + ] + + initializeField constructorIndex fieldIndex (ADTField fieldKind recursive) + | recursive + = [] + | isExactGMPKind cfg fieldKind + = let access = ownedField "value->" constructorIndex fieldIndex + mutable = gmpOutputType fieldKind + local = "field" ++ show constructorIndex ++ "_" ++ show fieldIndex + in [ " " ++ mutable ++ " " ++ local ++ " = (" ++ mutable ++ ") malloc(sizeof(*" ++ local ++ "));" + , " if (" ++ local ++ " == NULL) abort();" + , " " ++ gmpFunctionName fieldKind "init" ++ "(" ++ local ++ ");" + , " " ++ access ++ " = " ++ local ++ ";" + ] + | fieldKind == KString + = [ " " ++ ownedField "value->" constructorIndex fieldIndex + ++ " = (SString) {NULL, 0, 0};" + ] + | isList fieldKind + = [ " " ++ ownedField "value->" constructorIndex fieldIndex + ++ " = (" ++ elementCType fieldKind ++ ") {NULL, 0};" + ] + | isSet fieldKind + = [ " " ++ ownedField "value->" constructorIndex fieldIndex + ++ " = (" ++ elementCType fieldKind ++ ") {NULL, 0, false};" + ] + | isArray fieldKind + = [" " ++ ownedField "value->" constructorIndex fieldIndex ++ " = NULL;"] + | tupleNeedsOwnership cfg fieldKind + = [ " " ++ tupleOwnedInitName fieldKind + ++ "(&" ++ ownedField "value->" constructorIndex fieldIndex ++ ");" + ] + | isConcreteADT fieldKind + , adtNeedsOwnership cfg adts fieldKind + = [ " " ++ adtOwnedInitName fieldKind + ++ "(&" ++ ownedField "value->" constructorIndex fieldIndex + ++ ", " ++ adtTagName fieldKind 1 ++ ");" + ] + | True + = [] + + setField constructorIndex fieldIndex (ADTField fieldKind recursive) + | recursive + = [ " " ++ adtCType fieldKind ++ " *" ++ copy + ++ " = (" ++ adtCType fieldKind ++ " *) malloc(sizeof *" ++ copy ++ ");" + , " if (" ++ copy ++ " == NULL || " ++ source ++ " == NULL) abort();" + , " *" ++ copy ++ " = " ++ adtOwnedCloneName fieldKind ++ "(*" ++ source ++ ");" + , " if (" ++ target ++ " != NULL) {" + , " " ++ adtOwnedReleaseName fieldKind ++ "(" ++ target ++ ");" + , " free(" ++ target ++ ");" + , " }" + , " " ++ target ++ " = " ++ copy ++ ";" + ] + | isExactGMPKind cfg fieldKind + = [ " " ++ gmpFunctionName fieldKind "set" + ++ "((" ++ gmpOutputType fieldKind ++ ") " ++ target ++ ", " ++ source ++ ");" + ] + | fieldKind == KString + = [ " const SString " ++ copy + ++ " = " ++ render (managedValueClone fieldKind (text source)) ++ ";" + , " " ++ render (managedValueRelease fieldKind (text ("&" ++ target))) + , " " ++ target ++ " = " ++ copy ++ ";" + ] + | isList fieldKind + = [ " const " ++ elementCType fieldKind ++ " " ++ copy + ++ " = " ++ render (listClone fieldKind (text source)) ++ ";" + , " " ++ render (listRelease fieldKind (text target)) + , " " ++ target ++ " = " ++ copy ++ ";" + ] + | isSet fieldKind + = [ " const " ++ elementCType fieldKind ++ " " ++ copy + ++ " = " ++ render (setClone fieldKind (text source)) ++ ";" + , " " ++ render (setRelease fieldKind (text target)) + , " " ++ target ++ " = " ++ copy ++ ";" + ] + | isArray fieldKind + = [ " " ++ elementCType fieldKind ++ " " ++ copy + ++ " = " ++ render (managedValueClone fieldKind (text source)) ++ ";" + , " " ++ render (managedValueRelease fieldKind (text ("&" ++ target))) + , " " ++ target ++ " = " ++ copy ++ ";" + ] + | tupleNeedsOwnership cfg fieldKind + = [" " ++ tupleOwnedSetName fieldKind ++ "(&" ++ target ++ ", " ++ source ++ ");"] + | isConcreteADT fieldKind + , adtNeedsOwnership cfg adts fieldKind + = [" " ++ adtOwnedSetName fieldKind ++ "(&" ++ target ++ ", " ++ source ++ ");"] + | True + = [" " ++ target ++ " = " ++ source ++ ";"] + where target = ownedField "target->" constructorIndex fieldIndex + source = ownedField "source." constructorIndex fieldIndex + copy = "copy" ++ show constructorIndex ++ "_" ++ show fieldIndex + + releaseField constructorIndex fieldIndex (ADTField fieldKind recursive) + | recursive + = [ " if (" ++ access ++ " != NULL) {" + , " " ++ adtOwnedReleaseName fieldKind ++ "(" ++ access ++ ");" + , " free(" ++ access ++ ");" + , " }" + ] + | isExactGMPKind cfg fieldKind + = [ " if (" ++ access ++ " != NULL) {" + , " " ++ gmpFunctionName fieldKind "clear" ++ "((" ++ gmpOutputType fieldKind ++ ") " ++ access ++ ");" + , " free((void *) " ++ access ++ ");" + , " }" + ] + | fieldKind == KString + = [" " ++ render (managedValueRelease fieldKind (text ("&" ++ access)))] + | isList fieldKind + = [" " ++ render (listRelease fieldKind (text access))] + | isSet fieldKind + = [" " ++ render (setRelease fieldKind (text access))] + | isArray fieldKind + = [" " ++ render (managedValueRelease fieldKind (text ("&" ++ access)))] + | tupleNeedsOwnership cfg fieldKind + = [" " ++ tupleOwnedReleaseName fieldKind ++ "(&" ++ access ++ ");"] + | isConcreteADT fieldKind && adtNeedsOwnership cfg adts fieldKind + = [" " ++ adtOwnedReleaseName fieldKind ++ "(&" ++ access ++ ");"] + | True + = [] + where access = ownedField "value->" constructorIndex fieldIndex + + ownedField root constructorIndex fieldIndex = root + ++ "payload." + ++ adtConstructorMember constructorIndex + ++ "." + ++ adtFieldName fieldIndex + +-- | Initialize a generated-driver ADT and populate its active constructor +-- from a seed. Managed fields use the public owned-ADT storage protocol; other +-- fields use the supplied scalar renderer. The statement renderer initializes +-- retained values that occur through nested aggregate fields. +adtDriverInit :: CgConfig -> [Kind] -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> String -> Integer -> Doc +adtDriverInit cfg adts renderValue initializeValue kind externalName seed + | isConcreteADT kind + , adtNeedsOwnership cfg adts kind + = text (adtCType kind) <+> text externalName P.<> semi + $$ initialize kind (text externalName) constructorIndex + $$ vcat (assignConstructor maximumDepth kind (text externalName) externalName constructorIndex fields seed) + | True + = error $ "SBV->C: Expected an owned ADT, received " ++ show kind + where maximumDepth = max 3 (length adts + 1) + (constructorIndex, fields) = chooseConstructor maximumDepth kind seed + + initialize fieldKind access index = text (adtOwnedInitName fieldKind) + P.<> parens (fsep (punctuate comma [text "&" P.<> parens access, text (adtTagName fieldKind index)])) + P.<> semi + + release fieldKind access = text (adtOwnedReleaseName fieldKind) + P.<> parens (text "&" P.<> parens access) + P.<> semi + + assignConstructor depth _ access accessName index fieldKinds fieldSeed = concat + (zipWith (assignField depth access accessName index) [1 :: Int ..] (zip fieldKinds [fieldSeed ..])) + + assignField depth access accessName constructor fieldIndex (field, nestedSeed) = + assignAt depth field fieldAccess fieldName nestedSeed + where fieldAccess = adtField access constructor fieldIndex + fieldName = accessName ++ "_constructor_" ++ show constructor ++ "_field_" ++ show fieldIndex + + assignAt depth (ADTField fieldKind recursive) access accessName fieldSeed + | recursive + = let nestedDepth = depth - 1 + (nestedIndex, nestedFields) = chooseConstructor nestedDepth fieldKind fieldSeed + dereferenced = text "*" P.<> parens access + in [ access <+> text "=" <+> parens (text (adtCType fieldKind) <+> text "*") + <+> text "malloc" P.<> parens (text "sizeof" <+> text "*" P.<> parens access) P.<> semi + , text "if" <+> parens (access <+> text "== NULL") <+> text "abort" P.<> parens empty P.<> semi + , initialize fieldKind dereferenced nestedIndex + ] + ++ assignConstructor nestedDepth fieldKind dereferenced (accessName ++ "_recursive") nestedIndex nestedFields fieldSeed + | isExactGMPKind cfg fieldKind + = exactAssignments fieldKind access fieldSeed + | fieldKind == KString + = [access <+> text "=" <+> managedValueClone fieldKind (renderValue fieldKind fieldSeed) P.<> semi] + | isArray fieldKind + = [ initializeValue fieldKind accessName fieldSeed + , access <+> text "=" <+> text accessName P.<> semi + ] + | isList fieldKind + = collectionAssignment listNeedsDriverInit listDriverInit listDriverClear listClone + | isSet fieldKind + = collectionAssignment setNeedsDriverInit setDriverInit setDriverClear setClone + | KTuple fieldKinds <- fieldKind + , tupleNeedsOwnership cfg fieldKind + = concat (zipWith assignTupleField [1 :: Int ..] (zip fieldKinds [fieldSeed ..])) + | isConcreteADT fieldKind + , adtNeedsOwnership cfg adts fieldKind + = let (nestedIndex, nestedFields) = chooseConstructor depth fieldKind fieldSeed + in release fieldKind access + : initialize fieldKind access nestedIndex + : assignConstructor depth fieldKind access accessName nestedIndex nestedFields fieldSeed + | True + = [access <+> text "=" <+> renderValue fieldKind fieldSeed P.<> semi] + where assignTupleField fieldIndex (nestedKind, nestedSeed) = assignAt depth (ADTField nestedKind False) nestedAccess nestedName nestedSeed + where nestedAccess = access P.<> text "." P.<> text (tupleFieldName fieldIndex) + nestedName = accessName ++ "_field_" ++ show fieldIndex + + collectionAssignment needsDriverInit driverInit driverClear clone + | needsDriverInit cfg fieldKind + = [ driverInit cfg renderValue initializeValue fieldKind accessName fieldSeed + , access <+> text "=" <+> clone fieldKind (text accessName) P.<> semi + , driverClear cfg fieldKind accessName + ] + | True + = [access <+> text "=" <+> clone fieldKind (renderValue fieldKind fieldSeed) P.<> semi] + + chooseConstructor depth fieldKind fieldSeed + | null eligible = error $ "SBV->C: Recursive ADT " ++ show fieldKind + ++ " has no finite constructor for a generated driver value" + | True = let (index, (_, selectedFields)) = eligible !! fromInteger (mod fieldSeed (fromIntegral (length eligible))) + in (index, selectedFields) + where eligible = [(index, constructor) + | (index, constructor@(_, candidateFields)) <- zip [1 :: Int ..] (adtConstructorFields adts fieldKind) + , all (fits depth) candidateFields + ] + + fits _ (ADTField _ False) = True + fits depth (ADTField fieldKind True) = depth > 0 && constructible (depth - 1) fieldKind + + constructible depth fieldKind = any (all (fits depth) . snd) (adtConstructorFields adts fieldKind) + + exactAssignments fieldKind access value = gmpDriverAssign fieldKind access (integer value) + +-- | Render a concrete ADT value as a C99 compound literal using the enclosing +-- program's complete registry, shared with nested constant rendering. +adtConst :: [Kind] -> (CV -> Doc) -> CV -> Maybe Doc +adtConst adts renderValue cv@(CV kind (CADT (constructorName, fieldValues))) + | isConcreteADT kind + , Just (constructorIndex, fieldKinds) <- findConstructor adts kind constructorName + , map fst fieldValues == fieldKinds + = Just $ adtValue adts kind constructorIndex + [arrayStoredValue fieldKind (renderValue (CV fieldKind fieldValue)) | (fieldKind, fieldValue) <- fieldValues] + | isConcreteADT kind + = error $ "SBV->C: Malformed ADT constant " ++ show cv +adtConst _ _ _ = Nothing + +-- | Lower ADT construction, tests, accessors, equality, conditionals, and labels. +adtExpr :: CgConfig -> [Kind] -> Op -> [SV] -> SV -> [Doc] -> Maybe CLowering +adtExpr cfg adts op svs resultSV args + | not (isConcreteADT resultKind || any (isConcreteADT . kindOf) svs) + = Nothing + | LkUp{} <- op + = Nothing + | TupleConstructor{} <- op + = Nothing + | TupleAccess{} <- op + = Nothing + | Uninterpreted{} <- op + = Nothing + | True + = case (op, svs, args) of + (ADTOp (ADTConstructor constructorName kind), fields, renderedFields) + | kind == resultKind + , Just (constructorIndex, fieldKinds) <- findConstructor adts kind (T.unpack constructorName) + , map kindOf fields == fieldKinds + -> lowerConstructor kind constructorIndex (zipWith arrayStoredValue fieldKinds renderedFields) + (ADTOp (ADTTester testerName operationResultKind), [value], [renderedValue]) + | operationResultKind == resultKind + , Just constructorIndex <- findTester adts (kindOf value) (T.unpack testerName) + -> lower $ adtTag renderedValue <+> text "==" <+> text (adtTagName (kindOf value) constructorIndex) + -- The operation records SBV's scalar result kind, which strips any + -- surrounding arrays. The accessor field and result SV retain the full kind. + (ADTOp (ADTAccessor accessorName _operationResultKind), [value], [renderedValue]) + | Just (constructorIndex, fieldIndex, fieldKind, recursive) <- findAccessor adts (kindOf value) (T.unpack accessorName) + , fieldKind == resultKind + -> let field = if recursive + then text (adtDereferenceName fieldKind) + P.<> parens (adtField renderedValue constructorIndex fieldIndex) + else adtField renderedValue constructorIndex fieldIndex + in if isArray resultKind then Just (arrayStoredLoad resultSV field) else lower field + (Equal strong, [left, right], [renderedLeft, renderedRight]) + | kindOf left == kindOf right + -> lower $ adtEqual cfg adts strong (kindOf left) renderedLeft renderedRight + (NotEqual, [left, right], [renderedLeft, renderedRight]) + | kindOf left == kindOf right + -> lower $ text "!" P.<> parens (adtEqual cfg adts False (kindOf left) renderedLeft renderedRight) + (comparison, [left, right], [renderedLeft, renderedRight]) + | adtIsEnumeration adts (kindOf left) + , kindOf left == kindOf right + , Just comparisonSymbol <- adtComparisonSymbol comparison + -> lower $ adtTag renderedLeft <+> text comparisonSymbol <+> adtTag renderedRight + (Label label, [_], [renderedValue]) + -> lower $ renderedValue <+> text "/*" <+> cCommentText label <+> text "*/" + _ -> error $ "SBV->C: ADT lowering does not support " ++ adtOperationName op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + ++ "; constructors " + ++ show [constructorName | (constructorName, _) <- adtConstructors adts (sourceADTKind resultKind svs)] + where resultKind = kindOf resultSV + + lower = Just . expressionLowering [] + + lowerConstructor kind constructorIndex renderedFields + | null recursiveFields + = lower (adtValue adts kind constructorIndex renderedFields) + | True + = Just CLowering + { loweringExpression = adtValueWithStorage adts kind constructorIndex storeField renderedFields + , loweringDeclarations = [text (adtCType fieldKind) <+> text (backingName fieldIndex) P.<> semi + | (fieldIndex, fieldKind, _) <- recursiveFields + ] + , loweringSetup = [text (backingName fieldIndex) <+> text "=" <+> field P.<> semi + | (fieldIndex, _, field) <- recursiveFields + ] + , loweringRequirements = Set.empty + } + where fieldInfo = snd (adtConstructorFields adts kind !! (constructorIndex - 1)) + recursiveFields = [ (fieldIndex, fieldKind, field) + | (fieldIndex, (ADTField fieldKind True, field)) <- zip [1 :: Int ..] (zip fieldInfo renderedFields) + ] + + backingName fieldIndex = "sbv_local_adt_recursive_" ++ show resultSV ++ "_" ++ show fieldIndex + + storeField fieldIndex _ True _ = text "&" P.<> text (backingName fieldIndex) + storeField _ _ False field = field + +-- | Test whether an ADT contains an exact GMP-backed integer, real, or +-- rational field. +adtUsesExact :: CgConfig -> [Kind] -> Kind -> Bool +adtUsesExact cfg adts = any constructorUsesExact . adtConstructors adts + where constructorUsesExact (_, fields) = any fieldUsesExact fields + fieldUsesExact = any (isExactGMPKind cfg) . expandKinds + +-- | Test whether an ADT needs deep ownership because it contains collection +-- storage, exact storage, recursive pointers, or another managed aggregate. +adtNeedsOwnership :: CgConfig -> [Kind] -> Kind -> Bool +adtNeedsOwnership cfg adts = needsOwnership Set.empty + where needsOwnership visited kind + | kind `Set.member` visited = adtIsRecursive adts kind + | adtUsesExact cfg adts kind = True + | True = any (any fieldNeedsOwnership . snd) (adtConstructorFields adts kind) + where next = Set.insert kind visited + fieldNeedsOwnership (ADTField _ True) = True + fieldNeedsOwnership (ADTField fieldKind False) + | isConcreteADT fieldKind = needsOwnership next fieldKind + | True = valueNeedsOwnership cfg fieldKind + +-- | Construct a deterministic driver value, choosing a constructor from the +-- supplied integer and delegating field values to the caller. +adtDriverValue :: [Kind] -> (Kind -> Integer -> Doc) -> Kind -> Integer -> Doc +adtDriverValue adts renderField = construct (max 3 (length adts + 1)) + where construct :: Int -> Kind -> Integer -> Doc + construct depth kind seed + | null constructors = error $ "SBV->C: Cannot construct an uninterpreted sort in the C driver: " ++ show kind + | True = adtValue adts kind constructorIndex (zipWith renderADTField fields [seed ..]) + where constructors = adtConstructorFields adts kind + eligible = [ (index, constructor) + | (index, constructor@(_, candidateFields)) <- zip [1 :: Int ..] constructors + , all (fits depth) candidateFields + ] + (constructorIndex, (_, fields)) + | null eligible = error $ "SBV->C: Recursive ADT " ++ show kind + ++ " has no finite constructor for a generated driver value" + | True = eligible !! fromInteger (mod seed (fromIntegral (length eligible))) + + renderADTField (ADTField fieldKind recursive) fieldSeed + | isConcreteADT fieldKind = construct (if recursive then depth - 1 else depth) fieldKind fieldSeed + | True = renderField fieldKind fieldSeed + + fits _ (ADTField _ False) = True + fits depth (ADTField fieldKind True) = depth > 0 && constructible (depth - 1) fieldKind + + constructible depth kind = any (all (fits depth) . snd) (adtConstructorFields adts kind) + +-- | Render C statements that print an ADT value by constructor name and fields. +adtPrint :: [Kind] -> (Kind -> Doc -> Doc) -> Kind -> Doc -> Doc +adtPrint adts printField kind value + | adtIsRecursive adts kind = text (adtPrintName kind) P.<> parens value P.<> semi + | True = adtPrintSwitch adts printField kind value + +-- | Emit mutually recursive driver-side printers for recursive ADTs. +adtPrintHelpers :: [Kind] -> (Kind -> Doc -> Doc) -> Doc +adtPrintHelpers adts printField + | null recursiveKinds = empty + | True = vcat (map prototype recursiveKinds) + $$ text "" + $$ vcat (map definition recursiveKinds) + where recursiveKinds = filter (adtIsRecursive adts) adts + prototype kind = text "static SBV_CGEN_UNUSED void" <+> text (adtPrintName kind) + P.<> parens (text (adtCType kind) <+> text "value") + P.<> semi + definition kind = text "#ifndef" <+> text (adtPrintGuard kind) + $$ text "#define" <+> text (adtPrintGuard kind) + $$ text "static SBV_CGEN_UNUSED void" <+> text (adtPrintName kind) + P.<> parens (text (adtCType kind) <+> text "value") + $$ text "{" + $$ nest 2 (adtPrintSwitch adts printField kind (text "value")) + $$ text "}" + $$ text "#endif" + $$ text "" + +-- | Render the tag switch shared by inline and recursive ADT printers. +adtPrintSwitch :: [Kind] -> (Kind -> Doc -> Doc) -> Kind -> Doc -> Doc +adtPrintSwitch adts printField kind value + = text "switch" <+> parens (adtTag value) <+> text "{" + $$ nest 2 (vcat (zipWith printConstructor [1 :: Int ..] (adtConstructorFields adts kind)) + $$ text "default: printf(\"\"); break;") + $$ text "}" + where printConstructor constructorIndex (constructorName, fields) + = text "case" <+> text (adtTagName kind constructorIndex) P.<> colon + $$ nest 2 (text "printf" P.<> parens (fsep (punctuate comma [text "\"%s\"", text (show constructorName)])) P.<> semi + $$ printFields constructorIndex fields + $$ text "break" P.<> semi) + + printFields _ [] = empty + printFields constructorIndex fields = + text "printf(\"(\");" + $$ vcat (zipWith (printOne constructorIndex) [1 :: Int ..] fields) + $$ text "printf(\")\");" + + printOne constructorIndex fieldIndex (ADTField fieldKind recursive) + = (if fieldIndex == 1 then empty else text "printf(\", \");") + $$ if recursive + then text "if" <+> parens (fieldValue <+> text "== NULL") + <+> text "printf(\"\");" + <+> text "else" + <+> printField fieldKind (text "*" P.<> parens fieldValue) + else printField fieldKind fieldValue + where fieldValue = adtField value constructorIndex fieldIndex + +-- | Return the driver-side printer name for a recursive ADT. +adtPrintName :: Kind -> String +adtPrintName kind = "sbv_adt_print_" ++ adtCType kind + +-- | Return the preprocessor guard for one driver-side recursive ADT printer. +adtPrintGuard :: Kind -> String +adtPrintGuard kind = adtPrintName kind ++ "_DEFINED" + +-- | Return constructors with parameter variables and 'KApp' references +-- replaced by their concrete kinds. +adtConstructors :: [Kind] -> Kind -> [(String, [Kind])] +adtConstructors adts kind = [(constructorName, [fieldKind | ADTField fieldKind _ <- fields]) + | (constructorName, fields) <- adtConstructorFields adts kind + ] + +-- | Return concrete constructor fields while retaining which direct 'KApp' +-- references must use pointers to break recursive C layouts. +adtConstructorFields :: [Kind] -> Kind -> [(String, [ADTField])] +adtConstructorFields adts kind@(KADT typeName parameters constructors) + | isConcreteADT kind = map substituteConstructor constructors + | True = error $ "SBV->C: Expected a concrete ADT kind, received " ++ show kind + where substituteConstructor (constructorName, fields) = (constructorName, map substituteField fields) + + substituteField field = ADTField concrete recursive + where substituted = substituteADTVars typeName parameters field + concrete = resolveADTReferences adts substituted + recursive = case substituted of + KApp{} -> adtReachable adts concrete kind + _ | any (\application -> adtReachable adts (resolveADTReferences adts application) kind) + [application | application@KApp{} <- expandKinds substituted] + -> error $ "SBV->C: Recursive ADT references nested inside composite fields are not supported: " ++ show kind + ++ ". Put the recursive reference in a direct constructor field instead." + | True -> False +adtConstructorFields _ kind = error $ "SBV->C: Expected an ADT kind, received " ++ show kind + +-- | Return whether the second ADT is reachable from the first through ADT +-- declaration references. The visited set makes recursive registries finite. +adtReachable :: [Kind] -> Kind -> Kind -> Bool +adtReachable adts source target = walk Set.empty source + where walk visited current + | current == target = True + | current `Set.member` visited = False + | True = any (walk (Set.insert current visited)) (adtDependencies adts current) + +-- | Return the concrete ADTs referenced directly or through composite fields +-- by one concrete ADT declaration. +adtDependencies :: [Kind] -> Kind -> [Kind] +adtDependencies adts (KADT typeName parameters constructors) = nub + [ resolveADTReferences adts application + | (_, fields) <- constructors + , field <- fields + , application@KApp{} <- expandKinds (substituteADTVars typeName parameters field) + ] +adtDependencies _ kind = error $ "SBV->C: Expected an ADT kind, received " ++ show kind + +-- | Resolve concrete ADT applications occurring inside a supported composite +-- field without recursively expanding the referenced declaration. +resolveADTReferences :: [Kind] -> Kind -> Kind +resolveADTReferences adts kind@(KApp typeName arguments) = + case [ (parameters, constructors) + | KADT candidateName parameters constructors <- adts + , candidateName == typeName + , length parameters == length arguments + ] of + ((parameters, constructors) : _) -> KADT typeName (zip (map fst parameters) arguments) constructors + [] -> error $ "SBV->C: Cannot resolve ADT reference " ++ show kind + ++ "; available concrete ADTs: " ++ show adts +resolveADTReferences adts (KList elementKind) = KList (resolveADTReferences adts elementKind) +resolveADTReferences adts (KSet elementKind) = KSet (resolveADTReferences adts elementKind) +resolveADTReferences adts (KTuple fieldKinds) = KTuple (map (resolveADTReferences adts) fieldKinds) +resolveADTReferences adts (KArray keyKind valueKind) = + KArray (resolveADTReferences adts keyKind) (resolveADTReferences adts valueKind) +resolveADTReferences _ kind = kind + +-- | Render the field-level equality semantics used inside an ADT comparison. +adtFieldEqual :: CgConfig -> [Kind] -> Bool -> Kind -> Doc -> Doc -> Doc +adtFieldEqual cfg adts strong kind left right + | isWideBV kind = wideBVEqual kind left right + | isFP kind && strong = arbitraryFPObjectEqual kind left right + | isFP kind = arbitraryFPEqual kind left right + | strong && (isFloat kind || isDouble kind) = nativeFPObjectEqual left right + | isExactGMPKind cfg kind = adtExactEqual kind left right + | kind == KString = byValueEqual cfg strong kind left right + | isList kind = listEqual kind left right + | isSet kind = setEqual kind left right + | isArray kind = byValueEqual cfg strong kind left right + | KTuple fields <- kind = tupleEqual cfg adts strong fields left right + | isConcreteADT kind = adtEqual cfg adts strong kind left right + | True = left <+> text "==" <+> right + +-- | Render exact equality directly with GMP's public comparison API. +adtExactEqual :: Kind -> Doc -> Doc -> Doc +adtExactEqual KUnbounded left right = text "mpz_cmp" + P.<> parens (fsep (punctuate comma [left, right])) + <+> text "== 0" +adtExactEqual exactKind left right + | exactKind `elem` [KReal, KRational] + = text "mpq_cmp" + P.<> parens (fsep (punctuate comma [left, right])) + <+> text "== 0" +adtExactEqual kind _ _ = error $ "SBV->C: Expected an exact ADT field, received " ++ show kind + +-- | Render structural equality for a tuple nested in an ADT field. +tupleEqual :: CgConfig -> [Kind] -> Bool -> [Kind] -> Doc -> Doc -> Doc +tupleEqual cfg adts strong fields left right = andExpressions comparisons + where comparisons = zipWith compareField [1 :: Int ..] fields + compareField index fieldKind = adtFieldEqual cfg adts strong fieldKind + (parens left P.<> text ".field" P.<> int index) + (parens right P.<> text ".field" P.<> int index) + +-- | Render tag-sensitive structural equality for two ADT values. +adtEqual :: CgConfig -> [Kind] -> Bool -> Kind -> Doc -> Doc -> Doc +adtEqual cfg adts strong kind left right + | adtIsRecursive adts kind = text (adtEqualName strong kind) + P.<> parens (fsep (punctuate comma [left, right])) + | True = parens $ tagEquality <+> text "&&" <+> constructorEquality + where tagEquality = parens (adtTag left <+> text "==" <+> adtTag right) + constructorEquality = parens . orExpressions $ zipWith constructorCase [1 :: Int ..] (adtConstructors adts kind) + constructorCase constructorIndex (_, fields) = andExpressions + (parens (adtTag left <+> text "==" <+> text (adtTagName kind constructorIndex)) + : zipWith (fieldEquality constructorIndex) [1 :: Int ..] fields) + fieldEquality constructorIndex fieldIndex fieldKind = adtFieldEqual cfg adts strong fieldKind + (adtField left constructorIndex fieldIndex) + (adtField right constructorIndex fieldIndex) + +-- | Return whether an ADT has at least one pointer-backed recursive field. +adtIsRecursive :: [Kind] -> Kind -> Bool +adtIsRecursive adts = any (any recursive . snd) . adtConstructorFields adts + where recursive (ADTField _ isRecursive) = isRecursive + +-- | Return the generated checked-dereference helper for a recursive ADT edge. +adtDereferenceName :: Kind -> String +adtDereferenceName kind = "sbv_adt_dereference_" ++ adtCType kind + +-- | Return the guard protecting one recursive ADT dereference helper. +dereferenceGuard :: Kind -> String +dereferenceGuard kind = adtDereferenceName kind ++ "_DEFINED" + +-- | Join Boolean C expressions with short-circuiting conjunction. +andExpressions :: [Doc] -> Doc +andExpressions [] = text "true" +andExpressions expressions = parens (fsep (punctuate (text " &&") expressions)) + +-- | Join Boolean C expressions with short-circuiting disjunction. +orExpressions :: [Doc] -> Doc +orExpressions [] = text "false" +orExpressions expressions = parens (fsep (punctuate (text " ||") expressions)) + +-- | Locate a constructor and return its one-based tag and concrete fields. +findConstructor :: [Kind] -> Kind -> String -> Maybe (Int, [Kind]) +findConstructor adts kind constructorName = do + (index, (_, fields)) <- find ((== constructorName) . fst . snd) + (zip [1 :: Int ..] (adtConstructors adts kind)) + pure (index, fields) + +-- | Locate the constructor named by a canonical @is-Constructor@ tester. +findTester :: [Kind] -> Kind -> String -> Maybe Int +findTester adts kind testerName = fst <$> find matches (zip [1 :: Int ..] (adtConstructors adts kind)) + where matches (_, (constructorName, _)) = testerName == "is-" ++ constructorName + +-- | Locate the constructor field named by a canonical +-- @getConstructor_fieldIndex@ accessor. +findAccessor :: [Kind] -> Kind -> String -> Maybe (Int, Int, Kind, Bool) +findAccessor adts kind accessorName = findMatch candidates + where candidates = [(constructorIndex, fieldIndex, fieldKind, recursive) + | (constructorIndex, (constructorName, fields)) <- zip [1 :: Int ..] (adtConstructorFields adts kind) + , (fieldIndex, ADTField fieldKind recursive) <- zip [1 :: Int ..] fields + , accessorName == "get" ++ constructorName ++ "_" ++ show fieldIndex + ] + findMatch [] = Nothing + findMatch (x:_) = Just x + +-- | Return the C type used for a supported ADT field, introducing a pointer +-- precisely for a recursive dependency edge. +adtFieldCType :: ADTField -> String +adtFieldCType (ADTField kind True) = adtCType kind ++ " *" +adtFieldCType (ADTField kind False) + | isConcreteADT kind = adtCType kind +adtFieldCType (ADTField kind False) = elementCType kind + + +-- | Render the tag-selection expression for an ADT value. +adtTag :: Doc -> Doc +adtTag value = parens value P.<> text ".tag" + +-- | Render the payload-selection expression for an ADT field. +adtField :: Doc -> Int -> Int -> Doc +adtField value constructorIndex fieldIndex = parens value + P.<> text ".payload." + P.<> text (adtConstructorMember constructorIndex) + P.<> text "." + P.<> text (adtFieldName fieldIndex) + +-- | Return the generated payload member for a one-based constructor index. +adtConstructorMember :: Int -> String +adtConstructorMember index = "constructor" ++ show index + +-- | Return the generated field member for a one-based field index. +adtFieldName :: Int -> String +adtFieldName index = "field" ++ show index + +-- | Return the generated enumeration type used for an ADT tag. +adtTagCType :: Kind -> String +adtTagCType kind = adtCType kind ++ "_Tag" + +-- | Return the generated enumeration constant for one ADT constructor. +adtTagName :: Kind -> Int -> String +adtTagName kind constructorIndex = adtCType kind ++ "_TAG_" ++ show constructorIndex + +-- | Return the preprocessor guard protecting one ADT declaration. +adtGuard :: Kind -> String +adtGuard kind = adtCType kind ++ "_DEFINED" + +-- | Return the preprocessor guard protecting one ADT forward declaration. +adtForwardGuard :: Kind -> String +adtForwardGuard kind = adtCType kind ++ "_DECLARED" + +-- | Render a C99 tagged-union compound literal. +adtValue :: [Kind] -> Kind -> Int -> [Doc] -> Doc +adtValue adts kind constructorIndex = adtValueWithStorage adts kind constructorIndex storeField + where storeField _ fieldKind True field + = text "&" + P.<> parens ( parens (text (adtCType fieldKind) P.<> brackets (text "1")) + P.<> braces field + ) + P.<> brackets (text "0") + storeField _ _ False field = field + +-- | Render a C99 tagged-union compound literal while allowing the caller to +-- choose how each recursive pointer field receives its backing storage. +adtValueWithStorage :: [Kind] -> Kind -> Int -> (Int -> Kind -> Bool -> Doc -> Doc) -> [Doc] -> Doc +adtValueWithStorage adts kind constructorIndex storeField fields + | constructorIndex < 1 || constructorIndex > length constructors + = error $ "SBV->C: Invalid ADT constructor index " ++ show constructorIndex ++ " for " ++ show kind + | length fields /= length expectedFields + = error $ "SBV->C: ADT literal field mismatch for " ++ show kind + | True + = parens (text (adtCType kind)) P.<> braces (fsep (punctuate comma initializers)) + where constructors = adtConstructors adts kind + expectedFields = snd (constructors !! (constructorIndex - 1)) + initializers = text ".tag" <+> text "=" <+> text (adtTagName kind constructorIndex) + : zipWith initializer [1 :: Int ..] (zip fields fieldInfo) + fieldInfo = snd (adtConstructorFields adts kind !! (constructorIndex - 1)) + initializer fieldIndex (field, ADTField fieldKind recursive) = text ".payload." + P.<> text (adtConstructorMember constructorIndex) + P.<> text "." + P.<> text (adtFieldName fieldIndex) + <+> text "=" <+> storeField fieldIndex fieldKind recursive field + +-- | Return a total diagnostic name for an operation involving an ADT. +adtOperationName :: Op -> String +adtOperationName (ADTOp (ADTConstructor opName _)) = "constructor " ++ show opName +adtOperationName (ADTOp (ADTTester opName _)) = "tester " ++ show opName +adtOperationName (ADTOp (ADTAccessor opName _)) = "accessor " ++ show opName +adtOperationName LkUp{} = "table lookup" +adtOperationName (Equal strong) = if strong then "strong equality" else "equality" +adtOperationName NotEqual = "inequality" +adtOperationName Ite = "conditional" +adtOperationName (Label label) = "label " ++ show label +adtOperationName _ = "an unsupported operation" + +-- | Recover the ADT kind participating in a failed lowering for diagnostics. +sourceADTKind :: Kind -> [SV] -> Kind +sourceADTKind resultKind _ + | isConcreteADT resultKind = resultKind +sourceADTKind _ svs = case filter (isConcreteADT . kindOf) svs of + value : _ -> kindOf value + [] -> error "SBV->C: Missing ADT kind in ADT lowering diagnostic" + +-- | Return whether every constructor of an ADT is nullary. +adtIsEnumeration :: [Kind] -> Kind -> Bool +adtIsEnumeration adts = all (null . snd) . adtConstructors adts + +-- | Return the C comparison token supported for enumeration ADTs. +adtComparisonSymbol :: Op -> Maybe String +adtComparisonSymbol LessThan = Just "<" +adtComparisonSymbol GreaterThan = Just ">" +adtComparisonSymbol LessEq = Just "<=" +adtComparisonSymbol GreaterEq = Just ">=" +adtComparisonSymbol _ = Nothing diff --git a/Data/SBV/Compilers/C/Arena.hs b/Data/SBV/Compilers/C/Arena.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Arena.hs @@ -0,0 +1,76 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Arena +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Shared emission of per-call storage arenas for text and collections. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Arena (CArena(..), arenaRuntime) where + +-- | Separate ownership domains sharing the same allocation protocol. Keep +-- their C types and lifetimes independent even though their emitter is shared. +data CArena = TextArena -- ^ Byte-addressed UTF-8 string storage. + | ListArena -- ^ Aligned storage for symbolic-list elements. + | SetArena -- ^ Aligned storage for symbolic-set elements. + +-- | Emit overflow-checked allocation and whole-arena cleanup. Empty allocations +-- return null without allocating. Collection storage retains its long-double +-- alignment and checks both multiplication and header-addition overflow; text +-- storage accepts a byte count directly. Nodes own only their payload buffer, +-- not the managed values referenced by collection elements. +arenaRuntime :: CArena -> [String] +arenaRuntime arena + = [ "/* Per-call ownership arena for " ++ description ++ " temporaries. */" + , "typedef struct " ++ nodeType ++ " { struct " ++ nodeType ++ " *next; " ++ payloadType ++ " data[]; } " ++ nodeType ++ ";" + , "typedef struct { " ++ nodeType ++ " *head; } " ++ contextType ++ ";" + ] + ++ separator + ++ [ "static " ++ resultType ++ " *" ++ prefix ++ "_alloc(" ++ contextType ++ " *ctx, size_t count" ++ elementParameter ++ ")" + , "{" + , " if (count == 0) return NULL;" + ] + ++ [ line + | not byteStorage + , line <- [ " if (element_size == 0 || count > SIZE_MAX / element_size) abort();" + , " const size_t bytes = count * element_size;" + ] + ] + ++ [ " if (" ++ byteCount ++ " > SIZE_MAX - sizeof(" ++ nodeType ++ ")) abort();" + , " " ++ nodeType ++ " *node = (" ++ nodeType ++ " *) malloc(sizeof(*node) + " ++ byteCount ++ ");" + , " if (node == NULL) abort();" + , " node->next = ctx->head; ctx->head = node; return node->data;" + , "}" + ] + ++ separator + ++ [ "static void " ++ prefix ++ "_ctx_end(" ++ contextType ++ " *ctx)" + , "{" + , " while (ctx->head != NULL) {" + , " " ++ nodeType ++ " *next = ctx->head->next; free(ctx->head); ctx->head = next;" + , " }" + , "}" + ] + where stem = case arena of + TextArena -> "text" + ListArena -> "list" + SetArena -> "set" + description = case arena of + TextArena -> "string" + ListArena -> "symbolic-list" + SetArena -> "symbolic-set" + byteStorage = case arena of + TextArena -> True + _ -> False + prefix = "sbv_" ++ stem + nodeType = prefix ++ "_node" + contextType = prefix ++ "_ctx" + payloadType = if byteStorage then "uint8_t" else "long double" + resultType = if byteStorage then "uint8_t" else "void" + byteCount = if byteStorage then "count" else "bytes" + elementParameter = if byteStorage then "" else ", size_t element_size" + separator = ["" | byteStorage] diff --git a/Data/SBV/Compilers/C/Array.hs b/Data/SBV/Compilers/C/Array.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Array.hs @@ -0,0 +1,855 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Array +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Persistent functional-array lowering for the SBV-to-C compiler. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Array + ( arrayKinds + , arrayCType + , arrayInputCType + , arrayOutputCType + , arrayForwardTypeDecls + , arrayOutputReadName + , arrayOutputReleaseName + , arrayExportName + , arrayStoredValue + , arrayStoredLoad + , arrayTypeDecls + , arrayRuntime + , arrayContextStart + , arrayContextEnd + , arrayInputSetup + , arrayDriverCallback + , arrayDriverInput + , arrayDriverStoredInput + , arrayLambdaName + , arrayConst + , arrayExpr + , arrayReadName + , arrayEqualName + ) where + +import Data.List (nubBy, tails) + +import qualified Data.Set as Set +import qualified Data.Text as T + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>), render) + +import Data.SBV.Compilers.C.BV (isWideBV) +import Data.SBV.Compilers.C.GMP (gmpFunctionName, gmpNewName, gmpOutputType, isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering(..), CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute, cCommentText) +import Data.SBV.Compilers.C.Types ( isConcreteADT + , constElementCType + , arrayKindTag + , arrayOutputCTypeName + , arrayStoredCloneName + , arrayStoredReleaseName + , elementCType + ) +import Data.SBV.Compilers.C.Value (byValueEqual, managedValueClone, managedValueRelease, valueNeedsOwnership) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data +import Data.SBV.Core.Symbolic (smtLambdaInfo) + +-- | Return and validate the distinct array kinds used by a program. Arrays may +-- occur as values, but not as keys: array-key matching would require general +-- extensional equality, which the C backend cannot implement for arbitrary +-- domains. Deduplicate by C type: Boolean and unsigned one-bit keys or values +-- have the same representation and share their runtime helpers. +arrayKinds :: Set.Set Kind -> [Kind] +arrayKinds = nubBy (\left right -> arrayCType left == arrayCType right) . map validate . filter isArray . Set.toAscList + where validate k@(KArray keyKind valueKind) + | isArray keyKind + = error $ "SBV->C: Array-valued array keys require unsupported extensional equality: " ++ show k + | supported keyKind && supported valueKind + = k + | True + = error $ "SBV->C: Array kind is not yet supported: " ++ show k + validate kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + + supported kind = case kind of + KBool -> True + KBounded{} -> True + KUnbounded -> True + KReal -> True + KRational -> True + KFloat -> True + KDouble -> True + KFP{} -> True + KChar -> True + KString -> True + KList elementKind -> supported elementKind + KSet elementKind -> supported elementKind + KTuple fields -> all supported fields + KArray keyKind valueKind -> not (isArray keyKind) && supported keyKind && supported valueKind + KADT{} -> isRoundingMode kind || isConcreteADT kind + _ -> False + +-- | Return the public opaque-pointer type used for an SBV array kind. +arrayCType :: Kind -> String +arrayCType kind@KArray{} = "SBVArray_" ++ arrayKindTag kind +arrayCType kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Return the public callback-descriptor type accepted for an array-valued +-- C input. The descriptor and its context are borrowed for the duration of +-- the generated call. +arrayInputCType :: Kind -> String +arrayInputCType kind = "SBVArrayInput_" ++ arraySuffix kind + +-- | Return the public owned-descriptor type produced for an array-valued C +-- output or return value. +arrayOutputCType :: Kind -> String +arrayOutputCType = arrayOutputCTypeName + +-- | Return the public helper name used to read an owned array output. +arrayOutputReadName :: Kind -> String +arrayOutputReadName kind = "sbv_array_output_read_" ++ arraySuffix kind + +-- | Return the public helper name used to release an owned array output. +arrayOutputReleaseName :: Kind -> String +arrayOutputReleaseName kind = "sbv_array_output_release_" ++ arraySuffix kind + +-- | Return the public helper name used to retain an owned array output. +arrayOutputRetainName :: Kind -> String +arrayOutputRetainName kind = "sbv_array_output_retain_" ++ arraySuffix kind + +-- | Return the public helper name used to borrow an owned output as an input +-- descriptor for another generated call. +arrayOutputAsInputName :: Kind -> String +arrayOutputAsInputName kind = "sbv_array_output_as_input_" ++ arraySuffix kind + +-- | Return the internal helper name used to export a function-scoped array. +arrayExportName :: Kind -> String +arrayExportName kind = "sbv_array_export_" ++ arraySuffix kind + +-- | Return the internal helper name that exports an array into the generated +-- function's temporary ownership arena. +arrayStoredExportName :: Kind -> String +arrayStoredExportName kind = "sbv_array_stored_export_" ++ arraySuffix kind + +-- | Convert an internal array expression to the retained descriptor pointer +-- representation used when an array is stored inside another value. Other +-- kinds are returned unchanged. +arrayStoredValue :: Kind -> Doc -> Doc +arrayStoredValue kind value + | isArray kind + = text (arrayStoredExportName kind) + P.<> parens (fsep (punctuate comma [text "&sbv_local_array_ctx", value])) + | True + = value + +-- | Borrow a retained descriptor pointer as an internal array root for the +-- remainder of a generated call. +arrayStoredLoad :: SV -> Doc -> CLowering +arrayStoredLoad resultSV descriptor = CLowering + { loweringExpression = text "&" P.<> text nodeName + , loweringDeclarations = [ text "const" <+> text (arrayOutputCType kind) <+> text "*" P.<> text descriptorName P.<> semi + , text (arrayNodeType kind) <+> text nodeName P.<> semi + ] + , loweringSetup = [ text descriptorName <+> text "=" <+> descriptor P.<> semi + , text "if" P.<> parens (text descriptorName <+> text "== NULL" <+> text "||" <+> text descriptorName P.<> text "->lookup == NULL") + <+> text "abort" P.<> parens empty P.<> semi + , text nodeName <+> text "=" <+> parens (text (arrayNodeType kind)) + <+> braces (fsep (punctuate comma descriptorFields)) P.<> semi + ] + , loweringRequirements = Set.singleton CRequiresArrays + } + where kind = kindOf resultSV + descriptorName = "sbv_local_array_descriptor_" ++ show resultSV + nodeName = "sbv_local_array_" ++ show resultSV + descriptorFields = [ text ".kind = SBV_ARRAY_CALLBACK" + , text ".lookup =" <+> text descriptorName P.<> text "->lookup" + , text ".context =" <+> text descriptorName P.<> text "->context" + , text ".retain =" <+> text descriptorName P.<> text "->retain" + , text ".release =" <+> text descriptorName P.<> text "->release" + ] + +-- | Emit descriptor forward declarations needed by aggregate layouts that +-- store arrays by pointer. The complete descriptor remains delayed until its +-- key and value layouts are available. +arrayForwardTypeDecls :: [Kind] -> Doc +arrayForwardTypeDecls [] = empty +arrayForwardTypeDecls kinds = text . unlines $ + commonDeclarations + ++ concatMap declaration kinds + where commonDeclarations = + [ "/* Forward declarations for retained array descriptors. */" + , cUnusedAttribute + , "#ifndef SBV_ARRAY_CONTEXT_LIFETIME_DEFINED" + , "#define SBV_ARRAY_CONTEXT_LIFETIME_DEFINED" + , "typedef const void *(*SBVArrayContextRetain)(const void *context);" + , "typedef void (*SBVArrayContextRelease)(const void *context);" + , "#endif" + , "" + ] + + declaration kind@KArray{} = + [ "#ifndef " ++ arrayForwardGuard kind + , "#define " ++ arrayForwardGuard kind + , "typedef struct " ++ arrayOutputCType kind ++ " " ++ arrayOutputCType kind ++ ";" + , "static inline SBV_CGEN_UNUSED " ++ arrayOutputCType kind ++ " *" ++ arrayStoredCloneName kind + ++ "(const " ++ arrayOutputCType kind ++ " *value);" + , "static inline SBV_CGEN_UNUSED void " ++ arrayStoredReleaseName kind + ++ "(" ++ arrayOutputCType kind ++ " **value);" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Emit opaque public array types for every kind used by a generated +-- program. Input descriptors are borrowed during a call. Output descriptors +-- own retained contexts and must be released with their generated helper. +arrayTypeDecls :: [Kind] -> Doc +arrayTypeDecls [] = empty +arrayTypeDecls kinds = text . unlines $ + [ "/* Persistent functional arrays. Internal references are valid for one call. */" + , "/* Input contexts are borrowed unless an escaping result invokes their retain */" + , "/* callback. Owned outputs must be released with the generated release helper. */" + , "/* Callback results borrow their context; aggregate reads borrow the array owner. */" + , "/* Clone a managed read result to outlive its owner. The as_input helper only borrows. */" + , "/* Lookups must be stable; escaping non-null contexts require both retain and release. */" + ] + ++ concatMap declaration kinds + where declaration kind@(KArray keyKind valueKind) + = let inputType = arrayInputCType kind + outputType = arrayOutputCType kind + lookupType = arrayLookupType kind + readOutput = arrayOutputReadName kind + retainOutput = arrayOutputRetainName kind + releaseOutput = arrayOutputReleaseName kind + asInput = arrayOutputAsInputName kind + cloneStored = arrayStoredCloneName kind + releaseStored = arrayStoredReleaseName kind + keyType = elementCType keyKind + valueType = elementCType valueKind + in [ "#ifndef " ++ arrayGuard kind + , "#define " ++ arrayGuard kind + , "/* Owned descriptors carry one reference. Retain copied descriptors and release each owner. */" + , "/* The input adapter is borrowed; a generated callee retains it if the array escapes. */" + , "#ifndef " ++ arrayForwardGuard kind + , "#define " ++ arrayForwardGuard kind + , "typedef struct " ++ outputType ++ " " ++ outputType ++ ";" + , "static inline SBV_CGEN_UNUSED " ++ outputType ++ " *" ++ cloneStored ++ "(const " ++ outputType ++ " *value);" + , "static inline SBV_CGEN_UNUSED void " ++ releaseStored ++ "(" ++ outputType ++ " **value);" + , "#endif" + , "typedef struct " ++ arrayNodeType kind ++ " " ++ arrayNodeType kind ++ ";" + , "typedef const " ++ arrayNodeType kind ++ " *" ++ arrayCType kind ++ ";" + , "typedef " ++ valueType ++ " (*" ++ lookupType ++ ")(const void *context, " ++ keyType ++ " key);" + , "typedef struct { " ++ lookupType ++ " lookup; const void *context; SBVArrayContextRetain retain; SBVArrayContextRelease release; } " ++ inputType ++ ";" + , "struct " ++ outputType ++ " { " ++ lookupType ++ " lookup; const void *context; SBVArrayContextRetain retain; SBVArrayContextRelease release; };" + , "static inline " ++ valueType ++ " " ++ readOutput ++ "(" ++ outputType ++ " array, " ++ keyType ++ " key)" + , "{ if (array.lookup == NULL) abort(); return array.lookup(array.context, key); }" + , "static inline " ++ outputType ++ " " ++ retainOutput ++ "(" ++ outputType ++ " array)" + , "{" + , " if (array.context != NULL) {" + , " if (array.retain == NULL) abort();" + , " array.context = array.retain(array.context);" + , " if (array.context == NULL) abort();" + , " }" + , " return array;" + , "}" + , "static inline void " ++ releaseOutput ++ "(" ++ outputType ++ " *array)" + , "{ if (array == NULL) return; if (array->context != NULL) { if (array->release == NULL) abort(); array->release(array->context); } array->lookup = NULL; array->context = NULL; array->retain = NULL; array->release = NULL; }" + , "static inline " ++ inputType ++ " " ++ asInput ++ "(" ++ outputType ++ " array)" + , "{ " ++ inputType ++ " input = {array.lookup, array.context, array.retain, array.release}; return input; }" + , "static inline SBV_CGEN_UNUSED " ++ outputType ++ " *" ++ cloneStored ++ "(const " ++ outputType ++ " *value)" + , "{" + , " if (value == NULL) abort();" + , " " ++ outputType ++ " *copy = (" ++ outputType ++ " *) malloc(sizeof *copy);" + , " if (copy == NULL) abort();" + , " *copy = " ++ retainOutput ++ "(*value);" + , " return copy;" + , "}" + , "static inline SBV_CGEN_UNUSED void " ++ releaseStored ++ "(" ++ outputType ++ " **value)" + , "{" + , " if (value == NULL || *value == NULL) return;" + , " " ++ releaseOutput ++ "(*value);" + , " free(*value);" + , " *value = NULL;" + , "}" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Emit the node layouts and newest-write-first lookup helpers for every +-- array kind used by a generated program. +arrayRuntime :: CgConfig -> [Kind] -> Doc +arrayRuntime _ [] = empty +arrayRuntime cfg kinds = text . unlines $ + [ "/* Persistent functional-array runtime. */" + , "typedef enum { SBV_ARRAY_CONSTANT, SBV_ARRAY_STORE, SBV_ARRAY_CALLBACK } SBVArrayNodeKind;" + , "typedef struct sbv_array_temp sbv_array_temp;" + , "struct sbv_array_temp { sbv_array_temp *next; void *value; void (*release)(void *value); };" + , "typedef struct { sbv_array_temp *temporaries; } sbv_array_ctx;" + , "" + , "static SBV_CGEN_UNUSED void sbv_array_ctx_remember(sbv_array_ctx *ctx, void *value, void (*release)(void *value))" + , "{" + , " if (ctx == NULL || value == NULL || release == NULL) abort();" + , " sbv_array_temp *temporary = (sbv_array_temp *) malloc(sizeof *temporary);" + , " if (temporary == NULL) abort();" + , " temporary->next = ctx->temporaries;" + , " temporary->value = value;" + , " temporary->release = release;" + , " ctx->temporaries = temporary;" + , "}" + , "" + , "static SBV_CGEN_UNUSED void sbv_array_ctx_end(sbv_array_ctx *ctx)" + , "{" + , " while (ctx != NULL && ctx->temporaries != NULL) {" + , " sbv_array_temp *temporary = ctx->temporaries;" + , " ctx->temporaries = temporary->next;" + , " temporary->release(temporary->value);" + , " free(temporary);" + , " }" + , "}" + , "" + ] + ++ concatMap runtime kinds + where runtime kind@(KArray keyKind valueKind) = + let nodeType = arrayNodeType kind + arrayType = arrayCType kind + keyType = elementCType keyKind + valueType = elementCType valueKind + readName = arrayReadName kind + keyEquality = P.render $ keyEqual cfg keyKind (text "array->key") (text "key") + in [ "struct " ++ nodeType ++ " {" + , " SBVArrayNodeKind kind;" + , " " ++ arrayType ++ " parent;" + , " " ++ keyType ++ " key;" + , " " ++ valueType ++ " value;" + , " " ++ arrayLookupType kind ++ " lookup;" + , " const void *context;" + , " SBVArrayContextRetain retain;" + , " SBVArrayContextRelease release;" + , "};" + , "" + , "static SBV_CGEN_UNUSED " ++ valueType ++ " " ++ readName ++ "(" ++ arrayType ++ " array, " ++ keyType ++ " key)" + , "{" + , " while (array->kind == SBV_ARRAY_STORE) {" + , " if (" ++ keyEquality ++ ") return array->value;" + , " array = array->parent;" + , " }" + , " if (array->kind == SBV_ARRAY_CALLBACK) return array->lookup(array->context, key);" + , " return array->value;" + , "}" + , "" + ] + ++ ownershipRuntime cfg kind + ++ storedArrayRuntime kind + runtime kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Emit the per-kind bridge that turns a call-scoped array node into an +-- owned descriptor pointer tracked by the function's temporary arena. +storedArrayRuntime :: Kind -> [String] +storedArrayRuntime kind@KArray{} = + [ "static SBV_CGEN_UNUSED void " ++ releaseVoid ++ "(void *value)" + , "{" + , " " ++ outputType ++ " *array = (" ++ outputType ++ " *) value;" + , " " ++ arrayOutputReleaseName kind ++ "(array);" + , " free(array);" + , "}" + , "" + , "static SBV_CGEN_UNUSED " ++ outputType ++ " *" ++ exportStored + ++ "(sbv_array_ctx *ctx, " ++ arrayCType kind ++ " array)" + , "{" + , " " ++ outputType ++ " *result = (" ++ outputType ++ " *) malloc(sizeof *result);" + , " if (result == NULL) abort();" + , " *result = " ++ arrayExportName kind ++ "(array);" + , " sbv_array_ctx_remember(ctx, result, " ++ releaseVoid ++ ");" + , " return result;" + , "}" + , "" + ] + where outputType = arrayOutputCType kind + exportStored = arrayStoredExportName kind + releaseVoid = "sbv_array_stored_release_void_" ++ arraySuffix kind +storedArrayRuntime kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Emit the heap owner used when an array escapes its generated call. Store +-- chains are copied, exact keys and values are duplicated into a private GMP +-- arena, managed aggregates are deep-copied, and callback contexts are +-- retained through their lifetime protocol. +ownershipRuntime :: CgConfig -> Kind -> [String] +ownershipRuntime cfg kind@(KArray keyKind valueKind) = + [ "typedef struct {" + , " size_t references;" + , " size_t node_count;" + , " " ++ nodeType ++ " *nodes;" + ] + ++ [" sbv_gmp_ctx exact_values;" | hasExact] + ++ [ " const void *base_context;" + , " SBVArrayContextRelease base_release;" + , "} " ++ ownerType ++ ";" + , "" + , "static SBV_CGEN_UNUSED " ++ valueType ++ " " ++ ownedLookup ++ "(const void *context, " ++ keyType ++ " key)" + , "{" + , " const " ++ ownerType ++ " *owner = (const " ++ ownerType ++ " *) context;" + , " return " ++ arrayReadName kind ++ "(&owner->nodes[0], key);" + , "}" + , "" + , "static SBV_CGEN_UNUSED const void *" ++ ownedRetain ++ "(const void *context)" + , "{" + , " " ++ ownerType ++ " *owner = (" ++ ownerType ++ " *) context;" + , " ++owner->references;" + , " return context;" + , "}" + , "" + , "static SBV_CGEN_UNUSED void " ++ ownedRelease ++ "(const void *context)" + , "{" + , " " ++ ownerType ++ " *owner = (" ++ ownerType ++ " *) context;" + , " if (--owner->references != 0) return;" + , " if (owner->base_release != NULL) owner->base_release(owner->base_context);" + ] + ++ releaseManagedFields + ++ [" sbv_gmp_ctx_end(&owner->exact_values);" | hasExact] + ++ [ " free(owner->nodes);" + , " free(owner);" + , "}" + , "" + , "static SBV_CGEN_UNUSED " ++ outputType ++ " " ++ arrayExportName kind ++ "(" ++ arrayType ++ " array)" + , "{" + , " size_t count = 1;" + , " " ++ arrayType ++ " cursor = array;" + , " if (cursor == NULL) abort();" + , " while (cursor->kind == SBV_ARRAY_STORE) { if (cursor->parent == NULL) abort(); ++count; cursor = cursor->parent; }" + , " " ++ ownerType ++ " *owner = (" ++ ownerType ++ " *) calloc(1, sizeof(*owner));" + , " if (owner == NULL) abort();" + , " owner->nodes = (" ++ nodeType ++ " *) calloc(count, sizeof(*owner->nodes));" + , " if (owner->nodes == NULL) { free(owner); abort(); }" + , " owner->references = 1;" + , " owner->node_count = count;" + , " " ++ arrayType ++ " source = array;" + , " for (size_t i = 0; i < count; ++i) {" + , " owner->nodes[i] = *source;" + , " if (source->kind == SBV_ARRAY_STORE) {" + , " owner->nodes[i].parent = &owner->nodes[i + 1];" + ] + ++ cloneExact "key" keyKind + ++ cloneManaged "key" keyKind + ++ [ " }" + , " if (source->kind != SBV_ARRAY_CALLBACK) {" + ] + ++ cloneExact "value" valueKind + ++ cloneManaged "value" valueKind + ++ [ " }" + , " if (source->kind == SBV_ARRAY_CALLBACK && source->context != NULL) {" + , " if (source->retain == NULL || source->release == NULL) abort();" + , " owner->base_context = source->retain(source->context);" + , " if (owner->base_context == NULL) abort();" + , " owner->base_release = source->release;" + , " owner->nodes[i].context = owner->base_context;" + , " }" + , " if (source->kind == SBV_ARRAY_STORE) source = source->parent;" + , " }" + , " " ++ outputType ++ " output = {" ++ ownedLookup ++ ", owner, " ++ ownedRetain ++ ", " ++ ownedRelease ++ "};" + , " return output;" + , "}" + , "" + ] + where nodeType = arrayNodeType kind + arrayType = arrayCType kind + inputSuffix = arraySuffix kind + ownerType = "sbv_array_owner_" ++ inputSuffix + outputType = arrayOutputCType kind + ownedLookup = "sbv_array_owned_lookup_" ++ inputSuffix + ownedRetain = "sbv_array_owned_retain_" ++ inputSuffix + ownedRelease = "sbv_array_owned_release_" ++ inputSuffix + keyType = elementCType keyKind + valueType = elementCType valueKind + hasExact = isExactGMPKind cfg keyKind || isExactGMPKind cfg valueKind + + releaseManagedFields + | keyManaged || valueManaged + = [" for (size_t i = 0; owner->nodes != NULL && i < owner->node_count; ++i) {"] + ++ [ " if (owner->nodes[i].kind == SBV_ARRAY_STORE) " ++ release "key" keyKind + | keyManaged + ] + ++ [ " if (owner->nodes[i].kind != SBV_ARRAY_CALLBACK) " ++ release "value" valueKind + | valueManaged + ] + ++ [" }"] + | True + = [] + + keyManaged = arrayFieldNeedsOwnership cfg keyKind + valueManaged = arrayFieldNeedsOwnership cfg valueKind + + release field fieldKind = P.render $ managedValueRelease fieldKind (text ("&owner->nodes[i]." ++ field)) + + cloneExact field fieldKind + | isExactGMPKind cfg fieldKind + = [ " " ++ gmpOutputType fieldKind ++ " copy = " ++ gmpNewName fieldKind ++ "(&owner->exact_values);" + , " " ++ gmpFunctionName fieldKind "set" ++ "(copy, source->" ++ field ++ ");" + , " owner->nodes[i]." ++ field ++ " = copy;" + ] + | True + = [] + + cloneManaged field fieldKind + | arrayFieldNeedsOwnership cfg fieldKind + = [ " owner->nodes[i]." ++ field ++ " = " + ++ P.render (managedValueClone fieldKind (text ("source->" ++ field))) ++ ";" + ] + | True + = [] + +ownershipRuntime _ kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Materialize a borrowed public callback descriptor as an internal array +-- root. A null lookup callback is rejected before the symbolic program runs. +arrayInputSetup :: Int -> SV -> String -> [Doc] +arrayInputSetup typeWidth sv externalName + | kind@KArray{} <- kindOf sv + = [ text "if" P.<> parens (external P.<> text ".lookup == NULL") <+> text "abort" P.<> parens empty P.<> semi + , text "if" P.<> parens (parens (external P.<> text ".retain == NULL") <+> text "!=" <+> parens (external P.<> text ".release == NULL")) <+> text "abort" P.<> parens empty P.<> semi + , text "const" <+> text (arrayNodeType kind) <+> text nodeName <+> text "=" <+> braces (fsep (punctuate comma fields)) P.<> semi + , text "const" <+> paddedType <+> text (show sv) <+> text "=" <+> text "&" P.<> text nodeName P.<> semi + ] + where external = text externalName + nodeName = "sbv_local_array_input_" ++ show sv + paddedType = text $ arrayCType (kindOf sv) ++ replicate (typeWidth - length (arrayCType (kindOf sv))) ' ' + fields = [ text ".kind = SBV_ARRAY_CALLBACK" + , text ".lookup =" <+> external P.<> text ".lookup" + , text ".context =" <+> external P.<> text ".context" + , text ".retain =" <+> external P.<> text ".retain" + , text ".release =" <+> external P.<> text ".release" + ] +arrayInputSetup _ sv _ = error $ "SBV->C: Expected an array input, received " ++ show (kindOf sv) + +-- | Emit the per-kind default-only callback used by example-driver array +-- values. Sharing one callback per array kind lets arrays appear at arbitrary +-- depth inside driver aggregates without requiring path-specific functions. +arrayDriverCallback :: CgConfig -> Kind -> Doc +arrayDriverCallback cfg kind@(KArray keyKind valueKind) + = text "#ifndef" <+> text (arrayDriverGuard kind) + $$ text "#define" <+> text (arrayDriverGuard kind) + $$ text "static SBV_CGEN_UNUSED" <+> text (elementCType valueKind) <+> text callbackName + P.<> parens (fsep (punctuate comma [text "const void *context", text (elementCType keyKind) <+> text "key"])) + $$ text "{" + $$ nest 2 ( parens (text "void") <+> text "key" P.<> semi + $$ text "return" <+> result P.<> semi + ) + $$ text "}" + $$ text "" + $$ retainContext + $$ text "" + $$ releaseContext + $$ text "#endif" + where callbackName = arrayDriverCallbackName kind + retainName = arrayDriverRetainName kind + releaseName = arrayDriverReleaseName kind + result + | isExactGMPKind cfg valueKind = parens (text (elementCType valueKind)) <+> text "context" + | True = text "*" P.<> parens (parens (text (constElementCType valueKind) <+> text "*") <+> text "context") + + retainContext + | isExactGMPKind cfg valueKind + = text "static SBV_CGEN_UNUSED const void *" P.<> text retainName P.<> parens (text "const void *context") + $$ text "{" + $$ nest 2 ( text mutableType <+> text "copy =" <+> parens (text mutableType) <+> text "malloc(sizeof(*copy));" + $$ text "if (copy == NULL) abort();" + $$ vcat (map text exactCopy) + $$ text "return copy;" + ) + $$ text "}" + | arrayFieldNeedsOwnership cfg valueKind + = text "static SBV_CGEN_UNUSED const void *" P.<> text retainName P.<> parens (text "const void *context") + $$ text "{" + $$ nest 2 ( text (elementCType valueKind) <+> text "*copy =" <+> parens (text (elementCType valueKind) <+> text "*") <+> text "malloc(sizeof(*copy));" + $$ text "if (copy == NULL) abort();" + $$ text "*copy =" <+> managedValueClone valueKind managedContextValue P.<> semi + $$ text "return copy;" + ) + $$ text "}" + | True + = text "static SBV_CGEN_UNUSED const void *" P.<> text retainName P.<> parens (text "const void *context") + $$ text "{" + $$ nest 2 ( text (elementCType valueKind) <+> text "*copy =" <+> parens (text (elementCType valueKind) <+> text "*") <+> text "malloc(sizeof(*copy));" + $$ text "if (copy == NULL) abort();" + $$ text "*copy =" <+> managedContextValue P.<> semi + $$ text "return copy;" + ) + $$ text "}" + + releaseContext + = text "static SBV_CGEN_UNUSED void" <+> text releaseName P.<> parens (text "const void *context") + $$ text "{" + $$ nest 2 ( managedClear + $$ exactClear + $$ text "free" P.<> parens (text "(void *) context") P.<> semi + ) + $$ text "}" + + managedContextValue = text "*" P.<> parens (parens (text (constElementCType valueKind) <+> text "*") <+> text "context") + + managedClear + | arrayFieldNeedsOwnership cfg valueKind + = text (elementCType valueKind) <+> text "*value =" <+> parens (text (elementCType valueKind) <+> text "*") <+> text "context" P.<> semi + $$ managedValueRelease valueKind (text "value") + | True + = empty + + mutableType + | KUnbounded <- valueKind = "mpz_ptr" + | isExactGMPKind cfg valueKind = "mpq_ptr" + | True = error $ "SBV->C: Expected an exact callback value, received " ++ show valueKind + + exactCopy + | KUnbounded <- valueKind = ["mpz_init_set(copy, (SInteger) context);"] + | isExactGMPKind cfg valueKind + = ["mpq_init(copy);", "mpq_set(copy, (" ++ elementCType valueKind ++ ") context);"] + | True = error $ "SBV->C: Expected an exact callback value, received " ++ show valueKind + + exactClear + | KUnbounded <- valueKind = text "mpz_clear((mpz_ptr) context);" + | isExactGMPKind cfg valueKind = text "mpq_clear((mpq_ptr) context);" + | True = empty +arrayDriverCallback _ kind = error $ "SBV->C: Expected an array input kind, received " ++ show kind + +-- | Construct an example-driver descriptor around a named default value and +-- its generated callback. Exact GMP defaults already decay to pointers; +-- ordinary values are passed to the callback by address. +arrayDriverInput :: CgConfig -> Kind -> String -> String -> Doc +arrayDriverInput cfg kind inputName defaultName + | KArray _ valueKind <- kind + = let context + | isExactGMPKind cfg valueKind = text defaultName + | True = text "&" P.<> text defaultName + in text "const" <+> text (arrayInputCType kind) <+> text inputName <+> text "=" + <+> braces (fsep (punctuate comma [ text ".lookup =" <+> text (arrayDriverCallbackName kind) + , text ".context =" <+> context + , text ".retain =" <+> text (arrayDriverRetainName kind) + , text ".release =" <+> text (arrayDriverReleaseName kind) + ])) P.<> semi + | True + = error $ "SBV->C: Expected an array input kind, received " ++ show kind + +-- | Retain a generated input descriptor into the pointer representation used +-- by array-valued aggregate fields. The returned pointer owns both its heap +-- descriptor and one retained callback-context reference. +arrayDriverStoredInput :: Kind -> String -> String -> Doc +arrayDriverStoredInput kind@KArray{} externalName inputName + = text (arrayOutputCType kind) <+> text "*" P.<> text externalName <+> text "=" + <+> parens (text (arrayOutputCType kind) <+> text "*") <+> text "malloc(sizeof(*" P.<> text externalName P.<> text "));" + $$ text "if" <+> parens (text externalName <+> text "== NULL") <+> text "abort();" + $$ text "*" P.<> text externalName <+> text "=" + <+> text (arrayOutputRetainName kind) + P.<> parens (parens (text (arrayOutputCType kind)) + <+> braces (fsep (punctuate comma [ text ".lookup =" <+> text inputName P.<> text ".lookup" + , text ".context =" <+> text inputName P.<> text ".context" + , text ".retain =" <+> text inputName P.<> text ".retain" + , text ".release =" <+> text inputName P.<> text ".release" + ]))) P.<> semi +arrayDriverStoredInput kind _ _ = error $ "SBV->C: Expected an array input kind, received " ++ show kind + +-- | Render a concrete array model as a nested chain of C99 compound literals. +-- Association-list entries retain SBV's newest-write-first ordering. +arrayConst :: (CV -> Doc) -> CV -> Maybe Doc +arrayConst renderValue (CV kind@(KArray keyKind valueKind) (CArray (ArrayModel associations defaultValue))) + = Just $ foldr store base associations + where base = nodeLiteral [text ".kind = SBV_ARRAY_CONSTANT", text ".value =" <+> renderField valueKind defaultValue] + + store (key, value) parent = nodeLiteral + [ text ".kind = SBV_ARRAY_STORE" + , text ".parent =" <+> parent + , text ".key =" <+> renderValue (CV keyKind key) + , text ".value =" <+> renderField valueKind value + ] + + renderField fieldKind fieldValue + = arrayStoredValue fieldKind (renderValue (CV fieldKind fieldValue)) + + nodeLiteral fields = parens $ text "&" P.<> parens (text (arrayNodeType kind)) P.<> braces (fsep (punctuate comma fields)) +arrayConst _ _ = Nothing + +-- | Lower array initialization, reads, writes, and array-valued conditionals. +-- Structured lambda-backed arrays, including free arrays, become callback +-- roots. Array-valued elements cross node boundaries through retained +-- descriptor pointers. The supplied name resolvers identify private defined +-- functions and lambda-lifted array callbacks. Equality calls a helper whose +-- finite key domain and enumeration limit are checked by the C renderer. +arrayExpr :: CgConfig + -> (T.Text -> Maybe String) + -> (SV -> Maybe String) + -> Op + -> [SV] + -> SV + -> [Doc] + -> Maybe CLowering +arrayExpr cfg definedFunctionName structuredLambdaName op svs resultSV args + | not (isArray resultKind || any isArray svs) + = Nothing + | True + = case (op, svs, args) of + (TupleConstructor{}, _, _) -> Nothing + (TupleAccess{}, _, _) -> Nothing + (ADTOp{}, _, _) -> Nothing + (SeqOp{}, _, _) -> Nothing + (SetOp{}, _, _) -> Nothing + (LkUp{}, _, _) -> Nothing + (Uninterpreted symbol, _, renderedArguments) + | isArray resultKind + , Just functionName <- definedFunctionName symbol + -> Just $ arrayStoredLoad resultSV + (namedCall functionName (text "&sbv_local_function_ctx" : renderedArguments)) + | True + -> Nothing + (ArrayInit (Left pair), [_], [defaultValue]) + | resultKind == uncurry KArray pair + -> nodeLowering resultKind + [text ".kind = SBV_ARRAY_CONSTANT", text ".value =" <+> storedValue (snd pair) defaultValue] + (ArrayInit (Right lambdaDef), [], []) + | Just _ <- smtLambdaInfo lambdaDef + , Just callbackName <- structuredLambdaName resultSV + -> nodeLowering resultKind + [ text ".kind = SBV_ARRAY_CALLBACK" + , text ".lookup =" <+> text callbackName + , text ".context =" <+> text "&sbv_local_function_ctx" + , text ".retain =" <+> text "sbv_function_ctx_retain_empty" + , text ".release =" <+> text "sbv_function_ctx_release_owned" + ] + | True + -> unsupported "lambda arrays without registered retained structured expressions" + (ReadArray, [array, key], [renderedArray, renderedKey]) + | kindOf array == KArray (kindOf key) resultKind + -> let readResult = namedCall (arrayReadName (kindOf array)) [renderedArray, renderedKey] + in if isArray resultKind then Just (arrayStoredLoad resultSV readResult) else expression readResult + (WriteArray, [array, key, value], [renderedArray, renderedKey, renderedValue]) + | resultKind == kindOf array + , resultKind == KArray (kindOf key) (kindOf value) + -> nodeLowering resultKind + [ text ".kind = SBV_ARRAY_STORE" + , text ".parent =" <+> renderedArray + , text ".key =" <+> renderedKey + , text ".value =" <+> storedValue (kindOf value) renderedValue + ] + (Label label, [_], [array]) + -> expression $ array <+> text "/*" <+> cCommentText label <+> text "*/" + (Equal{}, initial:rest, a:as) + | all ((== kindOf initial) . kindOf) rest + -> expression $ conjunction [namedCall (arrayEqualName (kindOf initial)) [a, b] | b <- as] + (NotEqual, initial:rest, _) + | all ((== kindOf initial) . kindOf) rest + -> expression $ conjunction [text "!" P.<> parens (namedCall (arrayEqualName (kindOf initial)) [a, b]) + | a:as <- tails args, b <- as] + _ -> error $ "SBV->C: Unsupported array operation " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + where resultKind = kindOf resultSV + + expression = Just . expressionLowering requirements + + conjunction [] = text "true" + conjunction ds = hsep (punctuate (text " &&") (map parens ds)) + + nodeLowering kind fields = Just CLowering + { loweringExpression = text "&" P.<> text nodeName + , loweringDeclarations = [text (arrayNodeType kind) <+> text nodeName P.<> semi] + , loweringSetup = [text nodeName <+> text "=" <+> parens (text (arrayNodeType kind)) + <+> braces (fsep (punctuate comma fields)) P.<> semi] + , loweringRequirements = Set.fromList requirements + } + + nodeName = "sbv_local_array_" ++ show resultSV + + storedValue = arrayStoredValue + + requirements = CRequiresArrays : concatMap kindRequirements (resultKind : map kindOf svs) + + kindRequirements kind + | isWideBV kind = [CRequiresWideBV] + | isFP kind = [CRequiresLibBF, CRequiresLibM] + | isExactGMPKind cfg kind = [CRequiresGMP] + | kind `elem` [KFloat, KDouble] = [CRequiresLibM] + | KArray keyKind valueKind <- kind + = kindRequirements keyKind ++ kindRequirements valueKind + | True = [] + + unsupported feature = error $ "SBV->C: Arrays do not yet support " ++ feature ++ "." + + namedCall functionName callArgs = text functionName P.<> parens (fsep (punctuate comma callArgs)) + +-- | Name the private exact finite-domain array equality helper. +arrayEqualName :: Kind -> String +arrayEqualName kind = "sbv_array_equal_" ++ arraySuffix kind + +-- | Initialize the arena that owns array descriptors embedded in temporary +-- generated values. +arrayContextStart :: Doc +arrayContextStart = text "sbv_array_ctx sbv_local_array_ctx = {NULL};" + +-- | Release the array descriptors embedded in temporary generated values. +arrayContextEnd :: Doc +arrayContextEnd = text "sbv_array_ctx_end" P.<> parens (text "&sbv_local_array_ctx") P.<> semi + +-- | Return the concrete node-structure name for an array kind. +arrayNodeType :: Kind -> String +arrayNodeType kind = "sbv_array_node_" ++ arraySuffix kind + +-- | Return the lookup-helper name for an array kind. +arrayReadName :: Kind -> String +arrayReadName kind = "sbv_array_read_" ++ arraySuffix kind + +-- | Return the callback-function-pointer type for an array kind. +arrayLookupType :: Kind -> String +arrayLookupType kind = "SBVArrayLookup_" ++ arraySuffix kind + +-- | Return the generated example-driver callback name for an array kind. +arrayDriverCallbackName :: Kind -> String +arrayDriverCallbackName kind = "sbv_local_array_driver_lookup_" ++ arraySuffix kind + +-- | Return the generated example-driver context-retain callback name. +arrayDriverRetainName :: Kind -> String +arrayDriverRetainName kind = "sbv_local_array_retain_driver_" ++ arraySuffix kind + +-- | Return the generated example-driver context-release callback name. +arrayDriverReleaseName :: Kind -> String +arrayDriverReleaseName kind = "sbv_local_array_release_driver_" ++ arraySuffix kind + +-- | Return the preprocessor guard that deduplicates a per-kind driver callback +-- when independently generated library components share an array type. +arrayDriverGuard :: Kind -> String +arrayDriverGuard kind = "SBV_ARRAY_DRIVER_CALLBACK_" ++ arraySuffix kind ++ "_DEFINED" + +-- | Return the generated C lookup-helper name for a structured lambda array. +arrayLambdaName :: SV -> String +arrayLambdaName array = "sbv_array_lambda_" ++ show array + +-- | Return the key/value suffix shared by the generated names for an array +-- kind. +arraySuffix :: Kind -> String +arraySuffix = arrayKindTag + +-- | Return the preprocessor guard protecting an array type declaration. +arrayGuard :: Kind -> String +arrayGuard kind = arrayCType kind ++ "_DEFINED" + +-- | Return the preprocessor guard protecting an array descriptor's forward +-- declaration and stored-value helper prototypes. +arrayForwardGuard :: Kind -> String +arrayForwardGuard kind = arrayOutputCType kind ++ "_FORWARD_DEFINED" + +-- | Render the strong equality used to match array keys. Unlike IEEE numeric +-- equality, this recursively preserves object equality for aggregate fields. +keyEqual :: CgConfig -> Kind -> Doc -> Doc -> Doc +keyEqual cfg = byValueEqual cfg True + +-- | Test whether an array field needs an independent deep copy when its node +-- escapes the generated call. Direct exact values use the owner's GMP arena. +arrayFieldNeedsOwnership :: CgConfig -> Kind -> Bool +arrayFieldNeedsOwnership cfg kind + | isExactGMPKind cfg kind = False + | isConcreteADT kind = True + | True = valueNeedsOwnership cfg kind diff --git a/Data/SBV/Compilers/C/BV.hs b/Data/SBV/Compilers/C/BV.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/BV.hs @@ -0,0 +1,1031 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.BV +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Exact, portable lowering of non-native sized bit-vectors to C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.BV + ( isWideBV + , wideBVKinds + , wideBVTypeDecls + , bitVectorRuntime + , wideBVConst + , wideBVExpr + , bitVectorCastExpr + , nativeBVExpr + , mappedIntegerKind + , nativeBVOverflowExpr + , wideBVLookupInRange + , wideBVLookupIndex + , wideBVEqual + , wideBVNormalize + , wideBVPrint + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.Bits (shiftL, shiftR, (.&.)) +import Data.Char (toUpper) +import Data.List (intercalate, nub, stripPrefix, tails) +import qualified Data.Set as Set +import Numeric (showHex) + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Core.Data + +-- | True when a bit-vector cannot use the historical scalar C ABI. These +-- values are represented as little-endian arrays of 64-bit limbs. +isWideBV :: Kind -> Bool +isWideBV k = isBounded k + && k /= KBounded False 1 + && intSizeOf k `notElem` [8, 16, 32, 64] + +-- | The distinct non-native bit-vector kinds used by a program. +wideBVKinds :: Set.Set Kind -> [Kind] +wideBVKinds = filter isWideBV . Set.toAscList + +-- | Type declarations and printing routines belonging in the public header. +wideBVTypeDecls :: [Kind] -> Doc +wideBVTypeDecls [] = empty +wideBVTypeDecls ks = text . unlines $ + ["/* Exact-width bit-vectors (least-significant limb first). */" + , cUnusedAttribute] + ++ concatMap decl ks + where decl k = ["#ifndef " ++ guard k + , "#define " ++ guard k + , "typedef struct { uint64_t limb[" ++ show (limbs k) ++ "]; } " ++ cType k ++ ";" + , "static inline SBV_CGEN_UNUSED void " ++ prefix k ++ "_fprint(FILE *stream, " ++ cType k ++ " value)" + , "{" + , " size_t i = " ++ show (limbs k) ++ ";" + , " fputs(\"0x\", stream);" + , " while (i-- > 0) { fprintf(stream, \"%016\" PRIx64, value.limb[i]); }" + , "}" + , "#endif" + , ""] + + guard k = "SBV_BV_" ++ map toUpper (tag k) ++ "_DEFINED" + +-- | Runtime routines for each used exact-width type, together with the exact +-- native arithmetic, bit-manipulation, and cross-width helpers demanded by +-- the complete symbolic DAG. Native-only programs can require these helpers +-- even when no limb-backed type occurs. The optional integer width selects +-- modular arithmetic helpers for explicitly mapped 'SInteger' values too. +bitVectorRuntime :: Maybe Int -> [Kind] -> [(SV, SBVExpr)] -> Doc +bitVectorRuntime integerWidth ks asgns + | null routines = empty + | True = text . unlines . map markUnused $ + [ "/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */" + , cUnusedAttribute + , "" + ] + ++ routines + where specials (sv, SBVApp op args) = case op of + Extract hi lo -> [SpecialExtract (kindOf (headArg "Extract" args)) hi lo (kindOf sv)] + Join -> case args of + [a, b] -> [SpecialJoin (kindOf a) (kindOf b) (kindOf sv)] + _ -> badArity "Join" args + Rol{} + | source : _ <- args + , isNativeBV source -> [SpecialRotate (kindOf source)] + Ror{} + | source : _ <- args + , isNativeBV source -> [SpecialRotate (kindOf source)] + Shl + | source : _ <- args + , isNativeBV source -> [SpecialShift (kindOf source)] + Shr + | source : _ <- args + , isNativeBV source -> [SpecialShift (kindOf source)] + Plus -> nativeArithmetic args SpecialAdd + Minus -> nativeArithmetic args SpecialSub + Times -> nativeArithmetic args SpecialMul + UNeg -> nativeArithmetic args SpecialNeg + Abs -> nativeArithmetic args SpecialAbs + Quot -> nativeArithmetic args SpecialQuot + Rem -> nativeArithmetic args SpecialRem + ZeroExtend _ -> [SpecialConvert False (kindOf (headArg "ZeroExtend" args)) (kindOf sv)] + SignExtend _ -> [SpecialConvert True (kindOf (headArg "SignExtend" args)) (kindOf sv)] + KindCast fr to + | let source = mappedIntegerKind integerWidth fr + , let target = mappedIntegerKind integerWidth to + , isBounded source && isBounded target -> [SpecialConvert (hasSign source) source target] + IEEEFP (FP_Reinterpret fr to) + | isBounded fr && isBounded to -> [SpecialConvert False fr to] + _ -> [] + + specialRuntime s = case s of + SpecialExtract fr hi lo to -> conversionRuntime (extractName fr hi lo to) False lo fr to + SpecialJoin a b to -> joinRuntime a b to + SpecialConvert sign fr to -> conversionRuntime (convertName sign fr to) sign 0 fr to + SpecialRotate kind -> rotationRuntime kind + SpecialShift kind -> shiftRuntime kind + SpecialArithmetic arith kind -> nativeArithmeticRuntime arith kind + + routines = concatMap coreRuntime ks + ++ concatMap specialRuntime (nub (concatMap specials asgns)) + + nativeArithmetic args arith = case args of + source : _ + | let kind = mappedIntegerKind integerWidth (kindOf source) + , isNativeBVKind kind -> [SpecialArithmetic (integerArithmetic (kindOf source) arith) kind] + _ -> [] + + markUnused line + | Just rest <- stripPrefix "static inline " line = "static inline SBV_CGEN_UNUSED " ++ rest + | otherwise = line + +-- | Render a constant as a C99 compound literal. +wideBVConst :: Kind -> Integer -> Maybe Doc +wideBVConst k i + | isWideBV k = Just . text $ "(" ++ cType k ++ "){{" ++ intercalate ", " (map word [0 .. limbs k - 1]) ++ "}}" + | True = Nothing + where normalized = i `mod` (2 ^ intSizeOf k) + word n = u64 $ (normalized `shiftR` (64 * n)) .&. ((1 `shiftL` 64) - 1) + +-- | Lower an operation involving a non-native bit-vector. A 'Nothing' result +-- means that the legacy scalar lowering should handle the operation. +wideBVExpr :: Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +wideBVExpr op svs resultKind args + | not (isWideBV resultKind || any (isWideBV . kindOf) svs) + = Nothing + | LkUp{} <- op + = Nothing + | Uninterpreted{} <- op + = Nothing + | True + = Just . expressionLowering [CRequiresWideBV] $ case (op, args, svs) of + (Label _ , [a] , _) -> a + (Plus , [a, b] , _) -> call "add" [a, b] + (Minus , [a, b] , _) -> call "sub" [a, b] + (Times , [a, b] , _) -> call "mul" [a, b] + (UNeg , [a] , _) -> call "neg" [a] + (Abs , [a] , _) -> call "abs" [a] + (And , [a, b] , _) -> call "and" [a, b] + (Or , [a, b] , _) -> call "or" [a, b] + (XOr , [a, b] , _) -> call "xor" [a, b] + (Not , [a] , _) -> call "not" [a] + (Equal _ , [a, b] , x:_) -> argCall x "eq" [a, b] + (NotEqual , as , x:_) -> fsep $ punctuate (text " &&") + [text "!" P.<> parens (argCall x "eq" [a, b]) + | (a:rest) <- tails as, b <- rest] + (LessThan , [a, b] , x:_) -> argCall x "lt" [a, b] + (GreaterThan , [a, b] , x:_) -> argCall x "lt" [b, a] + (LessEq , [a, b] , x:_) -> text "!" P.<> parens (argCall x "lt" [b, a]) + (GreaterEq , [a, b] , x:_) -> text "!" P.<> parens (argCall x "lt" [a, b]) + (Ite , [c, a, b], _) -> c <+> text "?" <+> a <+> text ":" <+> b + (Quot , [a, b] , _) -> call "quot" [a, b] + (Rem , [a, b] , _) -> call "rem" [a, b] + (Shl , [a, n] , x:_) -> argCall x "shl" [a, argCall x "shift_amount" [n]] + (Shr , [a, n] , x:_) -> argCall x (if hasSign x then "ashr" else "lshr") [a, argCall x "shift_amount" [n]] + (Rol n , [a] , _) -> call "rotl" [a, integer (fromIntegral n)] + (Ror n , [a] , _) -> call "rotr" [a, integer (fromIntegral n)] + (Extract hi lo , [a] , x:_) -> namedCall (extractName (kindOf x) hi lo resultKind) [a] + (Join , [a, b] , [x, y]) -> namedCall (joinName (kindOf x) (kindOf y) resultKind) [a, b] + (ZeroExtend _ , [a] , x:_) -> namedCall (convertName False (kindOf x) resultKind) [a] + (SignExtend _ , [a] , x:_) -> namedCall (convertName True (kindOf x) resultKind) [a] + (OverflowOp ov , as , x:_) -> argCall x (overflowName ov) as + (IEEEFP (FP_Reinterpret fr to) , [a] , _) + | isBounded fr && isBounded to -> namedCall (convertName False fr to) [a] + _ -> error $ "SBV->C: exact bit-vector lowering does not yet support " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + where call suffix = namedCall (prefix resultKind ++ "_" ++ suffix) + argCall sv suffix = namedCall (prefix (kindOf sv) ++ "_" ++ suffix) + +-- | Lower casts between native or limb-backed bit-vectors, including explicit +-- native integer mappings. Resolve only the representations: the source's +-- signedness controls extension, and narrowing preserves the target's low bits. +bitVectorCastExpr :: Maybe Int -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +bitVectorCastExpr integerWidth (KindCast fr to) [source] resultKind [value] + | fr == kindOf source + , to == resultKind + , isBounded from + , isBounded target + = Just $ expressionLowering [CRequiresWideBV | isWideBV from || isWideBV target] + $ namedCall (convertName (hasSign from) from target) [value] + where from = mappedIntegerKind integerWidth fr + target = mappedIntegerKind integerWidth to +bitVectorCastExpr _ _ _ _ _ = Nothing + +-- | Lower native-width arithmetic, conversion, and bit manipulation through +-- exact bit-vector helpers. This avoids C's signed-overflow, promotion, +-- signed-shift, and oversized-shift behavior while retaining the scalar +-- public ABI. Explicitly mapped integers share the modular arithmetic helpers, +-- with separate Euclidean division helpers matching their symbolic operations. +nativeBVExpr :: Maybe Int -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +nativeBVExpr integerWidth op svs resultKind args = case (op, svs, args) of + (Extract hi lo , [source] , [renderedSource]) + | isNativeBV source + , isNativeBVKind resultKind + -> lower $ namedCall (extractName (kindOf source) hi lo resultKind) [renderedSource] + (Join , [high, low], [renderedHigh, renderedLow]) + | isNativeBV high + , isNativeBV low + , isNativeBVKind resultKind + -> lower $ namedCall (joinName (kindOf high) (kindOf low) resultKind) [renderedHigh, renderedLow] + (ZeroExtend _ , [source] , [renderedSource]) + | isNativeBV source + , isNativeBVKind resultKind + -> lower $ namedCall (convertName False (kindOf source) resultKind) [renderedSource] + (SignExtend _ , [source] , [renderedSource]) + | isNativeBV source + , isNativeBVKind resultKind + -> lower $ namedCall (convertName True (kindOf source) resultKind) [renderedSource] + (Plus , [left, right] , [renderedLeft, renderedRight]) + | nativeBinary left right + -> arithmetic SpecialAdd [renderedLeft, renderedRight] + (Minus , [left, right] , [renderedLeft, renderedRight]) + | nativeBinary left right + -> arithmetic SpecialSub [renderedLeft, renderedRight] + (Times , [left, right] , [renderedLeft, renderedRight]) + | nativeBinary left right + -> arithmetic SpecialMul [renderedLeft, renderedRight] + (UNeg , [source] , [renderedSource]) + | nativeUnary source + -> arithmetic SpecialNeg [renderedSource] + (Abs , [source] , [renderedSource]) + | nativeUnary source + -> arithmetic SpecialAbs [renderedSource] + (Quot , [left, right] , [renderedLeft, renderedRight]) + | nativeBinary left right + -> arithmetic SpecialQuot [renderedLeft, renderedRight] + (Rem , [left, right] , [renderedLeft, renderedRight]) + | nativeBinary left right + -> arithmetic SpecialRem [renderedLeft, renderedRight] + (Shl , [source, amount], [renderedSource, renderedAmount]) + | isNativeBV source + , isNativeBV amount + , kindOf source == resultKind + -> lower $ namedCall (prefix resultKind ++ "_shl") [renderedSource, renderedAmount] + (Shr , [source, amount], [renderedSource, renderedAmount]) + | isNativeBV source + , isNativeBV amount + , kindOf source == resultKind + -> lower $ namedCall (prefix resultKind ++ if hasSign source then "_ashr" else "_lshr") [renderedSource, renderedAmount] + (Rol amount , [source] , [renderedSource]) + | isNativeBV source + , kindOf source == resultKind + -> lower $ namedCall (prefix resultKind ++ "_rotl") [renderedSource, integer (fromIntegral amount)] + (Ror amount , [source] , [renderedSource]) + | isNativeBV source + , kindOf source == resultKind + -> lower $ namedCall (prefix resultKind ++ "_rotr") [renderedSource, integer (fromIntegral amount)] + _ -> Nothing + where lower = Just . expressionLowering [] + + arithmeticKind = mappedIntegerKind integerWidth resultKind + + nativeUnary source = isNativeBVKind arithmeticKind && kindOf source == resultKind + + nativeBinary left right = nativeUnary left && kindOf right == resultKind + + arithmetic arith = lower . namedCall (prefix arithmeticKind ++ "_" ++ arithmeticSuffix (integerArithmetic resultKind arith)) + +-- | Select the integer representation used by arithmetic and conversion +-- helpers without changing the symbolic graph or its operation semantics. +mappedIntegerKind :: Maybe Int -> Kind -> Kind +mappedIntegerKind (Just bits) KUnbounded = KBounded True bits +mappedIntegerKind _ kind = kind + +-- | Integer division in the symbolic graph is Euclidean, even when a native +-- representation is selected. Bit-vector division remains truncating. +integerArithmetic :: Kind -> NativeArithmetic -> NativeArithmetic +integerArithmetic KUnbounded SpecialQuot = SpecialEuclideanQuot +integerArithmetic KUnbounded SpecialRem = SpecialEuclideanRem +integerArithmetic _ arith = arith + +-- | Lower overflow predicates for scalar C bit-vector representations. The +-- one-bit unsigned case follows its Boolean truth table; wider native cases +-- avoid evaluating the overflowing operation itself, including signed +-- division of the minimum value by -1. +nativeBVOverflowExpr :: Op -> [SV] -> [Doc] -> Maybe CLowering +nativeBVOverflowExpr (OverflowOp ov) svs args + | x:_ <- svs + , let k = kindOf x + , k == KBounded False 1 + = Just . expressionLowering [] $ case (ov, args) of + (PlusOv False, [a, b]) -> a .&&. b + (SubOv False, [a, b]) -> parens (text "!" P.<> a) .&&. b + (MulOv False, [_, _]) -> text "false" + (DivOv , [_, _]) -> text "false" + (NegOv , [_]) -> text "false" + _ -> error $ "SBV->C: One-bit overflow operation is invalid or has an unexpected arity: " ++ show ov + | x:_ <- svs + , let k = kindOf x + , isBounded k + , not (isWideBV k) + , intSizeOf k `elem` [8, 16, 32, 64] + = Just . expressionLowering [] $ case (ov, args) of + (PlusOv False, [a, b]) -> a .>. (maximumValue k .-. b) + (PlusOv True , [a, b]) -> signedAdd k a b + (SubOv False, [a, b]) -> a .<. b + (SubOv True , [a, b]) -> signedSub k a b + (MulOv False, [a, b]) -> (b ./=. zero) .&&. (a .>. (maximumValue k ./. b)) + (MulOv True , [a, b]) -> signedMul k a b + (DivOv , [a, b]) -> (a .==. minimumValue k) .&&. (b .==. negativeOne) + (NegOv , [a]) -> a .==. minimumValue k + _ -> error $ "SBV->C: Overflow operation has an unexpected arity: " ++ show ov + | True = Nothing + where x .<. y = parens (x <+> text "<" <+> y) + x .>. y = parens (x <+> text ">" <+> y) + x .==. y = parens (x <+> text "==" <+> y) + x ./=. y = parens (x <+> text "!=" <+> y) + x .&&. y = parens (x <+> text "&&" <+> y) + x .||. y = parens (x <+> text "||" <+> y) + x .+. y = parens (x <+> text "+" <+> y) + x .-. y = parens (x <+> text "-" <+> y) + x ./. y = parens (x <+> text "/" <+> y) + + zero = text "0" + negativeOne = text "-1" + + signedAdd k a b = ((b .>. zero) .&&. (a .>. (maximumValue k .-. b))) + .||. ((b .<. zero) .&&. (a .<. (minimumValue k .-. b))) + + signedSub k a b = ((b .<. zero) .&&. (a .>. (maximumValue k .+. b))) + .||. ((b .>. zero) .&&. (a .<. (minimumValue k .+. b))) + + signedMul k a b = ((a .>. zero) .&&. (((b .>. zero) .&&. (a .>. (maximumValue k ./. b))) + .||. ((b .<. zero) .&&. (b .<. (minimumValue k ./. a))))) + .||. ((a .<. zero) .&&. (((b .>. zero) .&&. (a .<. (minimumValue k ./. b))) + .||. ((b .<. zero) .&&. (b .<. (maximumValue k ./. a))))) + + minimumValue k = text $ "INT" ++ show (intSizeOf k) ++ "_MIN" + maximumValue k = text $ (if hasSign k then "INT" else "UINT") ++ show (intSizeOf k) ++ "_MAX" +nativeBVOverflowExpr _ _ _ = Nothing + +-- | Print a wide value without requiring a printf conversion specifier. +wideBVPrint :: Kind -> Doc -> Doc +wideBVPrint k value = namedCall (prefix k ++ "_fprint") [text "stdout", value] + +-- | Test whether a wide bit-vector is a valid zero-based index below the +-- supplied table length. +wideBVLookupInRange :: Kind -> Int -> Doc -> Doc +wideBVLookupInRange k len value = namedCall (prefix k ++ "_index_in_range") [value, integer (fromIntegral len)] + +-- | Convert a wide bit-vector known to be in range to a native C table index. +wideBVLookupIndex :: Kind -> Doc -> Doc +wideBVLookupIndex k value = namedCall (prefix k ++ "_index") [value] + +-- | Compare two wide bit-vectors for exact bit-pattern equality. +wideBVEqual :: Kind -> Doc -> Doc -> Doc +wideBVEqual k left right = namedCall (prefix k ++ "_eq") [left, right] + +-- | Canonicalize an externally supplied wide value by clearing unused bits in +-- its most-significant limb. +wideBVNormalize :: Kind -> Doc -> Doc +wideBVNormalize k value = namedCall (prefix k ++ "_norm") [value] + +-- | Cross-width helpers discovered while walking the symbolic DAG. +data Special = SpecialExtract Kind Int Int Kind + | SpecialJoin Kind Kind Kind + | SpecialConvert Bool Kind Kind + | SpecialRotate Kind + | SpecialShift Kind + | SpecialArithmetic NativeArithmetic Kind + deriving (Eq) + +-- | Native scalar arithmetic operations that require exact modular C +-- helpers. +data NativeArithmetic = SpecialAdd + | SpecialSub + | SpecialMul + | SpecialNeg + | SpecialAbs + | SpecialQuot + | SpecialRem + | SpecialEuclideanQuot + | SpecialEuclideanRem + deriving (Eq) + +-- | Emit one exact native-width arithmetic helper. Modular operations are +-- evaluated through unsigned bits; signed division is guarded against both +-- zero divisors and the otherwise undefined minimum-value quotient. +nativeArithmeticRuntime :: NativeArithmetic -> Kind -> [String] +nativeArithmeticRuntime arith kind = + ["static inline " ++ ty ++ " " ++ functionName ++ "(" ++ parameters ++ ")" + , "{" + ] + ++ body + ++ ["}", ""] + where ty = cType kind + rawTy = cType (KBounded False width) + width = bitWidth kind + mask = u64 (topMask kind) + signMask = u64 (1 `shiftL` (width - 1)) + functionName = prefix kind ++ "_" ++ arithmeticSuffix arith + parameters + | arith `elem` [SpecialNeg, SpecialAbs] = ty ++ " a" + | True = ty ++ " a, " ++ ty ++ " b" + + raw value = "((uint64_t) (" ++ rawTy ++ ") " ++ value ++ ")" + + modular expression = + (" const " ++ rawTy ++ " bits = (" ++ rawTy ++ ") ((" ++ expression ++ ") & " ++ mask ++ ");") + : returnBits "bits" + + returnBits bits + | hasSign kind = [" " ++ ty ++ " result; memcpy(&result, &" ++ bits ++ ", sizeof result); return result;"] + | True = [" return (" ++ ty ++ ") " ++ bits ++ ";"] + + body = case arith of + SpecialAdd -> modular (raw "a" ++ " + " ++ raw "b") + SpecialSub -> modular (raw "a" ++ " - " ++ raw "b") + SpecialMul -> modular (raw "a" ++ " * " ++ raw "b") + SpecialNeg -> modular ("UINT64_C(0) - " ++ raw "a") + SpecialAbs + | hasSign kind -> modular ("(" ++ raw "a" ++ " & " ++ signMask ++ ") != 0 ? UINT64_C(0) - " ++ raw "a" ++ " : " ++ raw "a") + | True -> modular (raw "a") + SpecialQuot -> divisionBody "/" ("(" ++ ty ++ ") 0") "a" + SpecialRem -> divisionBody "%" "a" ("(" ++ ty ++ ") 0") + SpecialEuclideanQuot -> euclideanBody True + SpecialEuclideanRem -> euclideanBody False + + -- Once zero and minimum/-1 are excluded, both division and its + -- Euclidean correction fit the signed type. Subtract the negative + -- divisor directly so its minimum value is never negated. + euclideanBody quotient = + [ " if (b == (" ++ ty ++ ") 0) return a;" + , " if (a == " ++ minimumValue ++ " && b == (" ++ ty ++ ") -1) return " ++ (if quotient then "a" else "0") ++ ";" + , " const " ++ ty ++ " remainder = (" ++ ty ++ ") (a % b);" + ] + ++ if quotient + then [ " const " ++ ty ++ " quotient = (" ++ ty ++ ") (a / b);" + , " return remainder < 0 ? (b > 0 ? quotient - 1 : quotient + 1) : quotient;" + ] + else [ " return remainder < 0 ? (b > 0 ? remainder + b : remainder - b) : remainder;" + ] + + divisionBody operator zeroResult overflowResult = + [" if (b == (" ++ ty ++ ") 0) return " ++ zeroResult ++ ";"] + ++ signedOverflow + ++ [" return (" ++ ty ++ ") (a " ++ operator ++ " b);"] + where signedOverflow + | hasSign kind = [" if (a == " ++ minimumValue ++ " && b == (" ++ ty ++ ") -1) return " ++ overflowResult ++ ";"] + | True = [] + + minimumValue = "INT" ++ show width ++ "_MIN" + +-- | Return the generated helper suffix for exact native arithmetic. +arithmeticSuffix :: NativeArithmetic -> String +arithmeticSuffix SpecialAdd = "add" +arithmeticSuffix SpecialSub = "sub" +arithmeticSuffix SpecialMul = "mul" +arithmeticSuffix SpecialNeg = "neg" +arithmeticSuffix SpecialAbs = "abs" +arithmeticSuffix SpecialQuot = "quot" +arithmeticSuffix SpecialRem = "rem" +arithmeticSuffix SpecialEuclideanQuot = "equot" +arithmeticSuffix SpecialEuclideanRem = "erem" + +-- | Emit exact native-width rotations through an unsigned representation so +-- the result is independent of integer promotions and signed-shift rules. +rotationRuntime :: Kind -> [String] +rotationRuntime kind = + signedConversion + ++ ["static inline " ++ ty ++ " " ++ p ++ "_rotl(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " amount %= " ++ show width ++ ";" + , " if (amount == 0) return a;" + , " return " ++ finish ("(" ++ rawTy ++ ") ((((uint64_t) (" ++ rawTy ++ ") a) << amount) | (((uint64_t) (" ++ rawTy ++ ") a) >> (" ++ show width ++ " - amount)))") ++ ";" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_rotr(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " amount %= " ++ show width ++ ";" + , " if (amount == 0) return a;" + , " return " ++ finish ("(" ++ rawTy ++ ") ((((uint64_t) (" ++ rawTy ++ ") a) >> amount) | (((uint64_t) (" ++ rawTy ++ ") a) << (" ++ show width ++ " - amount)))") ++ ";" + , "}" + , "" + ] + where ty = cType kind + p = prefix kind + width = bitWidth kind + rawTy = cType (KBounded False width) + conversionName = p ++ "_rotate_from_bits" + signedConversion + | hasSign kind = ["static inline " ++ ty ++ " " ++ conversionName ++ "(" ++ rawTy ++ " bits)" + , "{ " ++ ty ++ " result; memcpy(&result, &bits, sizeof result); return result; }" + , ""] + | True = [] + finish value + | hasSign kind = conversionName ++ "(" ++ value ++ ")" + | True = value + +-- | Emit exact native-width logical and arithmetic shifts. The shift amount +-- is interpreted as an unsigned bit-vector, and amounts at least as large as +-- the operand width produce SMT-Lib's defined zero or sign-filled result. +shiftRuntime :: Kind -> [String] +shiftRuntime kind = + signedConversion + ++ leftShift + ++ rightShift + where ty = cType kind + p = prefix kind + width = bitWidth kind + rawTy = cType (KBounded False width) + amountValue = "(uint64_t) (" ++ rawTy ++ ") amount" + mask = u64 (topMask kind) + signMask = u64 (1 `shiftL` (width - 1)) + conversionName = p ++ "_shift_from_bits" + signedConversion + | hasSign kind = ["static inline " ++ ty ++ " " ++ conversionName ++ "(" ++ rawTy ++ " bits)" + , "{ " ++ ty ++ " result; memcpy(&result, &bits, sizeof result); return result; }" + , ""] + | True = [] + finish value + | hasSign kind = conversionName ++ "(" ++ value ++ ")" + | True = value + leftShift = ["static inline " ++ ty ++ " " ++ p ++ "_shl(" ++ ty ++ " a, " ++ ty ++ " amount)" + , "{" + , " const uint64_t n = " ++ amountValue ++ ";" + , " const " ++ rawTy ++ " result = n >= " ++ show width ++ " ? (" ++ rawTy ++ ") 0 : (" ++ rawTy ++ ") ((uint64_t) (" ++ rawTy ++ ") a << n);" + , " return " ++ finish "result" ++ ";" + , "}" + , ""] + rightShift + | hasSign kind = ["static inline " ++ ty ++ " " ++ p ++ "_ashr(" ++ ty ++ " a, " ++ ty ++ " amount)" + , "{" + , " const uint64_t n = " ++ amountValue ++ ";" + , " const uint64_t raw = (uint64_t) (" ++ rawTy ++ ") a;" + , " const bool sign = (raw & " ++ signMask ++ ") != 0;" + , " " ++ rawTy ++ " result;" + , " if (n >= " ++ show width ++ ") result = sign ? (" ++ rawTy ++ ") " ++ mask ++ " : (" ++ rawTy ++ ") 0;" + , " else { result = (" ++ rawTy ++ ") (raw >> n); if (sign && n != 0) result = (" ++ rawTy ++ ") ((uint64_t) result | (" ++ mask ++ " << (" ++ show width ++ " - n))); }" + , " return " ++ finish "result" ++ ";" + , "}" + , ""] + | True = ["static inline " ++ ty ++ " " ++ p ++ "_lshr(" ++ ty ++ " a, " ++ ty ++ " amount)" + , "{" + , " const uint64_t n = " ++ amountValue ++ ";" + , " return n >= " ++ show width ++ " ? (" ++ ty ++ ") 0 : (" ++ ty ++ ") ((uint64_t) (" ++ rawTy ++ ") a >> n);" + , "}" + , ""] + +-- | Emit the complete modular-arithmetic runtime for one bit-vector kind. +coreRuntime :: Kind -> [String] +coreRuntime k = + ["static inline " ++ ty ++ " " ++ p ++ "_zero(void)" + , "{" + , " " ++ ty ++ " r = {{0}};" + , " return r;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_norm(" ++ ty ++ " a)" + , "{" + , " a.limb[" ++ show (n - 1) ++ "] &= " ++ u64 mask ++ ";" + , " return a;" + , "}" + , "" + , "static inline bool " ++ p ++ "_get(" ++ ty ++ " a, uint64_t bit)" + , "{" + , " return bit < " ++ show w ++ " && ((a.limb[bit / 64] >> (bit % 64)) & UINT64_C(1)) != 0;" + , "}" + , "" + , "static inline void " ++ p ++ "_set(" ++ ty ++ " *a, uint64_t bit, bool value)" + , "{" + , " const uint64_t m = UINT64_C(1) << (bit % 64);" + , " if (value) { a->limb[bit / 64] |= m; } else { a->limb[bit / 64] &= ~m; }" + , "}" + , "" + , "static inline bool " ++ p ++ "_is_zero(" ++ ty ++ " a)" + , "{" + , " uint64_t v = 0;" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) { v |= a.limb[i]; }" + , " return v == 0;" + , "}" + , "" + , "static inline bool " ++ p ++ "_eq(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " uint64_t v = 0;" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) { v |= a.limb[i] ^ b.limb[i]; }" + , " return v == 0;" + , "}" + , "" + , "static inline int " ++ p ++ "_cmpu(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " size_t i = " ++ show n ++ ";" + , " while (i-- > 0) { if (a.limb[i] < b.limb[i]) return -1; if (a.limb[i] > b.limb[i]) return 1; }" + , " return 0;" + , "}" + , "" + , "static inline bool " ++ p ++ "_lt(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + ] + ++ signedCompare + ++ ["}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_add(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " r;" + , " uint64_t carry = 0;" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) {" + , " uint64_t s = a.limb[i] + b.limb[i];" + , " uint64_t c1 = s < a.limb[i];" + , " uint64_t t = s + carry;" + , " uint64_t c2 = t < s;" + , " r.limb[i] = t; carry = c1 | c2;" + , " }" + , " return " ++ p ++ "_norm(r);" + , "}" + , "" + , "static inline uint64_t " ++ p ++ "_index(" ++ ty ++ " a)" + , "{" + , " return a.limb[0];" + , "}" + , "" + , "static inline bool " ++ p ++ "_index_in_range(" ++ ty ++ " a, uint64_t limit)" + , "{" + , " size_t i;" + , " for (i = 1; i < " ++ show n ++ "; ++i) if (a.limb[i] != UINT64_C(0)) return false;" + , " return a.limb[0] < limit;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_sub(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " r;" + , " uint64_t borrow = 0;" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) {" + , " uint64_t d = a.limb[i] - b.limb[i];" + , " uint64_t b1 = a.limb[i] < b.limb[i];" + , " uint64_t t = d - borrow;" + , " uint64_t b2 = d < borrow;" + , " r.limb[i] = t; borrow = b1 | b2;" + , " }" + , " return " ++ p ++ "_norm(r);" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_not(" ++ ty ++ " a)" + , "{" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) { a.limb[i] = ~a.limb[i]; }" + , " return " ++ p ++ "_norm(a);" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_neg(" ++ ty ++ " a)" + , "{" + , " " ++ ty ++ " one = " ++ p ++ "_zero(); one.limb[0] = 1;" + , " return " ++ p ++ "_add(" ++ p ++ "_not(a), one);" + , "}" + , "" + ] + ++ concatMap bitwise [("and", "&"), ("or", "|"), ("xor", "^")] + ++ ["static inline " ++ ty ++ " " ++ p ++ "_shl(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " " ++ ty ++ " r = " ++ p ++ "_zero();" + , " uint64_t ws, bs; size_t i;" + , " if (amount >= " ++ show w ++ ") return r;" + , " ws = amount / 64; bs = amount % 64;" + , " for (i = " ++ show n ++ "; i-- > ws;) {" + , " r.limb[i] = a.limb[i - ws] << bs;" + , " if (bs != 0 && i > ws) r.limb[i] |= a.limb[i - ws - 1] >> (64 - bs);" + , " }" + , " return " ++ p ++ "_norm(r);" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_lshr(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " " ++ ty ++ " r = " ++ p ++ "_zero();" + , " uint64_t ws, bs; size_t i;" + , " if (amount >= " ++ show w ++ ") return r;" + , " ws = amount / 64; bs = amount % 64;" + , " for (i = 0; i + ws < " ++ show n ++ "; ++i) {" + , " r.limb[i] = a.limb[i + ws] >> bs;" + , " if (bs != 0 && i + ws + 1 < " ++ show n ++ ") r.limb[i] |= a.limb[i + ws + 1] << (64 - bs);" + , " }" + , " return " ++ p ++ "_norm(r);" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_ashr(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " " ++ ty ++ " r = " ++ p ++ "_zero(); uint64_t i;" + , " const bool sign = " ++ p ++ "_get(a, " ++ show (w - 1) ++ ");" + , " for (i = 0; i < " ++ show w ++ "; ++i) { " ++ p ++ "_set(&r, i, i + amount < " ++ show w ++ " ? " ++ p ++ "_get(a, i + amount) : sign); }" + , " return r;" + , "}" + , "" + , "static inline uint64_t " ++ p ++ "_shift_amount(" ++ ty ++ " a)" + , "{" + , " size_t i;" + , " for (i = 1; i < " ++ show n ++ "; ++i) if (a.limb[i] != 0) return " ++ show w ++ ";" + , " return a.limb[0] < " ++ show w ++ " ? a.limb[0] : " ++ show w ++ ";" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_rotl(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " amount %= " ++ show w ++ ";" + , " return amount == 0 ? a : " ++ p ++ "_or(" ++ p ++ "_shl(a, amount), " ++ p ++ "_lshr(a, " ++ show w ++ " - amount));" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_rotr(" ++ ty ++ " a, uint64_t amount)" + , "{" + , " amount %= " ++ show w ++ ";" + , " return amount == 0 ? a : " ++ p ++ "_or(" ++ p ++ "_lshr(a, amount), " ++ p ++ "_shl(a, " ++ show w ++ " - amount));" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_mul(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " r = " ++ p ++ "_zero(); uint64_t bit;" + , " for (bit = 0; bit < " ++ show w ++ "; ++bit) {" + , " " ++ ty ++ " selected; uint64_t mask = UINT64_C(0) - (uint64_t) " ++ p ++ "_get(b, bit); size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) selected.limb[i] = a.limb[i] & mask;" + , " r = " ++ p ++ "_add(r, selected); a = " ++ p ++ "_shl(a, 1);" + , " }" + , " return r;" + , "}" + , "" + , "static inline void " ++ p ++ "_udivrem(" ++ ty ++ " a, " ++ ty ++ " b, " ++ ty ++ " *q, " ++ ty ++ " *r)" + , "{" + , " uint64_t bit; *q = " ++ p ++ "_zero(); *r = " ++ p ++ "_zero();" + , " if (" ++ p ++ "_is_zero(b)) { *r = a; return; }" + , " for (bit = " ++ show w ++ "; bit-- > 0;) {" + , " *r = " ++ p ++ "_shl(*r, 1); " ++ p ++ "_set(r, 0, " ++ p ++ "_get(a, bit));" + , " if (" ++ p ++ "_cmpu(*r, b) >= 0) { *r = " ++ p ++ "_sub(*r, b); " ++ p ++ "_set(q, bit, true); }" + , " }" + , "}" + , "" + ] + ++ division + ++ ["static inline " ++ ty ++ " " ++ p ++ "_abs(" ++ ty ++ " a)" + , "{" + , if hasSign k then " return " ++ p ++ "_get(a, " ++ show (w - 1) ++ ") ? " ++ p ++ "_neg(a) : a;" else " return a;" + , "}" + , "" + ] + ++ overflowRuntime + where ty = cType k + p = prefix k + w = intSizeOf k + n = limbs k + mask = topMask k + + signedCompare + | hasSign k = [" const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ ");" + , " const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " return sa != sb ? sa : " ++ p ++ "_cmpu(a, b) < 0;"] + | True = [" return " ++ p ++ "_cmpu(a, b) < 0;"] + + bitwise (nm, op) = + ["static inline " ++ ty ++ " " ++ p ++ "_" ++ nm ++ "(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) { a.limb[i] " ++ op ++ "= b.limb[i]; }" + , " return " ++ p ++ "_norm(a);" + , "}" + , ""] + + division + | hasSign k = + ["static inline " ++ ty ++ " " ++ p ++ "_quot(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " q, r; const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ "); const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " " ++ p ++ "_udivrem(sa ? " ++ p ++ "_neg(a) : a, sb ? " ++ p ++ "_neg(b) : b, &q, &r);" + , " return sa != sb ? " ++ p ++ "_neg(q) : q;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_rem(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " q, r; const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ "); const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " " ++ p ++ "_udivrem(sa ? " ++ p ++ "_neg(a) : a, sb ? " ++ p ++ "_neg(b) : b, &q, &r);" + , " return sa ? " ++ p ++ "_neg(r) : r;" + , "}" + , ""] + | True = + ["static inline " ++ ty ++ " " ++ p ++ "_quot(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ " ++ ty ++ " q, r; " ++ p ++ "_udivrem(a, b, &q, &r); return q; }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_rem(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ " ++ ty ++ " q, r; " ++ p ++ "_udivrem(a, b, &q, &r); return r; }" + , ""] + + overflowRuntime = + ["static inline bool " ++ p ++ "_is_min(" ++ ty ++ " a)" + , "{" + , " " ++ ty ++ " m = " ++ p ++ "_zero();" + , " " ++ p ++ "_set(&m, " ++ show (w - 1) ++ ", true);" + , " return " ++ p ++ "_eq(a, m);" + , "}" + , "" + , "static inline bool " ++ p ++ "_uaddo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " return " ++ p ++ "_cmpu(" ++ p ++ "_add(a, b), a) < 0;" + , "}" + , "" + , "static inline bool " ++ p ++ "_saddo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " const " ++ ty ++ " r = " ++ p ++ "_add(a, b);" + , " const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ ");" + , " const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " const bool sr = " ++ p ++ "_get(r, " ++ show (w - 1) ++ ");" + , " return sa == sb && sa != sr;" + , "}" + , "" + , "static inline bool " ++ p ++ "_usubo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " return " ++ p ++ "_cmpu(a, b) < 0;" + , "}" + , "" + , "static inline bool " ++ p ++ "_ssubo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " const " ++ ty ++ " r = " ++ p ++ "_sub(a, b);" + , " const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ ");" + , " const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " const bool sr = " ++ p ++ "_get(r, " ++ show (w - 1) ++ ");" + , " return sa != sb && sa != sr;" + , "}" + , "" + , "static inline bool " ++ p ++ "_umulo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " q, r;" + , " if (" ++ p ++ "_is_zero(b)) return false;" + , " " ++ p ++ "_udivrem(" ++ p ++ "_mul(a, b), b, &q, &r);" + , " return !" ++ p ++ "_eq(q, a);" + , "}" + , "" + , "static inline bool " ++ p ++ "_smulo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " " ++ ty ++ " q, r, limit = " ++ p ++ "_zero();" + , " const bool sa = " ++ p ++ "_get(a, " ++ show (w - 1) ++ ");" + , " const bool sb = " ++ p ++ "_get(b, " ++ show (w - 1) ++ ");" + , " const bool negative = sa != sb;" + , " uint64_t bit;" + , " if (sa) a = " ++ p ++ "_neg(a);" + , " if (sb) b = " ++ p ++ "_neg(b);" + , " if (" ++ p ++ "_is_zero(a) || " ++ p ++ "_is_zero(b)) return false;" + , " if (negative) " ++ p ++ "_set(&limit, " ++ show (w - 1) ++ ", true);" + , " else for (bit = 0; bit < " ++ show (w - 1) ++ "; ++bit) " ++ p ++ "_set(&limit, bit, true);" + , " " ++ p ++ "_udivrem(limit, b, &q, &r);" + , " return " ++ p ++ "_cmpu(a, q) > 0;" + , "}" + , "" + , "static inline bool " ++ p ++ "_sdivo(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " return " ++ p ++ "_is_min(a) && " ++ p ++ "_eq(b, " ++ p ++ "_not(" ++ p ++ "_zero()));" + , "}" + , "" + , "static inline bool " ++ p ++ "_snego(" ++ ty ++ " a)" + , "{" + , " return " ++ p ++ "_is_min(a);" + , "}" + , ""] + +-- | Emit a bit-preserving extraction, extension, or integral conversion. +conversionRuntime :: String -> Bool -> Int -> Kind -> Kind -> [String] +conversionRuntime nm signExtend sourceOffset fr to = + ["static inline " ++ cType to ++ " " ++ nm ++ "(" ++ cType fr ++ " a)" + , "{" + , " " ++ cType to ++ " r = " ++ zeroValue to ++ ";" + , " uint64_t i;" + , " for (i = 0; i < " ++ show copied ++ "; ++i) { " ++ setBit to "r" "i" (getBit fr "a" (offset "i")) ++ " }" + ] + ++ extension + ++ [" return " ++ normalize to "r" ++ ";" + , "}" + , ""] + where available = max 0 (bitWidth fr - sourceOffset) + copied = min available (bitWidth to) + offset i = if sourceOffset == 0 then i else i ++ " + " ++ show sourceOffset + extension + | signExtend && bitWidth to > copied = + [" if (" ++ getBit fr "a" (show (bitWidth fr - 1)) ++ ") for (i = " ++ show copied ++ "; i < " ++ show (bitWidth to) ++ "; ++i) { " ++ setBit to "r" "i" "true" ++ " }"] + | True = [] + +-- | Emit concatenation code for a particular pair of operand kinds. +joinRuntime :: Kind -> Kind -> Kind -> [String] +joinRuntime a b to = + ["static inline " ++ cType to ++ " " ++ joinName a b to ++ "(" ++ cType a ++ " high, " ++ cType b ++ " low)" + , "{" + , " " ++ cType to ++ " r = " ++ zeroValue to ++ "; uint64_t i;" + , " for (i = 0; i < " ++ show (bitWidth b) ++ "; ++i) { " ++ setBit to "r" "i" (getBit b "low" "i") ++ " }" + , " for (i = 0; i < " ++ show (bitWidth a) ++ "; ++i) { " ++ setBit to "r" ("i + " ++ show (bitWidth b)) (getBit a "high" "i") ++ " }" + , " return " ++ normalize to "r" ++ ";" + , "}" + , ""] + +-- | Render a target-independent bit read from a scalar or limb value. +getBit :: Kind -> String -> String -> String +getBit k value bit + | isWideBV k = prefix k ++ "_get(" ++ value ++ ", " ++ bit ++ ")" + | isBoolean k || isBounded k = "((((uint64_t) " ++ value ++ ") >> (" ++ bit ++ ")) & UINT64_C(1)) != 0" + | otherwise = error $ "SBV->C: Cannot extract bits from " ++ show k + +-- | Render a target-independent bit update to a scalar or limb value. +setBit :: Kind -> String -> String -> String -> String +setBit k value bit bitValue + | isWideBV k = prefix k ++ "_set(&" ++ value ++ ", " ++ bit ++ ", " ++ bitValue ++ ");" + | isBoolean k || isBounded k = value ++ " = (" ++ cType k ++ ") ((uint64_t) " ++ value ++ " | ((uint64_t) (" ++ bitValue ++ ") << (" ++ bit ++ ")));" + | otherwise = error $ "SBV->C: Cannot set bits in " ++ show k + +-- | Render the zero value for a scalar or limb representation. +zeroValue :: Kind -> String +zeroValue k + | isWideBV k = prefix k ++ "_zero()" + | isBoolean k || isBounded k = "(" ++ cType k ++ ") 0" + | otherwise = error $ "SBV->C: Cannot construct a zero of " ++ show k + +-- | Render canonicalization for a scalar or limb representation. +normalize :: Kind -> String -> String +normalize k value + | isWideBV k = prefix k ++ "_norm(" ++ value ++ ")" + | isBoolean k || isBounded k = value + | otherwise = error $ "SBV->C: Cannot normalize " ++ show k + +-- | Construct the collision-free name of an extraction helper. +extractName :: Kind -> Int -> Int -> Kind -> String +extractName fr hi lo to = "sbv_bv_extract_" ++ tag fr ++ "_" ++ show hi ++ "_" ++ show lo ++ "_" ++ tag to + +-- | Construct the collision-free name of a concatenation helper. +joinName :: Kind -> Kind -> Kind -> String +joinName a b to = "sbv_bv_join_" ++ tag a ++ "_" ++ tag b ++ "_" ++ tag to + +-- | Construct the collision-free name of an extension/conversion helper. +convertName :: Bool -> Kind -> Kind -> String +convertName sign fr to = "sbv_bv_" ++ (if sign then "sext_" else "zext_") ++ tag fr ++ "_" ++ tag to + +-- | Render a C function call. +namedCall :: String -> [Doc] -> Doc +namedCall nm args = text nm P.<> parens (fsep (punctuate comma args)) + +-- | Select the first operation argument, reporting an internal arity error. +headArg :: String -> [a] -> a +headArg _ (a:_) = a +headArg nm [] = error $ "SBV->C: " ++ nm ++ " unexpectedly has no arguments" + +-- | Report an internal arity error for an operation. +badArity :: String -> [a] -> b +badArity nm _ = error $ "SBV->C: " ++ nm ++ " has an unexpected arity" + +-- | Return the generated helper suffix for an overflow predicate. +overflowName :: OvOp -> String +overflowName (PlusOv False) = "uaddo" +overflowName (PlusOv True) = "saddo" +overflowName (SubOv False) = "usubo" +overflowName (SubOv True) = "ssubo" +overflowName (MulOv False) = "umulo" +overflowName (MulOv True) = "smulo" +overflowName DivOv = "sdivo" +overflowName NegOv = "snego" + +-- | Return the logical bit width used by the C representation. Unlike +-- 'intSizeOf', this is defined for 'KBool', which occupies one logical bit. +bitWidth :: Kind -> Int +bitWidth k + | isBoolean k = 1 + | otherwise = intSizeOf k + +-- | Test whether a symbolic value uses one of the scalar C bit-vector +-- representations, including the one-bit unsigned representation. +isNativeBV :: HasKind a => a -> Bool +isNativeBV value = isNativeBVKind (kindOf value) + +-- | Test whether a kind uses one of the scalar C bit-vector representations. +isNativeBVKind :: Kind -> Bool +isNativeBVKind kind = isBounded kind && not (isWideBV kind) + +-- | Return the number of 64-bit limbs needed by a kind. +limbs :: Kind -> Int +limbs k = (intSizeOf k + 63) `div` 64 + +-- | Return the mask for the final limb of a canonical value. +topMask :: Kind -> Integer +topMask k + | r == 0 = (1 `shiftL` 64) - 1 + | otherwise = (1 `shiftL` r) - 1 + where r = intSizeOf k `mod` 64 + +-- | Return the C type name used for a bit-vector kind. +cType :: Kind -> String +cType KBool = "SBool" +cType (KBounded False 1) = "SBool" +cType (KBounded False w) = "SWord" ++ show w +cType (KBounded True w) = "SInt" ++ show w +cType k = error $ "SBV->C: Expected a C bit-vector type, received " ++ show k + +-- | Return the compact signedness-and-width tag used in generated names. +tag :: Kind -> String +tag KBool = "u1" +tag (KBounded False w) = "u" ++ show w +tag (KBounded True w) = "s" ++ show w +tag k = error $ "SBV->C: Expected a bit-vector tag, received " ++ show k + +-- | Return the namespace prefix for helpers belonging to a kind. +prefix :: Kind -> String +prefix k = "sbv_bv_" ++ tag k + +-- | Render an integer as a padded, portable C @uint64_t@ literal. +u64 :: Integer -> String +u64 i = "UINT64_C(0x" ++ pad 16 (showHex i "") ++ ")" + where pad n s = replicate (n - length s) '0' ++ s diff --git a/Data/SBV/Compilers/C/Backend.hs b/Data/SBV/Compilers/C/Backend.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Backend.hs @@ -0,0 +1,3143 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Backend +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Compilation of symbolic programs to C +----------------------------------------------------------------------------- + +{-# LANGUAGE TupleSections #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Backend(compileToC, compileToCLib, compileToC', compileToCLib') where + +import Data.SBV.Compilers.C.Types (isConcreteADTReference) +import Control.DeepSeq (rnf) +import Data.Char (isAsciiLower, isAsciiUpper, isDigit, isSpace, toLower) +import qualified Data.Foldable as F (toList) +import qualified Data.Graph as DG +import Data.List (intercalate, intersperse, isPrefixOf, nub, sortOn) +import qualified Data.Map.Strict as Map +import Data.Maybe (fromJust, fromMaybe, isJust, isNothing, maybeToList) +import qualified Data.Set as Set (Set, difference, empty, fromList, insert, intersection, map, member, notMember, null, toList, union, unions) +import qualified Data.Text as T +import System.FilePath (replaceExtension, takeBaseName) +import System.Random + +import Data.SBV.Core.Symbolic (LambdaInfo(..), ResultInp(..), ProgInfo(..), SMTDef(SMTDef), smtDefInfo, smtLambdaInfo) + +-- Work around the fact that GHC 8.4.1 started exporting <>.. Hmm.. +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds, kRoundingMode) +import Data.SBV.Compilers.C.ADT +import Data.SBV.Compilers.C.Array +import Data.SBV.Compilers.C.BV +import Data.SBV.Compilers.C.FP +import Data.SBV.Compilers.C.Finite (finiteDomainSize) +import Data.SBV.Compilers.C.GMP +import Data.SBV.Compilers.C.List +import Data.SBV.Compilers.C.Lowering +import Data.SBV.Compilers.C.NonLinear +import Data.SBV.Compilers.C.PseudoBoolean (assignPseudoBoolean) +import Data.SBV.Compilers.C.Real (mappedRealFloorWidth, mappedRealFloorCall, mappedRealFloorRuntime) +import Data.SBV.Compilers.C.RegExp (regexExpr) +import Data.SBV.Compilers.C.Set +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute, cCommentText, cStringLiteral) +import Data.SBV.Compilers.C.Table +import Data.SBV.Compilers.C.Text +import qualified Data.SBV.Compilers.C.Types as CTypes (constElementCType, definedFunctionCName, elementCType, kindTag) +import Data.SBV.Compilers.C.Tuple +import Data.SBV.Compilers.C.Value ( byValueEqual, managedValueClone, managedValueRelease, valueNeedsOwnership + , valueDriverNeedsInitialization, valueDriverInit, valueDriverClear + ) +import Data.SBV.Compilers.CodeGen + +import Data.SBV.Utils.PrettyNum (chex, showCFloat, showCDouble) + +import GHC.Stack + +--------------------------------------------------------------------------- +-- * 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. As a +-- result, we return whatever the code-gen function returns. Most uses should simply have @()@ as +-- the return type here, but the value can be useful if you want to chain the result of +-- one compilation act to the next. +-- Names must obey the public naming contract in "Data.SBV.Tools.CodeGen"; +-- invalid or reserved names are rejected before any files are written. +-- +-- Detected runtime failures in the generated code terminate the calling process; +-- there is no recoverable error-return interface. See the runtime contract in +-- "Data.SBV.Tools.CodeGen". +-- Callers must enter generated code in @FE_TONEAREST@ hardware rounding mode; +-- generated code does not check or change that mode. +compileToC :: Maybe FilePath -> String -> SBVCodeGen a -> IO a +compileToC mbDirName nm f = do (retVal, cfg, bundle) <- compileToC' nm f + renderCgPgmBundle mbDirName (cfg, bundle) + pure retVal + +-- | Lower level version of 'compileToC', producing a t'CgPgmBundle' +compileToC' :: String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle) +compileToC' nm f = do validateCName "function" nm `seq` pure () + rands <- randoms <$> newStdGen + result@(_, _, bundle) <- codeGen SBVToC (defaultCgConfig { cgDriverVals = rands }) nm f + bundle `seq` pure result + +-- | 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. +-- +-- The component list must be nonempty and component names must be distinct. +-- Generated file names and driver entry points must not collide either. +-- As with 'compileToC', detected runtime failures terminate the calling process, +-- including when the generated functions are used as a library. +compileToCLib :: Maybe FilePath -> String -> [(String, SBVCodeGen a)] -> IO [a] +compileToCLib mbDirName libName comps = do (retVal, cfg, pgm) <- compileToCLib' libName comps + renderCgPgmBundle mbDirName (cfg, pgm) + pure retVal + +-- | Lower level version of 'compileToCLib', producing a t'CgPgmBundle' +compileToCLib' :: String -> [(String, SBVCodeGen a)] -> IO ([a], CgConfig, CgPgmBundle) +compileToCLib' libName comps + | null comps + = error "SBV.compileToCLib: A library must contain at least one component." + | not (null duplicates) + = error $ "SBV.compileToCLib: Duplicate component names: " ++ unwords duplicates + | True + = do validateCName "library" libName `seq` pure () + mapM_ (\(fn, _) -> validateCName "component" fn `seq` pure ()) comps + resCfgBundles <- mapM component comps + let (finalCfg, finalPgm) = mergeToLib libName [(c, b) | (_, c, b) <- resCfgBundles] + finalPgm `seq` pure ([r | (r, _, _) <- resCfgBundles], finalCfg, finalPgm) + where duplicates = duplicateNames (map fst comps) + + component (componentName, program) = do + rands <- randoms <$> newStdGen + codeGen SBVToCLibraryComponent (defaultCgConfig { cgDriverVals = rands }) componentName program + +-- | Report each repeated name once, preserving its first occurrence order. +duplicateNames :: [String] -> [String] +duplicateNames names = [nm | nm <- nub names, length (filter (== nm) names) > 1] + +-- | Retain the first value for each key without repeated linear scans or +-- repeated rendering of documents. Original order is significant in C output. +uniqueOn :: Ord key => (value -> key) -> [value] -> [value] +uniqueOn key = go Set.empty + where go _ [] = [] + go seen (value:rest) + | valueKey `Set.member` seen = go seen rest + | True = value : go (Set.insert valueKey seen) rest + where valueKey = key value + +-- | Validate public C names before rendering. Use a portable ASCII spelling, +-- excluding language keywords and namespaces owned by the generated runtime +-- and its headers. User-supplied C declarations remain the caller's responsibility. +validateCName :: String -> String -> () +validateCName role nm + | not validIdentifier = reject "expected an ASCII C identifier" + | nm `elem` keywords = reject "C keyword" + | reserved = reject "reserved C/backend name" + | True = () + where reject reason = error $ "SBV->C: Invalid " ++ role ++ " name " ++ show nm ++ ": " ++ reason ++ "." + letter c = isAsciiLower c || isAsciiUpper c + validIdentifier = case nm of + initial : rest -> (letter initial || initial == '_') && all (\c -> letter c || isDigit c || c == '_') rest + [] -> False + keywords = words ("auto break case char const continue default do double else enum extern float for goto if inline int long register" + ++ " restrict return short signed sizeof static struct switch typedef union unsigned void volatile while alignas alignof" + ++ " bool constexpr false nullptr static_assert thread_local true typeof typeof_unqual") + reserved = any (`isPrefixOf` nm) + ["_", "sbv_", "SBV", "SWord", "SInt", "SFP", "mp_", "mpz_", "mpq_", "mpf_", "gmp_", "bf_", "BF_", "GMP_" + , "FLT_", "DBL_", "LDBL_", "FP_", "FE_", "va_"] + || nm `elem` integerMacros + || nm `elem` words ("SBool SFloat SDouble SReal SRational SChar SString RoundingMode div_t ldiv_t lldiv_t size_t ptrdiff_t intmax_t" + ++ " uintmax_t intptr_t uintptr_t FILE fpos_t NULL EOF stdin stdout stderr BUFSIZ FILENAME_MAX FOPEN_MAX L_tmpnam" + ++ " SEEK_CUR SEEK_END SEEK_SET TMP_MAX EXIT_SUCCESS EXIT_FAILURE RAND_MAX MB_CUR_MAX HUGE_VAL HUGE_VALF HUGE_VALL" + ++ " INFINITY NAN MATH_ERRNO MATH_ERREXCEPT math_errhandling errno limb_t slimb_t fenv_t fexcept_t" + ++ " SIZE_MAX PTRDIFF_MAX PTRDIFF_MIN SIG_ATOMIC_MIN SIG_ATOMIC_MAX WCHAR_MIN WCHAR_MAX WINT_MIN WINT_MAX") + || nm `elem` [sign ++ "int" ++ flavor ++ show bits ++ "_t" | sign <- ["", "u"], flavor <- ["", "_least", "_fast"], bits <- [8, 16, 32, 64 :: Int]] + || (role /= "parameter" && (nm `elem` libraryFunctions || nm `elem` mathFunctions)) + + -- External library identifiers may be shadowed in a prototype's + -- parameter scope, but cannot be redefined as generated entry points. + libraryFunctions = words ("main abort exit quick_exit _Exit atexit at_quick_exit malloc calloc realloc free aligned_alloc abs labs llabs div ldiv" + ++ " lldiv atoi atol atoll atof strtol strtoll strtoul strtoull strtof strtod strtold rand srand" + ++ " getenv system bsearch qsort mblen mbtowc wctomb mbstowcs wcstombs remove rename tmpfile tmpnam fclose fflush fopen" + ++ " freopen setbuf setvbuf fprintf fscanf printf scanf snprintf sprintf sscanf vfprintf vfscanf vprintf vscanf vsnprintf" + ++ " vsprintf vsscanf fgetc fgets fputc fputs getc getchar putc putchar puts ungetc fread fwrite fgetpos fseek fsetpos" + ++ " ftell rewind clearerr feof ferror perror memcpy memmove memcmp memchr memset strcat strncat strchr strrchr strcmp" + ++ " strncmp strcoll strcpy strncpy strcspn strerror strlen strpbrk strspn strstr strtok strxfrm fpclassify isfinite" + ++ " isinf isnan isnormal signbit isgreater isgreaterequal isless islessequal islessgreater isunordered") + mathFunctions = [base ++ suffix | base <- words ("acos asin atan atan2 cos sin tan acosh asinh atanh cosh sinh tanh exp exp2 expm1 frexp ldexp log log10 log1p log2" + ++ " logb modf scalbn scalbln cbrt fabs hypot pow sqrt erf erfc lgamma tgamma ceil floor nearbyint rint lrint llrint" + ++ " round lround llround trunc fmod remainder remquo copysign nan nextafter nexttoward fdim fmax fmin fma"), suffix <- ["", "f", "l"]] + + integerMacros = [sign ++ flavor ++ width ++ suffix + | sign <- ["INT", "UINT"], flavor <- ["", "_LEAST", "_FAST"] + , width <- ["8", "16", "32", "64", "MAX", "PTR"], suffix <- ["_MIN", "_MAX", "_C"]] + ++ [prefix ++ conversion ++ flavor ++ width + | prefix <- ["PRI", "SCN"], conversion <- ["d", "i", "o", "u", "x", "X"] + , flavor <- ["", "LEAST", "FAST"], width <- ["8", "16", "32", "64", "MAX", "PTR"]] + +-- | Bind each public parameter to a disjoint implementation-only name. C +-- parameter names do not affect linkage or the positional calling convention. +privateParameters :: String -> [(String, CgVal)] -> [(String, CgVal)] +privateParameters prefix = zipWith (\index (_, value) -> (prefix ++ show index, value)) [0 :: Int ..] + +--------------------------------------------------------------------------- +-- * Implementation +--------------------------------------------------------------------------- + +-- | C targets differ only in whether optional build metadata must survive +-- until library merging. The user's requested output configuration is retained. +data SBVToC = SBVToC | SBVToCLibraryComponent + +-- | Select the current lowering pipeline, retaining component build metadata +-- until a library's dependencies have been combined. +instance CgTarget SBVToC where + targetName _ = "C" + translate SBVToC = cgen False + translate SBVToCLibraryComponent = cgen True + +-- | Report an unexpected compiler input or violated internal invariant. +die :: String -> a +die msg = error $ "SBV->C: Unexpected: " ++ msg + +-- | Report an operation without an executable lowering. +tbd :: String -> a +tbd msg = error $ "SBV->C: Not yet supported: " ++ msg + +-- | Assemble the generated translation unit, public header, and optional +-- driver and build instructions from the symbolic result. +cgen :: Bool -> CgConfig -> String -> CgState -> Result -> CgPgmBundle +cgen retainBuildMetadata cfg nm st sbvProg + -- Force type declarations, the signature, and the main program so any + -- type-conversion exceptions appear while constructing the bundle. + = foldr (seq . validateCName "parameter") () interfaceNames `seq` + rnf (render extraTypes) `seq` rnf (render sig) `seq` rnf (render (vcat body)) `seq` result + where result = CgPgmBundle bundleKind + $ filt [ ("Makefile" , (CgMakefile flags , [genMake usesFloating (cgGenDriver cfg) nm nmd flags])) + , (nm ++ ".h" , (CgCHeader (CgCHeaderInfo usesFloating extraTypes [sig] extProtos), [genHeader usesFloating bundleKind nm [sig] extProtos extraTypes])) + , (nmd ++ ".c" , (CgDriver , driver)) + , (nm ++ ".c" , (CgSource , body)) + ] + + (body, requirements) = genCProg cfg adts lists sets nm implementationSig sbvProg privateIns privateOuts mbRet extDecls + privateIns = privateParameters "sbv_input_" ins + privateOuts = privateParameters "sbv_output_" allOuts + implementationSig = pprCFunHeader cfg nm privateIns privateOuts mbRet + + bundleKind = (cgInteger cfg, cgReal cfg) + + extraTypes = roundingModeTypeDecls usesRoundingModeType + $$ (if hasRequirement CRequiresWideBV then wideBVTypeDecls (wideBVKinds kinds) else empty) + $$ (if hasRequirement CRequiresLibBF then arbitraryFPTypeDecls (arbitraryFPKinds kinds) else empty) + $$ (if hasRequirement CRequiresGMP then gmpTypeDecls cfg kinds else empty) + $$ (if hasRequirement CRequiresText then textTypeDecls kinds else empty) + $$ (if hasRequirement CRequiresArrays then arrayForwardTypeDecls arrays else empty) + $$ tupleForwardTypeDecls tuples + $$ adtForwardTypeDecls adts + $$ listForwardTypeDecls lists + $$ setForwardTypeDecls sets + $$ (if hasRequirement CRequiresLists then listTypeDecls cfg lists else empty) + $$ (if hasRequirement CRequiresSets then setTypeDecls cfg sets else empty) + $$ structuralTypeDecls cfg adts tuples + $$ adtOwnershipTypePrototypes adts + $$ tupleOwnershipTypeDecls cfg tuples + $$ adtOwnershipTypeDecls cfg adts + $$ (if hasRequirement CRequiresLists then listOwnershipTypeDecls cfg lists else empty) + $$ (if hasRequirement CRequiresSets then setOwnershipTypeDecls cfg sets else empty) + $$ (if hasRequirement CRequiresArrays then arrayTypeDecls arrays else empty) + kinds = Set.unions [reskinds sbvProg, usedKinds] + usesFloating = any (cFloatingKind cfg) kinds + usedKinds = Set.union interfaceKinds (cProgramUsedKinds sbvProg) + interfaceKinds = Set.fromList . concatMap expandKinds + $ concatMap cgValKinds (map snd ins ++ map snd outs ++ cgReturns st) + where cgValKinds (CgAtomic sv) = [kindOf sv] + cgValKinds (CgArray svs) = map kindOf svs + arrays = arrayKinds kinds + lists = listKinds kinds + sets = setKinds kinds + adts = adtKinds kinds usedKinds + tuples = tupleKinds (Set.map (resolveADTReferences adts) kinds) + + hasRequirement requirement = requirement `Set.member` requirements + + usesRoundingModeType = any (any isRoundingMode . expandKinds) kinds + + randVals = cgDriverVals cfg + driver = genDriver cfg adts randVals nm ins allOuts mbRet + + filt xs = [c | c@(_, (k, _)) <- xs, need k] + where need k | isCgDriver k = cgGenDriver cfg + | isCgMakefile k = retainBuildMetadata || cgGenMakefile cfg + | True = True + + nmd = nm ++ "_driver" + sig = pprCFunHeader cfg nm ins allOuts mbRet + ins = cgInputs st + outs = cgOutputs st + allOuts = outs ++ returnOuts + mbRet = case cgReturns st of + [CgAtomic resultSV] -> Just resultSV + _ -> Nothing + + returnOuts = case cgReturns st of + [] -> [] + [CgAtomic{}] -> [] + results -> zipWith (\index returnValue -> (returnName index, returnValue)) [0 :: Int ..] results + + returnName index = availableName 0 + where availableName prefixLength + | candidate `elem` interfaceNames = availableName (prefixLength + 1) + | True = candidate + where candidate = concat (replicate prefixLength "sbv_") ++ "result_" ++ show index + + interfaceNames = map fst (ins ++ outs) + + extProtos = case cgPrototypes st of + [] -> empty + xs -> vcat $ text "/* User given prototypes: */" : map text xs + extDecls = case cgDecls st of + [] -> empty + xs -> vcat $ text "/* User given declarations: */" : map text xs + flags = requirementLDFlags requirements ++ cgLDFlags st + +-- | Collect types used by the entry point and all retained function/lambda +-- bodies. A private computation can construct and consume an ADT without that +-- type appearing in any public signature or top-level assignment. Constants, +-- parameters, and table entries count even when their body has no assignments. +cProgramUsedKinds :: Result -> Set.Set Kind +cProgramUsedKinds result = Set.fromList . concatMap expandKinds $ + assignmentKinds assignments + ++ map (kindOf . fst) (snd (resConsts result)) + ++ tableKinds (resTables result) + ++ concat [lambdaKinds body | (_, (definition, _)) <- resDefinitions result, Just body <- [smtDefInfo definition]] + where SBVPgm program = resAsgns result + assignments = F.toList program + + assignmentKinds expressions = concat + [ map kindOf (value : arguments) + ++ case operation of + ArrayInit (Right lambdaDef) | Just body <- smtLambdaInfo lambdaDef -> lambdaKinds body + _ -> [] + | (value, SBVApp operation arguments) <- expressions] + + lambdaKinds body = map kindOf (liOutput body : map snd (liParams body) ++ map fst (liConsts body)) + ++ assignmentKinds (F.toList (liAssignments body)) + ++ tableKinds (liTables body) + + tableKinds tables = concat [keyKind : valueKind : map kindOf entries | ((_, keyKind, valueKind), entries) <- tables] + +-- | Emit tuple and ADT layouts in their joint by-value dependency order. +-- Forward-declared recursive ADT pointers impose no ordering constraint. +structuralTypeDecls :: CgConfig -> [Kind] -> [Kind] -> Doc +structuralTypeDecls cfg adts tuples = vcat (map declaration orderedKinds) + where allKinds = tuples ++ adts + availableKinds = Set.fromList allKinds + dependencyNodes = [(kind, kind, filter (`Set.member` availableKinds) (dependencies kind)) | kind <- allKinds] + orderedKinds = concatMap orderedComponent (DG.stronglyConnComp dependencyNodes) + + dependencies (KTuple fieldKinds) = [ resolved + | fieldKind <- fieldKinds + , let resolved = resolveADTReferences adts fieldKind + , isTuple resolved || isConcreteADTReference resolved + ] + dependencies kind + | isConcreteADTReference kind = adtDeclarationDependencies adts kind + | True = [] + + orderedComponent (DG.AcyclicSCC kind) = [kind] + orderedComponent (DG.CyclicSCC kinds) = error $ "SBV->C: Recursive by-value tuple/ADT layout: " ++ show kinds + + declaration kind + | isTuple kind = tupleTypeDecls [kind] + | isConcreteADTReference kind = adtTypeDeclsFor cfg adts [kind] + | True = error $ "SBV->C: Expected a tuple or ADT layout, received " ++ show kind + +-- | Pretty print a function type. A single return value uses C's return +-- position when its representation permits; aggregate return groups and +-- multiple returns are passed as output parameters by the caller. +pprCFunHeader :: CgConfig -> String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> Doc +pprCFunHeader cfg fn ins outs mbRet = retType <+> text fn P.<> parens (fsep (punctuate comma params)) + where params = map (mkParam cfg) ins ++ map (mkPParam cfg) outs ++ exactResult + retType = case mbRet of + Just sv | isArray sv -> text (arrayOutputCType (kindOf sv)) + Just sv | not (isExactGMPKind cfg (kindOf sv)) -> pprCWord False sv + _ -> text "void" + + exactResult = case mbRet of + Just sv | isExactGMPKind cfg (kindOf sv) -> [text (gmpOutputType (kindOf sv)) <+> text "sbv_result"] + _ -> [] + +-- | Render a generated C input parameter. +mkParam :: CgConfig -> (String, CgVal) -> Doc +mkParam _ (n, CgAtomic sv) + | isArray sv = text "const" <+> text (arrayInputCType (kindOf sv)) <+> text n +mkParam _ (n, CgAtomic sv) = pprCWord True sv <+> text n +mkParam _ (_, CgArray []) = die "mkParam: CgArray with no elements!" +mkParam cfg (n, CgArray (sv:_)) + | isExactGMPKind cfg kind = text "const" <+> text (gmpArrayType kind) <+> text "*" P.<> text n + | isArray kind = text "const" <+> text (arrayInputCType kind) <+> text "*" P.<> text n + | True = pprCWord True sv <+> text "*" P.<> text n + where kind = kindOf sv + +-- | Render a generated C output parameter. +mkPParam :: CgConfig -> (String, CgVal) -> Doc +mkPParam _ (n, CgAtomic sv) + | isArray sv = text (arrayOutputCType (kindOf sv)) <+> text "*" P.<> text n +mkPParam cfg (n, CgAtomic sv) + | isExactGMPKind cfg (kindOf sv) = text (gmpOutputType (kindOf sv)) <+> text n + | True = pprCWord False sv <+> text "*" P.<> text n +mkPParam _ (_, CgArray []) = die "mkPParam: CgArray with no elements!" +mkPParam cfg (n, CgArray (sv:_)) + | isExactGMPKind cfg kind = text (gmpArrayType kind) <+> text "*" P.<> text n + | isArray kind = text (arrayOutputCType kind) <+> text "*" P.<> text n + | True = pprCWord False sv <+> text "*" P.<> text n + where kind = kindOf sv + +-- | Renders as "const SWord8 s0", etc. the first parameter is the width of the typefield +declSV :: Int -> SV -> Doc +declSV w sv = text "const" <+> pad (showCType sv) <+> text (show sv) + where pad s = text $ s ++ replicate (w - length s) ' ' + +-- | Return the proper declaration and the result as a pair. No consts +declSVNoConst :: Int -> SV -> (Doc, Doc) +declSVNoConst w sv = (text " " <+> pad (showCType sv), text (show sv)) + where pad s = text $ s ++ replicate (w - length s) ' ' + +-- | Shared rendering information for one generated function. Constants are +-- scoped to that function, while the ADT registry describes the whole bundle. +data CRenderEnv = CRenderEnv + { renderConfig :: CgConfig -- ^ Representation and runtime-check choices. + , renderADTs :: [Kind] -- ^ Complete concrete ADT registry. + , renderConstants :: [(SV, CV)] -- ^ Constants still eligible for inline rendering. + } + +-- | Renders as "s0", etc, or the corresponding constant. +showSV :: CRenderEnv -> SV -> Doc +showSV env sv + | sv == falseSV = text "false" + | sv == trueSV = text "true" + | Just cv <- sv `lookup` renderConstants env = mkConst env cv + | True = text $ show sv + +-- | Words as it would map to a C word +pprCWord :: HasKind a => Bool -> a -> Doc +pprCWord cnst v = (if cnst then text "const" else empty) <+> text (showCType v) + +-- | Almost a "show", but map "SWord1" to "SBool" +-- which is used for extracting one-bit words. This is OK since C's bool type +-- handles arithmetic fine, and maps nicely to our `SWord 1`. (Same isn't true for `SInt 1`, which +-- doesn't have an easy counter-part on the C side. +showCType :: HasKind a => a -> String +showCType i = case kindOf i of + KBounded False 1 -> "SBool" + KBounded False w -> "SWord" ++ show w + KBounded True w -> "SInt" ++ show w + k@KArray{} -> arrayCType k + k@KTuple{} -> tupleCType k + k@KADT{} + | not (isRoundingMode k) && not (isUninterpreted k) -> adtCType k + k@KFP{} -> arbitraryFPCType k + KString -> "SString" + KChar -> "SChar" + k@KList{} -> listCType k + k@KSet{} -> setCType k + k -> show k + +-- | The printf specifier for the type +specifier :: CgConfig -> SV -> Doc +specifier cfg = specifierKind cfg . kindOf + +-- | Return the @printf@ conversion for a supported scalar kind. +specifierKind :: CgConfig -> Kind -> Doc +specifierKind cfg kind = case kind of + KVar{} -> die $ "variable sort: " ++ show kind + KBool -> spec (False, 1) + KBounded b i -> spec (b, i) + KUnbounded -> spec (True, fromJust (cgInteger cfg)) + KReal -> specF (fromJust (cgReal cfg)) + KFloat -> specF CgFloat + KDouble -> specF CgDouble + KString -> text "%s" + KChar -> text "%c" + KRational -> die "rational sort" + KFP{} -> die "arbitrary float sort" + KList k -> die $ "list sort: " ++ show k + KSet k -> die $ "set sort: " ++ show k + KApp s _ -> die $ "ADT app: " ++ s + k@(KADT s _ _) + | isRoundingMode k -> text "%d" + | True -> die $ "ADT: " ++ s + KTuple k -> die $ "tuple sort: " ++ show k + KArray k1 k2 -> die $ "array sort: " ++ show (k1, k2) + where u8InHex = cgShowU8InHex cfg + + spec :: (Bool, Int) -> Doc + spec (False, 1) = text "%d" + spec (False, 8) + | u8InHex = text "0x%02\"PRIx8\"" + | True = text "%\"PRIu8\"" + spec (True, 8) = text "%\"PRId8\"" + spec (False, 16) = text "0x%04\"PRIx16\"U" + spec (True, 16) = text "%\"PRId16\"" + spec (False, 32) = text "0x%08\"PRIx32\"UL" + spec (True, 32) = text "%\"PRId32\"L" + spec (False, 64) = text "0x%016\"PRIx64\"ULL" + spec (True, 64) = text "%\"PRId64\"LL" + spec (s, sz) = die $ "Format specifier at type " ++ (if s then "SInt" else "SWord") ++ show sz + + specF :: CgSRealType -> Doc + specF CgFloat = text "%a" + specF CgDouble = text "%a" + specF CgLongDouble = text "%Lf" + +-- | Make a constant value of the given type. Explicitly mapped integers are +-- reduced to their requested width; bounded constants are already normalized. +-- The enclosing program's ADT registry is reused throughout nested literals. +-- There are many options here, using binary, decimal, etc. We simply use decimal for values 8-bits or less, +-- and hex otherwise. +mkConst :: CRenderEnv -> CV -> Doc +mkConst env = renderConstant + where + cfg = renderConfig env + adts = renderADTs env + + renderConstant (CV KReal (CAlgReal (AlgRational False _))) + = error "SBV->C: Inexact SReal literals do not specify an exact value and cannot be compiled." + renderConstant (CV KReal (CAlgReal AlgInterval{})) + = error "SBV->C: Interval SReal literals do not specify an exact value and cannot be compiled." + renderConstant (CV KReal (CAlgReal AlgPolyRoot{})) + = error "SBV->C: Algebraic SReal literals are not supported; use an explicitly chosen rational approximation." + renderConstant cv + | Just d <- roundingModeConst cv = d + renderConstant cv + | Just d <- arrayConst renderConstant cv = d + renderConstant cv + | Just d <- tupleConst renderConstant cv = d + renderConstant cv + | Just d <- adtConst adts renderConstant cv = d + renderConstant cv + | Just d <- listConst renderConstant cv = d + renderConstant cv + | Just d <- setConst renderConstant cv = d + renderConstant cv + | Just d <- gmpConst cfg cv = d + renderConstant (CV k (CInteger i)) + | Just d <- wideBVConst k i = d + renderConstant (CV KReal (CAlgReal (AlgRational _ r))) = double (fromRational r :: Double) P.<> sRealSuffix (fromJust (cgReal cfg)) + where sRealSuffix CgFloat = text "F" + sRealSuffix CgDouble = empty + sRealSuffix CgLongDouble = text "L" + renderConstant (CV KUnbounded (CInteger i)) = renderConstant (normCV (CV (KBounded True (fromJust (cgInteger cfg))) (CInteger i))) + renderConstant (CV (KBounded sg sz) (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (sg, sz) + renderConstant (CV KBool (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (False, 1) + renderConstant (CV KFloat (CFloat f)) = text $ showCFloat f + renderConstant (CV KDouble (CDouble d)) = text $ showCDouble d + renderConstant (CV k@KFP{} (CFP fp)) = fromJust (arbitraryFPConst k fp) + renderConstant cv@(CV KString CString{}) = fromJust (textConst cv) + renderConstant cv@(CV KChar CChar{}) = fromJust (textConst cv) + renderConstant cv = die $ "mkConst: " ++ show cv + +-- | Render a bounded literal using its signedness, width, and display mode. +showSizedConst :: Bool -> Integer -> (Bool, Int) -> Doc +showSizedConst _ i (False, 1) = text (if i == 0 then "false" else "true") +showSizedConst u8h i t@(False, 8) + | u8h = text $ T.unpack (chex False True t i) + | True = integer i +showSizedConst _ i (True, 8) = integer i +showSizedConst _ i t@(False, 16) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 16) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(False, 32) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 32) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(False, 64) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 64) = text $ T.unpack $ chex False True t i +showSizedConst _ i (s, sz) = die $ "Constant " ++ show i ++ " at type " ++ (if s then "SInt" else "SWord") ++ show sz + +-- | Invoke the C compiler with contraction disabled after user flags, including +-- during LTO linking. Explicit calls to @fma@ are not implicit contraction. +cCompilerCommand :: Bool -> Bool -> String +cCompilerCommand floating gmp = "${CC} ${CCFLAGS}" ++ (if gmp then " ${GMP_CFLAGS}" else "") + ++ (if floating then " -ffp-contract=off" else "") + +-- | Does a representation require the floating-point compilation contract? +cFloatingKind :: CgConfig -> Kind -> Bool +cFloatingKind cfg kind = isFloat kind || isDouble kind || isFP kind || (isReal kind && isJust (cgReal cfg)) + +-- | Generate a makefile. The first argument is True if we have a driver. +genMake :: Bool -> Bool -> String -> String -> [String] -> Doc +genMake floating ifdr fn dn ldFlags = foldr1 ($$) [l | (True, l) <- lns] + where ifld = not (null ldFlags) + gmp = "-lgmp" `elem` ldFlags + ld = text "${LDFLAGS}" <+> if ifld then text "${SBV_LIBS}" else empty + renderedLDFlags = unwords $ filter (/= "-lgmp") ldFlags ++ ["${GMP_LIBS}" | gmp] + lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") + , (True, text "") + , (True, text "# include any user-defined .mk file in the current directory.") + , (True, text "-include *.mk") + , (True, text "") + , (True, text "CC?=gcc") + , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") + , (gmp, text "GMP_CFLAGS?=$(shell pkg-config --cflags gmp)") + , (gmp, text "GMP_LIBS?=$(shell pkg-config --libs gmp)") + , (ifld, text "SBV_LIBS?=" P.<> text renderedLDFlags) + , (True, text "") + , (ifdr, text "all:" <+> nmd) + , (ifdr, text "") + , (True, nmo P.<> text (": " ++ ppSameLine (hsep [nmc, nmh]))) + , (True, text ("\t" ++ cCompilerCommand floating gmp) <+> text "-c $< -o $@") + , (True, text "") + , (ifdr, nmdo P.<> text (": " ++ ppSameLine (hsep [nmdc, nmh]))) + , (ifdr, text ("\t" ++ cCompilerCommand floating gmp) <+> text "-c $< -o $@") + , (ifdr, text "") + , (ifdr, nmd P.<> text (": " ++ ppSameLine (hsep [nmo, nmdo]))) + , (ifdr, text ("\t" ++ cCompilerCommand floating False) <+> text "$^ -o $@" <+> ld) + , (ifdr, text "") + , (True, text "clean:") + , (True, text "\trm -f *.o") + , (True, text "") + , (ifdr, text "veryclean: clean") + , (ifdr, text "\trm -f" <+> nmd) + , (ifdr, text "") + ] + nm = text fn + nmd = text dn + nmh = nm P.<> text ".h" + nmc = nm P.<> text ".c" + nmo = nm P.<> text ".o" + nmdc = nmd P.<> text ".c" + nmdo = nmd P.<> text ".o" + +-- | Generate the header +genHeader :: Bool -> (Maybe Int, Maybe CgSRealType) -> String -> [Doc] -> Doc -> Doc -> Doc +genHeader floating (ik, rk) fn sigs protos extraTypes = + text "/* Header file for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit! */" + $$ text "" + $$ text "#ifndef" <+> tag + $$ text "#define" <+> tag + $$ text "" + $$ (if floating then vcat [text "#if defined(__FAST_MATH__) || (defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__ > 0)" + , text "#error \"SBV-generated C requires IEEE floating-point semantics; disable fast-math and finite-math-only.\"" + , text "#endif"] else empty) + $$ text "" + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ (if floating then vcat [text "#include " + , text "#if FLT_EVAL_METHOD != 0" + , text "#error \"SBV-generated C requires FLT_EVAL_METHOD == 0; indeterminate or excess-precision floating evaluation is unsupported.\"" + , text "#endif"] else empty) + $$ text "" + $$ text "/* Floating-point calling convention:" + $$ text " * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even)." + $$ text " * Callbacks must preserve this mode before returning or re-entering." + $$ text " * Generated code does not check or change the hardware rounding mode." + $$ text " * Custom builds must disable implicit FP contraction, including at LTO link time." + $$ text " */" + $$ text "" + $$ text "/* The boolean type */" + $$ text "typedef bool SBool;" + $$ text "" + $$ text "/* The float type */" + $$ text "typedef float SFloat;" + $$ text "" + $$ text "/* The double type */" + $$ text "typedef double SDouble;" + $$ text "" + $$ text "/* Unsigned bit-vectors */" + $$ 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 "" + $$ imapping + $$ rmapping + $$ extraTypes + $$ text ("/* Entry point prototype" ++ plu ++ ": */") + $$ vcat (map (P.<> semi) sigs) + $$ text "" + $$ protos + $$ text "#endif /*" <+> tag <+> text "*/" + $$ text "" + where nm = text fn + tag = text "SBV_GENERATED_" P.<> nm P.<> text "_HEADER_INCLUDED" + plu = if length sigs /= 1 then "s" else "" + imapping = case ik of + Nothing -> empty + Just i -> text "/* User requested mapping for SInteger. */" + $$ text "/* NB. Loss of precision: Target type is subject to modular arithmetic. */" + $$ text ("typedef SInt" ++ show i ++ " SInteger;") + $$ text "" + rmapping = case rk of + Nothing -> empty + Just t -> text "/* User requested mapping for SReal. */" + $$ text "/* NB. Loss of precision: Target type is subject to rounding. */" + $$ text ("typedef " ++ show t ++ " SReal;") + $$ text "" + +-- | Insert an empty separating line when the condition holds. +sepIf :: Bool -> Doc +sepIf b = if b then text "" else empty + +-- | Test whether an ADT value needs the caller-owned deep-storage ABI. +isOwnedADT :: CgConfig -> [Kind] -> SV -> Bool +isOwnedADT cfg adts sv = isADT sv + && not (isRoundingMode sv) + && adtNeedsOwnership cfg adts (kindOf sv) + +-- | Generate an example driver program +genDriver :: CgConfig -> [Kind] -> [Integer] -> String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> [Doc] +genDriver cfg adts randVals fn publicInputs publicOutputs mbRet + = [pre, include, callbacks, printHelpers, header, body, post] + where env = CRenderEnv cfg adts [] + inps = privateParameters "sbv_driver_input_" publicInputs + outs = privateParameters "sbv_driver_output_" publicOutputs + publicName local = fromMaybe local (lookup local publicNames) + publicNames = zip (map fst (inps ++ outs)) (map fst (publicInputs ++ publicOutputs)) + + pre = text "/* Example driver program for" <+> nm P.<> text ". */" + $$ text "/* Automatically generated by SBV. Edit as you see fit! */" + $$ text "" + $$ text "#include " + include = text "#include" <+> doubleQuotes (nm P.<> text ".h") + callbacks = vcat (map (arrayDriverCallback cfg) inputArrayKinds) + header = 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 sv | isArray sv + -> displayArray "sbv_result" displayCall resultVar (kindOf sv) + Just sv | isTuple sv + -> displayTuple displayCall resultVar (kindOf sv) + Just sv | isADT sv && not (isRoundingMode sv) + -> displayADT displayCall resultVar (kindOf sv) + Just sv | isList sv + -> displayList displayCall resultVar (kindOf sv) + Just sv | isSet sv + -> displaySet displayCall resultVar (kindOf sv) + Just sv | isWideBV (kindOf sv) + -> text "printf" P.<> parens (printQuotes (displayCall <+> text "=")) P.<> semi + $$ wideBVPrint (kindOf sv) resultVar P.<> semi + $$ text "printf(\"\\n\");" + Just sv | isFP (kindOf sv) + -> text "printf" P.<> parens (printQuotes (displayCall <+> text "=")) P.<> semi + $$ arbitraryFPPrint (kindOf sv) resultVar P.<> semi + $$ text "printf(\"\\n\");" + Just sv | isExactGMPKind cfg (kindOf sv) + -> text "printf" P.<> parens (printQuotes (displayCall <+> text "=")) P.<> semi + $$ gmpPrint (kindOf sv) resultVar P.<> semi + $$ text "printf(\"\\n\");" + Just sv | kindOf sv `elem` [KChar, KString] + -> text "printf" P.<> parens (printQuotes (displayCall <+> text "=")) P.<> semi + $$ textPrint (kindOf sv) resultVar P.<> semi + $$ text "printf(\"\\n\");" + Just sv -> text "printf" P.<> parens (printQuotes (displayCall <+> text "=" <+> specifier cfg sv P.<> text "\\n") + P.<> comma <+> resultVar) P.<> semi + Nothing -> text "printf" P.<> parens (printQuotes (displayCall <+> text "->\\n")) P.<> semi) + $$ vcat (map display outs) + $$ driverCleanup + ) + post = text "" + $+$ nest 2 (text "return 0" P.<> semi) + $$ text "}" + $$ text "" + nm = text fn + inputArrayKinds = nub . concatMap collectInputArrays $ concatMap inputKinds inps + inputKinds (_, CgAtomic sv) = [kindOf sv] + inputKinds (_, CgArray svs) = map kindOf svs + + collectInputArrays = collect Set.empty + where collect visited kind + | kind `Set.member` visited = [] + | KApp{} <- kind + = collect nextVisited (resolveADTReferences adts kind) + | KArray keyKind valueKind <- kind + = kind : collect nextVisited keyKind ++ collect nextVisited valueKind + | KTuple fieldKinds <- kind + = concatMap (collect nextVisited) fieldKinds + | KList elementKind <- kind + = collect nextVisited elementKind + | KSet elementKind <- kind + = collect nextVisited elementKind + | isConcreteADTReference kind + = concatMap (concatMap (collect nextVisited) . snd) (adtConstructors adts kind) + | True + = [] + where nextVisited = Set.insert kind visited + pairedInputs = matchRands randVals inps + inputSeeds = matchInputSeeds randVals inps + matchRands _ [] = [] + matchRands [] _ = die "Run out of driver values!" + matchRands (r:rs) ((n, CgAtomic sv) : cs) + | KArray _ valueKind <- kindOf sv = ([mkRValKind valueKind r], n, CgAtomic sv) : matchRands rs cs + matchRands (r:rs) ((n, CgAtomic sv) : cs) = ([mkRVal sv r], n, CgAtomic sv) : matchRands rs cs + matchRands _ ((n, CgArray []) : _ ) = die $ "Unsupported empty array input " ++ show n + matchRands rs ((n, a@(CgArray sws@(sv:_))) : cs) + | length frs /= l = die "Run out of driver values!" + | True = (map (mkRVal sv) frs, n, a) : matchRands srs cs + where l = length sws + (frs, srs) = splitAt l rs + matchInputSeeds _ [] = [] + matchInputSeeds [] _ = die "Run out of driver values!" + matchInputSeeds (r:rs) ((n, CgAtomic{}) : cs) = (n, [r]) : matchInputSeeds rs cs + matchInputSeeds _ ((n, CgArray []) : _ ) = die $ "Unsupported empty array input " ++ show n + matchInputSeeds rs ((n, CgArray values@(_:_)) : cs) + | length seeds == length values = (n, seeds) : matchInputSeeds rest cs + | True = die "Run out of driver values!" + where (seeds, rest) = splitAt (length values) rs + inputSeed n = case inputGroupSeeds n of + seed:_ -> seed + [] -> die $ "Missing driver seed for composite input " ++ show n + inputGroupSeeds n = case lookup n inputSeeds of + Just seeds -> seeds + Nothing -> die $ "Missing driver seed for composite input " ++ show n + inputElementName n index = n ++ "_element_" ++ show (index :: Int) + inputNeedsInitialization kind + | isConcreteADTReference kind = adtNeedsOwnership cfg adts kind + | True = valueDriverNeedsInitialization cfg kind + mkRVal sv = mkRValKind (kindOf sv) + mkRValKind kind r + | isRoundingMode kind = roundingModeDriverValue r + | isExactGMPKind cfg kind = integer r + | kind `elem` [KChar, KString] = textDriverValue kind r + | isList kind = listDriverValue mkRValKind kind r + | isSet kind = setDriverValue mkRValKind kind r + | KTuple fieldKinds <- kind = tupleValue kind (zipWith mkField fieldKinds [0 :: Integer ..]) + | isADT kind = adtDriverValue adts mkRValKind kind r + | True = mkConst env $ mkConstCV kind r + where mkField fieldKind offset = mkRValKind fieldKind (r + offset) + driverValueInit = valueDriverInit cfg mkRValKind initializeComposite + + -- Only these constructors need the complete ADT registry or the public + -- versus stored array ABI. All other dispatch belongs to Value. + -- Resolving KApp re-enters the generic dispatcher with the concrete kind. + initializeComposite kind externalName seed + | KApp{} <- kind = driverValueInit (resolveADTReferences adts kind) externalName seed + | isArray kind = initializeArray kind externalName seed + | isConcreteADTReference kind + , adtNeedsOwnership cfg adts kind = adtDriverInit cfg adts mkRValKind driverValueInit kind externalName seed + | isConcreteADTReference kind = text (adtCType kind) <+> text externalName <+> text "=" + <+> adtDriverValue adts mkRValKind kind seed P.<> semi + | True = die $ "Expected an array or ADT driver kind, received " ++ show kind + initializeArray kind@(KArray _ valueKind) externalName seed + = let defaultName = externalName ++ "_default" + inputName = externalName ++ "_input" + in driverValueInit valueKind defaultName seed + $$ arrayDriverInput cfg kind inputName defaultName + $$ arrayDriverStoredInput kind externalName inputName + $$ driverValueClear valueKind defaultName + initializeArray kind _ _ = die $ "Expected an array driver kind, received " ++ show kind + driverValueClear kind externalName + | isConcreteADTReference kind + , not (adtNeedsOwnership cfg adts kind) = empty + | True = valueDriverClear cfg kind externalName + mkInp (_, n, CgAtomic sv) + | KArray _ valueKind <- kindOf sv + = let defaultName = n ++ "_default" + in driverValueInit valueKind defaultName (inputSeed n) + $$ arrayDriverInput cfg (kindOf sv) n defaultName + mkInp ([_], n, CgAtomic sv) + | inputNeedsInitialization (kindOf sv) = driverValueInit (kindOf sv) n (inputSeed n) + mkInp (_, _, CgAtomic{}) = empty -- constant, no need to declare + mkInp (_, n, CgArray []) = die $ "Unsupported empty array value for " ++ show n + mkInp (vs, n, CgArray sws@(sv:_)) + | isExactGMPKind cfg kind = text (gmpArrayType kind) <+> text n P.<> brackets (int lengthOfArray) P.<> semi + $$ vcat (zipWith initialize [0 :: Int ..] vs) + $$ displayInputArray + | inputNeedsInitialization kind + = vcat [initializeElement elementName seed | (elementName, seed) <- zip elementNames (inputGroupSeeds n)] + $$ text "const" <+> text inputType <+> text n P.<> brackets (int lengthOfArray) + <+> text "=" <+> braces (fsep (punctuate comma (map text elementNames))) P.<> semi + $$ displayInputArray + | True = pprCWord True sv <+> text n P.<> brackets (int lengthOfArray) <+> text "= {" + $$ nest 4 (fsep (punctuate comma (align vs))) + $$ text "};" + $$ displayInputArray + where kind = kindOf sv + lengthOfArray = length sws + + initialize index = gmpDriverInitialize kind (text n P.<> brackets (int index)) + + elementNames = [inputElementName n index | index <- [0 .. lengthOfArray - 1]] + inputType + | isArray kind = arrayInputCType kind + | True = showCType kind + initializeElement elementName seed + | KArray _ valueKind <- kind + = driverValueInit valueKind (elementName ++ "_default") seed + $$ arrayDriverInput cfg kind elementName (elementName ++ "_default") + | True + = driverValueInit kind elementName seed + + displayInputArray = text "" + $$ text "printf" P.<> parens (printQuotes (text "Contents of input array" <+> text (publicName n) P.<> text ":\\n")) P.<> semi + $$ display (n, CgArray sws) + $$ text "" + mkOut (v, CgAtomic sv) + | isArray sv = text (arrayOutputCType (kindOf sv)) <+> text v <+> text "=" <+> braces (text "0") P.<> semi + | isExactGMPKind cfg (kindOf sv) = gmpDriverInit (kindOf sv) (text v) (text "0") + | kindOf sv == KString = text "SString" <+> text v <+> text "=" <+> braces (text "0") P.<> semi + | isList sv = text (listCType (kindOf sv)) <+> text v <+> text "=" <+> braces (text "0") P.<> semi + | isSet sv = text (setCType (kindOf sv)) <+> text v <+> text "=" <+> braces (text "0") P.<> semi + | tupleNeedsOwnership cfg (kindOf sv) = text (tupleCType (kindOf sv)) <+> text v + <+> text "=" <+> braces (text "0") P.<> semi + | isOwnedADT cfg adts sv = text (adtCType (kindOf sv)) <+> text v + <+> text "=" <+> braces (text "0") P.<> semi + | True = pprCWord False sv <+> text v P.<> semi + mkOut (v, CgArray []) = die $ "Unsupported empty array value for " ++ show v + mkOut (v, CgArray sws@(sv:_)) + | isExactGMPKind cfg kind = text (gmpArrayType kind) <+> text v P.<> brackets (int lengthOfArray) P.<> semi + $$ vcat [gmpDriverInitialize kind (text v P.<> brackets (int index)) (text "0") | index <- [0 .. lengthOfArray - 1]] + | isArray kind = text (arrayOutputCType kind) <+> text v P.<> brackets (int lengthOfArray) + <+> text "=" <+> braces (text "0") P.<> semi + | True = pprCWord False sv <+> text v P.<> brackets (int lengthOfArray) P.<> semi + where kind = kindOf sv + lengthOfArray = length sws + resultVar = text "sbv_result" + call = case mbRet of + Nothing -> fcall P.<> semi + Just sv + | isExactGMPKind cfg (kindOf sv) -> gmpDriverInit (kindOf sv) resultVar (text "0") + $$ fcall P.<> semi + | isArray sv -> text (arrayOutputCType (kindOf sv)) <+> resultVar + <+> text "=" <+> fcall P.<> semi + | tupleNeedsOwnership cfg (kindOf sv) -> text (tupleCType (kindOf sv)) <+> resultVar + <+> text "=" <+> fcall P.<> semi + | isOwnedADT cfg adts sv -> text (adtCType (kindOf sv)) <+> resultVar + <+> text "=" <+> fcall P.<> semi + | kindOf sv == KString -> text "SString" <+> resultVar <+> text "=" <+> fcall P.<> semi + | isList sv -> text (listCType (kindOf sv)) <+> resultVar + <+> text "=" <+> fcall P.<> semi + | isSet sv -> text (setCType (kindOf sv)) <+> resultVar + <+> text "=" <+> fcall P.<> semi + | True -> pprCWord True sv <+> resultVar <+> text "=" <+> fcall P.<> semi + fcall = functionCall id + displayCall = nm P.<> parens (fsep (punctuate comma (map displayInput pairedInputs ++ map (mkOVal publicName) outs ++ exactResultArg))) + displayInput input@(_, inputName, CgAtomic sv) + | kindOf sv == KString || isTuple sv || isADT sv || isWideBV (kindOf sv) || isFP sv + = text (publicName inputName) + | True = mkCVal publicName input + displayInput input = mkCVal publicName input + functionCall rename = nm P.<> parens (fsep (punctuate comma (map (mkCVal rename) pairedInputs ++ map (mkOVal rename) outs ++ exactResultArg))) + exactResultArg = case mbRet of + Just sv | isExactGMPKind cfg (kindOf sv) -> [resultVar] + _ -> [] + mkCVal rename ([v], n, CgAtomic sv) + | inputNeedsInitialization (kindOf sv) = text (rename n) + | True = v + mkCVal _ (vs, n, CgAtomic{}) = die $ "Unexpected driver value computed for " ++ show n ++ render (hcat vs) + mkCVal rename (_, n, CgArray{}) = text (rename n) + mkOVal rename (n, CgAtomic sv) + | isExactGMPKind cfg (kindOf sv) = text (rename n) + | True = text "&" P.<> text (rename n) + mkOVal rename (n, CgArray{}) = text (rename n) + display (n, CgAtomic sv) + | isArray sv = displayArray n label (text n) (kindOf sv) + | isTuple sv = displayTuple label (text n) (kindOf sv) + | isADT sv && not (isRoundingMode sv) = displayADT label (text n) (kindOf sv) + | isList sv = displayList label (text n) (kindOf sv) + | isSet sv = displaySet label (text n) (kindOf sv) + | isWideBV (kindOf sv) = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ wideBVPrint (kindOf sv) (text n) P.<> semi + $$ text "printf(\"\\n\");" + | isFP (kindOf sv) = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ arbitraryFPPrint (kindOf sv) (text n) P.<> semi + $$ text "printf(\"\\n\");" + | isExactGMPKind cfg (kindOf sv) = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ gmpPrint (kindOf sv) (text n) P.<> semi + $$ text "printf(\"\\n\");" + | kindOf sv `elem` [KChar, KString] = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ textPrint (kindOf sv) (text n) P.<> semi + $$ text "printf(\"\\n\");" + | True = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=" <+> specifier cfg sv + P.<> text "\\n") P.<> comma <+> text n) P.<> semi + where label = text (publicName n) + display (n, CgArray []) = die $ "Unsupported empty array value for " ++ show n + display (n, CgArray sws@(sv:_)) = text "int" <+> nctr P.<> semi + $$ text "for(" P.<> nctr <+> text "= 0;" <+> nctr <+> text "<" <+> int len <+> text "; ++" P.<> nctr P.<> text ")" + $$ text "{" + $$ nest 2 displayEntry + $$ text "}" + where nctr = text n P.<> text "_ctr" + entry = text n P.<> text "[" P.<> nctr P.<> text "]" + entrySpec = text (publicName n) P.<> text "[%" P.<> int tab P.<> text "d]" + kind = kindOf sv + len = length sws + tab = length $ show (len - 1) + + displayEntry + | isArray kind = displayArrayEntry kind + | True = text "printf" P.<> parens (printQuotes (text " " <+> entrySpec <+> text "= ") P.<> comma <+> nctr) P.<> semi + $$ printValue kind entry + $$ text "printf(\"\\n\");" + + displayArrayEntry arrayKind@(KArray keyKind valueKind) + = keySetup + $$ text "printf" P.<> parens (printQuotes (text " " <+> (entrySpec P.<> text "[0] =")) P.<> comma <+> nctr) P.<> semi + $$ printValue valueKind arrayValue + $$ text "printf(\"\\n\");" + $$ keyCleanup + where keyName = "sbv_local_array_key_" ++ n + key = text keyName + keySetup = driverValueInit keyKind keyName 0 + keyCleanup = driverValueClear keyKind keyName + arrayValue + | n `elem` map fst inps + = entry P.<> text ".lookup" P.<> parens (fsep (punctuate comma [entry P.<> text ".context", key])) + | True + = text (arrayOutputReadName arrayKind) P.<> parens (fsep (punctuate comma [entry, key])) + displayArrayEntry arrayKind = die $ "Expected an array return-group element, received " ++ show arrayKind + + displayArray stem label descriptor kind@(KArray keyKind valueKind) + = keySetup + $$ text "printf" P.<> parens (printQuotes (text " " <+> label P.<> text "[0] =")) P.<> semi + $$ printArrayValue + $$ text "printf(\"\\n\");" + $$ keyCleanup + where keyName = "sbv_local_array_key_" ++ stem + key = text keyName + + keySetup = driverValueInit keyKind keyName 0 + keyCleanup = driverValueClear keyKind keyName + + value = text (arrayOutputReadName kind) P.<> parens (fsep (punctuate comma [descriptor, key])) + printArrayValue = printValue valueKind value + displayArray _ _ _ kind = die $ "Expected an array output, received " ++ show kind + + displayTuple label value kind@KTuple{} + = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ printTupleValue value kind + $$ text "printf(\"\\n\");" + displayTuple _ _ kind = die $ "Expected a tuple output, received " ++ show kind + + displayADT label value kind + = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ adtPrint adts printValue kind value + $$ text "printf(\"\\n\");" + + displayList label value kind@KList{} + = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ listPrint printValue kind value + $$ text "printf(\"\\n\");" + displayList _ _ kind = die $ "Expected a list output, received " ++ show kind + + displaySet label value kind@KSet{} + = text "printf" P.<> parens (printQuotes (text " " <+> label <+> text "=")) P.<> semi + $$ setPrint printValue kind value + $$ text "printf(\"\\n\");" + displaySet _ _ kind = die $ "Expected a set output, received " ++ show kind + + printHelpers = adtPrintHelpers adts printValue + + printTupleValue _ (KTuple []) = text "printf(\"()\");" + printTupleValue value (KTuple fieldKinds) + = text "printf(\"(\");" + $$ vcat (intersperse (text "printf(\", \");") (zipWith printField [1 :: Int ..] fieldKinds)) + $$ text "printf(\")\");" + where printField index fieldKind = printValue fieldKind (parens value P.<> text "." P.<> text (tupleFieldName index)) + printTupleValue _ kind = die $ "Expected a tuple value, received " ++ show kind + + printValue kind value + | KTuple{} <- kind = printTupleValue value kind + | KList{} <- kind = listPrint printValue kind value + | KSet{} <- kind = setPrint printValue kind value + | KArray{} <- kind = printStoredArray value kind + | isADT kind && not (isRoundingMode kind) = adtPrint adts printValue kind value + | isWideBV kind = wideBVPrint kind value P.<> semi + | isFP kind = arbitraryFPPrint kind value P.<> semi + | isExactGMPKind cfg kind = gmpPrint kind value P.<> semi + | kind `elem` [KChar, KString] = textPrint kind value P.<> semi + | True = text "printf" P.<> parens (printQuotes (specifierKind cfg kind) P.<> comma <+> value) P.<> semi + + printStoredArray descriptor kind@(KArray keyKind valueKind) + = text "{" + $$ nest 2 ( text "if" P.<> parens (descriptor <+> text "== NULL") <+> text "abort" P.<> parens empty P.<> semi + $$ keySetup + $$ text "printf(\"[0] =\");" + $$ printValue valueKind storedValue + $$ keyCleanup + ) + $$ text "}" + where keyName = "sbv_local_array_stored_key_" ++ kindTag kind + key = text keyName + keySetup = driverValueInit keyKind keyName 0 + keyCleanup = driverValueClear keyKind keyName + storedValue = text (arrayOutputReadName kind) + P.<> parens (fsep (punctuate comma [text "*" P.<> parens descriptor, key])) + printStoredArray _ kind = die $ "Expected a stored array, received " ++ show kind + + driverCleanup = vcat $ inputCleanup ++ outputCleanup ++ returnCleanup + where inputCleanup = [ clearInputElement (kindOf sv) n + | (_, n, CgAtomic sv) <- pairedInputs + , inputNeedsInitialization (kindOf sv) + ] + ++ [ clearInputElement (kindOf sv) elementName + | (_, n, CgArray svs) <- pairedInputs + , (index, sv) <- zip [0 :: Int ..] svs + , inputNeedsInitialization (kindOf sv) + , let elementName + | isExactGMPKind cfg (kindOf sv) = n ++ "[" ++ show index ++ "]" + | True = inputElementName n index + ] + clearInputElement (KArray _ valueKind) elementName = driverValueClear valueKind (elementName ++ "_default") + clearInputElement kind elementName = driverValueClear kind elementName + + outputCleanup = concatMap clearOutput outs + clearOutput (n, CgAtomic sv) = [outputValueClear (kindOf sv) n] + clearOutput (n, CgArray svs) = [outputValueClear (kindOf sv) (n ++ "[" ++ show index ++ "]") + | (index, sv) <- zip [0 :: Int ..] svs + ] + returnCleanup = [outputValueClear (kindOf sv) "sbv_result" | sv <- maybeToList mbRet] + + -- Public array outputs own an exported descriptor. Collection + -- outputs own their elements; driver inputs merely borrow them. + outputValueClear kind externalName + | isArray kind = text (arrayOutputReleaseName kind) P.<> parens address P.<> semi + | kind == KString || isList kind || isSet kind = managedValueRelease kind address + | True = driverValueClear kind externalName + where address = text "&" P.<> text externalName + +-- | Generate the C program +genCProg :: CgConfig + -> [Kind] + -> [Kind] + -> [Kind] + -> String + -> Doc + -> Result + -> [(String, CgVal)] + -> [(String, CgVal)] + -> Maybe SV + -> Doc + -> ([Doc], Set.Set CRequirement) +genCProg cfg adts lists sets fn proto + (Result pinfo kindInfo _tvals _ovals cgs topInps (_, preConsts) tbls _uis definitions + (SBVPgm asgns) cstrs origAsserts _) + inVars outVars mbRet extDecls + | not (null usorts) + = error $ "SBV->C: Cannot compile functions with uninterpreted sorts: " ++ intercalate ", " usorts + | not (null unsupportedSets) + = notyet $ "Sets with element kinds " ++ intercalate ", " (map (show . setElementKind) unsupportedSets) + | any (requiresExtensionalEquality adts (Equal True) . pure . setElementKind) sets + = error "SBV->C: Set elements require general extensional array equality." + | or [requiresExtensionalEquality adts (Equal True) [keyKind] | KArray keyKind _ <- arrays] + = error "SBV->C: Array keys require general extensional array equality." + | any containsNestedSet kindInfo + = notyet "Sets nested in arrays or unsupported aggregate types" + | not (null unsupportedLists) + = notyet $ "Lists with element kinds " ++ intercalate ", " (map (show . listElementKind) unsupportedLists) + | any containsNestedList kindInfo + = notyet "Lists nested in arrays or unsupported aggregate types" + | not $ null (progSpecialRels pinfo) + = error "SBV->C: Cannot compile in the presence of special relations." + | hasQuants pinfo + = error "SBV->C: Cannot compile in the presence of quantified variables." + | not (null unstructuredDefinitions) + = error $ "SBV->C: Cannot compile SMT-text-only function definitions: " ++ intercalate ", " unstructuredDefinitions + | (callbackName, captures) : _ <- capturingArrayLambdas + = error $ unlines + [ "SBV->C: Array lambdas that capture outer symbolic values are not supported." + , " Callback: " ++ callbackName + , " Captured values: " ++ intercalate ", " [show sv ++ " :: " ++ show (kindOf sv) | sv <- captures] + , "Only closed lambdaArray bodies can be compiled: use the index, literal constants, and local computations." + , "Support for captured array-lambda environments is deferred; captured values are never approximated or ignored." + ] + | (functionName, captures) : _ <- capturingFunctions + = error $ unlines + [ "SBV->C: Defined functions with implicit captures of outer symbolic values are not supported." + , " Function: " ++ functionName + , " Captured values: " ++ intercalate ", " [show sv ++ " :: " ++ show (kindOf sv) | sv <- captures] + , "Pass captured values as explicit function arguments, or use Closure with an explicit closureEnv for higher-order operations." + ] + | not (null softConstraints) + = tbd "Soft constraints" + | not (null unsupportedConstraintAttributes) + = tbd $ "Constraint attributes: " ++ intercalate ", " unsupportedConstraintAttributes + | True + = ([pre, header, post], requirements) + where notyet m = error $ "SBV->C: " ++ m ++ " are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!" + + asserts | cgIgnoreAsserts cfg = [] + | True = origAsserts + + usorts = [s | k@(KADT s _ _) <- Set.toList kindInfo, isUninterpreted k] + + pre = text "/* File:" <+> doubleQuotes (nm P.<> text ".c") P.<> text ". Automatically generated by SBV. Do not edit! */" + $$ text "" + + header = text "#include" <+> doubleQuotes (nm P.<> text ".h") + $$ (if requires CRequiresLibBF then text "#include " else empty) + + wideKinds = wideBVKinds kindInfo + fpKinds = arbitraryFPKinds kindInfo + arrays = arrayKinds kindInfo + unsupportedLists = filter (not . listSupported cfg) lists + unsupportedSets = filter (not . setSupported cfg) sets + post = text "" + $$ (if any (cFloatingKind cfg) kindInfo then nativeFPCompilePragmas else empty) + $$ vcat (map codeSeg cgs) + $$ extDecls + $$ mappedRealFloorRuntime cfg allAssignments + $$ bitVectorRuntime (cgInteger cfg) wideKinds allAssignments + $$ (if requires CRequiresGMP then gmpRuntime cfg kindInfo allAssignments else empty) + $$ (if requires CRequiresLibBF then arbitraryFPRuntime cfg fpKinds allAssignments else empty) + $$ (if requires CRequiresNativeFPRounding then nativeFPRuntime else empty) + $$ (if requires CRequiresIntegerPower then mappedIntegerPowerRuntime cfg else empty) + $$ (if requires CRequiresText then textRuntime cfg usesExactInteger else empty) + $$ adtEqualityRuntimeDecls adts + $$ (if requires CRequiresLists then listRuntimeDecls cfg lists else empty) + $$ (if requires CRequiresSets then setRuntimeDecls cfg sets else empty) + $$ (if requires CRequiresLists then listRuntime cfg usesExactInteger lists else empty) + $$ (if requires CRequiresSets then setRuntime cfg (map snd . adtConstructors adts . resolveADTReferences adts) sets else empty) + $$ (if requires CRequiresArrays then arrayRuntime cfg arrays else empty) + $$ adtEqualityRuntime cfg adts + $$ vcat [ppArrayEquality cfg adts kind | kind <- equalityArrayKinds] + $$ definedFunctionResultRuntime functionResultKinds + $$ (if hasStructuredCallbacks then definedFunctionContextType requirements else empty) + $$ vcat functionPrototypes + $$ vcat arrayLambdaPrototypes + $$ vcat functionDocs + $$ vcat arrayLambdaDocs + $$ proto + $$ text "{" + $$ text "" + $$ nest 2 ( gmpStart + $$ textStart + $$ listStart + $$ setStart + $$ arrayStart + $$ functionResultStart + $$ functionContextStart + $$ vcat (concatMap (genIO True . (\v -> (isAlive v, v))) inVars) + $$ constantDeclarations + $$ scheduledAssignments + $$ sepIf (not (null assignments) || not (null tbls)) + $$ vcat (concatMap (genIO False . (True,)) outVars) + $$ exactReturn + $$ arrayReturn + $$ ownedTupleReturn + $$ exactADTReturn + $$ textReturn + $$ listReturn + $$ setReturn + $$ functionResultEnd + $$ arrayEnd + $$ setEnd + $$ listEnd + $$ textEnd + $$ gmpEnd + $$ normalReturn + ) + $$ text "}" + $$ text "" + + nm = text fn + + assignments = F.toList asgns + + constraints = F.toList cstrs + + softConstraints = [() | (True, _, _) <- constraints] + + unsupportedConstraintAttributes = nub [attribute + | (_, attributes, _) <- constraints + , (attribute, _) <- attributes + , attribute /= ":named" + ] + + runtimeChecks = sortOn (cLocation allConsts . fst) + $ [(sv, snd (genAssert assertion)) | assertion@(_, _, sv) <- asserts] + ++ [(sv, snd (genConstraint constraint)) | constraint@(_, _, sv) <- constraints] + + functionNames = [(T.pack functionName, CTypes.definedFunctionCName functionName) | (functionName, _) <- definitions] + + structuredDefinitions = [ (functionName, resultKind, dependencies, functionType, lambdaInfo) + | (functionName, (definition@(SMTDef resultKind dependencies _ _), functionType)) <- definitions + , Just lambdaInfo <- [smtDefInfo definition] + ] + + unstructuredDefinitions = [ functionName + | (functionName, (definition, _)) <- definitions + , Nothing <- [smtDefInfo definition] + ] + + topLevelArrayLambdaDefinitions = [ (arrayLambdaName sv, sv, lambdaInfo) + | (sv, SBVApp (ArrayInit (Right lambdaDef)) []) <- assignments + , Just lambdaInfo <- [smtLambdaInfo lambdaDef] + ] + + topLevelArrayLambdaNames = [(sv, callbackName) | (callbackName, sv, _) <- topLevelArrayLambdaDefinitions] + + arrayLambdaDefinitions = + topLevelArrayLambdaDefinitions + ++ concat [nestedArrayLambdaDefinitions callbackName lambdaInfo + | (callbackName, _, lambdaInfo) <- topLevelArrayLambdaDefinitions + ] + ++ concat [nestedArrayLambdaDefinitions (CTypes.definedFunctionCName functionName) lambdaInfo + | (functionName, _, _, _, lambdaInfo) <- structuredDefinitions + ] + + nestedArrayLambdaDefinitions scope LambdaInfo{liAssignments = nestedAssignments} + = concat [ (callbackName, sv, lambdaInfo) : nestedArrayLambdaDefinitions callbackName lambdaInfo + | (sv, SBVApp (ArrayInit (Right lambdaDef)) []) <- F.toList nestedAssignments + , let callbackName = scopedArrayLambdaName scope sv + , Just lambdaInfo <- [smtLambdaInfo lambdaDef] + ] + + functionAssignments = concatMap (\(_, _, _, _, lambdaInfo) -> F.toList (liAssignments lambdaInfo)) structuredDefinitions + arrayLambdaAssignments = concatMap (\(_, _, lambdaInfo) -> F.toList (liAssignments lambdaInfo)) arrayLambdaDefinitions + lambdaAssignments = functionAssignments ++ arrayLambdaAssignments + allAssignments = assignments ++ lambdaAssignments + capturingArrayLambdas = [ (callbackName, captures) + | (callbackName, _, lambdaInfo) <- arrayLambdaDefinitions + , let captures = cLambdaFreeValues lambdaInfo + , not (null captures) + ] + capturingFunctions = [ (functionName, captures) + | (functionName, _, _, _, lambdaInfo) <- structuredDefinitions + , let captures = cLambdaFreeValues lambdaInfo + , not (null captures) + ] + equalityArrayKinds = uniqueOn arrayEqualName + [kindOf value | (_, SBVApp op (value:_)) <- allAssignments + , op `elem` [Equal False, Equal True, NotEqual] + , isArray value] + + functionPrototypes = [ definedFunctionSignature functionName resultKind (liParams lambdaInfo) P.<> semi + | (functionName, resultKind, _, _, lambdaInfo) <- structuredDefinitions + ] + + generatedFunctions = + [ ppDefinedFunction cfg adts functionNames functionName resultKind functionType lambdaInfo + | (functionName, resultKind, _, functionType, lambdaInfo) <- structuredDefinitions + ] + functionDocs = map fst generatedFunctions + + functionResultKinds = nub $ + [ resultKind + | (_, resultKind, _, _, _) <- structuredDefinitions + , definedFunctionResultNeedsClone cfg adts resultKind + ] + ++ [ kindOf (liOutput lambdaInfo) + | (_, _, lambdaInfo) <- arrayLambdaDefinitions + , definedFunctionResultNeedsClone cfg adts (kindOf (liOutput lambdaInfo)) + ] + + generatedArrayLambdas = [ppArrayLambda cfg adts functionNames callbackName sv lambdaInfo + | (callbackName, sv, lambdaInfo) <- arrayLambdaDefinitions + ] + arrayLambdaPrototypes = [arrayLambdaSignature callbackName sv lambdaInfo P.<> semi + | (callbackName, sv, lambdaInfo) <- arrayLambdaDefinitions + ] + arrayLambdaDocs = map fst generatedArrayLambdas + + (scheduledAssignments, scheduledRequirements) = + scheduleC env functionNames topLevelArrayLambdaNames + (map fst allConsts ++ concatMap (cgValues . snd) inVars) assignments tbls True typeWidth + evaluationRoots + + evaluationRoots = runtimeChecks ++ [(sv, empty) | sv <- concatMap (cgValues . snd) outVars ++ maybe [] pure mbRet] + + cgValues (CgAtomic sv) = [sv] + cgValues (CgArray svs) = svs + + requirements = Set.unions + [ kindRequirements + , scheduledRequirements + , Set.unions (map snd generatedFunctions) + , Set.unions (map snd generatedArrayLambdas) + , Set.unions [operationRequirements cfg (op, kindOf sv) | (sv, SBVApp op _) <- assignments] + ] + + kindRequirements = Set.fromList $ + [CRequiresWideBV | not (null wideKinds)] + ++ [CRequiresLibBF | not (null fpKinds)] + ++ [CRequiresLibM | not (null fpKinds)] + ++ [CRequiresGMP | usesGMP] + ++ [CRequiresText | KString `Set.member` kindInfo || KChar `Set.member` kindInfo] + ++ [CRequiresLists | not (null lists)] + ++ [CRequiresSets | not (null sets)] + ++ [CRequiresArrays | not (null arrays)] + + requires requirement = requirement `Set.member` requirements + + usesGMP = any (isExactGMPKind cfg) kindInfo + usesExactInteger = isExactGMPKind cfg KUnbounded && KUnbounded `Set.member` kindInfo + + containsNestedList = containsUnsupportedCollection isList + + containsNestedSet = containsUnsupportedCollection isSet + + containsUnsupportedCollection isCollection = walk Set.empty + where walk _ kind + | isCollection kind + = False + walk visited (KTuple fields) + = any (walk visited) fields + walk visited (KList elementKind) + = walk visited elementKind + walk visited (KSet elementKind) + = walk visited elementKind + walk visited (KArray keyKind valueKind) + = walk visited keyKind || walk visited valueKind + walk visited kind + | isADT kind + , not (isRoundingMode kind) + , not (isUninterpreted kind) + = not (kind `Set.member` visited) + && any (any (walk (Set.insert kind visited)) . snd) (adtConstructors adts kind) + walk _ kind + = any isCollection (expandKinds kind) + + listElementKind (KList elementKind) = elementKind + listElementKind kind = die $ "Expected a list kind, received " ++ show kind + + setElementKind (KSet elementKind) = elementKind + setElementKind kind = die $ "Expected a set kind, received " ++ show kind + + gmpStart + | requires CRequiresGMP = gmpContextStart + | True = empty + gmpEnd + | requires CRequiresGMP = gmpContextEnd + | True = empty + + textStart + | requires CRequiresText = textContextStart + | True = empty + textEnd + | requires CRequiresText = textContextEnd + | True = empty + + listStart + | requires CRequiresLists = listContextStart + | True = empty + listEnd + | requires CRequiresLists = listContextEnd + | True = empty + + setStart + | requires CRequiresSets = setContextStart + | True = empty + setEnd + | requires CRequiresSets = setContextEnd + | True = empty + + arrayStart + | requires CRequiresArrays = arrayContextStart + | True = empty + + arrayEnd + | requires CRequiresArrays = arrayContextEnd + | True = empty + + functionContextStart + | hasStructuredCallbacks = definedFunctionContextInitialization requirements + | True = empty + + hasStructuredCallbacks = not (null structuredDefinitions && null arrayLambdaDefinitions) + + functionResultStart + | requires CRequiresFunctionResults = text "sbv_function_result_ctx sbv_local_function_result_ctx = {NULL};" + | True = empty + + functionResultEnd + | requires CRequiresFunctionResults = text "sbv_function_result_ctx_end(&sbv_local_function_result_ctx);" + | True = empty + + exactReturn = case mbRet of + Just sv | isExactGMPKind cfg (kindOf sv) + -> gmpSet (kindOf sv) (text "sbv_result") (showSV env sv) P.<> semi + _ -> empty + + arrayReturn = case mbRet of + Just sv | isArray sv + -> text "const" <+> text (arrayOutputCType (kindOf sv)) <+> text "sbv_result" <+> text "=" + <+> text (arrayExportName (kindOf sv)) P.<> parens (showSV env sv) P.<> semi + _ -> empty + + ownedTupleReturn = case mbRet of + Just sv + | tupleNeedsOwnership cfg (kindOf sv) + -> text "const" <+> text (tupleCType (kindOf sv)) <+> text "sbv_result" <+> text "=" + <+> text (tupleOwnedCloneName (kindOf sv)) P.<> parens (showSV env sv) P.<> semi + _ -> empty + + exactADTReturn = case mbRet of + Just sv + | isOwnedADT cfg adts sv + -> text "const" <+> text (adtCType (kindOf sv)) <+> text "sbv_result" <+> text "=" + <+> text (adtOwnedCloneName (kindOf sv)) + P.<> parens (showSV env sv) + P.<> semi + _ -> empty + + textReturn = case mbRet of + Just sv | kindOf sv == KString + -> text "const SString sbv_result =" <+> textClone (showSV env sv) P.<> semi + _ -> empty + + listReturn = case mbRet of + Just sv | isList sv + -> text "const" <+> text (listCType (kindOf sv)) <+> text "sbv_result =" + <+> listClone (kindOf sv) (showSV env sv) P.<> semi + _ -> empty + + setReturn = case mbRet of + Just sv | isSet sv + -> text "const" <+> text (setCType (kindOf sv)) <+> text "sbv_result =" + <+> setClone (kindOf sv) (showSV env sv) P.<> semi + _ -> empty + + normalReturn = case mbRet of + Just sv | isArray sv -> text "return sbv_result;" + Just sv | tupleNeedsOwnership cfg (kindOf sv) -> text "return sbv_result;" + Just sv | isOwnedADT cfg adts sv -> text "return sbv_result;" + Just sv | kindOf sv == KString -> text "return sbv_result;" + Just sv | isList sv -> text "return sbv_result;" + Just sv | isSet sv -> text "return sbv_result;" + Just sv | not (isExactGMPKind cfg (kindOf sv)) -> mkRet sv + _ -> empty + + codeSeg (fnm, ls) = text "/* User specified custom code for" <+> doubleQuotes (text fnm) <+> text "*/" + $$ vcat (map text ls) + $$ text "" + + ins = case topInps of + ResultTopInps (is, []) -> is + ResultTopInps is -> die $ "Unexpected trackers: " ++ show is + ResultLamInps is -> die $ "Unexpected inputs : " ++ show is + + typeWidth = getMax 0 $ [len (kindOf s) | (s, _) <- assignments] ++ [len (kindOf s) | NamedSymVar s _ <- ins] + where len (KVar s) = die $ "Variable: " ++ s + len KReal{} = 5 + len KFloat{} = 6 -- SFloat + len KDouble{} = 7 -- SDouble + len KString{} = 7 -- SString + len KChar{} = 5 -- SChar + len k@KList{} = length (listCType k) + len k@KSet{} = length (setCType k) + len KUnbounded{} = 8 + len KBool = 5 -- SBool + len (KBounded False n) = 5 + length (show n) -- SWordN + len (KBounded True n) = 4 + length (show n) -- SIntN + len KRational{} = length "SRational" + len (KFP eb sb) = 6 + length (show eb) + length (show sb) + len k@KArray{} = length (arrayCType k) + len k@KTuple{} = length (tupleCType k) + len (KApp s _) = die $ "Uninterpreted ADT app: " ++ s + len k@(KADT s _ _) + | isRoundingMode k = length (show k) + | isUninterpreted k = die $ "Uninterpreted ADT: " ++ s + | True = length (adtCType k) + + getMax m [] = m + getMax m (x:xs) = getMax (m `max` x) xs + + allConsts = (falseSV, falseCV) : (trueSV, trueCV) : preConsts + (constantDeclarations, consts) = stabilizeCConstants cfg adts typeWidth (filter ((`Set.member` usedVariables) . fst) allConsts) + env = CRenderEnv cfg adts consts + + usedVariables = cReachableValues cfg (Map.fromList assignments) tbls (map fst evaluationRoots) + + isAlive :: (String, CgVal) -> Bool + isAlive (_, CgAtomic sv) = sv `Set.member` usedVariables + isAlive (_, _) = True + + genIO :: Bool -> (Bool, (String, CgVal)) -> [Doc] + genIO True (alive, (cNm, CgAtomic sv)) + | isArray sv = [statement | alive, statement <- arrayInputSetup typeWidth sv cNm] + | isSet sv = [declSV typeWidth sv <+> text "=" <+> setNormalize (kindOf sv) (text cNm) P.<> semi | alive] + | True = [declSV typeWidth sv <+> text "=" <+> inputValue cNm sv P.<> semi | alive] + genIO False (alive, (cNm, CgAtomic sv)) + | isArray sv = [text "*" P.<> text cNm <+> text "=" <+> text (arrayExportName (kindOf sv)) P.<> parens (showSV env sv) P.<> semi | alive] + | isExactGMPKind cfg (kindOf sv) = [gmpSet (kindOf sv) (text cNm) (showSV env sv) P.<> semi | alive] + | kindOf sv == KString = [text "*" P.<> text cNm <+> text "=" <+> textClone (showSV env sv) P.<> semi | alive] + | isList sv = [text "*" P.<> text cNm <+> text "=" <+> listClone (kindOf sv) (showSV env sv) P.<> semi | alive] + | isSet sv = [text "*" P.<> text cNm <+> text "=" <+> setClone (kindOf sv) (showSV env sv) P.<> semi | alive] + | tupleNeedsOwnership cfg (kindOf sv) = [text "*" P.<> text cNm <+> text "=" <+> text (tupleOwnedCloneName (kindOf sv)) P.<> parens (showSV env sv) P.<> semi | alive] + | isOwnedADT cfg adts sv = [ text "*" P.<> text cNm <+> text "=" + <+> text (adtOwnedCloneName (kindOf sv)) + P.<> parens (showSV env sv) + P.<> semi + | alive + ] + | True = [text "*" P.<> text cNm <+> text "=" <+> showSV env sv P.<> semi | alive] + genIO isInp (_, (cNm, CgArray sws)) = zipWith genElt sws [(0::Int)..] + where genElt sv i + | isInp = vcat (genIO True (sv `Set.member` usedVariables, (entry, CgAtomic sv))) + | isExactGMPKind cfg kind = gmpSet kind (text entry) value P.<> semi + | isArray kind = text entry <+> text "=" <+> text (arrayExportName kind) P.<> parens value P.<> semi + | kind == KString = text entry <+> text "=" <+> textClone value P.<> semi + | isList kind = text entry <+> text "=" <+> listClone kind value P.<> semi + | isSet kind = text entry <+> text "=" <+> setClone kind value P.<> semi + | tupleNeedsOwnership cfg kind = text entry <+> text "=" <+> text (tupleOwnedCloneName kind) P.<> parens value P.<> semi + | isOwnedADT cfg adts sv = text entry <+> text "=" <+> text (adtOwnedCloneName kind) P.<> parens value P.<> semi + | True = text entry <+> text "=" <+> value P.<> semi + where entry = cNm ++ "[" ++ show i ++ "]" + kind = kindOf sv + value = showSV env sv + + inputValue cNm sv + | isWideBV k = wideBVNormalize k (text cNm) + | isFP k = arbitraryFPNormalize k (text cNm) + | True = text cNm + where k = kindOf sv + + mkRet sv = text "return" <+> showSV env sv P.<> semi + + genAssert (msg, cs, sv) = (cLocation consts sv, doc) + where doc = text "/* ASSERTION:" <+> cCommentText msg + $$ maybe empty (vcat . map cCommentText) (locInfo (getCallStack <$> cs)) + $$ text " */" + $$ text "if" P.<> parens (showSV env sv) + $$ text "{" + $+$ nest 2 (vcat [errOut, text "exit(-1);"]) + $$ text "}" + $$ text "" + errOut = text "fprintf" P.<> parens (fsep (punctuate comma [ text "stderr" + , cStringLiteral "%s:%d:ASSERTION FAILED: %s\n" + , text "__FILE__" + , text "__LINE__" + , cStringLiteral msg + ])) P.<> semi + locInfo (Just ps) = let loc (f, sl) = concat [srcLocFile sl, ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f ] + in case map loc ps of + [] -> Nothing + (f:rs) -> Just $ (" * SOURCE : " ++ f) : map (" * " ++) rs + locInfo _ = Nothing + + genConstraint (_, attributes, sv) = (cLocation consts sv, doc) + where doc = text "/* CONSTRAINT */" + $$ text "if" P.<> parens (text "!" P.<> parens (showSV env sv)) + $$ text "{" + $+$ nest 2 (vcat [errOut, text "exit(-1);"]) + $$ text "}" + $$ text "" + + description = fromMaybe "unnamed" (lookup ":named" attributes) + + errOut = text "fprintf" P.<> parens (fsep (punctuate comma [ text "stderr" + , cStringLiteral "%s:%d:CONSTRAINT FAILED: %s\n" + , text "__FILE__" + , text "__LINE__" + , cStringLiteral description + ])) P.<> semi + +-- | Return the source-order location used to interleave a value's dependent +-- declarations. Constants are available before every generated assignment. +cLocation :: [(SV, CV)] -> SV -> Int +cLocation constants sv@(SV _ (NodeId (_, _, nodeIndex))) + | isJust (lookup sv constants) = -1 + | True = nodeIndex + +-- | Render one finite lookup table at the point where all its elements are +-- available. Constant top-level tables may use static storage; lambda-local +-- tables always use automatic storage so their entries may depend on parameters. +ppTable :: CRenderEnv -> Bool -> ((Int, Kind, Kind), [SV]) -> (Int, Doc) +ppTable env allowStatic ((tableIndex, _, resultKind), elements) + = (location, storage <+> text tableElementType <+> tableName P.<> text "[] = {" + $$ nest 4 (fsep (punctuate comma (align (map renderElement elements)))) + $$ text "};") + where cfg = renderConfig env + location = maximum (-1 : map (cLocation (renderConstants env)) elements) + renderElement element = arrayStoredValue resultKind (showSV env element) + tableElementType + | isArray resultKind = CTypes.constElementCType resultKind + | True = "const " ++ showCType resultKind + storage + | allowStatic && location == -1 && not (tableMustBeLocal cfg resultKind) = text "static" + | True = empty + tableName = text ("table" ++ show tableIndex) + +-- | Declare the private ownership-arena bundle threaded through generated SBV +-- functions and retained array callbacks. The retain bridge creates empty +-- arenas so an escaping lambda can produce fresh managed values without +-- retaining storage owned by the call that created it. +-- Define its unused-function annotation even when no other runtime is needed. +definedFunctionContextType :: Set.Set CRequirement -> Doc +definedFunctionContextType requirements = text . unlines $ + [ cUnusedAttribute + , "" + , "typedef struct {" + ] + ++ [" void *" ++ fieldName ++ ";" | (_, _, fieldName) <- functionContextFields] + ++ [ "} sbv_function_ctx;" + , "" + , "static SBV_CGEN_UNUSED const void *sbv_function_ctx_retain_empty(const void *context)" + , "{" + , " if (context == NULL) abort();" + , " const sbv_function_ctx *source = (const sbv_function_ctx *) context;" + , " (void) source;" + , " sbv_function_ctx *owned = (sbv_function_ctx *) calloc(1, sizeof *owned);" + , " if (owned == NULL) abort();" + ] + ++ concatMap retainArena activeArenas + ++ [ " return owned;" + , "}" + , "" + , "static SBV_CGEN_UNUSED void sbv_function_ctx_release_owned(const void *context)" + , "{" + , " sbv_function_ctx *owned = (sbv_function_ctx *) context;" + , " if (owned == NULL) return;" + ] + ++ concatMap releaseArena activeArenas + ++ [ " free(owned);" + , "}" + , "" + ] + where activeArenas = [ arena + | arena@(requirement, _, _, _) <- contextArenas + , requirement `Set.member` requirements + ] + + contextArenas = [ (requirement, fieldName, contextType, contextType ++ "_end") + | (requirement, contextType, fieldName) <- functionContextFields + ] + + retainArena (_, fieldName, contextType, _) = + [ " if (source->" ++ fieldName ++ " != NULL) {" + , " " ++ contextType ++ " *arena = (" ++ contextType ++ " *) calloc(1, sizeof *arena);" + , " if (arena == NULL) abort();" + , " owned->" ++ fieldName ++ " = arena;" + , " }" + ] + + releaseArena (_, fieldName, contextType, contextEnd) = + [ " if (owned->" ++ fieldName ++ " != NULL) {" + , " " ++ contextEnd ++ "((" ++ contextType ++ " *) owned->" ++ fieldName ++ ");" + , " free(owned->" ++ fieldName ++ ");" + , " }" + ] + +-- | Initialize a private function-context bundle from the ownership arenas +-- available in the surrounding generated function. +definedFunctionContextInitialization :: Set.Set CRequirement -> Doc +definedFunctionContextInitialization requirements + = text "sbv_function_ctx sbv_local_function_ctx =" <+> braces (fsep (punctuate comma fields)) P.<> semi + where fields = [ field requirement fieldName ("sbv_local_" ++ fieldName ++ "_ctx") + | (requirement, _, fieldName) <- functionContextFields + ] + + field requirement fieldName contextName + = text ("." ++ fieldName ++ " =") <+> if requirement `Set.member` requirements + then text ("&" ++ contextName) + else text "NULL" + +-- | Test whether a private function result needs a stable deep copy because +-- its by-value representation contains independently owned aggregate storage. +definedFunctionResultNeedsClone :: CgConfig -> [Kind] -> Kind -> Bool +definedFunctionResultNeedsClone cfg adts kind + | kind == KString = True + | isList kind = True + | isSet kind = True + | KTuple{} <- kind = tupleNeedsOwnership cfg kind + | isConcreteADTReference kind = adtNeedsOwnership cfg adts kind + | True = False + +-- | Shared ownership-context fields: requirement, C arena type, and field +-- name. Private functions and array callbacks must bind the same arenas. +functionContextFields :: [(CRequirement, String, String)] +functionContextFields = + [ (CRequiresGMP, "sbv_gmp_ctx", "gmp") + , (CRequiresText, "sbv_text_ctx", "text") + , (CRequiresLists, "sbv_list_ctx", "list") + , (CRequiresSets, "sbv_set_ctx", "set") + , (CRequiresArrays, "sbv_array_ctx", "array") + , (CRequiresFunctionResults, "sbv_function_result_ctx", "function_result") + ] + +-- | Borrow required parent arenas and bind a local function context to them. +functionContextSetup :: Set.Set CRequirement -> Doc +functionContextSetup requirements + = vcat [ text contextType <+> text ("*sbv_local_parent_" ++ fieldName ++ "_ctx = (" ++ contextType ++ " *) sbv_local_parent_function_ctx->" ++ fieldName ++ ";") + $$ text contextType <+> text ("sbv_local_" ++ fieldName ++ "_ctx = *sbv_local_parent_" ++ fieldName ++ "_ctx;") + | (requirement, contextType, fieldName) <- functionContextFields, requirement `Set.member` requirements + ] + $$ text "sbv_function_ctx sbv_local_function_ctx = *sbv_local_parent_function_ctx; (void) sbv_local_function_ctx;" + $$ vcat [text ("sbv_local_function_ctx." ++ fieldName ++ " = &sbv_local_" ++ fieldName ++ "_ctx;") + | (requirement, _, fieldName) <- functionContextFields, requirement `Set.member` requirements + ] + +-- | Publish arena allocations back to the parent before returning a result. +functionContextCommit :: Set.Set CRequirement -> Doc +functionContextCommit requirements + = vcat [text ("*sbv_local_parent_" ++ fieldName ++ "_ctx = sbv_local_" ++ fieldName ++ "_ctx;") + | (requirement, _, fieldName) <- functionContextFields, requirement `Set.member` requirements + ] + +-- | Return the generated helper name that clones one private managed result +-- into the shared function-result arena. +definedFunctionResultCloneName :: Kind -> String +definedFunctionResultCloneName kind = "sbv_function_result_clone_" ++ CTypes.kindTag kind + +-- | Render a deep clone into the shared private function-result arena. +definedFunctionResultClone :: Kind -> Doc -> Doc +definedFunctionResultClone kind value + = text (definedFunctionResultCloneName kind) + P.<> parens (fsep (punctuate comma [text "&sbv_local_function_result_ctx", value])) + +-- | Emit temporary ownership storage for managed values returned by private +-- generated functions or retained array callbacks. Public boundaries clone +-- these values once more before this arena is released. +definedFunctionResultRuntime :: [Kind] -> Doc +definedFunctionResultRuntime [] = empty +definedFunctionResultRuntime kinds = text . unlines $ + [ "/* Stable storage for managed private-function and array-lambda results. */" + , "typedef void (*sbv_function_result_release)(void *);" + , "typedef struct sbv_function_result_node {" + , " struct sbv_function_result_node *next;" + , " void *value;" + , " sbv_function_result_release release;" + , "} sbv_function_result_node;" + , "typedef struct { sbv_function_result_node *head; } sbv_function_result_ctx;" + , "" + , "static SBV_CGEN_UNUSED void sbv_function_result_ctx_remember(sbv_function_result_ctx *ctx, void *value, sbv_function_result_release release)" + , "{" + , " sbv_function_result_node *node = (sbv_function_result_node *) malloc(sizeof(*node));" + , " if (ctx == NULL || value == NULL || release == NULL || node == NULL) abort();" + , " node->next = ctx->head;" + , " node->value = value;" + , " node->release = release;" + , " ctx->head = node;" + , "}" + , "" + , "static SBV_CGEN_UNUSED void sbv_function_result_ctx_end(sbv_function_result_ctx *ctx)" + , "{" + , " while (ctx->head != NULL) {" + , " sbv_function_result_node *node = ctx->head;" + , " ctx->head = node->next;" + , " node->release(node->value);" + , " free(node);" + , " }" + , "}" + , "" + ] + ++ concatMap helpers kinds + where helpers kind = + [ "static SBV_CGEN_UNUSED void " ++ releaseName ++ "(void *opaque)" + , "{" + , " " ++ cType ++ " *value = (" ++ cType ++ " *) opaque;" + , " " ++ render (managedValueRelease kind (text "value")) + , " free(value);" + , "}" + , "" + , "static SBV_CGEN_UNUSED " ++ cType ++ " " ++ cloneName ++ "(sbv_function_result_ctx *ctx, " ++ cType ++ " value)" + , "{" + , " " ++ cType ++ " *result = (" ++ cType ++ " *) malloc(sizeof(*result));" + , " if (result == NULL) abort();" + , " *result = " ++ render (managedValueClone kind (text "value")) ++ ";" + , " sbv_function_result_ctx_remember(ctx, result, " ++ releaseName ++ ");" + , " return *result;" + , "}" + , "" + ] + where cType = showCType kind + cloneName = definedFunctionResultCloneName kind + releaseName = "sbv_function_result_release_" ++ CTypes.kindTag kind + +-- | Render the private C signature shared by a defined function's prototype +-- and implementation. +definedFunctionSignature :: String -> Kind -> [(Quantifier, SV)] -> Doc +definedFunctionSignature originalName resultKind parameters + = text "static" <+> text resultType <+> text (CTypes.definedFunctionCName originalName) + P.<> parens renderedParameters + where resultType + | isArray resultKind = CTypes.elementCType resultKind + | True = showCType resultKind + + renderedParameters = fsep . punctuate comma $ + text "sbv_function_ctx *const sbv_local_parent_function_ctx" + : [text "const" <+> text (showCType parameter) <+> text (show parameter) | (_, parameter) <- parameters] + +-- | Lower one first-order SBV function definition from its retained expression +-- DAG. All definitions use demand-driven control flow so operations protected +-- by conditionals and short-circuiting Boolean operations remain protected in +-- C, including partial ADT selectors in acyclic functions. Closed nested array +-- lambdas are lambda-lifted into private callbacks; +-- SBV's firstified higher-order specializations arrive through the same +-- first-order representation. +ppDefinedFunction :: CgConfig + -> [Kind] + -> [(T.Text, String)] + -> String + -> Kind + -> SBVType + -> LambdaInfo + -> (Doc, Set.Set CRequirement) +ppDefinedFunction cfg adts functionNames originalName declaredResultKind (SBVType signatureKinds) + LambdaInfo{ liAssignments = functionProgram + , liParams = parameters + , liOutput = functionOutput + , liConsts = constants + , liTables = tables + } + | null signatureKinds + = die $ "Empty type for defined function " ++ show originalName + | declaredResultKind /= resultKind + = die $ "Result-kind mismatch in defined function " ++ show originalName + | map (kindOf . snd) parameters /= parameterKinds + = die $ "Parameter-kind mismatch in defined function " ++ show originalName + | any ((/= ALL) . fst) parameters + = die $ "Non-universal parameter in defined function " ++ show originalName + | kindOf functionOutput /= resultKind + = die $ "Output-kind mismatch in defined function " ++ show originalName + | not (null unsupportedManagedKinds) + = tbd $ "Managed values in defined function " ++ show originalName ++ ": " ++ intercalate ", " (map show unsupportedManagedKinds) + | True + = (functionDoc, functionRequirements) + where (parameterKinds, resultKind) = (init signatureKinds, last signatureKinds) + assignments = F.toList functionProgram + functionConsts = (falseSV, falseCV) : (trueSV, trueCV) : constants + reachableValues = cReachableValues cfg (Map.fromList assignments) tables [functionOutput] + (constantDeclarations, renderingConsts) = stabilizeCConstants cfg adts typeWidth (filter ((`Set.member` reachableValues) . fst) functionConsts) + env = CRenderEnv cfg adts renderingConsts + functionValues = functionOutput : map snd parameters ++ map fst assignments ++ map fst constants + typeWidth = maximum (0 : map (length . showCType) functionValues) + nestedLambdaNames = [ (sv, scopedArrayLambdaName (CTypes.definedFunctionCName originalName) sv) + | (sv, SBVApp (ArrayInit (Right _)) _) <- assignments + ] + unsupportedManagedKinds = nub [ kind + | value <- functionValues + , let kind = kindOf value + , functionValueHasUnsupportedManagedStorage kind + ] + + functionValueHasUnsupportedManagedStorage kind + | isExactGMPKind cfg kind = False + | kind == KString = False + | isList kind = False + | isSet kind = False + | isArray kind = False + | KTuple fields <- kind = any functionValueHasUnsupportedManagedStorage fields + | isConcreteADTReference kind = False + | True = valueNeedsOwnership cfg kind + + (scheduledAssignments, scheduledRequirements) = + scheduleC env functionNames nestedLambdaNames + (map fst functionConsts ++ map snd parameters) assignments tables False typeWidth [(functionOutput, empty)] + + functionRequirements = Set.unions + [ Set.fromList $ [CRequiresGMP | any (isExactGMPKind cfg) expandedFunctionKinds] + ++ [CRequiresText | KString `elem` expandedFunctionKinds] + ++ [CRequiresLists | any isList expandedFunctionKinds] + ++ [CRequiresSets | any isSet expandedFunctionKinds] + ++ [CRequiresArrays | any isArray expandedFunctionKinds] + ++ [CRequiresFunctionResults | definedFunctionResultNeedsClone cfg adts resultKind] + , scheduledRequirements + , Set.unions [operationRequirements cfg (op, kindOf sv) | (sv, SBVApp op _) <- assignments] + ] + + expandedFunctionKinds = concatMap (expandKinds . kindOf) functionValues + + contextSetup = functionContextSetup functionRequirements + contextCommit = functionContextCommit functionRequirements + + functionDoc + = definedFunctionSignature originalName resultKind parameters + $$ text "{" + $$ nest 2 ( contextSetup + $$ constantDeclarations + $$ functionAssignments + $$ functionResultDeclaration <+> text "sbv_local_function_result =" <+> functionResult P.<> semi + $$ contextCommit + $$ text "return sbv_local_function_result;" + ) + $$ text "}" + $$ text "" + + functionAssignments = scheduledAssignments + + functionResult + | isArray resultKind + = arrayStoredValue resultKind (showSV env functionOutput) + | definedFunctionResultNeedsClone cfg adts resultKind + = definedFunctionResultClone resultKind (showSV env functionOutput) + | True + = showSV env functionOutput + + functionResultType + | isArray resultKind = CTypes.elementCType resultKind + | True = showCType resultKind + + functionResultDeclaration + | isArray resultKind = text functionResultType + | True = text "const" <+> text functionResultType + +-- | Collect every operand, including values retained inside an operator +-- instead of its ordinary argument list and the entries of referenced tables. +-- Defaults omitted by unchecked or provably in-range lookups are not live. +cExpressionDependencies :: CgConfig -> [((Int, Kind, Kind), [SV])] -> SBVExpr -> [SV] +cExpressionDependencies cfg tables (SBVApp op arguments) = arguments ++ case op of + LkUp (tableIndex, indexKind, _, tableLength) index defaultValue + -> index : [defaultValue | tableNeedsBounds cfg indexKind, isJust (snd (tableIndexAndBounds cfg indexKind tableLength empty))] + ++ [value | ((candidateIndex, _, _), values) <- tables, candidateIndex == tableIndex, value <- values] + IEEEFP (FP_Cast _ _ rmSV) -> [rmSV] + _ -> [] + +-- | Find the complete demand closure of a collection of roots. Inputs and +-- constants are included, so declaration liveness and evaluation scheduling +-- use the same dependency graph. +cReachableValues :: CgConfig -> Map.Map SV SBVExpr -> [((Int, Kind, Kind), [SV])] -> [SV] -> Set.Set SV +cReachableValues cfg assignments tables = foldl reach Set.empty + where reach visited sv + | sv `Set.member` visited = visited + | True = foldl reach (Set.insert sv visited) + (maybe [] (cExpressionDependencies cfg tables) (Map.lookup sv assignments)) + +-- | Give managed constants function-wide backing storage. Rendering compound +-- literals inside a conditional would otherwise leave dangling pointers when +-- a descriptor is used after that branch exits. A lowering may elide a live +-- operand, such as an unreachable table default, so acknowledge each binding +-- even if its rendered use disappears. +stabilizeCConstants :: CgConfig -> [Kind] -> Int -> [(SV, CV)] -> (Doc, [(SV, CV)]) +stabilizeCConstants cfg adts typeWidth constants + = ( vcat [ declSV typeWidth sv <+> text "=" <+> mkConst env cv P.<> semi + $$ text "(void)" <+> text (show sv) P.<> semi + | (sv, cv) <- stabilized + ] + , filter ((`Set.notMember` stabilizedValues) . fst) constants + ) + where env = CRenderEnv cfg adts constants + stabilized = [(sv, cv) | (sv, cv) <- constants, isArray sv || definedFunctionResultNeedsClone cfg adts (kindOf sv)] + stabilizedValues = Set.fromList (map fst stabilized) + +-- | Recognize total bit-vector operations that may be computed before a +-- guard when all their dependencies are already safe. Restrict speculation +-- to the exact bit-vector runtime: calls, selectors, allocation, and native +-- floating-point operations retain their demand ordering. +cSpeculatable :: SV -> SBVExpr -> Bool +cSpeculatable result (SBVApp op arguments) = all bitVector (result : arguments) && totalOperation op + where bitVector sv = kindOf sv == KBool || isBounded sv + + totalOperation operation = case operation of + Plus -> True + Times -> True + Minus -> True + UNeg -> True + Abs -> True + Quot -> True + Rem -> True + Equal{} -> True + NotEqual -> True + LessThan -> True + GreaterThan -> True + LessEq -> True + GreaterEq -> True + Ite -> True + Implies -> True + And -> True + Or -> True + XOr -> True + Not -> True + Shl -> True + Shr -> True + Rol{} -> True + Ror{} -> True + Extract{} -> True + Join -> True + _ -> False + +-- | Path-sensitive scheduling facts. Tables, unlike hoisted values, are local +-- to the C block that declares them. Memoized values accumulate across paths. +data CAvailability = CAvailability + { definitelyAvailable :: Set.Set SV -- ^ Values computed on every incoming path. + , possiblyAvailable :: Set.Set SV -- ^ Values computed on some incoming path. + , availableCTables :: Set.Set Int -- ^ Tables declared in the current scope. + , memoizedValues :: Set.Set SV -- ^ Values requiring a runtime readiness check. + } + +-- | Schedule a collection of demanded values and their following statements. +-- Branch-local work stays under its guard, while declarations are hoisted so +-- values computed on both paths can safely be reused after the join. Root +-- statements let entry points retain runtime checks even without live outputs. +scheduleC :: CRenderEnv + -> [(T.Text, String)] + -> [(SV, String)] + -> [SV] + -> [(SV, SBVExpr)] + -> [((Int, Kind, Kind), [SV])] + -> Bool + -> Int + -> [(SV, Doc)] + -> (Doc, Set.Set CRequirement) +scheduleC env functionNames lambdaNames initialValues assignments tables allowStatic typeWidth roots + = (vcat eagerDocs $$ declarations $$ statements, Set.union requirements eagerRequirements) + where cfg = renderConfig env + initialAvailability = CAvailability eagerValues eagerValues Set.empty Set.empty + (analyzed, _, _, _) = schedulePass Set.empty + guardedValues = memoizedValues analyzed + (_, statements, requirements, extraDeclarations) = guardedValues `seq` schedulePass guardedValues + declarations = vcat [typ <+> var <+> (if sv `Set.member` guardedValues then text "= {0}" else empty) P.<> semi + | (sv, _) <- assignments + , sv `Set.member` reachableValues + , sv `Set.notMember` eagerValues + , let (typ, var) = declSVNoConst typeWidth sv + ] + $$ vcat [text "bool" <+> readyName sv <+> text "= false;" | sv <- Set.toList guardedValues] + $$ vcat (uniqueOn render extraDeclarations) + + assignmentMap = Map.fromList assignments + reachableValues = cReachableValues cfg assignmentMap tables (map fst roots) + + -- The first pass discovers which values need readiness flags. The + -- second pass receives that completed set explicitly. Even forcing + -- first-pass documents cannot create a dependency on the second pass. + readyName sv = text ("sbv_ready_" ++ show sv) + + (eagerValues, eagerReversed) = foldl speculate (Set.fromList initialValues, []) assignments + eagerLowerings = [ppExpr env functionNames lambdaNames expression sv + (declSV typeWidth sv) (declSVNoConst typeWidth sv) True + | (sv, expression) <- reverse eagerReversed] + eagerDocs = [doc | (doc, _, _) <- eagerLowerings] + eagerRequirements = Set.unions [needed | (_, needed, _) <- eagerLowerings] + + speculate available@(values, emitted) assignment@(sv, expression) + | sv `Set.member` reachableValues + , cSpeculatable sv expression + , all (`Set.member` values) (cExpressionDependencies cfg tables expression) + = (Set.insert sv values, assignment : emitted) + | True + = available + + schedulePass markedValues = emitRoots initialAvailability roots + where + emitRoots available [] = (available, empty, Set.empty, []) + emitRoots available ((sv, action):rest) = + let (withValue, valueDocs, valueRequirements, valueDeclarations) = emit available sv + (withRest, restDocs, restRequirements, restDeclarations) = emitRoots withValue rest + in ( withRest + , valueDocs $$ action $$ restDocs + , Set.union valueRequirements restRequirements + , valueDeclarations ++ restDeclarations + ) + + emit available sv + | sv `Set.member` definitelyAvailable available + = (available, empty, Set.empty, []) + | True + = let (after, docs, needed, decls) = emitAssignment available sv + marked = docs $$ if sv `Set.member` markedValues then readyName sv <+> text "= true;" else empty + guarded = text "if" P.<> parens (text "!" P.<> readyName sv) + $$ text "{" + $$ nest 2 marked + $$ text "}" + in if sv `Set.member` possiblyAvailable available + then (after { availableCTables = availableCTables available + , memoizedValues = Set.insert sv (memoizedValues after) + }, guarded, needed, decls) + else (after, marked, needed, decls) + + emitAssignment available sv + | Just expression@(SBVApp op arguments) <- Map.lookup sv assignmentMap + = case (op, arguments) of + (LkUp tableInfo index defaultValue, []) + -> tableLookup available sv expression tableInfo index defaultValue + (Ite, [condition, trueValue, falseValue]) + -> conditional available sv condition trueValue falseValue + (And, [left, right]) + | kindOf sv == KBool + -> conditional available sv left right falseSV + (Or, [left, right]) + | kindOf sv == KBool + -> conditional available sv left trueSV right + (Implies, [left, right]) + | kindOf sv == KBool + -> conditional available sv left right trueSV + _ -> let (withArguments, argumentDocs, argumentRequirements, argumentDeclarations) = emitMany available + (cExpressionDependencies cfg tables expression) + (withTable, tableDocs) = emitTable withArguments op + (assignmentDoc, assignmentRequirements, assignmentDeclarations) = + ppExpr env functionNames lambdaNames expression sv (text (show sv)) + (declSVNoConst typeWidth sv) False + in ( insertAvailableValue sv withTable + , argumentDocs $$ tableDocs $$ assignmentDoc + , Set.union argumentRequirements assignmentRequirements + , argumentDeclarations ++ assignmentDeclarations + ) + | True + = die $ "Missing assignment while scheduling C evaluation: " ++ show sv + + emitMany available [] = (available, empty, Set.empty, []) + emitMany available (sv:svs) = + let (withValue, valueDocs, valueRequirements, valueDeclarations) = emit available sv + (withRest, restDocs, restRequirements, restDeclarations) = emitMany withValue svs + in ( withRest + , valueDocs $$ restDocs + , Set.union valueRequirements restRequirements + , valueDeclarations ++ restDeclarations + ) + + emitTable available op + | LkUp (tableIndex, _, _, _) _ _ <- op + , tableIndex `Set.notMember` availableCTables available + = case [table | table@((candidateIndex, _, _), _) <- tables, candidateIndex == tableIndex] of + [table] -> (insertAvailableTable tableIndex available, snd (ppTable env allowStatic table)) + _ -> die "Missing table while scheduling C evaluation" + | True + = (available, empty) + + tableLookup available result expression (tableIndex, indexKind, _, tableLength) index defaultValue = + let (withIndex, indexDocs, indexRequirements, indexDeclarations) = emit available index + (afterLookup, lookupDocs, lookupRequirements, lookupDeclarations) = selectValue withIndex + in ( afterLookup + , indexDocs $$ lookupDocs + , Set.union indexRequirements lookupRequirements + , indexDeclarations ++ lookupDeclarations + ) + where elements = case [values | ((candidateIndex, _, _), values) <- tables, candidateIndex == tableIndex] of + [values] | length values == tableLength -> values + _ -> die "Missing or inconsistent table while scheduling C evaluation" + (nativeIndex, outOfRange) = tableIndexAndBounds cfg indexKind tableLength (showSV env index) + checkedBounds = if tableNeedsBounds cfg indexKind then outOfRange else Nothing + entriesReady current = all (`Set.member` definitelyAvailable current) elements + + selectValue current + | entriesReady current + , isNothing checkedBounds || defaultValue `Set.member` definitelyAvailable current + = renderLookup cfg current + | Just check <- checkedBounds + = let (withDefault, defaultDocs, defaultRequirements, defaultDeclarations) = emitChoice current defaultValue + (withEntry, entryDocs, entryRequirements, entryDeclarations) = selectEntry current + in ( insertAvailableValue result (joinAvailability current [withDefault, withEntry]) + , text "if" P.<> parens check + $$ text "{" $$ nest 2 defaultDocs $$ text "}" + $$ text "else" + $$ text "{" $$ nest 2 entryDocs $$ text "}" + , Set.union defaultRequirements entryRequirements + , defaultDeclarations ++ entryDeclarations + ) + | True + = selectEntry current + + selectEntry current + | entriesReady current + , isNothing checkedBounds || defaultValue `Set.member` definitelyAvailable current + = renderLookup (cfg {cgRTC = False}) current + | True + = let cases = [(position, emitChoice current value) | (position, value) <- zip [0 :: Int ..] elements] + renderCase (position, (_, docs, _, _)) = text "case" <+> int position P.<> colon + $$ text "{" + $$ nest 2 (docs $$ text "break;") + $$ text "}" + availableAfter = joinAvailability current [values | (_, (values, _, _, _)) <- cases] + in ( insertAvailableValue result availableAfter + , text "switch" P.<> parens (text "(uint64_t)" <+> parens nativeIndex) + $$ text "{" + $$ nest 2 (vcat (map renderCase cases) + $$ text "default:" + $$ nest 2 (text "/* Unreachable for checked indices; invalid unchecked index. */" $$ text "abort();")) + $$ text "}" + , Set.unions [needed | (_, (_, _, needed, _)) <- cases] + , concat [decls | (_, (_, _, _, decls)) <- cases] + ) + + emitChoice current value = + let (withValue, docs, needed, decls) = emit current value + in ( insertAvailableValue result withValue + , docs $$ text (show result) <+> text "=" <+> showSV env value P.<> semi + , needed + , decls + ) + + renderLookup loweringConfig current = + let SBVApp op _ = expression + (withTable, tableDocs) = emitTable current op + (docs, needed, decls) = ppExpr env{renderConfig = loweringConfig} functionNames lambdaNames expression result + (text (show result)) (declSVNoConst typeWidth result) False + in (insertAvailableValue result withTable, tableDocs $$ docs, needed, decls) + + conditional available result condition trueValue falseValue = + let (withCondition, conditionDocs, conditionRequirements, conditionDeclarations) = emit available condition + shared = Set.intersection (mandatoryValues withCondition trueValue) (mandatoryValues withCondition falseValue) + (withCommon, commonDocs, commonRequirements, commonDeclarations) = emitMany withCondition (Set.toList shared) + (withTrue, trueDocs, trueRequirements, trueDeclarations) = emit withCommon trueValue + (withFalse, falseDocs, falseRequirements, falseDeclarations) = emit withCommon falseValue + branch label branchDocs branchValue = text label + $$ text "{" + $$ nest 2 (branchDocs $$ assign branchValue) + $$ text "}" + assign value = text (show result) <+> text "=" <+> showSV env value P.<> semi + docs = conditionDocs + $$ commonDocs + $$ text "if" P.<> parens (showSV env condition) + $$ branch "" trueDocs trueValue + $$ branch "else" falseDocs falseValue + needed = Set.unions [conditionRequirements, commonRequirements, trueRequirements, falseRequirements] + -- Values are declared outside the branches, but branch-local C + -- table declarations do not remain in scope after the join. + availableAfter = joinAvailability withCommon [withTrue, withFalse] + branchDeclarations = conditionDeclarations ++ commonDeclarations ++ trueDeclarations ++ falseDeclarations + in (insertAvailableValue result availableAfter, docs, needed, branchDeclarations) + + -- Sharing a mandatory dependency is safe even for partial operations: + -- either branch will demand it. Stop at nested guards rather than + -- treating their inactive alternatives as mandatory dependencies. + mandatoryValues available = walk Set.empty + where walk visited sv + | sv `Set.member` definitelyAvailable available || sv `Set.member` visited = visited + | True = foldl walk (Set.insert sv visited) dependencies + where dependencies = case Map.lookup sv assignmentMap of + Just (SBVApp Ite (condition:_)) -> [condition] + Just (SBVApp (LkUp _ index _) _) -> [index] + Just (SBVApp op (left:_)) + | kindOf sv == KBool, op `elem` [And, Or, Implies] -> [left] + Just expression -> cExpressionDependencies cfg tables expression + Nothing -> [] + + joinAvailability current [] = current + joinAvailability current branches@(initial:rest) = current + { definitelyAvailable = foldl Set.intersection (definitelyAvailable initial) (map definitelyAvailable rest) + , possiblyAvailable = Set.unions (map possiblyAvailable branches) + , memoizedValues = Set.unions (map memoizedValues branches) + } + + insertAvailableValue value available = available + { definitelyAvailable = Set.insert value (definitelyAvailable available) + , possiblyAvailable = Set.insert value (possiblyAvailable available) + } + + insertAvailableTable tableIndex available = available {availableCTables = Set.insert tableIndex (availableCTables available)} + +-- | Give a lambda-lifted array callback a name unique to its lexical owner. +scopedArrayLambdaName :: String -> SV -> String +scopedArrayLambdaName scope arraySV = scope ++ "_nested_" ++ show arraySV + +-- | Render the private C signature for a structured array callback. +-- Captures are rejected separately before any callback is lowered. +arrayLambdaSignature :: String -> SV -> LambdaInfo -> Doc +arrayLambdaSignature callbackName arraySV LambdaInfo{liParams = parameters} + = case (kindOf arraySV, parameters) of + (KArray _ valueKind, [(ALL, parameter)]) + -> text "static" <+> text (arrayLambdaResultType valueKind) <+> text callbackName + P.<> parens (fsep (punctuate comma [text "const void *context", text (showCType (kindOf parameter)) <+> text (show parameter)])) + (KArray{}, _) -> die $ "Expected exactly one universal array-lambda parameter, received " ++ show parameters + (kind, _) -> die $ "Expected an array-valued lambda node, received " ++ show kind + +-- | Return the C callback result type for an array element kind. +arrayLambdaResultType :: Kind -> String +arrayLambdaResultType kind + | isArray kind = CTypes.elementCType kind + | True = showCType kind + +-- | Conservatively check the complete retained body for free symbolic values, +-- independently of scheduling or dead-code elimination. Include values hidden +-- in operators, every table entry/default, the result itself, and free values +-- of nested array lambdas. Each nested callback is also checked separately, +-- so capturing its enclosing lambda's parameter is rejected too. +cLambdaFreeValues :: LambdaInfo -> [SV] +cLambdaFreeValues lambdaInfo = Set.toList $ Set.fromList uses `Set.difference` bound + where assignments = F.toList (liAssignments lambdaInfo) + bound = Set.fromList (falseSV : trueSV : map fst assignments ++ map snd (liParams lambdaInfo) ++ map fst (liConsts lambdaInfo)) + uses = liOutput lambdaInfo : concatMap (dependencies . snd) assignments ++ concatMap snd (liTables lambdaInfo) + + dependencies (SBVApp op arguments) = arguments ++ case op of + LkUp _ index defaultValue -> [index, defaultValue] + IEEEFP (FP_Cast _ _ rm) -> [rm] + ArrayInit (Right lambdaDef) + | Just nested <- smtLambdaInfo lambdaDef -> cLambdaFreeValues nested + _ -> [] + +-- | Lower a retained one-argument array lambda into a C lookup callback. Its +-- local DAG uses the ordinary lowering pipeline, so scalar and managed values +-- share the same semantics and ownership arenas as the enclosing generated +-- function. +ppArrayLambda :: CgConfig + -> [Kind] + -> [(T.Text, String)] + -> String + -> SV + -> LambdaInfo + -> (Doc, Set.Set CRequirement) +ppArrayLambda cfg adts functionNames callbackName arraySV lambdaInfo@LambdaInfo{ liAssignments = lambdaPgm + , liParams = parameters + , liOutput = lambdaOutput + , liConsts = constants + , liTables = tables + } + = case (kindOf arraySV, parameters) of + (KArray keyKind valueKind, [(ALL, parameter)]) + | kindOf parameter /= keyKind + -> die $ "Array-lambda parameter kind " ++ show (kindOf parameter) ++ " does not match " ++ show keyKind + | kindOf lambdaOutput /= valueKind + -> die $ "Array-lambda result kind " ++ show (kindOf lambdaOutput) ++ " does not match " ++ show valueKind + | True + -> (helper keyKind valueKind parameter, requirements) + (KArray{}, _) -> die $ "Expected exactly one universal array-lambda parameter, received " ++ show parameters + (kind, _) -> die $ "Expected an array-valued lambda node, received " ++ show kind + where assignments = F.toList lambdaPgm + lambdaConsts = (falseSV, falseCV) : (trueSV, trueCV) : constants + reachableValues = cReachableValues cfg (Map.fromList assignments) tables [lambdaOutput] + (constantDeclarations, renderingConsts) = stabilizeCConstants cfg adts typeWidth (filter ((`Set.member` reachableValues) . fst) lambdaConsts) + env = CRenderEnv cfg adts renderingConsts + lambdaValues = lambdaOutput : map snd parameters ++ map fst assignments ++ map fst constants ++ concatMap snd tables + typeWidth = maximum (0 : map (length . showCType) lambdaValues) + + nestedLambdaNames = [ (sv, scopedArrayLambdaName callbackName sv) + | (sv, SBVApp (ArrayInit (Right _)) _) <- assignments + ] + definedFunctionCalls = [ symbol + | (_, SBVApp (Uninterpreted symbol) _) <- assignments + , isJust (lookup symbol functionNames) + ] + + (scheduledAssignments, scheduledRequirements) = + scheduleC env functionNames nestedLambdaNames + (map fst lambdaConsts ++ map snd parameters) assignments tables False typeWidth [(lambdaOutput, empty)] + + requirements = Set.unions + [ contextRequirements + , scheduledRequirements + , Set.unions [operationRequirements cfg (op, kindOf sv) | (sv, SBVApp op _) <- assignments] + ] + + expandedLambdaKinds = concatMap (expandKinds . kindOf) lambdaValues + + contextRequirements = Set.fromList $ + [CRequiresGMP | any (isExactGMPKind cfg) expandedLambdaKinds] + ++ [CRequiresText | any (`elem` [KChar, KString]) expandedLambdaKinds] + ++ [CRequiresLists | any isList expandedLambdaKinds] + ++ [CRequiresSets | any isSet expandedLambdaKinds] + ++ [CRequiresArrays | any isArray expandedLambdaKinds] + ++ [CRequiresFunctionResults | definedFunctionResultNeedsClone cfg adts (kindOf lambdaOutput)] + + helper _ valueKind _ + = arrayLambdaSignature callbackName arraySV lambdaInfo + $$ text "{" + $$ nest 2 ( contextSetup + $$ constantDeclarations + $$ scheduledAssignments + $$ lambdaResultDeclaration valueKind <+> text "sbv_local_lambda_result" <+> text "=" <+> lambdaResult P.<> semi + $$ contextCommit + $$ text "return sbv_local_lambda_result;" + ) + $$ text "}" + $$ text "" + + lambdaResult + | isArray lambdaOutput + = arrayStoredValue (kindOf lambdaOutput) (showSV env lambdaOutput) + | definedFunctionResultNeedsClone cfg adts (kindOf lambdaOutput) + = definedFunctionResultClone (kindOf lambdaOutput) (showSV env lambdaOutput) + | True + = showSV env lambdaOutput + + lambdaResultDeclaration valueKind + | isArray lambdaOutput = text (arrayLambdaResultType valueKind) + | True = text "const" <+> text (arrayLambdaResultType valueKind) + + contextSetup + | not needsFunctionContext = parens (text "void") <+> text "context" P.<> semi + | True + = text "sbv_function_ctx *const sbv_local_parent_function_ctx = (sbv_function_ctx *) context;" + $$ functionContextSetup contextRequirements + + contextCommit = functionContextCommit contextRequirements + + needsFunctionContext = not (Set.null contextRequirements && null definedFunctionCalls) + + +-- | Lower native IEEE operations not handled by the explicit LibBF adapters. +handleIEEE :: FPOp -> [(SV, CV)] -> [(SV, Doc)] -> Doc -> Doc +handleIEEE w consts as var = cvt w + where same f = (f, f) + named fnm dnm f = (f fnm, f dnm) + + unary f [a] = f a + unary _ args = wrongArity 1 args + binary f [a, b] = f a b + binary _ args = wrongArity 2 args + ternary f [a, b, c] = f a b c + ternary _ args = wrongArity 3 args + wrongArity expected args = die $ "Native floating-point operation " ++ show w ++ " expects " + ++ show (expected :: Int) ++ " arguments, received " ++ show (length args) + + cvt FP_Cast{} = die "Floating-point cast escaped the exact cast lowering pipeline" + + cvt (FP_Reinterpret f t) = case (f, t) of + (KBounded False 32, KFloat) -> cast $ cpy "sizeof(SFloat)" + (KBounded False 64, KDouble) -> cast $ cpy "sizeof(SDouble)" + (KFloat, KBounded False 32) -> cast $ cpy "sizeof(SWord32)" + (KDouble, KBounded False 64) -> cast $ cpy "sizeof(SWord64)" + _ -> die $ "Reinterpretation from : " ++ show f ++ " to " ++ show t + where cpy sz = unary $ \a -> text "memcpy" P.<> parens (fsep (punctuate comma + [text "&" P.<> var, text "&" P.<> a, text sz])) + cvt FP_Abs = dispatch $ named "fabsf" "fabs" $ \nm _ -> unary $ \a -> text nm P.<> parens a + cvt FP_Neg = dispatch $ same $ \_ -> unary $ \a -> text "-" P.<> a + cvt FP_Add = dispatch $ same $ \_ -> binary $ \a b -> a <+> text "+" <+> b + cvt FP_Sub = dispatch $ same $ \_ -> binary $ \a b -> a <+> text "-" <+> b + cvt FP_Mul = dispatch $ same $ \_ -> binary $ \a b -> a <+> text "*" <+> b + cvt FP_Div = dispatch $ same $ \_ -> binary $ \a b -> a <+> text "/" <+> b + cvt FP_FMA = dispatch $ named "fmaf" "fma" $ \nm _ -> ternary $ \a b c -> text nm P.<> parens (fsep (punctuate comma [a, b, c])) + cvt FP_Sqrt = dispatch $ named "sqrtf" "sqrt" $ \nm _ -> unary $ \a -> text nm P.<> parens a + cvt FP_Rem = dispatch $ named "remainderf" "remainder" $ \nm _ -> binary $ \a b -> text nm P.<> parens (fsep (punctuate comma [a, b])) + cvt FP_RoundToIntegral = dispatch $ named "rintf" "rint" $ \nm _ -> unary $ \a -> text nm P.<> parens a + cvt FP_Min = dispatch $ named "fminf" "fmin" $ \nm k -> binary $ \a b -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) + cvt FP_Max = dispatch $ named "fmaxf" "fmax" $ \nm k -> binary $ \a b -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) + cvt FP_ObjEqual = dispatch $ same $ \_ -> binary $ \a b -> nativeFPObjectEqual a b + cvt FP_IsNormal = dispatch $ same $ \_ -> unary $ \a -> text "isnormal" P.<> parens a + cvt FP_IsSubnormal = dispatch $ same $ \_ -> unary $ \a -> text "FP_SUBNORMAL == fpclassify" P.<> parens a + cvt FP_IsZero = dispatch $ same $ \_ -> unary $ \a -> text "FP_ZERO == fpclassify" P.<> parens a + cvt FP_IsInfinite = dispatch $ same $ \_ -> unary $ \a -> text "isinf" P.<> parens a + cvt FP_IsNaN = dispatch $ same $ \_ -> unary $ \a -> text "isnan" P.<> parens a + cvt FP_IsNegative = dispatch $ same $ \_ -> unary $ \a -> text "!isnan" P.<> parens a <+> text "&&" <+> text "signbit" P.<> parens a + cvt FP_IsPositive = dispatch $ same $ \_ -> unary $ \a -> text "!isnan" P.<> parens a <+> text "&&" <+> text "!signbit" P.<> parens a + + -- grab the rounding-mode, if present, and make sure it's RoundNearestTiesToEven. Otherwise skip. + fpArgs = case as of + [] -> [] + ((m, _):args) + | isRoundingMode m -> case checkRM (m `lookup` consts) of + Nothing -> args + Just (Left msg) -> die msg + Just (Right msg) -> tbd msg + | True -> as + + -- Explicit non-default and symbolic rounding modes are handled by the + -- LibBF adapters before this native fallback is selected. + checkRM (Just cv@(CV k v)) + | k == kRoundingMode = case v of + CADT ("RoundNearestTiesToEven", []) -> Nothing + CADT (s, []) -> Just (Right $ "handleIEEE: Unsupported rounding-mode: " ++ show s ++ " for: " ++ show w) + _ -> Just (Left $ "handleIEEE: Unexpected value for rounding-mode: " ++ show cv ++ " for: " ++ show w) + checkRM (Just cv) = Just (Left $ "handleIEEE: Expected rounding-mode, but got: " ++ show cv ++ " for: " ++ show w) + checkRM Nothing = Just (Right $ "handleIEEE: Non-constant rounding-mode for: " ++ show w) + + pickOp _ [] = die $ "Cannot determine float/double kind for op: " ++ show w + pickOp (fOp, dOp) args@((a,_):_) = case kindOf a of + KFloat -> fOp KFloat (map snd args) + KDouble -> dOp KDouble (map snd args) + k -> die $ "handleIEEE: Expected double/float args, but got: " ++ show k ++ " for: " ++ show w + + dispatch (fOp, dOp) = pickOp (fOp, dOp) fpArgs + cast f = f (map snd fpArgs) + + -- In SMT-Lib, fpMin/fpMax is underspecified when given +0/-0 as the two arguments. (In any order.) + -- In C, the second argument is returned. (I think, might depend on the architecture, optimizations etc.). + -- We'll translate it so that we deterministically return +0. + -- There's really no good choice here. + wrapMinMax k a b s = parens cond <+> text "?" <+> fzero <+> text ":" <+> s + where fzero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 + cond = parens (text "FP_ZERO == fpclassify" P.<> parens a) -- a is zero + <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" P.<> parens b) -- b is zero + <+> text "&&" <+> parens (text "signbit" P.<> parens a <+> text "!=" <+> text "signbit" P.<> parens b) -- a and b differ in sign + +-- | Lower and render one symbolic assignment together with the facilities it +-- requires from the generated C translation unit. +ppExpr :: CRenderEnv + -> [(T.Text, String)] + -> [(SV, String)] + -> SBVExpr + -> SV + -> Doc + -> (Doc, Doc) + -> Bool + -> (Doc, Set.Set CRequirement, [Doc]) +ppExpr env functionNames structuredLambdaNames (SBVApp op opArgs) resultSV lhs (typ, var) declareResult + | requiresExtensionalEquality adts op (map kindOf opArgs) + , not (op `elem` [Equal False, Equal True, NotEqual] && all isArray opArgs) + = error $ "SBV->C: " ++ show op ++ " requires general extensional array equality, including array-valued elements or fields." + | True + = ( vcat $ declarations + ++ loweringSetup selected + ++ [assignment] + , loweringRequirements selected + , loweringDeclarations selected + ) + where cfg = renderConfig env + adts = renderADTs env + consts = renderConstants env + + declarations + | declareResult = loweringDeclarations selected + | True = [] + + doNotAssign (IEEEFP FP_Reinterpret{}) + | not (isFP (kindOf resultSV) || any (isFP . kindOf) opArgs) + , not (isWideBV (kindOf resultSV) || any (isWideBV . kindOf) opArgs) + = True -- generates a memcpy instead; no simple assignment + doNotAssign PseudoBoolean{} = True -- assigns through an overflow-safe reduction + doNotAssign _ = False + + renderedArgs = map (showSV env) opArgs + + -- Precedence is intentional, not a uniqueness invariant: aggregate + -- storage operations precede scalar operations touching their fields; + -- exact/mapped casts precede native fallbacks. In particular FP owns + -- BV/FP reinterpretation, including interchange vectors wider than 64. + -- Ite and short-circuit booleans are scheduled separately; only total + -- bit-vector Ite can reach this dispatch through eager speculation. + selected = fromMaybe legacy $ chooseLowering + [ arrayExpr cfg (`lookup` functionNames) (`lookup` structuredLambdaNames) op opArgs resultSV renderedArgs + , tableExpr cfg (showSV env) op resultSV + , setExpr cfg op opArgs (kindOf resultSV) renderedArgs + , nonLinearExpr cfg op opArgs (kindOf resultSV) renderedArgs + , regexExpr cfg op resultSV renderedArgs + , textExpr cfg op opArgs (kindOf resultSV) renderedArgs + , listExpr cfg op opArgs resultSV renderedArgs + , adtExpr cfg adts op opArgs resultSV renderedArgs + , tupleExpr op opArgs resultSV renderedArgs + , gmpExpr cfg op opArgs (kindOf resultSV) renderedArgs + , bitVectorCastExpr (cgInteger cfg) op opArgs (kindOf resultSV) renderedArgs + , arbitraryFPExpr cfg consts op opArgs (kindOf resultSV) renderedArgs + , nativeFPExpr consts op opArgs (kindOf resultSV) renderedArgs + , nativeBVExpr (cgInteger cfg) op opArgs (kindOf resultSV) renderedArgs + , nativeBVOverflowExpr op opArgs renderedArgs + , wideBVExpr op opArgs (kindOf resultSV) renderedArgs + ] + + legacy = expressionLowering [] (p op renderedArgs) + + rhs = loweringExpression selected + + assignment + | doNotAssign op + = (if declareResult then typ <+> var P.<> semi else empty) <+> rhs P.<> semi + | True + = lhs <+> text "=" <+> rhs P.<> semi + + rtc = cgRTC cfg + + functionName symbol = fromMaybe (T.unpack symbol) (lookup symbol functionNames) + + functionArguments symbol arguments + | isJust (lookup symbol functionNames) = text "&sbv_local_function_ctx" : arguments + | True = arguments + + cBinOps = [ (Plus, "+"), (Times, "*"), (Minus, "-") + , (Equal False, "==") -- no strong equality! + , (NotEqual, "!="), (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=") + , (And, "&"), (Or, "|"), (XOr, "^") + ] + + hd _ (h:_) = h + hd w [] = error $ "Data.SBV.C.ppExpr: Impossible happened: " ++ w ++ ", received empty list!" + + p :: Op -> [Doc] -> Doc + p ReadArray{} _ = die "Array read escaped the persistent-array lowering pipeline" + p WriteArray{} _ = die "Array write escaped the persistent-array lowering pipeline" + p ArrayInit{} _ = die "Array initialization escaped the persistent-array lowering pipeline" + p QuantifiedBool{} _ = solverOnly "quantified Boolean expressions" + p SpecialRelOp{} _ = solverOnly "special relations" + p RegExOp{} _ = die "Regex comparison escaped the bounded-automaton lowering pipeline" + p (StrOp StrInRe{}) _ = die "Regex membership escaped the bounded-automaton lowering pipeline" + p (Label s) [a] = a <+> text "/*" <+> cCommentText s <+> text "*/" + p (IEEEFP w) as = handleIEEE w consts (zip opArgs as) var + p (PseudoBoolean pb) as = assignPseudoBoolean pb as var + p OverflowOp{} _ = die "Overflow operation escaped the exact bit-vector lowering pipeline" + p NonLinear{} _ = die "Non-linear operation escaped the dedicated lowering pipeline" + p castOp@KindCast{} [a] + | Just width <- mappedRealFloorWidth cfg castOp + = mappedRealFloorCall width a + p (KindCast _ to) [a] = parens (text (showCType to)) <+> a + p (Uninterpreted s) [] + | isJust (lookup s functionNames) + = text "/* Defined function */" <+> text (functionName s) P.<> parens (text "&sbv_local_function_ctx") + | True + = text "/* Uninterpreted constant */" <+> text (functionName s) + p (Uninterpreted s) as = text "/* Uninterpreted function */" <+> text (functionName s) + P.<> parens (fsep (punctuate comma (functionArguments s as))) + p Extract{} _ = die "Bit-vector extraction escaped the exact bit-vector lowering pipeline" + p Join _ = die "Bit-vector concatenation escaped the exact bit-vector lowering pipeline" + p ZeroExtend{} _ = die "Zero extension escaped the exact bit-vector lowering pipeline" + p SignExtend{} _ = die "Sign extension escaped the exact bit-vector lowering pipeline" + p Rol{} _ = die "Left rotation escaped the exact bit-vector lowering pipeline" + p Ror{} _ = die "Right rotation escaped the exact bit-vector lowering pipeline" + p Shl{} _ = die "Left shift escaped the exact bit-vector lowering pipeline" + p Shr{} _ = die "Right shift escaped the exact bit-vector lowering pipeline" + p Not [a] = case kindOf (hd "Not" opArgs) of + -- be careful about booleans, bitwise complement is not correct for them! + KBool -> text "!" P.<> a + _ -> text "~" P.<> a + p Ite [a, b, c] = a <+> text "?" <+> b <+> text ":" <+> c + p (LkUp (t, k, _, 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 = showSV env ind + defVal = showSV env def + + lkUp = text "table" P.<> int t P.<> brackets renderedIndex + cndLkUp cnd = cnd <+> text "?" <+> defVal <+> text ":" <+> lkUp + + checkLeft + | isWideBV k = text "!" P.<> parens (wideBVLookupInRange k len index) + | True = index <+> text "< 0" + + checkRight + | isWideBV k = text "!" P.<> parens (wideBVLookupInRange k len index) + | True = index <+> text ">=" <+> int len + + checkBoth = parens (checkLeft <+> text "||" <+> checkRight) + + renderedIndex + | isWideBV k = wideBVLookupIndex k index + | True = index + + canOverflow True sz = (2::Integer)^(sz-1)-1 >= fromIntegral len + canOverflow False sz = (2::Integer)^sz -1 >= fromIntegral len + + (needsCheckL, needsCheckR) = case k of + KVar{} -> die $ "array index with variable: " ++ show k + KBool -> (False, canOverflow False (1::Int)) + KBounded sg sz + | isWideBV k -> (sg, not sg) + | True -> (sg, canOverflow sg sz) + KReal -> die "array index with real value" + KFloat -> die "array index with float value" + KDouble -> die "array index with double value" + KFP{} -> die "array index with arbitrary float value" + KRational -> die "array index with rational value" + KString -> die "array index with string value" + KChar -> die "array index with character value" + KUnbounded -> case cgInteger cfg of + Nothing -> (True, True) -- won't matter, it'll be rejected later + Just i -> (True, canOverflow True i) + KList s -> die $ "List sort " ++ show s + KSet s -> die $ "Set sort " ++ show s + KTuple s -> die $ "Tuple sort " ++ show s + KArray k1 k2 -> die $ "Array sort " ++ show (k1, k2) + KApp s _ -> die $ "ADT app: " ++ s + KADT s _ _ -> die $ "ADT: " ++ s + + -- Integral quotient/remainder use the dedicated GMP or bit-vector + -- helpers above. Keep zero-divisor protection in the scalar fallback; + -- native IEEE division itself must retain its infinities and NaNs. + p (Divides n) [a] = mappedIntegerDivides n a + p Quot [a, b] = let k = kindOf (hd "Quot" opArgs) + z = mkConst env $ mkConstCV k (0::Integer) + in protectDiv0 k "/" z a b + p Rem [a, b] = protectDiv0 (kindOf (hd "Rem" opArgs)) "%" a a b + p UNeg [a] = parens (text "-" <+> a) + p Abs [a] = let f KFloat = text "fabsf" P.<> parens a + f KDouble = text "fabs" P.<> parens a + f (KBounded False _) = text "/* unsigned, skipping call to abs */" <+> a + f (KBounded True 32) = text "labs" P.<> parens a + f (KBounded True 64) = text "llabs" P.<> parens a + f KUnbounded = case cgInteger cfg of + Nothing -> f $ KBounded True 32 -- won't matter, it'll be rejected later + Just i -> f $ KBounded True i + f KReal = case cgReal cfg of + Nothing -> f KDouble -- won't matter, it'll be rejected later + Just CgFloat -> f KFloat + Just CgDouble -> f KDouble + Just CgLongDouble -> text "fabsl" P.<> parens a + f _ = text "abs" P.<> parens a + in f (kindOf (hd "Abs" opArgs)) + -- for And/Or, translate to boolean versions if on boolean kind + p And [a, b] | kindOf (hd "And" opArgs) == KBool = a <+> text "&&" <+> b + p Or [a, b] | kindOf (hd "Or" opArgs) == KBool = a <+> text "||" <+> b + p o [a, b] + | Just co <- lookup o cBinOps + = a <+> text co <+> b + + p Implies [a, b] | kindOf (hd "Implies" opArgs) == KBool = parens (text "!" P.<> a <+> text "||" <+> b) + + p NotEqual xs = mkDistinct xs + p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args + + solverOnly feature = error $ "SBV->C: " ++ feature ++ " has solver-only semantics and cannot be compiled to executable C" + + mappedIntegerDivides divisor value + | divisor > maximumMagnitude = parens (value <+> text "==" <+> text "0") + | True = parens $ magnitude <+> text "%" <+> uint64 divisor <+> text "==" <+> uint64 0 + where width = case cgInteger cfg of + Just w -> w + Nothing -> die "Exact integer divisibility escaped the GMP lowering pipeline" + + maximumMagnitude = 2 ^ (width - 1) + magnitude = parens $ value <+> text "< 0" + <+> text "?" <+> uint64 0 <+> text "-" <+> asUnsigned value + <+> text ":" <+> asUnsigned value + asUnsigned a = parens (text "uint64_t") <+> a + uint64 n = text "UINT64_C" P.<> parens (integer n) + + -- generate a pairwise inequality check + mkDistinct args = fsep $ andAll $ walk args + where walk [] = [] + walk (e:es) = map (pair e) es ++ walk es + + pair e1 e2 = parens (e1 <+> text "!=" <+> e2) + + -- like punctuate, but more spacing + andAll [] = [] + andAll (d:ds) = go d ds + where go d' [] = [d'] + go d' (e:es) = (d' <+> text "&&") : go e es + + -- Div0 needs to protect, but only when the arguments are not float/double. (Div by 0 for those are well defined to be Inf/NaN etc.) + protectDiv0 k divOp def a b = case k of + KFloat -> res + KDouble -> res + _ -> wrap + where res = a <+> text divOp <+> b + wrap = parens (b <+> text "== 0") <+> text "?" <+> def <+> text ":" <+> parens res + +-- | Render exact equality over a finite array domain. Each iteration performs +-- two ordered lookups and an SMT object comparison; no backing arrays are +-- materialized. Reject excessive domains before any C files are emitted. +ppArrayEquality :: CgConfig -> [Kind] -> Kind -> Doc +ppArrayEquality cfg adts kind@(KArray keyKind valueKind) + | requiresExtensionalEquality adts (Equal True) [valueKind] + = error $ "SBV->C: Nested extensional array equality is not supported: array values of kind " ++ show valueKind + ++ " contain arrays. This comparison is not approximated." + | cgArrayEqualityMaxKeys cfg == 0 + = error "SBV->C: Extensional array equality is disabled by cgArrayEqualityLimit 0. Select a positive limit to permit finite-domain comparisons." + | Nothing <- cardinality + = error $ "SBV->C: Extensional array equality cannot enumerate key domain " ++ show keyKind + ++ ". Only supported finite domains can be compared; raising cgArrayEqualityLimit does not enable infinite or unsupported domains." + | Just count <- cardinality, count > cgArrayEqualityMaxKeys cfg + = error $ "SBV->C: Extensional array equality for " ++ show keyKind ++ " requires " ++ show count + ++ " keys, exceeding cgArrayEqualityLimit " ++ show (cgArrayEqualityMaxKeys cfg) + ++ ". Raise cgArrayEqualityLimit explicitly to permit this work." + | True + = text "static SBV_CGEN_UNUSED bool" <+> text (arrayEqualName kind) + P.<> parens (text (arrayCType kind ++ " left, " ++ arrayCType kind ++ " right")) + $$ text "{" + $$ nest 2 (enumerate "sbv_local_key" keyKind compareAt $$ text "return true;") + $$ text "}" + $$ text "" + where cardinality = finiteDomainSize (map snd . adtConstructors adts) keyKind + + compareAt key = text ("const " ++ showCType keyKind ++ " key =") <+> key P.<> semi + $$ text ("const " ++ CTypes.elementCType valueKind ++ " left_value = " ++ arrayReadName kind ++ "(left, key);") + $$ text ("const " ++ CTypes.elementCType valueKind ++ " right_value = " ++ arrayReadName kind ++ "(right, key);") + $$ text "if" P.<> parens (text "!" P.<> parens (byValueEqual cfg True valueKind (text "left_value") (text "right_value"))) + $$ nest 2 (text "return false;") + + enumerate scope key yield + | key == KBool || key == KBounded False 1 + = counted scope 2 (\counter -> yield (parens (text "SBool") <+> counter)) + | key == KFloat = floating scope key 32 yield + | key == KDouble = floating scope key 64 yield + | KFP eb sb <- key = floating scope key (eb + sb) yield + | isWideBV key + = limbEnumeration scope key (intSizeOf key) yield + | isBounded key + = let raw = scope ++ "_raw" + keyDoc = if hasSign key then text scope else text raw + signedKey = if hasSign key + then text (showCType key ++ " " ++ scope ++ "; memcpy(&" ++ scope ++ ", &" ++ raw ++ ", sizeof " ++ scope ++ ");") + else empty + in text ("uint" ++ show (intSizeOf key) ++ "_t " ++ raw ++ " = 0;") + $$ text "do {" + $$ nest 2 (signedKey $$ yield keyDoc $$ text ("++" ++ raw ++ ";")) + $$ text ("} while (" ++ raw ++ " != 0);") + | key == KChar + = counted scope 0x30000 yield + | isRoundingMode key + = counted scope 5 (\counter -> yield (parens (text (showCType key)) <+> counter)) + | KTuple fields <- key + = enumerateFields scope fields (yield . tupleValue key) + | isConcreteADTReference key + = vcat [ text "{" $$ nest 2 (enumerateFields (scope ++ "_c" ++ show index) fields (yield . adtValue adts key index)) $$ text "}" + | (index, (_, fields)) <- zip [1 :: Int ..] (adtConstructors adts key)] + | True + = die $ "Cannot enumerate array key kind " ++ show key + + limbEnumeration :: String -> Kind -> Int -> (Doc -> Doc) -> Doc + limbEnumeration scope key width yield = + let limbCount = (width + 63) `div` 64 + limb index = scope ++ ".limb[" ++ show index ++ "]" + topMask = 2 ^ (1 + (width - 1) `mod` 64) - 1 :: Integer + in text (showCType key ++ " " ++ scope ++ " = {{0}};") + $$ text "do {" + $$ nest 2 (yield (text scope) + $$ text ("for (size_t i = 0; i < " ++ show limbCount ++ "; ++i) { if (++" ++ scope ++ ".limb[i] != 0) break; }") + $$ text (limb (limbCount - 1) ++ " &= UINT64_C(" ++ show topMask ++ ");")) + $$ text ("} while (" ++ intercalate " || " [limb i ++ " != 0" | i <- [0 .. limbCount - 1]] ++ ");") + + floating :: String -> Kind -> Int -> (Doc -> Doc) -> Doc + floating scope key width yield = + let seen = scope ++ "_nan_seen" + visit value = text "const bool is_nan =" <+> (if isFP key then arbitraryFPIsNaN key value else text "isnan" P.<> parens value) P.<> semi + $$ text ("if (!is_nan || !" ++ seen ++ ") {") + $$ nest 2 (text (seen ++ " |= is_nan;") $$ yield value) + $$ text "}" + raw = scope ++ "_raw" + nativeLoop = text ("uint" ++ show width ++ "_t " ++ raw ++ " = 0;") + $$ text "do {" + $$ nest 2 (text (showCType key ++ " " ++ scope ++ "; memcpy(&" ++ scope ++ ", &" ++ raw ++ ", sizeof " ++ scope ++ ");") + $$ visit (text scope) $$ text ("++" ++ raw ++ ";")) + $$ text ("} while (" ++ raw ++ " != 0);") + in text ("bool " ++ seen ++ " = false;") + $$ if isFP key then limbEnumeration scope key width visit else nativeLoop + + enumerateFields scope fields yield = fieldsFrom (1 :: Int) fields [] + where fieldsFrom _ [] values = yield (reverse values) + fieldsFrom index (field:rest) values = enumerate (scope ++ "_f" ++ show index) field + (\value -> fieldsFrom (index + 1) rest (value : values)) + + counted scope count yield = text ("for (uint32_t " ++ scope ++ " = 0; " ++ scope ++ " < " ++ show (count :: Integer) ++ "; ++" ++ scope ++ ") {") + $$ nest 2 (yield (text scope)) + $$ text "}" +ppArrayEquality _ _ kind = die $ "Expected an array equality kind, received " ++ show kind + +-- | Detect comparisons that transitively require array equality, resolving +-- recursive ADT references without revisiting already inspected definitions. +-- Array-valued data can still be constructed, selected, and transported. +requiresExtensionalEquality :: [Kind] -> Op -> [Kind] -> Bool +requiresExtensionalEquality adts op kinds = comparesElements op && any (containsArray Set.empty) kinds + where comparesElements Equal{} = True + comparesElements NotEqual = True + comparesElements (SeqOp SeqIndexOf{}) = True + comparesElements (SeqOp SeqContains{}) = True + comparesElements (SeqOp SeqPrefixOf{}) = True + comparesElements (SeqOp SeqSuffixOf{}) = True + comparesElements (SeqOp SeqReplace{}) = True + comparesElements _ = False + + containsArray _ KArray{} = True + containsArray visited (KList elementKind) = containsArray visited elementKind + containsArray visited (KSet elementKind) = containsArray visited elementKind + containsArray visited (KTuple fields) = any (containsArray visited) fields + containsArray visited kind + | isConcreteADTReference kind + , kind `Set.notMember` visited + = any (any (containsArray (Set.insert kind visited)) . snd) (adtConstructors adts kind) + | True + = False + +-- | Quote a document after removing line breaks, for generated format strings. +printQuotes :: Doc -> Doc +printQuotes d = text $ '"' : ppSameLine d ++ "\"" + +-- | Flatten a document onto one line for generated build commands and labels. +ppSameLine :: Doc -> String +ppSameLine = trim . render + where trim "" = "" + trim ('\n':cs) = ' ' : trim (dropWhile isSpace cs) + trim (c:cs) = c : trim cs + +-- | Left-pad documents so their rendered representations have equal width. +align :: [Doc] -> [Doc] +align ds = map (text . pad) ss + where ss = map render ds + l = maximum (0 : map length ss) + pad s = replicate (l - length s) ' ' ++ s + +-- | Merge component bundles. Code-generation options have already been +-- applied per component; the returned config describes the merged artifacts +-- and permits overwriting only when every component explicitly permits it. +-- Other returned settings are representative of the first component. +mergeToLib :: String -> [(CgConfig, CgPgmBundle)] -> (CgConfig, CgPgmBundle) +mergeToLib libName cfgBundles + | length nubKinds /= 1 + = error $ "Cannot merge programs with differing SInteger/SReal mappings. Received the following kinds:\n" + ++ unlines (map show nubKinds) + | not (null duplicateFiles) + = error $ "SBV.compileToCLib: Conflicting generated file names: " ++ unwords duplicateFiles + | not (null duplicateSymbols) + = error $ "SBV.compileToCLib: Conflicting generated entry points: " ++ unwords duplicateSymbols + | True + = (finalCfg, CgPgmBundle bundleKind resultFiles) + where bundles = map snd cfgBundles + kinds = [k | CgPgmBundle k _ <- bundles] + nubKinds = nub kinds + bundleKind = case nubKinds of + bk:_ -> bk + [] -> error "Data.SBV.C: Impossible happened: mergeLibs: kinds ended up being empty!" + files = concat [fs | CgPgmBundle _ fs <- bundles] + headerMeta = [metadata | (_, (CgCHeader metadata, _)) <- files] + typeDecls = uniqueOn render (map cgHeaderTypes headerMeta) + sigs = concatMap cgHeaderSignatures headerMeta + extProtos = vcat $ uniqueOn render (map cgHeaderPrototypes headerMeta) + floating = any cgHeaderFloating headerMeta + anyMake = any (cgGenMakefile . fst) cfgBundles + drivers = [(takeBaseName sourceName, ds) + | (_, CgPgmBundle _ componentFiles) <- cfgBundles + , (sourceName, (CgSource, _)) <- componentFiles + , (_, (CgDriver, ds)) <- componentFiles + ] + anyDriver = not (null drivers) + mkFlags = nub (concat [xs | (_, (CgMakefile xs, _)) <- files]) + sources = [(f, (CgSource, replaceHeader f parts)) | (f, (CgSource, parts)) <- files] + replaceHeader _ [pre, _, post] = [pre, libHInclude, post] + replaceHeader f _ = die $ "Invalid C source bundle layout for " ++ f + sourceNms = map fst sources + libHeader = (libName ++ ".h", (CgCHeader (CgCHeaderInfo floating (vcat typeDecls) sigs extProtos), [genHeader floating bundleKind libName sigs extProtos (vcat typeDecls)])) + libHInclude = text "#include" <+> text (show (libName ++ ".h")) + $$ if "-lbf" `elem` mkFlags then text "#include " else empty + libMake = ("Makefile", (CgMakefile mkFlags, [genLibMake floating anyDriver libName sourceNms mkFlags])) + libDriver = (libName ++ "_driver.c", (CgDriver, mergeDrivers libName libHInclude drivers)) + resultFiles = sources ++ libHeader : [libDriver | anyDriver] ++ [libMake | anyMake] + duplicateFiles = duplicateNames (map (map toLower . fst) resultFiles) + duplicateSymbols = duplicateNames $ map takeBaseName sourceNms ++ [fn ++ "_driver" | (fn, _) <- drivers] ++ ["main" | anyDriver] + finalCfg = case cfgBundles of + [] -> defaultCgConfig + ((c, _):_) -> c { cgGenDriver = anyDriver + , cgGenMakefile = anyMake + , cgOverwriteGenerated = all (cgOverwriteGenerated . fst) cfgBundles + } + +-- | Create a Makefile for the library +genLibMake :: Bool -> Bool -> String -> [String] -> [String] -> Doc +genLibMake floating ifdr libName fs ldFlags = foldr1 ($$) [l | (True, l) <- lns] + where ifld = not (null ldFlags) + gmp = "-lgmp" `elem` ldFlags + ld = text "${LDFLAGS}" <+> if ifld then text "${SBV_LIBS}" else empty + renderedLDFlags = unwords $ filter (/= "-lgmp") ldFlags ++ ["${GMP_LIBS}" | gmp] + lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") + , (True, text "") + , (True, text "# include any user-defined .mk file in the current directory.") + , (True, text "-include *.mk") + , (True, text "") + , (True, text "CC?=gcc") + , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") + , (gmp, text "GMP_CFLAGS?=$(shell pkg-config --cflags gmp)") + , (gmp, text "GMP_LIBS?=$(shell pkg-config --libs gmp)") + , (ifld, text "SBV_LIBS?=" P.<> text renderedLDFlags) + , (True, text "AR?=ar") + , (True, text "ARFLAGS?=cr") + , (True, text "") + , (not ifdr, text ("all: " ++ liba)) + , (ifdr, text ("all: " ++ unwords [liba, libd])) + , (True, text "") + , (True, text liba P.<> text (": " ++ unwords os)) + , (True, text "\trm -f $@.tmp") + , (True, text "\t${AR} ${ARFLAGS} $@.tmp $^") + , (True, text "\tmv -f $@.tmp $@") + , (True, text "") + , (ifdr, text libd P.<> text (": " ++ unwords [libd ++ ".c", libh, liba])) + , (ifdr, text ("\t" ++ cCompilerCommand floating gmp ++ " $< -o $@ " ++ liba) <+> ld) + , (ifdr, text "") + , (True, vcat (zipWith mkObj os fs)) + , (True, text "clean:") + , (True, text "\trm -f *.o") + , (True, text "") + , (True, text "veryclean: clean") + , (not ifdr, text "\trm -f" <+> text (unwords [liba, liba ++ ".tmp"])) + , (ifdr, text "\trm -f" <+> text (unwords [liba, libd, liba ++ ".tmp"])) + , (True, text "") + ] + nm = text libName + liba = libName ++ ".a" + libh = libName ++ ".h" + libd = libName ++ "_driver" + os = map (`replaceExtension` ".o") fs + mkObj o f = text o P.<> text (": " ++ unwords [f, libh]) + $$ text ("\t" ++ cCompilerCommand floating gmp ++ " -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 P.<> text ". */" + $$ text "/* Automatically generated by SBV. Edit as you see fit! */" + $$ text "" + $$ text "#include " + $$ inc + mkDFun (f, [_pre, _include, callbacks, helpers, _header, body, _post]) = [callbacks, helpers, 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 = replicate (length tag) '=' + psep = "printf(\"" ++ lsep ++ "\\n\");" + +-- | Return the runtime requirements introduced by a legacy scalar operation. +operationRequirements :: CgConfig -> (Op, Kind) -> Set.Set CRequirement +operationRequirements cfg (o, k) = Set.fromList (required o) + where required (IEEEFP FP_Cast{}) = math + required castOp@KindCast{} + | Just _ <- mappedRealFloorWidth cfg castOp = math + required (IEEEFP fop) + | fop `elem` requiresMath = math + required Abs + | usesNativeFloatingPoint k = math + required _ = [] + + math = [CRequiresLibM] + + usesNativeFloatingPoint KFloat = True + usesNativeFloatingPoint KDouble = True + usesNativeFloatingPoint KReal = not (isExactGMPKind cfg KReal) + usesNativeFloatingPoint _ = False + + requiresMath = [ FP_Abs + , FP_FMA + , FP_Sqrt + , FP_Rem + , FP_Min + , FP_Max + , FP_RoundToIntegral + , FP_ObjEqual + , FP_IsSubnormal + , FP_IsInfinite + , FP_IsNaN + , FP_IsNegative + , FP_IsPositive + , FP_IsNormal + , FP_IsZero + ] + +-- | Translate collected runtime requirements to external C linker options. +requirementLDFlags :: Set.Set CRequirement -> [String] +requirementLDFlags requirements = + [ flag + | (requirement, flag) <- [ (CRequiresGMP, "-lgmp") + , (CRequiresLibBF, "-lbf") + , (CRequiresLibM, "-lm") + ] + , requirement `Set.member` requirements + ] + +{- HLint ignore module "Redundant lambda" -} diff --git a/Data/SBV/Compilers/C/FP.hs b/Data/SBV/Compilers/C/FP.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/FP.hs @@ -0,0 +1,1261 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.FP +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- LibBF-backed lowering of arbitrary IEEE-754 floating-point values to C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.FP + ( arbitraryFPKinds + , roundingModeTypeDecls + , roundingModeConst + , roundingModeDriverValue + , arbitraryFPTypeDecls + , arbitraryFPRuntime + , arbitraryFPConst + , arbitraryFPExpr + , nativeFPRuntime + , nativeFPExpr + , nativeFPCompilePragmas + , arbitraryFPNormalize + , arbitraryFPPrint + , arbitraryFPCType + , arbitraryFPEqual + , arbitraryFPObjectEqual + , arbitraryFPIsNaN + , nativeFPObjectEqual + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.Bits (shiftL, shiftR, (.&.)) +import Data.List (intercalate, nub, tails) +import qualified Data.Set as Set +import Numeric (showHex) + +import qualified LibBF as BF + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.BV (isWideBV, mappedIntegerKind) +import Data.SBV.Compilers.C.GMP (isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Real (mappedRealFloorWidth) +import Data.SBV.Compilers.CodeGen (CgConfig(..), CgSRealType(..)) +import Data.SBV.Core.Data +import Data.SBV.Core.SizedFloats (FP(..), mkBFOpts) + +-- | Disable implicit contraction in generated translation units without +-- changing the caller's compilation state through a public header. The +-- Makefiles also pass @-ffp-contract=off@: Clang can ignore these pragmas when +-- contraction is explicitly enabled on the command line. Explicit FMA calls +-- retain their single-rounding semantics. +nativeFPCompilePragmas :: Doc +nativeFPCompilePragmas = text . unlines $ + ["/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */" + , "#if defined(__clang__)" + , "#pragma STDC FP_CONTRACT OFF" + , "#endif" + , ""] + +-- | The distinct arbitrary floating-point kinds used by a program. +arbitraryFPKinds :: Set.Set Kind -> [Kind] +arbitraryFPKinds = map validate . filter isFP . Set.toAscList + where validate k@(KFP eb _) + | eb <= 61 = k + | True = error $ "SBV->C: LibBF supports arbitrary floating-point exponent widths only up to 61 bits, received " ++ show k + validate k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | Declare the public C enumeration used for symbolic rounding modes. +roundingModeTypeDecls :: Bool -> Doc +roundingModeTypeDecls required + | required = text . unlines $ + ["/* IEEE-754 rounding modes. */" + , "#ifndef SBV_ROUNDING_MODE_DEFINED" + , "#define SBV_ROUNDING_MODE_DEFINED" + , "typedef enum { SBV_RM_RNE = 0, SBV_RM_RNA = 1, SBV_RM_RTP = 2, SBV_RM_RTN = 3, SBV_RM_RTZ = 4 } RoundingMode;" + , "#endif" + , ""] + | True = empty + +-- | Render an SBV rounding-mode constant as a public C enumerator. +roundingModeConst :: CV -> Maybe Doc +roundingModeConst (CV k (CADT (constructorName, []))) + | isRoundingMode k = text . fst <$> lookup constructorName roundingModeNames +roundingModeConst _ = Nothing + +-- | Select a deterministic rounding-mode enumerator for a generated driver. +roundingModeDriverValue :: Integer -> Doc +roundingModeDriverValue sample = text cName + where (cName, _) = map snd roundingModeNames !! fromInteger (sample `mod` toInteger (length roundingModeNames)) + +-- | Declare the raw IEEE interchange representation used at the public C ABI. +arbitraryFPTypeDecls :: [Kind] -> Doc +arbitraryFPTypeDecls [] = empty +arbitraryFPTypeDecls ks = text . unlines $ + ["/* Arbitrary IEEE-754 values, encoded as raw interchange bits. */" + , cUnusedAttribute] + ++ concatMap decl ks + where decl k = ["#ifndef " ++ typeGuard k + , "#define " ++ typeGuard k + , "typedef struct { uint64_t limb[" ++ show (limbs k) ++ "]; } " ++ arbitraryFPCType k ++ ";" + , "static inline SBV_CGEN_UNUSED void " ++ prefix k ++ "_fprint(FILE *stream, " ++ arbitraryFPCType k ++ " value)" + , "{" + , " size_t i = " ++ show (limbs k) ++ ";" + , " fputs(\"0x\", stream);" + , " while (i-- > 0) fprintf(stream, \"%016\" PRIx64, value.limb[i]);" + , "}" + , "#endif" + , ""] + + typeGuard (KFP eb sb) = "SBV_FP_E" ++ show eb ++ "_S" ++ show sb ++ "_DEFINED" + typeGuard k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | Emit the LibBF adapter and helpers for arbitrary formats and conversions +-- that require exact rounding. +arbitraryFPRuntime :: CgConfig -> [Kind] -> [(SV, SBVExpr)] -> Doc +arbitraryFPRuntime cfg ks asgns + | null ks && null floatCasts = empty + | True = text . unlines . map markUnused $ + ["/* LibBF-backed arbitrary floating-point runtime. */" + , cUnusedAttribute + , "" + , "static inline bf_rnd_t sbv_bf_rounding_mode(int mode)" + , "{" + , " switch (mode) {" + , " case 0: return BF_RNDN;" + , " case 1: return BF_RNDNA;" + , " case 2: return BF_RNDU;" + , " case 3: return BF_RNDD;" + , " case 4: return BF_RNDZ;" + , " default: abort();" + , " }" + , "}" + , "" + , "static void *sbv_bf_realloc(void *opaque, void *ptr, size_t size)" + , "{" + , " (void) opaque;" + , " return realloc(ptr, size);" + , "}" + , ""] + ++ concatMap formatRuntime ks + ++ concat [exactBridgeRuntime | any castUsesExact floatCasts] + ++ concat [longDoubleBridgeRuntime | cgReal cfg == Just CgLongDouble, any castUsesReal floatCasts] + ++ concatMap reinterpretRuntime (nub (concatMap reinterprets asgns)) + ++ concatMap (castRuntime cfg) floatCasts + where markUnused line = case splitAt 7 line of + ("static ", rest) -> "static SBV_CGEN_UNUSED " ++ rest + _ -> line + + reinterprets (_, SBVApp (IEEEFP (FP_Reinterpret fr to)) _) + | isFP fr || isFP to = [Reinterpret fr to] + reinterprets _ = [] + + casts (_, SBVApp (IEEEFP (FP_Cast fr to _)) _) + | supportedFPCast cfg fr to + , not (exactNativeFPCast (floatCastKind cfg fr) (floatCastKind cfg to)) = [FloatCast fr to] + casts (_, SBVApp castOp@(KindCast fr to) _) + | Nothing <- mappedRealFloorWidth cfg castOp + , mappedFloatCast cfg fr to = [FloatCast fr to] + casts _ = [] + + floatCasts = nub (concatMap casts asgns) + + castUsesExact (FloatCast fr to) = isExactGMPKind cfg fr || isExactGMPKind cfg to + castUsesReal (FloatCast fr to) = KReal `elem` [fr, to] + +-- | Shared ownership predicate for cast lowering and helper emission. Keeping +-- this decision in one place prevents generation of calls without definitions. +supportedFPCast :: CgConfig -> Kind -> Kind -> Bool +supportedFPCast cfg fr to = isFP fr || isFP to || mappedFloatCast cfg fr to + || (native fr && (native to || isBounded to || isExactGMPKind cfg to)) + || (native to && (isBounded fr || isExactGMPKind cfg fr)) + where native kind = isFloat kind || isDouble kind + +-- | Render an arbitrary floating-point constant in raw interchange form. +arbitraryFPConst :: Kind -> FP -> Maybe Doc +arbitraryFPConst k@(KFP eb sb) (FP _ _ value) = Just . text $ rawLiteral k bits + where bits = BF.bfToBits (mkBFOpts eb sb BF.NearEven) value +arbitraryFPConst _ _ = Nothing + +-- | Lower an operation requiring LibBF-backed floating-point semantics. A +-- 'Nothing' result delegates native RNE operations, table lookup, and +-- user-defined functions to the general C renderer. +-- Numeric floating casts use the bridge unless their native conversion is +-- provably exact: C casts and @rint@ would otherwise depend on the caller's +-- hardware rounding mode, even for RNE. +arbitraryFPExpr :: CgConfig -> [(SV, CV)] -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +arbitraryFPExpr cfg consts op svs resultKind args + | Just _ <- mappedRealFloorWidth cfg op + = Nothing + | IEEEFP (FP_Cast fr to rm) <- op + , let target = floatCastKind cfg to + , exactNativeFPCast (floatCastKind cfg fr) target + , value:_ <- reverse args + , let ignored = maybe [text (show rm)] (const []) (lookup rm consts) + , let cast = parens (text (if isFloat target then "SFloat" else "SDouble")) <+> value + = Just . expressionLowering [] $ case ignored of + [] -> cast + _ -> parens $ fsep (punctuate comma (map (text "(void)" <+>) ignored ++ [cast])) + | not (isFP resultKind + || any (isFP . kindOf) svs + || isSupportedCast) + = Nothing + | LkUp{} <- op + = Nothing + | Uninterpreted{} <- op + = Nothing + | True + = Just . expressionLowering requirements $ case (op, args, svs) of + (Label _ , [a] , _) -> a + (UNeg , [a] , x:_) -> argCall x "neg" [a] + (Abs , [a] , x:_) -> argCall x "abs" [a] + (Plus , [a, b] , x:_) -> argCall x "add" [a, b, text "BF_RNDN"] + (Minus , [a, b] , x:_) -> argCall x "sub" [a, b, text "BF_RNDN"] + (Times , [a, b] , x:_) -> argCall x "mul" [a, b, text "BF_RNDN"] + (Quot , [a, b] , x:_) -> argCall x "div" [a, b, text "BF_RNDN"] + (Equal False , [a, b] , x:_) -> argCall x "eq" [a, b] + (Equal True , [a, b] , x:_) -> argCall x "obj_eq" [a, b] + (NotEqual , as , x:_) -> distinctExpr x as + (LessThan , [a, b] , x:_) -> argCall x "lt" [a, b] + (GreaterThan , [a, b] , x:_) -> argCall x "lt" [b, a] + (LessEq , [a, b] , x:_) -> argCall x "le" [a, b] + (GreaterEq , [a, b] , x:_) -> argCall x "le" [b, a] + (IEEEFP fpOp , as , fpArgs) -> fpExpr fpOp as fpArgs + (KindCast fr to , [a] , _) -> namedCall (castName fr to) + ([text "&sbv_local_gmp_ctx" | isExactGMPKind cfg to] + ++ [a, text (if fr == KReal && to == KUnbounded then "BF_RNDD" else "BF_RNDN")]) + _ -> unsupported + where argCall sv suffix = namedCall (prefix (kindOf sv) ++ "_" ++ suffix) + + distinctExpr sv as = fsep $ punctuate (text " &&") + [text "!" P.<> parens (argCall sv "eq" [a, b]) + | (a:rest) <- tails as, b <- rest] + + fpExpr fpOp as fpArgs = case (fpOp, as, fpArgs) of + (FP_Abs , [a] , x:_) -> argCall x "abs" [a] + (FP_Neg , [a] , x:_) -> argCall x "neg" [a] + (FP_Add , [_rm, a, b] , r:x:_) -> argCall x "add" [a, b, bfRoundingMode consts r] + (FP_Sub , [_rm, a, b] , r:x:_) -> argCall x "sub" [a, b, bfRoundingMode consts r] + (FP_Mul , [_rm, a, b] , r:x:_) -> argCall x "mul" [a, b, bfRoundingMode consts r] + (FP_Div , [_rm, a, b] , r:x:_) -> argCall x "div" [a, b, bfRoundingMode consts r] + (FP_FMA , [_rm, a, b, c], r:x:_) -> argCall x "fma" [a, b, c, bfRoundingMode consts r] + (FP_Sqrt , [_rm, a] , r:x:_) -> argCall x "sqrt" [a, bfRoundingMode consts r] + (FP_Rem , [a, b] , x:_) -> argCall x "rem" [a, b] + (FP_RoundToIntegral , [_rm, a] , r:x:_) -> argCall x "round" [a, bfRoundingMode consts r] + (FP_Min , [a, b] , x:_) -> argCall x "min" [a, b] + (FP_Max , [a, b] , x:_) -> argCall x "max" [a, b] + (FP_ObjEqual , [a, b] , x:_) -> argCall x "obj_eq" [a, b] + (FP_IsNormal , [a] , x:_) -> argCall x "is_normal" [a] + (FP_IsSubnormal , [a] , x:_) -> argCall x "is_subnormal" [a] + (FP_IsZero , [a] , x:_) -> argCall x "is_zero" [a] + (FP_IsInfinite , [a] , x:_) -> argCall x "is_infinite" [a] + (FP_IsNaN , [a] , x:_) -> argCall x "is_nan" [a] + (FP_IsNegative , [a] , x:_) -> argCall x "is_negative" [a] + (FP_IsPositive , [a] , x:_) -> argCall x "is_positive" [a] + (FP_Reinterpret fr to, [a] , _) -> namedCall (reinterpretName fr to) [a] + (FP_Cast fr to rm , [a] , _) -> namedCall (castName fr to) (castArgs to a rm) + (FP_Cast fr to rm , [_rm, a] , _) -> namedCall (castName fr to) (castArgs to a rm) + _ -> unsupported + + castArgs to a rm + | isExactGMPKind cfg to = [text "&sbv_local_gmp_ctx", a, bfRoundingMode consts rm] + | True = [a, bfRoundingMode consts rm] + + requirements = [CRequiresLibBF, CRequiresLibM] ++ [CRequiresGMP | usesExact] + + usesExact = isExactGMPKind cfg resultKind || any (isExactGMPKind cfg . kindOf) svs + + isSupportedCast = case op of + IEEEFP (FP_Cast fr to _) -> supportedFPCast cfg fr to + KindCast fr to -> mappedFloatCast cfg fr to + _ -> False + + unsupported = error $ "SBV->C: arbitrary floating-point lowering does not yet support " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + +-- | Identify scalar casts whose entire source range is exactly representable +-- in the destination. No rounding, software adapter, or hardware rounding-mode +-- change is needed for any valid SBV rounding mode. +exactNativeFPCast :: Kind -> Kind -> Bool +exactNativeFPCast from to + | to `notElem` [KFloat, KDouble] = False + | from == to = True + | from == KFloat, to == KDouble = True + | isBounded from + , not (isWideBV from) = intSizeOf from - (if hasSign from then 1 else 0) <= significandBits to + | True = False + +-- | Emit LibBF adapters for native 'SFloat' and 'SDouble' operations whose +-- rounding mode cannot safely be expressed as an ordinary C expression. +nativeFPRuntime :: Doc +nativeFPRuntime = text . unlines . map markUnused $ + ["/* Exact rounding adapters for native floating-point operations. */" + , cUnusedAttribute + , "" + , "static inline bf_rnd_t sbv_native_bf_rounding_mode(int mode)" + , "{" + , " switch (mode) {" + , " case 0: return BF_RNDN;" + , " case 1: return BF_RNDNA;" + , " case 2: return BF_RNDU;" + , " case 3: return BF_RNDD;" + , " case 4: return BF_RNDZ;" + , " default: abort();" + , " }" + , "}" + , "" + , "static void *sbv_native_bf_realloc(void *opaque, void *ptr, size_t size)" + , "{" + , " (void) opaque;" + , " return realloc(ptr, size);" + , "}" + , "" + ] + ++ concatMap format [("SFloat", "float", 24, 8), ("SDouble", "double", 53, 11)] + where markUnused line = case splitAt 14 line of + ("static inline ", rest) -> "static inline SBV_CGEN_UNUSED " ++ rest + _ -> line + + format :: (String, String, Int, Int) -> [String] + format (cType, tag, precision, exponentBits) = + ["static inline bf_flags_t sbv_native_" ++ tag ++ "_flags(bf_rnd_t rnd)" + , "{ return (bf_flags_t) rnd | BF_FLAG_SUBNORMAL | bf_set_exp_bits(" ++ show exponentBits ++ "); }" + , "" + , "static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_finish(bf_t *value, bf_rnd_t rnd)" + , "{" + , " double result;" + , " bf_get_float64(value, &result, rnd);" + , " return (" ++ cType ++ ") result;" + , "}" + , "" + , "static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_binary(" ++ cType ++ " a, " ++ cType ++ " b, bf_rnd_t rnd, int op)" + , "{" + , " bf_context_t ctx; bf_t x, y, r; " ++ cType ++ " result;" + , " bf_context_init(&ctx, sbv_native_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &y); bf_init(&ctx, &r);" + , " bf_set_float64(&x, (double) a); bf_set_float64(&y, (double) b);" + , " if (op == 0) bf_add(&r, &x, &y, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd));" + , " else if (op == 1) bf_sub(&r, &x, &y, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd));" + , " else if (op == 2) bf_mul(&r, &x, &y, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd));" + , " else bf_div(&r, &x, &y, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd));" + , " result = sbv_native_" ++ tag ++ "_finish(&r, rnd);" + , " bf_delete(&r); bf_delete(&y); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , "" + ] + ++ concatMap (binaryWrapper cType tag) [("add", 0), ("sub", 1), ("mul", 2), ("div", 3)] + ++ ["static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_sqrt(" ++ cType ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, r; " ++ cType ++ " result;" + , " bf_context_init(&ctx, sbv_native_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &r); bf_set_float64(&x, (double) a);" + , " bf_sqrt(&r, &x, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd)); result = sbv_native_" ++ tag ++ "_finish(&r, rnd);" + , " bf_delete(&r); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , "" + , "static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_round(" ++ cType ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ cType ++ " result;" + , " bf_context_init(&ctx, sbv_native_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a);" + , " bf_rint(&x, rnd); result = sbv_native_" ++ tag ++ "_finish(&x, rnd);" + , " bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , "" + , "static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_fma(" ++ cType ++ " a, " ++ cType ++ " b, " ++ cType ++ " c, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, y, z, r; " ++ cType ++ " result;" + , " bf_context_init(&ctx, sbv_native_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &y); bf_init(&ctx, &z); bf_init(&ctx, &r);" + , " bf_set_float64(&x, (double) a); bf_set_float64(&y, (double) b); bf_set_float64(&z, (double) c);" + , " bf_mul(&r, &x, &y, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDN);" + , " bf_add(&r, &r, &z, " ++ show precision ++ ", sbv_native_" ++ tag ++ "_flags(rnd)); result = sbv_native_" ++ tag ++ "_finish(&r, rnd);" + , " bf_delete(&r); bf_delete(&z); bf_delete(&y); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , "" + ] + + binaryWrapper :: String -> String -> (String, Int) -> [String] + binaryWrapper cType tag (suffix, operation) = + ["static inline " ++ cType ++ " sbv_native_" ++ tag ++ "_" ++ suffix ++ "(" ++ cType ++ " a, " ++ cType ++ " b, bf_rnd_t rnd)" + , "{ return sbv_native_" ++ tag ++ "_binary(a, b, rnd, " ++ show operation ++ "); }" + , ""] + +-- | Lower explicitly rounded native floating-point arithmetic. RNE remains a +-- direct native C operation under the public FE_TONEAREST calling convention; +-- other constants and symbolic modes use LibBF without changing hardware +-- rounding. The caller precondition is not checked at runtime. +nativeFPExpr :: [(SV, CV)] -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +nativeFPExpr consts (IEEEFP fpOp) svs resultKind args + | resultKind `elem` [KFloat, KDouble] + = case (fpOp, args, svs) of + (FP_Add , [_rm, a, b] , r:_) | needsAdapter r -> lower "add" [a, b] r + (FP_Sub , [_rm, a, b] , r:_) | needsAdapter r -> lower "sub" [a, b] r + (FP_Mul , [_rm, a, b] , r:_) | needsAdapter r -> lower "mul" [a, b] r + (FP_Div , [_rm, a, b] , r:_) | needsAdapter r -> lower "div" [a, b] r + (FP_FMA , [_rm, a, b, c], r:_) | needsAdapter r -> lower "fma" [a, b, c] r + (FP_Sqrt , [_rm, a] , r:_) | needsAdapter r -> lower "sqrt" [a] r + (FP_RoundToIntegral , [_rm, a] , r:_) | needsAdapter r -> lower "round" [a] r + _ -> Nothing + | True = Nothing + where lower suffix values rm = Just . expressionLowering + [CRequiresLibBF, CRequiresLibM, CRequiresNativeFPRounding] + $ namedCall (nativePrefix resultKind ++ suffix) + (values ++ [nativeBFRoundingMode consts rm]) + + needsAdapter rm = case rm `lookup` consts of + Just (CV k (CADT ("RoundNearestTiesToEven", []))) | isRoundingMode k -> False + Just (CV k (CADT (_, []))) | isRoundingMode k -> True + Nothing | isRoundingMode rm -> True + _ -> error $ "SBV->C: Expected a rounding mode, received " ++ show rm + + nativePrefix KFloat = "sbv_native_float_" + nativePrefix KDouble = "sbv_native_double_" + nativePrefix k = error $ "SBV->C: Expected a native floating-point kind, received " ++ show k +nativeFPExpr _ _ _ _ _ = Nothing + +-- | Render a LibBF rounding mode for a native floating-point adapter. +nativeBFRoundingMode :: [(SV, CV)] -> SV -> Doc +nativeBFRoundingMode consts sv = case sv `lookup` consts of + Just (CV k (CADT (rmName, []))) + | isRoundingMode k -> maybe bad (text . snd) (lookup rmName roundingModeNames) + Nothing + | isRoundingMode sv -> namedCall "sbv_native_bf_rounding_mode" [text (show sv)] + _ -> bad + where bad = error $ "SBV->C: Expected a rounding mode, received " ++ show sv + +-- | Canonicalize externally supplied raw bits by clearing unused high bits. +arbitraryFPNormalize :: Kind -> Doc -> Doc +arbitraryFPNormalize k value = namedCall (prefix k ++ "_norm") [value] + +-- | Print arbitrary floating-point interchange bits as fixed-width hexadecimal. +arbitraryFPPrint :: Kind -> Doc -> Doc +arbitraryFPPrint k value = namedCall (prefix k ++ "_fprint") [text "stdout", value] + +-- | Compare two arbitrary floating-point interchange values using SMT object +-- equality: all NaNs compare equal and the two signed zeroes remain distinct. +arbitraryFPObjectEqual :: Kind -> Doc -> Doc -> Doc +arbitraryFPObjectEqual k left right = namedCall (prefix k ++ "_obj_eq") [left, right] + +-- | Classify a raw arbitrary-format value without performing arithmetic. +arbitraryFPIsNaN :: Kind -> Doc -> Doc +arbitraryFPIsNaN kind value = namedCall (prefix kind ++ "_is_nan") [value] + +-- | Compare two arbitrary floating-point values using IEEE equality. +arbitraryFPEqual :: Kind -> Doc -> Doc -> Doc +arbitraryFPEqual k left right = namedCall (prefix k ++ "_eq") [left, right] + +-- | Compare two native floating-point values using SMT object equality: all +-- NaNs compare equal and the two signed zeroes remain distinct. +nativeFPObjectEqual :: Doc -> Doc -> Doc +nativeFPObjectEqual left right = choose (renderedIsNaN left) (renderedIsNaN right) + $ choose (renderedIsNegativeZero left) (renderedIsNegativeZero right) + $ choose (renderedIsNegativeZero right) (renderedIsNegativeZero left) (equal left right) + where choose condition ifTrue ifFalse = condition <+> text "?" <+> ifTrue <+> text ":" <+> ifFalse + renderedIsNaN value = text "isnan" P.<> parens value + equal x y = parens (x <+> text "==" <+> y) + renderedIsNegativeZero value = parens (text "signbit" P.<> parens value <+> text "&&" <+> equal value (text "0")) + +-- | Return the public C type name for an arbitrary floating-point kind. +arbitraryFPCType :: Kind -> String +arbitraryFPCType (KFP eb sb) = "SFP" ++ show eb ++ "_" ++ show sb +arbitraryFPCType k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | A bit-preserving conversion between a floating-point interchange value +-- and a bit-vector of the same width. +data Reinterpret = Reinterpret Kind Kind deriving Eq + +-- | A value conversion implemented by the LibBF runtime. +data FloatCast = FloatCast Kind Kind deriving Eq + +-- | Emit a bit-preserving conversion between raw C representations. +reinterpretRuntime :: Reinterpret -> [String] +reinterpretRuntime (Reinterpret fr to) + | reprWidth fr /= reprWidth to = error $ "SBV->C: Cannot reinterpret representations of different widths: " ++ show (fr, to) + | True = + ["static inline " ++ reprCType to ++ " " ++ reinterpretName fr to ++ "(" ++ reprCType fr ++ " a)" + , "{" + , " " ++ reprCType to ++ " r = " ++ reprZero to ++ "; uint64_t i;" + , " for (i = 0; i < " ++ show (reprWidth to) ++ "; ++i) { " ++ reprSetBit to "r" "i" (reprGetBit fr "a" "i") ++ " }" + , " return " ++ reprNormalize to "r" ++ ";" + , "}" + , ""] + +-- | Construct the collision-free name of a reinterpretation helper. +reinterpretName :: Kind -> Kind -> String +reinterpretName fr to = "sbv_fp_reinterpret_" ++ reprTag fr ++ "_" ++ reprTag to + +-- | Resolve explicit native mappings for numeric conversion helpers. A native +-- real mapping to long double has no fixed SBV IEEE kind; retain 'KReal' so the +-- bridge can use the target C compiler's format instead of assuming binary64. +floatCastKind :: CgConfig -> Kind -> Kind +floatCastKind cfg KReal = case cgReal cfg of + Just CgFloat -> KFloat + Just CgDouble -> KDouble + _ -> KReal +floatCastKind cfg kind = mappedIntegerKind (cgInteger cfg) kind + +-- | Test whether a cast crosses an explicitly mapped floating representation, +-- including integer mappings used as a floating-point source or destination. +mappedFloatCast :: CgConfig -> Kind -> Kind -> Bool +mappedFloatCast cfg fr to = (from /= fr || target /= to || mappedReal) + && (floating from || floating target || mappedReal) + where from = floatCastKind cfg fr + target = floatCastKind cfg to + floating kind = isFP kind || isFloat kind || isDouble kind + mappedReal = KReal `elem` [fr, to] && case cgReal cfg of + Just{} -> True + Nothing -> False + +-- | Emit a LibBF-backed value conversion between supported numeric formats. +castRuntime :: CgConfig -> FloatCast -> [String] +castRuntime cfg (FloatCast source target) = case (fr, to) of + (KFP{}, KFP{}) -> + ["static inline " ++ reprCType to ++ " " ++ helperName ++ "(" ++ reprCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ reprCType to ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ prefix fr ++ "_decode(&ctx, &x, a);" + , " bf_round(&x, " ++ show (significandBits to) ++ ", " ++ prefix to ++ "_flags(rnd)); raw = " ++ prefix to ++ "_encode(&x);" + , " bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , ""] + (KFloat, KFP{}) -> fromNative "SFloat" + (KDouble, KFP{}) -> fromNative "SDouble" + (KReal, KFP{}) | longDouble fr -> fromNative "SReal" + (KFP{}, KFloat) -> toNative "SFloat" True + (KFP{}, KDouble) -> toNative "SDouble" False + (KFP{}, KReal) | longDouble to -> toNative "SReal" False + _ | isNativeFloat fr && isNativeFloat to -> nativeToNative + _ | isExactGMPKind cfg fr && isNativeFloat to -> exactToNative + _ | isNativeFloat fr && isExactGMPKind cfg to -> nativeToExact + _ | isExactGMPKind cfg fr && isFP to -> exactToFP + _ | isFP fr && isExactGMPKind cfg to -> fpToExact + _ | isBounded fr && isSomeFloat to -> integerToFP + _ | isSomeFloat fr && isBounded to -> fpToInteger + _ -> error $ "SBV->C: Unsupported arbitrary floating-point cast: " ++ show (fr, to) + where fr = floatCastKind cfg source + to = floatCastKind cfg target + helperName = castName source target + + fromNative sourceType = + ["static inline " ++ reprCType to ++ " " ++ helperName ++ "(" ++ sourceType ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ reprCType to ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ decodeFloating fr + , " bf_round(&x, " ++ show (significandBits to) ++ ", " ++ prefix to ++ "_flags(rnd)); raw = " ++ prefix to ++ "_encode(&x);" + , " bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , ""] + + toNative targetType singlePrecision = + ["static inline " ++ targetType ++ " " ++ helperName ++ "(" ++ reprCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ nativeResultType to ++ " result;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ prefix fr ++ "_decode(&ctx, &x, a);" + ] + ++ [" bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd);" | singlePrecision] + ++ [" " ++ getNative to ++ " bf_delete(&x); bf_context_end(&ctx); return (" ++ targetType ++ ") result;" + , "}" + , ""] + + nativeToNative = + ["static inline " ++ nativeCType to ++ " " ++ helperName ++ "(" ++ nativeCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ nativeResultType to ++ " result;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ decodeFloating fr + , " bf_round(&x, " ++ precision to ++ ", " ++ nativeFlags to ++ "); " ++ getNative to + , " bf_delete(&x); bf_context_end(&ctx); return (" ++ nativeCType to ++ ") result;" + , "}" + , ""] + + integerToFP = + ["static inline " ++ floatingCType to ++ " " ++ helperName ++ "(" ++ reprCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " uint64_t words[" ++ show sourceWords ++ "]; uint64_t carry = 1; size_t i; limb_t j;" + , " const bool negative = " ++ (if hasSign fr then reprGetBit fr "a" (show (reprWidth fr - 1)) else "false") ++ ";" + , " bf_context_t ctx; bf_t x, chunk;" ++ integerResultDeclaration + , " for (i = 0; i < " ++ show sourceWords ++ "; ++i) {" + , " words[i] = 0;" + , " for (j = 0; j < 64 && i * 64 + j < " ++ show (reprWidth fr) ++ "; ++j)" + , " if (" ++ reprGetBit fr "a" "(i * 64 + j)" ++ ") words[i] |= UINT64_C(1) << j;" + , " }" + , " if (negative) for (i = 0; i < " ++ show sourceWords ++ "; ++i) {" + , " const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next;" + , " }" + , " words[" ++ show (sourceWords - 1) ++ "] &= " ++ u64 (reprTopMask fr) ++ ";" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0);" + , " for (i = " ++ show sourceWords ++ "; i-- > 0;) {" + , " bf_mul_2exp(&x, i == " ++ show (sourceWords - 1) ++ " ? " ++ show sourceTopBits ++ " : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " }" + , " if (negative) bf_neg(&x);" + , " bf_round(&x, " ++ precision to ++ ", " ++ floatingFlags to ++ ");" ++ integerFinish + , " bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return " ++ integerResult ++ ";" + , "}" + , ""] + + fpToInteger = + ["static inline " ++ reprCType to ++ " " ++ helperName ++ "(" ++ floatingCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ reprCType integerBits ++ " raw = " ++ reprZero integerBits ++ "; limb_t i;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ decodeFloating fr ++ " bf_rint(&x, rnd);" + , " if (bf_is_finite(&x) && !bf_is_zero(&x)) {" + , " const slimb_t base = (slimb_t) x.len * LIMB_BITS;" + , " for (i = 0; i < " ++ show (reprWidth to) ++ "; ++i) {" + , " const slimb_t bit = (slimb_t) i - x.expn + base;" + , " if (bit >= 0 && bit < base) { " ++ reprSetBit integerBits "raw" "i" "((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0" ++ " }" + , " }" + , " if (x.sign) raw = " ++ negateRepr integerBits "raw" ++ ";" + , " }" + , " bf_delete(&x); bf_context_end(&ctx);" + , if integerBits /= to + then " " ++ reprCType to ++ " result; memcpy(&result, &raw, sizeof result); return result;" + else " return " ++ reprNormalize to "raw" ++ ";" + , "}" + , ""] + + -- Reconstruct native signed results through their unsigned object + -- representation, avoiding implementation-defined unsigned-to-signed casts. + integerBits + | KBounded True width <- to + , not (isWideBV to) = KBounded False width + | True = to + + exactToFP + | fr == KUnbounded = + ["static inline " ++ reprCType to ++ " " ++ helperName ++ "(SInteger a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, chunk; " ++ reprCType to ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk);" + , " sbv_bf_set_mpz(&x, &chunk, a); bf_round(&x, " ++ show (significandBits to) ++ ", " ++ prefix to ++ "_flags(rnd));" + , " raw = " ++ prefix to ++ "_encode(&x); bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , ""] + | fr == KReal = + ["static inline " ++ reprCType to ++ " " ++ helperName ++ "(SReal a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, numerator, denominator, chunk; " ++ reprCType to ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &numerator); bf_init(&ctx, &denominator); bf_init(&ctx, &chunk);" + , " sbv_bf_set_mpz(&numerator, &chunk, mpq_numref(a)); sbv_bf_set_mpz(&denominator, &chunk, mpq_denref(a));" + , " bf_div(&x, &numerator, &denominator, " ++ show (significandBits to) ++ ", " ++ prefix to ++ "_flags(rnd)); raw = " ++ prefix to ++ "_encode(&x);" + , " bf_delete(&chunk); bf_delete(&denominator); bf_delete(&numerator); bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , ""] + | otherwise = error $ "SBV->C: Expected an exact GMP source kind, received " ++ show fr + + fpToExact + | to == KUnbounded = + ["static inline SInteger " ++ helperName ++ "(sbv_gmp_ctx *gmp_ctx, " ++ reprCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; mpz_ptr result = sbv_gmp_new_integer(gmp_ctx);" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ prefix fr ++ "_decode(&ctx, &x, a); bf_rint(&x, rnd);" + , " sbv_bf_get_mpz(result, &x); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , ""] + | to == KReal = + ["static inline SReal " ++ helperName ++ "(sbv_gmp_ctx *gmp_ctx, " ++ reprCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; mpq_ptr result = sbv_gmp_new_real(gmp_ctx);" + , " (void) rnd; bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ prefix fr ++ "_decode(&ctx, &x, a);" + , " sbv_bf_get_mpq(result, &x); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , ""] + | otherwise = error $ "SBV->C: Expected an exact GMP target kind, received " ++ show to + + exactToNative + | fr == KUnbounded = + ["static inline " ++ nativeCType to ++ " " ++ helperName ++ "(SInteger a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, chunk; " ++ nativeResultType to ++ " result;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); sbv_bf_set_mpz(&x, &chunk, a);" + , " bf_round(&x, " ++ precision to ++ ", " ++ nativeFlags to ++ "); " ++ getNative to + , " bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (" ++ nativeCType to ++ ") result;" + , "}" + , ""] + | fr == KReal = + ["static inline " ++ nativeCType to ++ " " ++ helperName ++ "(SReal a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, numerator, denominator, chunk; " ++ nativeResultType to ++ " result;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &numerator); bf_init(&ctx, &denominator); bf_init(&ctx, &chunk);" + , " sbv_bf_set_mpz(&numerator, &chunk, mpq_numref(a)); sbv_bf_set_mpz(&denominator, &chunk, mpq_denref(a));" + , " bf_div(&x, &numerator, &denominator, " ++ precision to ++ ", " ++ nativeFlags to ++ "); " ++ getNative to + , " bf_delete(&chunk); bf_delete(&denominator); bf_delete(&numerator); bf_delete(&x); bf_context_end(&ctx); return (" ++ nativeCType to ++ ") result;" + , "}" + , ""] + | otherwise = error $ "SBV->C: Expected an exact GMP source kind, received " ++ show fr + + nativeToExact + | to == KUnbounded = + ["static inline SInteger " ++ helperName ++ "(sbv_gmp_ctx *gmp_ctx, " ++ nativeCType fr ++ " a, bf_rnd_t rnd)" + , "{" + ] + ++ [" if (!isfinite(a)) { fputs(\"SBV->C: Cannot convert a non-finite mapped SReal to exact SInteger.\\n\", stderr); abort(); }" | source == KReal] + ++ [ " bf_context_t ctx; bf_t x; mpz_ptr result = sbv_gmp_new_integer(gmp_ctx);" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ decodeFloating fr ++ " bf_rint(&x, rnd);" + , " sbv_bf_get_mpz(result, &x); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , ""] + | to == KReal = + ["static inline SReal " ++ helperName ++ "(sbv_gmp_ctx *gmp_ctx, " ++ nativeCType fr ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; mpq_ptr result = sbv_gmp_new_real(gmp_ctx);" + , " (void) rnd; bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ decodeFloating fr + , " sbv_bf_get_mpq(result, &x); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , ""] + | otherwise = error $ "SBV->C: Expected an exact GMP target kind, received " ++ show to + + nativeFlags KFloat = "BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd" + nativeFlags KDouble = "BF_FLAG_SUBNORMAL | bf_set_exp_bits(11) | (bf_flags_t) rnd" + nativeFlags KReal | longDouble KReal = "sbv_bf_long_double_flags(rnd)" + nativeFlags k = error $ "SBV->C: Expected a native floating-point kind, received " ++ show k + + nativeCType KFloat = "SFloat" + nativeCType KDouble = "SDouble" + nativeCType KReal | longDouble KReal = "SReal" + nativeCType k = error $ "SBV->C: Expected a native floating-point kind, received " ++ show k + + longDouble k = k == KReal && cgReal cfg == Just CgLongDouble + + precision k | longDouble k = "LDBL_MANT_DIG" + | True = show (significandBits k) + + nativeResultType k | longDouble k = "long double" + | True = "double" + + getNative k | longDouble k = "result = sbv_bf_get_long_double(&x, rnd);" + | True = "bf_get_float64(&x, &result, rnd);" + + isNativeFloat k = k == KFloat || k == KDouble || longDouble k + + isSomeFloat k = isFP k || isNativeFloat k + + floatingCType k + | isFP k = reprCType k + | isNativeFloat k = nativeCType k + | otherwise = error $ "SBV->C: Expected a floating-point kind, received " ++ show k + + floatingFlags k + | isFP k = prefix k ++ "_flags(rnd)" + | isNativeFloat k = nativeFlags k + | otherwise = error $ "SBV->C: Expected a floating-point kind, received " ++ show k + + decodeFloating k + | isFP k = prefix k ++ "_decode(&ctx, &x, a);" + | longDouble k = "bf_init(&ctx, &x); sbv_bf_set_long_double(&x, a);" + | isNativeFloat k = "bf_init(&ctx, &x); bf_set_float64(&x, (double) a);" + | otherwise = error $ "SBV->C: Expected a floating-point kind, received " ++ show k + + integerResultDeclaration + | isFP to = " " ++ reprCType to ++ " raw;" + | isNativeFloat to = " " ++ nativeResultType to ++ " result;" + | otherwise = error $ "SBV->C: Expected a floating-point target kind, received " ++ show to + + integerFinish + | isFP to = " raw = " ++ prefix to ++ "_encode(&x);" + | isNativeFloat to = " " ++ getNative to + | otherwise = error $ "SBV->C: Expected a floating-point target kind, received " ++ show to + + integerResult + | isFP to = "raw" + | isNativeFloat to = "(" ++ nativeCType to ++ ") result" + | otherwise = error $ "SBV->C: Expected a floating-point target kind, received " ++ show to + + sourceWords = (reprWidth fr + 63) `div` 64 + sourceTopBits = let r = reprWidth fr `mod` 64 in if r == 0 then 64 else r + +-- | Import and export native long doubles without binary64 intermediates. +-- Work on numeric significands, not ABI-dependent object layouts (in particular +-- x87 padding and its explicit integer bit). Unsupported non-IEEE-like formats +-- are rejected by the target compiler. All reconstruction operations are exact +-- after LibBF has rounded once to the target precision and exponent range. +longDoubleBridgeRuntime :: [String] +longDoubleBridgeRuntime = + [ "#include " + , "#if FLT_RADIX == 2 && LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 && LDBL_MIN_EXP == -1021" + , "#define SBV_LDBL_EXP_BITS 11" + , "#elif FLT_RADIX == 2 && (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381" + , "#define SBV_LDBL_EXP_BITS 15" + , "#else" + , "#error SBV C long-double conversions require binary64, x87 extended, or binary128 long double" + , "#endif" + , "#if BF_EXP_BITS_MAX < SBV_LDBL_EXP_BITS" + , "#error SBV C long-double conversions exceed the LibBF exponent range" + , "#endif" + , "" + , "static bf_flags_t sbv_bf_long_double_flags(bf_rnd_t rnd)" + , "{" + , " return BF_FLAG_SUBNORMAL | bf_set_exp_bits(SBV_LDBL_EXP_BITS) | (bf_flags_t) rnd;" + , "}" + , "" + , "static void sbv_bf_set_long_double(bf_t *result, long double value)" + , "{" + , " int exponent, shift = 0, status = 0; bf_t chunk;" + , " if (isnan(value)) { bf_set_nan(result); return; }" + , " if (isinf(value)) { bf_set_inf(result, signbit(value) != 0); return; }" + , " if (value == 0) { bf_set_zero(result, signbit(value) != 0); return; }" + , " long double fraction = frexpl(fabsl(value), &exponent);" + , " bf_init(result->ctx, &chunk); bf_set_zero(result, 0);" + , " while (fraction != 0) {" + , " fraction = ldexpl(fraction, 32);" + , " const uint32_t bits = (uint32_t) fraction; fraction -= (long double) bits;" + , " status |= bf_mul_2exp(result, 32, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " status |= bf_set_ui(&chunk, bits);" + , " status |= bf_add(result, result, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); shift += 32;" + , " }" + , " status |= bf_mul_2exp(result, exponent - shift, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " bf_delete(&chunk); if (status & BF_ST_MEM_ERROR) abort();" + , " if (signbit(value)) bf_neg(result);" + , "}" + , "" + , "static long double sbv_bf_get_long_double(bf_t *value, bf_rnd_t rnd)" + , "{" + , " if (bf_round(value, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)) & BF_ST_MEM_ERROR) abort();" + , " if (bf_is_nan(value)) return nanl(\"\");" + , " if (!bf_is_finite(value)) return value->sign ? -HUGE_VALL : HUGE_VALL;" + , " if (bf_is_zero(value)) return value->sign ? -0.0L : 0.0L;" + , " long double significand = 0;" + , " const slimb_t base = (slimb_t) value->len * LIMB_BITS;" + , " for (int i = 0; i < LDBL_MANT_DIG; ++i) {" + , " const slimb_t bit = base - 1 - i;" + , " const unsigned digit = bit < 0 ? 0 : (unsigned) ((value->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1);" + , " significand = significand * 2 + digit;" + , " }" + , " const long double result = ldexpl(significand, (int) value->expn - LDBL_MANT_DIG);" + , " return value->sign ? -result : result;" + , "}" + , "" + ] + +-- | Emit conversion primitives shared by LibBF/GMP value casts. +exactBridgeRuntime :: [String] +exactBridgeRuntime = + ["static void sbv_bf_set_mpz(bf_t *result, bf_t *chunk, mpz_srcptr value)" + , "{" + , " const size_t count = (mpz_sizeinbase(value, 2) + 63) / 64; size_t written = 0, i;" + , " uint64_t *words; bf_set_ui(result, 0);" + , " if (mpz_sgn(value) == 0) return;" + , " words = (uint64_t *) calloc(count, sizeof(*words)); if (words == NULL) abort();" + , " mpz_export(words, &written, -1, sizeof(*words), 0, 0, value);" + , " for (i = written; i-- > 0;) {" + , " bf_mul_2exp(result, 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " bf_set_ui(chunk, words[i]); bf_add(result, result, chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " }" + , " free(words); if (mpz_sgn(value) < 0) bf_neg(result);" + , "}" + , "" + , "static void sbv_bf_get_mpz(mpz_ptr result, const bf_t *value)" + , "{" + , " slimb_t shift; mpz_set_ui(result, 0);" + , " if (!bf_is_finite(value) || bf_is_zero(value)) return;" + , " mpz_import(result, value->len, -1, sizeof(*value->tab), 0, 0, value->tab);" + , " shift = value->expn - (slimb_t) value->len * LIMB_BITS;" + , " if (shift >= 0) mpz_mul_2exp(result, result, (mp_bitcnt_t) shift);" + , " else mpz_tdiv_q_2exp(result, result, (mp_bitcnt_t) -shift);" + , " if (value->sign) mpz_neg(result, result);" + , "}" + , "" + , "static void sbv_bf_get_mpq(mpq_ptr result, const bf_t *value)" + , "{" + , " slimb_t shift; mpq_set_ui(result, 0, 1);" + , " if (!bf_is_finite(value) || bf_is_zero(value)) return;" + , " mpz_import(mpq_numref(result), value->len, -1, sizeof(*value->tab), 0, 0, value->tab);" + , " shift = value->expn - (slimb_t) value->len * LIMB_BITS;" + , " if (shift >= 0) mpz_mul_2exp(mpq_numref(result), mpq_numref(result), (mp_bitcnt_t) shift);" + , " else mpz_mul_2exp(mpq_denref(result), mpq_denref(result), (mp_bitcnt_t) -shift);" + , " if (value->sign) mpz_neg(mpq_numref(result), mpq_numref(result)); mpq_canonicalize(result);" + , "}" + , ""] + +-- | Construct the collision-free name of a floating-point value conversion. +castName :: Kind -> Kind -> String +castName fr to = "sbv_fp_cast_" ++ castTag fr ++ "_" ++ castTag to + +-- | Return the generated tag used in a floating-point value conversion. +castTag :: Kind -> String +castTag k@KFP{} = reprTag k +castTag KFloat = "float" +castTag KDouble = "double" +castTag KUnbounded = "integer" +castTag KReal = "real" +castTag k = reprTag k + +-- | Return the significand width of an arbitrary floating-point kind. +significandBits :: Kind -> Int +significandBits (KFP _ sb) = sb +significandBits KFloat = 24 +significandBits KDouble = 53 +significandBits k = error $ "SBV->C: Expected a floating-point kind, received " ++ show k + +-- | Render modular negation of a raw bit-vector representation. +negateRepr :: Kind -> String -> String +negateRepr k value + | isWideBV k = bvPrefix k ++ "_neg(" ++ value ++ ")" + | isBounded k = "(" ++ reprCType k ++ ") (~(uint64_t) " ++ value ++ " + UINT64_C(1))" + | otherwise = error $ "SBV->C: Cannot negate " ++ show k + +-- | Return the mask for the high limb of a raw bit-vector representation. +reprTopMask :: Kind -> Integer +reprTopMask k + | r == 0 = (1 `shiftL` 64) - 1 + | otherwise = (1 `shiftL` r) - 1 + where r = reprWidth k `mod` 64 + +-- | Return the bit width of a raw floating-point or bit-vector representation. +reprWidth :: Kind -> Int +reprWidth k + | isFP k || isBounded k = intSizeOf k + | otherwise = error $ "SBV->C: Expected a raw floating-point or bit-vector representation, received " ++ show k + +-- | Return the C type used by a raw floating-point or bit-vector representation. +reprCType :: Kind -> String +reprCType k@KFP{} = arbitraryFPCType k +reprCType (KBounded False 1) = "SBool" +reprCType (KBounded False w) = "SWord" ++ show w +reprCType (KBounded True w) = "SInt" ++ show w +reprCType k = error $ "SBV->C: Expected a raw floating-point or bit-vector representation, received " ++ show k + +-- | Return the generated tag for a raw representation. +reprTag :: Kind -> String +reprTag (KFP eb sb) = "f" ++ show eb ++ "_" ++ show sb +reprTag (KBounded False w) = "u" ++ show w +reprTag (KBounded True w) = "s" ++ show w +reprTag k = error $ "SBV->C: Expected a raw floating-point or bit-vector representation, received " ++ show k + +-- | Render a bit read from a raw representation. +reprGetBit :: Kind -> String -> String -> String +reprGetBit k@KFP{} value bit = prefix k ++ "_get(" ++ value ++ ", " ++ bit ++ ")" +reprGetBit k value bit + | isWideBV k = bvPrefix k ++ "_get(" ++ value ++ ", " ++ bit ++ ")" + | isBounded k = "((((uint64_t) " ++ value ++ ") >> (" ++ bit ++ ")) & UINT64_C(1)) != 0" + | otherwise = error $ "SBV->C: Cannot read bits from " ++ show k + +-- | Render a bit update to a raw representation. +reprSetBit :: Kind -> String -> String -> String -> String +reprSetBit k@KFP{} value bit bitValue = prefix k ++ "_set(&" ++ value ++ ", " ++ bit ++ ", " ++ bitValue ++ ");" +reprSetBit k value bit bitValue + | isWideBV k = bvPrefix k ++ "_set(&" ++ value ++ ", " ++ bit ++ ", " ++ bitValue ++ ");" + | isBounded k = value ++ " = (" ++ reprCType k ++ ") ((uint64_t) " ++ value ++ " | ((uint64_t) (" ++ bitValue ++ ") << (" ++ bit ++ ")));" + | otherwise = error $ "SBV->C: Cannot update bits in " ++ show k + +-- | Render the zero value for a raw representation. +reprZero :: Kind -> String +reprZero k@KFP{} = prefix k ++ "_zero()" +reprZero k + | isWideBV k = bvPrefix k ++ "_zero()" + | isBounded k = "(" ++ reprCType k ++ ") 0" + | otherwise = error $ "SBV->C: Cannot construct a zero of " ++ show k + +-- | Render canonicalization for a raw representation. +reprNormalize :: Kind -> String -> String +reprNormalize k@KFP{} value = prefix k ++ "_norm(" ++ value ++ ")" +reprNormalize k value + | isWideBV k = bvPrefix k ++ "_norm(" ++ value ++ ")" + | isBounded k = value + | otherwise = error $ "SBV->C: Cannot normalize " ++ show k + +-- | Return the generated namespace prefix for an exact-width bit-vector. +bvPrefix :: Kind -> String +bvPrefix (KBounded False w) = "sbv_bv_u" ++ show w +bvPrefix (KBounded True w) = "sbv_bv_s" ++ show w +bvPrefix k = error $ "SBV->C: Expected a bit-vector kind, received " ++ show k + +-- | Emit all helpers associated with a single floating-point format. +formatRuntime :: Kind -> [String] +formatRuntime k@(KFP eb sb) = + ["#if BF_EXP_BITS_MAX < " ++ show eb + , "#error \"The selected LibBF build cannot represent " ++ arbitraryFPCType k ++ "\"" + , "#endif" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_zero(void)" + , "{" + , " " ++ ty ++ " r = {{0}};" + , " return r;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_norm(" ++ ty ++ " a)" + , "{" + , " a.limb[" ++ show (n - 1) ++ "] &= " ++ u64 mask ++ ";" + , " return a;" + , "}" + , "" + , "static inline bool " ++ p ++ "_get(" ++ ty ++ " a, limb_t bit)" + , "{" + , " return bit < " ++ show width ++ " && ((a.limb[bit / 64] >> (bit % 64)) & UINT64_C(1)) != 0;" + , "}" + , "" + , "static inline void " ++ p ++ "_set(" ++ ty ++ " *a, limb_t bit, bool value)" + , "{" + , " const uint64_t m = UINT64_C(1) << (bit % 64);" + , " if (value) { a->limb[bit / 64] |= m; } else { a->limb[bit / 64] &= ~m; }" + , "}" + , "" + , "static inline uint64_t " ++ p ++ "_slice(" ++ ty ++ " a, limb_t offset, limb_t count)" + , "{" + , " uint64_t r = 0; limb_t i;" + , " for (i = 0; i < count; ++i) if (" ++ p ++ "_get(a, offset + i)) r |= UINT64_C(1) << i;" + , " return r;" + , "}" + , "" + , "static inline bool " ++ p ++ "_raw_eq(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " uint64_t r = 0; size_t i;" + , " for (i = 0; i < " ++ show n ++ "; ++i) r |= a.limb[i] ^ b.limb[i];" + , " return r == 0;" + , "}" + , "" + , "static inline uint64_t " ++ p ++ "_exponent(" ++ ty ++ " a)" + , "{" + , " return " ++ p ++ "_slice(a, " ++ show fracBits ++ ", " ++ show eb ++ ");" + , "}" + , "" + , "static inline bool " ++ p ++ "_fraction_is_zero(" ++ ty ++ " a)" + , "{" + , " limb_t i;" + , " for (i = 0; i < " ++ show fracBits ++ "; ++i) if (" ++ p ++ "_get(a, i)) return false;" + , " return true;" + , "}" + , "" + , "static inline bool " ++ p ++ "_is_nan(" ++ ty ++ " a)" + , "{ return " ++ p ++ "_exponent(a) == " ++ show expMask ++ " && !" ++ p ++ "_fraction_is_zero(a); }" + , "" + , "static inline bool " ++ p ++ "_is_infinite(" ++ ty ++ " a)" + , "{ return " ++ p ++ "_exponent(a) == " ++ show expMask ++ " && " ++ p ++ "_fraction_is_zero(a); }" + , "" + , "static inline bool " ++ p ++ "_is_zero(" ++ ty ++ " a)" + , "{ return " ++ p ++ "_exponent(a) == 0 && " ++ p ++ "_fraction_is_zero(a); }" + , "" + , "static inline bool " ++ p ++ "_is_subnormal(" ++ ty ++ " a)" + , "{ return " ++ p ++ "_exponent(a) == 0 && !" ++ p ++ "_fraction_is_zero(a); }" + , "" + , "static inline bool " ++ p ++ "_is_normal(" ++ ty ++ " a)" + , "{ const uint64_t e = " ++ p ++ "_exponent(a); return e != 0 && e != " ++ show expMask ++ "; }" + , "" + , "static inline bool " ++ p ++ "_is_negative(" ++ ty ++ " a)" + , "{ return !" ++ p ++ "_is_nan(a) && " ++ p ++ "_get(a, " ++ show (width - 1) ++ "); }" + , "" + , "static inline bool " ++ p ++ "_is_positive(" ++ ty ++ " a)" + , "{ return !" ++ p ++ "_is_nan(a) && !" ++ p ++ "_get(a, " ++ show (width - 1) ++ "); }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_neg(" ++ ty ++ " a)" + , "{ a.limb[" ++ show ((width - 1) `div` 64) ++ "] ^= UINT64_C(1) << " ++ show ((width - 1) `mod` 64) ++ "; return a; }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_abs(" ++ ty ++ " a)" + , "{ a.limb[" ++ show ((width - 1) `div` 64) ++ "] &= ~(UINT64_C(1) << " ++ show ((width - 1) `mod` 64) ++ "); return a; }" + , "" + , "static inline bool " ++ p ++ "_obj_eq(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ return (" ++ p ++ "_is_nan(a) && " ++ p ++ "_is_nan(b)) || " ++ p ++ "_raw_eq(a, b); }" + , "" + , "static inline void " ++ p ++ "_decode(bf_context_t *ctx, bf_t *r, " ++ ty ++ " raw)" + , "{" + , " const uint64_t e = " ++ p ++ "_exponent(raw);" + , " const bool sign = " ++ p ++ "_get(raw, " ++ show (width - 1) ++ ");" + , " bf_t chunk;" + , " bf_init(ctx, r); bf_init(ctx, &chunk);" + , " if (e == " ++ show expMask ++ ") {" + , " if (" ++ p ++ "_fraction_is_zero(raw)) bf_set_inf(r, sign); else bf_set_nan(r);" + , " } else if (e == 0 && " ++ p ++ "_fraction_is_zero(raw)) {" + , " bf_set_zero(r, sign);" + , " } else {" + , " bf_set_ui(r, e == 0 ? 0 : 1);" + ] + ++ concatMap decodeChunk chunks + ++ [" bf_mul_2exp(r, (slimb_t) e - " ++ show bias ++ " - " ++ show fracBits ++ " + (e == 0 ? 1 : 0), BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " if (sign) bf_neg(r);" + , " }" + , " bf_delete(&chunk);" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_encode(const bf_t *a)" + , "{" + , " " ++ ty ++ " raw = " ++ p ++ "_zero(); limb_t i;" + , " if (bf_is_nan(a)) {" + , " for (i = 0; i < " ++ show eb ++ "; ++i) " ++ p ++ "_set(&raw, " ++ show fracBits ++ " + i, true);" + , " " ++ p ++ "_set(&raw, " ++ show (fracBits - 1) ++ ", true);" + , " return raw;" + , " }" + , " if (a->sign) " ++ p ++ "_set(&raw, " ++ show (width - 1) ++ ", true);" + , " if (a->expn == BF_EXP_INF) {" + , " for (i = 0; i < " ++ show eb ++ "; ++i) " ++ p ++ "_set(&raw, " ++ show fracBits ++ " + i, true);" + , " return raw;" + , " }" + , " if (a->expn != BF_EXP_ZERO) {" + , " const slimb_t biased = a->expn + " ++ show bias ++ " - 1;" + , " const bool normal = biased > 0;" + , " const uint64_t e = normal ? (uint64_t) biased : UINT64_C(0);" + , " const slimb_t base = (slimb_t) a->len * LIMB_BITS;" + , " for (i = 0; i < " ++ show eb ++ "; ++i) " ++ p ++ "_set(&raw, " ++ show fracBits ++ " + i, ((e >> i) & UINT64_C(1)) != 0);" + , " for (i = 0; i < " ++ show fracBits ++ "; ++i) {" + , " const slimb_t bit = normal ? base + (slimb_t) i - " ++ show sb + ++ " : base + (slimb_t) i + 2 - " ++ show bias ++ " - " ++ show sb ++ " - a->expn;" + , " if (bit >= 0 && bit < base) " ++ p ++ "_set(&raw, i, ((a->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0);" + , " }" + , " }" + , " return raw;" + , "}" + , "" + ] + ++ arithmeticRuntime k + where ty = arbitraryFPCType k + p = prefix k + width = eb + sb + fracBits = sb - 1 + n = limbs k + mask = topMask k + expMask = (1 `shiftL` eb) - 1 :: Integer + bias = expMask `shiftR` 1 + chunks = reverse [(offset, min 64 (fracBits - offset)) | offset <- [0, 64 .. fracBits - 1]] + + decodeChunk (offset, count) = + [" bf_mul_2exp(r, " ++ show count ++ ", BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + , " bf_set_ui(&chunk, " ++ p ++ "_slice(raw, " ++ show offset ++ ", " ++ show count ++ "));" + , " bf_add(r, r, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ);" + ] +formatRuntime k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | Emit arithmetic and comparison adapters for one floating-point format. +arithmeticRuntime :: Kind -> [String] +arithmeticRuntime k@(KFP eb sb) = + ["static inline bf_flags_t " ++ p ++ "_flags(bf_rnd_t rnd)" + , "{ return (bf_flags_t) rnd | BF_FLAG_SUBNORMAL | bf_set_exp_bits(" ++ show eb ++ "); }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_binary(" ++ ty ++ " a, " ++ ty ++ " b, bf_rnd_t rnd, int op)" + , "{" + , " bf_context_t ctx; bf_t x, y, r; " ++ ty ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL);" + , " " ++ p ++ "_decode(&ctx, &x, a); " ++ p ++ "_decode(&ctx, &y, b); bf_init(&ctx, &r);" + , " if (op == 0) bf_add(&r, &x, &y, " ++ show sb ++ ", " ++ p ++ "_flags(rnd));" + , " else if (op == 1) bf_sub(&r, &x, &y, " ++ show sb ++ ", " ++ p ++ "_flags(rnd));" + , " else if (op == 2) bf_mul(&r, &x, &y, " ++ show sb ++ ", " ++ p ++ "_flags(rnd));" + , " else if (op == 3) bf_div(&r, &x, &y, " ++ show sb ++ ", " ++ p ++ "_flags(rnd));" + , " else bf_rem(&r, &x, &y, " ++ show sb ++ ", " ++ p ++ "_flags(BF_RNDN), BF_RNDN);" + , " raw = " ++ p ++ "_encode(&r);" + , " bf_delete(&r); bf_delete(&y); bf_delete(&x); bf_context_end(&ctx);" + , " return raw;" + , "}" + , "" + ] + ++ concatMap binaryWrapper [("add", 0), ("sub", 1), ("mul", 2), ("div", 3)] + ++ ["static inline " ++ ty ++ " " ++ p ++ "_rem(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ return " ++ p ++ "_binary(a, b, BF_RNDN, 4); }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_sqrt(" ++ ty ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, r; " ++ ty ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ p ++ "_decode(&ctx, &x, a); bf_init(&ctx, &r);" + , " bf_sqrt(&r, &x, " ++ show sb ++ ", " ++ p ++ "_flags(rnd)); raw = " ++ p ++ "_encode(&r);" + , " bf_delete(&r); bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_round(" ++ ty ++ " a, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x; " ++ ty ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ p ++ "_decode(&ctx, &x, a);" + , " bf_rint(&x, rnd); raw = " ++ p ++ "_encode(&x);" + , " bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_fma(" ++ ty ++ " a, " ++ ty ++ " b, " ++ ty ++ " c, bf_rnd_t rnd)" + , "{" + , " bf_context_t ctx; bf_t x, y, z, r; " ++ ty ++ " raw;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL);" + , " " ++ p ++ "_decode(&ctx, &x, a); " ++ p ++ "_decode(&ctx, &y, b); " ++ p ++ "_decode(&ctx, &z, c); bf_init(&ctx, &r);" + , " bf_mul(&r, &x, &y, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDN); bf_add(&r, &r, &z, " ++ show sb ++ ", " ++ p ++ "_flags(rnd));" + , " raw = " ++ p ++ "_encode(&r);" + , " bf_delete(&r); bf_delete(&z); bf_delete(&y); bf_delete(&x); bf_context_end(&ctx); return raw;" + , "}" + , "" + , "static inline int " ++ p ++ "_compare(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " bf_context_t ctx; bf_t x, y; int result;" + , " bf_context_init(&ctx, sbv_bf_realloc, NULL); " ++ p ++ "_decode(&ctx, &x, a); " ++ p ++ "_decode(&ctx, &y, b);" + , " result = bf_cmp(&x, &y); bf_delete(&y); bf_delete(&x); bf_context_end(&ctx); return result;" + , "}" + , "" + , "static inline bool " ++ p ++ "_eq(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ return " ++ p ++ "_compare(a, b) == 0; }" + , "" + , "static inline bool " ++ p ++ "_lt(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ return " ++ p ++ "_compare(a, b) < 0; }" + , "" + , "static inline bool " ++ p ++ "_le(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{ return " ++ p ++ "_compare(a, b) <= 0; }" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_min(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " if (" ++ p ++ "_is_nan(a)) return b; if (" ++ p ++ "_is_nan(b)) return a;" + , " if (" ++ p ++ "_is_zero(a) && " ++ p ++ "_is_zero(b)) return " ++ p ++ "_is_negative(a) ? a : b;" + , " return " ++ p ++ "_lt(a, b) ? a : b;" + , "}" + , "" + , "static inline " ++ ty ++ " " ++ p ++ "_max(" ++ ty ++ " a, " ++ ty ++ " b)" + , "{" + , " if (" ++ p ++ "_is_nan(a)) return b; if (" ++ p ++ "_is_nan(b)) return a;" + , " if (" ++ p ++ "_is_zero(a) && " ++ p ++ "_is_zero(b)) return " ++ p ++ "_is_negative(a) ? b : a;" + , " return " ++ p ++ "_lt(b, a) ? a : b;" + , "}" + , "" + ] + where ty = arbitraryFPCType k + p = prefix k + + binaryWrapper :: (String, Int) -> [String] + binaryWrapper (nm, op) = + ["static inline " ++ ty ++ " " ++ p ++ "_" ++ nm ++ "(" ++ ty ++ " a, " ++ ty ++ " b, bf_rnd_t rnd)" + , "{ return " ++ p ++ "_binary(a, b, rnd, " ++ show op ++ "); }" + , ""] +arithmeticRuntime k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | Render the LibBF rounding mode corresponding to an SBV value. +bfRoundingMode :: [(SV, CV)] -> SV -> Doc +bfRoundingMode consts sv = case sv `lookup` consts of + Just (CV k (CADT (rmName, []))) + | isRoundingMode k -> maybe bad (text . snd) (lookup rmName roundingModeNames) + Nothing + | isRoundingMode sv -> namedCall "sbv_bf_rounding_mode" [text (show sv)] + _ -> bad + where bad = error $ "SBV->C: Expected a rounding mode, received " ++ show sv + +-- | Mapping from SBV constructor names to public C and LibBF constants. +roundingModeNames :: [(String, (String, String))] +roundingModeNames = + [ ("RoundNearestTiesToEven", ("SBV_RM_RNE", "BF_RNDN")) + , ("RoundNearestTiesToAway", ("SBV_RM_RNA", "BF_RNDNA")) + , ("RoundTowardPositive", ("SBV_RM_RTP", "BF_RNDU")) + , ("RoundTowardNegative", ("SBV_RM_RTN", "BF_RNDD")) + , ("RoundTowardZero", ("SBV_RM_RTZ", "BF_RNDZ")) + ] + +-- | Render a C function call. +namedCall :: String -> [Doc] -> Doc +namedCall nm args = text nm P.<> parens (fsep (punctuate comma args)) + +-- | Return the number of raw 64-bit limbs occupied by an arbitrary float. +limbs :: Kind -> Int +limbs k = (intSizeOf k + 63) `div` 64 + +-- | Return the mask for the high raw limb of an arbitrary float. +topMask :: Kind -> Integer +topMask k + | r == 0 = (1 `shiftL` 64) - 1 + | otherwise = (1 `shiftL` r) - 1 + where r = intSizeOf k `mod` 64 + +-- | Return the generated namespace prefix for a floating-point format. +prefix :: Kind -> String +prefix (KFP eb sb) = "sbv_fp_e" ++ show eb ++ "_s" ++ show sb +prefix k = error $ "SBV->C: Expected an arbitrary floating-point kind, received " ++ show k + +-- | Render raw interchange bits as a C compound literal. +rawLiteral :: Kind -> Integer -> String +rawLiteral k bits = "(" ++ arbitraryFPCType k ++ "){{" ++ intercalate ", " words64 ++ "}}" + where words64 = [u64 ((bits `shiftR` (64 * i)) .&. ((1 `shiftL` 64) - 1)) | i <- [0 .. limbs k - 1]] + +-- | Render an integer as a padded, portable C @uint64_t@ literal. +u64 :: Integer -> String +u64 i = "UINT64_C(0x" ++ pad 16 (showHex i "") ++ ")" + where pad n s = replicate (n - length s) '0' ++ s diff --git a/Data/SBV/Compilers/C/Finite.hs b/Data/SBV/Compilers/C/Finite.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Finite.hs @@ -0,0 +1,40 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Finite +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Finite SMT-object domains shared by C collection lowering. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Finite (finiteDomainSize) where + +import qualified Data.Set as Set + +import Data.SBV.Core.Data + +-- | Count distinct SMT objects without imposing a machine-integer limit. +-- All NaN encodings denote one object; signed zeros remain distinct. The +-- constructor callback resolves ADT references without a module dependency +-- cycle. Recursive and unbounded domains return 'Nothing'. +finiteDomainSize :: (Kind -> [[Kind]]) -> Kind -> Maybe Integer +finiteDomainSize constructorsOf = count Set.empty + where count _ KBool = Just 2 + count _ (KBounded _ width) = Just (2 ^ width) + count _ KFloat = Just (2 ^ (32 :: Int) - 2 ^ (24 :: Int) + 3) + count _ KDouble = Just (2 ^ (64 :: Int) - 2 ^ (53 :: Int) + 3) + count _ KChar = Just 0x30000 + count _ (KFP eb sb) = Just (2 ^ (eb + sb) - 2 ^ sb + 3) + count seen (KTuple fields) = product <$> mapM (count seen) fields + count seen kind + | isRoundingMode kind = Just 5 + | concrete kind, kind `Set.notMember` seen + = sum <$> mapM (fmap product . mapM (count (Set.insert kind seen))) (constructorsOf kind) + | True = Nothing + + concrete KApp{} = True + concrete kind = isADT kind && not (isUninterpreted kind) diff --git a/Data/SBV/Compilers/C/GMP.hs b/Data/SBV/Compilers/C/GMP.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/GMP.hs @@ -0,0 +1,801 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.GMP +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Exact GMP-backed lowering of unbounded integers, reals, and rationals to C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.GMP + ( isExactGMPKind + , gmpEqual + , gmpTypeDecls + , gmpRuntime + , gmpConst + , gmpExpr + , gmpPrint + , gmpSet + , gmpFunctionName + , gmpNewName + , gmpInitializeCopy + , gmpDriverAssign + , gmpOutputType + , gmpArrayType + , gmpDriverInitialize + , gmpDriverInit + , gmpDriverClear + , gmpContextStart + , gmpContextEnd + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.Bits (shiftL) +import Data.List (nub, stripPrefix, tails) +import Data.Ratio (denominator, numerator) +import qualified Data.Set as Set +import qualified Data.Text as T +import Numeric (showHex) + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.BV (isWideBV, mappedIntegerKind) +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.CodeGen (CgConfig(..)) +import Data.SBV.Core.Data +import Data.SBV.Core.Symbolic (NROp(..)) + +-- | Test whether a kind uses the exact GMP representation under this +-- configuration. Supplying 'Data.SBV.Tools.CodeGen.cgIntegerSize' or +-- 'Data.SBV.Tools.CodeGen.cgSRealType' selects the +-- historical lossy representation for 'KUnbounded' or 'KReal'; 'KRational' +-- is always exact. +isExactGMPKind :: CgConfig -> Kind -> Bool +isExactGMPKind cfg KUnbounded = case cgInteger cfg of + Nothing -> True + Just{} -> False +isExactGMPKind cfg KReal = case cgReal cfg of + Nothing -> True + Just{} -> False +isExactGMPKind _ KRational = True +isExactGMPKind _ _ = False + +-- | Compare two exact GMP-backed values for equality. +gmpEqual :: Kind -> Doc -> Doc -> Doc +gmpEqual kind left right = parens $ namedCall (kindPrefix kind ++ "cmp") [left, right] <+> text "==" <+> text "0" + +-- | Declare the GMP-backed public C types required by the supplied kinds. +-- Inputs are borrowed read-only pointers. Outputs and exact return parameters +-- are caller-initialized mutable GMP pointers. +gmpTypeDecls :: CgConfig -> Set.Set Kind -> Doc +gmpTypeDecls cfg kinds + | not needsExactInteger && not needsExactQuotient = empty + | True = text . unlines $ + ["/* Exact integers, reals, and rationals. Inputs are borrowed; scalar outputs are caller-initialized. */" + , "/* Initialize each scalar/group output with mpz_init or mpq_init; clear it after its last use. */" + , "/* Aggregate outputs instead receive fresh owned values, including any embedded GMP fields. */" + , "#include " + , cUnusedAttribute] + ++ integerDecls + ++ realDecls + ++ rationalDecls + ++ [""] + where needsExactInteger = isExactGMPKind cfg KUnbounded && KUnbounded `Set.member` kinds + needsExactReal = isExactGMPKind cfg KReal && KReal `Set.member` kinds + needsRational = KRational `Set.member` kinds + needsExactQuotient = needsExactReal || needsRational + + integerDecls + | needsExactInteger = [ "#ifndef SBV_GMP_INTEGER_DEFINED" + , "#define SBV_GMP_INTEGER_DEFINED" + , "typedef mpz_srcptr SInteger;" + , "#endif" + ] + | True = [] + + realDecls + | needsExactReal = [ "#ifndef SBV_GMP_REAL_DEFINED" + , "#define SBV_GMP_REAL_DEFINED" + , "typedef mpq_srcptr SReal;" + , "#endif" + ] + | True = [] + + rationalDecls + | needsRational = [ "#ifndef SBV_GMP_RATIONAL_DEFINED" + , "#define SBV_GMP_RATIONAL_DEFINED" + , "typedef mpq_srcptr SRational;" + , "#endif" + ] + | True = [] + +-- | Emit the per-call arena and the exact numeric helpers required by a +-- program. Every temporary GMP value is released together at function exit. +gmpRuntime :: CgConfig -> Set.Set Kind -> [(SV, SBVExpr)] -> Doc +gmpRuntime cfg kinds assignments + | not needsExactInteger && not needsExactQuotient = empty + | True = text . unlines . map markUnused $ + commonRuntime + ++ [""] + ++ concat [integerRuntime needsIntegerShifts | needsExactInteger] + ++ concat [realRuntime | needsExactQuotient] + ++ concat [rationalRuntime cfg | needsRational] + ++ concat [crossRuntime | needsExactInteger && needsExactQuotient] + ++ concatMap nativeGMPResultRuntime (nativeGMPResultKinds cfg assignments) + ++ concat [concatMap wideIntegerRuntime conversions | needsExactInteger] + ++ concat [concatMap wideQuotientRuntime quotientConversions | needsExactQuotient] + where needsExactInteger = isExactGMPKind cfg KUnbounded && KUnbounded `Set.member` kinds + needsExactReal = isExactGMPKind cfg KReal && KReal `Set.member` kinds + needsRational = KRational `Set.member` kinds + needsExactQuotient = needsExactReal || needsRational + conversions = nub (concatMap wideIntegerConversions assignments) + quotientConversions = nub (concatMap wideQuotientConversions assignments) + needsIntegerShifts = any integerShift assignments + integerShift (result, SBVApp operation _) + | kindOf result == KUnbounded = case operation of + Shl -> True + Shr -> True + Rol{} -> True + Ror{} -> True + _ -> False + | True = False + + markUnused line = case stripPrefix "static " line of + Just rest -> "static SBV_CGEN_UNUSED " ++ rest + Nothing -> line + +-- | Render an exact integer, real, or rational constant as an arena allocation. +gmpConst :: CgConfig -> CV -> Maybe Doc +gmpConst cfg (CV KUnbounded (CInteger i)) + | isExactGMPKind cfg KUnbounded + = Just $ namedCall "sbv_gmp_integer_const" [text "&sbv_local_gmp_ctx", doubleQuotes (integer i)] +gmpConst cfg (CV KReal (CAlgReal (AlgRational _ r))) + | isExactGMPKind cfg KReal + = Just $ namedCall "sbv_gmp_real_const" [text "&sbv_local_gmp_ctx", doubleQuotes (text value)] + where value = show (numerator r) ++ "/" ++ show (denominator r) +gmpConst cfg (CV KReal (CAlgReal r)) + | isExactGMPKind cfg KReal + = error $ "SBV->C: GMP-backed SReal constants must be rational, received " ++ show r +gmpConst _ (CV KRational (CRational r)) + = Just $ namedCall "sbv_gmp_real_const" [text "&sbv_local_gmp_ctx", doubleQuotes (text value)] + where value = show (numerator r) ++ "/" ++ show (denominator r) +gmpConst _ _ = Nothing + +-- | Lower an operation involving an exact GMP value. A 'Nothing' result +-- delegates the operation to another C lowering module. +gmpExpr :: CgConfig -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +gmpExpr cfg op svs resultKind args + | not (isExactGMPKind cfg resultKind || any (isExactGMPKind cfg . kindOf) svs) + = Nothing + | IEEEFP{} <- op + = Nothing + | KindCast fr to <- op + , Just{} <- cgReal cfg + , KReal `elem` [fr, to] + = Nothing + | LkUp{} <- op + = Nothing + | Uninterpreted functionName <- op + , T.unpack functionName /= "sbv.rat.numerator" + , T.unpack functionName /= "sbv.rat.denominator" + = Nothing + | True + = case (op, args, svs) of + (Label _ , [a] , _) -> lower a + (Plus , [a, b] , x:_) -> lower $ valueCall x "add" [a, b] + (Minus , [a, b] , x:_) -> lower $ valueCall x "sub" [a, b] + (Times , [a, b] , x:_) -> lower $ valueCall x "mul" [a, b] + (NonLinear NR_IntPow , [a, b] , x:_) -> lower $ valueCall x "pow" [a, b] + (UNeg , [a] , x:_) -> lower $ valueCall x "neg" [a] + (Abs , [a] , x:_) -> lower $ valueCall x "abs" [a] + (Quot , [a, b] , x:_) -> lower $ valueCall x "quot" [a, b] + (RationalConstructor , [n, d] , _) -> lower $ namedCall "sbv_gmp_rational_construct" [text "&sbv_local_gmp_ctx", n, d] + (Uninterpreted funName, [a] , _) + | T.unpack funName == "sbv.rat.numerator" -> lower $ namedCall "sbv_gmp_rational_numerator" [a] + | T.unpack funName == "sbv.rat.denominator" -> lower $ namedCall "sbv_gmp_rational_denominator" [a] + (Rem , [a, b] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "rem" [a, b] + (And , [a, b] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "and" [a, b] + (Or , [a, b] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "or" [a, b] + (XOr , [a, b] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "xor" [a, b] + (Not , [a] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "com" [a] + (Shl , [a, n] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "shl" [a, n] + (Shr , [a, n] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "shr" [a, n] + (Rol n , [a] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "shl" [a, integerValue n] + (Ror n , [a] , x:_) + | kindOf x == KUnbounded -> lower $ valueCall x "shr" [a, integerValue n] + (Equal _ , [a, b] , x:_) -> lower $ comparison x "==" a b + (NotEqual , as , x:_) -> lower $ distinctExpr x as + (LessThan , [a, b] , x:_) -> lower $ comparison x "<" a b + (GreaterThan , [a, b] , x:_) -> lower $ comparison x ">" a b + (LessEq , [a, b] , x:_) -> lower $ comparison x "<=" a b + (GreaterEq , [a, b] , x:_) -> lower $ comparison x ">=" a b + (Divides n , [a] , x:_) + | kindOf x == KUnbounded -> lower $ namedCall "sbv_gmp_integer_divides" + [namedCall "sbv_gmp_integer_const" [text "&sbv_local_gmp_ctx", doubleQuotes (integer n)], a] + (KindCast fr to , [a] , _) -> gmpCast fr to a + _ -> unsupported + where lower = lowerWith [CRequiresGMP] + + lowerWith requirements = Just . expressionLowering requirements + + valueCall sv suffix = namedCall (kindPrefix (kindOf sv) ++ suffix) . (text "&sbv_local_gmp_ctx" :) + + comparison sv relation a b = parens $ namedCall (kindPrefix (kindOf sv) ++ "cmp") [a, b] <+> text relation <+> text "0" + + integerValue value = namedCall "sbv_gmp_integer_const" [text "&sbv_local_gmp_ctx", doubleQuotes (integer (fromIntegral value))] + + distinctExpr sv as = fsep $ punctuate (text " &&") + [parens (namedCall (kindPrefix (kindOf sv) ++ "cmp") [a, b] <+> text "!= 0") + | (a:rest) <- tails as, b <- rest] + + gmpCast fr to a + | fr == to = lower a + | fr == KUnbounded && to `elem` [KReal, KRational] + = if isExactGMPKind cfg KUnbounded + then lower $ namedCall "sbv_gmp_real_from_integer" [text "&sbv_local_gmp_ctx", a] + else lower $ namedCall "sbv_gmp_real_from_s64" + [text "&sbv_local_gmp_ctx", parens (text "int64_t") <+> a] + | fr == KReal && to == KUnbounded + = if isExactGMPKind cfg to + then lower $ namedCall "sbv_gmp_integer_from_real" [text "&sbv_local_gmp_ctx", a] + else lower $ nativeResult to (namedCall "sbv_gmp_real_low_u64" [a]) + | isWideBV fr && to `elem` [KReal, KRational] + = lowerWith [CRequiresGMP, CRequiresWideBV] $ namedCall (quotientFromWideName fr) [text "&sbv_local_gmp_ctx", a] + | isWideBV fr && to == KUnbounded + = lowerWith [CRequiresGMP, CRequiresWideBV] $ namedCall (integerFromWideName fr) [text "&sbv_local_gmp_ctx", a] + | fr == KUnbounded && isWideBV to + = lowerWith [CRequiresGMP, CRequiresWideBV] $ namedCall (integerToWideName to) [a] + | isBounded fr && intSizeOf fr <= 64 && to == KUnbounded + = lower $ namedCall (if hasSign fr then "sbv_gmp_integer_from_s64" else "sbv_gmp_integer_from_u64") + [text "&sbv_local_gmp_ctx", parens (text (if hasSign fr then "int64_t" else "uint64_t")) <+> a] + | fr == KUnbounded && isBounded to && not (isWideBV to) + = lower $ nativeResult to (namedCall "sbv_gmp_integer_low_u64" [a]) + | isBounded fr && intSizeOf fr <= 64 && to `elem` [KReal, KRational] + = lower $ namedCall (if hasSign fr then "sbv_gmp_real_from_s64" else "sbv_gmp_real_from_u64") + [text "&sbv_local_gmp_ctx", parens (text (if hasSign fr then "int64_t" else "uint64_t")) <+> a] + | fr == KReal && isBounded to && not (isWideBV to) + = lower $ nativeResult to (namedCall "sbv_gmp_real_low_u64" [a]) + | otherwise + = unsupportedCast fr to + + nativeResult to value = namedCall (nativeGMPResultName (mappedIntegerKind (cgInteger cfg) to)) [value] + + unsupported = error $ "SBV->C: exact GMP lowering does not yet support " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + + unsupportedCast fr to = error $ "SBV->C: exact GMP lowering does not yet support a cast from " ++ show fr ++ " to " ++ show to + +-- | Discover native result representations for exact GMP casts. Explicitly +-- mapped integers use the same low-bit conversion as signed bit-vectors. +nativeGMPResultKinds :: CgConfig -> [(SV, SBVExpr)] -> [Kind] +nativeGMPResultKinds cfg = nub . concatMap resultKind + where resultKind (_, SBVApp (KindCast fr to) _) + | isExactGMPKind cfg fr + , let target = mappedIntegerKind (cgInteger cfg) to + , isBounded target + , not (isWideBV target) = [target] + resultKind _ = [] + +-- | Name a helper that interprets low integer bits in a native representation. +nativeGMPResultName :: Kind -> String +nativeGMPResultName kind = "sbv_gmp_low_bits_" ++ boundedTag kind + +-- | Convert reduced unsigned bits without implementation-defined signed +-- narrowing or C's nonzero-to-Boolean conversion. A one-bit vector uses bit 0. +nativeGMPResultRuntime :: Kind -> [String] +nativeGMPResultRuntime kind = + [ "static " ++ boundedCType kind ++ " " ++ nativeGMPResultName kind ++ "(uint64_t value)" + , "{" + ] + ++ result + ++ ["}", ""] + where result + | kind == KBounded False 1 + = [" return (value & UINT64_C(1)) != 0;"] + | hasSign kind + = [ " const SWord" ++ show (intSizeOf kind) ++ " bits = (SWord" ++ show (intSizeOf kind) ++ ") value;" + , " " ++ boundedCType kind ++ " result; memcpy(&result, &bits, sizeof result); return result;" + ] + | True + = [" return (" ++ boundedCType kind ++ ") value;"] + +-- | A generated conversion between a limb-backed bit-vector and an exact GMP +-- integer. +data WideIntegerConversion = IntegerFromWide Kind + | IntegerToWide Kind + deriving Eq + +-- | Discover wide bit-vector and exact-integer casts in one symbolic +-- assignment. +wideIntegerConversions :: (SV, SBVExpr) -> [WideIntegerConversion] +wideIntegerConversions (_, SBVApp (KindCast fr to) _) + | isWideBV fr && to == KUnbounded = [IntegerFromWide fr] + | fr == KUnbounded && isWideBV to = [IntegerToWide to] +wideIntegerConversions _ = [] + +-- | A generated conversion from a limb-backed bit-vector to an exact GMP +-- real or rational. +newtype WideQuotientConversion = QuotientFromWide Kind + deriving Eq + +-- | Discover limb-backed bit-vector to exact real or rational casts in one +-- symbolic assignment. +wideQuotientConversions :: (SV, SBVExpr) -> [WideQuotientConversion] +wideQuotientConversions (_, SBVApp (KindCast fr to) _) + | isWideBV fr + , to `elem` [KReal, KRational] = [QuotientFromWide fr] +wideQuotientConversions _ = [] + +-- | Emit an exact conversion helper for one wide bit-vector kind. +wideIntegerRuntime :: WideIntegerConversion -> [String] +wideIntegerRuntime (IntegerFromWide k) = + [ "static SInteger " ++ integerFromWideName k ++ "(sbv_gmp_ctx *ctx, " ++ boundedCType k ++ " a)" + , "{" + , " mpz_ptr r = sbv_gmp_new_integer(ctx);" + , " mpz_import(r, " ++ show limbCount ++ ", -1, sizeof(a.limb[0]), 0, 0, a.limb);" + ] + ++ signedAdjustment + ++ [ " return r;" + , "}" + , "" + ] + where limbCount = (intSizeOf k + 63) `div` 64 + signedAdjustment + | hasSign k = + [ " if ((a.limb[" ++ show topLimb ++ "] & " ++ u64 signMask ++ ") != 0) {" + , " mpz_t modulus; mpz_init_set_ui(modulus, 1); mpz_mul_2exp(modulus, modulus, " ++ show width ++ ");" + , " mpz_sub(r, r, modulus); mpz_clear(modulus);" + , " }" + ] + | True = [] + width = intSizeOf k + topLimb = (width - 1) `div` 64 + signMask = 1 `shiftL` ((width - 1) `mod` 64) +wideIntegerRuntime (IntegerToWide k) = + [ "static " ++ boundedCType k ++ " " ++ integerToWideName k ++ "(SInteger a)" + , "{" + , " " ++ boundedCType k ++ " r = {{0}}; size_t count = 0; mpz_t reduced;" + , " mpz_init(reduced); mpz_fdiv_r_2exp(reduced, a, " ++ show (intSizeOf k) ++ ");" + , " mpz_export(r.limb, &count, -1, sizeof(r.limb[0]), 0, 0, reduced); mpz_clear(reduced);" + , " r.limb[" ++ show (limbCount - 1) ++ "] &= " ++ u64 topMask ++ ";" + , " return r;" + , "}" + , "" + ] + where limbCount = (intSizeOf k + 63) `div` 64 + remainder = intSizeOf k `mod` 64 + topMask + | remainder == 0 = (1 `shiftL` 64) - 1 + | True = (1 `shiftL` remainder) - 1 + +-- | Emit an exact real-or-rational conversion helper for one wide bit-vector +-- kind. +wideQuotientRuntime :: WideQuotientConversion -> [String] +wideQuotientRuntime (QuotientFromWide k) = + [ "static mpq_srcptr " ++ quotientFromWideName k ++ "(sbv_gmp_ctx *ctx, " ++ boundedCType k ++ " a)" + , "{" + , " mpq_ptr r = sbv_gmp_new_real(ctx);" + , " mpz_import(mpq_numref(r), " ++ show limbCount ++ ", -1, sizeof(a.limb[0]), 0, 0, a.limb);" + ] + ++ signedAdjustment + ++ [ " return r;" + , "}" + , "" + ] + where limbCount = (intSizeOf k + 63) `div` 64 + signedAdjustment + | hasSign k = + [ " if ((a.limb[" ++ show topLimb ++ "] & " ++ u64 signMask ++ ") != 0) {" + , " mpz_t modulus; mpz_init_set_ui(modulus, 1); mpz_mul_2exp(modulus, modulus, " ++ show width ++ ");" + , " mpz_sub(mpq_numref(r), mpq_numref(r), modulus); mpz_clear(modulus);" + , " }" + ] + | True = [] + width = intSizeOf k + topLimb = (width - 1) `div` 64 + signMask = 1 `shiftL` ((width - 1) `mod` 64) + +-- | Construct the helper name for a wide bit-vector to exact-integer cast. +integerFromWideName :: Kind -> String +integerFromWideName k = "sbv_gmp_integer_from_" ++ boundedTag k + +-- | Construct the helper name for an exact-integer to wide bit-vector cast. +integerToWideName :: Kind -> String +integerToWideName k = "sbv_gmp_integer_to_" ++ boundedTag k + +-- | Construct the helper name for a wide bit-vector to an exact GMP quotient. +quotientFromWideName :: Kind -> String +quotientFromWideName k = "sbv_gmp_real_from_" ++ boundedTag k + +-- | Return the C type used for a bounded SBV kind. +boundedCType :: Kind -> String +boundedCType (KBounded False 1) = "SBool" +boundedCType (KBounded False w) = "SWord" ++ show w +boundedCType (KBounded True w) = "SInt" ++ show w +boundedCType k = error $ "SBV->C: Expected a bounded kind, received " ++ show k + +-- | Return the signedness-and-width suffix used in a conversion helper name. +boundedTag :: Kind -> String +boundedTag k + | isBounded k = (if hasSign k then "s" else "u") ++ show (intSizeOf k) + | True = error $ "SBV->C: Expected a bounded kind, received " ++ show k + +-- | Render a padded, portable C @uint64_t@ literal. +u64 :: Integer -> String +u64 value = "UINT64_C(0x" ++ replicate (16 - length rendered) '0' ++ rendered ++ ")" + where rendered = showHex value "" + +-- | Print an exact GMP value in canonical decimal notation. +gmpPrint :: Kind -> Doc -> Doc +gmpPrint KUnbounded value = namedCall "gmp_printf" [doubleQuotes (text "%Zd"), value] +gmpPrint KReal value = namedCall "gmp_printf" [doubleQuotes (text "%Qd"), value] +gmpPrint KRational value = namedCall "gmp_printf" [doubleQuotes (text "%Qd"), value] +gmpPrint k _ = error $ "SBV->C: Expected an exact GMP kind, received " ++ show k + +-- | Copy an internal immutable exact value into caller-owned GMP storage. +gmpSet :: Kind -> Doc -> Doc -> Doc +gmpSet kind target value = namedCall (gmpFunctionName kind "set") [target, value] + +-- | Select a public GMP operation for storage already known to use the exact +-- representation. Callers must check 'isExactGMPKind' before using this for a +-- configurable integer or real kind. +gmpFunctionName :: Kind -> String -> String +gmpFunctionName kind suffix = gmpPrefix kind ++ suffix + +-- | Public GMP namespace for a kind whose storage has already been selected +-- as exact. Representation selection belongs to 'isExactGMPKind'; this helper +-- supplies the common prefix of both function and type names. +gmpPrefix :: Kind -> String +gmpPrefix KUnbounded = "mpz_" +gmpPrefix KReal = "mpq_" +gmpPrefix KRational = "mpq_" +gmpPrefix kind = error $ "SBV->C: Expected an exact GMP kind, received " ++ show kind + +-- | Name the arena allocator for an exact value. It returns initialized, +-- mutable GMP storage owned by the supplied arena. +gmpNewName :: Kind -> String +gmpNewName KUnbounded = "sbv_gmp_new_integer" +gmpNewName KReal = "sbv_gmp_new_real" +gmpNewName KRational = "sbv_gmp_new_real" +gmpNewName kind = error $ "SBV->C: Expected an exact GMP kind, received " ++ show kind + +-- | Initialize uninitialized exact storage with a copy. GMP provides a +-- combined operation for integers, but rationals require two calls. +gmpInitializeCopy :: Kind -> Doc -> Doc -> Doc +gmpInitializeCopy KUnbounded target value = namedCall "mpz_init_set" [target, value] P.<> semi +gmpInitializeCopy kind target value = namedCall (gmpFunctionName kind "init") [target] P.<> semi + $$ gmpSet kind target value P.<> semi + +-- | Assign an integer-valued decimal driver sample to an initialized field. +-- The field may have the immutable public pointer type, so cast back to its +-- owned mutable storage. Rational values are canonicalized after parsing. +gmpDriverAssign :: Kind -> Doc -> Doc -> [Doc] +gmpDriverAssign kind access value + = ( text "if" <+> parens (namedCall (gmpFunctionName kind "set_str") [target, doubleQuotes value, text "10"] <+> text "!= 0") + <+> namedCall "abort" [] P.<> semi + ) + : [namedCall (gmpFunctionName kind "canonicalize") [target] P.<> semi | kind /= KUnbounded] + where target = parens (text (gmpOutputType kind)) <+> access + +-- | Return the mutable GMP pointer type used for an output parameter. +gmpOutputType :: Kind -> String +gmpOutputType kind = gmpPrefix kind ++ "ptr" + +-- | Return the mutable GMP storage type used for one element of a generated +-- fixed-size array. +gmpArrayType :: Kind -> String +gmpArrayType kind = gmpPrefix kind ++ "t" + +-- | Initialize already-declared caller-owned GMP storage from an +-- integer-valued driver sample. +gmpDriverInitialize :: Kind -> Doc -> Doc -> Doc +gmpDriverInitialize KUnbounded storage value = namedCall "mpz_init_set_str" [storage, doubleQuotes value, text "10"] P.<> semi +gmpDriverInitialize KReal storage value = namedCall "mpq_init" [storage] P.<> semi + $$ namedCall "mpq_set_str" [storage, doubleQuotes value, text "10"] P.<> semi + $$ namedCall "mpq_canonicalize" [storage] P.<> semi +gmpDriverInitialize KRational storage value = namedCall "mpq_init" [storage] P.<> semi + $$ namedCall "mpq_set_str" [storage, doubleQuotes value, text "10"] P.<> semi + $$ namedCall "mpq_canonicalize" [storage] P.<> semi +gmpDriverInitialize kind _ _ = error $ "SBV->C: Expected an exact GMP kind, received " ++ show kind + +-- | Declare and initialize a caller-owned GMP value from an integer-valued +-- driver sample. +gmpDriverInit :: Kind -> Doc -> Doc -> Doc +gmpDriverInit kind storage value = text (gmpArrayType kind) <+> storage P.<> semi + $$ gmpDriverInitialize kind storage value + +-- | Clear caller-owned GMP storage in a generated driver. +gmpDriverClear :: Kind -> Doc -> Doc +gmpDriverClear kind storage = namedCall (gmpFunctionName kind "clear") [storage] P.<> semi + +-- | Initialize the arena used by exact temporaries in a generated function. +gmpContextStart :: Doc +gmpContextStart = text "sbv_gmp_ctx sbv_local_gmp_ctx = {NULL};" + +-- | Release all exact temporaries allocated by a generated function. +gmpContextEnd :: Doc +gmpContextEnd = namedCall "sbv_gmp_ctx_end" [text "&sbv_local_gmp_ctx"] P.<> semi + +-- | Return the generated helper namespace for an exact numeric kind. +kindPrefix :: Kind -> String +kindPrefix KUnbounded = "sbv_gmp_integer_" +kindPrefix KReal = "sbv_gmp_real_" +kindPrefix KRational = "sbv_gmp_real_" +kindPrefix k = error $ "SBV->C: Expected an exact GMP kind, received " ++ show k + +-- | Render a C function call. +namedCall :: String -> [Doc] -> Doc +namedCall nm args = text nm P.<> parens (fsep (punctuate comma args)) + +-- | Runtime shared by exact integers, reals, and rationals. +commonRuntime :: [String] +commonRuntime = + ["/* Per-call ownership arena for exact GMP temporaries. */" + , "typedef struct sbv_gmp_node {" + , " struct sbv_gmp_node *next;" + , " bool is_real;" + , " union { mpz_t integer; mpq_t real; } value;" + , "} sbv_gmp_node;" + , "" + , "typedef struct { sbv_gmp_node *head; } sbv_gmp_ctx;" + , "" + , "static mpz_ptr sbv_gmp_new_integer(sbv_gmp_ctx *ctx)" + , "{" + , " sbv_gmp_node *node = (sbv_gmp_node *) malloc(sizeof(*node));" + , " if (node == NULL) abort();" + , " node->next = ctx->head; node->is_real = false; ctx->head = node;" + , " mpz_init(node->value.integer);" + , " return node->value.integer;" + , "}" + , "" + , "static mpq_ptr sbv_gmp_new_real(sbv_gmp_ctx *ctx)" + , "{" + , " sbv_gmp_node *node = (sbv_gmp_node *) malloc(sizeof(*node));" + , " if (node == NULL) abort();" + , " node->next = ctx->head; node->is_real = true; ctx->head = node;" + , " mpq_init(node->value.real);" + , " return node->value.real;" + , "}" + , "" + , "static void sbv_gmp_ctx_end(sbv_gmp_ctx *ctx)" + , "{" + , " while (ctx->head != NULL) {" + , " sbv_gmp_node *node = ctx->head; ctx->head = node->next;" + , " if (node->is_real) mpq_clear(node->value.real); else mpz_clear(node->value.integer);" + , " free(node);" + , " }" + , "}" + , "" + , "static void sbv_gmp_ctx_release_owned(const void *context)" + , "{" + , " sbv_gmp_ctx *owned = (sbv_gmp_ctx *) context;" + , " sbv_gmp_ctx_end(owned);" + , " free(owned);" + , "}" + ] + +-- | Runtime helpers for exact unbounded integers. Raw low-level shift nodes +-- need additional helpers; ordinary SBV integer programs do not emit them. +integerRuntime :: Bool -> [String] +integerRuntime includeShifts = + ["static SInteger sbv_gmp_integer_const(sbv_gmp_ctx *ctx, const char *value)" + , "{ mpz_ptr r = sbv_gmp_new_integer(ctx); if (mpz_set_str(r, value, 10) != 0) abort(); return r; }" + , "" + , "static SInteger sbv_gmp_integer_from_u64(sbv_gmp_ctx *ctx, uint64_t value)" + , "{ mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_import(r, 1, -1, sizeof(value), 0, 0, &value); return r; }" + , "" + , "static SInteger sbv_gmp_integer_from_s64(sbv_gmp_ctx *ctx, int64_t value)" + , "{" + , " const uint64_t magnitude = value < 0 ? UINT64_C(0) - (uint64_t) value : (uint64_t) value;" + , " mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_import(r, 1, -1, sizeof(magnitude), 0, 0, &magnitude);" + , " if (value < 0) mpz_neg(r, r); return r;" + , "}" + , "" + , "static uint64_t sbv_gmp_integer_low_u64(SInteger value)" + , "{" + , " uint64_t result = 0; size_t count; mpz_t reduced;" + , " mpz_init(reduced); mpz_fdiv_r_2exp(reduced, value, 64);" + , " mpz_export(&result, &count, -1, sizeof(result), 0, 0, reduced); mpz_clear(reduced); return result;" + , "}" + , "" + ] + ++ concatMap integerUnary [("neg", "mpz_neg"), ("abs", "mpz_abs"), ("com", "mpz_com")] + ++ concatMap integerBinary [("add", "mpz_add"), ("sub", "mpz_sub"), ("mul", "mpz_mul"), ("and", "mpz_and"), ("or", "mpz_ior"), ("xor", "mpz_xor")] + ++ ["static SInteger sbv_gmp_integer_quot(sbv_gmp_ctx *ctx, SInteger a, SInteger b)" + , "{" + , " mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_t divisor;" + , " if (mpz_sgn(b) == 0) { mpz_set(r, a); return r; }" + , " mpz_init(divisor); mpz_abs(divisor, b); mpz_fdiv_q(r, a, divisor);" + , " if (mpz_sgn(b) < 0) mpz_neg(r, r); mpz_clear(divisor); return r;" + , "}" + , "" + , "static SInteger sbv_gmp_integer_rem(sbv_gmp_ctx *ctx, SInteger a, SInteger b)" + , "{" + , " mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_t divisor;" + , " if (mpz_sgn(b) == 0) { mpz_set(r, a); return r; }" + , " mpz_init(divisor); mpz_abs(divisor, b); mpz_fdiv_r(r, a, divisor); mpz_clear(divisor); return r;" + , "}" + , "" + , "static int sbv_gmp_integer_cmp(SInteger a, SInteger b) { return mpz_cmp(a, b); }" + , "" + , "static bool sbv_gmp_integer_divides(SInteger divisor, SInteger value)" + , "{ return mpz_sgn(divisor) != 0 && mpz_divisible_p(value, divisor) != 0; }" + , "" + , "static SInteger sbv_gmp_integer_pow(sbv_gmp_ctx *ctx, SInteger base, SInteger exponent)" + , "{" + , " mpz_ptr result = sbv_gmp_new_integer(ctx); mpz_t factor, power;" + , " if (mpz_sgn(exponent) < 0) {" + , " if (mpz_cmp_si(base, 1) == 0) mpz_set_ui(result, 1);" + , " else if (mpz_cmp_si(base, -1) == 0) mpz_set_si(result, mpz_odd_p(exponent) ? -1 : 1);" + , " else mpz_set_ui(result, 0);" + , " return result;" + , " }" + , " mpz_set_ui(result, 1); mpz_init_set(factor, base); mpz_init_set(power, exponent);" + , " while (mpz_sgn(power) != 0) {" + , " if (mpz_odd_p(power)) mpz_mul(result, result, factor);" + , " mpz_fdiv_q_2exp(power, power, 1);" + , " if (mpz_sgn(power) != 0) mpz_mul(factor, factor, factor);" + , " }" + , " mpz_clear(power); mpz_clear(factor); return result;" + , "}" + , "" + ] + ++ [line | includeShifts, line <- + [ "static SInteger sbv_gmp_integer_shift(sbv_gmp_ctx *ctx, SInteger a, SInteger amount, bool left)" + , "{" + , " mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_t magnitude; bool effective_left = left;" + , " mpz_init(magnitude); mpz_abs(magnitude, amount);" + , " if (mpz_sgn(amount) < 0) effective_left = !effective_left;" + , " if (!mpz_fits_ulong_p(magnitude)) {" + , " if (effective_left) abort();" + , " mpz_set_si(r, mpz_sgn(a) < 0 ? -1 : 0);" + , " } else if (effective_left) {" + , " mpz_mul_2exp(r, a, mpz_get_ui(magnitude));" + , " } else {" + , " mpz_fdiv_q_2exp(r, a, mpz_get_ui(magnitude));" + , " }" + , " mpz_clear(magnitude); return r;" + , "}" + , "" + , "static SInteger sbv_gmp_integer_shl(sbv_gmp_ctx *ctx, SInteger a, SInteger amount)" + , "{ return sbv_gmp_integer_shift(ctx, a, amount, true); }" + , "" + , "static SInteger sbv_gmp_integer_shr(sbv_gmp_ctx *ctx, SInteger a, SInteger amount)" + , "{ return sbv_gmp_integer_shift(ctx, a, amount, false); }" + , "" + ] + ] + where integerUnary (suffix, operation) = + ["static SInteger sbv_gmp_integer_" ++ suffix ++ "(sbv_gmp_ctx *ctx, SInteger a)" + , "{ mpz_ptr r = sbv_gmp_new_integer(ctx); " ++ operation ++ "(r, a); return r; }" + , ""] + + integerBinary (suffix, operation) = + ["static SInteger sbv_gmp_integer_" ++ suffix ++ "(sbv_gmp_ctx *ctx, SInteger a, SInteger b)" + , "{ mpz_ptr r = sbv_gmp_new_integer(ctx); " ++ operation ++ "(r, a, b); return r; }" + , ""] + +-- | Runtime helpers shared by exact reals and symbolic rationals. +realRuntime :: [String] +realRuntime = + ["static mpq_srcptr sbv_gmp_real_const(sbv_gmp_ctx *ctx, const char *value)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); if (mpq_set_str(r, value, 10) != 0) abort(); mpq_canonicalize(r); return r; }" + , "" + , "static mpq_srcptr sbv_gmp_real_from_u64(sbv_gmp_ctx *ctx, uint64_t value)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); mpz_import(mpq_numref(r), 1, -1, sizeof(value), 0, 0, &value); return r; }" + , "" + , "static mpq_srcptr sbv_gmp_real_from_s64(sbv_gmp_ctx *ctx, int64_t value)" + , "{" + , " const uint64_t magnitude = value < 0 ? UINT64_C(0) - (uint64_t) value : (uint64_t) value;" + , " mpq_ptr r = sbv_gmp_new_real(ctx); mpz_import(mpq_numref(r), 1, -1, sizeof(magnitude), 0, 0, &magnitude);" + , " if (value < 0) mpz_neg(mpq_numref(r), mpq_numref(r)); return r;" + , "}" + , "" + , "static uint64_t sbv_gmp_real_low_u64(mpq_srcptr value)" + , "{" + , " uint64_t result = 0; size_t count; mpz_t rounded, reduced;" + , " mpz_init(rounded); mpz_init(reduced); mpz_fdiv_q(rounded, mpq_numref(value), mpq_denref(value));" + , " mpz_fdiv_r_2exp(reduced, rounded, 64); mpz_export(&result, &count, -1, sizeof(result), 0, 0, reduced);" + , " mpz_clear(reduced); mpz_clear(rounded); return result;" + , "}" + , "" + ] + ++ concatMap realUnary [("neg", "mpq_neg"), ("abs", "mpq_abs")] + ++ concatMap realBinary [("add", "mpq_add"), ("sub", "mpq_sub"), ("mul", "mpq_mul")] + ++ ["static mpq_srcptr sbv_gmp_real_quot(sbv_gmp_ctx *ctx, mpq_srcptr a, mpq_srcptr b)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); if (mpq_sgn(b) == 0) mpq_set_ui(r, 0, 1); else mpq_div(r, a, b); return r; }" + , "" + , "static int sbv_gmp_real_cmp(mpq_srcptr a, mpq_srcptr b) { return mpq_cmp(a, b); }" + , "" + ] + where realUnary (suffix, operation) = + ["static mpq_srcptr sbv_gmp_real_" ++ suffix ++ "(sbv_gmp_ctx *ctx, mpq_srcptr a)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); " ++ operation ++ "(r, a); return r; }" + , ""] + + realBinary (suffix, operation) = + ["static mpq_srcptr sbv_gmp_real_" ++ suffix ++ "(sbv_gmp_ctx *ctx, mpq_srcptr a, mpq_srcptr b)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); " ++ operation ++ "(r, a, b); return r; }" + , ""] + +-- | Runtime helpers for the symbolic-rational constructor and internal +-- numerator/denominator accessors. +rationalRuntime :: CgConfig -> [String] +rationalRuntime cfg + | isExactGMPKind cfg KUnbounded = exactRuntime + | Just width <- cgInteger cfg = mappedRuntime width + | True = error "SBV->C: Cannot determine the SInteger representation used by SRational." + where exactRuntime = + ["static SRational sbv_gmp_rational_construct(sbv_gmp_ctx *ctx, mpz_srcptr numerator, mpz_srcptr denominator)" + , "{" + , " mpq_ptr r = sbv_gmp_new_real(ctx);" + , " if (mpz_sgn(denominator) == 0) { mpq_set_ui(r, 0, 1); return r; }" + , " mpz_set(mpq_numref(r), numerator); mpz_set(mpq_denref(r), denominator);" + , " if (mpz_sgn(mpq_denref(r)) < 0) { mpz_neg(mpq_numref(r), mpq_numref(r)); mpz_neg(mpq_denref(r), mpq_denref(r)); }" + , " mpq_canonicalize(r); return r;" + , "}" + , "" + , "static mpz_srcptr sbv_gmp_rational_numerator(SRational value) { return mpq_numref(value); }" + , "" + , "static mpz_srcptr sbv_gmp_rational_denominator(SRational value) { return mpq_denref(value); }" + , "" + ] + + mappedRuntime width = + ["static void sbv_gmp_rational_set_s64(mpz_ptr target, int64_t value)" + , "{" + , " const uint64_t magnitude = value < 0 ? UINT64_C(0) - (uint64_t) value : (uint64_t) value;" + , " mpz_import(target, 1, -1, sizeof(magnitude), 0, 0, &magnitude);" + , " if (value < 0) mpz_neg(target, target);" + , "}" + , "" + , "static SInteger sbv_gmp_rational_part(mpz_srcptr value)" + , "{" + , " " ++ unsignedType width ++ " bits = 0; size_t count; mpz_t reduced; SInteger result;" + , " mpz_init(reduced); mpz_fdiv_r_2exp(reduced, value, " ++ show width ++ ");" + , " mpz_export(&bits, &count, -1, sizeof(bits), 0, 0, reduced); mpz_clear(reduced);" + , " memcpy(&result, &bits, sizeof result); return result;" + , "}" + , "" + , "static SRational sbv_gmp_rational_construct(sbv_gmp_ctx *ctx, SInteger numerator, SInteger denominator)" + , "{" + , " mpq_ptr r = sbv_gmp_new_real(ctx);" + , " if (denominator == 0) { mpq_set_ui(r, 0, 1); return r; }" + , " sbv_gmp_rational_set_s64(mpq_numref(r), (int64_t) numerator);" + , " sbv_gmp_rational_set_s64(mpq_denref(r), (int64_t) denominator);" + , " if (mpz_sgn(mpq_denref(r)) < 0) { mpz_neg(mpq_numref(r), mpq_numref(r)); mpz_neg(mpq_denref(r), mpq_denref(r)); }" + , " mpq_canonicalize(r); return r;" + , "}" + , "" + , "static SInteger sbv_gmp_rational_numerator(SRational value) { return sbv_gmp_rational_part(mpq_numref(value)); }" + , "" + , "static SInteger sbv_gmp_rational_denominator(SRational value) { return sbv_gmp_rational_part(mpq_denref(value)); }" + , "" + ] + + unsignedType width = "SWord" ++ show width + +-- | Runtime helpers that convert between exact integers and GMP quotients. +crossRuntime :: [String] +crossRuntime = + ["static SInteger sbv_gmp_integer_from_real(sbv_gmp_ctx *ctx, mpq_srcptr a)" + , "{ mpz_ptr r = sbv_gmp_new_integer(ctx); mpz_fdiv_q(r, mpq_numref(a), mpq_denref(a)); return r; }" + , "" + , "static mpq_srcptr sbv_gmp_real_from_integer(sbv_gmp_ctx *ctx, SInteger a)" + , "{ mpq_ptr r = sbv_gmp_new_real(ctx); mpq_set_z(r, a); return r; }" + , "" + ] diff --git a/Data/SBV/Compilers/C/Legacy.hs b/Data/SBV/Compilers/C/Legacy.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Legacy.hs @@ -0,0 +1,21 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Legacy +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Compatibility facade for the original SBV-to-C compiler. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Legacy + ( compileToC + , compileToCLib + , compileToC' + , compileToCLib' + ) where + +import Data.SBV.Compilers.C.Legacy.Internal (compileToC, compileToC', compileToCLib, compileToCLib') diff --git a/Data/SBV/Compilers/C/Legacy/Internal.hs b/Data/SBV/Compilers/C/Legacy/Internal.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Legacy/Internal.hs @@ -0,0 +1,1095 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Legacy.Internal +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Frozen compatibility implementation of the original SBV-to-C compiler. +-- Based on the implementation before comprehensive backend work began, +-- at SBV commit @8c161542945382014976a3cb1f9c17dc6e51b270@. The initial copy +-- added Haddocks and formatting; subsequent changes are compatibility fixes, +-- not a verbatim snapshot of today's master. +----------------------------------------------------------------------------- + +{-# LANGUAGE TupleSections #-} + +{-# OPTIONS_GHC -Wall -Werror -Wno-incomplete-uni-patterns #-} + +module Data.SBV.Compilers.C.Legacy.Internal(compileToC, compileToCLib, compileToC', compileToCLib') where + +import Control.DeepSeq (rnf) +import Data.Char (isSpace) +import Data.List (nub, intercalate) +import Data.Maybe (isJust, isNothing, fromJust) +import qualified Data.Foldable as F (toList) +import qualified Data.Set as Set (member, union, unions, empty, toList, singleton, fromList) +import qualified Data.Text as T +import System.FilePath (takeBaseName, replaceExtension) +import System.Random + +import Data.SBV.Core.Symbolic (ResultInp(..), ProgInfo(..)) + +-- Work around the fact that GHC 8.4.1 started exporting <>.. Hmm.. +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (kRoundingMode) +import Data.SBV.Compilers.C.PseudoBoolean (assignPseudoBoolean) +import Data.SBV.Compilers.C.Real (mappedRealFloorWidth, mappedRealFloorCall, mappedRealFloorRuntime) +import Data.SBV.Compilers.C.Syntax (cCommentText, cStringLiteral) +import Data.SBV.Compilers.CodeGen + +import Data.SBV.Utils.PrettyNum (chex, showCFloat, showCDouble) + +import GHC.Stack + +--------------------------------------------------------------------------- +-- * 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. As a +-- result, we return whatever the code-gen function returns. Most uses should simply have @()@ as +-- the return type here, but the value can be useful if you want to chain the result of +-- one compilation act to the next. +compileToC :: Maybe FilePath -> String -> SBVCodeGen a -> IO a +compileToC mbDirName nm f = do (retVal, cfg, bundle) <- compileToC' nm f + renderCgPgmBundle mbDirName (cfg, bundle) + pure retVal + +-- | Lower level version of 'compileToC', producing a t'CgPgmBundle' +compileToC' :: String -> SBVCodeGen a -> IO (a, CgConfig, CgPgmBundle) +compileToC' nm f = do rands <- randoms <$> newStdGen + 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 a)] -> IO [a] +compileToCLib mbDirName libName comps = do (retVal, cfg, pgm) <- compileToCLib' libName comps + renderCgPgmBundle mbDirName (cfg, pgm) + pure retVal + +-- | Lower level version of 'compileToCLib', producing a t'CgPgmBundle' +compileToCLib' :: String -> [(String, SBVCodeGen a)] -> IO ([a], CgConfig, CgPgmBundle) +compileToCLib' libName comps = do resCfgBundles <- mapM (uncurry compileToC') comps + let (finalCfg, finalPgm) = mergeToLib libName [(c, b) | (_, c, b) <- resCfgBundles] + pure ([r | (r, _, _) <- resCfgBundles], finalCfg, finalPgm) + +--------------------------------------------------------------------------- +-- * Implementation +--------------------------------------------------------------------------- + +-- | Target-language marker for the legacy C compiler. +data SBVToC = SBVToC + +-- | Connect the legacy C compiler to the shared code-generation framework. +instance CgTarget SBVToC where + targetName _ = "C" + translate _ = cgen + +-- | Report an unexpected input to the legacy compiler. +die :: String -> a +die msg = error $ "SBV->C: Unexpected: " ++ msg + +-- | Report a feature unsupported by the legacy compiler. +tbd :: String -> a +tbd msg = error $ "SBV->C: Not yet supported: " ++ msg + +-- | Translate a symbolic result with the legacy C implementation. +cgen :: CgConfig -> String -> CgState -> Result -> CgPgmBundle +cgen cfg nm st sbvProg + -- we rnf the main pg and the sig to make sure any exceptions in type conversion pop-out early enough + -- this is purely cosmetic, of course.. + = rnf (render sig) `seq` rnf (render (vcat body)) `seq` result + where result = CgPgmBundle bundleKind + $ filt [ ("Makefile", (CgMakefile flags, [genMake (cgGenDriver cfg) nm nmd flags])) + , (nm ++ ".h", (CgHeader [sig], [genHeader bundleKind nm [sig] extProtos])) + , (nmd ++ ".c", (CgDriver, genDriver cfg randVals nm ins outs mbRet)) + , (nm ++ ".c", (CgSource, body)) + ] + + (body, flagsNeeded) = genCProg cfg nm sig sbvProg ins outs mbRet extDecls + + bundleKind = (cgInteger cfg, cgReal cfg) + + randVals = cgDriverVals cfg + + filt xs = [c | c@(_, (k, _)) <- xs, need k] + where need k | isCgDriver k = cgGenDriver cfg + | isCgMakefile k = cgGenMakefile cfg + | True = True + + 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" + extProtos = case cgPrototypes st of + [] -> empty + xs -> vcat $ text "/* User given prototypes: */" : map text xs + extDecls = case cgDecls st of + [] -> empty + xs -> vcat $ text "/* User given declarations: */" : map text xs + flags = flagsNeeded ++ cgLDFlags st + +-- | 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 SV -> Doc +pprCFunHeader fn ins outs mbRet = retType <+> text fn P.<> parens (fsep (punctuate comma (map mkParam ins ++ map mkPParam outs))) + where retType = case mbRet of + Nothing -> text "void" + Just sv -> pprCWord False sv + +-- | Render legacy C input and output parameters, respectively. +mkParam, mkPParam :: (String, CgVal) -> Doc +mkParam (n, CgAtomic sv) = pprCWord True sv <+> text n +mkParam (_, CgArray []) = die "mkParam: CgArray with no elements!" +mkParam (n, CgArray (sv:_)) = pprCWord True sv <+> text "*" P.<> text n +mkPParam (n, CgAtomic sv) = pprCWord False sv <+> text "*" P.<> text n +mkPParam (_, CgArray []) = die "mPkParam: CgArray with no elements!" +mkPParam (n, CgArray (sv:_)) = pprCWord False sv <+> text "*" P.<> text n + +-- | Renders as "const SWord8 s0", etc. the first parameter is the width of the typefield +declSV :: Int -> SV -> Doc +declSV w sv = text "const" <+> pad (showCType sv) <+> text (show sv) + where pad s = text $ s ++ replicate (w - length s) ' ' + +-- | Return the proper declaration and the result as a pair. No consts +declSVNoConst :: Int -> SV -> (Doc, Doc) +declSVNoConst w sv = (text " " <+> pad (showCType sv), text (show sv)) + where pad s = text $ s ++ replicate (w - length s) ' ' + +-- | Renders as "s0", etc, or the corresponding constant +showSV :: CgConfig -> [(SV, CV)] -> SV -> Doc +showSV cfg consts sv + | sv == falseSV = text "false" + | sv == trueSV = text "true" + | Just cv <- sv `lookup` consts = mkConst cfg cv + | True = text $ show sv + +-- | Words as it would map to a C word +pprCWord :: HasKind a => Bool -> a -> Doc +pprCWord cnst v = (if cnst then text "const" else empty) <+> text (showCType v) + +-- | Almost a "show", but map "SWord1" to "SBool" +-- which is used for extracting one-bit words. This is OK since C's bool type +-- handles arithmetic fine, and maps nicely to our `SWord 1`. (Same isn't true for `SInt 1`, which +-- doesn't have an easy counter-part on the C side. +showCType :: HasKind a => a -> String +showCType i = case kindOf i of + KBounded False 1 -> "SBool" + k -> show k + +-- | The printf specifier for the type +specifier :: CgConfig -> SV -> Doc +specifier cfg sv = case kindOf sv of + KVar{} -> die $ "variable sort: " ++ show (kindOf sv) + KBool -> spec (False, 1) + KBounded b i -> spec (b, i) + KUnbounded -> spec (True, fromJust (cgInteger cfg)) + KReal -> specF (fromJust (cgReal cfg)) + KFloat -> specF CgFloat + KDouble -> specF CgDouble + KString -> text "%s" + KChar -> text "%c" + KRational -> die "rational sort" + KFP{} -> die "arbitrary float sort" + KList k -> die $ "list sort: " ++ show k + KSet k -> die $ "set sort: " ++ show k + KApp s _ -> die $ "ADT app: " ++ s + KADT s _ _ -> die $ "ADT: " ++ s + KTuple k -> die $ "tuple sort: " ++ show k + KArray k1 k2 -> die $ "array sort: " ++ show (k1, k2) + where u8InHex = cgShowU8InHex cfg + + spec :: (Bool, Int) -> Doc + spec (False, 1) = text "%d" + spec (False, 8) + | u8InHex = text "0x%02\"PRIx8\"" + | True = text "%\"PRIu8\"" + spec (True, 8) = text "%\"PRId8\"" + spec (False, 16) = text "0x%04\"PRIx16\"U" + spec (True, 16) = text "%\"PRId16\"" + spec (False, 32) = text "0x%08\"PRIx32\"UL" + spec (True, 32) = text "%\"PRId32\"L" + spec (False, 64) = text "0x%016\"PRIx64\"ULL" + spec (True, 64) = text "%\"PRId64\"LL" + spec (s, sz) = die $ "Format specifier at type " ++ (if s then "SInt" else "SWord") ++ show sz + + specF :: CgSRealType -> Doc + specF CgFloat = text "%a" + specF CgDouble = text "%a" + specF CgLongDouble = text "%Lf" + +-- | 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 use decimal for values 8-bits or less, +-- and hex otherwise. +mkConst :: CgConfig -> CV -> Doc +mkConst cfg (CV KReal (CAlgReal (AlgRational _ r))) = double (fromRational r :: Double) P.<> sRealSuffix (fromJust (cgReal cfg)) + where sRealSuffix CgFloat = text "F" + sRealSuffix CgDouble = empty + sRealSuffix CgLongDouble = text "L" +mkConst cfg (CV KUnbounded (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (True, fromJust (cgInteger cfg)) +mkConst cfg (CV (KBounded sg sz) (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (sg, sz) +mkConst cfg (CV KBool (CInteger i)) = showSizedConst (cgShowU8InHex cfg) i (False, 1) +mkConst _ (CV KFloat (CFloat f)) = text $ showCFloat f +mkConst _ (CV KDouble (CDouble d)) = text $ showCDouble d +mkConst _ (CV KString (CString s)) = text $ show s +mkConst _ (CV KChar (CChar c)) = text $ show c +mkConst _ cv = die $ "mkConst: " ++ show cv + +-- | Render an integral constant using one of the legacy native C widths. +showSizedConst :: Bool -> Integer -> (Bool, Int) -> Doc +showSizedConst _ i (False, 1) = text (if i == 0 then "false" else "true") +showSizedConst u8h i t@(False, 8) + | u8h = text $ T.unpack (chex False True t i) + | True = integer i +showSizedConst _ i (True, 8) = integer i +showSizedConst _ i t@(False, 16) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 16) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(False, 32) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 32) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(False, 64) = text $ T.unpack $ chex False True t i +showSizedConst _ i t@(True, 64) = text $ T.unpack $ chex False True t i +showSizedConst _ i (s, sz) = die $ "Constant " ++ show i ++ " at type " ++ (if s then "SInt" else "SWord") ++ show sz + +-- | Generate a makefile. The first argument is True if we have a driver. +genMake :: Bool -> String -> String -> [String] -> Doc +genMake ifdr fn dn ldFlags = foldr1 ($$) [l | (True, l) <- lns] + where ifld = not (null ldFlags) + ld | ifld = text "${LDFLAGS}" + | True = empty + lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") + , (True, text "") + , (True, text "# include any user-defined .mk file in the current directory.") + , (True, text "-include *.mk") + , (True, text "") + , (True, text "CC?=gcc") + , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") + , (ifld, text "LDFLAGS?=" P.<> text (unwords ldFlags)) + , (True, text "") + , (ifdr, text "all:" <+> nmd) + , (ifdr, text "") + , (True, nmo P.<> text (": " ++ ppSameLine (hsep [nmc, nmh]))) + , (True, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") + , (True, text "") + , (ifdr, nmdo P.<> text (": " ++ ppSameLine (hsep [nmdc, nmh]))) + , (ifdr, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") + , (ifdr, text "") + , (ifdr, nmd P.<> text (": " ++ ppSameLine (hsep [nmo, nmdo]))) + , (ifdr, text "\t${CC} ${CCFLAGS}" <+> text "$^ -o $@" <+> ld) + , (ifdr, text "") + , (True, text "clean:") + , (True, text "\trm -f *.o") + , (True, text "") + , (ifdr, text "veryclean: clean") + , (ifdr, text "\trm -f" <+> nmd) + , (ifdr, text "") + ] + nm = text fn + nmd = text dn + nmh = nm P.<> text ".h" + nmc = nm P.<> text ".c" + nmo = nm P.<> text ".o" + nmdc = nmd P.<> text ".c" + nmdo = nmd P.<> text ".o" + +-- | Generate the header +genHeader :: (Maybe Int, Maybe CgSRealType) -> String -> [Doc] -> Doc -> Doc +genHeader (ik, rk) fn sigs protos = + text "/* Header file for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit! */" + $$ text "" + $$ text "#ifndef" <+> tag + $$ text "#define" <+> tag + $$ text "" + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "#include " + $$ text "" + $$ text "/* The boolean type */" + $$ text "typedef bool SBool;" + $$ text "" + $$ text "/* The float type */" + $$ text "typedef float SFloat;" + $$ text "" + $$ text "/* The double type */" + $$ text "typedef double SDouble;" + $$ text "" + $$ text "/* Unsigned bit-vectors */" + $$ 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 "" + $$ imapping + $$ rmapping + $$ text ("/* Entry point prototype" ++ plu ++ ": */") + $$ vcat (map (P.<> semi) sigs) + $$ text "" + $$ protos + $$ text "#endif /*" <+> tag <+> text "*/" + $$ text "" + where nm = text fn + tag = text "__" P.<> nm P.<> text "__HEADER_INCLUDED__" + plu = if length sigs /= 1 then "s" else "" + imapping = case ik of + Nothing -> empty + Just i -> text "/* User requested mapping for SInteger. */" + $$ text "/* NB. Loss of precision: Target type is subject to modular arithmetic. */" + $$ text ("typedef SInt" ++ show i ++ " SInteger;") + $$ text "" + rmapping = case rk of + Nothing -> empty + Just t -> text "/* User requested mapping for SReal. */" + $$ text "/* NB. Loss of precision: Target type is subject to rounding. */" + $$ text ("typedef " ++ show t ++ " SReal;") + $$ text "" + +-- | Emit a blank separator line when requested. +sepIf :: Bool -> Doc +sepIf b = if b then text "" else empty + +-- | Generate an example driver program +genDriver :: CgConfig -> [Integer] -> String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> [Doc] +genDriver cfg randVals fn inps outs mbRet = [pre, header, body, post] + where pre = text "/* Example driver program for" <+> nm P.<> text ". */" + $$ text "/* Automatically generated by SBV. Edit as you see fit! */" + $$ text "" + $$ text "#include " + header = text "#include" <+> doubleQuotes (nm P.<> 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 sv -> text "printf" P.<> parens (printQuotes (fcall <+> text "=" <+> specifier cfg sv P.<> text "\\n") + P.<> comma <+> resultVar) P.<> semi + Nothing -> text "printf" P.<> parens (printQuotes (fcall <+> text "->\\n")) P.<> semi) + $$ vcat (map display outs) + ) + post = text "" + $+$ nest 2 (text "return 0" P.<> semi) + $$ text "}" + $$ text "" + nm = text fn + pairedInputs = matchRands randVals inps + matchRands _ [] = [] + matchRands [] _ = die "Run out of driver values!" + matchRands (r:rs) ((n, CgAtomic sv) : cs) = ([mkRVal sv r], n, CgAtomic sv) : matchRands rs cs + matchRands _ ((n, CgArray []) : _ ) = die $ "Unsupported empty array input " ++ show n + matchRands rs ((n, a@(CgArray sws@(sv:_))) : cs) + | length frs /= l = die "Run out of driver values!" + | True = (map (mkRVal sv) frs, n, a) : matchRands srs cs + where l = length sws + (frs, srs) = splitAt l rs + mkRVal sv r = mkConst cfg $ mkConstCV (kindOf sv) r + mkInp (_, _, CgAtomic{}) = empty -- constant, no need to declare + mkInp (_, n, CgArray []) = die $ "Unsupported empty array value for " ++ show n + mkInp (vs, n, CgArray sws@(sv:_)) = pprCWord True sv <+> text n P.<> brackets (int (length sws)) <+> text "= {" + $$ nest 4 (fsep (punctuate comma (align vs))) + $$ text "};" + $$ text "" + $$ text "printf" P.<> parens (printQuotes (text "Contents of input array" <+> text n P.<> text ":\\n")) P.<> semi + $$ display (n, CgArray sws) + $$ text "" + mkOut (v, CgAtomic sv) = pprCWord False sv <+> text v P.<> semi + mkOut (v, CgArray []) = die $ "Unsupported empty array value for " ++ show v + mkOut (v, CgArray sws@(sv:_)) = pprCWord False sv <+> text v P.<> brackets (int (length sws)) P.<> semi + resultVar = text "__result" + call = case mbRet of + Nothing -> fcall P.<> semi + Just sv -> pprCWord True sv <+> resultVar <+> text "=" <+> fcall P.<> semi + fcall = nm P.<> 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 "&" P.<> text n + mkOVal (n, CgArray{}) = text n + display (n, CgAtomic sv) = text "printf" P.<> parens (printQuotes (text " " <+> text n <+> text "=" <+> specifier cfg sv + P.<> text "\\n") P.<> comma <+> text n) P.<> semi + display (n, CgArray []) = die $ "Unsupported empty array value for " ++ show n + display (n, CgArray sws@(sv:_)) = text "int" <+> nctr P.<> semi + $$ text "for(" P.<> nctr <+> text "= 0;" <+> nctr <+> text "<" <+> int len <+> text "; ++" P.<> nctr P.<> text ")" + $$ nest 2 (text "printf" P.<> parens (printQuotes (text " " <+> entrySpec <+> text "=" <+> spec P.<> text "\\n") + P.<> comma <+> nctr <+> comma P.<> entry) P.<> semi) + where nctr = text n P.<> text "_ctr" + entry = text n P.<> text "[" P.<> nctr P.<> text "]" + entrySpec = text n P.<> text "[%" P.<> int tab P.<> text "d]" + spec = specifier cfg sv + len = length sws + tab = length $ show (len - 1) + +-- | Generate the C program +genCProg :: CgConfig -> String -> Doc -> Result -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SV -> Doc -> ([Doc], [String]) +genCProg cfg fn proto (Result pinfo kindInfo _tvals _ovals cgs topInps (_, preConsts) tbls _uis axioms (SBVPgm asgns) cstrs origAsserts _) inVars outVars mbRet extDecls + | isNothing (cgInteger cfg) && KUnbounded `Set.member` kindInfo + = error $ "SBV->C: Unbounded integers are not supported by the C compiler." + ++ "\nUse 'cgIntegerSize' to specify a fixed size for SInteger representation." + | KString `Set.member` kindInfo + = notyet "Strings" + | KChar `Set.member` kindInfo + = notyet "Characters" + | any isSet kindInfo + = notyet "Sets (SSet)" + | any isList kindInfo + = notyet "Lists (SList)" + | any isTuple kindInfo + = notyet "Tuples (STupleN)" + | isNothing (cgReal cfg) && KReal `Set.member` kindInfo + = error $ "SBV->C: SReal values are not supported by the C compiler." + ++ "\nUse 'cgSRealType' to specify a custom type for SReal representation." + | not (null unsupportedBVs) + = error $ "SBV->C: Unsupported bit-vector type(s): " ++ intercalate ", " (map show unsupportedBVs) + | not (null usorts) + = error $ "SBV->C: Cannot compile functions with uninterpreted sorts: " ++ intercalate ", " usorts + | hasQuants pinfo + = error "SBV->C: Cannot compile in the presence of quantified variables." + | not $ null (progSpecialRels pinfo) + = error "SBV->C: Cannot compile in the presence of special relations." + | not (null axioms) + = error "SBV->C: Cannot compile in the presence of 'smtFunction' definitions, use 'compileToCLib' instead." + | not (null cstrs) + = tbd "Explicit constraints" + | True + = ([pre, header, post], flagsNeeded) + where notyet m = error $ "SBV->C: " ++ m ++ " are currently not supported by the C compiler. Please get in touch if you'd like support for this feature!" + + asserts | cgIgnoreAsserts cfg = [] + | True = origAsserts + + usorts = [s | k@(KADT s _ _) <- Set.toList kindInfo, isADT k && not (isRoundingMode k)] -- No support for any sorts other than RoundingMode! + + pre = text "/* File:" <+> doubleQuotes (nm P.<> text ".c") P.<> text ". Automatically generated by SBV. Do not edit! */" + $$ text "" + + header = text "#include" <+> doubleQuotes (nm P.<> text ".h") + + unsupportedBVs = [k | k@(KBounded sg sz) <- Set.toList kindInfo, (not . supported) (sg, sz)] + where supported (False, sz) = sz `elem` [1, 8, 16, 32, 64] + supported (True, sz) = sz `elem` [ 8, 16, 32, 64] + + post = text "" + $$ vcat (map codeSeg cgs) + $$ extDecls + $$ mappedRealFloorRuntime cfg assignments + $$ proto + $$ text "{" + $$ text "" + $$ nest 2 ( vcat (concatMap (genIO True . (\v -> (isAlive v, v))) inVars) + $$ vcat (merge (map genTbl tbls) (map genAsgn assignments) (map genAssert asserts)) + $$ sepIf (not (null assignments) || not (null tbls)) + $$ vcat (concatMap (genIO False . (True,)) outVars) + $$ maybe empty mkRet mbRet + ) + $$ text "}" + $$ text "" + + nm = text fn + + assignments = F.toList asgns + + -- Do we need any linker flags for C? + flagsNeeded = nub $ concatMap (getLDFlag . opRes) assignments + where opRes (sv, SBVApp o _) = (o, kindOf sv) + + codeSeg (fnm, ls) = text "/* User specified custom code for" <+> doubleQuotes (text fnm) <+> text "*/" + $$ vcat (map text ls) + $$ text "" + + ins = case topInps of + ResultTopInps (is, []) -> is + ResultTopInps is -> die $ "Unexpected trackers: " ++ show is + ResultLamInps is -> die $ "Unexpected inputs : " ++ show is + + typeWidth = getMax 0 $ [len (kindOf s) | (s, _) <- assignments] ++ [len (kindOf s) | NamedSymVar s _ <- ins] + where len (KVar s) = die $ "Variable: " ++ s + len KReal{} = 5 + len KFloat{} = 6 -- SFloat + len KDouble{} = 7 -- SDouble + len KString{} = 7 -- SString + len KChar{} = 5 -- SChar + len KUnbounded{} = 8 + len KBool = 5 -- SBool + len (KBounded False n) = 5 + length (show n) -- SWordN + len (KBounded True n) = 4 + length (show n) -- SIntN + len KRational{} = die "Rational." + len KFP{} = die "Arbitrary float." + len (KList s) = die $ "List sort: " ++ show s + len (KSet s) = die $ "Set sort: " ++ show s + len (KTuple s) = die $ "Tuple sort: " ++ show s + len (KArray k1 k2) = die $ "Array sort: " ++ show (k1, k2) + len (KApp s _) = die $ "Uninterpreted ADT app: " ++ s + len (KADT s _ _) = die $ "Uninterpreted ADT: " ++ s + + getMax 8 _ = 8 -- 8 is the max we can get with SInteger, so don't bother looking any further + getMax m [] = m + getMax m (x:xs) = getMax (m `max` x) xs + + consts = (falseSV, falseCV) : (trueSV, trueCV) : preConsts + + isConst s = isJust (lookup s consts) + + -- TODO: The following is brittle. We should really have a function elsewhere + -- that walks the SBVExprs and collects the SWs together. + usedVariables = Set.unions (retSWs : map usedCgVal outVars ++ map usedAsgn assignments) + where retSWs = maybe Set.empty Set.singleton mbRet + + usedCgVal (_, CgAtomic s) = Set.singleton s + usedCgVal (_, CgArray ss) = Set.fromList ss + usedAsgn (_, SBVApp o ss) = Set.union (opSWs o) (Set.fromList ss) + + opSWs (LkUp _ a b) = Set.fromList [a, b] + opSWs (IEEEFP (FP_Cast _ _ s)) = Set.singleton s + opSWs _ = Set.empty + + isAlive :: (String, CgVal) -> Bool + isAlive (_, CgAtomic sv) = sv `Set.member` usedVariables + isAlive (_, _) = True + + genIO :: Bool -> (Bool, (String, CgVal)) -> [Doc] + genIO True (alive, (cNm, CgAtomic sv)) = [declSV typeWidth sv <+> text "=" <+> text cNm P.<> semi | alive] + genIO False (alive, (cNm, CgAtomic sv)) = [text "*" P.<> text cNm <+> text "=" <+> showSV cfg consts sv P.<> semi | alive] + genIO isInp (_, (cNm, CgArray sws)) = zipWith genElt sws [(0::Int)..] + where genElt sv i + | isInp = declSV typeWidth sv <+> text "=" <+> text entry P.<> semi + | True = text entry <+> text "=" <+> showSV cfg consts sv P.<> semi + where entry = cNm ++ "[" ++ show i ++ "]" + + mkRet sv = text "return" <+> showSV cfg consts sv P.<> semi + + genTbl :: ((Int, Kind, Kind), [SV]) -> (Int, Doc) + genTbl ((i, _, k), elts) = (location, static <+> text "const" <+> text (show k) <+> text ("table" ++ show i) P.<> text "[] = {" + $$ nest 4 (fsep (punctuate comma (align (map (showSV cfg consts) elts)))) + $$ text "};") + where static = if location == -1 then text "static" else empty + location = maximum (-1 : map getNodeId elts) + + getNodeId s@(SV _ (NodeId (_, _, n))) | isConst s = -1 + | True = n + + genAsgn :: (SV, SBVExpr) -> (Int, Doc) + genAsgn (sv, n) = (getNodeId sv, ppExpr cfg consts n (declSV typeWidth sv) (declSVNoConst typeWidth sv) P.<> semi) + + -- merge tables intermixed with assignments and assertions, paying attention to putting tables as + -- early as possible and tables right after.. Note that the assignment list (second argument) is sorted on its order + merge :: [(Int, Doc)] -> [(Int, Doc)] -> [(Int, Doc)] -> [Doc] + merge tables asgnments asrts = map snd $ merge2 asrts (merge2 tables asgnments) + where merge2 [] as = as + merge2 ts [] = ts + merge2 ts@((i, t):trest) as@((i', a):arest) + | i < i' = (i, t) : merge2 trest as + | True = (i', a) : merge2 ts arest + + genAssert (msg, cs, sv) = (getNodeId sv, doc) + where doc = text "/* ASSERTION:" <+> cCommentText msg + $$ maybe empty (vcat . map cCommentText) (locInfo (getCallStack <$> cs)) + $$ text " */" + $$ text "if" P.<> parens (showSV cfg consts sv) + $$ text "{" + $+$ nest 2 (vcat [errOut, text "exit(-1);"]) + $$ text "}" + $$ text "" + errOut = text "fprintf(stderr, \"%s:%d:ASSERTION FAILED: %s\\n\", __FILE__, __LINE__," + <+> cStringLiteral msg P.<> text ");" + locInfo (Just ps) = let loc (f, sl) = concat [srcLocFile sl, ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f ] + in case map loc ps of + [] -> Nothing + (f:rs) -> Just $ (" * SOURCE : " ++ f) : map (" * " ++) rs + locInfo _ = Nothing + +-- | Render a native floating-point operation with the legacy lowering. +handleIEEE :: FPOp -> [(SV, CV)] -> [(SV, Doc)] -> Doc -> Doc +handleIEEE w consts as var = cvt w + where same f = (f, f) + named fnm dnm f = (f fnm, f dnm) + + cvt (FP_Cast from to m) = case checkRM (m `lookup` consts) of + Nothing -> cast $ \[a] -> parens (text (show to)) <+> rnd a + Just (Left msg) -> die msg + Just (Right msg) -> tbd msg + where -- if we're converting from float to some integral like; first use rint/rintf to do the internal conversion and then cast. + rnd a + | (isFloat from || isDouble from) && (isBounded to || isUnbounded to) + = let f = if isFloat from then "rintf" else "rint" + in text f P.<> parens a + | True + = a + + cvt (FP_Reinterpret f t) = case (f, t) of + (KBounded False 32, KFloat) -> cast $ cpy "sizeof(SFloat)" + (KBounded False 64, KDouble) -> cast $ cpy "sizeof(SDouble)" + (KFloat, KBounded False 32) -> cast $ cpy "sizeof(SWord32)" + (KDouble, KBounded False 64) -> cast $ cpy "sizeof(SWord64)" + _ -> die $ "Reinterpretation from : " ++ show f ++ " to " ++ show t + where cpy sz = \[a] -> let alhs = text "&" P.<> var + arhs = text "&" P.<> a + in text "memcpy" P.<> parens (fsep (punctuate comma [alhs, arhs, text sz])) + cvt FP_Abs = dispatch $ named "fabsf" "fabs" $ \nm _ [a] -> text nm P.<> parens a + cvt FP_Neg = dispatch $ same $ \_ [a] -> text "-" P.<> a + cvt FP_Add = dispatch $ same $ \_ [a, b] -> a <+> text "+" <+> b + cvt FP_Sub = dispatch $ same $ \_ [a, b] -> a <+> text "-" <+> b + cvt FP_Mul = dispatch $ same $ \_ [a, b] -> a <+> text "*" <+> b + cvt FP_Div = dispatch $ same $ \_ [a, b] -> a <+> text "/" <+> b + cvt FP_FMA = dispatch $ named "fmaf" "fma" $ \nm _ [a, b, c] -> text nm P.<> parens (fsep (punctuate comma [a, b, c])) + cvt FP_Sqrt = dispatch $ named "sqrtf" "sqrt" $ \nm _ [a] -> text nm P.<> parens a + cvt FP_Rem = dispatch $ named "fmodf" "fmod" $ \nm _ [a, b] -> text nm P.<> parens (fsep (punctuate comma [a, b])) + cvt FP_RoundToIntegral = dispatch $ named "rintf" "rint" $ \nm _ [a] -> text nm P.<> parens a + cvt FP_Min = dispatch $ named "fminf" "fmin" $ \nm k [a, b] -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) + cvt FP_Max = dispatch $ named "fmaxf" "fmax" $ \nm k [a, b] -> wrapMinMax k a b (text nm P.<> parens (fsep (punctuate comma [a, b]))) + cvt FP_ObjEqual = let mkIte x y z = x <+> text "?" <+> y <+> text ":" <+> z + chkNaN x = text "isnan" P.<> parens x + signbit x = text "signbit" P.<> parens x + eq x y = parens (x <+> text "==" <+> y) + eqZero x = eq x (text "0") + negZero x = parens (signbit x <+> text "&&" <+> eqZero x) + in dispatch $ same $ \_ [a, b] -> mkIte (chkNaN a) (chkNaN b) (mkIte (negZero a) (negZero b) (mkIte (negZero b) (negZero a) (eq a b))) + cvt FP_IsNormal = dispatch $ same $ \_ [a] -> text "isnormal" P.<> parens a + cvt FP_IsSubnormal = dispatch $ same $ \_ [a] -> text "FP_SUBNORMAL == fpclassify" P.<> parens a + cvt FP_IsZero = dispatch $ same $ \_ [a] -> text "FP_ZERO == fpclassify" P.<> parens a + cvt FP_IsInfinite = dispatch $ same $ \_ [a] -> text "isinf" P.<> parens a + cvt FP_IsNaN = dispatch $ same $ \_ [a] -> text "isnan" P.<> parens a + cvt FP_IsNegative = dispatch $ same $ \_ [a] -> text "!isnan" P.<> parens a <+> text "&&" <+> text "signbit" P.<> parens a + cvt FP_IsPositive = dispatch $ same $ \_ [a] -> text "!isnan" P.<> parens a <+> text "&&" <+> text "!signbit" P.<> parens a + + -- grab the rounding-mode, if present, and make sure it's RoundNearestTiesToEven. Otherwise skip. + fpArgs = case as of + [] -> [] + ((m, _):args) + | isRoundingMode m -> case checkRM (m `lookup` consts) of + Nothing -> args + Just (Left msg) -> die msg + Just (Right msg) -> tbd msg + | True -> as + + -- Check that the RM is RoundNearestTiesToEven. + -- If we start supporting other rounding-modes, this would be the point where we'd insert the rounding-mode set/reset code + -- instead of merely returning OK or not + checkRM (Just cv@(CV k v)) + | k == kRoundingMode = case v of + CADT ("RoundNearestTiesToEven", []) -> Nothing + CADT (s, []) -> Just (Right $ "handleIEEE: Unsupported rounding-mode: " ++ show s ++ " for: " ++ show w) + _ -> Just (Left $ "handleIEEE: Unexpected value for rounding-mode: " ++ show cv ++ " for: " ++ show w) + checkRM (Just cv) = Just (Left $ "handleIEEE: Expected rounding-mode, but got: " ++ show cv ++ " for: " ++ show w) + checkRM Nothing = Just (Right $ "handleIEEE: Non-constant rounding-mode for: " ++ show w) + + pickOp _ [] = die $ "Cannot determine float/double kind for op: " ++ show w + pickOp (fOp, dOp) args@((a,_):_) = case kindOf a of + KFloat -> fOp KFloat (map snd args) + KDouble -> dOp KDouble (map snd args) + k -> die $ "handleIEEE: Expected double/float args, but got: " ++ show k ++ " for: " ++ show w + + dispatch (fOp, dOp) = pickOp (fOp, dOp) fpArgs + cast f = f (map snd fpArgs) + + -- In SMT-Lib, fpMin/fpMax is underspecified when given +0/-0 as the two arguments. (In any order.) + -- In C, the second argument is returned. (I think, might depend on the architecture, optimizations etc.). + -- We'll translate it so that we deterministically return +0. + -- There's really no good choice here. + wrapMinMax k a b s = parens cond <+> text "?" <+> fzero <+> text ":" <+> s + where fzero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 + cond = parens (text "FP_ZERO == fpclassify" P.<> parens a) -- a is zero + <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" P.<> parens b) -- b is zero + <+> text "&&" <+> parens (text "signbit" P.<> parens a <+> text "!=" <+> text "signbit" P.<> parens b) -- a and b differ in sign + +-- | Render one symbolic assignment with the legacy operation dispatcher. +ppExpr :: CgConfig -> [(SV, CV)] -> SBVExpr -> Doc -> (Doc, Doc) -> Doc +ppExpr cfg consts (SBVApp op opArgs) lhs (typ, var) + | doNotAssign op + = typ <+> var P.<> semi <+> rhs + | True + = lhs <+> text "=" <+> rhs + where doNotAssign (IEEEFP FP_Reinterpret{}) = True -- generates a memcpy instead; no simple assignment + doNotAssign PseudoBoolean{} = True -- assigns through an overflow-safe reduction + doNotAssign _ = False -- generates simple assignment + + rhs = p op (map (showSV cfg consts) opArgs) + + rtc = cgRTC cfg + + cBinOps = [ (Plus, "+"), (Times, "*"), (Minus, "-") + , (Equal False, "==") -- no strong equality! + , (NotEqual, "!="), (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=") + , (And, "&"), (Or, "|"), (XOr, "^") + ] + + -- see if we can find a constant shift; makes the output way more readable + getShiftAmnt def [_, sv] = case sv `lookup` consts of + Just (CV _ (CInteger i)) -> integer i + _ -> def + getShiftAmnt def _ = def + + hd _ (h:_) = h + hd w [] = error $ "Data.SBV.C.ppExpr: Impossible happened: " ++ w ++ ", received empty list!" + + p :: Op -> [Doc] -> Doc + p ReadArray{} _ = tbd "User specified arrays (ReadArray)" + p WriteArray{} _ = tbd "User specified arrays (WriteArray)" + p (Label s) [a] = a <+> text "/*" <+> cCommentText s <+> text "*/" + p (IEEEFP w) as = handleIEEE w consts (zip opArgs as) var + p (PseudoBoolean pb) as = assignPseudoBoolean pb as var + p (OverflowOp o) _ = tbd $ "Overflow operations" ++ show o + p castOp@KindCast{} [a] + | Just width <- mappedRealFloorWidth cfg castOp + = mappedRealFloorCall width a + p (KindCast _ to) [a] = parens (text (show to)) <+> a + p (Uninterpreted s) [] = text "/* Uninterpreted constant */" <+> text (T.unpack s) + p (Uninterpreted s) as = text "/* Uninterpreted function */" <+> text (T.unpack s) P.<> parens (fsep (punctuate comma as)) + p (Extract i j) [a] = extract i j (hd "Extract" opArgs) a + p Join [a, b] = join (let (s1 : s2 : _) = opArgs in (s1, s2, a, b)) + p (Rol i) [a] = rotate True i a (hd "Rol" opArgs) + p (Ror i) [a] = rotate False i a (hd "Ror" opArgs) + p Shl [a, i] = shift True (getShiftAmnt i opArgs) a -- The order of i/a being reversed here is + p Shr [a, i] = shift False (getShiftAmnt i opArgs) a -- intentional and historical (from the days when Shl/Shr had a constant parameter.) + p Not [a] = case kindOf (hd "Not" opArgs) of + -- be careful about booleans, bitwise complement is not correct for them! + KBool -> text "!" P.<> a + _ -> text "~" P.<> a + p Ite [a, b, c] = a <+> text "?" <+> b <+> text ":" <+> c + p (LkUp (t, k, _, 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 (showSV cfg consts) [ind, def] + + lkUp = text "table" P.<> int t P.<> brackets (showSV cfg consts ind) + cndLkUp cnd = cnd <+> text "?" <+> defVal <+> text ":" <+> lkUp + + checkLeft = index <+> text "< 0" + checkRight = index <+> text ">=" <+> int len + checkBoth = parens (checkLeft <+> text "||" <+> checkRight) + + canOverflow True sz = (2::Integer)^(sz-1)-1 >= fromIntegral len + canOverflow False sz = (2::Integer)^sz -1 >= fromIntegral len + + (needsCheckL, needsCheckR) = case k of + KVar{} -> die $ "array index with variable: " ++ show k + KBool -> (False, canOverflow False (1::Int)) + KBounded sg sz -> (sg, canOverflow sg sz) + KReal -> die "array index with real value" + KFloat -> die "array index with float value" + KDouble -> die "array index with double value" + KFP{} -> die "array index with arbitrary float value" + KRational -> die "array index with rational value" + KString -> die "array index with string value" + KChar -> die "array index with character value" + KUnbounded -> case cgInteger cfg of + Nothing -> (True, True) -- won't matter, it'll be rejected later + Just i -> (True, canOverflow True i) + KList s -> die $ "List sort " ++ show s + KSet s -> die $ "Set sort " ++ show s + KTuple s -> die $ "Tuple sort " ++ show s + KArray k1 k2 -> die $ "Array sort " ++ show (k1, k2) + KApp s _ -> die $ "ADT app: " ++ s + KADT s _ _ -> die $ "ADT: " ++ s + + -- Div/Rem should be careful on 0, in the SBV world x `div` 0 is 0, x `rem` 0 is x + -- NB: Quot is supposed to truncate toward 0; Not clear to me if C guarantees this behavior. + -- Brief googling suggests C99 does indeed truncate toward 0, but other C compilers might differ. + p Quot [a, b] = let k = kindOf (hd "Quot" opArgs) + z = mkConst cfg $ mkConstCV k (0::Integer) + in protectDiv0 k "/" z a b + p Rem [a, b] = protectDiv0 (kindOf (hd "Rem" opArgs)) "%" a a b + p UNeg [a] = parens (text "-" <+> a) + p Abs [a] = let f KFloat = text "fabsf" P.<> parens a + f KDouble = text "fabs" P.<> parens a + f (KBounded False _) = text "/* unsigned, skipping call to abs */" <+> a + f (KBounded True 32) = text "labs" P.<> parens a + f (KBounded True 64) = text "llabs" P.<> parens a + f KUnbounded = case cgInteger cfg of + Nothing -> f $ KBounded True 32 -- won't matter, it'll be rejected later + Just i -> f $ KBounded True i + f KReal = case cgReal cfg of + Nothing -> f KDouble -- won't matter, it'll be rejected later + Just CgFloat -> f KFloat + Just CgDouble -> f KDouble + Just CgLongDouble -> text "fabsl" P.<> parens a + f _ = text "abs" P.<> parens a + in f (kindOf (hd "Abs" opArgs)) + -- for And/Or, translate to boolean versions if on boolean kind + p And [a, b] | kindOf (hd "And" opArgs) == KBool = a <+> text "&&" <+> b + p Or [a, b] | kindOf (hd "Or" opArgs) == KBool = a <+> text "||" <+> b + p o [a, b] + | Just co <- lookup o cBinOps + = a <+> text co <+> b + + p Implies [a, b] | kindOf (hd "Implies" opArgs) == KBool = parens (text "!" P.<> a <+> text "||" <+> b) + + p NotEqual xs = mkDistinct xs + p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args + + -- generate a pairwise inequality check + mkDistinct args = fsep $ andAll $ walk args + where walk [] = [] + walk (e:es) = map (pair e) es ++ walk es + + pair e1 e2 = parens (e1 <+> text "!=" <+> e2) + + -- like punctuate, but more spacing + andAll [] = [] + andAll (d:ds) = go d ds + where go d' [] = [d'] + go d' (e:es) = (d' <+> text "&&") : go e es + + -- Div0 needs to protect, but only when the arguments are not float/double. (Div by 0 for those are well defined to be Inf/NaN etc.) + protectDiv0 k divOp def a b = case k of + KFloat -> res + KDouble -> res + _ -> wrap + where res = a <+> text divOp <+> b + wrap = parens (b <+> text "== 0") <+> text "?" <+> def <+> text ":" <+> parens res + + shift toLeft i a = a <+> text cop <+> i + where cop | toLeft = "<<" + | True = ">>" + + rotate toLeft i a s + | i < 0 = rotate (not toLeft) (-i) a s + | i == 0 = a + | True = case kindOf s of + KBounded True _ -> tbd $ "Rotation of signed quantities: " ++ show (toLeft, i, s) + KBounded False sz | i >= sz -> rotate toLeft (i `mod` sz) a s + KBounded False sz -> parens (a <+> text cop <+> int i) + <+> text "|" + <+> parens (a <+> text cop' <+> int (sz - i)) + KUnbounded -> shift toLeft (int i) a -- For SInteger, rotate is the same as shift in Haskell + _ -> tbd $ "Rotation for unbounded quantity: " ++ show (toLeft, i, s) + where (cop, cop') | toLeft = ("<<", ">>") + | True = (">>", "<<") + + -- TBD: below we only support the values for extract that are "easy" to implement. These should cover + -- almost all instances actually generated by SBV, however. + extract hi lo i a -- Isolate the bit-extraction case + | hi == lo, KBounded _ sz <- kindOf i, hi < sz, hi >= 0 + = if hi == 0 + then text "(SBool)" <+> parens (a <+> text "& 1") + else text "(SBool)" <+> parens (parens (a <+> text ">>" <+> int hi) <+> text "& 1") + extract hi lo i a + | srcSize `notElem` [64, 32, 16] + = bad "Unsupported source size" + | (hi + 1) `mod` 8 /= 0 || lo `mod` 8 /= 0 + = bad "Unsupported non-byte-aligned extraction" + | tgtSize < 8 || tgtSize `mod` 8 /= 0 + = bad "Unsupported target size" + | True + = text cast <+> shifted + where bad why = tbd $ "extract with " ++ show (hi, lo, k, i) ++ " (Reason: " ++ why ++ ".)" + + k = kindOf i + srcSize = intSizeOf k + tgtSize = hi - lo + 1 + signChange = srcSize == tgtSize + + cast + | signChange && hasSign k = "(SWord" ++ show srcSize ++ ")" + | signChange = "(SInt" ++ show srcSize ++ ")" + | True = "(SWord" ++ show tgtSize ++ ")" + + shifted + | lo == 0 = a + | True = parens (a <+> text ">>" <+> int lo) + + -- TBD: ditto here for join, just like extract above + join (i, j, a, b) = case (kindOf i, kindOf j) of + (KBounded False 8, KBounded False 8) -> parens (parens (text "(SWord16)" <+> a) <+> text "<< 8") <+> text "|" <+> parens (text "(SWord16)" <+> b) + (KBounded False 16, KBounded False 16) -> parens (parens (text "(SWord32)" <+> a) <+> text "<< 16") <+> text "|" <+> parens (text "(SWord32)" <+> b) + (KBounded False 32, KBounded False 32) -> parens (parens (text "(SWord64)" <+> a) <+> text "<< 32") <+> text "|" <+> parens (text "(SWord64)" <+> b) + (k1, k2) -> tbd $ "join with " ++ show ((k1, i), (k2, j)) + +-- | Quote a document after replacing its line breaks with spaces. +-- Otherwise breaks the generated code.. sigh +printQuotes :: Doc -> Doc +printQuotes d = text $ '"' : ppSameLine d ++ "\"" + +-- | Replace document line breaks with spaces for single-line output. +ppSameLine :: Doc -> String +ppSameLine = trim . render + where trim "" = "" + trim ('\n':cs) = ' ' : trim (dropWhile isSpace cs) + trim (c:cs) = c : trim cs + +-- | Align documents by padding their left sides to the same width. +-- 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 = replicate (l - length s) ' ' ++ s + +-- | Merge a bunch of bundles to generate code for a library. For the final +-- config, we simply return the first config we receive, or the default if none. +mergeToLib :: String -> [(CgConfig, CgPgmBundle)] -> (CgConfig, CgPgmBundle) +mergeToLib libName cfgBundles + | length nubKinds /= 1 + = error $ "Cannot merge programs with differing SInteger/SReal mappings. Received the following kinds:\n" + ++ unlines (map show nubKinds) + | True + = (finalCfg, CgPgmBundle bundleKind $ sources ++ libHeader : [libDriver | anyDriver] ++ [libMake | anyMake]) + where bundles = map snd cfgBundles + kinds = [k | CgPgmBundle k _ <- bundles] + nubKinds = nub kinds + bundleKind = case nubKinds of + bk:_ -> bk + [] -> error "Data.SBV.C: Impossible happened: mergeLibs: kinds ended up being empty!" + files = concat [fs | CgPgmBundle _ fs <- bundles] + sigs = concat [ss | (_, (CgHeader ss, _)) <- files] + anyMake = not (null [() | (_, (CgMakefile{}, _)) <- files]) + drivers = [ds | (_, (CgDriver, ds)) <- files] + anyDriver = not (null drivers) + mkFlags = nub (concat [xs | (_, (CgMakefile xs, _)) <- files]) + sources = [(f, (CgSource, [pre, libHInclude, post])) | (f, (CgSource, [pre, _, post])) <- files] + sourceNms = map fst sources + libHeader = (libName ++ ".h", (CgHeader sigs, [genHeader bundleKind libName sigs empty])) + libHInclude = text "#include" <+> text (show (libName ++ ".h")) + libMake = ("Makefile", (CgMakefile mkFlags, [genLibMake anyDriver libName sourceNms mkFlags])) + libDriver = (libName ++ "_driver.c", (CgDriver, mergeDrivers libName libHInclude (zip (map takeBaseName sourceNms) drivers))) + finalCfg = case cfgBundles of + [] -> defaultCgConfig + ((c, _):_) -> c + +-- | Create a Makefile for the library +genLibMake :: Bool -> String -> [String] -> [String] -> Doc +genLibMake ifdr libName fs ldFlags = foldr1 ($$) [l | (True, l) <- lns] + where ifld = not (null ldFlags) + ld | ifld = text "${LDFLAGS}" + | True = empty + lns = [ (True, text "# Makefile for" <+> nm P.<> text ". Automatically generated by SBV. Do not edit!") + , (True, text "") + , (True, text "# include any user-defined .mk file in the current directory.") + , (True, text "-include *.mk") + , (True, text "") + , (True, text "CC?=gcc") + , (True, text "CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer") + , (ifld, text "LDFLAGS?=" P.<> text (unwords ldFlags)) + , (True, text "AR?=ar") + , (True, text "ARFLAGS?=cr") + , (True, text "") + , (not ifdr, text ("all: " ++ liba)) + , (ifdr, text ("all: " ++ unwords [liba, libd])) + , (True, text "") + , (True, text liba P.<> text (": " ++ unwords os)) + , (True, text "\trm -f $@.tmp") + , (True, text "\t${AR} ${ARFLAGS} $@.tmp $^") + , (True, text "\tmv -f $@.tmp $@") + , (True, text "") + , (ifdr, text libd P.<> text (": " ++ unwords [libd ++ ".c", libh, liba])) + , (ifdr, text ("\t${CC} ${CCFLAGS} $< -o $@ " ++ liba) <+> ld) + , (ifdr, text "") + , (True, vcat (zipWith mkObj os fs)) + , (True, text "clean:") + , (True, text "\trm -f *.o") + , (True, text "") + , (True, text "veryclean: clean") + , (not ifdr, text "\trm -f" <+> text (unwords [liba, liba ++ ".tmp"])) + , (ifdr, text "\trm -f" <+> text (unwords [liba, libd, liba ++ ".tmp"])) + , (True, text "") + ] + nm = text libName + liba = libName ++ ".a" + libh = libName ++ ".h" + libd = libName ++ "_driver" + os = map (`replaceExtension` ".o") fs + mkObj o f = text o P.<> 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 P.<> text ". */" + $$ text "/* Automatically generated by SBV. Edit as you see fit! */" + $$ text "" + $$ text "#include " + $$ 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 = replicate (length tag) '=' + psep = "printf(\"" ++ lsep ++ "\\n\");" + +-- | Return the linker flags required by a legacy scalar operation. +getLDFlag :: (Op, Kind) -> [String] +getLDFlag (o, k) = flag o + where math = ["-lm"] + + flag (IEEEFP FP_Cast{}) = math + flag (KindCast KReal KUnbounded) = math + flag (IEEEFP fop) | fop `elem` requiresMath = math + flag Abs | k `elem` [KFloat, KDouble, KReal] = math + flag _ = [] + + requiresMath = [ FP_Abs + , FP_FMA + , FP_Sqrt + , FP_Rem + , FP_Min + , FP_Max + , FP_RoundToIntegral + , FP_ObjEqual + , FP_IsSubnormal + , FP_IsInfinite + , FP_IsNaN + , FP_IsNegative + , FP_IsPositive + , FP_IsNormal + , FP_IsZero + ] + +{- HLint ignore module "Redundant lambda" -} diff --git a/Data/SBV/Compilers/C/List.hs b/Data/SBV/Compilers/C/List.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/List.hs @@ -0,0 +1,605 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.List +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Typed symbolic-list lowering for generated C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.List + ( listKinds + , listSupported + , listUsesExact + , listNeedsDriverInit + , listCType + , listForwardTypeDecls + , listTypeDecls + , listOwnershipTypeDecls + , listRuntimeDecls + , listRuntime + , listConst + , listExpr + , listEqual + , listClone + , listRelease + , listDriverValue + , listDriverInit + , listDriverClear + , listPrint + , listContextStart + , listContextEnd + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.List (nub, sortOn, stripPrefix, tails) +import qualified Data.Set as Set + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Arena (CArena(..), arenaRuntime) +import Data.SBV.Compilers.C.Array (arrayStoredLoad, arrayStoredValue) +import Data.SBV.Compilers.C.GMP (gmpFunctionName, gmpInitializeCopy, gmpOutputType, isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Types (isConcreteADT, constElementCType, elementCType, kindTag, listCloneName, listReleaseName, listHelperName) +import Data.SBV.Compilers.C.Value ( byValueEqual + , managedValueClone + , managedValueRelease + , valueDriverClear + , valueDriverInit + , valueDriverNeedsInitialization + , valueNeedsOwnership + ) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds) + +-- | Return all distinct symbolic-list kinds in dependency order. +listKinds :: Set.Set Kind -> [Kind] +listKinds = sortOn listDepth . nub . concatMap (filter isList . expandKinds) . Set.toAscList + where listDepth :: Kind -> Int + listDepth (KList elementKind) = 1 + listDepth elementKind + listDepth _ = 0 + +-- | Test whether a list element kind has a supported C representation. Array +-- elements support structural movement and indexing, but operations requiring +-- extensional element equality are rejected by 'listExpr'. +listSupported :: CgConfig -> Kind -> Bool +listSupported _ (KList elementKind) = supportedElement elementKind + where supportedElement KBool = True + supportedElement KBounded{} = True + supportedElement KFloat = True + supportedElement KDouble = True + supportedElement KChar = True + supportedElement KString = True + supportedElement KFP{} = True + supportedElement KUnbounded = True + supportedElement KReal = True + supportedElement KRational = True + supportedElement (KList kind) = supportedElement kind + supportedElement (KSet kind) = supportedElement kind + supportedElement (KArray keyKind valueKind) = supportedElement keyKind && supportedElement valueKind + supportedElement (KTuple kinds) = all supportedElement kinds + supportedElement kind + | isConcreteADT kind = True + | True = isRoundingMode kind +listSupported _ _ = False + +-- | Test whether a list stores exact GMP-backed elements. +listUsesExact :: CgConfig -> Kind -> Bool +listUsesExact cfg (KList elementKind) = isExactGMPKind cfg elementKind +listUsesExact _ _ = False + +-- | Test whether an example-driver list requires statement-based element +-- initialization instead of a single compound literal. +listNeedsDriverInit :: CgConfig -> Kind -> Bool +listNeedsDriverInit cfg (KList elementKind) = valueDriverNeedsInitialization cfg elementKind +listNeedsDriverInit _ _ = False + +-- | Return the public C descriptor type for a symbolic-list kind. +listCType :: Kind -> String +listCType kind@KList{} = elementCType kind +listCType kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Emit guarded forward declarations for symbolic-list descriptor types. +-- These declarations allow list and set descriptors to contain pointers to +-- each other before either family has emitted its complete layouts. +listForwardTypeDecls :: [Kind] -> Doc +listForwardTypeDecls [] = empty +listForwardTypeDecls kinds = text . unlines $ concatMap declaration kinds + where declaration kind@KList{} = + [ "#ifndef " ++ listForwardGuard kind + , "#define " ++ listForwardGuard kind + , "typedef struct " ++ listCType kind ++ " " ++ listCType kind ++ ";" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Emit typed borrowed-list descriptors and ownership-helper prototypes. +-- The element type may remain incomplete here because descriptors only carry +-- pointers; definitions that inspect elements are emitted later by +-- 'listOwnershipTypeDecls'. +listTypeDecls :: CgConfig -> [Kind] -> Doc +listTypeDecls cfg kinds + | null kinds = empty + | True = listForwardTypeDecls kinds $$ text (unlines $ + ["/* Typed symbolic lists. Inputs borrow their elements; outputs and returns own them. */" + , cUnusedAttribute + ] + ++ concatMap declaration kinds + ) + where declaration kind@(KList elementKind) + | listSupported cfg kind + = let cType = listCType kind + cloneName = listCloneName kind + releaseName = listReleaseName kind + in [ "#ifndef " ++ listGuard kind + , "#define " ++ listGuard kind + , "struct " ++ cType ++ " { " ++ constElementCType elementKind ++ " *data; size_t length; };" + , "static inline SBV_CGEN_UNUSED " ++ cType ++ " " ++ cloneName ++ "(" ++ cType ++ " value);" + , "static inline SBV_CGEN_UNUSED void " ++ releaseName ++ "(" ++ cType ++ " *value);" + , "#endif" + , "" + ] + | True + = error $ "SBV->C: Unsupported list element kind: " ++ show elementKind + declaration kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Emit list clone and release definitions after aggregate element layouts +-- are complete. Inputs borrow their element arrays; output and return values +-- own a cloned array and must be released with the matching helper. +listOwnershipTypeDecls :: CgConfig -> [Kind] -> Doc +listOwnershipTypeDecls cfg kinds + | null kinds = empty + | True = text . unlines $ concatMap declaration kinds + where declaration kind@(KList elementKind) + | listSupported cfg kind + = let cType = listCType kind + elementType = listElementCType elementKind + cloneName = listCloneName kind + releaseName = listReleaseName kind + in [ "#ifndef " ++ listOwnershipGuard kind + , "#define " ++ listOwnershipGuard kind + , "static inline SBV_CGEN_UNUSED " ++ cType ++ " " ++ cloneName ++ "(" ++ cType ++ " value)" + , "{" + , " " ++ elementType ++ " *copy = NULL;" + , " if (value.length != 0) {" + , " if (value.length > SIZE_MAX / sizeof(*copy)) abort();" + , " copy = (" ++ elementType ++ " *) malloc(value.length * sizeof(*copy));" + , " if (copy == NULL) abort();" + ] + ++ cloneElements elementKind + ++ [ " }" + , " return (" ++ cType ++ ") {copy, value.length};" + , "}" + , "static inline SBV_CGEN_UNUSED void " ++ releaseName ++ "(" ++ cType ++ " *value)" + , "{" + , " if (value == NULL) return;" + ] + ++ releaseElements elementKind + ++ [ " *value = (" ++ cType ++ ") {NULL, 0};" + , "}" + , "#endif" + , "" + ] + | True + = error $ "SBV->C: Unsupported list element kind: " ++ show elementKind + declaration kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + + cloneElements elementKind + | isExactGMPKind cfg elementKind + = [ " for (size_t i = 0; i < value.length; ++i) {" + , " " ++ gmpOutputType elementKind ++ " element = (" ++ gmpOutputType elementKind ++ ") malloc(sizeof(*element));" + , " if (element == NULL) abort();" + ] + ++ map (" " ++) (lines (render (gmpInitializeCopy elementKind (text "element") (text "value.data[i]")))) + ++ [ " copy[i] = element;" + , " }" + ] + | isConcreteADT elementKind || valueNeedsOwnership cfg elementKind + = [ " for (size_t i = 0; i < value.length; ++i)" + , " copy[i] = " ++ render (managedValueClone elementKind (text "value.data[i]")) ++ ";" + ] + | True + = [" memcpy(copy, value.data, value.length * sizeof(*copy));"] + + releaseElements elementKind + | isExactGMPKind cfg elementKind + = [ " " ++ listElementCType elementKind ++ " *data = (" ++ listElementCType elementKind ++ " *) value->data;" + , " for (size_t i = 0; i < value->length; ++i) {" + , " " ++ gmpOutputType elementKind ++ " element = (" ++ gmpOutputType elementKind ++ ") data[i];" + , " if (element != NULL) { " ++ gmpFunctionName elementKind "clear" ++ "(element); free(element); }" + , " }" + , " free(data);" + ] + | isConcreteADT elementKind || valueNeedsOwnership cfg elementKind + = [ " " ++ listElementCType elementKind ++ " *data = (" ++ listElementCType elementKind ++ " *) value->data;" + , " for (size_t i = 0; i < value->length; ++i)" + , " " ++ render (managedValueRelease elementKind (text "&data[i]")) + , " free(data);" + ] + | True + = [" free((void *) value->data);"] + +-- | Emit forward declarations for list equality helpers referenced by nested +-- aggregate element comparisons. +listRuntimeDecls :: CgConfig -> [Kind] -> Doc +listRuntimeDecls cfg kinds = text . unlines $ + [ "static SBV_CGEN_UNUSED bool " ++ helperName kind "equal" ++ "(" ++ listCType kind ++ " left, " ++ listCType kind ++ " right);" + | kind <- kinds + , listSupported cfg kind + ] + +-- | Emit the shared list arena and specialized sequence operations for every +-- list kind used by the generated program. +listRuntime :: CgConfig -> Bool -> [Kind] -> Doc +listRuntime cfg usesExactInteger kinds = text . unlines . map markUnused $ + commonRuntime + ++ (if usesExactInteger then exactIndexRuntime else []) + ++ concatMap specializedRuntime kinds + where markUnused line = case stripPrefix "static " line of + Just rest -> "static SBV_CGEN_UNUSED " ++ rest + Nothing -> line + + specializedRuntime kind + | listSupported cfg kind = listKindRuntime cfg usesExactInteger kind + | True = error $ "SBV->C: Unsupported list kind: " ++ show kind + +-- | Render a list constant with a caller-supplied renderer for its elements. +listConst :: (CV -> Doc) -> CV -> Maybe Doc +listConst renderElement (CV kind@(KList elementKind) (CList values)) + = Just $ text "((" P.<> text (listCType kind) P.<> text ") {" + P.<> elements + P.<> text ", " + P.<> int (length values) + P.<> text "})" + where elements + | null values = text "NULL" + | True = text "(" P.<> text (constElementCType elementKind) P.<> text "[]) {" + P.<> fsep (punctuate comma (map (arrayStoredValue elementKind . renderElement . CV elementKind) values)) + P.<> text "}" +listConst _ _ = Nothing + +-- | Lower the core symbolic sequence operations for non-character lists. +listExpr :: CgConfig -> Op -> [SV] -> SV -> [Doc] -> Maybe CLowering +listExpr cfg op svs resultSV args + | not touchesList = Nothing + | True = case (op, args) of + (ADTOp{} , _ ) -> Nothing + (TupleConstructor{} , _ ) -> Nothing + (TupleAccess{} , _ ) -> Nothing + (Uninterpreted{} , _ ) -> Nothing + (Label _ , [a] ) -> lower a + (Equal _ , [a, b] ) -> lower $ call (helper "equal") [a, b] + (NotEqual , as ) -> lower $ distinctLists as + (SeqOp (SeqLen kind) , [a] ) | kind /= KChar -> lowerInteger False $ call (helperFor kind "length") [a] + (SeqOp (SeqConcat _) , as ) + | KList elementKind <- resultKind -> lower $ foldLists elementKind as + (SeqOp (SeqNth kind) , [a, i] ) | kind /= KChar -> loadArray $ indexed kind "nth" [a] i + (SeqOp (SeqUnit kind) , [a] ) | kind /= KChar -> lower $ call (helperFor kind "unit") [text "&sbv_local_list_ctx", arrayStoredValue kind a] + (SeqOp (SeqSubseq kind) , [a, i, n]) | kind /= KChar -> lower $ indexed2 kind "substring" a i n + (SeqOp (SeqIndexOf kind) , [a, b, i]) | kind /= KChar -> lowerInteger True $ indexed kind "index_of" [a, b] i + (SeqOp (SeqContains kind) , [a, b] ) | kind /= KChar -> lower $ call (helperFor kind "contains") [a, b] + (SeqOp (SeqPrefixOf kind) , [a, b] ) | kind /= KChar -> lower $ call (helperFor kind "prefix_of") [a, b] + (SeqOp (SeqSuffixOf kind) , [a, b] ) | kind /= KChar -> lower $ call (helperFor kind "suffix_of") [a, b] + (SeqOp (SeqReplace kind) , [a, b, c]) | kind /= KChar -> lower $ call (helperFor kind "replace") [text "&sbv_local_list_ctx", a, b, c] + _ -> unsupported + where resultKind = kindOf resultSV + + touchesList = isList resultKind || any (isList . kindOf) svs || isListOp op + + listKind = case [kind | value <- resultKind : map kindOf svs, kind@(KList _) <- [value]] of + kind:_ -> kind + [] -> error $ "SBV->C: Cannot determine list kind for " ++ show op + + lower expression = Just $ expressionLowering requirements expression + + loadArray expression + | isArray resultKind = Just (arrayStoredLoad resultSV expression) + | True = lower expression + + lowerInteger signed expression + | isExactGMPKind cfg resultKind + = Just $ expressionLowering [CRequiresLists, CRequiresGMP] + $ call (if signed then "sbv_gmp_integer_from_s64" else "sbv_gmp_integer_from_u64") + [text "&sbv_local_gmp_ctx", expression] + | True + = lower $ parens (text "SInteger") <+> expression + + requirements = CRequiresLists : [CRequiresGMP | any (isExactGMPKind cfg) touchedKinds] + + touchedKinds = concatMap expandKinds (resultKind : map kindOf svs) + + helper = helperName listKind + + helperFor elementKind = helperName (KList elementKind) + + distinctLists rendered = fsep $ punctuate (text " &&") + [parens (text "!" P.<> call (helper "equal") [left, right]) + | (left:rest) <- tails rendered, right <- rest] + + foldLists _ [] = text "((" P.<> text (listCType listKind) P.<> text ") {NULL, 0})" + foldLists _ [value] = value + foldLists elementKind (value:rest) = foldl combine value rest + where combine left right = call (helperFor elementKind "concat") [text "&sbv_local_list_ctx", left, right] + + indexed elementKind suffix prefix index + | exactIndex = call (helperFor elementKind (suffix ++ "_mpz")) (context ++ prefix ++ [index]) + | True = call (helperFor elementKind suffix) (context ++ prefix ++ [parens (text "int64_t") <+> index]) + where context + | suffix == "nth" && isExactGMPKind cfg elementKind = [text "&sbv_local_gmp_ctx"] + | True = [] + + indexed2 elementKind suffix value offset count + | exactIndex = call (helperFor elementKind (suffix ++ "_mpz")) [text "&sbv_local_list_ctx", value, offset, count] + | True = call (helperFor elementKind suffix) + [text "&sbv_local_list_ctx", value, parens (text "int64_t") <+> offset, parens (text "int64_t") <+> count] + + exactIndex = any (isExactGMPKind cfg . kindOf) svs + + requiresElementEquality Equal{} = True + requiresElementEquality NotEqual = True + requiresElementEquality (SeqOp SeqIndexOf{}) = True + requiresElementEquality (SeqOp SeqContains{}) = True + requiresElementEquality (SeqOp SeqPrefixOf{}) = True + requiresElementEquality (SeqOp SeqSuffixOf{}) = True + requiresElementEquality (SeqOp SeqReplace{}) = True + requiresElementEquality _ = False + + unsupported + | requiresElementEquality op + , any isArray (expandKinds (listElementKind listKind)) + = error $ "SBV->C: List operation " ++ show op + ++ " requires unsupported extensional equality for array-valued elements." + | True + = error $ "SBV->C: List lowering does not support " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + +-- | Compare two list descriptors using symbolic sequence equality. +listEqual :: Kind -> Doc -> Doc -> Doc +listEqual kind left right = call (helperName kind "equal") [left, right] + +-- | Deep-copy a list across the generated function's ownership boundary. +listClone :: Kind -> Doc -> Doc +listClone kind value = call (listCloneName kind) [value] + +-- | Release an owned list in a generated driver. +listRelease :: Kind -> Doc -> Doc +listRelease kind value = call (listReleaseName kind) [text "&" P.<> value] P.<> semi + +-- | Produce a deterministic three-element list value for an example driver. +listDriverValue :: (Kind -> Integer -> Doc) -> Kind -> Integer -> Doc +listDriverValue renderValue kind@(KList elementKind) seed + = text "((" P.<> text (listCType kind) P.<> text ") {" + P.<> text "(" P.<> text (constElementCType elementKind) P.<> text "[]) {" + P.<> fsep (punctuate comma [renderValue elementKind seed, renderValue elementKind (seed + 1), renderValue elementKind (seed + 2)]) + P.<> text "}, 3})" +listDriverValue _ kind _ = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Initialize a generated-driver list whose elements require statement-based +-- setup. The descriptor borrows three independently initialized elements; +-- release their storage with 'listDriverClear' after the call completes. The +-- supplied statement renderer handles retained array and ADT elements. +listDriverInit :: CgConfig -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> String -> Integer -> Doc +listDriverInit cfg renderValue initializeValue kind@KList{} externalName seed = valueDriverInit cfg renderValue initializeValue kind externalName seed +listDriverInit _ _ _ kind _ _ = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Clear managed element storage initialized by 'listDriverInit'. +listDriverClear :: CgConfig -> Kind -> String -> Doc +listDriverClear cfg kind@KList{} externalName = valueDriverClear cfg kind externalName +listDriverClear _ kind _ = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Print a list value using the supplied element printer. +listPrint :: (Kind -> Doc -> Doc) -> Kind -> Doc -> Doc +listPrint printElement (KList elementKind) value + = text "printf(\"[\");" + $$ text "for (size_t" <+> index <+> text "= 0;" <+> index <+> text "<" <+> value P.<> text ".length; ++" P.<> index P.<> text ")" + $$ text "{" + $$ nest 2 ( text "if" <+> parens (index <+> text "!= 0") <+> text "printf(\", \");" + $$ printElement elementKind (value P.<> text ".data[" P.<> index P.<> text "]") + ) + $$ text "}" + $$ text "printf(\"]\");" + where index = text ("sbv_local_list_print_index_" ++ kindTag elementKind) +listPrint _ kind _ = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Initialize the arena used by list temporaries in a generated function. +listContextStart :: Doc +listContextStart = text "sbv_list_ctx sbv_local_list_ctx = {NULL};" + +-- | Release all list temporaries allocated by a generated function. +listContextEnd :: Doc +listContextEnd = call "sbv_list_ctx_end" [text "&sbv_local_list_ctx"] P.<> semi + +-- | Test whether an operation belongs to the non-character sequence family. +isListOp :: Op -> Bool +isListOp (SeqOp (SeqLen kind)) = kind /= KChar +isListOp (SeqOp (SeqConcat kind)) = kind /= KChar +isListOp (SeqOp (SeqNth kind)) = kind /= KChar +isListOp (SeqOp (SeqUnit kind)) = kind /= KChar +isListOp (SeqOp (SeqSubseq kind)) = kind /= KChar +isListOp (SeqOp (SeqIndexOf kind)) = kind /= KChar +isListOp (SeqOp (SeqContains kind)) = kind /= KChar +isListOp (SeqOp (SeqPrefixOf kind)) = kind /= KChar +isListOp (SeqOp (SeqSuffixOf kind)) = kind /= KChar +isListOp (SeqOp (SeqReplace kind)) = kind /= KChar +isListOp _ = False + +-- | Return the C type used to store one supported list element. +listElementCType :: Kind -> String +listElementCType KChar = "SChar" +listElementCType kind = elementCType kind + +-- | Return the preprocessor guard for one list forward declaration. +listForwardGuard :: Kind -> String +listForwardGuard kind = "SBV_LIST_" ++ kindTag (listElementKind kind) ++ "_FORWARD_DEFINED" + +-- | Return the preprocessor guard for one list descriptor. +listGuard :: Kind -> String +listGuard kind = "SBV_LIST_" ++ kindTag (listElementKind kind) ++ "_DEFINED" + +-- | Return the preprocessor guard for one list ownership-helper definition. +listOwnershipGuard :: Kind -> String +listOwnershipGuard kind = "SBV_LIST_" ++ kindTag (listElementKind kind) ++ "_OWNERSHIP_DEFINED" + +-- | Return the element kind of a symbolic-list kind. +listElementKind :: Kind -> Kind +listElementKind (KList elementKind) = elementKind +listElementKind kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Return one specialized list-operation helper name. +helperName :: Kind -> String -> String +helperName = listHelperName + +-- | Render a C helper call. +call :: String -> [Doc] -> Doc +call functionName args = text functionName P.<> parens (fsep (punctuate comma args)) + +-- | Shared per-call allocation arena used by every list specialization. +commonRuntime :: [String] +commonRuntime = arenaRuntime ListArena + +-- | Exact-GMP index conversion shared by specialized list operations. +exactIndexRuntime :: [String] +exactIndexRuntime = + ["static bool sbv_list_mpz_to_size(SInteger value, size_t *result)" + , "{" + , " if (mpz_sgn(value) < 0 || mpz_sizeinbase(value, 2) > sizeof(size_t) * CHAR_BIT) return false;" + , " size_t written = 0; *result = 0;" + , " (void) mpz_export(result, &written, -1, sizeof(*result), 0, 0, value);" + , " return true;" + , "}" + ] + +-- | Emit all sequence helpers for one supported list element kind. +listKindRuntime :: CgConfig -> Bool -> Kind -> [String] +listKindRuntime cfg usesExactInteger kind@(KList elementKind) = + [ "" + , "static bool " ++ equalElement ++ "(" ++ elementType ++ " left, " ++ elementType ++ " right)" + , "{ return " ++ elementEqual ++ "; }" + , "static bool " ++ equalList ++ "(" ++ listType ++ " left, " ++ listType ++ " right)" + , "{" + , " if (left.length != right.length) return false;" + , " for (size_t i = 0; i < left.length; ++i) if (!" ++ equalElement ++ "(left.data[i], right.data[i])) return false;" + , " return true;" + , "}" + , "static uint64_t " ++ helper "length" ++ "(" ++ listType ++ " value) { return (uint64_t) value.length; }" + , "static " ++ listType ++ " " ++ helper "concat" ++ "(sbv_list_ctx *ctx, " ++ listType ++ " left, " ++ listType ++ " right)" + , "{" + , " if (right.length > SIZE_MAX - left.length) abort();" + , " if (left.length == 0) return right;" + , " if (right.length == 0) return left;" + , " const size_t length = left.length + right.length;" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_list_alloc(ctx, length, sizeof(*data));" + , " memcpy(data, left.data, left.length * sizeof(*data));" + , " memcpy(data + left.length, right.data, right.length * sizeof(*data));" + , " return (" ++ listType ++ ") {data, length};" + , "}" + , "static " ++ listType ++ " " ++ helper "unit" ++ "(sbv_list_ctx *ctx, " ++ elementType ++ " value)" + , "{" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_list_alloc(ctx, 1, sizeof(*data));" + , " data[0] = value; return (" ++ listType ++ ") {data, 1};" + , "}" + , "static " ++ elementType ++ " " ++ helper "nth_size" ++ "(" ++ exactContextParam ++ listType ++ " value, size_t index)" + , "{ return index < value.length ? value.data[index] : " ++ defaultElement ++ "; }" + , "static " ++ elementType ++ " " ++ helper "nth" ++ "(" ++ exactContextParam ++ listType ++ " value, int64_t index)" + , "{ return index < 0 ? " ++ defaultElement ++ " : " ++ helper "nth_size" ++ "(" ++ exactContextArg ++ "value, (size_t) index); }" + , "static " ++ listType ++ " " ++ helper "substring_size" ++ "(sbv_list_ctx *ctx, " ++ listType ++ " value, size_t offset, size_t count)" + , "{" + , " if (offset >= value.length || count == 0) return (" ++ listType ++ ") {NULL, 0};" + , " if (count > value.length - offset) count = value.length - offset;" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_list_alloc(ctx, count, sizeof(*data));" + , " memcpy(data, value.data + offset, count * sizeof(*data)); return (" ++ listType ++ ") {data, count};" + , "}" + , "static " ++ listType ++ " " ++ helper "substring" ++ "(sbv_list_ctx *ctx, " ++ listType ++ " value, int64_t offset, int64_t count)" + , "{" + , " if (offset < 0 || count <= 0) return (" ++ listType ++ ") {NULL, 0};" + , " return " ++ helper "substring_size" ++ "(ctx, value, (size_t) offset, (size_t) count);" + , "}" + ] + ++ matchRuntime + ++ [ "static bool " ++ helper "prefix_of" ++ "(" ++ listType ++ " prefix, " ++ listType ++ " value)" + , "{ return prefix.length <= value.length && " ++ helper "match_at" ++ "(value, prefix, 0); }" + , "static bool " ++ helper "suffix_of" ++ "(" ++ listType ++ " suffix, " ++ listType ++ " value)" + , "{ return suffix.length <= value.length && " ++ helper "match_at" ++ "(value, suffix, value.length - suffix.length); }" + , "static bool " ++ helper "contains" ++ "(" ++ listType ++ " value, " ++ listType ++ " part)" + , "{ return " ++ helper "index_of_size" ++ "(value, part, 0) >= 0; }" + , "static int64_t " ++ helper "index_of" ++ "(" ++ listType ++ " value, " ++ listType ++ " part, int64_t start)" + , "{ return start < 0 ? -1 : " ++ helper "index_of_size" ++ "(value, part, (size_t) start); }" + , "static " ++ listType ++ " " ++ helper "replace" ++ "(sbv_list_ctx *ctx, " ++ listType ++ " value, " ++ listType ++ " source, " ++ listType ++ " replacement)" + , "{" + , " const int64_t index = " ++ helper "index_of_size" ++ "(value, source, 0);" + , " if (index < 0) return value;" + , " const size_t retained = value.length - source.length;" + , " if (replacement.length > SIZE_MAX - retained) abort();" + , " const size_t length = retained + replacement.length;" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_list_alloc(ctx, length, sizeof(*data));" + , " const size_t first = (size_t) index; const size_t after = first + source.length;" + , " if (first != 0) memcpy(data, value.data, first * sizeof(*data));" + , " if (replacement.length != 0) memcpy(data + first, replacement.data, replacement.length * sizeof(*data));" + , " if (after != value.length) memcpy(data + first + replacement.length, value.data + after, (value.length - after) * sizeof(*data));" + , " return (" ++ listType ++ ") {data, length};" + , "}" + ] + ++ exactRuntime + where listType = listCType kind + elementType = listElementCType elementKind + helper = helperName kind + equalElement = helper "element_equal" + equalList = helper "equal" + elementEqual = render $ byValueEqual cfg True elementKind (text "left") (text "right") + + exactContextParam + | isExactGMPKind cfg elementKind = "sbv_gmp_ctx *exact_ctx, " + | True = "" + + exactContextArg + | isExactGMPKind cfg elementKind = "exact_ctx, " + | True = "" + + defaultElement + | isExactGMPKind cfg elementKind + , elementKind == KUnbounded = "sbv_gmp_integer_const(exact_ctx, \"0\")" + | isExactGMPKind cfg elementKind = "sbv_gmp_real_const(exact_ctx, \"0\")" + | True = "(" ++ elementType ++ ") {0}" + + matchRuntime = + [ "static bool " ++ helper "match_at" ++ "(" ++ listType ++ " value, " ++ listType ++ " part, size_t offset)" + , "{" + , " if (offset > value.length || part.length > value.length - offset) return false;" + , " for (size_t i = 0; i < part.length; ++i) if (!" ++ equalElement ++ "(value.data[offset + i], part.data[i])) return false;" + , " return true;" + , "}" + , "static int64_t " ++ helper "index_of_size" ++ "(" ++ listType ++ " value, " ++ listType ++ " part, size_t start)" + , "{" + , " if (start > value.length) return -1;" + , " for (size_t i = start; i <= value.length; ++i) {" + , " if (" ++ helper "match_at" ++ "(value, part, i)) return i <= INT64_MAX ? (int64_t) i : -1;" + , " if (i == value.length) break;" + , " }" + , " return -1;" + , "}" + ] + + exactRuntime + | usesExactInteger = + [ "static " ++ elementType ++ " " ++ helper "nth_mpz" ++ "(" ++ exactContextParam ++ listType ++ " value, SInteger index)" + , "{ size_t converted; return sbv_list_mpz_to_size(index, &converted) ? " ++ helper "nth_size" ++ "(" ++ exactContextArg ++ "value, converted) : " ++ defaultElement ++ "; }" + , "static " ++ listType ++ " " ++ helper "substring_mpz" ++ "(sbv_list_ctx *ctx, " ++ listType ++ " value, SInteger offset, SInteger count)" + , "{" + , " size_t converted_offset, converted_count;" + , " if (!sbv_list_mpz_to_size(offset, &converted_offset) || !sbv_list_mpz_to_size(count, &converted_count)) return (" ++ listType ++ ") {NULL, 0};" + , " return " ++ helper "substring_size" ++ "(ctx, value, converted_offset, converted_count);" + , "}" + , "static int64_t " ++ helper "index_of_mpz" ++ "(" ++ listType ++ " value, " ++ listType ++ " part, SInteger start)" + , "{ size_t converted; return sbv_list_mpz_to_size(start, &converted) ? " ++ helper "index_of_size" ++ "(value, part, converted) : -1; }" + ] + | True = [] +listKindRuntime _ _ kind = error $ "SBV->C: Expected a list kind, received " ++ show kind diff --git a/Data/SBV/Compilers/C/Lowering.hs b/Data/SBV/Compilers/C/Lowering.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Lowering.hs @@ -0,0 +1,63 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Lowering +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Structured results shared by the individual C lowering backends. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Lowering + ( CLowering(..) + , CRequirement(..) + , expressionLowering + , chooseLowering + ) where + +import Data.Maybe (catMaybes, listToMaybe) +import qualified Data.Set as Set + +import Text.PrettyPrint.HughesPJ (Doc) + +-- | Facilities required by a lowered C fragment. The program-level +-- collector will ultimately turn these capabilities into includes, runtime +-- helpers, compiler options, and linker options. +data CRequirement = CRequiresGMP -- ^ GMP-backed exact-number support. + | CRequiresLibBF -- ^ LibBF-backed arbitrary floating-point support. + | CRequiresLibM -- ^ The platform C mathematics library. + | CRequiresNativeFPRounding -- ^ LibBF adapters for explicitly rounded native floating-point operations. + | CRequiresWideBV -- ^ Exact-width limb-backed bit-vector support. + | CRequiresArrays -- ^ Persistent functional-array support. + | CRequiresText -- ^ Length-aware character and string support. + | CRequiresLists -- ^ Typed symbolic-list support. + | CRequiresSets -- ^ Finite/cofinite symbolic-set support. + | CRequiresFunctionResults -- ^ Stable private storage for owned aggregate function results. + | CRequiresIntegerPower -- ^ Modular exponentiation for mapped unbounded integers. + deriving (Eq, Ord, Show) + +-- | A C expression together with statements and capabilities needed around +-- its evaluation. Declarations may be hoisted for function-wide backing +-- storage, but setup statements execute in order only when the value is demanded. +data CLowering = CLowering + { loweringExpression :: Doc -- ^ Expression producing the lowered result. + , loweringDeclarations :: [Doc] -- ^ Declarations that may be hoisted above guarded control flow. + , loweringSetup :: [Doc] -- ^ Statements required before evaluation. + , loweringRequirements :: Set.Set CRequirement -- ^ Runtime and external capabilities used. + } + +-- | Construct a statement-free expression lowering. +expressionLowering :: [CRequirement] -> Doc -> CLowering +expressionLowering requirements expression = CLowering + { loweringExpression = expression + , loweringDeclarations = [] + , loweringSetup = [] + , loweringRequirements = Set.fromList requirements + } + +-- | Select the first backend that accepts an operation. +chooseLowering :: [Maybe CLowering] -> Maybe CLowering +chooseLowering = listToMaybe . catMaybes diff --git a/Data/SBV/Compilers/C/NonLinear.hs b/Data/SBV/Compilers/C/NonLinear.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/NonLinear.hs @@ -0,0 +1,119 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.NonLinear +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Lowering of transcendental real operations and mapped integer powers. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.NonLinear + ( nonLinearExpr + , mappedIntegerPowerRuntime + ) where + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.CodeGen (CgConfig(..), CgSRealType(..)) +import Data.SBV.Core.Data +import Data.SBV.Core.Symbolic (NROp(..)) + +-- | Lower mapped-real transcendental operations and mapped integer +-- exponentiation. Exact integer exponentiation delegates to the GMP lowering +-- stage, while transcendental operations over exact rational reals receive an +-- actionable diagnostic. +nonLinearExpr :: CgConfig -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +nonLinearExpr cfg (NonLinear nonLinearOp) svs resultKind args + | nonLinearOp == NR_IntPow + = integerPower + | resultKind == KReal && all ((== KReal) . kindOf) svs + = realOperation + | True + = unsupported + where integerPower + | resultKind == KUnbounded + , map kindOf svs == [KUnbounded, KUnbounded] + , [base, powerValue] <- args + = case cgInteger cfg of + Nothing -> Nothing + Just width -> Just $ expressionLowering [CRequiresIntegerPower] + $ namedCall ("sbv_integer_pow_s" ++ show width) [base, powerValue] + | True + = unsupported + + realOperation = case cgReal cfg of + Nothing -> error $ "SBV->C: The exact GMP-rational SReal representation cannot represent " + ++ nonLinearName nonLinearOp + ++ ". Select a native approximation with cgSRealType to compile this operation." + Just realType -> Just $ expressionLowering [CRequiresLibM] (renderReal realType) + + renderReal realType = case (nonLinearOp, args) of + (NR_Pow , [left, right]) -> namedCall (realFunction realType "pow") [left, right] + (NR_IntPow, _ ) -> unsupportedDoc + (_ , [value] ) -> namedCall (realFunction realType (nonLinearName nonLinearOp)) [value] + _ -> unsupportedDoc + + unsupportedDoc = error unsupportedMessage + unsupported = error unsupportedMessage + + unsupportedMessage = "SBV->C: Cannot lower " ++ nonLinearName nonLinearOp + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + + namedCall functionName callArgs = text functionName P.<> parens (fsep (punctuate comma callArgs)) + + realFunction CgFloat baseName = baseName ++ "f" + realFunction CgDouble baseName = baseName + realFunction CgLongDouble baseName = baseName ++ "l" + + nonLinearName NR_Sin = "sin" + nonLinearName NR_Cos = "cos" + nonLinearName NR_Tan = "tan" + nonLinearName NR_ASin = "asin" + nonLinearName NR_ACos = "acos" + nonLinearName NR_ATan = "atan" + nonLinearName NR_Sqrt = "sqrt" + nonLinearName NR_Sinh = "sinh" + nonLinearName NR_Cosh = "cosh" + nonLinearName NR_Tanh = "tanh" + nonLinearName NR_Exp = "exp" + nonLinearName NR_Log = "log" + nonLinearName NR_Pow = "pow" + nonLinearName NR_IntPow = "integer exponentiation" +nonLinearExpr _ _ _ _ _ = Nothing + +-- | Emit modular exponentiation for an explicitly bounded C representation +-- of 'SInteger'. Negative exponents follow SMT-LIB integer-power semantics; +-- nonnegative results wrap through the selected two's-complement width. +mappedIntegerPowerRuntime :: CgConfig -> Doc +mappedIntegerPowerRuntime cfg = case cgInteger cfg of + Nothing -> error "SBV->C: Mapped integer-power runtime requested for exact SInteger" + Just width -> text . unlines $ + [ "static " ++ signedType ++ " " ++ helperName ++ "(" ++ signedType ++ " base, " ++ signedType ++ " exponent)" + , "{" + , " " ++ unsignedType ++ " result_bits = (" ++ unsignedType ++ ") 1, factor_bits, power;" + , " " ++ signedType ++ " result;" + , " if (exponent < 0) {" + , " if (base == 1) return (" ++ signedType ++ ") 1;" + , " if (base == -1) return ((" ++ unsignedType ++ ") exponent & (" ++ unsignedType ++ ") 1) != 0 ? (" ++ signedType ++ ") -1 : (" ++ signedType ++ ") 1;" + , " return (" ++ signedType ++ ") 0;" + , " }" + , " memcpy(&factor_bits, &base, sizeof factor_bits); power = (" ++ unsignedType ++ ") exponent;" + , " while (power != 0) {" + , " if ((power & (" ++ unsignedType ++ ") 1) != 0) result_bits = (" ++ unsignedType ++ ") ((uint64_t) result_bits * (uint64_t) factor_bits);" + , " power = (" ++ unsignedType ++ ") (power >> 1);" + , " if (power != 0) factor_bits = (" ++ unsignedType ++ ") ((uint64_t) factor_bits * (uint64_t) factor_bits);" + , " }" + , " memcpy(&result, &result_bits, sizeof result); return result;" + , "}" + , "" + ] + where signedType = "SInt" ++ show width + unsignedType = "SWord" ++ show width + helperName = "sbv_integer_pow_s" ++ show width diff --git a/Data/SBV/Compilers/C/PseudoBoolean.hs b/Data/SBV/Compilers/C/PseudoBoolean.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/PseudoBoolean.hs @@ -0,0 +1,58 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.PseudoBoolean +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Overflow-safe pseudo-Boolean comparisons shared by the C backends. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.PseudoBoolean (assignPseudoBoolean) where + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Core.Data (PBOp(..)) + +-- | Assign a pseudo-Boolean comparison to an already declared Boolean result. +-- Use an exact unsigned sum when the maximum possible total fits in 64 bits. +-- Otherwise stop adding after exceeding the bound: non-negative coefficients +-- cannot bring the sum back down. Both the bound and each coefficient fit in +-- a signed 64-bit integer, so every addition to a sum at most the bound fits +-- in uint64_t, even when the mathematical total would require more bits. +-- Retain zero-weight operands so their generated bindings remain referenced. +assignPseudoBoolean :: PBOp -> [Doc] -> Doc -> Doc +assignPseudoBoolean operation arguments result + | length coefficients /= length arguments + = error "SBV->C: Pseudo-Boolean coefficient/argument count mismatch." + | any (\n -> n < 0 || n > 2 ^ (63 :: Int) - 1) (bound : coefficients) + = error "SBV->C: Pseudo-Boolean coefficients and bounds must be non-negative signed 64-bit values." + | sum coefficients <= 2 ^ (64 :: Int) - 1 + = assign (case terms of [] -> unsigned 0; _ -> parens (hsep (punctuate (text " +") terms))) + | True + = text "{" + $$ nest 2 (text "uint64_t sbv_pb_sum = UINT64_C(0);" + $$ vcat [ text "if" P.<> parens (accumulator <+> text "<=" <+> unsigned bound <+> text "&&" <+> parens argument) + $$ nest 2 (accumulator <+> text "+=" <+> unsigned coefficient P.<> semi) + | (coefficient, argument) <- weighted + ] + $$ assign accumulator) + $$ text "}" + where (coefficients, comparison, bound) = case operation of + PB_AtMost k -> (replicate (length arguments) 1, "<=", toInteger k) + PB_AtLeast k -> (replicate (length arguments) 1, ">=", toInteger k) + PB_Exactly k -> (replicate (length arguments) 1, "==", toInteger k) + PB_Le cs k -> (map toInteger cs, "<=", toInteger k) + PB_Ge cs k -> (map toInteger cs, ">=", toInteger k) + PB_Eq cs k -> (map toInteger cs, "==", toInteger k) + + weighted = zip coefficients arguments + accumulator = text "sbv_pb_sum" + unsigned n = text "UINT64_C" P.<> parens (integer n) + assign sumDoc = result <+> text "=" <+> sumDoc <+> text comparison <+> unsigned bound P.<> semi + terms = [parens (argument <+> text "?" <+> unsigned coefficient <+> text ":" <+> unsigned 0) + | (coefficient, argument) <- weighted] diff --git a/Data/SBV/Compilers/C/Real.hs b/Data/SBV/Compilers/C/Real.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Real.hs @@ -0,0 +1,67 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Real +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Safe flooring of native real representations to mapped integers. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Real (mappedRealFloorWidth, mappedRealFloorCall, mappedRealFloorRuntime) where + +import Data.Maybe (mapMaybe) +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.CodeGen (CgConfig(..)) +import Data.SBV.Core.Data + +-- | Identify flooring from an explicitly native real to a mapped integer. +-- Exact GMP representations are handled by their own conversion paths. +mappedRealFloorWidth :: CgConfig -> Op -> Maybe Int +mappedRealFloorWidth cfg (KindCast KReal KUnbounded) + | Just _ <- cgReal cfg = cgInteger cfg +mappedRealFloorWidth _ _ = Nothing + +-- | Call the width-specific helper. Promotion to long double is exact for +-- the native float and double mappings and preserves long-double precision. +mappedRealFloorCall :: Int -> Doc -> Doc +mappedRealFloorCall width value = text (mappedRealFloorName width) P.<> parens value + +-- | Emit the helper only when a program actually floors a mapped real. +-- Reduce the magnitude modulo a power of two before any integer cast. Split +-- 64-bit residues into 32-bit halves so even a binary64 long double never +-- needs to represent UINT64_MAX or a rounded signed upper bound. +-- Non-finite real representations have no mathematical floor and fail fast. +mappedRealFloorRuntime :: CgConfig -> [(SV, SBVExpr)] -> Doc +mappedRealFloorRuntime cfg assignments = case mapMaybe (\(_, SBVApp operation _) -> mappedRealFloorWidth cfg operation) assignments of + [] -> empty + width:_ -> text . unlines $ + [ "/* Floor native reals, then retain the mapped integer's low bits. */" + , "static " ++ signedType ++ " " ++ mappedRealFloorName width ++ "(long double value)" + , "{" + , " if (!isfinite(value)) {" + , " fputs(\"SBV->C: Cannot floor a non-finite mapped SReal to SInteger.\\n\", stderr);" + , " abort();" + , " }" + , " const long double integral = floorl(value);" + , " const long double residue = fmodl(fabsl(integral), 0x1p" ++ show width ++ "L);" + , " const uint64_t high = (uint64_t) (residue / 0x1p32L);" + , " const uint64_t low = (uint64_t) (residue - (long double) high * 0x1p32L);" + , " uint64_t bits = (high << 32) | low;" + , " if (signbit(integral)) bits = UINT64_C(0) - bits;" + , " const " ++ unsignedType ++ " raw = (" ++ unsignedType ++ ") bits;" + , " " ++ signedType ++ " result; memcpy(&result, &raw, sizeof result); return result;" + , "}" + , "" + ] + where signedType = "SInt" ++ show width + unsignedType = "SWord" ++ show width + +-- | Name the private helper by its mapped integer width. +mappedRealFloorName :: Int -> String +mappedRealFloorName width = "sbv_real_floor_to_s" ++ show width diff --git a/Data/SBV/Compilers/C/RegExp.hs b/Data/SBV/Compilers/C/RegExp.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/RegExp.hs @@ -0,0 +1,371 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.RegExp +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Bounded derivative automata for dependency-free, exact C regex operations. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.RegExp (regexExpr) where + +import Control.Monad (foldM, when) +import Control.Monad.State.Strict (StateT, evalStateT, get, put, lift) +import Data.Char (ord) +import Data.List (intercalate) +import Data.Maybe (fromMaybe) +import qualified Data.Map.Strict as Map +import qualified Data.Sequence as Seq +import qualified Data.Set as Set +import Text.PrettyPrint.HughesPJ (Doc, render, text) + +import Data.SBV.Compilers.CodeGen (CgConfig(..)) +import Data.SBV.Compilers.C.Lowering (CLowering(..), CRequirement(..), expressionLowering) +import qualified Data.SBV.Core.Data as S +import Data.SBV.Core.Symbolic (validateRegExp) + +-- | A normalized residual language, caching nullability and tree size so +-- nullable concatenation and budget checks need no uncharged recursive walks. +data Regex = Regex { nullable :: !Bool -- ^ Whether this residual accepts the empty string. + , nodeCount :: !Integer -- ^ Nodes in its normalized expression tree. + , form :: !RegexForm -- ^ Canonical constructor and children. + } + deriving (Eq, Ord) + +-- | Union and intersection operands are sorted and duplicate-free; +-- concatenations are flattened. Complement is relative to the SBV alphabet. +data RegexForm = Empty + | Epsilon + | Character Int Int + | Concatenate [Regex] + | Unite [Regex] + | Intersect [Regex] + | Complement Regex + | Star Regex + deriving (Eq, Ord) + +-- | Per-operation budgets. Work counts visited/constructed nodes and a +-- conservative allowance for normalization and automaton-state comparisons. +data Budget = Budget { configuration :: CgConfig -- ^ User-selected limits for this operation. + , remainingWork :: !Integer -- ^ Work still available before generation fails. + } + +-- | Pure compilation with explicit, recoverable internal budget failures. +type Build = StateT Budget (Either String) + +-- | The empty language. +emptyRegex :: Regex +emptyRegex = Regex False 1 Empty + +-- | The language containing only the empty string. +epsilonRegex :: Regex +epsilonRegex = Regex True 1 Epsilon + +-- | All strings over SBV's character domain. +allRegex :: Regex +allRegex = Regex True 2 (Complement emptyRegex) + +-- | One past the largest SBV character, including numeric surrogate values. +alphabetEnd :: Int +alphabetEnd = 0x30000 + +-- | Turn a compiler-budget failure into the usual generation diagnostic. +runCompiler :: CgConfig -> Build a -> a +runCompiler cfg action + | any (<= 0) [cgRegexMaxStates cfg, cgRegexMaxNodes cfg, cgRegexMaxWork cfg] + = error "SBV->C: Regex compilation is disabled by cgRegexLimits; all three limits must be positive." + | True + = either (error . ("SBV->C: " ++)) id $ evalStateT action (Budget cfg (cgRegexMaxWork cfg)) + +-- | Fail without printing a potentially huge input or derivative expression. +exceeded :: String -> Integer -> Build a +exceeded dimension limit = lift $ Left $ "Regex generation exceeds the " ++ dimension ++ " limit (" ++ show limit + ++ "). Raise cgRegexLimits explicitly to permit more generation work." + +-- | Charge work before performing the associated allocation or traversal. +charge :: Integer -> Build () +charge amount = do + budget <- get + when (amount > remainingWork budget) $ exceeded "work" (cgRegexMaxWork (configuration budget)) + put budget { remainingWork = remainingWork budget - amount } + +-- | Check a normalized expression or bounded expansion before allocating it. +checkNodes :: Integer -> Build () +checkNodes count = do + budget <- get + let limit = cgRegexMaxNodes (configuration budget) + when (count > limit) $ exceeded "expression-node" limit + +-- | Construct a bounded node. Children are shared, not copied; charge the +-- immediate traversal while retaining the full expression-size bound. +node :: Bool -> RegexForm -> [Regex] -> Build Regex +node accepts shape children = do + let count = 1 + sum (map nodeCount children) + checkNodes count + charge (1 + toInteger (length children)) + pure (Regex accepts count shape) + +-- | Traverse a source list without first allocating an unbounded converted +-- list. This also bounds literals and concatenations before normalization. +boundedTraverse :: (a -> Build b) -> [a] -> Build [b] +boundedTraverse convert values = reverse . snd <$> foldM step (0, []) values + where step (count, results) value = do + checkNodes (count + 1) + charge 1 + result <- convert value + pure (count + 1, result : results) + +-- | Flatten an associative operation after charging its input traversal. +flatten :: (RegexForm -> Maybe [Regex]) -> [Regex] -> Build [Regex] +flatten children rs = do + let result = concatMap (\r -> fromMaybe [r] (children (form r))) rs + charge (1 + toInteger (length rs + length result)) + pure result + +-- | Canonicalize a Boolean operation without distributing it over other +-- operators. The comparison allowance is deliberately conservative. +boolean :: Bool -> [Regex] -> Build Regex +boolean intersection rs = do + flat <- flatten children rs + charge (comparisonDepth (length flat) * (1 + sum (map nodeCount flat))) + let absorbing = if intersection then emptyRegex else allRegex + identity = if intersection then allRegex else emptyRegex + members = Set.fromList (filter (/= identity) flat) + opposite r = case form r of + Complement value -> value `Set.member` members + _ -> False + if absorbing `Set.member` members || any opposite members + then pure absorbing + else case Set.toAscList members of + [] -> pure identity + [r] -> pure r + xs -> node (if intersection then all nullable xs else any nullable xs) + (if intersection then Intersect xs else Unite xs) xs + where children (Intersect xs) | intersection = Just xs + children (Unite xs) | not intersection = Just xs + children _ = Nothing + +-- | Flatten concatenation, eliminate epsilon, and propagate the empty language. +concatenate :: [Regex] -> Build Regex +concatenate rs = do + flat <- flatten children rs + if any ((== Empty) . form) flat + then pure emptyRegex + else case filter ((/= Epsilon) . form) flat of + [] -> pure epsilonRegex + [r] -> pure r + xs -> node (all nullable xs) (Concatenate xs) xs + where children (Concatenate xs) = Just xs + children _ = Nothing + +-- | Cancel double complements; no language approximation is performed. +complement :: Regex -> Build Regex +complement r = case form r of + Complement value -> charge 1 >> pure value + _ -> node (not (nullable r)) (Complement r) [r] + +-- | Normalize trivial and nested stars without unrolling any repetition. +star :: Regex -> Build Regex +star r = case form r of + Empty -> pure epsilonRegex + Epsilon -> pure epsilonRegex + Star _ -> pure r + _ -> node True (Star r) [r] + +-- | Translate every SBV regex constructor. Bounded repetitions are expanded +-- only after checking their size; invalid bounds retain the frontend diagnostic. +convertRegex :: S.RegExp -> Build Regex +convertRegex regex = do + charge 1 + result <- case regex of + S.Literal value -> boundedTraverse character value >>= concatenate + S.All -> pure allRegex + S.AllChar -> node False (Character 0 (alphabetEnd - 1)) [] + S.None -> pure emptyRegex + S.Range lo hi -> do + a <- code lo + b <- code hi + if a > b then pure emptyRegex else node False (Character a b) [] + S.Conc rs -> boundedTraverse convertRegex rs >>= concatenate + S.Union rs -> boundedTraverse convertRegex rs >>= boolean False + S.Inter a b -> pair a b >>= boolean True + S.Diff a b -> do + left <- convertRegex a + right <- convertRegex b >>= complement + boolean True [left, right] + S.Comp r -> convertRegex r >>= complement + S.KStar r -> convertRegex r >>= star + S.KPlus r -> do + body <- convertRegex r + rest <- star body + concatenate [body, rest] + S.Opt r -> convertRegex r >>= \body -> boolean False [epsilonRegex, body] + S.Loop lo hi r -> validateRegExp (S.Loop lo hi (S.Literal "")) `seq` repeatRegex lo hi r + S.Power n r -> validateRegExp (S.Power n (S.Literal "")) `seq` repeatRegex n n r + checkNodes (nodeCount result) + pure result + where code c + | ord c < alphabetEnd = pure (ord c) + | True = lift $ Left "Regex character is outside SBV's domain 0..0x2ffff." + + character c = do + value <- code c + node False (Character value value) [] + + pair a b = sequence [convertRegex a, convertRegex b] + + repeatRegex lo hi r = do + checkNodes (1 + toInteger hi) + charge (toInteger hi) + body <- convertRegex r + optional <- boolean False [epsilonRegex, body] + checkNodes (1 + toInteger lo * nodeCount body + toInteger (hi - lo) * nodeCount optional) + concatenate (replicate lo body ++ replicate (hi - lo) optional) + +-- | Compute the left derivative by a single representative character. +-- Nullability of the result states whether the consumed input is accepted. +derivative :: Int -> Regex -> Build Regex +derivative c regex = do + charge 1 + case form regex of + Empty -> pure emptyRegex + Epsilon -> pure emptyRegex + Character lo hi -> pure $ if lo <= c && c <= hi then epsilonRegex else emptyRegex + Unite rs -> mapM (derivative c) rs >>= boolean False + Intersect rs -> mapM (derivative c) rs >>= boolean True + Complement r -> derivative c r >>= complement + Star r -> derivative c r >>= \first -> concatenate [first, regex] + Concatenate [] -> pure emptyRegex + Concatenate (r:rs) -> do + first <- derivative c r >>= \value -> concatenate (value : rs) + if nullable r + then do rest <- concatenate rs >>= derivative c + boolean False [first, rest] + else pure first + +-- | Partition the complete character domain at every literal/range boundary. +-- Derivatives cannot introduce new boundaries, so representatives are exact. +alphabet :: [Regex] -> Build [(Int, Int)] +alphabet regexes = do + cuts <- foldM visit (Set.fromList [0, alphabetEnd]) regexes + let points = Set.toAscList cuts + pure [(lo, end - 1) | (lo, end) <- zip points (drop 1 points)] + where visit cuts r = do + charge 1 + case form r of + Character lo hi -> pure $ Set.insert lo (Set.insert (hi + 1) cuts) + Concatenate rs -> foldM visit cuts rs + Unite rs -> foldM visit cuts rs + Intersect rs -> foldM visit cuts rs + Complement x -> visit cuts x + Star x -> visit cuts x + _ -> pure cuts + +-- | A complete automaton or an early language-inequality witness. An accepting +-- state in a membership automaton is not itself an inequality witness. +data Exploration = CompleteAutomaton [(Bool, [Int])] -- ^ All reachable states and transitions. + | InequalityWitness -- ^ A reachable pair differs in acceptance. + +-- | Explore states breadth-first, assigning deterministic integer indices. +-- Language comparison stops at the first accepting product state (a witness +-- of inequality); membership builds all reachable rows. State limits apply +-- before insertion, including to pairs explored for language comparison. +explore :: Ord a => Bool -> (a -> Bool) -> (a -> Integer) -> (Int -> a -> Build a) + -> [(Int, Int)] -> a -> Build Exploration +explore stop accepts size step classes initial = go (Map.singleton initial 0) (Seq.singleton initial) [] + where go known pending rows = case Seq.viewl pending of + Seq.EmptyL -> pure (CompleteAutomaton (reverse rows)) + r Seq.:< rest -> do + charge 1 + if stop && accepts r + then pure InequalityWitness + else do + (known', pending', reversed) <- foldM (transition r) (known, rest, []) classes + go known' pending' ((accepts r, reverse reversed) : rows) + + transition r (known, pending, indices) (c, _) = do + next <- step c r + charge (comparisonDepth (Map.size known) * size next) + case Map.lookup next known of + Just index -> pure (known, pending, index : indices) + Nothing -> do + budget <- get + let index = Map.size known + limit = cgRegexMaxStates (configuration budget) + when (toInteger index >= limit) $ exceeded "state" limit + pure (Map.insert next index known, pending Seq.|> next, index : indices) + +-- | Conservative logarithmic comparison allowance for balanced maps and sets. +comparisonDepth :: Int -> Integer +comparisonDepth count + | count <= 1 = 1 + | True = 1 + comparisonDepth (count `quot` 2) + +-- | Compile exact membership into function-local static tables and a guarded +-- loop. Locally scoped names work unchanged in definitions, callbacks, and +-- library components; dead operations are never compiled by the scheduler. +regexExpr :: CgConfig -> S.Op -> S.SV -> [Doc] -> Maybe CLowering +regexExpr cfg (S.StrOp (S.StrInRe regex)) result [value] = Just $ runCompiler cfg $ do + initial <- convertRegex regex + classes <- alphabet [initial] + automaton <- explore False nullable nodeCount derivative classes initial + case automaton of + CompleteAutomaton rows -> pure $ membership result value classes rows + InequalityWitness -> lift $ Left "Unexpected inequality witness during regex membership compilation." +regexExpr cfg (S.RegExOp operation) _ [] = Just $ runCompiler cfg $ do + let (left, right, negateResult) = case operation of + S.RegExEq a b -> (a, b, False) + S.RegExNEq a b -> (a, b, True) + a <- convertRegex left + b <- convertRegex right + classes <- alphabet [a, b] + comparison <- explore True (\(x, y) -> nullable x /= nullable y) (\(x, y) -> nodeCount x + nodeCount y) + (\c (x, y) -> (,) <$> derivative c x <*> derivative c y) classes (a, b) + let equal = case comparison of + CompleteAutomaton{} -> True + InequalityWitness -> False + pure $ expressionLowering [] (text (if equal /= negateResult then "true" else "false")) +regexExpr _ _ _ _ = Nothing + +-- | Render an allocation-free matcher over canonical SBV text, preserving +-- embedded NULs and surrogate character codes. Use compact transition entries +-- when all actual state indices fit, falling back to size_t for larger custom +-- budgets. Input size is independent of the generation budgets. +membership :: S.SV -> Doc -> [(Int, Int)] -> [(Bool, [Int])] -> CLowering +membership result value classes rows = (expressionLowering [CRequiresText] (text answer)) + { loweringDeclarations = map text + [ "static const uint32_t " ++ bounds ++ "[] = {" ++ intercalate ", " (map (show . snd) classes) ++ "};" + , "static const uint8_t " ++ accepting ++ "[] = {" ++ intercalate ", " [if yes then "1" else "0" | (yes, _) <- rows] ++ "};" + , "static const " ++ transitionType ++ " " ++ transitions ++ "[][" ++ show (length classes) ++ "] = {\n" + ++ intercalate ",\n" [" {" ++ intercalate ", " (map show indices) ++ "}" | (_, indices) <- rows] ++ "\n};" + , "SBool " ++ answer ++ ";" + ] + , loweringSetup = [text $ unlines + [ "{" + , " const SString input = " ++ render value ++ ";" + , " size_t state = 0;" + , " for (size_t offset = 0; offset < input.byte_length;) {" + , " const SChar character = sbv_text_decode(input.data + offset);" + , " if (character > UINT32_C(0x2ffff)) abort();" + , " offset += sbv_text_width(input.data[offset]);" + , " size_t column = 0;" + , " while (column + 1 < " ++ show (length classes) ++ " && character > " ++ bounds ++ "[column]) ++column;" + , " state = " ++ transitions ++ "[state][column];" + , " }" + , " " ++ answer ++ " = " ++ accepting ++ "[state];" + , "}" + ]] + } + where prefix = "sbv_regex_" ++ show result + transitionType | stateCount <= 65536 = "uint16_t" + | stateCount <= 4294967296 = "uint32_t" + | True = "size_t" + stateCount = toInteger (length rows) + answer = prefix ++ "_result" + bounds = prefix ++ "_bounds" + accepting = prefix ++ "_accept" + transitions = prefix ++ "_step" diff --git a/Data/SBV/Compilers/C/Set.hs b/Data/SBV/Compilers/C/Set.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Set.hs @@ -0,0 +1,584 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Set +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Finite and cofinite symbolic-set lowering for generated C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Set + ( setKinds + , setSupported + , setUsesExact + , setNeedsDriverInit + , setCType + , setForwardTypeDecls + , setTypeDecls + , setOwnershipTypeDecls + , setRuntimeDecls + , setRuntime + , setConst + , setExpr + , setEqual + , setNormalize + , setClone + , setRelease + , setDriverValue + , setDriverInit + , setDriverClear + , setPrint + , setContextStart + , setContextEnd + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.List (nub, stripPrefix, tails) +import qualified Data.Set as Set + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Arena (CArena(..), arenaRuntime) +import Data.SBV.Compilers.C.Finite (finiteDomainSize) +import Data.SBV.Compilers.C.GMP (gmpFunctionName, gmpInitializeCopy, gmpOutputType, isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Types (isConcreteADT, elementCType, kindTag, setCloneName, setReleaseName, setHelperName) +import Data.SBV.Compilers.C.Value ( byValueEqual + , managedValueClone + , managedValueRelease + , valueDriverClear + , valueDriverInit + , valueDriverNeedsInitialization + , valueNeedsOwnership + ) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds) +import Data.SBV.Core.Symbolic (SetOp(..)) + +-- | Return all distinct symbolic-set kinds used by a program. +setKinds :: Set.Set Kind -> [Kind] +setKinds = nub . concatMap (filter isSet . expandKinds) . Set.toAscList + +-- | Test whether a set element kind has a supported C representation. +setSupported :: CgConfig -> Kind -> Bool +setSupported _ (KSet elementKind) = supportedElement elementKind + where supportedElement KBool = True + supportedElement KBounded{} = True + supportedElement KFloat = True + supportedElement KDouble = True + supportedElement KChar = True + supportedElement KString = True + supportedElement KFP{} = True + supportedElement KUnbounded = True + supportedElement KReal = True + supportedElement KRational = True + supportedElement (KList kind) = supportedElement kind + supportedElement (KTuple kinds) = all supportedElement kinds + supportedElement kind + | isConcreteADT kind = True + | True = isRoundingMode kind +setSupported _ _ = False + +-- | Test whether a set stores exact GMP-backed elements. +setUsesExact :: CgConfig -> Kind -> Bool +setUsesExact cfg (KSet elementKind) = isExactGMPKind cfg elementKind +setUsesExact _ _ = False + +-- | Test whether an example-driver set requires statement-based element +-- initialization instead of a single compound literal. +setNeedsDriverInit :: CgConfig -> Kind -> Bool +setNeedsDriverInit cfg (KSet elementKind) = valueDriverNeedsInitialization cfg elementKind +setNeedsDriverInit _ _ = False + +-- | Return the public C descriptor type for a symbolic-set kind. +setCType :: Kind -> String +setCType kind@KSet{} = elementCType kind +setCType kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Emit guarded forward declarations for symbolic-set descriptor types. +-- These declarations allow set and list descriptors to contain pointers to +-- each other before either family has emitted its complete layouts. +setForwardTypeDecls :: [Kind] -> Doc +setForwardTypeDecls [] = empty +setForwardTypeDecls kinds = text . unlines $ concatMap declaration kinds + where declaration kind@KSet{} = + [ "#ifndef " ++ setForwardGuard kind + , "#define " ++ setForwardGuard kind + , "typedef struct " ++ setCType kind ++ " " ++ setCType kind ++ ";" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Emit finite/cofinite set descriptors and ownership-helper prototypes. +-- Aggregate element layouts may remain incomplete here; helper definitions +-- are emitted later by 'setOwnershipTypeDecls'. +setTypeDecls :: CgConfig -> [Kind] -> Doc +setTypeDecls cfg kinds + | null kinds = empty + | True = setForwardTypeDecls kinds $$ text (unlines $ + ["/* Finite/cofinite symbolic sets. Inputs borrow elements; outputs and returns own them. */" + , cUnusedAttribute + ] + ++ concatMap declaration kinds + ) + where declaration kind@(KSet elementKind) + | setSupported cfg kind + = let cType = setCType kind + elementType = setElementCType elementKind + cloneName = setCloneName kind + releaseName = setReleaseName kind + in [ "#ifndef " ++ setGuard kind + , "#define " ++ setGuard kind + , "struct " ++ cType ++ " { const " ++ elementType ++ " *data; size_t length; bool is_complement; };" + , "static inline SBV_CGEN_UNUSED " ++ cType ++ " " ++ cloneName ++ "(" ++ cType ++ " value);" + , "static inline SBV_CGEN_UNUSED void " ++ releaseName ++ "(" ++ cType ++ " *value);" + , "#endif" + , "" + ] + | True + = error $ "SBV->C: Unsupported set element kind: " ++ show elementKind + declaration kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Emit set clone and release definitions after aggregate element layouts +-- are complete. Inputs borrow arrays that may contain duplicates; outputs and +-- returns own their cloned arrays. +setOwnershipTypeDecls :: CgConfig -> [Kind] -> Doc +setOwnershipTypeDecls cfg kinds + | null kinds = empty + | True = text . unlines $ concatMap declaration kinds + where declaration kind@(KSet elementKind) + | setSupported cfg kind + = let cType = setCType kind + elementType = setElementCType elementKind + cloneName = setCloneName kind + releaseName = setReleaseName kind + in [ "#ifndef " ++ setOwnershipGuard kind + , "#define " ++ setOwnershipGuard kind + , "static inline SBV_CGEN_UNUSED " ++ cType ++ " " ++ cloneName ++ "(" ++ cType ++ " value)" + , "{" + , " " ++ elementType ++ " *copy = NULL;" + , " if (value.length != 0) {" + , " if (value.length > SIZE_MAX / sizeof(*copy)) abort();" + , " copy = (" ++ elementType ++ " *) malloc(value.length * sizeof(*copy));" + , " if (copy == NULL) abort();" + ] + ++ cloneElements elementKind + ++ [ " }" + , " return (" ++ cType ++ ") {copy, value.length, value.is_complement};" + , "}" + , "static inline SBV_CGEN_UNUSED void " ++ releaseName ++ "(" ++ cType ++ " *value)" + , "{" + , " if (value == NULL) return;" + ] + ++ releaseElements elementKind + ++ [ " *value = (" ++ cType ++ ") {NULL, 0, false};" + , "}" + , "#endif" + , "" + ] + | True + = error $ "SBV->C: Unsupported set element kind: " ++ show elementKind + declaration kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + + cloneElements elementKind + | isExactGMPKind cfg elementKind + = [ " for (size_t i = 0; i < value.length; ++i) {" + , " " ++ gmpOutputType elementKind ++ " element = (" ++ gmpOutputType elementKind ++ ") malloc(sizeof(*element));" + , " if (element == NULL) abort();" + ] + ++ map (" " ++) (lines (render (gmpInitializeCopy elementKind (text "element") (text "value.data[i]")))) + ++ [ " copy[i] = element;" + , " }" + ] + | isConcreteADT elementKind || valueNeedsOwnership cfg elementKind + = [ " for (size_t i = 0; i < value.length; ++i)" + , " copy[i] = " ++ render (managedValueClone elementKind (text "value.data[i]")) ++ ";" + ] + | True + = [" memcpy(copy, value.data, value.length * sizeof(*copy));"] + + releaseElements elementKind + | isExactGMPKind cfg elementKind + = [ " " ++ setElementCType elementKind ++ " *data = (" ++ setElementCType elementKind ++ " *) value->data;" + , " for (size_t i = 0; i < value->length; ++i) {" + , " " ++ gmpOutputType elementKind ++ " element = (" ++ gmpOutputType elementKind ++ ") data[i];" + , " if (element != NULL) { " ++ gmpFunctionName elementKind "clear" ++ "(element); free(element); }" + , " }" + , " free(data);" + ] + | isConcreteADT elementKind || valueNeedsOwnership cfg elementKind + = [ " " ++ setElementCType elementKind ++ " *data = (" ++ setElementCType elementKind ++ " *) value->data;" + , " for (size_t i = 0; i < value->length; ++i)" + , " " ++ render (managedValueRelease elementKind (text "&data[i]")) + , " free(data);" + ] + | True + = [" free((void *) value->data);"] + +-- | Emit forward declarations for set equality helpers referenced by nested +-- aggregate element comparisons. +setRuntimeDecls :: CgConfig -> [Kind] -> Doc +setRuntimeDecls cfg kinds = text . unlines $ + [ "static SBV_CGEN_UNUSED bool " ++ helperName kind "equal" ++ "(" ++ setCType kind ++ " left, " ++ setCType kind ++ " right);" + | kind <- kinds + , setSupported cfg kind + ] + +-- | Emit the shared set arena and one operation family per element kind. +setRuntime :: CgConfig -> (Kind -> [[Kind]]) -> [Kind] -> Doc +setRuntime cfg constructorsOf kinds = text . unlines . map markUnused $ commonRuntime ++ concatMap specializedRuntime kinds + where markUnused line = case stripPrefix "static " line of + Just rest -> "static SBV_CGEN_UNUSED " ++ rest + Nothing -> line + + specializedRuntime kind + | setSupported cfg kind = setKindRuntime cfg constructorsOf kind + | True = error $ "SBV->C: Unsupported set kind: " ++ show kind + +-- | Render a regular or complemented set constant. +setConst :: (CV -> Doc) -> CV -> Maybe Doc +setConst renderElement (CV kind@(KSet elementKind) (CSet value)) + = Just $ text "((" P.<> text (setCType kind) P.<> text ") {" + P.<> elements + P.<> text ", " + P.<> int (length values) + P.<> text ", " + P.<> text (if isComplement then "true" else "false") + P.<> text "})" + where (isComplement, stored) = case value of + RegularSet entries -> (False, entries) + ComplementSet entries -> (True, entries) + values = Set.toAscList stored + elements + | null values = text "NULL" + | True = text "(const" <+> text (setElementCType elementKind) P.<> text "[]) {" + P.<> fsep (punctuate comma (map (renderElement . CV elementKind) values)) + P.<> text "}" +setConst _ _ = Nothing + +-- | Lower symbolic set construction, membership, comparison, and algebra. +setExpr :: CgConfig -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +setExpr cfg op svs resultKind args + | not touchesSet = Nothing + | True = case (op, args) of + (ADTOp{} , _ ) -> Nothing + (TupleConstructor{} , _ ) -> Nothing + (TupleAccess{} , _ ) -> Nothing + (Uninterpreted{} , _ ) -> Nothing + (Label _ , [a] ) -> lower a + (Equal _ , [a, b] ) -> lower $ call (helper "equal") [a, b] + (NotEqual , as ) -> lower $ distinctSets as + (SetOp SetEqual , [a, b] ) -> lower $ call (helper "equal") [a, b] + (SetOp SetMember , [e, s] ) -> lower $ call (helper "member") [e, s] + (SetOp SetInsert , [e, s] ) -> lower $ arenaCall "insert" [e, s] + (SetOp SetDelete , [e, s] ) -> lower $ arenaCall "delete" [e, s] + (SetOp SetIntersect , [a, b] ) -> lower $ arenaCall "intersection" [a, b] + (SetOp SetUnion , [a, b] ) -> lower $ arenaCall "union" [a, b] + (SetOp SetSubset , [a, b] ) -> lower $ call (helper "subset") [a, b] + (SetOp SetDifference , [a, b] ) -> lower $ arenaCall "difference" [a, b] + (SetOp SetComplement , [a] ) -> lower $ call (helper "complement") [a] + _ -> unsupported + where touchesSet = isSet resultKind || any (isSet . kindOf) svs || isSetOp op + + setKind = case [kind | value <- resultKind : map kindOf svs, kind@(KSet _) <- [value]] of + kind : _ -> kind + [] -> error $ "SBV->C: Cannot determine set kind for " ++ show op + + lower expression = Just $ expressionLowering requirements expression + + requirements = CRequiresSets : [CRequiresGMP | any (isExactGMPKind cfg) touchedKinds] + + touchedKinds = concatMap expandKinds (resultKind : map kindOf svs) + + helper = helperName setKind + + arenaCall suffix rendered = call (helper suffix) (text "&sbv_local_set_ctx" : rendered) + + distinctSets rendered = fsep $ punctuate (text " &&") + [parens (text "!" P.<> call (helper "equal") [left, right]) + | left : rest <- tails rendered, right <- rest] + + unsupported = error $ "SBV->C: Set lowering does not support " ++ show op + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + +-- | Compare two set descriptors using finite/cofinite symbolic-set equality. +setEqual :: Kind -> Doc -> Doc -> Doc +setEqual kind left right = call (helperName kind "equal") [left, right] + +-- | Normalize a borrowed set descriptor into the generated function's arena. +setNormalize :: Kind -> Doc -> Doc +setNormalize kind value = call (helperName kind "normalize") [text "&sbv_local_set_ctx", value] + +-- | Deep-copy a set across the generated function's ownership boundary. +setClone :: Kind -> Doc -> Doc +setClone kind value = call (setCloneName kind) [value] + +-- | Release an owned set in a generated driver. +setRelease :: Kind -> Doc -> Doc +setRelease kind value = call (setReleaseName kind) [text "&" P.<> value] P.<> semi + +-- | Produce a deterministic three-element finite or cofinite driver value. +setDriverValue :: (Kind -> Integer -> Doc) -> Kind -> Integer -> Doc +setDriverValue renderValue kind@(KSet elementKind) seed + = text "((" P.<> text (setCType kind) P.<> text ") {" + P.<> text "(const" <+> text (setElementCType elementKind) P.<> text "[]) {" + P.<> fsep (punctuate comma [renderValue elementKind seed, renderValue elementKind (seed + 1), renderValue elementKind (seed + 2)]) + P.<> text "}, 3, " + P.<> text (if odd seed then "true" else "false") + P.<> text "})" +setDriverValue _ kind _ = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Initialize a generated-driver set whose elements require statement-based +-- setup. The descriptor borrows three independently initialized elements and +-- uses the sample seed's parity to choose a finite or cofinite representation. +-- The supplied statement renderer handles retained aggregate elements. +setDriverInit :: CgConfig -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> String -> Integer -> Doc +setDriverInit cfg renderValue initializeValue kind@KSet{} externalName seed = valueDriverInit cfg renderValue initializeValue kind externalName seed +setDriverInit _ _ _ kind _ _ = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Clear managed element storage initialized by 'setDriverInit'. +setDriverClear :: CgConfig -> Kind -> String -> Doc +setDriverClear cfg kind@KSet{} externalName = valueDriverClear cfg kind externalName +setDriverClear _ kind _ = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Print a finite set as @{...}@ and a cofinite set as @U - {...}@. +setPrint :: (Kind -> Doc -> Doc) -> Kind -> Doc -> Doc +setPrint printElement (KSet elementKind) value + = text "if" P.<> parens (value P.<> text ".is_complement") <+> text "printf(\"U\");" + $$ text "if" P.<> parens (text "!" P.<> value P.<> text ".is_complement ||" <+> value P.<> text ".length != 0") + $$ text "{" + $$ nest 2 ( text "if" P.<> parens (value P.<> text ".is_complement") <+> text "printf(\" - \");" + $$ text "printf(\"{\");" + $$ text "for (size_t" <+> index <+> text "= 0;" <+> index <+> text "<" <+> value P.<> text ".length; ++" P.<> index P.<> text ")" + $$ text "{" + $$ nest 2 ( text "if" <+> parens (index <+> text "!= 0") <+> text "printf(\", \");" + $$ printElement elementKind (value P.<> text ".data[" P.<> index P.<> text "]") + ) + $$ text "}" + $$ text "printf(\"}\");" + ) + $$ text "}" + where index = text ("sbv_local_set_print_index_" ++ kindTag elementKind) +setPrint _ kind _ = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Initialize the arena used by set temporaries in a generated function. +setContextStart :: Doc +setContextStart = text "sbv_set_ctx sbv_local_set_ctx = {NULL};" + +-- | Release all set temporaries allocated by a generated function. +setContextEnd :: Doc +setContextEnd = call "sbv_set_ctx_end" [text "&sbv_local_set_ctx"] P.<> semi + +-- | Test whether an operation belongs to the symbolic-set family. +isSetOp :: Op -> Bool +isSetOp SetOp{} = True +isSetOp _ = False + +-- | Return the element kind of a symbolic-set kind. +setElementKind :: Kind -> Kind +setElementKind (KSet elementKind) = elementKind +setElementKind kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Return the public C type used for one supported set element. +setElementCType :: Kind -> String +setElementCType KChar = "SChar" +setElementCType kind = elementCType kind + +-- | Return the preprocessor guard for one set forward declaration. +setForwardGuard :: Kind -> String +setForwardGuard kind = "SBV_SET_" ++ kindTag (setElementKind kind) ++ "_FORWARD_DEFINED" + +-- | Return the preprocessor guard for one set descriptor. +setGuard :: Kind -> String +setGuard kind = "SBV_SET_" ++ kindTag (setElementKind kind) ++ "_DEFINED" + +-- | Return the preprocessor guard for one set ownership-helper definition. +setOwnershipGuard :: Kind -> String +setOwnershipGuard kind = "SBV_SET_" ++ kindTag (setElementKind kind) ++ "_OWNERSHIP_DEFINED" + +-- | Return one specialized set-operation helper name. +helperName :: Kind -> String -> String +helperName = setHelperName + +-- | Render a C helper call. +call :: String -> [Doc] -> Doc +call functionName args = text functionName P.<> parens (fsep (punctuate comma args)) + +-- | Shared per-call allocation arena used by every set specialization. +commonRuntime :: [String] +commonRuntime = arenaRuntime SetArena + +-- | Emit all set helpers for one supported element kind. +setKindRuntime :: CgConfig -> (Kind -> [[Kind]]) -> Kind -> [String] +setKindRuntime cfg constructorsOf kind@(KSet elementKind) = + [ "" + , "static bool " ++ equalElement ++ "(" ++ elementType ++ " left, " ++ elementType ++ " right)" + , "{ return " ++ elementEqual ++ "; }" + , "static bool " ++ helper "stored_contains" ++ "(" ++ setType ++ " value, " ++ elementType ++ " element)" + , "{" + , " for (size_t i = 0; i < value.length; ++i) if (" ++ equalElement ++ "(value.data[i], element)) return true;" + , " return false;" + , "}" + , "static " ++ setType ++ " " ++ helper "normalize" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " value)" + , "{" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, value.length, sizeof(*data));" + , " " ++ setType ++ " result = (" ++ setType ++ ") {data, 0, value.is_complement};" + , " for (size_t i = 0; i < value.length; ++i) if (!" ++ helper "stored_contains" ++ "(result, value.data[i])) data[result.length++] = value.data[i];" + , " return result;" + , "}" + , "static bool " ++ helper "stored_subset" ++ "(" ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " for (size_t i = 0; i < left.length; ++i) if (!" ++ helper "stored_contains" ++ "(right, left.data[i])) return false;" + , " return true;" + , "}" + , "static bool " ++ helper "stored_disjoint" ++ "(" ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " for (size_t i = 0; i < left.length; ++i) if (" ++ helper "stored_contains" ++ "(right, left.data[i])) return false;" + , " return true;" + , "}" + ] + ++ storedRuntime + ++ domainRuntime + ++ [ "static bool " ++ helper "equal" ++ "(" ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " if (left.is_complement == right.is_complement) return " ++ helper "stored_subset" ++ "(left, right) && " ++ helper "stored_subset" ++ "(right, left);" + , " return " ++ helper "stored_disjoint" ++ "(left, right) && " ++ helper "domain_covered" ++ "(left, right);" + , "}" + , "static bool " ++ helper "member" ++ "(" ++ elementType ++ " element, " ++ setType ++ " value)" + , "{ return value.is_complement != " ++ helper "stored_contains" ++ "(value, element); }" + , "static " ++ setType ++ " " ++ helper "insert" ++ "(sbv_set_ctx *ctx, " ++ elementType ++ " element, " ++ setType ++ " value)" + , "{" + , " const bool stored = " ++ helper "stored_contains" ++ "(value, element);" + , " if ((!value.is_complement && stored) || (value.is_complement && !stored)) return value;" + , " if (value.is_complement) return " ++ helper "stored_remove" ++ "(ctx, value, element, true);" + , " return " ++ helper "stored_add" ++ "(ctx, value, element, false);" + , "}" + , "static " ++ setType ++ " " ++ helper "delete" ++ "(sbv_set_ctx *ctx, " ++ elementType ++ " element, " ++ setType ++ " value)" + , "{" + , " const bool stored = " ++ helper "stored_contains" ++ "(value, element);" + , " if ((!value.is_complement && !stored) || (value.is_complement && stored)) return value;" + , " if (value.is_complement) return " ++ helper "stored_add" ++ "(ctx, value, element, true);" + , " return " ++ helper "stored_remove" ++ "(ctx, value, element, false);" + , "}" + , "static " ++ setType ++ " " ++ helper "union" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " if (!left.is_complement && !right.is_complement) return " ++ helper "stored_union" ++ "(ctx, left, right, false);" + , " if (!left.is_complement && right.is_complement) return " ++ helper "stored_difference" ++ "(ctx, right, left, true);" + , " if ( left.is_complement && !right.is_complement) return " ++ helper "stored_difference" ++ "(ctx, left, right, true);" + , " return " ++ helper "stored_intersection" ++ "(ctx, left, right, true);" + , "}" + , "static " ++ setType ++ " " ++ helper "intersection" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " if (!left.is_complement && !right.is_complement) return " ++ helper "stored_intersection" ++ "(ctx, left, right, false);" + , " if (!left.is_complement && right.is_complement) return " ++ helper "stored_difference" ++ "(ctx, left, right, false);" + , " if ( left.is_complement && !right.is_complement) return " ++ helper "stored_difference" ++ "(ctx, right, left, false);" + , " return " ++ helper "stored_union" ++ "(ctx, left, right, true);" + , "}" + , "static " ++ setType ++ " " ++ helper "difference" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " if (!left.is_complement && !right.is_complement) return " ++ helper "stored_difference" ++ "(ctx, left, right, false);" + , " if (!left.is_complement && right.is_complement) return " ++ helper "stored_intersection" ++ "(ctx, left, right, false);" + , " if ( left.is_complement && !right.is_complement) return " ++ helper "stored_union" ++ "(ctx, left, right, true);" + , " return " ++ helper "stored_difference" ++ "(ctx, right, left, false);" + , "}" + , "static " ++ setType ++ " " ++ helper "complement" ++ "(" ++ setType ++ " value)" + , "{ value.is_complement = !value.is_complement; return value; }" + , "static bool " ++ helper "subset" ++ "(" ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + , " if (!left.is_complement && !right.is_complement) return " ++ helper "stored_subset" ++ "(left, right);" + , " if (!left.is_complement && right.is_complement) return " ++ helper "stored_disjoint" ++ "(left, right);" + , " if ( left.is_complement && !right.is_complement) return " ++ helper "domain_covered" ++ "(left, right);" + , " return " ++ helper "stored_subset" ++ "(right, left);" + , "}" + ] + where setType = setCType kind + elementType = setElementCType elementKind + helper = helperName kind + equalElement = helper "element_equal" + + elementEqual = render $ byValueEqual cfg True elementKind (text "left") (text "right") + + domainRuntime = + [ "static bool " ++ helper "domain_covered" ++ "(" ++ setType ++ " left, " ++ setType ++ " right)" + , "{" + ] + ++ case elementDomainSize constructorsOf elementKind of + Nothing -> [ " (void) left; (void) right; return false;" ] + Just domainSize -> + [ " const uint64_t domain_size = UINT64_C(" ++ show domainSize ++ ");" + , " if (domain_size > (uint64_t) SIZE_MAX) return false;" + , " size_t covered = 0;" + , " for (size_t i = 0; i < left.length; ++i) {" + , " bool duplicate = false;" + , " for (size_t j = 0; j < i; ++j) if (" ++ equalElement ++ "(left.data[i], left.data[j])) { duplicate = true; break; }" + , " if (!duplicate) ++covered;" + , " }" + , " for (size_t i = 0; i < right.length; ++i) {" + , " bool duplicate = " ++ helper "stored_contains" ++ "(left, right.data[i]);" + , " for (size_t j = 0; !duplicate && j < i; ++j) duplicate = " ++ equalElement ++ "(right.data[i], right.data[j]);" + , " if (!duplicate) ++covered;" + , " }" + , " return (uint64_t) covered == domain_size;" + ] + ++ [ "}" ] + + storedRuntime = + [ "static " ++ setType ++ " " ++ helper "stored_add" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " value, " ++ elementType ++ " element, bool is_complement)" + , "{" + , " if (value.length == SIZE_MAX) abort();" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, value.length + 1, sizeof(*data));" + , " if (value.length != 0) memcpy(data, value.data, value.length * sizeof(*data));" + , " data[value.length] = element; return (" ++ setType ++ ") {data, value.length + 1, is_complement};" + , "}" + , "static " ++ setType ++ " " ++ helper "stored_remove" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " value, " ++ elementType ++ " element, bool is_complement)" + , "{" + , " size_t length = 0;" + , " for (size_t i = 0; i < value.length; ++i) if (!" ++ equalElement ++ "(value.data[i], element)) ++length;" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, length, sizeof(*data));" + , " size_t output = 0;" + , " for (size_t i = 0; i < value.length; ++i) if (!" ++ equalElement ++ "(value.data[i], element)) data[output++] = value.data[i];" + , " return (" ++ setType ++ ") {data, length, is_complement};" + , "}" + , "static " ++ setType ++ " " ++ helper "stored_union" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right, bool is_complement)" + , "{" + , " if (right.length > SIZE_MAX - left.length) abort();" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, left.length + right.length, sizeof(*data));" + , " " ++ setType ++ " result = (" ++ setType ++ ") {data, 0, is_complement};" + , " for (size_t i = 0; i < left.length; ++i) data[result.length++] = left.data[i];" + , " for (size_t i = 0; i < right.length; ++i) if (!" ++ helper "stored_contains" ++ "(result, right.data[i])) data[result.length++] = right.data[i];" + , " return result;" + , "}" + , "static " ++ setType ++ " " ++ helper "stored_intersection" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right, bool is_complement)" + , "{" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, left.length, sizeof(*data));" + , " " ++ setType ++ " result = (" ++ setType ++ ") {data, 0, is_complement};" + , " for (size_t i = 0; i < left.length; ++i) if (" ++ helper "stored_contains" ++ "(right, left.data[i])) data[result.length++] = left.data[i];" + , " return result;" + , "}" + , "static " ++ setType ++ " " ++ helper "stored_difference" ++ "(sbv_set_ctx *ctx, " ++ setType ++ " left, " ++ setType ++ " right, bool is_complement)" + , "{" + , " " ++ elementType ++ " *data = (" ++ elementType ++ " *) sbv_set_alloc(ctx, left.length, sizeof(*data));" + , " " ++ setType ++ " result = (" ++ setType ++ ") {data, 0, is_complement};" + , " for (size_t i = 0; i < left.length; ++i) if (!" ++ helper "stored_contains" ++ "(right, left.data[i])) data[result.length++] = left.data[i];" + , " return result;" + , "}" + ] +setKindRuntime _ _ kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + + +-- | Return the number of distinct SMT objects when the domain cardinality fits +-- in a C @uint64_t@. The callback supplies resolved ADT constructor fields, +-- allowing finite sums of products without importing the ADT lowering module. +-- Recursive domains and domains too large for a descriptor return 'Nothing'. +elementDomainSize :: (Kind -> [[Kind]]) -> Kind -> Maybe Integer +elementDomainSize constructorsOf kind = do + total <- finiteDomainSize constructorsOf kind + if total <= 2 ^ (64 :: Int) - 1 then Just total else Nothing diff --git a/Data/SBV/Compilers/C/Syntax.hs b/Data/SBV/Compilers/C/Syntax.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Syntax.hs @@ -0,0 +1,63 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Syntax +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Safe rendering of diagnostic text in generated C source. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Syntax (cCommentText, cStringLiteral, cUnusedAttribute) where + +import qualified Data.ByteString as BS +import Data.Char (chr, isControl, ord) +import Data.List (intercalate) +import qualified Data.Text as T +import qualified Data.Text.Encoding as TE +import Numeric (showOct) +import Text.PrettyPrint.HughesPJ (Doc, doubleQuotes, text) + +-- | Shared portability preamble for helpers unused by a particular program. +cUnusedAttribute :: String +cUnusedAttribute = intercalate "\n" + [ "#ifndef SBV_CGEN_UNUSED" + , "#if defined(__GNUC__) || defined(__clang__)" + , "#define SBV_CGEN_UNUSED __attribute__((unused))" + , "#else" + , "#define SBV_CGEN_UNUSED" + , "#endif" + , "#endif" + ] + +-- | Render comment contents without allowing comment delimiters, line splices, +-- trigraphs, or embedded control characters to affect the surrounding C source. +-- Octal spellings here are readable text, not escapes interpreted by C comments. +cCommentText :: String -> Doc +cCommentText = text . protect + where protect [] = [] + protect ('*':'/':rest) = "\\052/" ++ protect rest + protect ('/':'*':rest) = "/\\052" ++ protect rest + protect ('?':'?':rest) = "\\077" ++ protect ('?' : rest) + protect (c:rest) = escape c ++ protect rest + escape '\\' = "\\134" + escape '\n' = "\n" + escape '\t' = "\t" + escape c + | isControl c = '\\' : showOct (ord c) "" + | True = [c] + +-- | Render arbitrary text as a UTF-8 C string literal, using fixed-width +-- octal escapes where a byte cannot safely appear verbatim. +cStringLiteral :: String -> Doc +cStringLiteral = doubleQuotes . text . concatMap escapeByte . BS.unpack . TE.encodeUtf8 . T.pack + where escapeByte byte + | byte == 34 = "\\\"" + | byte == 63 = "\\?" + | byte == 92 = "\\\\" + | 32 <= byte, byte <= 126 = [chr (fromIntegral byte)] + | True = '\\' : replicate (3 - length octal) '0' ++ octal + where octal = showOct byte "" diff --git a/Data/SBV/Compilers/C/Table.hs b/Data/SBV/Compilers/C/Table.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Table.hs @@ -0,0 +1,135 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Table +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Lowering of finite SBV lookup tables to C arrays. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Table + ( tableExpr + , tableIndexAndBounds + , tableMustBeLocal + , tableNeedsBounds + ) where + +import Data.SBV.Compilers.C.Types (isConcreteADT) +import qualified Data.Set as Set + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Array (arrayStoredLoad, arrayStoredValue) +import Data.SBV.Compilers.C.BV (isWideBV, wideBVLookupIndex, wideBVLookupInRange) +import Data.SBV.Compilers.C.GMP (isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering(..), CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Value (valueNeedsOwnership) +import Data.SBV.Compilers.CodeGen (CgConfig(..)) +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds) + +-- | Lower a finite SBV table lookup. Bounds are checked when requested by the +-- code-generation configuration (always before wide/exact index narrowing), +-- and the default value is returned for every checked out-of-range index. +-- Only the integral index kinds accepted by SBV's +-- 'Data.SBV.select' operation can reach this function. +tableExpr :: CgConfig -> (SV -> Doc) -> Op -> SV -> Maybe CLowering +tableExpr cfg renderSV (LkUp (tableId, indexKind, _, tableLength) index defaultValue) resultSV + | isArray resultKind + = let lowering = arrayStoredLoad resultSV selectedValue + in Just lowering {loweringRequirements = Set.fromList requirements} + | True + = Just $ expressionLowering requirements selectedValue + where renderedIndex = renderSV index + renderedDefault = arrayStoredValue resultKind (renderSV defaultValue) + lookupValue = text "table" P.<> int tableId P.<> brackets nativeIndex + selectedValue = case outOfRange of + Just check | tableNeedsBounds cfg indexKind -> check <+> text "?" <+> renderedDefault <+> text ":" <+> lookupValue + _ -> lookupValue + + resultKind = kindOf resultSV + + requirements = [CRequiresGMP | any (isExactGMPKind cfg) touchedKinds] + ++ [CRequiresWideBV | any isWideBV touchedKinds] + ++ [CRequiresLibBF | any isFP touchedKinds] + ++ [CRequiresLibM | any isFP touchedKinds] + ++ [CRequiresText | any (`elem` [KChar, KString]) touchedKinds] + ++ [CRequiresLists | any isList touchedKinds] + ++ [CRequiresSets | any isSet touchedKinds] + ++ [CRequiresArrays | any isArray touchedKinds] + + touchedKinds = concatMap expandKinds [indexKind, resultKind] + + (nativeIndex, outOfRange) = tableIndexAndBounds cfg indexKind tableLength renderedIndex +tableExpr _ _ _ _ = Nothing + +-- | Representation-changing index conversions must preserve out-of-range +-- values even when optional native-index checks are disabled. +tableNeedsBounds :: CgConfig -> Kind -> Bool +tableNeedsBounds cfg kind = cgRTC cfg || isWideBV kind || isExactGMPKind cfg kind + +-- | Render a machine index together with its exact out-of-range predicate. +-- Check the original value before narrowing a wide bit-vector or GMP integer; +-- otherwise a large index could alias an in-range table entry. +tableIndexAndBounds :: CgConfig -> Kind -> Int -> Doc -> (Doc, Maybe Doc) +tableIndexAndBounds cfg indexKind tableLength renderedIndex = (nativeIndex, outOfRange) + where nativeIndex + | isWideBV indexKind = wideBVLookupIndex indexKind renderedIndex + | isExactGMPKind cfg indexKind = namedCall "mpz_get_ui" [renderedIndex] + | True = renderedIndex + + outOfRange + | isWideBV indexKind + = Just $ text "!" P.<> parens (wideBVLookupInRange indexKind tableLength renderedIndex) + | isExactGMPKind cfg indexKind + = Just $ text "!" P.<> parens ( namedCall "mpz_sgn" [renderedIndex] <+> text ">= 0" + <+> text "&&" + <+> namedCall "mpz_cmp_ui" [renderedIndex, int tableLength] <+> text "< 0" + ) + | KBool <- indexKind + = if maximumIndex indexKind >= fromIntegral tableLength + then Just $ renderedIndex <+> text ">=" <+> int tableLength + else Nothing + | isBounded indexKind + = case (hasSign indexKind, maximumIndex indexKind >= fromIntegral tableLength) of + (True, True) -> Just . parens $ renderedIndex <+> text "< 0" + <+> text "||" + <+> renderedIndex <+> text ">=" <+> int tableLength + (True, False) -> Just $ renderedIndex <+> text "< 0" + (False, True) -> Just $ renderedIndex <+> text ">=" <+> int tableLength + (False, False) -> Nothing + | KUnbounded <- indexKind + = case cgInteger cfg of + Nothing -> error "SBV->C: Internal error: exact SInteger table index escaped GMP lowering." + Just width -> case maximumSignedIndex width >= fromIntegral tableLength of + True -> Just . parens $ renderedIndex <+> text "< 0" + <+> text "||" + <+> renderedIndex <+> text ">=" <+> int tableLength + False -> Just $ renderedIndex <+> text "< 0" + | True + = error $ "SBV->C: Unsupported table index kind: " ++ show indexKind + + maximumIndex :: Kind -> Integer + maximumIndex KBool = 1 + maximumIndex kind + | hasSign kind = maximumSignedIndex (intSizeOf kind) + | True = 2 ^ intSizeOf kind - 1 + + maximumSignedIndex :: Int -> Integer + maximumSignedIndex width = 2 ^ (width - 1) - 1 + + namedCall functionName args = text functionName P.<> parens (fsep (punctuate comma args)) + +-- | Test whether a table declaration must be emitted inside the generated +-- function. Exact GMP values use the function's ownership arena, while +-- managed descriptors point at compound-literal backing storage that is not +-- a portable static C initializer. ADTs are conservatively local because +-- their concrete ownership graph is resolved by the ADT lowering phase. +tableMustBeLocal :: CgConfig -> Kind -> Bool +tableMustBeLocal cfg = any mustBeLocal . expandKinds + where mustBeLocal kind = isExactGMPKind cfg kind || valueNeedsOwnership cfg kind || isConcreteADT kind diff --git a/Data/SBV/Compilers/C/Text.hs b/Data/SBV/Compilers/C/Text.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Text.hs @@ -0,0 +1,580 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Text +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Length-aware character and string lowering for generated C. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Text + ( textTypeDecls + , textRuntime + , textConst + , textExpr + , textPrint + , textClone + , textRelease + , textDriverValue + , textContextStart + , textContextEnd + ) where + +import Data.SBV.Compilers.C.Syntax (cUnusedAttribute) +import Data.Bits ((.&.), (.|.), shiftR) +import Data.Char (chr, ord) +import Data.List (intercalate, stripPrefix, tails) +import qualified Data.Set as Set +import Numeric (showHex) + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Arena (CArena(..), arenaRuntime) +import Data.SBV.Compilers.C.GMP (isExactGMPKind) +import Data.SBV.Compilers.C.Lowering (CLowering, CRequirement(..), expressionLowering) +import Data.SBV.Compilers.C.Types (textCloneName, textReleaseName, textCompareName) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data + +-- | Declare the public character and string C types. String inputs borrow +-- their bytes for the duration of a generated call; returned and output +-- strings own their bytes and must be released with @sbv_string_release@. +textTypeDecls :: Set.Set Kind -> Doc +textTypeDecls kinds + | not usesText = empty + | True = text . unlines $ + ["/* Characters and length-aware UTF-8-compatible strings. */" + , "/* SString inputs borrow their bytes for the duration of a generated call. */" + , "/* SString outputs and returns own their bytes; release them with sbv_string_release. */" + , "/* sbv_string_borrow preserves embedded NULs; sbv_string_borrow_utf8 is for NUL-terminated input. */" + , "/* Borrowed text must use the canonical encoding below and character codes must be at most 0x2ffff. */" + , "#ifndef SBV_TEXT_TYPES_DEFINED" + , "#define SBV_TEXT_TYPES_DEFINED" + , "#include " + , cUnusedAttribute + , "typedef uint32_t SChar;" + , "typedef struct {" + , " const uint8_t *data;" + , " size_t byte_length;" + , " size_t length;" + , "} SString;" + , "" + , "static inline SString sbv_string_borrow(const uint8_t *data, size_t byte_length, size_t length)" + , "{" + , " const SString result = {data, byte_length, length};" + , " return result;" + , "}" + , "" + , "static inline SString sbv_string_borrow_utf8(const char *value)" + , "{" + , " const size_t byte_length = value == NULL ? 0 : strlen(value);" + , " size_t length = 0;" + , " for (size_t i = 0; i < byte_length; ++i)" + , " if ((((const uint8_t *) value)[i] & UINT8_C(0xc0)) != UINT8_C(0x80)) ++length;" + , " return sbv_string_borrow((const uint8_t *) value, byte_length, length);" + , "}" + , "" + , "static inline SString " ++ textCloneName ++ "(SString value)" + , "{" + , " uint8_t *copy = NULL;" + , " if (value.byte_length != 0) {" + , " copy = (uint8_t *) malloc(value.byte_length);" + , " if (copy == NULL) abort();" + , " memcpy(copy, value.data, value.byte_length);" + , " }" + , " return sbv_string_borrow(copy, value.byte_length, value.length);" + , "}" + , "" + , "static inline void " ++ textReleaseName ++ "(SString *value)" + , "{" + , " if (value == NULL) return;" + , " free((void *) value->data);" + , " *value = sbv_string_borrow(NULL, 0, 0);" + , "}" + , "" + , "static inline void sbv_string_fprint(FILE *stream, SString value)" + , "{" + , " if (value.byte_length != 0) (void) fwrite(value.data, 1, value.byte_length, stream);" + , "}" + , "" + , "static inline size_t sbv_char_encode(SChar value, uint8_t bytes[4])" + , "{" + , " if (value > UINT32_C(0x2ffff)) abort();" + , " if (value <= UINT32_C(0x7f)) { bytes[0] = (uint8_t) value; return 1; }" + , " if (value <= UINT32_C(0x7ff)) {" + , " bytes[0] = (uint8_t) (UINT32_C(0xc0) | (value >> 6));" + , " bytes[1] = (uint8_t) (UINT32_C(0x80) | (value & UINT32_C(0x3f)));" + , " return 2;" + , " }" + , " if (value <= UINT32_C(0xffff)) {" + , " bytes[0] = (uint8_t) (UINT32_C(0xe0) | (value >> 12));" + , " bytes[1] = (uint8_t) (UINT32_C(0x80) | ((value >> 6) & UINT32_C(0x3f)));" + , " bytes[2] = (uint8_t) (UINT32_C(0x80) | (value & UINT32_C(0x3f)));" + , " return 3;" + , " }" + , " bytes[0] = (uint8_t) (UINT32_C(0xf0) | (value >> 18));" + , " bytes[1] = (uint8_t) (UINT32_C(0x80) | ((value >> 12) & UINT32_C(0x3f)));" + , " bytes[2] = (uint8_t) (UINT32_C(0x80) | ((value >> 6) & UINT32_C(0x3f)));" + , " bytes[3] = (uint8_t) (UINT32_C(0x80) | (value & UINT32_C(0x3f)));" + , " return 4;" + , "}" + , "" + , "static inline void sbv_char_fprint(FILE *stream, SChar value)" + , "{" + , " uint8_t bytes[4];" + , " const size_t count = sbv_char_encode(value, bytes);" + , " (void) fwrite(bytes, 1, count, stream);" + , "}" + , "#endif" + , "" + ] + where usesText = KString `Set.member` kinds || KChar `Set.member` kinds + +-- | Emit the per-call text arena and the helpers used by string operations. +textRuntime :: CgConfig -> Bool -> Doc +textRuntime cfg usesExactInteger = text . unlines . map markUnused $ + commonRuntime + ++ nativeIntegerRuntime + ++ if usesExactInteger then exactIntegerRuntime else [] + where markUnused line = case stripPrefix "static " line of + Just rest -> "static SBV_CGEN_UNUSED " ++ rest + Nothing -> line + + nativeIntegerRuntime + | isExactGMPKind cfg KUnbounded = [] + | True = nativeIntegerHelpers + +-- | Render a character or string constant without relying on C string +-- escaping, so embedded NULs and arbitrary character codes are preserved. +textConst :: CV -> Maybe Doc +textConst (CV KChar (CChar value)) + | ord value > 0x2ffff = error $ "SBV->C: Character literal exceeds the SMT-LIB maximum: " ++ show value + | True = Just $ text (charLiteral value) +textConst (CV KString (CString value)) + | any ((> 0x2ffff) . ord) value = error "SBV->C: String literal contains a character exceeding the SMT-LIB maximum" + | True = Just $ text "((SString) {" + P.<> dataBytes + P.<> text ", " + P.<> integer (fromIntegral (length bytes)) + P.<> text ", " + P.<> integer (fromIntegral (length value)) + P.<> text "})" + where bytes = concatMap encodeChar value + dataBytes + | null bytes = text "NULL" + | True = text "(const uint8_t[]) {" P.<> text (intercalate ", " (map byteLiteral bytes)) P.<> text "}" +textConst _ = Nothing + +-- | Lower character and string operations. Sequence operations are accepted +-- here only when their element kind is 'KChar'; general sequences are handled +-- by the list runtime. +textExpr :: CgConfig -> Op -> [SV] -> Kind -> [Doc] -> Maybe CLowering +textExpr cfg op svs resultKind args + | not touchesText = Nothing + | True = case (op, args) of + (ADTOp{} , _ ) -> Nothing + (Uninterpreted{} , _ ) -> Nothing + (Label _ , [a] ) -> lower a + (Equal _ , [a, b] ) -> lower $ equal a b + (NotEqual , as ) -> lower $ distinctText as + (LessThan , [a, b] ) -> lower $ ordered "<" a b + (GreaterThan , [a, b] ) -> lower $ ordered ">" a b + (LessEq , [a, b] ) -> lower $ ordered "<=" a b + (GreaterEq , [a, b] ) -> lower $ ordered ">=" a b + (SeqOp (SeqLen KChar) , [a] ) -> lowerInteger False $ text "sbv_text_length" P.<> parens a + (SeqOp (SeqConcat KChar) , as ) -> lower $ foldText "sbv_text_concat" as + (SeqOp (SeqNth KChar) , [a, i] ) -> lower $ indexed "sbv_text_nth" [a] i + (SeqOp (SeqUnit KChar) , [a] ) -> lower $ call "sbv_text_unit" [text "&sbv_local_text_ctx", a] + (SeqOp (SeqSubseq KChar) , [a, i, n]) -> lower $ indexed2 "sbv_text_substring" a i n + (SeqOp (SeqIndexOf KChar) , [a, b, i]) -> lowerInteger True $ indexed "sbv_text_index_of" [a, b] i + (SeqOp (SeqContains KChar) , [a, b] ) -> lower $ call "sbv_text_contains" [a, b] + (SeqOp (SeqPrefixOf KChar) , [a, b] ) -> lower $ call "sbv_text_prefix_of" [a, b] + (SeqOp (SeqSuffixOf KChar) , [a, b] ) -> lower $ call "sbv_text_suffix_of" [a, b] + (SeqOp (SeqReplace KChar) , [a, b, c]) -> lower $ call "sbv_text_replace" [text "&sbv_local_text_ctx", a, b, c] + (StrOp StrToCode , [a] ) -> lowerInteger False a + (StrOp StrFromCode , [a] ) -> lower $ fromCode a + (StrOp StrStrToNat , [a] ) -> lowerNat a + (StrOp StrNatToStr , [a] ) -> lower $ fromNat a + (StrOp StrInRe{} , _ ) -> Nothing + (TupleConstructor{} , _ ) -> Nothing + (TupleAccess{} , _ ) -> Nothing + _ -> unsupported (show op) + where touchesText = resultKind `elem` [KChar, KString] + || any ((`elem` [KChar, KString]) . kindOf) svs + || isTextOp op + + lower expression = Just $ expressionLowering [CRequiresText] expression + + lowerNat value + | isExactGMPKind cfg resultKind + = Just $ expressionLowering [CRequiresText, CRequiresGMP] (toNat value) + | True + = lower $ parens (text "SInteger") <+> toNat value + + lowerInteger signed expression + | isExactGMPKind cfg resultKind + = Just $ expressionLowering [CRequiresText, CRequiresGMP] + $ call (if signed then "sbv_gmp_integer_from_s64" else "sbv_gmp_integer_from_u64") + [text "&sbv_local_gmp_ctx", expression] + | True + = lower $ parens (text "SInteger") <+> expression + + usesString = any ((== KString) . kindOf) svs + + equal a b + | usesString = parens $ call textCompareName [a, b] <+> text "== 0" + | True = a <+> text "==" <+> b + + ordered relation a b + | usesString = parens $ call textCompareName [a, b] <+> text relation <+> text "0" + | True = a <+> text relation <+> b + + distinctText as = fsep $ punctuate (text " &&") + [parens (if usesString + then call textCompareName [a, b] <+> text "!= 0" + else a <+> text "!=" <+> b) + | (a:rest) <- tails as, b <- rest] + + foldText _ [] = text "((SString) {NULL, 0, 0})" + foldText _ [a] = a + foldText helper (a:as) = foldl (\left right -> call helper [text "&sbv_local_text_ctx", left, right]) a as + + indexed helper prefix index + | exactIndex = call (helper ++ "_mpz") (prefix ++ [index]) + | True = call helper (prefix ++ [parens (text "int64_t") <+> index]) + + indexed2 helper value offset count + | exactIndex = call (helper ++ "_mpz") [text "&sbv_local_text_ctx", value, offset, count] + | True = call helper [text "&sbv_local_text_ctx", value, parens (text "int64_t") <+> offset, parens (text "int64_t") <+> count] + + exactIndex = any (isExactGMPKind cfg . kindOf) svs + + fromCode value + | exactIndex = call "sbv_text_from_code_mpz" [value] + | True = call "sbv_text_from_code" [parens (text "int64_t") <+> value] + + toNat value + | isExactGMPKind cfg resultKind + = call "sbv_text_to_nat_mpz" [text "&sbv_local_gmp_ctx", text "&sbv_local_text_ctx", value] + | True + = call "sbv_text_to_nat" [value] + + fromNat value + | exactIndex = call "sbv_text_from_nat_mpz" [text "&sbv_local_text_ctx", value] + | True = call "sbv_text_from_nat" [text "&sbv_local_text_ctx", parens (text "int64_t") <+> value] + + unsupported what = error $ "SBV->C: text lowering does not yet support " ++ what + ++ " with argument kinds " ++ show (map kindOf svs) + ++ " and result kind " ++ show resultKind + +-- | Print a generated character or string value to standard output. +textPrint :: Kind -> Doc -> Doc +textPrint KChar value = call "sbv_char_fprint" [text "stdout", value] +textPrint KString value = call "sbv_string_fprint" [text "stdout", value] +textPrint kind _ = error $ "SBV->C: Expected a text kind, received " ++ show kind + +-- | Deep-copy a string across the generated function's ownership boundary. +textClone :: Doc -> Doc +textClone value = call textCloneName [value] + +-- | Release an owned string in a generated driver. +textRelease :: Doc -> Doc +textRelease value = call textReleaseName [text "&" P.<> value] P.<> semi + +-- | Produce a deterministic printable driver value for a character or string. +textDriverValue :: Kind -> Integer -> Doc +textDriverValue KChar seed = text $ charLiteral $ chr $ 32 + fromInteger (abs seed `mod` 95) +textDriverValue KString seed = case textConst (CV KString (CString ("sbv" ++ show (abs seed `mod` 1000)))) of + Just value -> value + Nothing -> error "SBV->C: Impossible string driver value" +textDriverValue kind _ = error $ "SBV->C: Expected a text kind, received " ++ show kind + +-- | Initialize the arena used by string temporaries in a generated function. +textContextStart :: Doc +textContextStart = text "sbv_text_ctx sbv_local_text_ctx = {NULL};" + +-- | Release all string temporaries allocated by a generated function. +textContextEnd :: Doc +textContextEnd = call "sbv_text_ctx_end" [text "&sbv_local_text_ctx"] P.<> semi + +-- | Test whether an operation belongs to the string/character family even +-- when neither its result nor all of its operands have a text kind. +isTextOp :: Op -> Bool +isTextOp StrOp{} = True +isTextOp (SeqOp (SeqLen KChar)) = True +isTextOp (SeqOp (SeqConcat KChar)) = True +isTextOp (SeqOp (SeqNth KChar)) = True +isTextOp (SeqOp (SeqUnit KChar)) = True +isTextOp (SeqOp (SeqSubseq KChar)) = True +isTextOp (SeqOp (SeqIndexOf KChar)) = True +isTextOp (SeqOp (SeqContains KChar)) = True +isTextOp (SeqOp (SeqPrefixOf KChar)) = True +isTextOp (SeqOp (SeqSuffixOf KChar)) = True +isTextOp (SeqOp (SeqReplace KChar)) = True +isTextOp _ = False + +-- | Render a portable numeric C character literal. +charLiteral :: Char -> String +charLiteral value = "UINT32_C(0x" ++ replicate (8 - length rendered) '0' ++ rendered ++ ")" + where rendered = showHex (ord value) "" + +-- | Encode one Haskell character with the canonical one-to-four-byte scheme +-- used by the generated runtime. Numeric surrogate values are preserved. +encodeChar :: Char -> [Int] +encodeChar value + | code <= 0x7f = [code] + | code <= 0x7ff = [0xc0 .|. (code `shiftR` 6), 0x80 .|. (code .&. 0x3f)] + | code <= 0xffff = [ 0xe0 .|. (code `shiftR` 12) + , 0x80 .|. ((code `shiftR` 6) .&. 0x3f) + , 0x80 .|. (code .&. 0x3f) + ] + | True = [ 0xf0 .|. (code `shiftR` 18) + , 0x80 .|. ((code `shiftR` 12) .&. 0x3f) + , 0x80 .|. ((code `shiftR` 6) .&. 0x3f) + , 0x80 .|. (code .&. 0x3f) + ] + where code = ord value + +-- | Render one encoded byte as a fixed-width portable C literal. +byteLiteral :: Int -> String +byteLiteral value = "UINT8_C(0x" ++ replicate (2 - length rendered) '0' ++ rendered ++ ")" + where rendered = showHex value "" + +-- | Render a C helper call. +call :: String -> [Doc] -> Doc +call functionName args = text functionName P.<> parens (fsep (punctuate comma args)) + +-- | Runtime helpers shared by mapped and exact integer configurations. +commonRuntime :: [String] +commonRuntime = arenaRuntime TextArena ++ + [ "" + , "static size_t sbv_text_width(uint8_t first)" + , "{" + , " if (first < UINT8_C(0x80)) return 1;" + , " if (first < UINT8_C(0xe0)) return 2;" + , " if (first < UINT8_C(0xf0)) return 3;" + , " return 4;" + , "}" + , "" + , "static size_t sbv_text_byte_offset(SString value, size_t index)" + , "{" + , " size_t byte = 0;" + , " for (size_t character = 0; character < index && byte < value.byte_length; ++character)" + , " byte += sbv_text_width(value.data[byte]);" + , " return byte;" + , "}" + , "" + , "static SChar sbv_text_decode(const uint8_t *bytes)" + , "{" + , " const size_t width = sbv_text_width(bytes[0]);" + , " if (width == 1) return bytes[0];" + , " SChar result = bytes[0] & (width == 2 ? UINT8_C(0x1f) : width == 3 ? UINT8_C(0x0f) : UINT8_C(0x07));" + , " for (size_t i = 1; i < width; ++i) result = (result << 6) | (bytes[i] & UINT8_C(0x3f));" + , " return result;" + , "}" + , "" + , "static uint64_t sbv_text_length(SString value) { return (uint64_t) value.length; }" + , "" + , "static int " ++ textCompareName ++ "(SString left, SString right)" + , "{" + , " const size_t common = left.byte_length < right.byte_length ? left.byte_length : right.byte_length;" + , " const int prefix = common == 0 ? 0 : memcmp(left.data, right.data, common);" + , " if (prefix != 0) return prefix;" + , " return left.byte_length < right.byte_length ? -1 : left.byte_length > right.byte_length ? 1 : 0;" + , "}" + , "" + , "static SString sbv_text_concat(sbv_text_ctx *ctx, SString left, SString right)" + , "{" + , " if (SIZE_MAX - left.byte_length < right.byte_length || SIZE_MAX - left.length < right.length) abort();" + , " if (left.byte_length == 0) return right;" + , " if (right.byte_length == 0) return left;" + , " const size_t byte_length = left.byte_length + right.byte_length;" + , " uint8_t *data = sbv_text_alloc(ctx, byte_length);" + , " memcpy(data, left.data, left.byte_length);" + , " memcpy(data + left.byte_length, right.data, right.byte_length);" + , " return sbv_string_borrow(data, byte_length, left.length + right.length);" + , "}" + , "" + , "static SString sbv_text_unit(sbv_text_ctx *ctx, SChar value)" + , "{" + , " uint8_t encoded[4];" + , " const size_t count = sbv_char_encode(value, encoded);" + , " uint8_t *data = sbv_text_alloc(ctx, count); memcpy(data, encoded, count);" + , " return sbv_string_borrow(data, count, 1);" + , "}" + , "" + , "static SChar sbv_text_nth(SString value, int64_t index)" + , "{" + , " if (index < 0 || (uint64_t) index >= value.length) return UINT32_C(0);" + , " return sbv_text_decode(value.data + sbv_text_byte_offset(value, (size_t) index));" + , "}" + , "" + , "static SString sbv_text_substring_size(sbv_text_ctx *ctx, SString value, size_t offset, size_t count)" + , "{" + , " if (offset >= value.length || count == 0) return sbv_string_borrow(NULL, 0, 0);" + , " if (count > value.length - offset) count = value.length - offset;" + , " const size_t first = sbv_text_byte_offset(value, offset);" + , " const size_t last = sbv_text_byte_offset(value, offset + count);" + , " uint8_t *data = sbv_text_alloc(ctx, last - first); memcpy(data, value.data + first, last - first);" + , " return sbv_string_borrow(data, last - first, count);" + , "}" + , "" + , "static SString sbv_text_substring(sbv_text_ctx *ctx, SString value, int64_t offset, int64_t count)" + , "{" + , " if (offset < 0 || count <= 0) return sbv_string_borrow(NULL, 0, 0);" + , " return sbv_text_substring_size(ctx, value, (size_t) offset, (size_t) count);" + , "}" + , "" + , "static bool sbv_text_prefix_of(SString prefix, SString value)" + , "{" + , " return prefix.byte_length <= value.byte_length" + , " && (prefix.byte_length == 0 || memcmp(prefix.data, value.data, prefix.byte_length) == 0);" + , "}" + , "" + , "static bool sbv_text_suffix_of(SString suffix, SString value)" + , "{" + , " return suffix.byte_length <= value.byte_length" + , " && (suffix.byte_length == 0 || memcmp(suffix.data, value.data + value.byte_length - suffix.byte_length, suffix.byte_length) == 0);" + , "}" + , "" + , "static bool sbv_text_contains(SString value, SString part)" + , "{" + , " if (part.byte_length == 0) return true;" + , " if (part.byte_length > value.byte_length) return false;" + , " for (size_t offset = 0; offset + part.byte_length <= value.byte_length; offset += sbv_text_width(value.data[offset]))" + , " if (memcmp(value.data + offset, part.data, part.byte_length) == 0) return true;" + , " return false;" + , "}" + , "" + , "static int64_t sbv_text_index_of_size(SString value, SString part, size_t start)" + , "{" + , " if (start > value.length) return -1;" + , " if (part.byte_length == 0) return start <= INT64_MAX ? (int64_t) start : -1;" + , " if (part.byte_length > value.byte_length) return -1;" + , " size_t character = start;" + , " for (size_t byte = sbv_text_byte_offset(value, start); byte + part.byte_length <= value.byte_length; ++character) {" + , " if (memcmp(value.data + byte, part.data, part.byte_length) == 0) return character <= INT64_MAX ? (int64_t) character : -1;" + , " byte += sbv_text_width(value.data[byte]);" + , " }" + , " return -1;" + , "}" + , "" + , "static int64_t sbv_text_index_of(SString value, SString part, int64_t start)" + , "{" + , " return start < 0 ? -1 : sbv_text_index_of_size(value, part, (size_t) start);" + , "}" + , "" + , "static SString sbv_text_replace(sbv_text_ctx *ctx, SString value, SString source, SString replacement)" + , "{" + , " const int64_t index = sbv_text_index_of_size(value, source, 0);" + , " if (index < 0) return value;" + , " const size_t first = sbv_text_byte_offset(value, (size_t) index);" + , " const size_t after = first + source.byte_length;" + , " const size_t retained = value.byte_length - source.byte_length;" + , " if (replacement.byte_length > SIZE_MAX - retained) abort();" + , " const size_t byte_length = retained + replacement.byte_length;" + , " uint8_t *data = sbv_text_alloc(ctx, byte_length);" + , " if (first != 0) memcpy(data, value.data, first);" + , " if (replacement.byte_length != 0) memcpy(data + first, replacement.data, replacement.byte_length);" + , " if (after != value.byte_length) memcpy(data + first + replacement.byte_length, value.data + after, value.byte_length - after);" + , " return sbv_string_borrow(data, byte_length, value.length - source.length + replacement.length);" + , "}" + , "" + , "static SChar sbv_text_from_code(int64_t value)" + , "{" + , " if (value < 0 || value > INT64_C(0x2ffff)) abort();" + , " return (SChar) value;" + , "}" + ] + +-- | Runtime helpers used when 'SInteger' has a native lossy mapping. +nativeIntegerHelpers :: [String] +nativeIntegerHelpers = + ["" + , "static int64_t sbv_text_to_nat(SString value)" + , "{" + , " if (value.byte_length == 0) return -1;" + , " uint64_t result = 0;" + , " for (size_t i = 0; i < value.byte_length; ++i) {" + , " if (value.data[i] < UINT8_C(0x30) || value.data[i] > UINT8_C(0x39)) return -1;" + , " result = result * UINT64_C(10) + (value.data[i] - UINT8_C(0x30));" + , " }" + , " return (int64_t) result;" + , "}" + , "" + , "static SString sbv_text_from_nat(sbv_text_ctx *ctx, int64_t value)" + , "{" + , " if (value < 0) return sbv_string_borrow(NULL, 0, 0);" + , " char buffer[32];" + , " const int count = snprintf(buffer, sizeof buffer, \"%\" PRIu64, (uint64_t) value);" + , " uint8_t *data = sbv_text_alloc(ctx, (size_t) count); memcpy(data, buffer, (size_t) count);" + , " return sbv_string_borrow(data, (size_t) count, (size_t) count);" + , "}" + ] + +-- | Runtime adapters used when 'SInteger' retains its exact GMP mapping. +exactIntegerRuntime :: [String] +exactIntegerRuntime = + ["" + , "static bool sbv_text_mpz_to_size(SInteger value, size_t *result)" + , "{" + , " if (mpz_sgn(value) < 0 || mpz_sizeinbase(value, 2) > sizeof(size_t) * CHAR_BIT) return false;" + , " size_t written = 0; *result = 0;" + , " (void) mpz_export(result, &written, -1, sizeof(*result), 0, 0, value);" + , " return true;" + , "}" + , "" + , "static SChar sbv_text_nth_mpz(SString value, SInteger index)" + , "{" + , " size_t converted;" + , " if (!sbv_text_mpz_to_size(index, &converted) || converted >= value.length) return UINT32_C(0);" + , " return sbv_text_decode(value.data + sbv_text_byte_offset(value, converted));" + , "}" + , "" + , "static SString sbv_text_substring_mpz(sbv_text_ctx *ctx, SString value, SInteger offset, SInteger count)" + , "{" + , " size_t converted_offset, converted_count;" + , " if (!sbv_text_mpz_to_size(offset, &converted_offset) || !sbv_text_mpz_to_size(count, &converted_count))" + , " return sbv_string_borrow(NULL, 0, 0);" + , " return sbv_text_substring_size(ctx, value, converted_offset, converted_count);" + , "}" + , "" + , "static int64_t sbv_text_index_of_mpz(SString value, SString part, SInteger start)" + , "{" + , " size_t converted;" + , " return sbv_text_mpz_to_size(start, &converted) ? sbv_text_index_of_size(value, part, converted) : -1;" + , "}" + , "" + , "static SChar sbv_text_from_code_mpz(SInteger value)" + , "{" + , " if (mpz_sgn(value) < 0 || mpz_cmp_ui(value, 0x2ffffUL) > 0) abort();" + , " return (SChar) mpz_get_ui(value);" + , "}" + , "" + , "static SInteger sbv_text_to_nat_mpz(sbv_gmp_ctx *gmp_ctx, sbv_text_ctx *text_ctx, SString value)" + , "{" + , " if (value.byte_length == 0) return sbv_gmp_integer_from_s64(gmp_ctx, -1);" + , " if (value.byte_length == SIZE_MAX) abort();" + , " for (size_t i = 0; i < value.byte_length; ++i)" + , " if (value.data[i] < UINT8_C(0x30) || value.data[i] > UINT8_C(0x39)) return sbv_gmp_integer_from_s64(gmp_ctx, -1);" + , " char *digits = (char *) sbv_text_alloc(text_ctx, value.byte_length + 1);" + , " memcpy(digits, value.data, value.byte_length); digits[value.byte_length] = '\\0';" + , " return sbv_gmp_integer_const(gmp_ctx, digits);" + , "}" + , "" + , "static SString sbv_text_from_nat_mpz(sbv_text_ctx *ctx, SInteger value)" + , "{" + , " if (mpz_sgn(value) < 0) return sbv_string_borrow(NULL, 0, 0);" + , " const size_t count = mpz_sizeinbase(value, 10);" + , " if (count == SIZE_MAX) abort();" + , " uint8_t *data = sbv_text_alloc(ctx, count + 1);" + , " (void) mpz_get_str((char *) data, 10, value);" + , " const size_t length = strlen((const char *) data);" + , " return sbv_string_borrow(data, length, length);" + , "}" + ] diff --git a/Data/SBV/Compilers/C/Tuple.hs b/Data/SBV/Compilers/C/Tuple.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Tuple.hs @@ -0,0 +1,311 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Tuple +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Structural tuple lowering for the SBV-to-C compiler. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Tuple + ( tupleKinds + , tupleCType + , tupleFieldName + , tupleForwardTypeDecls + , tupleTypeDecls + , tupleOwnershipTypeDecls + , tupleOwnedInitName + , tupleOwnedSetName + , tupleOwnedCloneName + , tupleOwnedReleaseName + , tupleDriverInit + , tupleValue + , tupleConst + , tupleExpr + , tupleUsesExact + , tupleNeedsOwnership + , elementCType + , kindTag + ) where + +import Data.List (nub, sortOn) +import qualified Data.Set as Set + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.Array (arrayStoredLoad, arrayStoredValue) +import Data.SBV.Compilers.C.GMP (gmpFunctionName, gmpOutputType, isExactGMPKind) +import Data.SBV.Compilers.C.List (listClone, listRelease) +import Data.SBV.Compilers.C.Lowering (CLowering, expressionLowering) +import Data.SBV.Compilers.C.Set (setClone, setRelease) +import Data.SBV.Compilers.C.Syntax (cCommentText) +import Data.SBV.Compilers.C.Types ( elementCType, kindTag, tupleCType, tupleFieldName + , tupleOwnedInitName, tupleOwnedSetName, tupleOwnedCloneName, tupleOwnedReleaseName + , textCloneName, textReleaseName + ) +import Data.SBV.Compilers.C.Value (managedValueClone, managedValueRelease, valueDriverInit, valueNeedsOwnership) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data +import Data.SBV.Core.Kind (expandKinds) + +-- | Return the distinct tuple kinds used by a program, with nested tuple +-- declarations ordered before the structures that contain them. +tupleKinds :: Set.Set Kind -> [Kind] +tupleKinds = sortOn tupleDepth . nub . concatMap (filter isTuple . expandKinds) . Set.toAscList + where tupleDepth :: Kind -> Int + tupleDepth (KTuple fields) = 1 + maximum (0 : map tupleDepth fields) + tupleDepth _ = 0 + +-- | Emit forward declarations that permit collection descriptors to refer to +-- tuple element types before their layouts are complete. +tupleForwardTypeDecls :: [Kind] -> Doc +tupleForwardTypeDecls [] = empty +tupleForwardTypeDecls tuples = text . unlines $ "/* Forward declarations for structural tuples. */" : concatMap declaration tuples + where declaration kind@KTuple{} = + [ "#ifndef " ++ tupleForwardGuard kind + , "#define " ++ tupleForwardGuard kind + , "typedef struct " ++ tupleCType kind ++ " " ++ tupleCType kind ++ ";" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Emit public structure definitions for all tuple kinds used by a program. +-- The unit tuple carries a private byte because ISO C does not permit empty +-- structures. Each definition also provides its own guarded forward +-- declaration so this function remains independently usable. +tupleTypeDecls :: [Kind] -> Doc +tupleTypeDecls [] = empty +tupleTypeDecls tuples = text . unlines $ "/* Structural tuple values. */" : concatMap declaration tuples + where declaration kind@(KTuple fields) = + [ "#ifndef " ++ tupleGuard kind + , "#define " ++ tupleGuard kind + , "#ifndef " ++ tupleForwardGuard kind + , "#define " ++ tupleForwardGuard kind + , "typedef struct " ++ tupleCType kind ++ " " ++ tupleCType kind ++ ";" + , "#endif" + , "struct " ++ tupleCType kind ++ " {" + ] + ++ (case fields of + [] -> [" uint8_t unit;"] + _ -> zipWith fieldDeclaration [1 :: Int ..] fields) + ++ [ "};" + , "#endif" + , "" + ] + declaration kind = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + + fieldDeclaration index kind = " " ++ elementCType kind ++ " " ++ tupleFieldName index ++ ";" + +-- | Emit public ownership helpers for tuples containing exact GMP-backed, +-- string, collection, retained-array, or concrete ADT fields. Inputs may +-- borrow an ordinary tuple value. +-- Cloned values own their recursively managed fields and must be released +-- with 'tupleOwnedReleaseName'. +tupleOwnershipTypeDecls :: CgConfig -> [Kind] -> Doc +tupleOwnershipTypeDecls cfg tuples + | null owned = empty + | True = text . unlines $ concatMap declaration owned + where owned = filter (tupleNeedsOwnership cfg) tuples + + declaration kind@(KTuple fields) = + [ "#ifndef " ++ ownershipGuard + , "#define " ++ ownershipGuard + , "/* Recursive ownership helpers for " ++ tupleCType kind ++ ". */" + , "/* Owned values have unique ownership; clone before copying and release every owner. */" + , "static inline SBV_CGEN_UNUSED void " ++ tupleOwnedInitName kind ++ "(" ++ tupleCType kind ++ " *value)" + , "{" + , " if (value == NULL) abort();" + , " memset(value, 0, sizeof *value);" + ] + ++ concat (zipWith initializeField [1 :: Int ..] fields) + ++ [ "}" + , "" + , "static inline SBV_CGEN_UNUSED void " ++ tupleOwnedSetName kind ++ "(" ++ tupleCType kind ++ " *target, " ++ tupleCType kind ++ " source)" + , "{" + ] + ++ concat (zipWith setField [1 :: Int ..] fields) + ++ [ "}" + , "" + , "static inline SBV_CGEN_UNUSED " ++ tupleCType kind ++ " " ++ tupleOwnedCloneName kind ++ "(" ++ tupleCType kind ++ " source)" + , "{" + , " " ++ tupleCType kind ++ " result;" + , " " ++ tupleOwnedInitName kind ++ "(&result);" + , " " ++ tupleOwnedSetName kind ++ "(&result, source);" + , " return result;" + , "}" + , "" + , "static inline SBV_CGEN_UNUSED void " ++ tupleOwnedReleaseName kind ++ "(" ++ tupleCType kind ++ " *value)" + , "{" + , " if (value == NULL) return;" + ] + ++ concat (zipWith releaseField [1 :: Int ..] fields) + ++ [ " memset(value, 0, sizeof *value);" + , "}" + , "#endif" + , "" + ] + where ownershipGuard = tupleCType kind ++ "_OWNERSHIP_DEFINED" + + initializeField index fieldKind + | isExactGMPKind cfg fieldKind + = let access = "value->" ++ tupleFieldName index + mutable = gmpOutputType fieldKind + local = "field" ++ show index + in [ " " ++ mutable ++ " " ++ local ++ " = (" ++ mutable ++ ") malloc(sizeof(*" ++ local ++ "));" + , " if (" ++ local ++ " == NULL) abort();" + , " " ++ gmpFunctionName fieldKind "init" ++ "(" ++ local ++ ");" + , " " ++ access ++ " = " ++ local ++ ";" + ] + | fieldKind == KString + = [" value->" ++ tupleFieldName index ++ " = (SString) {NULL, 0, 0};"] + | isList fieldKind + = [" value->" ++ tupleFieldName index ++ " = (" ++ elementCType fieldKind ++ ") {NULL, 0};"] + | isSet fieldKind + = [" value->" ++ tupleFieldName index ++ " = (" ++ elementCType fieldKind ++ ") {NULL, 0, false};"] + | isArray fieldKind + = [" value->" ++ tupleFieldName index ++ " = NULL;"] + | isTuple fieldKind && tupleNeedsOwnership cfg fieldKind + = [" " ++ tupleOwnedInitName fieldKind ++ "(&value->" ++ tupleFieldName index ++ ");"] + | True + = [] + + setField index fieldKind + | isExactGMPKind cfg fieldKind + = [" " ++ gmpFunctionName fieldKind "set" ++ "((" ++ gmpOutputType fieldKind ++ ") target->" ++ field ++ ", source." ++ field ++ ");"] + | fieldKind == KString + = [ " const SString " ++ field ++ "_copy = " ++ textCloneName ++ "(source." ++ field ++ ");" + , " " ++ textReleaseName ++ "(&target->" ++ field ++ ");" + , " target->" ++ field ++ " = " ++ field ++ "_copy;" + ] + | isList fieldKind + = [ " const " ++ elementCType fieldKind ++ " " ++ field ++ "_copy = " ++ render (listClone fieldKind (text ("source." ++ field))) ++ ";" + , " " ++ render (listRelease fieldKind (text ("target->" ++ field))) + , " target->" ++ field ++ " = " ++ field ++ "_copy;" + ] + | isSet fieldKind + = [ " const " ++ elementCType fieldKind ++ " " ++ field ++ "_copy = " ++ render (setClone fieldKind (text ("source." ++ field))) ++ ";" + , " " ++ render (setRelease fieldKind (text ("target->" ++ field))) + , " target->" ++ field ++ " = " ++ field ++ "_copy;" + ] + | isArray fieldKind + = [ " " ++ elementCType fieldKind ++ " " ++ field ++ "_copy = " ++ render (managedValueClone fieldKind (text ("source." ++ field))) ++ ";" + , " " ++ render (managedValueRelease fieldKind (text ("&target->" ++ field))) + , " target->" ++ field ++ " = " ++ field ++ "_copy;" + ] + | isTuple fieldKind && tupleNeedsOwnership cfg fieldKind + = [" " ++ tupleOwnedSetName fieldKind ++ "(&target->" ++ field ++ ", source." ++ field ++ ");"] + | valueNeedsOwnership cfg fieldKind + = [ " " ++ elementCType fieldKind ++ " " ++ field ++ "_copy = " ++ render (managedValueClone fieldKind (text ("source." ++ field))) ++ ";" + , " " ++ render (managedValueRelease fieldKind (text ("&target->" ++ field))) + , " target->" ++ field ++ " = " ++ field ++ "_copy;" + ] + | True + = [" target->" ++ field ++ " = source." ++ field ++ ";"] + where field = tupleFieldName index + + releaseField index fieldKind + | isExactGMPKind cfg fieldKind + = [ " if (value->" ++ field ++ " != NULL) {" + , " " ++ gmpFunctionName fieldKind "clear" ++ "((" ++ gmpOutputType fieldKind ++ ") value->" ++ field ++ ");" + , " free((void *) value->" ++ field ++ ");" + , " }" + ] + | fieldKind == KString + = [" " ++ textReleaseName ++ "(&value->" ++ field ++ ");"] + | isList fieldKind + = [" " ++ render (listRelease fieldKind (text ("value->" ++ field)))] + | isSet fieldKind + = [" " ++ render (setRelease fieldKind (text ("value->" ++ field)))] + | isArray fieldKind + = [" " ++ render (managedValueRelease fieldKind (text ("&value->" ++ field)))] + | isTuple fieldKind && tupleNeedsOwnership cfg fieldKind + = [" " ++ tupleOwnedReleaseName fieldKind ++ "(&value->" ++ field ++ ");"] + | valueNeedsOwnership cfg fieldKind + = [" " ++ render (managedValueRelease fieldKind (text ("&value->" ++ field)))] + | True + = [] + where field = tupleFieldName index + declaration kind = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Initialize a generated-driver tuple and populate its fields from a seed. +-- Recursively owned fields use the public owned-tuple storage protocol; other +-- fields use the supplied scalar renderer. Array and ADT fields delegate to +-- the supplied statement initializer. +tupleDriverInit :: CgConfig -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> String -> Integer -> Doc +tupleDriverInit cfg renderValue initializeValue kind@KTuple{} externalName seed = valueDriverInit cfg renderValue initializeValue kind externalName seed +tupleDriverInit _ _ _ kind _ _ = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Render a concrete tuple value as a C99 compound literal. +tupleConst :: (CV -> Doc) -> CV -> Maybe Doc +tupleConst renderValue (CV kind@(KTuple fieldKinds) (CTuple fieldValues)) + | length fieldKinds == length fieldValues + = Just $ tupleValue kind (zipWith (\fieldKind fieldValue -> arrayStoredValue fieldKind (renderValue (CV fieldKind fieldValue))) fieldKinds fieldValues) + | True + = error $ "SBV->C: Malformed tuple constant " ++ show (CV kind (CTuple fieldValues)) +tupleConst _ _ = Nothing + +-- | Lower tuple construction, projection, conditionals, and labels. Other +-- operators are left to the scalar pipeline; SBV normally expands structural +-- comparisons into field operations before code generation. +tupleExpr :: Op -> [SV] -> SV -> [Doc] -> Maybe CLowering +tupleExpr op svs resultSV args + | not (isTuple resultKind || any isTuple svs) + = Nothing + | True + = case (op, svs, args) of + (TupleConstructor arity, fields, renderedFields) + | KTuple fieldKinds <- resultKind + , arity == length fieldKinds + , map kindOf fields == fieldKinds + -> lower $ tupleValue resultKind (zipWith arrayStoredValue fieldKinds renderedFields) + (TupleAccess fieldIndex arity, [tupleSV], [renderedTuple]) + | KTuple fieldKinds <- kindOf tupleSV + , arity == length fieldKinds + , fieldIndex >= 1 + , fieldIndex <= arity + , resultKind == fieldKinds !! (fieldIndex - 1) + -> let field = parens renderedTuple P.<> text "." P.<> text (tupleFieldName fieldIndex) + in if isArray resultKind then Just (arrayStoredLoad resultSV field) else lower field + (Label label, [_], [renderedTuple]) + -> lower $ renderedTuple <+> text "/*" <+> cCommentText label <+> text "*/" + _ -> Nothing + where resultKind = kindOf resultSV + + lower = Just . expressionLowering [] + +-- | Test whether a tuple contains an exact GMP-backed integer, real, or +-- rational at any nesting depth under the active code-generation configuration. +tupleUsesExact :: CgConfig -> Kind -> Bool +tupleUsesExact cfg kind@KTuple{} = any (isExactGMPKind cfg) (expandKinds kind) +tupleUsesExact _ _ = False + +-- | Test whether a tuple contains a field that must be cloned when it crosses +-- the generated function's ownership boundary. +tupleNeedsOwnership :: CgConfig -> Kind -> Bool +tupleNeedsOwnership cfg kind@KTuple{} = valueNeedsOwnership cfg kind +tupleNeedsOwnership _ _ = False + +-- | Render a tuple expression from its field expressions. +tupleValue :: Kind -> [Doc] -> Doc +tupleValue kind@(KTuple []) [] = parens (text (tupleCType kind)) P.<> braces (text "0") +tupleValue kind@(KTuple fieldKinds) fields + | length fieldKinds == length fields + = parens (text (tupleCType kind)) P.<> braces (fsep (punctuate comma designatedFields)) + | True + = error $ "SBV->C: Tuple literal field mismatch for " ++ show kind + where designatedFields = zipWith (\index field -> text "." P.<> text (tupleFieldName index) <+> text "=" <+> field) [1 :: Int ..] fields +tupleValue kind _ = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Return the preprocessor guard protecting one tuple definition. +tupleGuard :: Kind -> String +tupleGuard kind = tupleCType kind ++ "_DEFINED" + +-- | Return the preprocessor guard protecting one tuple forward declaration. +tupleForwardGuard :: Kind -> String +tupleForwardGuard kind = tupleCType kind ++ "_FORWARD_DEFINED" diff --git a/Data/SBV/Compilers/C/Types.hs b/Data/SBV/Compilers/C/Types.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Types.hs @@ -0,0 +1,274 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Types +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Shared C type and helper names for structurally lowered SBV kinds. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Types + ( tupleCType + , adtCType + , definedFunctionCName + , arrayKindTag + , arrayOutputCTypeName + , arrayStoredCloneName + , arrayStoredReleaseName + , tupleFieldName + , tupleOwnedInitName + , tupleOwnedSetName + , tupleOwnedCloneName + , tupleOwnedReleaseName + , adtOwnedInitName + , adtOwnedSetName + , adtOwnedCloneName + , adtOwnedReleaseName + , adtEqualName + , listCloneName + , listReleaseName + , listHelperName + , setCloneName + , setReleaseName + , setHelperName + , textCloneName + , textReleaseName + , textCompareName + , elementCType + , constElementCType + , kindTag + , isConcreteADT + , isConcreteADTReference + ) where + +import Data.Char (isAlphaNum, isAscii, ord) +import Numeric (showHex) + +import Data.SBV.Compilers.C.FP (arbitraryFPCType) +import Data.SBV.Core.Data + +-- | Return the helper name that initializes caller-owned storage for a tuple +-- with recursively managed fields. +tupleOwnedInitName :: Kind -> String +tupleOwnedInitName kind = "sbv_tuple_owned_init_" ++ kindTag kind + +-- | Return the helper name that assigns into initialized owned tuple storage. +tupleOwnedSetName :: Kind -> String +tupleOwnedSetName kind = "sbv_tuple_owned_set_" ++ kindTag kind + +-- | Return the public helper name that deep-copies a managed-field tuple. +tupleOwnedCloneName :: Kind -> String +tupleOwnedCloneName kind = "sbv_tuple_owned_clone_" ++ kindTag kind + +-- | Return the public helper name that releases an owned managed-field tuple. +tupleOwnedReleaseName :: Kind -> String +tupleOwnedReleaseName kind = "sbv_tuple_owned_release_" ++ kindTag kind + +-- | Return the helper name that initializes caller-owned storage for one ADT +-- constructor. +adtOwnedInitName :: Kind -> String +adtOwnedInitName kind = "sbv_adt_owned_init_" ++ adtCType kind + +-- | Return the helper name that assigns into initialized owned ADT storage. +adtOwnedSetName :: Kind -> String +adtOwnedSetName kind = "sbv_adt_owned_set_" ++ adtCType kind + +-- | Return the public helper name that deep-copies an owned ADT. +adtOwnedCloneName :: Kind -> String +adtOwnedCloneName kind = "sbv_adt_owned_clone_" ++ adtCType kind + +-- | Return the public helper name that releases an owned ADT. +adtOwnedReleaseName :: Kind -> String +adtOwnedReleaseName kind = "sbv_adt_owned_release_" ++ adtCType kind + +-- | Return the generated structural-equality helper for a recursive ADT. +adtEqualName :: Bool -> Kind -> String +adtEqualName strong kind = "sbv_adt_" ++ (if strong then "object_" else "") + ++ "equal_" ++ adtCType kind + +-- | Return the generated clone-helper name for a list kind. +listCloneName :: Kind -> String +listCloneName (KList elementKind) = "sbv_list_clone_" ++ kindTag elementKind +listCloneName kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Return the generated release-helper name for a list kind. +listReleaseName :: Kind -> String +listReleaseName (KList elementKind) = "sbv_list_release_" ++ kindTag elementKind +listReleaseName kind = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Return one specialized list-operation helper name. +listHelperName :: Kind -> String -> String +listHelperName (KList elementKind) suffix = "sbv_list_" ++ kindTag elementKind ++ "_" ++ suffix +listHelperName kind _ = error $ "SBV->C: Expected a list kind, received " ++ show kind + +-- | Return the generated clone-helper name for a set kind. +setCloneName :: Kind -> String +setCloneName (KSet elementKind) = "sbv_set_clone_" ++ kindTag elementKind +setCloneName kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Return the generated release-helper name for a set kind. +setReleaseName :: Kind -> String +setReleaseName (KSet elementKind) = "sbv_set_release_" ++ kindTag elementKind +setReleaseName kind = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Return one specialized set-operation helper name. +setHelperName :: Kind -> String -> String +setHelperName (KSet elementKind) suffix = "sbv_set_" ++ kindTag elementKind ++ "_" ++ suffix +setHelperName kind _ = error $ "SBV->C: Expected a set kind, received " ++ show kind + +-- | Name of the public helper that copies a string into owned storage. +textCloneName :: String +textCloneName = "sbv_string_clone" + +-- | Name of the public helper that releases owned string storage. +textReleaseName :: String +textReleaseName = "sbv_string_release" + +-- | Name of the lexicographic string-comparison runtime helper. +textCompareName :: String +textCompareName = "sbv_text_compare" + +-- | A resolved user ADT, excluding built-in rounding modes and opaque sorts. +isConcreteADT :: Kind -> Bool +isConcreteADT kind = isADT kind && not (isRoundingMode kind) && not (isUninterpreted kind) + +-- | A user ADT or a retained application awaiting ADT-reference resolution. +-- Keep this distinct from 'isConcreteADT' for dependency and ownership walks. +isConcreteADTReference :: Kind -> Bool +isConcreteADTReference KApp{} = True +isConcreteADTReference kind = isConcreteADT kind + +-- | Return the public C structure type used for a tuple kind. +tupleCType :: Kind -> String +tupleCType kind@KTuple{} = "SBVTuple_" ++ kindTag kind +tupleCType kind = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Return the public C structure type used for a concrete ADT kind or an +-- unresolved application of a registered ADT. +adtCType :: Kind -> String +adtCType kind@(KADT typeName parameters _) + | isADT kind && not (isRoundingMode kind) && not (isUninterpreted kind) + = appliedType typeName (map snd parameters) + | True + = error $ "SBV->C: Expected a concrete ADT kind, received " ++ show kind +adtCType (KApp typeName arguments) = appliedType typeName arguments +adtCType kind = error $ "SBV->C: Expected an ADT kind, received " ++ show kind + +-- | Return the private C identifier used for an SBV-defined function. Encoding +-- the complete SMT identifier keeps quoted and firstified names collision-free. +definedFunctionCName :: String -> String +definedFunctionCName functionName = "sbv_function_" ++ encodeIdentifier functionName + +-- | Render the common C type spelling shared by a concrete ADT and an +-- unresolved application of that same registered ADT. +appliedType :: String -> [Kind] -> String +appliedType typeName arguments = "SBVADT_" ++ encodeIdentifier typeName ++ concatMap parameterTag arguments + where parameterTag parameterKind = "_" ++ show (length tag) ++ "_" ++ tag + where tag = kindTag parameterKind + +-- | Return the public member name used for a one-based tuple field index. +tupleFieldName :: Int -> String +tupleFieldName index + | index >= 1 = "field" ++ show index + | True = error $ "SBV->C: Tuple fields are one-based, received " ++ show index + +-- | Return the public C type used for a structurally lowered field or element. +elementCType :: Kind -> String +elementCType KBool = "SBool" +elementCType (KBounded False 1) = "SBool" +elementCType (KBounded False w) = "SWord" ++ show w +elementCType (KBounded True w) = "SInt" ++ show w +elementCType KUnbounded = "SInteger" +elementCType KReal = "SReal" +elementCType KRational = "SRational" +elementCType KFloat = "SFloat" +elementCType KDouble = "SDouble" +elementCType KChar = "SChar" +elementCType KString = "SString" +elementCType kind@KFP{} = arbitraryFPCType kind +elementCType kind@KTuple{} = tupleCType kind +elementCType kind@KADT{} + | isRoundingMode kind = "RoundingMode" + | True = adtCType kind +elementCType kind@KApp{} = adtCType kind +elementCType (KList elementKind) = "SBVList_" ++ kindTag elementKind +elementCType (KSet elementKind) = "SBVSet_" ++ kindTag elementKind +elementCType kind@KArray{} = arrayOutputCTypeName kind ++ " *" +elementCType kind = error $ "SBV->C: Unsupported structural kind: " ++ show kind + +-- | Qualify a stored value itself. Array values are spelled as pointers, so +-- their const qualifier belongs after the pointer, not on its pointee. +constElementCType :: Kind -> String +constElementCType kind + | isArray kind = elementCType kind ++ " const" + | True = "const " ++ elementCType kind + +-- | Return the suffix used by a generated structural C type. Structural +-- components are length-framed and identifiers are escaped injectively. +-- Consumers must preserve case, including in preprocessor guards and tags. +-- Booleans and unsigned one-bit vectors intentionally share a representation, +-- as do a concrete ADT and its corresponding resolved application. +kindTag :: Kind -> String +kindTag KBool = "u1" +kindTag (KBounded False w) = "u" ++ show w +kindTag (KBounded True w) = "s" ++ show w +kindTag KUnbounded = "integer" +kindTag KReal = "real" +kindTag KRational = "rational" +kindTag KFloat = "float" +kindTag KDouble = "double" +kindTag KChar = "char" +kindTag KString = "string" +kindTag (KFP eb sb) = "fp_e" ++ show eb ++ "_s" ++ show sb +kindTag (KTuple fields) = "t" ++ show (length fields) ++ concatMap (('_' :) . taggedKind . kindTag) fields +kindTag kind@KADT{} + | isRoundingMode kind = "rounding_mode" + | True = "adt_" ++ encodeIdentifier (adtCType kind) +kindTag kind@KApp{} = "adt_" ++ encodeIdentifier (adtCType kind) +kindTag (KList elementKind) = "list_" ++ taggedKind (kindTag elementKind) +kindTag (KSet elementKind) = "set_" ++ taggedKind (kindTag elementKind) +kindTag kind@KArray{} = "array_" ++ taggedKind (arrayKindTag kind) +kindTag kind = error $ "SBV->C: Unsupported structural kind: " ++ show kind + +-- | Return the key/value suffix shared by generated names for an array kind. +-- Frame both components by length, just as for tuple fields and ADT arguments, +-- so nested tags need not be parsed to find the key/value boundary. +-- +-- >>> arrayKindTag (KArray (KBounded False 8) (KBounded False 32)) +-- "2_u8_3_u32" +arrayKindTag :: Kind -> String +arrayKindTag (KArray keyKind valueKind) = taggedKind (kindTag keyKind) ++ "_" ++ taggedKind (kindTag valueKind) +arrayKindTag kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Return the public owned-output descriptor name for an array kind. +arrayOutputCTypeName :: Kind -> String +arrayOutputCTypeName kind@KArray{} = "SBVArrayOutput_" ++ arrayKindTag kind +arrayOutputCTypeName kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Return the helper name that clones an array descriptor stored by pointer +-- inside another generated value. +arrayStoredCloneName :: Kind -> String +arrayStoredCloneName kind@KArray{} = "sbv_array_stored_clone_" ++ arrayKindTag kind +arrayStoredCloneName kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Return the helper name that releases an array descriptor stored by pointer +-- inside another generated value. +arrayStoredReleaseName :: Kind -> String +arrayStoredReleaseName kind@KArray{} = "sbv_array_stored_release_" ++ arrayKindTag kind +arrayStoredReleaseName kind = error $ "SBV->C: Expected an array kind, received " ++ show kind + +-- | Prefix a generated kind tag with its length so adjacent tags cannot +-- collide. +taggedKind :: String -> String +taggedKind value = show (length value) ++ "_" ++ value + +-- | Encode an arbitrary Haskell type name as a valid C identifier component. +encodeIdentifier :: String -> String +encodeIdentifier = concatMap encode + where encode character + | isAscii character && isAlphaNum character = [character] + | True = "_x" ++ showHex (ord character) "" ++ "_" diff --git a/Data/SBV/Compilers/C/Value.hs b/Data/SBV/Compilers/C/Value.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Compilers/C/Value.hs @@ -0,0 +1,233 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Compilers.C.Value +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Shared properties and operations for structurally lowered C values. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Compilers.C.Value + ( valueNeedsOwnership + , valueDriverNeedsInitialization + , byValueEqual + , managedValueClone + , managedValueRelease + , valueDriverInit + , valueDriverClear + ) where + +import Text.PrettyPrint.HughesPJ +import qualified Text.PrettyPrint.HughesPJ as P ((<>)) + +import Data.SBV.Compilers.C.BV (isWideBV, wideBVEqual) +import Data.SBV.Compilers.C.FP (arbitraryFPEqual, arbitraryFPObjectEqual, nativeFPObjectEqual) +import Data.SBV.Compilers.C.GMP (gmpDriverAssign, gmpDriverClear, gmpDriverInit, gmpEqual, isExactGMPKind) +import Data.SBV.Compilers.C.Types ( isConcreteADTReference, arrayStoredCloneName, arrayStoredReleaseName + , constElementCType, elementCType, tupleCType, tupleFieldName + , adtEqualName, adtOwnedCloneName, adtOwnedReleaseName + , tupleOwnedInitName, tupleOwnedCloneName, tupleOwnedReleaseName + , listCloneName, listReleaseName, listHelperName + , setCloneName, setReleaseName, setHelperName + , textCloneName, textReleaseName, textCompareName + ) +import Data.SBV.Compilers.CodeGen (CgConfig) +import Data.SBV.Core.Data + +-- | Test whether a value requires clone-and-release ownership when it crosses +-- a generated C ABI boundary. Concrete ADTs use a uniform ownership protocol, +-- including those whose resolved fields do not themselves need deep storage. +valueNeedsOwnership :: CgConfig -> Kind -> Bool +valueNeedsOwnership cfg kind + | isExactGMPKind cfg kind = True +valueNeedsOwnership _ KString = True +valueNeedsOwnership _ KList{} = True +valueNeedsOwnership _ KSet{} = True +valueNeedsOwnership _ KArray{} = True +valueNeedsOwnership cfg (KTuple kinds) = any (valueNeedsOwnership cfg) kinds +valueNeedsOwnership _ kind@KADT{} = isConcreteADTReference kind +valueNeedsOwnership _ KApp{} = True +valueNeedsOwnership _ _ = False + +-- | Test whether a deterministic example-driver value needs declarations or +-- initialization statements instead of a single C compound literal. +valueDriverNeedsInitialization :: CgConfig -> Kind -> Bool +valueDriverNeedsInitialization cfg kind + | isExactGMPKind cfg kind = True +valueDriverNeedsInitialization cfg (KTuple fields) = any (valueNeedsOwnership cfg) fields +valueDriverNeedsInitialization cfg (KList elementKind) = valueDriverNeedsInitialization cfg elementKind +valueDriverNeedsInitialization cfg (KSet elementKind) = valueDriverNeedsInitialization cfg elementKind +valueDriverNeedsInitialization _ KArray{} = True +valueDriverNeedsInitialization _ kind@KADT{} = isConcreteADTReference kind +valueDriverNeedsInitialization _ KApp{} = True +valueDriverNeedsInitialization _ _ = False + +-- | Render equality for a scalar or recursively nested aggregate. The Boolean +-- flag selects object equality for floating-point values. Array-valued fields +-- carry an unreachable abort sentinel: operation validation rejects consumers +-- requiring extensional equality, while unused aggregate helpers may be emitted. +byValueEqual :: CgConfig -> Bool -> Kind -> Doc -> Doc -> Doc +byValueEqual cfg strong kind left right + | isWideBV kind = wideBVEqual kind left right + | isFP kind && strong = arbitraryFPObjectEqual kind left right + | isFP kind = arbitraryFPEqual kind left right + | strong && (isFloat kind || isDouble kind) = nativeFPObjectEqual left right + | isExactGMPKind cfg kind = gmpEqual kind left right + | kind == KString = parens $ call textCompareName [left, right] <+> text "== 0" + | isList kind = call (listHelperName kind "equal") [left, right] + | isSet kind = call (setHelperName kind "equal") [left, right] + | isArray kind = text "(abort(), false)" + | KTuple fields <- kind = tupleEquality fields + | isConcreteADTReference kind = call (adtEqualName strong kind) [left, right] + | True = left <+> text "==" <+> right + where tupleEquality [] = parens . fsep . punctuate comma $ [text "(void)" <+> parens left, text "(void)" <+> parens right, text "true"] + tupleEquality fields = parens . fsep . punctuate (text " &&") $ + zipWith equalField [1 :: Int ..] fields + + equalField index fieldKind = byValueEqual cfg strong fieldKind + (parens left P.<> text "." P.<> text (tupleFieldName index)) + (parens right P.<> text "." P.<> text (tupleFieldName index)) + +-- | Deep-copy one non-GMP managed value. Exact GMP values require initialized +-- destination storage and are therefore handled by their aggregate owner. +managedValueClone :: Kind -> Doc -> Doc +managedValueClone KString value = call textCloneName [value] +managedValueClone kind@KList{} value = call (listCloneName kind) [value] +managedValueClone kind@KSet{} value = call (setCloneName kind) [value] +managedValueClone kind@KArray{} value = call (arrayStoredCloneName kind) [value] +managedValueClone kind@KTuple{} value = call (tupleOwnedCloneName kind) [value] +managedValueClone kind value + | isConcreteADTReference kind = call (adtOwnedCloneName kind) [value] +managedValueClone kind _ = error $ "SBV->C: Expected a non-GMP managed kind, received " ++ show kind + +-- | Release one non-GMP managed value through a pointer to its owned storage. +managedValueRelease :: Kind -> Doc -> Doc +managedValueRelease KString address = call textReleaseName [address] P.<> semi +managedValueRelease kind@KList{} address = call (listReleaseName kind) [address] P.<> semi +managedValueRelease kind@KSet{} address = call (setReleaseName kind) [address] P.<> semi +managedValueRelease kind@KArray{} address = call (arrayStoredReleaseName kind) [address] P.<> semi +managedValueRelease kind@KTuple{} address = call (tupleOwnedReleaseName kind) [address] P.<> semi +managedValueRelease kind address + | isConcreteADTReference kind = call (adtOwnedReleaseName kind) [address] P.<> semi +managedValueRelease kind _ = error $ "SBV->C: Expected a non-GMP managed kind, received " ++ show kind + +-- | Declare and initialize one deterministic example-driver value. Managed +-- aggregates receive unique ownership; collection descriptors themselves +-- borrow the element variables declared alongside them. The supplied +-- statement renderer constructs retained arrays and registered ADTs without +-- creating dependency cycles between the structural lowering modules. +-- Collections whose elements need no initialization use a compound literal; +-- 'valueDriverClear' emits no element cleanup for those borrowed literals. +valueDriverInit :: CgConfig -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> String -> Integer -> Doc +valueDriverInit cfg _ _ kind externalName seed + | isExactGMPKind cfg kind + = gmpDriverInit kind (text externalName) (integer seed) +valueDriverInit cfg renderValue initializeValue kind@(KTuple fields) externalName seed + | valueNeedsOwnership cfg kind + = text (tupleCType kind) <+> text externalName P.<> semi + $$ call (tupleOwnedInitName kind) [text "&" P.<> text externalName] P.<> semi + $$ vcat (concat (zipWith initializeTupleField [1 :: Int ..] (zip fields [seed ..]))) + where initializeTupleField index (fieldKind, fieldSeed) = initializeAt fieldKind access fieldName fieldSeed + where access = text externalName P.<> text "." P.<> text (tupleFieldName index) + fieldName = externalName ++ "_field_" ++ show index + + initializeAt fieldKind access fieldName fieldSeed + | isExactGMPKind cfg fieldKind = exactAssignment fieldKind access fieldSeed + | fieldKind == KString = [access <+> text "=" <+> managedValueClone fieldKind (renderValue fieldKind fieldSeed) P.<> semi] + | isArray fieldKind = [ initializeValue fieldKind fieldName fieldSeed + , access <+> text "=" <+> text fieldName P.<> semi + ] + | isConcreteADTReference fieldKind = [ initializeValue fieldKind fieldName fieldSeed + , access <+> text "=" <+> text fieldName P.<> semi + ] + | KList{} <- fieldKind = collectionAssignment fieldKind access fieldName fieldSeed + | KSet{} <- fieldKind = collectionAssignment fieldKind access fieldName fieldSeed + | nested@KTuple{} <- fieldKind + , valueNeedsOwnership cfg nested + = concat (zipWith initializeNested [1 :: Int ..] (zip (tupleFields nested) [fieldSeed ..])) + | True = [access <+> text "=" <+> renderValue fieldKind fieldSeed P.<> semi] + where initializeNested nestedIndex (nestedKind, nestedSeed) = initializeAt nestedKind nestedAccess nestedName nestedSeed + where nestedAccess = access P.<> text "." P.<> text (tupleFieldName nestedIndex) + nestedName = fieldName ++ "_field_" ++ show nestedIndex + + collectionAssignment fieldKind access fieldName fieldSeed = + [ valueDriverInit cfg renderValue initializeValue fieldKind fieldName fieldSeed + , access <+> text "=" <+> managedValueClone fieldKind (text fieldName) P.<> semi + , valueDriverClear cfg fieldKind fieldName + ] + + exactAssignment fieldKind access value = gmpDriverAssign fieldKind access (integer value) +valueDriverInit cfg renderValue initializeValue kind@(KList elementKind) externalName seed + | valueDriverNeedsInitialization cfg kind + = collectionDriverInit cfg renderValue initializeValue kind elementKind externalName seed False +valueDriverInit cfg renderValue initializeValue kind@(KSet elementKind) externalName seed + | valueDriverNeedsInitialization cfg kind + = collectionDriverInit cfg renderValue initializeValue kind elementKind externalName seed (odd seed) +valueDriverInit _ _ initializeValue kind@KArray{} externalName seed + = initializeValue kind externalName seed +valueDriverInit _ _ initializeValue kind externalName seed + | isConcreteADTReference kind + = initializeValue kind externalName seed +valueDriverInit _ renderValue _ kind externalName seed + = text "const" <+> text (elementCType kind) <+> text externalName <+> text "=" <+> renderValue kind seed P.<> semi + +-- | Release storage created by 'valueDriverInit'. Borrowed scalar and string +-- literals require no cleanup. Collections use the same initialization test +-- as construction, so cleanup names only separately declared element variables. +valueDriverClear :: CgConfig -> Kind -> String -> Doc +valueDriverClear cfg kind externalName + | isExactGMPKind cfg kind + = gmpDriverClear kind (text externalName) +valueDriverClear cfg kind@KTuple{} externalName + | valueNeedsOwnership cfg kind + = managedValueRelease kind (text "&" P.<> text externalName) +valueDriverClear _ kind externalName + | isConcreteADTReference kind + = managedValueRelease kind (text "&" P.<> text externalName) +valueDriverClear _ kind@KArray{} externalName + = managedValueRelease kind (text "&" P.<> text externalName) +valueDriverClear cfg kind@(KList elementKind) externalName + | valueDriverNeedsInitialization cfg kind + = vcat [valueDriverClear cfg elementKind (collectionElementName externalName index) | index <- [0 :: Int .. collectionElementCount - 1]] +valueDriverClear cfg kind@(KSet elementKind) externalName + | valueDriverNeedsInitialization cfg kind + = vcat [valueDriverClear cfg elementKind (collectionElementName externalName index) | index <- [0 :: Int .. collectionElementCount - 1]] +valueDriverClear _ _ _ = empty + +-- | Declare a deterministic borrowed list or set descriptor and its elements. +collectionDriverInit :: CgConfig -> (Kind -> Integer -> Doc) -> (Kind -> String -> Integer -> Doc) -> Kind -> Kind -> String -> Integer -> Bool -> Doc +collectionDriverInit cfg renderValue initializeValue kind elementKind externalName seed isComplemented + = vcat (zipWith initializeElement elementNames [seed ..]) + $$ text (constElementCType elementKind) <+> text dataName P.<> brackets (int collectionElementCount) + <+> text "=" <+> braces (fsep (punctuate comma (map text elementNames))) P.<> semi + $$ text "const" <+> text (elementCType kind) <+> text externalName <+> text "=" + <+> braces (fsep (punctuate comma descriptorFields)) P.<> semi + where elementNames = [collectionElementName externalName index | index <- [0 :: Int .. collectionElementCount - 1]] + dataName = externalName ++ "_data" + descriptorFields = [text dataName, int collectionElementCount] + ++ case kind of + KSet{} -> [text (if isComplemented then "true" else "false")] + _ -> [] + + initializeElement = valueDriverInit cfg renderValue initializeValue elementKind + +-- | Return the generated name of one deterministic collection element. +collectionElementName :: String -> Int -> String +collectionElementName externalName index = externalName ++ "_element_" ++ show index + +-- | Number of elements placed in each deterministic example collection. +collectionElementCount :: Int +collectionElementCount = 3 + +-- | Extract the fields of a tuple kind. +tupleFields :: Kind -> [Kind] +tupleFields (KTuple fields) = fields +tupleFields kind = error $ "SBV->C: Expected a tuple kind, received " ++ show kind + +-- | Render a C helper call. +call :: String -> [Doc] -> Doc +call functionName arguments = text functionName P.<> parens (fsep (punctuate comma arguments)) diff --git a/Data/SBV/Compilers/CodeGen.hs b/Data/SBV/Compilers/CodeGen.hs --- a/Data/SBV/Compilers/CodeGen.hs +++ b/Data/SBV/Compilers/CodeGen.hs @@ -10,6 +10,7 @@ ----------------------------------------------------------------------------- {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} {-# OPTIONS_GHC -Wall -Werror #-} @@ -28,12 +29,14 @@ , svCgReturn, svCgReturnArr -- * Settings - , cgPerformRTCs, cgSetDriverValues + , cgPerformRTCs, cgSetDriverValues, cgArrayEqualityLimit, cgRegexLimits + , CgRegexLimits(..), defaultCgRegexLimits, cgSetRegexLimits , cgAddPrototype, cgAddDecl, cgAddLDFlags, cgIgnoreSAssert, cgOverwriteFiles, cgShowU8UsingHex , cgIntegerSize, cgSRealType, CgSRealType(..) -- * Infrastructure - , CgTarget(..), CgConfig(..), CgState(..), CgPgmBundle(..), CgPgmKind(..), CgVal(..) + , CgTarget(..), CgConfig(..), CgState(..), CgPgmBundle(..) + , CgPgmKind(CgMakefile, CgHeader, CgCHeader, CgSource, CgDriver), CgCHeader(..), CgVal(..) , defaultCgConfig, initCgState, isCgDriver, isCgMakefile -- * Generating collateral @@ -53,7 +56,7 @@ import qualified Text.PrettyPrint.HughesPJ as P (render) import Data.SBV.Core.Data -import Data.SBV.Core.Symbolic (MonadSymbolic(..), svToSymSV, svMkSymVar, outputSVal, VarContext(..)) +import Data.SBV.Core.Symbolic (MonadSymbolic(..), addNewSMTOption, imposeConstraint, newInternalVariable, outputSVal, svMkSymVar, svToSymSV, VarContext(..)) import Data.SBV.Provers.Prover(defaultSMTCfg) @@ -64,29 +67,39 @@ -- | 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. - , cgInteger :: Maybe Int -- ^ Bit-size to use for representing SInteger (if any) - , cgReal :: Maybe CgSRealType -- ^ Type to use for representing SReal (if any) - , cgDriverVals :: [Integer] -- ^ Values to use for the driver program generated, useful for generating non-random drivers. - , cgGenDriver :: Bool -- ^ If 'True', will generate a driver program - , cgGenMakefile :: Bool -- ^ If 'True', will generate a makefile - , cgIgnoreAsserts :: Bool -- ^ If 'True', will ignore 'Data.SBV.sAssert' calls - , cgOverwriteGenerated :: Bool -- ^ If 'True', will overwrite the generated files without prompting. - , cgShowU8InHex :: Bool -- ^ If 'True', then 8-bit unsigned values will be shown in hex as well, otherwise decimal. (Other types always shown in hex.) + cgRTC :: Bool -- ^ If 'True', check finite table indices and select the supplied default when out of bounds. + , cgInteger :: Maybe Int -- ^ Optional lossy bit-size for representing SInteger; 'Nothing' selects exact GMP integers + , cgReal :: Maybe CgSRealType -- ^ Optional lossy representation for SReal; 'Nothing' selects exact GMP rationals + , cgDriverVals :: [Integer] -- ^ Values to use for the driver program generated, useful for generating non-random drivers. + , cgGenDriver :: Bool -- ^ If 'True', will generate a driver program + , cgGenMakefile :: Bool -- ^ If 'True', will generate a makefile + , cgIgnoreAsserts :: Bool -- ^ If 'True', will ignore 'Data.SBV.sAssert' calls + , cgOverwriteGenerated :: Bool -- ^ If 'True', will overwrite the generated files without prompting. + , cgShowU8InHex :: Bool -- ^ If 'True', then 8-bit unsigned values will be shown in hex as well, otherwise decimal. (Other types always shown in hex.) + , cgArrayEqualityMaxKeys :: Integer -- ^ Maximum key-domain size for exhaustive array equality in the current C backend. + , cgRegexMaxStates :: Integer -- ^ Maximum states explored per regex membership or language comparison. + , cgRegexMaxNodes :: Integer -- ^ Maximum nodes in a regex expression, including intermediate derivatives. + , cgRegexMaxWork :: Integer -- ^ Maximum charged generation work per regex operation; not a runtime input bound. } --- | Default options for code generation. The run-time checks are turned-off, and the driver values are completely random. +-- | Default options for code generation. Run-time checks are disabled, driver +-- values are random, and any 'SInteger' or rational 'SReal' values use exact +-- GMP representations. defaultCgConfig :: CgConfig -defaultCgConfig = CgConfig { cgRTC = False - , cgInteger = Nothing - , cgReal = Nothing - , cgDriverVals = [] - , cgGenDriver = True - , cgGenMakefile = True - , cgIgnoreAsserts = False - , cgOverwriteGenerated = False - , cgShowU8InHex = False - } +defaultCgConfig = CgConfig { cgRTC = False + , cgInteger = Nothing + , cgReal = Nothing + , cgDriverVals = [] + , cgGenDriver = True + , cgGenMakefile = True + , cgIgnoreAsserts = False + , cgOverwriteGenerated = False + , cgShowU8InHex = False + , cgArrayEqualityMaxKeys = 256 + , cgRegexMaxStates = 1024 + , cgRegexMaxNodes = 4096 + , cgRegexMaxWork = 16000000 + } -- | Abstraction of target language values data CgVal = CgAtomic SV @@ -124,18 +137,108 @@ , MonadFail ) +-- | Code-generation computations support hard symbolic constraints. Target +-- backends decide which constraint variants have executable semantics. +instance SolverContext SBVCodeGen where + constrain = imposeConstraint False [] . unSBV . quantifiedBool + softConstrain = imposeConstraint True [] . unSBV . quantifiedBool + namedConstraint nm = imposeConstraint False [(":named", nm)] . unSBV . quantifiedBool + constrainWithAttribute attrs = imposeConstraint False attrs . unSBV . quantifiedBool + + contextState = symbolicEnv + setOption = addNewSMTOption + + internalVariable kind = do + state <- contextState + sv <- liftIO $ newInternalVariable state kind + pure $ SBV $ SVal kind $ Right $ cache $ const $ pure sv + -- | Reach into symbolic monad from code-generation cgSym :: Symbolic a -> SBVCodeGen a cgSym = SBVCodeGen . lift --- | Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off. Default: 'False'. +-- | Enable bounds checks for finite table selection. Out-of-range indices +-- select the supplied default. With checks disabled (the default), callers +-- must guarantee in-range indices. This setting does not disable assertions, +-- executable constraints, ownership checks, or exact bit-vector shift +-- semantics in the current C backend. Wide bit-vector and GMP indices always +-- retain their bounds check before conversion to a machine index. cgPerformRTCs :: Bool -> SBVCodeGen () cgPerformRTCs b = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRTC = b } }) +-- | Set the maximum number of keys enumerated by an array equality comparison +-- in the current C backend. The default is 256. Larger or infinite domains +-- are rejected during generation; equality is never approximated. Zero +-- disables exhaustive array equality. Negative limits are invalid. +-- +-- For example, @cgArrayEqualityLimit 65536@ permits comparing arrays indexed +-- by 'SWord16', at the cost of up to 65,536 lookups in each array per comparison. +-- The setting also applies inside generated defined functions and array lambdas. +-- +-- >>> import Data.SBV +-- >>> import Data.SBV.Internals (compileToC') +-- >>> :{ +-- let compareArrays = do +-- cgArrayEqualityLimit 65536 +-- left <- cgInput "left" :: SBVCodeGen (SArray Word16 Word8) +-- right <- cgInput "right" :: SBVCodeGen (SArray Word16 Word8) +-- cgReturn (left .== right) +-- :} +-- +-- >>> (_, _, generated) <- compileToC' "compareArrays" compareArrays +-- >>> length (show generated) `seq` pure () +cgArrayEqualityLimit :: Integer -> SBVCodeGen () +cgArrayEqualityLimit limit + | limit < 0 = error "SBV.cgArrayEqualityLimit: The limit must be nonnegative." + | True = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgArrayEqualityMaxKeys = limit } }) + +-- | Bound dependency-free C regex compilation: maximum explored states, +-- expression nodes, and generation work, respectively. Defaults are 1024, +-- 4096, and 16000000. Exceeding a budget fails during generation, never by +-- approximating the language or limiting runtime input length. Zero disables +-- regex compilation; negative limits are invalid. Limits apply independently +-- to each operation, also inside defined functions and library components. +-- +-- For example, @cgRegexLimits 4096 8192 64000000@ permits larger automata and +-- intermediate expressions, at the cost of more generation time and memory. +-- See "Data.SBV.Tools.CodeGen" for an executable generation example. +cgRegexLimits :: Integer -> Integer -> Integer -> SBVCodeGen () +cgRegexLimits states nodes work + | any (< 0) [states, nodes, work] = error "SBV.cgRegexLimits: Limits must be nonnegative." + | True = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRegexMaxStates = states + , cgRegexMaxNodes = nodes + , cgRegexMaxWork = work + } }) + +-- | Named limits for dependency-free regex compilation. Work is a conservative +-- generation allowance, not a promise that every smaller automaton will fit. +data CgRegexLimits = CgRegexLimits + { regexMaxStates :: Integer -- ^ Maximum explored automaton states. + , regexMaxNodes :: Integer -- ^ Maximum nodes per intermediate expression. + , regexMaxWork :: Integer -- ^ Maximum charged construction work. + } deriving (Eq, Show) + +-- | The default regex budgets, suitable for record updates. +defaultCgRegexLimits :: CgRegexLimits +defaultCgRegexLimits = CgRegexLimits (cgRegexMaxStates defaultCgConfig) + (cgRegexMaxNodes defaultCgConfig) + (cgRegexMaxWork defaultCgConfig) + +-- | Configure regex budgets using named fields. The positional 'cgRegexLimits' +-- remains available for compatibility. +-- +-- >>> let larger = defaultCgRegexLimits { regexMaxStates = 4096, regexMaxWork = 64000000 } +-- >>> regexMaxNodes larger == regexMaxNodes defaultCgRegexLimits +-- True +cgSetRegexLimits :: CgRegexLimits -> SBVCodeGen () +cgSetRegexLimits limits = cgRegexLimits (regexMaxStates limits) (regexMaxNodes limits) (regexMaxWork limits) + -- | Sets number of bits to be used for representing the 'SInteger' type in the generated C code. -- The argument must be one of @8@, @16@, @32@, or @64@. Note that this is essentially unsafe as -- the semantics of unbounded Haskell integers becomes reduced to the corresponding bit size, as --- typical in most C implementations. +-- typical in most C implementations. Without this setting, generated C uses +-- exact GMP integers in the current backend. The Legacy backend instead rejects +-- SInteger programs unless this mapping is specified. cgIntegerSize :: Int -> SBVCodeGen () cgIntegerSize i | i `notElem` [8, 16, 32, 64] @@ -162,7 +265,9 @@ -- The setting can be one of C's @"float"@, @"double"@, or @"long double"@, types, depending -- on the precision needed. Note that this is essentially unsafe as the semantics of -- infinite precision SReal values becomes reduced to the corresponding floating point type in --- C, and hence it is subject to rounding errors. +-- C, and hence it is subject to rounding errors. Without this setting, +-- generated C uses exact GMP rationals for rational-valued computations in the +-- current backend. The Legacy backend requires an explicit mapping instead. cgSRealType :: CgSRealType -> SBVCodeGen () cgSRealType rt = modify' (\s -> s {cgFinalConfig = (cgFinalConfig s) { cgReal = Just rt }}) @@ -201,6 +306,9 @@ -- | Adds the given lines to the program file generated, useful for generating programs with uninterpreted functions. +-- External implementations must represent pure mathematical functions: their +-- results must depend only on their arguments, with no observable side effects. +-- The compiler may eliminate unused calls or share equal applications. cgAddDecl :: [String] -> SBVCodeGen () cgAddDecl ss = modify' (\s -> s { cgDecls = cgDecls s ++ ss }) @@ -305,10 +413,34 @@ -- | Different kinds of "files" we can produce. Currently this is quite "C" specific. data CgPgmKind = CgMakefile [String] -- list of flags to pass to linker - | CgHeader [Doc] + | CgHeaderInternal [Doc] (Maybe CgCHeader) | CgSource | CgDriver +-- | Header signatures, as exposed by the original bundle interface. Matches +-- headers from both backends; construction produces a header without private +-- merge metadata. Existing four-way matches on 'CgPgmKind' remain exhaustive. +pattern CgHeader :: [Doc] -> CgPgmKind +pattern CgHeader signatures <- CgHeaderInternal signatures _ + where CgHeader signatures = CgHeaderInternal signatures Nothing + +-- | Structured metadata for current-backend header merging. This is a more +-- specific view of 'CgHeader', not an additional kind of generated file. +pattern CgCHeader :: CgCHeader -> CgPgmKind +pattern CgCHeader metadata <- CgHeaderInternal _ (Just metadata) + where CgCHeader metadata = CgHeaderInternal (cgHeaderSignatures metadata) (Just metadata) + +{-# COMPLETE CgMakefile, CgHeader, CgSource, CgDriver #-} + +-- | Structured C header metadata used when combining current-backend bundles. +-- 'CgHeader' provides the compatibility view for both backends. +data CgCHeader = CgCHeaderInfo + { cgHeaderFloating :: Bool -- ^ Requires IEEE floating-point compilation. + , cgHeaderTypes :: Doc -- ^ Runtime type declarations. + , cgHeaderSignatures :: [Doc] -- ^ Public entry points. + , cgHeaderPrototypes :: Doc -- ^ User-supplied prototypes. + } + -- | Is this a driver program? isCgDriver :: CgPgmKind -> Bool isCgDriver CgDriver = True @@ -334,6 +466,7 @@ ((retVal, st'), res) <- runSymbolic defaultSMTCfg CodeGen $ runStateT comp initCgState { cgFinalConfig = cgConfig } let st = st' { cgInputs = reverse (cgInputs st') , cgOutputs = reverse (cgOutputs st') + , cgReturns = reverse (cgReturns st') } allNamedVars = map fst (cgInputs st ++ cgOutputs st) dupNames = allNamedVars \\ nub allNamedVars diff --git a/Data/SBV/Control/BaseIO.hs b/Data/SBV/Control/BaseIO.hs --- a/Data/SBV/Control/BaseIO.hs +++ b/Data/SBV/Control/BaseIO.hs @@ -441,6 +441,12 @@ -- of the domain of the first list. If the result is not a value-association, then we get a string -- representation and the triple of whether it's curried, the argument list given by the user, and the s-expression as parsed -- by SBV from the SMT solver. +-- +-- The function must already be declared when satisfiability is checked. If it +-- does not occur in any constraints, call 'Data.SBV.registerFunction' before +-- entering the query, then 'ensureSat' before retrieving its interpretation. +-- An unregistered function is an error; this call never changes solver state +-- or reruns the satisfiability check. getFunction :: (SymVal a, SymVal r, Trans.SMTFunction fun a r) => fun -> Query (Either (String, (Bool, Maybe [String], SExpr)) ([(a, r)], r)) getFunction = Trans.getFunction diff --git a/Data/SBV/Control/Utils.hs b/Data/SBV/Control/Utils.hs --- a/Data/SBV/Control/Utils.hs +++ b/Data/SBV/Control/Utils.hs @@ -82,7 +82,7 @@ , extractSymbolicSimulationState, MonadSymbolic(..) , UserInputs, getSV, NamedSymVar(..), lookupInput, getUserName, getUserName' , Name, CnstMap, Inputs(..), ProgInfo(..) - , mustIgnoreVar, newInternalVariable, Penalty(..), smtLibPgmText + , mustIgnoreVar, newInternalVariable, Penalty(..), smtLibPgmText, registerKind, mkNewState ) import Data.SBV.Core.AlgReals (mergeAlgReals, AlgReal(..), RealPoint(..)) @@ -117,6 +117,8 @@ contextState = queryState + registerKindInContext k = inNewContext (`registerKind` k) + internalVariable :: forall a. Kind -> QueryT m (SBV a) internalVariable k = contextState >>= \st -> liftIO $ do sv <- newInternalVariable st k @@ -160,10 +162,13 @@ io = liftIO -- | Sync-up the external solver with new context we have generated -syncUpSolver :: (MonadIO m, MonadQuery m) => ProgInfo -> IORef CnstMap -> IncState -> m () -syncUpSolver progInfo rGlobalConsts is = do +syncUpSolver :: (MonadIO m, MonadQuery m) => State -> ProgInfo -> IORef CnstMap -> IncState -> m () +syncUpSolver st progInfo rGlobalConsts is = do cfg <- getConfig + checks <- io $ readIORef (rNewMeasureChecks is) + io $ verifyMeasureChecks cfg st checks + -- update global consts to have the new ones (newConsts, allConsts) <- liftIO $ do nc <- readIORef (rNewConsts is) oc <- readIORef rGlobalConsts @@ -175,16 +180,34 @@ inps <- reverse <$> readIORef (rNewInps is) ks <- readIORef (rNewKinds is) tbls <- map arrange . mapToSortedList <$> readIORef (rNewTbls is) - uis <- Map.toAscList <$> readIORef (rNewUIs is) + newUIs <- readIORef (rNewUIs is) + newDefns <- readIORef (rNewDefns is) as <- readIORef (rNewAsgns is) constraints <- readIORef (rNewConstraints is) - let cnsts = mapToSortedList newConsts + let cnsts = mapToSortedList newConsts + defineSet = Map.keysSet newDefns + uis = Map.toAscList (Map.withoutKeys newUIs defineSet) + definitions = Map.toAscList newDefns - pure $ toIncSMTLib cfg progInfo inps ks (allConsts, cnsts) tbls uis as constraints cfg + pure $ toIncSMTLib cfg progInfo inps ks (allConsts, cnsts) tbls uis definitions as constraints cfg mapM_ (send True) $ mergeSExpr ls +-- | Run deferred termination and productivity checks before sending newly encountered definitions. +verifyMeasureChecks :: SMTConfig -> State -> [(String, Bool, SMTConfig -> IO ())] -> IO () +verifyMeasureChecks cfg st checks = do + skip <- readIORef (rSkipMeasureChecks st) + unless (skip || null checks) $ do + let nms = map (\(n, _, _) -> n) checks + debug cfg ["[MEASURE] Verifying termination measures for: " <> T.pack (intercalate ", " nms)] + mapM_ (\(nm, isProductive, check) -> do + debug cfg ["[MEASURE] Checking: " <> T.pack nm] + check cfg + let tag = if isProductive then "productive" else "terminating" + debug cfg ["[MEASURE] Passed (" <> tag <> "): " <> T.pack nm] + ) checks + -- | Retrieve the query context getQueryState :: (MonadIO m, MonadQuery m) => m QueryState getQueryState = do state <- queryState @@ -213,17 +236,23 @@ inNewContext act = do st@State{rconstMap, rProgInfo} <- queryState (is, r) <- io $ withNewIncState st act progInfo <- io $ readIORef rProgInfo - syncUpSolver progInfo rconstMap is + syncUpSolver st progInfo rconstMap is pure r -- | Generalization of 'Data.SBV.Control.freshVar_' freshVar_ :: forall a m. (MonadIO m, MonadQuery m, SymVal a) => m (SBV a) -freshVar_ = inNewContext $ fmap SBV . svMkSymVar QueryVar k Nothing +freshVar_ = inNewContext $ \st -> do + v <- SBV <$> svMkSymVar QueryVar k Nothing st + mkSymValInit st v + pure v where k = kindOf (Proxy @a) -- | Generalization of 'Data.SBV.Control.freshVar' freshVar :: forall a m. (MonadIO m, MonadQuery m, SymVal a) => String -> m (SBV a) -freshVar nm = inNewContext $ fmap SBV . svMkSymVar QueryVar k (Just nm) +freshVar nm = inNewContext $ \st -> do + v <- SBV <$> svMkSymVar QueryVar k (Just nm) st + mkSymValInit st v + pure v where k = kindOf (Proxy @a) -- | Generalization of 'Data.SBV.Control.queryDebug' @@ -387,7 +416,7 @@ smtFunSaturate :: fun -> SBV r smtFunType :: fun -> SBVType smtFunDefault :: fun -> Maybe r - sexprToFun :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m, SymVal r) => fun -> (String, SExpr) -> m (Either String ([(a, r)], r)) + sexprToFun :: (MonadIO m, SolverContext m, MonadQuery m, MonadSymbolic m, SymVal r) => fun -> String -> (String, SExpr) -> m (Either String ([(a, r)], r)) {-# MINIMAL sexprToArg, smtFunSaturate, smtFunType #-} @@ -398,17 +427,30 @@ | True = Nothing - -- Given the function, determine what its name is and do some sanity checks - smtFunName f = do st@State{rUIMap} <- contextState + -- Discover the name in an isolated state. Inspecting a model must not add + -- declarations to the live solver, which can invalidate its current model. + smtFunName f = do State{rUIMap, stCfg} <- contextState uiMap <- liftIO $ readIORef rUIMap - nm <- findName st uiMap - - -- Read the uiMap again here. Why? Because the act of finding the name might've - -- introduced it as an uninterpreted name! - newUIMap <- liftIO $ readIORef rUIMap - case nm `Map.lookup` newUIMap of - Nothing -> cantFind newUIMap - Just (isCurried, mbArgs, _) -> pure ((nm, mbArgs), isCurried) + probe <- mkNewState stCfg{verbose = False} (LambdaGen (Just 0)) + nm <- findName probe uiMap + case nm `Map.lookup` uiMap of + Nothing -> error $ unlines + [ "" + , "*** Data.SBV.getFunction: Uninterpreted function " ++ show nm ++ " is not registered in this context." + , "*** Use it in a constraint, or call registerFunction before entering the query." + , "*** Then check satisfiability before calling getFunction." + , "*** getFunction only inspects the current model; it does not register functions or rerun checkSat." + ] + -- SMT signatures do not distinguish curried and uncurried + -- Haskell functions. Keep the registered display convention. + Just (isCurried, mbArgs, ty) + | ty == smtFunType f -> pure ((nm, mbArgs), isCurried) + | True -> error $ unlines + [ "" + , "*** Data.SBV.getFunction: Uninterpreted function " ++ show nm ++ " used at incompatible SMT signatures." + , "*** Requested argument/result sorts: " ++ show (smtFunType f) + , "*** Declared argument/result sorts: " ++ show ty + ] where cantFind uiMap = error $ unlines $ [ "" , "*** Data.SBV.getFunction: Must be called on an uninterpreted function!" , "***" @@ -438,25 +480,25 @@ (sv, SBVApp (Uninterpreted nm) _) | r == sv -> pure (T.unpack nm) _ -> cantFind uiMap - sexprToFun f (s, e) = do nm <- fst . fst <$> smtFunName f - si <- contextState >>= getSInfo - mbRes <- case parseSExprFunction e of - Just (Left nm') -> case (nm == nm', smtFunDefault f) of - (True, Just v) -> pure $ Just ([], v) - _ -> bailOut nm - Just (Right v) -> convert si v - Nothing -> do mbPVS <- pointWiseExtract nm (smtFunType f) - case mbPVS of - Nothing -> pure Nothing - Just pts -> convert si pts - pure $ maybe (Left s) Right mbRes + sexprToFun f nm (s, e) = do + si <- contextState >>= getSInfo + mbRes <- case parseSExprFunction e of + Just (Left nm') -> case (unBar nm == unBar nm', smtFunDefault f) of + (True, Just v) -> pure $ Just ([], v) + _ -> bailOut + Just (Right v) -> convert si v + Nothing -> do mbPVS <- pointWiseExtract nm (smtFunType f) + case mbPVS of + Nothing -> pure Nothing + Just pts -> convert si pts + pure $ maybe (Left s) Right mbRes where convert st (vs, d) = do ps <- mapM (sexprPoint st) vs pure $ (,) <$> sequenceA ps <*> sexprToVal st d sexprPoint st (as, v) = do mbA <- sexprToArg f as pure $ (,) <$> mbA <*> sexprToVal st v - bailOut nm = error $ unlines [ "" + bailOut = error $ unlines [ "" , "*** Data.SBV.getFunction: Unable to extract an interpretation for function " ++ show nm , "***" , "*** Failed while trying to extract a pointwise interpretation." @@ -511,11 +553,11 @@ then (trues, falseSExpr) else (falses, trueSExpr) --- | For saturation purposes, get a proper argument. The forall quantification --- is safe here since we only use in smtFunSaturate calls, which looks at the --- kind stored inside only. +-- | Use symbolic arguments for discovery: uninterpreted sorts need not have +-- a concrete default value. These variables belong only to the probe state. +-- The forall is safe since smtFunSaturate supplies the argument's actual kind. mkSaturatingArg :: forall a. Kind -> SBV a -mkSaturatingArg k = SBV $ SVal k (Left (defaultKindedValue k)) +mkSaturatingArg k = SBV $ SVal k $ Right $ cache $ \st -> newInternalVariable st k -- | Functions of arity 1 instance ( SymVal a, HasKind a @@ -816,21 +858,6 @@ , mkSaturatingArg (kindOf (Proxy @h)) ) --- Turn "((F (lambda ((x!1 Int)) (+ 3 (* 2 x!1)))))" --- into something more palatable. --- If we can't do that, we simply return the input unchanged -trimFunctionResponse :: String -> String -> Bool -> Maybe [String] -> String -trimFunctionResponse resp nm isCurried mbArgs - | Just parsed <- makeHaskellFunction resp nm isCurried mbArgs - = parsed - | True - = def $ case trim resp of - '(':'(':rest | nm `isPrefixOf` rest -> butLast2 $ trim (drop (length nm) rest) - _ -> resp - where trim = dropWhile isSpace - butLast2 = reverse . drop 2 . reverse - def x = nm ++ " = fromSMTLib " ++ x - -- | Generalization of 'Data.SBV.Control.getFunction' getFunction :: (MonadIO m, MonadQuery m, SolverContext m, MonadSymbolic m, SymVal a, SymVal r, SMTFunction fun a r) => fun -> m (Either (String, (Bool, Maybe [String], SExpr)) ([(a, r)], r)) @@ -843,8 +870,8 @@ si <- contextState >>= getSInfo - parse r bad $ \case EApp [EApp [ECon o, e]] | o == nm -> do - mbAssocs <- sexprToFun f (trimFunctionResponse r nm isCurried args, e) + parse r bad $ \case EApp [EApp [ECon o, e]] | unBar o == unBar nm -> do + mbAssocs <- sexprToFun f nm (formatFunctionResponse e r nm isCurried args, e) case mbAssocs of Right assocs -> pure $ Right assocs Left raw -> do @@ -1229,25 +1256,25 @@ toRes = recoverKindedValue si rt -- if we fail to parse, we'll return this answer as the string - fallBack = trimFunctionResponse r nm isCurried mbArgs + fallBack e = formatFunctionResponse e r nm isCurried mbArgs -- In case we end up in the pointwise scenario, boolify the result -- as that's the only type we support here. - tryPointWise = do mbSExprs <- pointWiseExtract nm typ - case mbSExprs of - Nothing -> pure $ Left fallBack - Just sExprs -> pure $ maybe (Left fallBack) Right (convert sExprs) - - parse r bad $ \case EApp [EApp [ECon o, e]] | o == nm -> case parseSExprFunction e of - Just (Right assocs) | Just res <- convert assocs -> pure (Right res) - | True -> tryPointWise - - Just (Left nm') | nm == nm', let res = defaultKindedValue rt -> pure (Right ([], res)) - | True -> bad r Nothing - - Nothing -> tryPointWise + tryPointWise e = do mbSExprs <- pointWiseExtract nm typ + case mbSExprs of + Nothing -> pure $ Left $ fallBack e + Just sExprs -> pure $ maybe (Left $ fallBack e) Right (convert sExprs) - _ -> bad r Nothing + parse r bad $ \case + EApp [EApp [ECon o, e]] | unBar o == unBar nm -> case parseSExprFunction e of + Just (Right assocs) + | Just res <- convert assocs -> pure (Right res) + | True -> tryPointWise e + Just (Left nm') + | unBar nm == unBar nm' -> pure (Right ([], defaultKindedValue rt)) + | True -> bad r Nothing + Nothing -> tryPointWise e + _ -> bad r Nothing -- | Generalization of 'Data.SBV.Control.checkSat' checkSat :: (MonadIO m, MonadQuery m) => m CheckSatResult @@ -1301,7 +1328,7 @@ -- Generalization of 'Data.SBV.Control.getUIs'. getUIs :: forall m. (MonadIO m, MonadQuery m) => m [(String, (Bool, Maybe [String], SBVType))] getUIs = do State{rUIMap, rDefns, rIncState} <- queryState - -- NB. no need to worry about new-defines, because we don't allow definitions once query mode starts + -- Definitions are tracked in the UI map as well, but they are not uninterpreted. defineSet <- Map.keysSet <$> io (readIORef rDefns) prior <- io $ readIORef rUIMap @@ -1910,18 +1937,8 @@ setOpts <- liftIO $ reverse <$> readIORef (rSMTOptions st) -- Run any registered measure checks (termination/productivity verification) - liftIO $ do skip <- readIORef (rSkipMeasureChecks st) - unless skip $ do - checks <- readIORef (rMeasureChecks st) - unless (null checks) $ do - let nms = map (\(n, _, _) -> n) checks - debug cfg ["[MEASURE] Verifying termination measures for: " <> T.pack (intercalate ", " nms)] - mapM_ (\(nm, isProductive, check) -> do - debug cfg ["[MEASURE] Checking: " <> T.pack nm] - check cfg - let tag = if isProductive then "productive" else "terminating" - debug cfg ["[MEASURE] Passed (" <> tag <> "): " <> T.pack nm] - ) checks + checks <- liftIO $ readIORef (rMeasureChecks st) + liftIO $ verifyMeasureChecks cfg st checks let SMTProblem{smtLibPgm} = runProofOn rm queryContext [] res cfg' = cfg { solverSetOptions = solverSetOptions cfg ++ setOpts } diff --git a/Data/SBV/Core/Data.hs b/Data/SBV/Core/Data.hs --- a/Data/SBV/Core/Data.hs +++ b/Data/SBV/Core/Data.hs @@ -574,6 +574,13 @@ -- | Get the state associated with this context contextState :: m State + -- | Register a kind, synchronizing declarations when already in query mode. + -- Implementation hook for 'registerType'; callers should use that public API. + registerKindInContext :: Kind -> m () + default registerKindInContext :: MonadIO m => Kind -> m () + registerKindInContext k = do st <- contextState + liftIO $ registerKind st k + -- | Get an internal-variable internalVariable :: Kind -> m (SBV a) @@ -584,12 +591,12 @@ setLogic = setOption . SetLogic setInfo k = setOption . SetInfo k --- | Register a type with the solver. Like 'Data.SBV.Core.Model.registerFunction', This is typically not necessary --- since SBV will register types as it encounters them automatically. But there are cases --- where doing this can explicitly can come handy, typically in query contexts. +-- | Register a type eagerly, either before or inside a query. SBV automatically +-- registers types on first use, so ordinary symbolic computations do not need +-- this call. It can be useful before sending custom SMT-Lib commands that refer +-- to a type without first creating a symbolic value of that type. registerType :: forall a m. (MonadIO m, SolverContext m, HasKind a) => Proxy a -> m () -registerType _ = do st <- contextState - liftIO $ registerKind st (kindOf (Proxy @a)) +registerType _ = registerKindInContext (kindOf (Proxy @a)) -- | Various info we use in recoverKinded value newtype SInfo = SInfo { sInfoKinds :: [Kind] } diff --git a/Data/SBV/Core/Floating.hs b/Data/SBV/Core/Floating.hs --- a/Data/SBV/Core/Floating.hs +++ b/Data/SBV/Core/Floating.hs @@ -171,36 +171,67 @@ fromSFloat :: SRoundingMode -> SFloat -> SBV a fromSFloat = genericFromFloat - -- | Convert to an IEEE-754 Single-precision float. + -- | Convert to an IEEE-754 Single-precision float. Integral literals are + -- rounded directly to binary32 in the requested rounding mode. + -- + -- >>> unliteral (toSFloat sRTP (16777217 :: SInteger)) + -- Just 1.6777218e7 toSFloat :: SRoundingMode -> SBV a -> SFloat -- default definition if we have an integral like default toSFloat :: Integral a => SRoundingMode -> SBV a -> SFloat - toSFloat = genericToFloat (onlyWhenRNE (Just . fromRational . fromIntegral)) + toSFloat = genericToFloat (\rm -> Just . fpToFloat rm . roundIntegralFP 8 24 rm) -- | Convert from an IEEE74 double precision float. fromSDouble :: SRoundingMode -> SDouble -> SBV a fromSDouble = genericFromFloat - -- | Convert to an IEEE-754 Double-precision float. + -- | Convert to an IEEE-754 Double-precision float. Integral literals are + -- rounded directly to binary64 in the requested rounding mode. + -- + -- >>> unliteral (toSDouble sRTN (-9007199254740993 :: SInteger)) + -- Just (-9.007199254740994e15) toSDouble :: SRoundingMode -> SBV a -> SDouble -- default definition if we have an integral like default toSDouble :: Integral a => SRoundingMode -> SBV a -> SDouble - toSDouble = genericToFloat (onlyWhenRNE (Just . fromRational . fromIntegral)) + toSDouble = genericToFloat (\rm -> Just . fpToDouble rm . roundIntegralFP 11 53 rm) -- | Convert from an arbitrary floating point. fromSFloatingPoint :: ValidFloat eb sb => SRoundingMode -> SFloatingPoint eb sb -> SBV a fromSFloatingPoint = genericFromFloat - -- | Convert to an arbitrary floating point. + -- | Convert to an arbitrary floating point. Integral literals are rounded + -- directly to the target format in the requested rounding mode. + -- + -- >>> unliteral (toSFloatingPoint sRTP (2049 :: SInteger) :: SFPHalf) + -- Just 2050.0 + -- + -- >>> unliteral (toSFloatingPoint sRTN (-2049 :: SInteger) :: SFPHalf) + -- Just -2050.0 toSFloatingPoint :: ValidFloat eb sb => SRoundingMode -> SBV a -> SFloatingPoint eb sb - -- -- default definition if we have an integral like + -- Default definition for integral sources. default toSFloatingPoint :: (Integral a, ValidFloat eb sb) => SRoundingMode -> SBV a -> SFloatingPoint eb sb - toSFloatingPoint = genericToFloat (const (Just . fromRational . fromIntegral)) + toSFloatingPoint = integralToFloatingPoint --- Run the function if the conversion is in RNE. Otherwise return Nothing. +-- | Convert an integral source without an intermediate floating-point format. +-- Concrete inputs round the exact integer once; symbolic inputs or rounding +-- modes retain the ordinary floating-point cast expression. +integralToFloatingPoint :: forall a eb sb. (Integral a, IEEEFloatConvertible a, ValidFloat eb sb) + => SRoundingMode -> SBV a -> SFloatingPoint eb sb +integralToFloatingPoint = genericToFloat convert + where convert rm value = Just $ FloatingPoint $ roundIntegralFP ei si rm value + ei = intOfProxy (Proxy @eb) + si = intOfProxy (Proxy @sb) + +-- | Round an exact integer once to the requested format. Converting the result +-- to a matching native Float or Double is exact, including directed overflow. +roundIntegralFP :: Integral a => Int -> Int -> RoundingMode -> a -> FP +roundIntegralFP ei si rm value = FP ei si + $ fst (bfRoundFloat (mkBFOpts ei si (roundingModeToRoundMode rm)) (bfFromInteger (toInteger value))) + +-- | Run the function if the conversion is in RNE. Otherwise return Nothing. onlyWhenRNE :: (a -> Maybe b) -> RoundingMode -> a -> Maybe b onlyWhenRNE f RoundNearestTiesToEven v = f v onlyWhenRNE _ _ _ = Nothing @@ -218,7 +249,8 @@ xsv <- sbvToSV st f newExpr st kTo (SBVApp (IEEEFP (FP_Cast kFrom kTo msv)) [xsv]) --- | A generic to-float converter, which will constant-fold as necessary, but only in the sRNE mode for regular floats. +-- | A generic to-float converter. Fold concrete operands and rounding modes +-- when the supplied converter supports them; otherwise emit a symbolic cast. genericToFloat :: forall a r. (IEEEFloatConvertible a, IEEEFloating r) => (RoundingMode -> a -> Maybe r) -- How to convert concretely, if possible -> SRoundingMode -- Rounding mode diff --git a/Data/SBV/Core/Kind.hs b/Data/SBV/Core/Kind.hs --- a/Data/SBV/Core/Kind.hs +++ b/Data/SBV/Core/Kind.hs @@ -14,9 +14,11 @@ {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DeriveLift #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} @@ -27,7 +29,9 @@ {-# OPTIONS_GHC -Wall -Werror -Wno-orphans #-} module Data.SBV.Core.Kind ( - Kind(..), HasKind(..), smtType, hasUninterpretedSorts + Kind(KBool, KBounded, KUnbounded, KReal, KFloat, KDouble, KFP, KRational, KChar, KString, KVar, KApp, KADT, KList, KSet, KTuple, KArray) + , HasKind(..), smtType, hasUninterpretedSorts + , withADTDependencies, adtKindDependencies , BVIsNonZero, ValidFloat, intOfProxy , showBaseKind, needsFlattening , eqCheckIsObjectEq, containsFloats, isSomeKindOfFloat, expandKinds @@ -35,7 +39,7 @@ , kRoundingMode ) where -import qualified Data.Generics as G (Data(..), DataType, dataTypeName, tyconUQname) +import qualified Data.Generics as G (Data(..), DataType, Constr, Fixity(Prefix), mkConstr, mkDataType, dataTypeName, tyconUQname) import Data.Char (isSpace) import Data.Int @@ -62,6 +66,7 @@ import Data.SBV.Utils.Numeric (RoundingMode) import GHC.Generics +import qualified Language.Haskell.TH.Syntax as TH import qualified Data.Generics.Uniplate.Data as G -- | Kind of symbolic value @@ -93,9 +98,10 @@ -- Algebraic datatypes | KVar String -- only used temporarily during ADT construction | KApp String [Kind] -- Application of a constructor to a bunch of types - | KADT String + | KADTWithDependencies String [(String, Kind)] -- Parameters, applied to these args [(String, [Kind])] -- Constructors, and their fields + ADTDependencies -- Additional declarations needed to register this type -- Collections | KList Kind @@ -104,7 +110,64 @@ -- Arrays | KArray Kind Kind - deriving (Eq, Ord, G.Data, NFData, Generic) + deriving (Eq, Ord, G.Data, NFData, Generic, TH.Lift) + +-- | Compatibility constructor and pattern for an ADT kind. Registration +-- metadata does not change its symbolic identity or constructor fields. +pattern KADT :: String -> [(String, Kind)] -> [(String, [Kind])] -> Kind +pattern KADT typeName parameters constructors <- KADTWithDependencies typeName parameters constructors _ + where KADT typeName parameters constructors = KADTWithDependencies typeName parameters constructors (ADTDependencies []) + +{-# COMPLETE KBool, KBounded, KUnbounded, KReal, KFloat, KDouble, KFP, KRational, KChar, KString, KVar, KApp, KADT, KList, KSet, KTuple, KArray #-} + +-- | A finite set of independent ADT declaration templates. These are +-- registration metadata, not children of the annotated type: generic kind +-- traversal and type-variable substitution must not enter their scopes. +newtype ADTDependencies = ADTDependencies [Kind] + deriving (NFData, Generic, TH.Lift) + +-- | Registration metadata does not participate in kind equality. +-- For a given datatype name, generated dependency schemas are fixed and +-- interchangeable; this annotation must not carry per-instantiation semantics. +instance Eq ADTDependencies where + _ == _ = True + +-- | Registration metadata does not participate in kind ordering. +-- This uses the same name-determined-schema invariant as the equality instance. +instance Ord ADTDependencies where + compare _ _ = EQ + +-- | Keep independent declaration scopes opaque to generic transformations. +-- Reconstructing the metadata's nullary generic representation yields the +-- empty annotation; ordinary traversals preserve the existing annotation. +instance G.Data ADTDependencies where + gfoldl _ z = z + gunfold _ z _ = z (ADTDependencies []) + toConstr _ = adtDependenciesConstr + dataTypeOf _ = adtDependenciesDataType + +-- | Opaque generic datatype for ADT registration metadata. +adtDependenciesDataType :: G.DataType +adtDependenciesDataType = G.mkDataType "Data.SBV.Core.Kind.ADTDependencies" [adtDependenciesConstr] + +-- | Nullary generic constructor for ADT registration metadata. +adtDependenciesConstr :: G.Constr +adtDependenciesConstr = G.mkConstr adtDependenciesDataType "ADTDependencies" [] G.Prefix + +-- | Attach the complete dependency registry generated by 'Data.SBV.mkSymbolic'. +-- Strip annotations throughout each dependency so mutually recursive kinds +-- remain finite even when recursion passes through a datatype parameter. +withADTDependencies :: [Kind] -> Kind -> Kind +withADTDependencies dependencies (KADT typeName parameters constructors) + = KADTWithDependencies typeName parameters constructors (ADTDependencies (map (G.transform strip) dependencies)) + where strip (KADT n ps cs) = KADT n ps cs + strip kind = kind +withADTDependencies _ kind = error $ "SBV: Expected an ADT kind when attaching dependencies, received " ++ show kind + +-- | Return the independent declaration templates needed to register an ADT. +adtKindDependencies :: Kind -> [Kind] +adtKindDependencies (KADTWithDependencies _ _ _ (ADTDependencies dependencies)) = dependencies +adtKindDependencies _ = [] -- | Built in kind for rounding mode kRoundingMode :: Kind diff --git a/Data/SBV/Core/Model.hs b/Data/SBV/Core/Model.hs --- a/Data/SBV/Core/Model.hs +++ b/Data/SBV/Core/Model.hs @@ -2543,7 +2543,7 @@ mapOpSVs :: (SV -> SV) -> Op -> Op mapOpSVs f (LkUp p sv1 sv2) = LkUp p (f sv1) (f sv2) mapOpSVs f (IEEEFP (FP_Cast fk tk sv)) = IEEEFP (FP_Cast fk tk (f sv)) -mapOpSVs _ (ArrayInit (Right (SMTLambda s))) = ArrayInit (Right (SMTLambda s)) -- Lambda strings don't contain SVs to map +mapOpSVs _ (ArrayInit (Right lambdaDef)) = ArrayInit (Right lambdaDef) -- Lambda-local SVs must not be mapped in the enclosing DAG. mapOpSVs _ op = op -- | Compute the reaching condition for each SV: under what boolean condition @@ -4123,41 +4123,18 @@ -- You can also define higher-order functions, see 'smtHOFunction' for that purpose. smtFunctionDef :: (Typeable a, Lambda Symbolic a) => String -> Measure a -> a -> a - -- | Register a function. This function is typically not needed as SBV will register functions used - -- automatically upon first use. However, there are scenarios (in particular query contexts) - -- where the definition isn't used before query-mode starts, and SBV (for historical reasons) - -- requires functions to be known before query-mode starts executing. In such cases, use this function - -- to register them with the system. + -- | Register a function eagerly. This function is typically not needed, since SBV registers functions + -- automatically upon first use, including uses first encountered in query mode. Use it to include an + -- otherwise unused uninterpreted function in 'Data.SBV.allSat' enumeration, or to declare one before + -- checking satisfiability and retrieving its interpretation with 'Data.SBV.Control.getFunction'. + -- It also lets you request definition validation and any termination or productivity checks before + -- the function is otherwise needed. Registration does not constrain the function's result. + -- Internally, it applies the function to fresh internal arguments to discover its definition; + -- these argument declarations and the application can appear in SMT transcripts. registerFunction :: a -> Symbolic () -- | Uninterpret a value, i.e., add this value as a completely undefined value/function that -- the solver is free to instantiate to satisfy other constraints. - -- - -- __Known issues__ - -- - -- Usually using an uninterpret function will register itself to the solver, but sometimes the laziness - -- of the evaluation might render this unreliable. - -- - -- For example, when working with quantifiers and uninterpreted functions with the following code: - -- - -- > runSMTWith z3 $ do - -- > let f = uninterpret "f" :: SInteger -> SInteger - -- > query $ do - -- > constrain $ \(Forall (b :: SInteger)) -> f b .== f b - -- > checkSat - -- - -- The solver will complain about the unknown constant @f (Int)@. - -- - -- A workaround of this is to explicit register them with 'Data.SBV.Control.registerUISMTFunction': - -- - -- > runSMTWith z3 $ do - -- > let f = uninterpret "f" :: SInteger -> SInteger - -- > registerUISMTFunction f - -- > query $ do - -- > constrain $ \(Forall (b :: SInteger)) -> f b .== f b - -- > checkSat - -- - -- See https://github.com/LeventErkok/sbv/issues/711 for more info. uninterpret :: String -> a -- | Uninterpret a value, with named arguments in case of functions. SBV will use these @@ -4223,8 +4200,11 @@ (def, info) <- lambdaWithInfo st TopLevel fk v -- Record LambdaInfo for SCC-aware mutual recursion checking modifyIORef' (rFuncLambdaInfos st) (Map.insert funcNm info) - let barFuncNm = barify funcNm + let rootState = getRootState st + barFuncNm = barify funcNm tBarFuncNm = T.pack barFuncNm + addMeasureCheck check = modifyState rootState rMeasureChecks (check :) + $ modifyIncState rootState rNewMeasureChecks (check :) isSelfRec = any (\(_, SBVApp op _) -> case op of Uninterpreted n -> n == tBarFuncNm _ -> False) @@ -4236,37 +4216,29 @@ case msr of AutoMeasure -> do when isSelfRec $ - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> autoGuessOrFail cfg funcNm info) :) + addMeasureCheck (funcNm, False, \cfg -> autoGuessOrFail cfg funcNm info) when hasCrossRefs $ - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> checkMutualFromState cfg funcNm st Nothing) :) + addMeasureCheck (funcNm, False, \cfg -> checkMutualFromState cfg funcNm st Nothing) pure def HasMeasure eval helpers -> do when isSelfRec $ - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> verifyMeasure cfg funcNm info eval helpers) :) + addMeasureCheck (funcNm, False, \cfg -> verifyMeasure cfg funcNm info eval helpers) when hasCrossRefs $ - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> checkMutualFromState cfg funcNm st (Just eval)) :) + addMeasureCheck (funcNm, False, \cfg -> checkMutualFromState cfg funcNm st (Just eval)) pure def HasContract eval ceval helpers -> do when hasCrossRefs $ - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> rejectMutualContractFromState cfg funcNm st) :) - modifyIORef' (rMeasureChecks st) - ((funcNm, False, \cfg -> verifyMeasureWithContract cfg funcNm info eval ceval helpers) :) + addMeasureCheck (funcNm, False, \cfg -> rejectMutualContractFromState cfg funcNm st) + addMeasureCheck (funcNm, False, \cfg -> verifyMeasureWithContract cfg funcNm info eval ceval helpers) pure def Productive -> do when isSelfRec $ - modifyIORef' (rMeasureChecks st) - ((funcNm, True, \cfg -> verifyGuardedness cfg funcNm info) :) + addMeasureCheck (funcNm, True, \cfg -> verifyGuardedness cfg funcNm info) when hasCrossRefs $ - modifyIORef' (rMeasureChecks st) - ((funcNm, True, \cfg -> checkMutualProductiveFromState cfg funcNm st) :) + addMeasureCheck (funcNm, True, \cfg -> checkMutualProductiveFromState cfg funcNm st) pure def Unverified -> do modifyIORef' (rNoTermCheckFunctions st) (Set.insert nm) @@ -4437,7 +4409,8 @@ mapM_ forceSVArg svs newExpr st ka $ SBVApp op svs - registerFunction x = constrain $ x .== x + registerFunction x = do st <- symbolicEnv + liftIO $ sbvToSV st x >>= forceSVArg symWithKind nm = sym (nm ++ "_" ++ show (kindOf (Proxy @a))) @@ -5011,8 +4984,8 @@ -> (a -> SBV b) -- ^ The ho-function we're modeling -> a -> SBV b -- ^ The resulting function smtHOFunctionGen nm f measure hof arg = SBV $ SVal (kindOf (Proxy @(SBV b))) $ Right $ cache r - where r st = do SMTLambda lam <- lambdaStr st HigherOrderArg (arrayResultKind (kindOf (Proxy @f))) f - let uniq = lambdaFingerprint st (T.unpack lam) + where r st = do lambdaDef <- lambdaStr st HigherOrderArg (arrayResultKind (kindOf (Proxy @f))) f + let uniq = lambdaFingerprint st (T.unpack (smtLambdaText lambdaDef)) sbvToSV st (smtFunctionDef (atProxy (Proxy @f) nm <> "_" <> uniq) measure hof arg) -- | Chase through nested array kinds to find the final result kind. Higher-order diff --git a/Data/SBV/Core/Symbolic.hs b/Data/SBV/Core/Symbolic.hs --- a/Data/SBV/Core/Symbolic.hs +++ b/Data/SBV/Core/Symbolic.hs @@ -22,11 +22,13 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE ViewPatterns #-} {-# OPTIONS_GHC -Wall -Werror -Wno-orphans #-} @@ -34,7 +36,8 @@ ( NodeId(..) , SV(..), swKind, trueSV, falseSV , Op(..), PBOp(..), OvOp(..), FPOp(..), NROp(..), StrOp(..), RegExOp(..), SeqOp(..), SetOp(..), SpecialRelOp(..), ADTOp(..) - , RegExp(..), regExpToSMTString, SMTLambda(..) + , RegExp(..), regExpToSMTString, validateRegExp + , SMTLambda(SMTLambda), smtLambdaWithInfo, smtLambdaText, smtLambdaInfo , Quantifier(..), needsExistentials, SBVContext(..), globalSBVContext, VarContext(..) , SBVType(..), svUninterpreted, svUninterpretedNamedArgs, newUninterpreted , SVal(..) @@ -46,7 +49,7 @@ , getUserName', getUserName , lookupInput , getSValPathCondition, extendSValPathCondition , getTableIndex, sObserve - , SBVPgm(..), MonadSymbolic(..), SymbolicT, Symbolic, runSymbolic, mkNewState, runSymbolicInState, State(..), SMTDef(..), smtDefEq, conflictError, withNewIncState, IncState(..), incrementInternalCounter, incrementFreshNameCounter + , SBVPgm(..), MonadSymbolic(..), SymbolicT, Symbolic, runSymbolic, mkNewState, runSymbolicInState, State(..), SMTDef(SMTDef), smtDefWithInfo, smtDefInfo, smtDefEq, conflictError, withNewIncState, IncState(..), incrementInternalCounter, incrementFreshNameCounter , inSMTMode, SBVRunMode(..), IStage(..), Result(..), ResultInp(..), UICodeKind(..), UIName(..) , registerKind, registerLabel, recordObservable , addAssertion, addNewSMTOption, imposeConstraint, internalConstraint, newInternalVariable, lambdaVar, quantVar @@ -247,9 +250,9 @@ deriving (Eq, Ord, Generic, G.Data, NFData) -- | ADT operations -data ADTOp = ADTConstructor T.Text Kind -- Construct an ADT. Kind is the kind of the resulting ADT - | ADTTester T.Text Kind -- Check if top-level constructor matches. Kind is the kind of the argument - | ADTAccessor T.Text Kind -- Extract a field from an ADT value. Kind is the kind of the argument +data ADTOp = ADTConstructor T.Text Kind -- Construct an ADT. Kind is the kind of the result. + | ADTTester T.Text Kind -- Check if top-level constructor matches. Kind is the kind of the result. + | ADTAccessor T.Text Kind -- Extract a field from an ADT value. Kind is the kind of the result. deriving (Eq, Ord, Generic, G.Data, NFData) -- | Special relations supported by z3 @@ -415,14 +418,14 @@ | AllChar -- ^ Accept every single character | None -- ^ Accept no strings | Range Char Char -- ^ Accept range of characters - | Conc [RegExp] -- ^ Concatenation + | Conc [RegExp] -- ^ Concatenation; the empty list matches exactly the empty string | KStar RegExp -- ^ Kleene Star: Zero or more | KPlus RegExp -- ^ Kleene Plus: One or more | Opt RegExp -- ^ Zero or one | Comp RegExp -- ^ Complement of regular expression | Diff RegExp RegExp -- ^ Difference of regular expressions - | Loop Int Int RegExp -- ^ From @n@ repetitions to @m@ repetitions - | Power Int RegExp -- ^ Exactly @n@ repetitions, i.e., nth power + | Loop Int Int RegExp -- ^ From @n@ repetitions to @m@ repetitions; requires @0 <= n <= m@ + | Power Int RegExp -- ^ Exactly @n@ repetitions, i.e., nth power; requires @n >= 0@ | Union [RegExp] -- ^ Union of regular expressions | Inter RegExp RegExp -- ^ Intersection of regular expressions deriving (Eq, Ord, G.Data, Generic, NFData) @@ -460,11 +463,35 @@ -- | Convert a reg-exp to a Haskell-like string instance Show RegExp where - show = T.unpack . regExpToText (T.pack . show) + show r = validateRegExp r `seq` T.unpack (regExpToText (T.pack . show) r) +-- | Reject invalid repetition bounds throughout a regex, even in branches +-- that literal matching could skip. Sharing this check keeps literal matching +-- and SMT serialization consistent without constructing text during folding. +validateRegExp :: RegExp -> () +validateRegExp (Literal _) = () +validateRegExp All = () +validateRegExp AllChar = () +validateRegExp None = () +validateRegExp (Range _ _) = () +validateRegExp (Conc rs) = foldr (seq . validateRegExp) () rs +validateRegExp (KStar r) = validateRegExp r +validateRegExp (KPlus r) = validateRegExp r +validateRegExp (Opt r) = validateRegExp r +validateRegExp (Comp r) = validateRegExp r +validateRegExp (Diff a b) = validateRegExp a `seq` validateRegExp b +validateRegExp (Loop lo hi r) + | lo >= 0, hi >= lo = validateRegExp r + | True = error $ "Invalid regular-expression Loop with arguments: " ++ show (lo, hi) +validateRegExp (Power n r) + | n >= 0 = validateRegExp r + | True = error $ "Invalid regular-expression Power with arguments: " ++ show n +validateRegExp (Union rs) = foldr (seq . validateRegExp) () rs +validateRegExp (Inter a b) = validateRegExp a `seq` validateRegExp b + -- | Convert a reg-exp to a SMT-lib acceptable representation regExpToSMTString :: RegExp -> Text -regExpToSMTString = regExpToText (\s -> "\"" <> T.pack (stringToQFS s) <> "\"") +regExpToSMTString r = validateRegExp r `seq` regExpToText (\s -> "\"" <> T.pack (stringToQFS s) <> "\"") r -- | Convert a RegExp to text, parameterized by how strings are converted regExpToText :: (String -> Text) -> RegExp -> Text @@ -473,7 +500,7 @@ regExpToText _ AllChar = "re.allchar" regExpToText _ None = "re.nostr" regExpToText fs (Range ch1 ch2) = "(re.range " <> fs [ch1] <> " " <> fs [ch2] <> ")" -regExpToText _ (Conc []) = "1" +regExpToText fs (Conc []) = regExpToText fs (Literal "") regExpToText fs (Conc [x]) = regExpToText fs x regExpToText fs (Conc xs) = "(re.++ " <> T.unwords (map (regExpToText fs) xs) <> ")" regExpToText fs (KStar r) = "(re.* " <> regExpToText fs r <> ")" @@ -481,12 +508,8 @@ regExpToText fs (Opt r) = "(re.opt " <> regExpToText fs r <> ")" regExpToText fs (Comp r) = "(re.comp " <> regExpToText fs r <> ")" regExpToText fs (Diff r1 r2) = "(re.diff " <> regExpToText fs r1 <> " " <> regExpToText fs r2 <> ")" -regExpToText fs (Loop lo hi r) - | lo >= 0, hi >= lo = "((_ re.loop " <> showText lo <> " " <> showText hi <> ") " <> regExpToText fs r <> ")" - | True = error $ "Invalid regular-expression Loop with arguments: " ++ show (lo, hi) -regExpToText fs (Power n r) - | n >= 0 = regExpToText fs (Loop n n r) - | True = error $ "Invalid regular-expression Power with arguments: " ++ show n +regExpToText fs (Loop lo hi r) = "((_ re.loop " <> showText lo <> " " <> showText hi <> ") " <> regExpToText fs r <> ")" +regExpToText fs (Power n r) = regExpToText fs (Loop n n r) regExpToText fs (Inter r1 r2) = "(re.inter " <> regExpToText fs r1 <> " " <> regExpToText fs r2 <> ")" regExpToText _ (Union []) = "re.nostr" regExpToText fs (Union [x]) = regExpToText fs x @@ -506,15 +529,51 @@ show (RegExEq r1 r2) = "(= " ++ T.unpack (regExpToSMTString r1) ++ " " ++ T.unpack (regExpToSMTString r2) ++ ")" show (RegExNEq r1 r2) = "(distinct " ++ T.unpack (regExpToSMTString r1) ++ " " ++ T.unpack (regExpToSMTString r2) ++ ")" --- | For now, we represent lambda functions in op with their SMTLib equivalent strings. --- This might change in the future. -newtype SMTLambda = SMTLambda T.Text - deriving (Eq, Ord, G.Data, Generic) - deriving newtype NFData +-- | A lambda's canonical SMT-Lib representation, optionally accompanied by +-- the expression DAG from which it was rendered. The structured form lets +-- non-SMT backends consume lambdas without parsing SMT-Lib. +data SMTLambda = SMTLambdaValue T.Text (Maybe LambdaInfo) + deriving (G.Data, Generic) +-- | Compatibility constructor and pattern for an SMT-text-only lambda. The +-- pattern also matches lambdas carrying retained backend metadata. +pattern SMTLambda :: T.Text -> SMTLambda +pattern SMTLambda textValue <- (smtLambdaText -> textValue) + where SMTLambda textValue = SMTLambdaValue textValue Nothing + +{-# COMPLETE SMTLambda #-} + +-- | Construct a lambda with both its canonical SMT-Lib text and retained +-- expression DAG. +smtLambdaWithInfo :: T.Text -> LambdaInfo -> SMTLambda +smtLambdaWithInfo textValue lambdaInfo = SMTLambdaValue textValue (Just lambdaInfo) + +-- | Compare lambdas by their canonical SMT-Lib representation. The retained +-- DAG is backend metadata and does not affect symbolic identity. +instance Eq SMTLambda where + left == right = smtLambdaText left == smtLambdaText right + +-- | Order lambdas by their canonical SMT-Lib representation. The retained +-- DAG is backend metadata and does not affect symbolic identity. +instance Ord SMTLambda where + compare left right = compare (smtLambdaText left) (smtLambdaText right) + +-- | Fully evaluate both the canonical text and any retained expression DAG. +instance NFData SMTLambda where + rnf (SMTLambdaValue textValue lambdaInfo) = rnf textValue `seq` rnf lambdaInfo + +-- | Return the canonical SMT-Lib rendering of a lambda. +smtLambdaText :: SMTLambda -> T.Text +smtLambdaText (SMTLambdaValue textValue _) = textValue + +-- | Return a lambda's retained expression DAG when it was constructed by +-- SBV rather than directly from an SMT-Lib string. +smtLambdaInfo :: SMTLambda -> Maybe LambdaInfo +smtLambdaInfo (SMTLambdaValue _ lambdaInfo) = lambdaInfo + -- | Simple show instance for SMTLambda instance Show SMTLambda where - show (SMTLambda s) = T.unpack s + show = T.unpack . smtLambdaText -- | Sequence operations. Indexed by the element kind. data SeqOp = SeqLen Kind @@ -1002,13 +1061,15 @@ CodeGen -> True -- | The state in query mode, i.e., additional context -data IncState = IncState { rNewInps :: IORef [NamedSymVar] -- always existential! - , rNewKinds :: IORef KindSet - , rNewConsts :: IORef CnstMap - , rNewTbls :: IORef TableMap - , rNewUIs :: IORef UIMap - , rNewAsgns :: IORef SBVPgm - , rNewConstraints :: IORef (S.Seq (Bool, [(String, String)], SV)) +data IncState = IncState { rNewInps :: IORef [NamedSymVar] -- always existential! + , rNewKinds :: IORef KindSet + , rNewConsts :: IORef CnstMap + , rNewTbls :: IORef TableMap + , rNewUIs :: IORef UIMap + , rNewDefns :: IORef (Map.Map String (SMTDef, SBVType)) + , rNewMeasureChecks :: IORef [(String, Bool, SMTConfig -> IO ())] + , rNewAsgns :: IORef SBVPgm + , rNewConstraints :: IORef (S.Seq (Bool, [(String, String)], SV)) } -- | Get a new IncState @@ -1019,15 +1080,19 @@ nc <- newIORef Map.empty tm <- newIORef Map.empty ui <- newIORef Map.empty + ds <- newIORef Map.empty + ms <- newIORef [] pgm <- newIORef (SBVPgm S.empty) cstrs <- newIORef S.empty - pure IncState { rNewInps = is - , rNewKinds = ks - , rNewConsts = nc - , rNewTbls = tm - , rNewUIs = ui - , rNewAsgns = pgm - , rNewConstraints = cstrs + pure IncState { rNewInps = is + , rNewKinds = ks + , rNewConsts = nc + , rNewTbls = tm + , rNewUIs = ui + , rNewDefns = ds + , rNewMeasureChecks = ms + , rNewAsgns = pgm + , rNewConstraints = cstrs } -- | Get a new IncState @@ -1110,16 +1175,36 @@ -- we use the more expensive O (n) to find the index and the elem secondLookup = S.elemIndexL sv svs >>= flip S.lookup ns --- | A defined function/value -data SMTDef = SMTDef Kind -- ^ Final kind of the definition (resulting kind, not the params) - [String] -- ^ other definitions it refers to - (Maybe Text) -- ^ parameter string - (Int -> Text) -- ^ Body, in SMTLib syntax, given the tab amount +-- | A defined function/value, optionally retaining its structured expression +-- DAG for consumers other than SMT-Lib. +data SMTDef = SMTDefValue Kind -- ^ Final kind of the definition (resulting kind, not the params) + [String] -- ^ other definitions it refers to + (Maybe Text) -- ^ parameter string + (Int -> Text) -- ^ Body, in SMTLib syntax, given the tab amount + (Maybe LambdaInfo) -- ^ Structured function body, when constructed by SBV deriving G.Data +-- | Compatibility constructor and pattern for an SMT-text definition. The +-- pattern also matches definitions carrying retained backend metadata. +pattern SMTDef :: Kind -> [String] -> Maybe Text -> (Int -> Text) -> SMTDef +pattern SMTDef resultKind dependencies parameters body <- SMTDefValue resultKind dependencies parameters body _ + where SMTDef resultKind dependencies parameters body = SMTDefValue resultKind dependencies parameters body Nothing + +{-# COMPLETE SMTDef #-} + +-- | Attach a structured expression DAG to an SMT definition. +smtDefWithInfo :: SMTDef -> LambdaInfo -> SMTDef +smtDefWithInfo (SMTDefValue resultKind dependencies parameters body _) lambdaInfo + = SMTDefValue resultKind dependencies parameters body (Just lambdaInfo) + +-- | Return a definition's retained expression DAG, when it was constructed by +-- SBV rather than supplied only as SMT-Lib text. +smtDefInfo :: SMTDef -> Maybe LambdaInfo +smtDefInfo (SMTDefValue _ _ _ _ lambdaInfo) = lambdaInfo + -- | For debug purposes instance Show SMTDef where - show (SMTDef fk frees p body) = unlines [ "-- User defined function:" + show (SMTDefValue fk frees p body _) = unlines [ "-- User defined function:" , "-- Final return type : " ++ show fk , "-- Refers to : " ++ intercalate ", " frees , "-- Parameters : " ++ maybe "NONE" T.unpack p @@ -1129,12 +1214,13 @@ -- | NFData instance for SMTDef instance NFData SMTDef where - rnf (SMTDef fk frees params body) = rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body + rnf (SMTDefValue fk frees params body lambdaInfo) + = rnf fk `seq` rnf frees `seq` rnf params `seq` rnf body `seq` rnf lambdaInfo -- | Compare two SMTDef values for semantic equality. -- The body is @(Int -> Text)@ where @Int@ is indentation; we compare rendered output at indent 0. smtDefEq :: SMTDef -> SMTDef -> Bool -smtDefEq (SMTDef k1 refs1 params1 body1) (SMTDef k2 refs2 params2 body2) +smtDefEq (SMTDefValue k1 refs1 params1 body1 _) (SMTDefValue k2 refs2 params2 body2 _) = k1 == k2 && refs1 == refs2 && params1 == params2 && body1 0 == body2 0 -- | Error for conflicting smtFunction definitions with the same name. @@ -1149,14 +1235,21 @@ , "*** Please use a unique name for each distinct function." ] --- | Information about a compiled lambda body, used for measure verification. +-- | Structured information about a compiled lambda body, used for measure +-- verification and by backends that should not parse its SMT-Lib rendering. data LambdaInfo = LambdaInfo - { liAssignments :: S.Seq (SV, SBVExpr) -- ^ The expression DAG - , liParams :: [(Quantifier, SV)] -- ^ Formal parameters with quantifier - , liOutput :: SV -- ^ The output node - , liConsts :: [(SV, CV)] -- ^ Constants used - } + { liAssignments :: S.Seq (SV, SBVExpr) -- ^ The expression DAG + , liParams :: [(Quantifier, SV)] -- ^ Formal parameters with quantifier + , liOutput :: SV -- ^ The output node + , liConsts :: [(SV, CV)] -- ^ Constants used + , liTables :: [((Int, Kind, Kind), [SV])] -- ^ Finite lookup tables used by the body + } deriving G.Data +-- | Fully evaluate the retained pieces of a compiled lambda body. +instance NFData LambdaInfo where + rnf LambdaInfo{liAssignments, liParams, liOutput, liConsts, liTables} + = rnf liAssignments `seq` rnf liParams `seq` rnf liOutput `seq` rnf liConsts `seq` rnf liTables + -- | The state of the symbolic interpreter data State = State { sbvContext :: SBVContext , pathCond :: SVal -- ^ kind KBool @@ -1326,7 +1419,9 @@ newUninterpreted :: State -> UIName -> Maybe [String] -> SBVType -> UICodeKind -> IO Op newUninterpreted st uiName mbArgNames t uiCode = do - let (adtOp, candName) = case uiName of + let rootState = getRootState st + + (adtOp, candName) = case uiName of UIGiven n -> (False, n) UIADT o -> case o of ADTConstructor n _ -> (True, T.unpack n) @@ -1359,15 +1454,9 @@ Just (oldDef, _) | not (smtDefEq d oldDef) -> conflictError nm - _ -> pure () - modifyState st rDefns (Map.insert nm (d, t)) - $ noInteractive [ "Defined functions (smtFunction):" - , " Name: " ++ nm ++ extraComment - , " Type: " ++ show t - , "" - , "You should explicitly register these functions by calling" - , "the function 'registerFunction' on them before starting the query section." - ] + Just{} -> pure () + Nothing -> modifyState rootState rDefns (Map.insert nm (d, t)) + $ modifyIncState rootState rNewDefns (Map.insert nm (d, t)) pure True UICgC c -> -- No need to record the code in interactive mode: CodeGen doesn't use interactive do modifyState st rCgMap (Map.insert nm c) (pure ()) @@ -1385,8 +1474,8 @@ uiMap <- readIORef (rUIMap st) case nm `Map.lookup` uiMap of Just (_, _, t') -> checkType t' (pure ()) - Nothing -> modifyState st rUIMap (Map.insert nm (isCurried, mbArgNames, t)) - $ modifyIncState st rNewUIs + Nothing -> modifyState rootState rUIMap (Map.insert nm (isCurried, mbArgNames, t)) + $ modifyIncState rootState rNewUIs (\newUIs -> case nm `Map.lookup` newUIs of Just (_, _, t') -> checkType t' newUIs Nothing -> Map.insert nm (isCurried, mbArgNames, t) newUIs) @@ -1456,9 +1545,12 @@ -- * If it's an uninterpreted sort that's not already in the general state -- * OR If it's a tuple-sort whose cardinality isn't already in the general state -- * OR If it's a list that's not already in the general state (so we can send the flatten commands) + -- * OR If rationals are first used, so we can declare their datatype and equality helpers - existingKinds <- readIORef (rUsedKinds st) + let rootState = getRootState st + existingKinds <- readIORef (rUsedKinds rootState) + -- For ADTs we need to make sure we haven't added it before let adtNameExists s = any (\case KADT s' _ _ -> s == s'; _ -> False) existingKinds @@ -1467,7 +1559,7 @@ _ -> False unless adtExists $ - modifyState st rUsedKinds (Set.insert k) $ do + modifyState rootState rUsedKinds (Set.insert k) $ do -- Why do we discriminate here? Because the incremental context is sensitive to the -- order: In particular, if an uninterpreted kind is already in there, we don't @@ -1475,10 +1567,11 @@ let needsAdding = case k of KADT s _ _ -> not (adtNameExists s) KList{} -> k `Set.notMember` existingKinds + KRational -> k `Set.notMember` existingKinds KTuple nks -> not $ any (\case KTuple oks -> length nks == length oks; _ -> False) existingKinds _ -> False - when needsAdding $ modifyIncState st rNewKinds (Set.insert k) + when needsAdding $ modifyIncState rootState rNewKinds (Set.insert k) -- Don't forget to register subkinds! case k of @@ -1495,7 +1588,7 @@ KString {} -> pure () KApp _ ks -> mapM_ (registerKind st) ks - KADT _ pks cks -> mapM_ (registerKind st) (map snd pks ++ concatMap snd cks) + KADT _ pks cks -> mapM_ (registerKind st) (map snd pks ++ concatMap snd cks ++ adtKindDependencies k) KList ek -> registerKind st ek KSet ek -> registerKind st ek KTuple eks -> mapM_ (registerKind st) eks @@ -1990,17 +2083,15 @@ -- | Generalization of 'Data.SBV.addNewSMTOption' addNewSMTOption :: MonadSymbolic m => SMTOption -> m () addNewSMTOption o = do st <- symbolicEnv + codeGeneration <- liftIO $ isCodeGenMode st + when codeGeneration $ error "SBV->C: SMT solver options have no executable C semantics; remove setOption from the code-generation program." liftIO $ modifyState st rSMTOptions (o:) (pure ()) -- | Generalization of 'Data.SBV.imposeConstraint' imposeConstraint :: MonadSymbolic m => Bool -> [(String, String)] -> SVal -> m () imposeConstraint isSoft attrs c = do st <- symbolicEnv - rm <- liftIO $ readIORef (runMode st) - - case rm of - CodeGen -> error "SBV: constraints are not allowed in code-generation" - _ -> liftIO $ do mapM_ (registerLabel "Constraint" st) [nm | (":named", nm) <- attrs] - internalConstraint st isSoft attrs c + liftIO $ do mapM_ (registerLabel "Constraint" st) [nm | (":named", nm) <- attrs] + internalConstraint st isSoft attrs c -- | Require a boolean condition to be true in the state. Only used for internal purposes. internalConstraint :: State -> Bool -> [(String, String)] -> SVal -> IO () @@ -2029,6 +2120,10 @@ -- | Generalization of 'Data.SBV.addSValOptGoal' addSValOptGoal :: MonadSymbolic m => Objective SVal -> m () addSValOptGoal obj = do st <- symbolicEnv + mode <- liftIO $ readIORef (runMode st) + case mode of + CodeGen -> error "SBV->C: Optimization objectives require a solver and cannot be compiled to executable C." + _ -> pure () -- create the tracking variable here for the metric let mkGoal nm orig = liftIO $ do origSV <- svToSV st orig diff --git a/Data/SBV/Dynamic.hs b/Data/SBV/Dynamic.hs --- a/Data/SBV/Dynamic.hs +++ b/Data/SBV/Dynamic.hs @@ -111,7 +111,7 @@ , SBVCodeGen -- ** Setting code-generation options - , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile + , cgPerformRTCs, cgSetDriverValues, cgArrayEqualityLimit, cgRegexLimits, cgGenerateDriver, cgGenerateMakefile -- ** Designating inputs , svCgInput, svCgInputArr @@ -148,7 +148,7 @@ , svCgInput, svCgInputArr , svCgOutput, svCgOutputArr , svCgReturn, svCgReturnArr - , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile + , cgPerformRTCs, cgSetDriverValues, cgArrayEqualityLimit, cgRegexLimits, cgGenerateDriver, cgGenerateMakefile , cgAddPrototype, cgAddDecl, cgAddLDFlags, cgIgnoreSAssert , cgIntegerSize, cgSRealType, CgSRealType(..) ) diff --git a/Data/SBV/Internals.hs b/Data/SBV/Internals.hs --- a/Data/SBV/Internals.hs +++ b/Data/SBV/Internals.hs @@ -41,6 +41,9 @@ , genLiteral, genFromCV, CV(..), genMkSymVar, genParse, showModel, SMTModel(..), liftQRem, liftDMod, registerKind, svToSV , ProvableM(), SatisfiableM(), UICodeKind(..) + -- * Kind traversal and ADT registration metadata + , expandKinds, substituteADTVars, withADTDependencies, adtKindDependencies + -- * Compilation to C, extras , compileToC', compileToCLib' @@ -60,6 +63,9 @@ -- $coordinateSolverInfo , sendStringToSolver, sendRequestToSolver, retrieveResponseFromSolver + -- * Parsing and formatting solver responses + , SExpr(..), parseSExpr, formatFunctionResponse + -- * Defining new metrics , addSValOptGoal , sFloatAsComparableSWord32, sDoubleAsComparableSWord64, sFloatingPointAsComparableSWord @@ -79,7 +85,7 @@ import Data.SBV.Core.Data hiding (Forall(..), Exists(..), ForallN(..), ExistsN(..), ExistsUnique(..), Skolemize(..), QNot(..)) -import Data.SBV.Core.Kind (BVIsNonZero, ValidFloat) +import Data.SBV.Core.Kind (BVIsNonZero, ValidFloat, expandKinds, substituteADTVars, withADTDependencies, adtKindDependencies) import Data.SBV.Core.Model (genLiteral, genFromCV, genMkSymVar, liftQRem, liftDMod) import Data.SBV.Core.Symbolic (IStage(..), QueryContext(..), MonadQuery, addSValOptGoal, registerKind, VarContext(..), svToSV, mkNewState, UICodeKind(..), UIName(..)) @@ -99,6 +105,7 @@ import Data.SBV.Utils.TDiff import Data.SBV.Utils.PrettyNum +import Data.SBV.Utils.SExpr (SExpr(..), parseSExpr, formatFunctionResponse) import GHC.TypeLits diff --git a/Data/SBV/Lambda.hs b/Data/SBV/Lambda.hs --- a/Data/SBV/Lambda.hs +++ b/Data/SBV/Lambda.hs @@ -34,7 +34,7 @@ import Data.SBV.Core.Data import Data.SBV.Core.Kind import Data.SBV.SMT.SMTLib2 -import Data.SBV.Utils.Lib (showText) +import Data.SBV.Utils.Lib (mapToSortedList, showText) import Data.SBV.Utils.PrettyNum import Data.SBV.Core.Symbolic hiding (mkNewState) @@ -154,48 +154,51 @@ -- | Generic creator for anonymous lambdas. lambdaGen :: (MonadIO m, Lambda (SymbolicT m) a) => LambdaScope -> (Defn -> b) -> State -> Kind -> a -> m b -lambdaGen scope trans inState fk f = inSubState scope inState $ \st -> handle <$> convert st fk (mkLambda st f) - where handle d@(Defn _ frees _ _) - | null frees - = trans d - | True - = error $ unlines [ "" - , "*** Data.SBV.Lambda: Detected free variables passed to a lambda." - , "***" - , "*** Free vars : " ++ unwords frees - , "*** Definition: " ++ shift (lines (sh d)) - , "***" - , "*** SBV currently does not support lambda-functions that capture variables. For" - , "*** instance, consider:" - , "***" - , "*** map (\\x -> map (\\y -> x + y))" - , "***" - , "*** where the inner 'map' uses 'x', bound by the outer 'map'. Instead, create" - , "*** a closure instead:" - , "***" - , "*** map (\\x -> map (Closure { closureEnv = x" - , "*** , closureFun = \\env y -> env + y" - , "*** }))" - , "***" - , "*** which will explicitly create the closure before calling 'map'. The environment can" - , "*** be any symbolic value: You can use a tuple to support multiple free variables." - , "***" - , "*** (SBV firstifies higher-order functions via a simple translation to make it fit with" - , "*** SMTLib's first-order logic. This translation does not currently support free" - , "*** variables. In technical terms, we would need to do closure conversion and lambda-lifting." - , "*** SBV isn't capable of doing the closure-conversion part, relying on the user to do so.)" - , "***" - , "*** Please rewrite your program to create a closure and use that as an argument." - , "*** If this solution isn't applicable, or if you'd like help doing so, please get in" - , "*** touch for further possible enhancements." - ] +lambdaGen scope trans inState fk f = inSubState scope inState $ \st -> handleLambdaDefn trans <$> convert st fk (mkLambda st f) - sh (Defn _unints _frees Nothing body) = T.unpack (body 0) - sh (Defn _unints _frees (Just params) body) = "(lambda " ++ T.unpack (extractAllUniversals params) ++ "\n" ++ T.unpack (body 2) ++ ")" +-- | Apply a lambda translation after enforcing SBV's no-captured-variables +-- rule and preserving its established diagnostic. +handleLambdaDefn :: (Defn -> b) -> Defn -> b +handleLambdaDefn trans d@(Defn _ frees _ _) + | null frees + = trans d + | True + = error $ unlines [ "" + , "*** Data.SBV.Lambda: Detected free variables passed to a lambda." + , "***" + , "*** Free vars : " ++ unwords frees + , "*** Definition: " ++ shift (lines (sh d)) + , "***" + , "*** SBV currently does not support lambda-functions that capture variables. For" + , "*** instance, consider:" + , "***" + , "*** map (\\x -> map (\\y -> x + y))" + , "***" + , "*** where the inner 'map' uses 'x', bound by the outer 'map'. Instead, create" + , "*** a closure instead:" + , "***" + , "*** map (\\x -> map (Closure { closureEnv = x" + , "*** , closureFun = \\env y -> env + y" + , "*** }))" + , "***" + , "*** which will explicitly create the closure before calling 'map'. The environment can" + , "*** be any symbolic value: You can use a tuple to support multiple free variables." + , "***" + , "*** (SBV firstifies higher-order functions via a simple translation to make it fit with" + , "*** SMTLib's first-order logic. This translation does not currently support free" + , "*** variables. In technical terms, we would need to do closure conversion and lambda-lifting." + , "*** SBV isn't capable of doing the closure-conversion part, relying on the user to do so.)" + , "***" + , "*** Please rewrite your program to create a closure and use that as an argument." + , "*** If this solution isn't applicable, or if you'd like help doing so, please get in" + , "*** touch for further possible enhancements." + ] + where sh (Defn _unints _frees Nothing body) = T.unpack (body 0) + sh (Defn _unints _frees (Just params) body) = "(lambda " ++ T.unpack (extractAllUniversals params) ++ "\n" ++ T.unpack (body 2) ++ ")" - shift [] = [] - shift (x:xs) = intercalate "\n" (x : map tab xs) - where tab s = "*** " ++ s + shift [] = [] + shift (x:xs) = intercalate "\n" (x : map tab xs) + where tab s = "*** " ++ s -- | Create an SMTLib lambda, in the given state. lambda :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTDef @@ -207,7 +210,7 @@ lambdaWithInfo inState scope fk f = inSubState scope inState $ \st -> do defn <- handleDefn <$> convert st fk (mkLambda st f) info <- liftIO $ extractLambdaInfo st - pure (defn, info) + pure (smtDefWithInfo defn info, info) where handleDefn d@(Defn _ frees _ _) | null frees = mkLam d | True = error $ unlines [ "" @@ -223,6 +226,7 @@ linps <- readIORef (rlambdaInps st) outs <- readIORef (routs st) cmap <- readIORef (rconstMap st) + tables <- map arrange . mapToSortedList <$> readIORef (rtblMap st) let params = [(q, getSV nsv) | (q, nsv) <- F.toList linps] outSV = case F.toList outs of [o] -> o @@ -231,15 +235,25 @@ , liParams = params , liOutput = outSV , liConsts = map swap $ Map.toList cmap + , liTables = tables } - where swap (a, b) = (b, a) + where arrange (i, (indexKind, resultKind, elements)) = ((i, indexKind, resultKind), elements) + swap (a, b) = (b, a) -- | Create an anonymous lambda, rendered as n SMTLib string. The kind passed is the kind of the final result. lambdaStr :: (MonadIO m, Lambda (SymbolicT m) a) => State -> LambdaScope -> Kind -> a -> m SMTLambda -lambdaStr st scope k a = SMTLambda <$> lambdaGen scope mkLam st k a - where mkLam (Defn _unints _frees Nothing body) = body 0 - mkLam (Defn _unints _frees (Just params) body) = "(lambda " <> extractAllUniversals params <> "\n" <> body 2 <> ")" +lambdaStr inState HigherOrderArg fk f = SMTLambda <$> lambdaGen HigherOrderArg renderLambdaDefn inState fk f +lambdaStr inState TopLevel fk f = inSubState TopLevel inState $ \st -> do + defn <- convert st fk (mkLambda st f) + let rendered = handleLambdaDefn renderLambdaDefn defn + rendered `seq` do lambdaInfo <- liftIO $ extractLambdaInfo st + pure (smtLambdaWithInfo rendered lambdaInfo) +-- | Render a validated anonymous lambda in its canonical SMT-Lib form. +renderLambdaDefn :: Defn -> T.Text +renderLambdaDefn (Defn _unints _frees Nothing body) = body 0 +renderLambdaDefn (Defn _unints _frees (Just params) body) = "(lambda " <> extractAllUniversals params <> "\n" <> body 2 <> ")" + -- | Generic constraint generator. constraintGen :: (MonadIO m, Constraint (SymbolicT m) a) => LambdaScope -> ([String] -> (Int -> T.Text) -> b) -> State -> a -> m b constraintGen scope trans inState@State{rProgInfo} f = do @@ -452,9 +466,9 @@ rm = roundingMode cfg - -- NB. The following is dead-code, since we ensure tbls is empty - -- We used to support this, but there are issues, so dropping support - -- See, for instance, https://github.com/LeventErkok/sbv/issues/664 + -- Tables are local to this lambda. Constant tables can be bound + -- immediately, while tables containing symbolic elements must be + -- introduced after their last element has been defined. (tableMap, constTables, nonConstTablesUnindexed) = constructTables consts tbls -- Index each non-const table with the largest index of SV it needs diff --git a/Data/SBV/RegExp.hs b/Data/SBV/RegExp.hs --- a/Data/SBV/RegExp.hs +++ b/Data/SBV/RegExp.hs @@ -56,6 +56,7 @@ import qualified Data.List as L import Data.SBV.Core.Data +import Data.SBV.Core.Symbolic (validateRegExp) import Data.SBV.List import qualified Data.Char as C @@ -89,8 +90,27 @@ -- >>> sat $ \(s :: SString) -> s `match` phone -- Satisfiable. Model: -- s0 = "100-1000" :: String +-- +-- Literal matching preserves concatenation: 'All' can consume any prefix, +-- but the rest of the expression must still match the remaining suffix. +-- +-- >>> ("a" :: SString) `match` Conc [All, "b"] +-- False +-- +-- Boolean operations apply to the same prefix, not to separate matches of +-- the entire concatenation: +-- +-- >>> ("ab" :: SString) `match` Conc [Diff "ab" "a", Opt "b"] +-- True +-- >>> ("ab" :: SString) `match` Conc [Inter "a" "ab", All] +-- False class RegExpMatchable a where -- | @`match` s r@ checks whether @s@ is in the language generated by @r@. + -- Invalid 'Loop' or 'Power' bounds are rejected, including in unused branches. + -- An empty concatenation is the identity for concatenation: + -- + -- >>> prove $ \(s :: SString) -> match s (Conc []) .== (s .== "") + -- Q.E.D. match :: a -> RegExp -> SBool -- | Matching a character simply means the singleton string matches the regex. @@ -99,11 +119,12 @@ -- | Matching symbolic strings. instance RegExpMatchable SString where - match input regExp = lift1 (StrInRe regExp) (Just (go regExp P.null)) input - where -- This isn't super efficient, but it gets the job done. + match input regExp = validateRegExp regExp `seq` lift1 (StrInRe regExp) (Just (go regExp P.null)) input + where -- Match a prefix of the input, then pass the remaining suffix to + -- the continuation. The initial continuation requires an empty suffix. go :: RegExp -> (String -> Bool) -> String -> Bool go (Literal l) k s = l `L.isPrefixOf` s && k (P.drop (P.length l) s) - go All _ _ = True + go All k s = P.any k (L.tails s) go AllChar k s = not (P.null s) && k (P.drop 1 s) go None _ _ = False go (Range _ _) _ [] = False @@ -113,14 +134,19 @@ go (KStar r) k s = k s || go r (smaller (P.length s) (go (KStar r) k)) s go (KPlus r) k s = go (Conc [r, KStar r]) k s go (Opt r) k s = k s || go r k s - go (Comp r) k s = not $ go r k s - go (Diff r1 r2) k s = go r1 k s && not (go r2 k s) + go (Comp r) k s = matchingPrefix (not . go r P.null) k s + go (Diff r1 r2) k s = matchingPrefix (\p -> go r1 P.null p && not (go r2 P.null p)) k s go (Loop i j r) k s = go (Conc (P.replicate i r P.++ P.replicate (j - i) (Opt r))) k s go (Power n r) k s = go (Loop n n r) k s go (Union []) _ _ = False go (Union [x]) k s = go x k s go (Union (x:xs)) k s = go x k s || go (Union xs) k s - go (Inter a b) k s = go a k s && go b k s + go (Inter a b) k s = matchingPrefix (\p -> go a P.null p && go b P.null p) k s + + -- Boolean language operations must inspect exactly the same prefix. + -- Only after accepting that prefix may we check the continuation. + matchingPrefix :: (String -> Bool) -> (String -> Bool) -> String -> Bool + matchingPrefix accepts k s = P.or [accepts p && k suffix | (p, suffix) <- P.zip (L.inits s) (L.tails s)] -- In the KStar case, make sure the continuation is called with something -- smaller to avoid infinite recursion! diff --git a/Data/SBV/SMT/SMTLib2.hs b/Data/SBV/SMT/SMTLib2.hs --- a/Data/SBV/SMT/SMTLib2.hs +++ b/Data/SBV/SMT/SMTLib2.hs @@ -36,7 +36,7 @@ import Data.SBV.SMT.Utils import Data.SBV.Core.Symbolic ( QueryContext(..), SetOp(..), getUserName, getUserName', getSV, regExpToSMTString, NROp(..), showNROp - , SMTDef(..), SMTLambda(..), ResultInp(..), ProgInfo(..), SpecialRelOp(..), ADTOp(..) + , SMTDef(..), smtLambdaText, ResultInp(..), ProgInfo(..), SpecialRelOp(..), ADTOp(..) ) import Data.SBV.Utils.PrettyNum (smtRoundingMode, cvToSMTLib) @@ -444,21 +444,26 @@ -- for a list of what we include, in case something doesn't show up -- and you need it! cvtInc :: SMTLibIncConverter [Text] -cvtInc curProgInfo inps newKs (_, consts) tbls uis (SBVPgm asgnsSeq) cstrs cfg = +cvtInc curProgInfo inps newKs (_, consts) tbls uis defs (SBVPgm asgnsSeq) cstrs cfg = -- any new settings? settings + -- Tuples precede ADTs that may use them, as in non-incremental output. + -- Only declare the new sizes; old sizes persist. + <> concatMap declTuple (findTupleArities newKs) + -- Rationals precede ADTs that may contain rational fields. + <> (if containsRationals newKs then declRationals else []) -- sorts <> declADT [(s, pks, cs) | k@(KADT s pks cs) <- newKinds, not (isRoundingMode k)] - -- tuples. NB. Only declare the new sizes, old sizes persist. - <> concatMap declTuple (findTupleArities newKs) -- constants <> concatMap (declConst cfg) consts -- inputs <> concatMap declInp inps - -- uninterpreteds - <> concatMap (declUI curProgInfo) uis -- table declarations <> tableDecls + -- uninterpreteds + <> concatMap (declUI curProgInfo) uis + -- user defined functions + <> concatMap T.lines (declUserFuns defs) -- expressions <> concatMap (declDef curProgInfo cfg tableMap) asgnsSeq -- table setups @@ -835,10 +840,10 @@ sh (SBVApp (KindCast f t) [a]) = handleKindCast f t (cvtSV a) - sh (SBVApp (ArrayInit (Left (f, t))) [a]) = "((as const (Array " <> smtType f <> " " <> smtType t <> ")) " <> cvtSV a <> ")" - sh (SBVApp (ArrayInit (Right (SMTLambda s))) []) = s - sh (SBVApp ReadArray [a, i]) = "(select " <> cvtSV a <> " " <> cvtSV i <> ")" - sh (SBVApp WriteArray [a, i, e]) = "(store " <> cvtSV a <> " " <> cvtSV i <> " " <> cvtSV e <> ")" + sh (SBVApp (ArrayInit (Left (f, t))) [a]) = "((as const (Array " <> smtType f <> " " <> smtType t <> ")) " <> cvtSV a <> ")" + sh (SBVApp (ArrayInit (Right lambdaDef)) []) = smtLambdaText lambdaDef + sh (SBVApp ReadArray [a, i]) = "(select " <> cvtSV a <> " " <> cvtSV i <> ")" + sh (SBVApp WriteArray [a, i, e]) = "(store " <> cvtSV a <> " " <> cvtSV i <> " " <> cvtSV e <> ")" sh (SBVApp (Uninterpreted nm) []) = nm sh (SBVApp (Uninterpreted nm) args) = "(" <> nm <> " " <> T.unwords (map cvtSV args) <> ")" diff --git a/Data/SBV/SMT/Utils.hs b/Data/SBV/SMT/Utils.hs --- a/Data/SBV/SMT/Utils.hs +++ b/Data/SBV/SMT/Utils.hs @@ -82,6 +82,7 @@ -> (CnstMap, [(SV, CV)]) -- ^ all constants sofar, and new constants -> [((Int, Kind, Kind), [SV])] -- ^ newly created tables -> [(String, (Bool, Maybe [String], SBVType))] -- ^ newly created uninterpreted functions/constants + -> [(String, (SMTDef, SBVType))] -- ^ newly created user definitions -> SBVPgm -- ^ assignments -> S.Seq (Bool, [(String, String)], SV) -- ^ extra constraints -> SMTConfig -- ^ configuration diff --git a/Data/SBV/Tools/CodeGen.hs b/Data/SBV/Tools/CodeGen.hs --- a/Data/SBV/Tools/CodeGen.hs +++ b/Data/SBV/Tools/CodeGen.hs @@ -6,7 +6,9 @@ -- Maintainer: erkokl@gmail.com -- Stability : experimental -- --- Code-generation from SBV programs. +-- Code-generation from SBV programs. This module selects the current C +-- backend. Import "Data.SBV.Tools.CodeGen.Legacy" instead to use the original +-- compatibility backend. ----------------------------------------------------------------------------- {-# OPTIONS_GHC -Wall -Werror #-} @@ -18,7 +20,8 @@ SBVCodeGen, cgSym -- ** Setting code-generation options - , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile, cgOverwriteFiles, cgShowU8UsingHex + , cgPerformRTCs, cgSetDriverValues, cgArrayEqualityLimit, cgRegexLimits, cgGenerateDriver, cgGenerateMakefile, cgOverwriteFiles, cgShowU8UsingHex + , CgRegexLimits(..), defaultCgRegexLimits, cgSetRegexLimits -- ** Designating inputs , cgInput, cgInputArr @@ -44,21 +47,432 @@ import Data.SBV.Compilers.CodeGen {- $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. +The SBV library can generate executable C code from symbolic programs. Total +native bit-vector arithmetic retains compact straight-line code. Programs +using arbitrary-width bit-vectors, arbitrary floating-point values, or exact +numbers can additionally contain generated runtime helpers, loops, and managed +temporary storage appropriate to those representations. + +The original, native-scalar-only implementation remains available from +"Data.SBV.Tools.CodeGen.Legacy" for compatibility during the transition to the +new backend. + +Migration changes: without an explicit mapping, 'Data.SBV.SInteger' and +rational-valued 'Data.SBV.SReal' now use exact GMP storage and require GMP at +C build time. Legacy rejects these types without 'cgIntegerSize' or +'cgSRealType'. Retain those settings if native, precision-losing mappings are +intentional, or use the Legacy import to retain the original backend. + +== Building generated code + +'compileToC' writes a function source and header, plus an example driver and +Makefile by default. 'compileToCLib' writes component sources, a shared header, +and a Makefile building @name.a@ (not @libname.a@), with an optional combined +driver. Generated C does not need the Haskell runtime or an SMT solver. + +For a standalone function named @example@, a typical build is: + +@ +make CC=clang CCFLAGS='-std=c11 -Wall -O2' +./example_driver +@ + +Use 'cgGenerateDriver' to omit the example driver, and 'cgGenerateMakefile' to +integrate sources into an existing build. With the driver disabled, build +@example.o@ for a standalone function or @name.a@ for a library. Example drivers +illustrate the generated calling convention; they are not exhaustive tests. + +Dependencies are selected from the operations and representations actually +used, including those inside private functions and array lambdas: + +* Native and arbitrary-width bit-vectors, text, collections, arrays, and regex + matching do not themselves require an external runtime library. Their element + types or computations can still require one. +* Exact integers, rational reals, and rationals require the C GMP headers and + library. Generated Makefiles obtain @GMP_CFLAGS@ and @GMP_LIBS@ from + @pkg-config@; set both variables explicitly if GMP is installed elsewhere. +* LibBF-backed floating-point operations require @libbf.h@ and a compatible C + LibBF library. The default link flags are @-lbf -lm@. Installing the Haskell + @libBF@ package does not necessarily install a standalone library named + @libbf@ on the C linker's search path. +* Native mathematical operations can require @-lm@ without GMP or LibBF. + +Generated Makefiles use @CCFLAGS@, not @CFLAGS@, and include local @*.mk@ files +for overrides. Supply nonstandard include paths through @CCFLAGS@ and library +paths through @LDFLAGS@. Required dependencies and 'cgAddLDFlags' are retained +separately in @SBV_LIBS@, so inherited @LDFLAGS@ cannot discard them. Override +@SBV_LIBS@ only to replace dependency discovery; retain every required library. +For example, a LibBF-only program can use: + +@ +make CC=clang CCFLAGS='-std=c11 -Wall -O2 -I\/path\/to\/libbf' \\ + SBV_LIBS='\/path\/to\/libbf.a -lm' +@ + +An external C caller should include the generated header and link the generated +object or archive, followed by its required libraries. Static archives do not +embed their GMP or LibBF dependencies. For a dependency-free library named +@example@, for instance: + +@ +clang -std=c11 -O2 -ffp-contract=off caller.c example.a -o caller +@ + +Use the generated Makefile's link flags for libraries that need dependencies. +Custom builds must also follow the floating-point and ownership contracts below. + +== Public C names + +Function, library, input, and output names must be portable ASCII C identifiers. +Invalid names and C keywords are rejected, not silently renamed. Leading +underscores, @sbv_@ and @SBV@ prefixes, generated type names, and names reserved +for the runtime's C, GMP, and LibBF headers are unavailable for public names. +For example, @my-function@, @switch@, and @sbv_bv_s16_mul@ are rejected. +Ordinary library function names such as @remainder@ are allowed as parameter +names, but not as generated entry points. + +Accepted names are preserved in public headers. Implementations and example +drivers use private parameter bindings, so an input named @s0@ cannot collide +with a symbolic temporary, and @values_data@ cannot collide with storage for +an input named @values@. Driver output labels retain the requested names. +Library component files must also have distinct names ignoring ASCII case, +so a bundle is safe to render on case-insensitive filesystems. + +User-supplied C prototypes, declarations, and external implementations remain +the caller's responsibility; their identifiers must not conflict with the +generated runtime or entry points. + +Generated ADT constructor tags and structural declaration guards preserve +case. Structural type names encode component boundaries explicitly; array +names length-prefix both the key and value tags. Use the names in the generated +header rather than deriving them from Haskell type spellings. + +== Representations and execution + +Generated code evaluates the symbolic computation without an SMT solver. +Standalone programs and multi-function static libraries share these mappings: + +* Booleans use C @bool@. Native-width bit-vectors use fixed-width C integers; + other widths use generated limb structures. Arithmetic, shifts, joins, and + extractions preserve the declared bit width; 673 bits is only one example. +* 'Data.SBV.SInteger', rational-valued 'Data.SBV.SReal', and + 'Data.SBV.SRational' use GMP unless an applicable native mapping is selected. +* 'Data.SBV.SFloat' and 'Data.SBV.SDouble' use native C values. Arbitrary + floating-point formats and explicitly directed native arithmetic rounding + use LibBF. Numeric casts between IEEE formats, bit-vectors, and exact GMP + numbers use LibBF too, except when a native conversion is provably exact. + Casts honor even the default round-to-nearest mode independently of the + caller's hardware rounding mode. + Floating-to-bit-vector casts round first, then retain the destination's low + bits; non-finite inputs produce zero. The latter choices give deterministic + results where SMT leaves an out-of-range or non-finite conversion unspecified. + Arbitrary formats are subject to LibBF's exponent-range limits: the backend + accepts at most 61 exponent bits and checks the selected C LibBF build too. +* Strings and lists use length-aware descriptors. Sets use finite/cofinite + descriptors. Tuples and concrete ADTs use generated structures, including + tagged constructors and managed storage for recursive ADTs. +* Symbolic arrays use persistent descriptors supporting constant arrays, + writes, retained lambdas, and caller-provided lookup callbacks. They are + distinct from finite lookup tables and 'cgInputArr'/'cgOutputArr' groups. + Reads walk the stored writes, taking time linear in their number in the + worst case. Embedding a function-scoped array in an aggregate copies its + stored-write chain, not its logical domain; already-owned storage can be shared. + +Generated headers supply ownership helpers for managed values. Inputs borrow +their storage for the call; owned outputs must be released with the appropriate +generated helper. Escaping callback contexts additionally require retain and +release callbacks. See each generated header for its representation contract. + +Entry points, defined functions, and array lambdas preserve the guards of +conditionals and short-circuit Boolean operations. An inactive branch does not +evaluate its partial ADT selectors or function calls. Total bit-vector work may +be shared outside branches; dependencies needed by both alternatives are also +shared. Explicit assertions and hard constraints remain executable checks even +when the generated function has no outputs. + +Finite table selection likewise protects unselected entries and unused defaults. +Already available entries use direct C-array lookup; entries that require guarded +evaluation use a switch. Enable 'cgPerformRTCs' to select the default for an +out-of-range index. With checks disabled (the default), callers must guarantee +in-range indices; invalid unchecked indices have no defined result and may +terminate the process. Wide and exact indices are always checked before +narrowing, independently of this option, to avoid aliasing an in-range entry. + +=== Floating-point calling convention + +Callers must enter generated code with the hardware rounding mode set to +round-to-nearest, ties-to-even: @FE_TONEAREST@ from @@. This requirement +applies to standalone generated functions and library entry points. Callbacks +and supplied C implementations must preserve this mode, or restore it before +returning to or re-entering generated code. + +Generated code does not check, save, change, or restore the hardware rounding +mode. Violating this precondition is unsupported and need not produce a +diagnostic. Ordinary 'Data.SBV.SFloat' and 'Data.SBV.SDouble' RNE arithmetic +therefore stays native, without a rounding-mode guard or a LibBF fallback. +Explicit non-RNE and symbolic SBV rounding modes still use the rounding-aware +adapters; they do not require the caller to change the hardware mode. The +conversion bridges' independence from hardware rounding does not relax the +entry-point precondition. + +Compile generated code with settings that preserve IEEE floating-point +semantics; this precondition does not permit fast-math transformations that +discard NaNs, signed zeros, or required rounding steps. +Generated headers reject detectable fast-math and finite-math-only compiler +modes, and floating-point programs require @FLT_EVAL_METHOD == 0@ so native +expressions do not acquire excess evaluation precision. Generated Makefiles +append @-ffp-contract=off@ after user compiler flags +when compiling and linking, so separate SBV operations cannot be silently fused. +Custom build systems must disable implicit contraction as well, including at +LTO link time; source pragmas alone are insufficient with some compiler options. +Explicit 'Data.SBV.fpFMA' remains a fused, single-rounding operation. Other +unsafe floating-point options and caller-enabled flush-to-zero modes remain +unsupported even when the compiler does not provide a detectable macro. + +=== Calling and owning generated values + +Input storage, including reachable aggregate fields and callback contexts, must +remain valid and unchanged throughout the call. Pointer parameters must address +valid objects; fixed-size groups require the declared number of elements. +Outputs must not overlap other outputs or storage reachable through an input. +In-place calls are not part of the supported ABI. + +Fixed-size input groups follow the same per-element borrowing rules as scalar +inputs. In particular, a group of symbolic arrays accepts a C array of the +generated @SBVArrayInput_...@ callback descriptors, not private array-node +pointers. The example driver initializes and releases managed group elements +individually, including their nested exact values and callback contexts. + +Scalar GMP output parameters, including each element of a GMP output group, +must be initialized with @mpz_init@ or @mpq_init@ before the call. They can be +reused across calls and must eventually be cleared by the caller. This also +applies to the extra output parameter used for a single exact-number return. + +In contrast, managed string, list, set, tuple, ADT, and array output slots receive +fresh owned values. They need no initialization, even when an aggregate contains +GMP fields. Release an old owned value before reusing its slot; the generated +entry point does not release the previous contents. Each output and return is +an independent owner. Plain C assignment does not create another owner: use the +generated clone or retain helper when both copies must survive independently. +Never release borrowed input storage with an ownership helper. + +Reading an owned array can return a borrowed managed value. Clone that value +before releasing the array if it must survive. Likewise, the generated +@sbv_array_output_as_input_...@ helper borrows its array owner; it does not retain +it. A callback's returned storage must remain valid while its context is alive. +Callbacks must implement a stable, immutable lookup. When a non-null context +escapes in a result, both retain and release hooks are required; retaining must +preserve the lookup's meaning and give the result an independent lifetime. + +'Data.SBV.smtFunction' definitions and firstified higher-order specializations +can compile to private C functions, including recursive definitions. Explicit +closure environments remain SBV values; this is not an ABI for runtime Haskell +function values. Hard constraints become executable preconditions. + +Array lambdas must be closed: their bodies may use their index, literal +constants, and local computations, but may not capture outer symbolic values. +The C backend checks every retained callback before generation, including +nested lambdas, table entries/defaults, and rounding-mode operands. Unsupported +captures are rejected explicitly, never replaced with default values or ignored. +This check is conservative even when a retained capture would not be evaluated. +Capturing array environments are deferred; SBV's existing frontend restrictions +on nested and higher-order captures remain unchanged. + +== Runtime failures + +Generated programs and libraries use a fail-fast contract: a detected runtime +failure terminates the calling process, using @abort@ or an unsuccessful exit. +This includes failed executable preconditions and enabled assertions, detected +invalid descriptors or missing required callback hooks, and allocation or +resource-limit failures. There is no recoverable status-returning API. + +Callers must still satisfy the generated header's ABI and ownership requirements; +runtime checks cannot validate arbitrary pointers or detect every malformed +value. Outputs and cleanup are not guaranteed after failure. Intercepting +termination or using @longjmp@ is not a supported recovery mechanism. + +Ordinary numerical results, including floating-point NaNs and infinities and +SBV-defined totalized operations, are not themselves runtime failures. + +== Array equality + +Array equality enumerates a supported finite key domain and compares values +using SMT object equality: NaNs are equal and signed floating-point zeros are +distinct. It works for constant, updated, lambda-backed, and caller-provided +arrays, stopping at the first mismatch. No backing array is materialized. +Use 'Data.SBV..===' for arrays involving floating-point types; ordinary +'Data.SBV..==' on such arrays is rejected by SBV before C generation. +Lookup callbacks must respect SMT key equality, including returning the same +value for all NaN encodings of a floating-point key. + +'cgArrayEqualityLimit' controls the maximum domain size, defaulting to 256 +keys per comparison. For example, setting it to 65536 permits 'Data.SBV.SWord16' keys, +at the cost of up to 65,536 lookups in each array. The setting also applies +inside defined functions and array lambdas, independently for each library +component. A zero limit disables exhaustive comparison. This is a generation +setting, not a runtime timeout; lookup and value-comparison costs are additional. +Exceeding the limit reports the required domain size and suggests raising it. +Infinite or unsupported domains and nested array equality remain unsupported +regardless of the limit. These are generation-time diagnostics, not internal +compiler errors, and library preflight rejects the whole bundle before writing +any component files. + +Supported key domains are Booleans, bit-vectors, characters, rounding modes, +floating-point formats, and non-recursive tuples and ADTs built from these. +Floating-point enumeration visits bit encodings but compares only one NaN +representative. Large domains require explicit opt-in even when the generated +loop itself is compact. + +For example, admit the full 16-bit domain when generating a comparator: + +>>> import Data.SBV +>>> import Data.SBV.Internals (compileToC') +>>> :{ +let compareArrays = do + cgArrayEqualityLimit 65536 + left <- cgInput "left" :: SBVCodeGen (SArray Word16 Word8) + right <- cgInput "right" :: SBVCodeGen (SArray Word16 Word8) + cgReturn (left .== right) +:} + +>>> (_, _, generated) <- compileToC' "compareArrays" compareArrays +>>> length (show generated) `seq` pure () + +== Regular expressions + +Regex membership compiles to a bounded deterministic automaton: function-local +static tables and an allocation-free C loop. All 'Data.SBV.RegExp.RegExp' +constructors are supported, including complement, intersection, difference, +and nullable repetitions. Matching consumes the entire string, preserves +embedded NULs, and uses SBV's character domain @0..0x2ffff@, including numeric +surrogate values. The normal canonical string-encoding ABI still applies. +Regex language equality and inequality are decided during generation and +produce Boolean constants, not runtime comparisons. + +There are no additional packages, generation tools, headers, or linker flags. +Non-regex programs acquire no regex runtime code. Tables are private to each +generated function and work inside defined functions and closed array lambdas. + +'cgRegexLimits' bounds compilation independently per regex operation: maximum +explored automaton states (default 1024), expression nodes (4096), and charged +generation work (16000000). Language comparison counts pairs of residual states. +Expression limits also bound literal/list lengths and repetition expansion; +work accounts for traversals, construction, normalization, and state comparisons. +These are conservative implementation budgets, not time or memory guarantees. +They can reject even a regex whose minimal automaton would be small; this +initial implementation does not minimize automata or optimize large repetitions. + +Exceeding a budget fails during generation with a diagnostic naming the limit. +No language approximation or fallback matcher is used. Zero in any limit +disables regex compilation; negative limits are invalid. Successful generation +supports inputs of any length, independently of these limits. Each library +component can choose its own limits. Already folded or dead operations need +no regex compilation. + +For example, permit a larger automaton when generating a suffix matcher: + +>>> import qualified Data.SBV.RegExp as RE +>>> :{ +let suffixMatcher = do + cgRegexLimits 4096 8192 64000000 + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `RE.match` RE.Conc [RE.All, RE.Literal "done"]) +:} + +>>> (_, _, regexCode) <- compileToC' "suffixMatcher" suffixMatcher +>>> length (show regexCode) `seq` pure () + +== Boundaries + +=== Support policy + +The following distinctions apply equally to standalone functions and libraries: + +* /Supported representations/: arbitrary-width bit-vectors, native and + arbitrary-format floats, GMP integers and rational-valued reals, text, + lists, finite\/cofinite sets, tuples, concrete ADTs, and persistent arrays. + Dependencies and ownership follow the representation descriptions above. +* /Supported with generation budgets/: exhaustive finite-domain array equality + ('cgArrayEqualityLimit') and regex compilation ('cgRegexLimits'). Exceeding + a budget reports the relevant setting; raising it does not enable a different + feature or change semantics. Regex matching has no approximate fallback. +* /Unsupported types/: uninterpreted sorts, including uses nested in supported + containers. Uninterpreted /functions/ with caller-supplied C implementations + are a separate, supported mechanism. +* /Unsupported recursive layouts/: recursive ADT references nested inside + composite constructor fields, such as tuples. Put recursive references in + direct constructor fields instead; those use the supported pointer layout. +* /Unsupported equality/: nested arrays and general infinite-domain array + equality, even for sparse constant-plus-write arrays. The same restriction + applies to implicit element comparisons in collection operations. +* /Unsupported solver requests/: finite or infinite quantifiers, special + relations, soft constraints, solver options, optimization objectives, and SMT-only constraint + attributes. Ordinary hard constraints become executable checks, not searches + for satisfying inputs. +* /Unsupported closures/: array lambdas capturing outer symbolic values. + Closed array lambdas and firstified higher-order operations with explicit + 'Data.SBV.Closure' environments remain supported. Unsupported implicit + higher-order captures are rejected by SBV's frontend or by C preflight when + retained in a defined function; the backend does not add first-class runtime + functions or general function equality. +* /Unsupported exact real values/: algebraic roots, transcendental operations + in exact-rational mode, and inexact or interval literals that do not specify + a single exact value. A native real mapping explicitly opts into approximate + arithmetic; it does not choose an approximation for an algebraic literal. + +These unsupported cases report an explicit diagnostic during generation, +including retained private-function and array-lambda bodies. Validation of an +entire library precedes file output: a rejected component does not leave earlier +components partially written. This is not a filesystem transaction; an I\/O +failure while writing otherwise valid output can still leave files behind. +Already constant-folded or eliminated operations do not require a lowering. +Runtime failures and caller preconditions are separate contracts, described +above; in particular, violating the RNE entry requirement is not diagnosed. + +Array comparisons with infinite or unsupported key domains, or values that +themselves contain arrays, are rejected during generation. Comparing arrays +nested inside collections or aggregates is also not implemented. Quantifiers, +special solver relations, uninterpreted sorts, and soft constraints are rejected. +The comparison restriction includes list searches, prefix/suffix checks, and +replacement: these operations compare elements even when their result is not +a Boolean. Arrays may still be transported inside lists and aggregates without +comparing them. Array-containing set elements and array keys are rejected, since +their representations require element or key equality. + +Exact GMP reals represent rational values, not arbitrary algebraic or +transcendental values. Select 'cgSRealType' for native approximations and +@libm@ transcendental operations when rounding is acceptable. The fixed-size +input/output/return group APIs require at least one element; symbolic lists +can be empty. + +Numeric conversions honor 'cgIntegerSize' and the @CgFloat@/@CgDouble@ real +mappings. Converting a mapped real to an integer still floors; explicitly +rounded floating casts retain their requested rounding mode. @CgLongDouble@ +retains native arithmetic and uses representation-aware LibBF bridges to exact +integers, bit-vectors, and native or arbitrary floating-point formats. These +bridges import the full significand and round directly to the destination, +without narrowing through binary64. The target C compiler must provide binary64, +x87 extended, or binary128 @long double@; other formats (including double-double) +receive a compile-time diagnostic when a bridge is needed. Merely selecting +@CgLongDouble@ does not itself require LibBF. Explicit native mappings remain +approximations: compound expressions, including integer numerator\/denominator +conversions in 'Data.SBV.Rational.sRationalToSReal', retain their separate rounding +steps instead of becoming a single exact-rational conversion. -} {- $unboundedCGen -The types 'Data.SBV.SInteger' and 'Data.SBV.SReal' are unbounded quantities that have no direct counterparts in the C language. Therefore, -it is not possible to generate standard C code for SBV programs using these types, unless custom libraries are available. To -overcome this, SBV allows the user to explicitly set what the corresponding types should be for these two cases, using -the functions below. Note that while these mappings will produce valid C code, the resulting code will be subject to -overflow/underflows for 'Data.SBV.SInteger', and rounding for 'Data.SBV.SReal', so there is an implicit loss of precision. +The types 'Data.SBV.SInteger' and 'Data.SBV.SReal' are represented exactly by +GMP when no alternative mapping is selected. The functions below retain the +option of mapping them to native C types when a smaller ABI or compatibility +with historical generated code is more important than exactness. Such native +mappings are subject to overflow for 'Data.SBV.SInteger' and rounding for +'Data.SBV.SReal'. -If the user does /not/ specify these mappings, then SBV will -refuse to compile programs that involve these types. +Real-to-integer flooring preserves the mathematical floor of the represented +native real, then retains the low bits selected by 'cgIntegerSize'. This applies +to @CgFloat@, @CgDouble@, and @CgLongDouble@ without an out-of-range C integer +cast. Flooring a non-finite mapped real terminates the process with a diagnostic. + +The compatibility backend in "Data.SBV.Tools.CodeGen.Legacy" retains the +original requirement that these mappings be supplied explicitly. -} diff --git a/Data/SBV/Tools/CodeGen/Legacy.hs b/Data/SBV/Tools/CodeGen/Legacy.hs new file mode 100644 --- /dev/null +++ b/Data/SBV/Tools/CodeGen/Legacy.hs @@ -0,0 +1,36 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Data.SBV.Tools.CodeGen.Legacy +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Opt-in access to the original SBV-to-C compiler. This module exports the +-- same code-generation interface as "Data.SBV.Tools.CodeGen"; changing the +-- import is sufficient to select the compatibility backend. +-- +-- @ +-- import Data.SBV.Tools.CodeGen.Legacy +-- @ +-- +-- New code should normally import "Data.SBV.Tools.CodeGen" instead. +-- Unlike the current backend, Legacy requires explicit 'cgIntegerSize' and +-- 'cgSRealType' mappings; it never supplies the GMP fallback. Array-equality +-- and regex generation limits are not exported: Legacy cannot use them. +-- Native real-to-integer flooring uses the same overflow-safe, low-bit mapping +-- as the current backend; flooring a non-finite mapped real fails explicitly. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Data.SBV.Tools.CodeGen.Legacy + ( module Data.SBV.Tools.CodeGen + , compileToC + , compileToCLib + , compileToC' + , compileToCLib' + ) where + +import Data.SBV.Compilers.C.Legacy (compileToC, compileToCLib, compileToC', compileToCLib') +import Data.SBV.Tools.CodeGen hiding (compileToC, compileToCLib, cgArrayEqualityLimit, cgRegexLimits, CgRegexLimits(..), defaultCgRegexLimits, cgSetRegexLimits) diff --git a/Data/SBV/Utils/SExpr.hs b/Data/SBV/Utils/SExpr.hs --- a/Data/SBV/Utils/SExpr.hs +++ b/Data/SBV/Utils/SExpr.hs @@ -14,7 +14,7 @@ {-# OPTIONS_GHC -Wall -Werror #-} module Data.SBV.Utils.SExpr ( SExpr(..), parenDeficit, parseSExpr - , parseSExprFunction, makeHaskellFunction + , parseSExprFunction, makeHaskellFunction, formatFunctionResponse , unQuote, simplifyECon , nameSupply ) where @@ -51,30 +51,36 @@ -- | Extremely simple minded tokenizer, good for our use model. tokenize :: String -> [String] -tokenize inp = go inp [] +tokenize = tokenizeWith (\tok _ _ -> tok) + +-- The callback receives the decoded token and the original input suffixes at +-- its start and end. Retaining these boundaries lets display code take exact +-- source slices without changing the tokens used for parsing. +tokenizeWith :: (String -> String -> String -> a) -> String -> [a] +tokenizeWith retain inp = go inp [] where go "" sofar = reverse sofar go (c:cs) sofar | isSpace c = go (dropWhile isSpace cs) sofar - go ('(':cs) sofar = go cs ("(" : sofar) - go (')':cs) sofar = go cs (")" : sofar) + go src@('(':cs) sofar = go cs (retain "(" src cs : sofar) + go src@(')':cs) sofar = go cs (retain ")" src cs : sofar) - go (':':':':cs) sofar = go cs ("::" : sofar) + go src@(':':':':cs) sofar = go cs (retain "::" src cs : sofar) - go (':':cs) sofar = case break (`elem` stopper) cs of - (pre, rest) -> go rest ((':':pre) : sofar) + go src@(':':cs) sofar = case break (`elem` stopper) cs of + (pre, rest) -> go rest (retain (':':pre) src rest : sofar) - go ('|':r) sofar = let wrap s = '|' : s ++ "|" - in case span (/= '|') r of - (pre, '|':rest) -> go rest (wrap pre : sofar) - (pre, rest) -> go rest (wrap pre : sofar) + go src@('|':r) sofar = let wrap s = '|' : s ++ "|" + in case span (/= '|') r of + (pre, '|':rest) -> go rest (retain (wrap pre) src rest : sofar) + (pre, rest) -> go rest (retain (wrap pre) src rest : sofar) go (';':r) sofar = go (drop 1 (dropWhile (/= '\n') r)) sofar - go ('"':r) sofar = go rest (finalStr : sofar) + go src@('"':r) sofar = go rest (retain finalStr src rest : sofar) where grabString [] acc = (reverse acc, []) -- Strictly speaking, this is the unterminated string case; but let's ignore - grabString ('"' :'"':cs) acc = grabString cs ('"' :acc) + grabString ('"' :'"':cs) acc = grabString cs ('"' : acc) grabString ('"':cs) acc = (reverse acc, cs) grabString (c:cs) acc = grabString cs (c:acc) @@ -82,7 +88,7 @@ finalStr = '"' : str ++ "\"" go cs sofar = case span (`notElem` stopper) cs of - (pre, post) -> go post (pre : sofar) + (pre, post) -> go post (retain pre cs post : sofar) -- characters that can stop the current token -- it is *crucial* that this list contains every character @@ -561,8 +567,8 @@ eRank EDouble{} = 5 eRank EApp{} = 6 --- Turn --- "((F (lambda ((x!1 Int)) (+ 3 (* 2 x!1)))))" +-- Turn a parsed function value +-- "(lambda ((x!1 Int)) (+ 3 (* 2 x!1)))" --- into -- "F x = 3 + 2 * x" -- if we can. We try but don't push too hard! This is only used for display purposes. @@ -570,14 +576,12 @@ -- This isn't very fool-proof; can be confused if there are binding constructs etc. -- Also, the generated text isn't necessarily fully Haskell acceptable. -- But it seems to do an OK job for most common use cases. -makeHaskellFunction :: String -> String -> Bool -> Maybe [String] -> Maybe String -makeHaskellFunction resp nm isCurried mbArgs - = case parseSExpr resp of - Right (EApp [EApp [ECon o, e]]) | o == nm -> do (args, bd) <- lambda e - let params | isCurried = unwords args - | True = '(' : intercalate ", " args ++ ")" - pure $ unBar nm ++ " " ++ params ++ " = " ++ bd - _ -> Nothing +makeHaskellFunction :: SExpr -> String -> Bool -> Maybe [String] -> Maybe String +makeHaskellFunction value nm isCurried mbArgs = do + (args, bd) <- lambda value + let params | isCurried = unwords args + | True = '(' : intercalate ", " args ++ ")" + pure $ unBar nm ++ " " ++ params ++ " = " ++ bd where -- infinite supply of names; starting with the ones we're given preSupply = fromMaybe [] mbArgs @@ -590,6 +594,23 @@ getArg (EApp [ECon argName, _]) = Just argName getArg _ = Nothing + +-- | Format an already parsed function value. The caller validates the response +-- name. If lambda formatting fails, slice the original SMT-Lib value at token +-- boundaries. This preserves its exact spelling, whitespace, and comments; +-- rebuilding it from the normalized SExpr or decoded tokens would lose details. +formatFunctionResponse :: SExpr -> String -> String -> Bool -> Maybe [String] -> String +formatFunctionResponse value response nm isCurried mbArgs + | Just formatted <- makeHaskellFunction value nm isCurried mbArgs + = formatted + | ("(", _, _) : ("(", _, _) : (actual, _, _) : rest <- tokenizeWith (,,) response + , unBar actual == unBar nm + , (")", _, _) : (")", _, _) : body@((_, _, end) : _) <- reverse rest + , (_, start, _) : _ <- reverse body + = raw $ take (length start - length end) start + | True + = raw response + where raw s = nm ++ " = fromSMTLib " ++ s -- | z3 prints uninterpreted values like this: T!val!4 or T_val_4. Turn that into T_4 simplifyECon :: String -> String diff --git a/Documentation/SBV/Examples/ADT/Shapes.hs b/Documentation/SBV/Examples/ADT/Shapes.hs new file mode 100644 --- /dev/null +++ b/Documentation/SBV/Examples/ADT/Shapes.hs @@ -0,0 +1,110 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Documentation.SBV.Examples.ADT.Shapes +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Generate shapes satisfying constraints on their dimensions and area. This +-- example demonstrates symbolic pattern matching on an algebraic datatype, +-- enumerating models with 'allSatWith', and extracting concrete Haskell values +-- in query mode. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE QuasiQuotes #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +module Documentation.SBV.Examples.ADT.Shapes where + +import Data.SBV +import Data.SBV.Control + +-- | Shapes with signed 32-bit dimensions. We reserve 'Rectangle' for shapes +-- with unequal sides, so squares have their own constructor. +data Shape = Dot -- ^ A point, with zero area. + | Square { side :: Int32 } -- ^ A square. + | Rectangle { sideA :: Int32, sideB :: Int32 } -- ^ A rectangle. + deriving Show + +-- | Generate 'SShape', symbolic constructors such as 'sSquare', and the +-- support needed to pass shapes to and from the solver. +mkSymbolic [''Shape] + +-- | Compute the area using 'sCase' to match a symbolic shape. Ordinary Haskell +-- pattern matching cannot inspect a shape whose constructor is not yet known. +area :: SShape -> SInt32 +area s = [sCase| s of + Dot -> 0 + Square a -> a * a + Rectangle a b -> a * b + |] + +-- | Require positive dimensions below 100, and unequal sides for rectangles. +-- The bounds also ensure that area calculations cannot overflow 'Int32'. +-- A dot has no dimensions to constrain. +goodShape :: SShape -> SBool +goodShape s = [sCase| s of + Dot -> sTrue + Square a -> a .> 0 .&& a .< 100 + Rectangle a b -> a .> 0 .&& a .< 100 .&& b .> 0 .&& b .< 100 .&& a ./= b + |] + +-- | Create a symbolic shape and constrain its dimensions. Creating the value +-- automatically declares the datatype to the solver. +newShape :: Symbolic SShape +newShape = do x <- free "shape" + constrain $ goodShape x + pure x + +-- | Select non-dot shapes with area between 10 and 30, inclusive. +-- The explicit exclusion of 'Dot' is redundant with the area bound, but +-- illustrates a symbolic comparison with a datatype constructor. +interesting :: SShape -> SBool +interesting x = area x .>= 10 .&& area x .<= 30 .&& x ./= sDot + +-- | Ask for five distinct models using SBV's built-in enumeration. +-- +-- >>> examples +-- Solution #1: +-- shape = Rectangle 24 1 :: Shape +-- Solution #2: +-- shape = Rectangle 1 25 :: Shape +-- Solution #3: +-- shape = Rectangle 25 1 :: Shape +-- Solution #4: +-- shape = Square 5 :: Shape +-- Solution #5: +-- shape = Square 4 :: Shape +-- Found 5 different solutions. +examples :: IO AllSatResult +examples = allSatWith z3{allSatMaxModelCount = Just 5} (interesting <$> newShape) + +-- | Enumerate shapes manually in query mode. After each satisfiability check, +-- 'getValue' returns a concrete 'Shape'. We exclude that value using 'literal' +-- before asking for the next model. Stop after five shapes, or earlier if +-- there are no more solutions, and return them in discovery order. +-- +-- >>> extracted +-- [Square {side = 4},Rectangle {sideA = 15, sideB = 1},Square {side = 5},Rectangle {sideA = 4, sideB = 6},Rectangle {sideA = 12, sideB = 2}] +extracted :: IO [Shape] +extracted = runSMT $ do + x <- newShape + constrain $ interesting x + + let loop :: Int -> [Shape] -> Query [Shape] + loop 5 sofar = pure $ reverse sofar + loop i sofar = do cs <- checkSat + case cs of + Sat -> do xv <- getValue x + -- Exclude the entire shape, including its fields. + constrain $ x ./= literal xv + loop (i+1) (xv : sofar) + Unsat -> pure $ reverse sofar + _ -> error $ "Solver said: " ++ show cs + + query $ loop 0 [] diff --git a/Documentation/SBV/Examples/CodeGeneration/AddSub.hs b/Documentation/SBV/Examples/CodeGeneration/AddSub.hs --- a/Documentation/SBV/Examples/CodeGeneration/AddSub.hs +++ b/Documentation/SBV/Examples/CodeGeneration/AddSub.hs @@ -16,7 +16,7 @@ import Data.SBV import Data.SBV.Tools.CodeGen --- | Simple function that returns add/sum of args +-- | Return the sum and difference of two unsigned 8-bit values, wrapping modulo 256. addSub :: SWord8 -> SWord8 -> (SWord8, SWord8) addSub x y = (x+y, x-y) @@ -37,11 +37,11 @@ -- addSub.o: addSub.c addSub.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- --- addSub_driver.o: addSub_driver.c +-- addSub_driver.o: addSub_driver.c addSub.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- addSub_driver: addSub.o addSub_driver.o --- ${CC} ${CCFLAGS} $^ -o $@ +-- ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} -- -- clean: -- rm -f *.o @@ -52,9 +52,10 @@ -- == BEGIN: "addSub.h" ================ -- /* Header file for addSub. Automatically generated by SBV. Do not edit! */ -- --- #ifndef __addSub__HEADER_INCLUDED__ --- #define __addSub__HEADER_INCLUDED__ +-- #ifndef SBV_GENERATED_addSub_HEADER_INCLUDED +-- #define SBV_GENERATED_addSub_HEADER_INCLUDED -- +-- -- #include -- #include -- #include @@ -63,6 +64,13 @@ -- #include -- #include -- +-- /* Floating-point calling convention: +-- * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). +-- * Callbacks must preserve this mode before returning or re-entering. +-- * Generated code does not check or change the hardware rounding mode. +-- * Custom builds must disable implicit FP contraction, including at LTO link time. +-- */ +-- -- /* The boolean type */ -- typedef bool SBool; -- @@ -88,7 +96,7 @@ -- void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, -- SWord8 *dif); -- --- #endif /* __addSub__HEADER_INCLUDED__ */ +-- #endif /* SBV_GENERATED_addSub_HEADER_INCLUDED */ -- == END: "addSub.h" ================== -- == BEGIN: "addSub_driver.c" ================ -- /* Example driver program for addSub. */ @@ -99,14 +107,14 @@ -- -- int main(void) -- { --- SWord8 sum; --- SWord8 dif; +-- SWord8 sbv_driver_output_0; +-- SWord8 sbv_driver_output_1; -- --- addSub(132, 241, &sum, &dif); +-- addSub(132, 241, &sbv_driver_output_0, &sbv_driver_output_1); -- -- printf("addSub(132, 241, &sum, &dif) ->\n"); --- printf(" sum = %"PRIu8"\n", sum); --- printf(" dif = %"PRIu8"\n", dif); +-- printf(" sum = %"PRIu8"\n", sbv_driver_output_0); +-- printf(" dif = %"PRIu8"\n", sbv_driver_output_1); -- -- return 0; -- } @@ -116,24 +124,46 @@ -- -- #include "addSub.h" -- --- void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, --- SWord8 *dif) +-- /* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +-- #ifndef SBV_CGEN_UNUSED +-- #if defined(__GNUC__) || defined(__clang__) +-- #define SBV_CGEN_UNUSED __attribute__((unused)) +-- #else +-- #define SBV_CGEN_UNUSED +-- #endif +-- #endif +-- +-- static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) -- { --- const SWord8 s0 = x; --- const SWord8 s1 = y; --- const SWord8 s2 = s0 + s1; --- const SWord8 s3 = s0 - s1; +-- const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); +-- return (SWord8) bits; +-- } -- --- *sum = s2; --- *dif = s3; +-- static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_sub(SWord8 a, SWord8 b) +-- { +-- const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) - ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); +-- return (SWord8) bits; -- } +-- +-- +-- void addSub(const SWord8 sbv_input_0, const SWord8 sbv_input_1, +-- SWord8 *sbv_output_0, SWord8 *sbv_output_1) +-- { +-- const SWord8 s0 = sbv_input_0; +-- const SWord8 s1 = sbv_input_1; +-- const SWord8 s2 = sbv_bv_u8_add(s0, s1); +-- const SWord8 s3 = sbv_bv_u8_sub(s0, s1); +-- +-- *sbv_output_0 = s2; +-- *sbv_output_1 = s3; +-- } -- == END: "addSub.c" ================== -- genAddSub :: IO () genAddSub = compileToC outDir "addSub" $ do x <- cgInput "x" y <- cgInput "y" - -- leave the cgDriverVals call out for generating a driver with random values + -- leave the cgSetDriverValues call out for generating a driver with random values cgSetDriverValues [132, 241] let (s, d) = addSub x y cgOutput "sum" s diff --git a/Documentation/SBV/Examples/CodeGeneration/PopulationCount.hs b/Documentation/SBV/Examples/CodeGeneration/PopulationCount.hs --- a/Documentation/SBV/Examples/CodeGeneration/PopulationCount.hs +++ b/Documentation/SBV/Examples/CodeGeneration/PopulationCount.hs @@ -91,7 +91,7 @@ -- 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 `popCountFast`: +-- Below are the generated files for `popCountFast`: -- -- >>> genPopCountInC -- == BEGIN: "Makefile" ================ @@ -108,11 +108,11 @@ -- popCount.o: popCount.c popCount.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- --- popCount_driver.o: popCount_driver.c +-- popCount_driver.o: popCount_driver.c popCount.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- popCount_driver: popCount.o popCount_driver.o --- ${CC} ${CCFLAGS} $^ -o $@ +-- ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} -- -- clean: -- rm -f *.o @@ -123,9 +123,10 @@ -- == BEGIN: "popCount.h" ================ -- /* Header file for popCount. Automatically generated by SBV. Do not edit! */ -- --- #ifndef __popCount__HEADER_INCLUDED__ --- #define __popCount__HEADER_INCLUDED__ +-- #ifndef SBV_GENERATED_popCount_HEADER_INCLUDED +-- #define SBV_GENERATED_popCount_HEADER_INCLUDED -- +-- -- #include -- #include -- #include @@ -134,6 +135,13 @@ -- #include -- #include -- +-- /* Floating-point calling convention: +-- * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). +-- * Callbacks must preserve this mode before returning or re-entering. +-- * Generated code does not check or change the hardware rounding mode. +-- * Custom builds must disable implicit FP contraction, including at LTO link time. +-- */ +-- -- /* The boolean type */ -- typedef bool SBool; -- @@ -158,7 +166,7 @@ -- /* Entry point prototype: */ -- SWord8 popCount(const SWord64 x); -- --- #endif /* __popCount__HEADER_INCLUDED__ */ +-- #endif /* SBV_GENERATED_popCount_HEADER_INCLUDED */ -- == END: "popCount.h" ================== -- == BEGIN: "popCount_driver.c" ================ -- /* Example driver program for popCount. */ @@ -169,9 +177,9 @@ -- -- int main(void) -- { --- const SWord8 __result = popCount(0x1b02e143e4f0e0e5ULL); +-- const SWord8 sbv_result = popCount(0x1b02e143e4f0e0e5ULL); -- --- printf("popCount(0x1b02e143e4f0e0e5ULL) = %"PRIu8"\n", __result); +-- printf("popCount(0x1b02e143e4f0e0e5ULL) = %"PRIu8"\n", sbv_result); -- -- return 0; -- } @@ -181,9 +189,68 @@ -- -- #include "popCount.h" -- --- SWord8 popCount(const SWord64 x) +-- /* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +-- #ifndef SBV_CGEN_UNUSED +-- #if defined(__GNUC__) || defined(__clang__) +-- #define SBV_CGEN_UNUSED __attribute__((unused)) +-- #else +-- #define SBV_CGEN_UNUSED +-- #endif +-- #endif +-- +-- static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_shl(SWord64 a, SWord64 amount) -- { --- const SWord64 s0 = x; +-- const uint64_t n = (uint64_t) (SWord64) amount; +-- const SWord64 result = n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a << n); +-- return result; +-- } +-- +-- static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_lshr(SWord64 a, SWord64 amount) +-- { +-- const uint64_t n = (uint64_t) (SWord64) amount; +-- return n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a >> n); +-- } +-- +-- static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) +-- { +-- const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); +-- return (SWord8) bits; +-- } +-- +-- +-- SWord8 popCount(const SWord64 sbv_input_0) +-- { +-- const SWord64 s0 = sbv_input_0; +-- const SWord64 s11 = s0 & 0x00000000000000ffULL; +-- const SWord64 s14 = sbv_bv_u64_lshr(s0, 0x0000000000000008ULL); +-- const SWord64 s15 = 0x00000000000000ffULL & s14; +-- const SWord64 s18 = sbv_bv_u64_lshr(s14, 0x0000000000000008ULL); +-- const SWord64 s19 = 0x00000000000000ffULL & s18; +-- const SWord64 s22 = sbv_bv_u64_lshr(s18, 0x0000000000000008ULL); +-- const SWord64 s23 = 0x00000000000000ffULL & s22; +-- const SWord64 s26 = sbv_bv_u64_lshr(s22, 0x0000000000000008ULL); +-- const SWord64 s27 = 0x00000000000000ffULL & s26; +-- const SWord64 s30 = sbv_bv_u64_lshr(s26, 0x0000000000000008ULL); +-- const SWord64 s31 = 0x00000000000000ffULL & s30; +-- const SWord64 s34 = sbv_bv_u64_lshr(s30, 0x0000000000000008ULL); +-- const SWord64 s35 = 0x00000000000000ffULL & s34; +-- const SWord64 s38 = sbv_bv_u64_lshr(s34, 0x0000000000000008ULL); +-- const SWord64 s39 = 0x00000000000000ffULL & s38; +-- SWord8 s12; +-- SWord8 s16; +-- SWord8 s17; +-- SWord8 s20; +-- SWord8 s21; +-- SWord8 s24; +-- SWord8 s25; +-- SWord8 s28; +-- SWord8 s29; +-- SWord8 s32; +-- SWord8 s33; +-- SWord8 s36; +-- SWord8 s37; +-- SWord8 s40; +-- SWord8 s41; -- 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, @@ -198,36 +265,21 @@ -- 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 s14 = s0 >> 8; --- const SWord64 s15 = 0x00000000000000ffULL & s14; --- const SWord8 s16 = table0[s15]; --- const SWord8 s17 = s12 + s16; --- const SWord64 s18 = s14 >> 8; --- const SWord64 s19 = 0x00000000000000ffULL & s18; --- const SWord8 s20 = table0[s19]; --- const SWord8 s21 = s17 + s20; --- const SWord64 s22 = s18 >> 8; --- const SWord64 s23 = 0x00000000000000ffULL & s22; --- const SWord8 s24 = table0[s23]; --- const SWord8 s25 = s21 + s24; --- const SWord64 s26 = s22 >> 8; --- const SWord64 s27 = 0x00000000000000ffULL & s26; --- const SWord8 s28 = table0[s27]; --- const SWord8 s29 = s25 + s28; --- const SWord64 s30 = s26 >> 8; --- const SWord64 s31 = 0x00000000000000ffULL & s30; --- const SWord8 s32 = table0[s31]; --- const SWord8 s33 = s29 + s32; --- const SWord64 s34 = s30 >> 8; --- const SWord64 s35 = 0x00000000000000ffULL & s34; --- const SWord8 s36 = table0[s35]; --- const SWord8 s37 = s33 + s36; --- const SWord64 s38 = s34 >> 8; --- const SWord64 s39 = 0x00000000000000ffULL & s38; --- const SWord8 s40 = table0[s39]; --- const SWord8 s41 = s37 + s40; +-- s12 = table0[s11]; +-- s16 = table0[s15]; +-- s17 = sbv_bv_u8_add(s12, s16); +-- s20 = table0[s19]; +-- s21 = sbv_bv_u8_add(s17, s20); +-- s24 = table0[s23]; +-- s25 = sbv_bv_u8_add(s21, s24); +-- s28 = table0[s27]; +-- s29 = sbv_bv_u8_add(s25, s28); +-- s32 = table0[s31]; +-- s33 = sbv_bv_u8_add(s29, s32); +-- s36 = table0[s35]; +-- s37 = sbv_bv_u8_add(s33, s36); +-- s40 = table0[s39]; +-- s41 = sbv_bv_u8_add(s37, s40); -- -- return s41; -- } diff --git a/Documentation/SBV/Examples/Crypto/AES.hs b/Documentation/SBV/Examples/Crypto/AES.hs --- a/Documentation/SBV/Examples/Crypto/AES.hs +++ b/Documentation/SBV/Examples/Crypto/AES.hs @@ -9,16 +9,13 @@ -- An implementation of AES (Advanced Encryption Standard), using SBV. -- For details on AES, see . -- --- 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 clarity 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. +-- We choose a T-box implementation because it maps AES round operations to +-- table lookups and word-sized XORs in generated C. The Haskell code can use +-- ordinary lists and describe the tables mathematically: SBV computes their +-- entries during code generation and emits constant C arrays. This keeps +-- the algorithm readable without recomputing field arithmetic at run time. +-- The examples below generate either a standalone block encryptor or a library +-- with separate key-expansion, encryption, and decryption functions. -- -- All 3 valid key sizes (128, 192, and 256) as required by the FIPS-197 standard -- are supported. @@ -740,48 +737,40 @@ -- ${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 serious 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.) + The C generator emits lookup tables and an unrolled sequence of AES rounds. + The generated block encryptor takes two input arrays of four 32-bit words + (plaintext and key), and writes four ciphertext words to an output array. + It expands the key on every call. To reuse an expanded key across blocks, + use the separate key-schedule and block functions generated by 'cgAESLibrary'. -} --- | Code generation for 128-bit AES encryption. --- --- The following sample from the generated code-lines show how T-Boxes are rendered as C arrays: +-- | Generate and print the source, header, example driver, and Makefile for +-- 128-bit AES encryption. The driver uses the test vector from Appendix C.1 +-- of the AES standard. -- --- @ --- static const SWord32 table1[] = { --- 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, --- 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, --- 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, --- 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, --- ... --- } --- @ +-- We can inspect the same program without writing files: -- --- 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: +-- >>> import Data.SBV.Internals (compileToC') +-- >>> import Data.List (isPrefixOf) +-- >>> (_, _, generated) <- compileToC' "aes128BlockEncrypt" aes128BlockEncrypt +-- >>> let generatedLines = lines (show generated) -- --- @ --- 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 generated program has four T-box tables and one S-box table: -- --- The GNU C-compiler does a fine job of optimizing this straightline code to generate a fairly efficient C implementation. +-- >>> putStr $ unlines $ filter (isPrefixOf " static const ") generatedLines +-- static const SWord32 table1[] = { +-- static const SWord32 table2[] = { +-- static const SWord32 table3[] = { +-- static const SWord32 table4[] = { +-- static const SWord8 table0[] = { cgAES128BlockEncrypt :: IO () -cgAES128BlockEncrypt = compileToC Nothing "aes128BlockEncrypt" $ do +cgAES128BlockEncrypt = compileToC Nothing "aes128BlockEncrypt" aes128BlockEncrypt + +-- | Code-generation action shared by the standalone encryptor and the +-- generated-code examples above. Pass it to 'compileToC' with a destination +-- directory to write the files instead of printing them. +aes128BlockEncrypt :: SBVCodeGen () +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 @@ -802,6 +791,10 @@ 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. + + For example, @cgAESLibrary 128 (Just "aes128")@ writes the library sources, + header, example driver, and Makefile to @aes128@. Run @make -C aes128@ to + build the archive and driver. -} -- | Components of the AES implementation that the library is generated from. For each case, we provide @@ -885,11 +878,8 @@ configure dvals code = cgSetDriverValues dvals >> code -- | 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.) +-- The generated library includes a header, a Makefile, and an example driver. +-- Build the archive and driver with @make@ in the destination directory. cgAES128Library :: IO () cgAES128Library = cgAESLibrary 128 Nothing diff --git a/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs b/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs --- a/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs +++ b/Documentation/SBV/Examples/Puzzles/HexPuzzle.hs @@ -47,8 +47,6 @@ import Data.SBV import Data.SBV.Control -import Data.Proxy - -- | Colors we're allowed data Color = Black | Blue | Green | Red @@ -83,8 +81,7 @@ -- | Iteratively search at increasing depths of button-presses to see if we can -- transform from the initial board position to a final board position. search :: [Color] -> [Color] -> IO () -search initial final = runSMT $ do registerType (Proxy @SColor) - let emptyGrid = constArray sBlack +search initial final = runSMT $ do let emptyGrid = constArray sBlack initGrid = foldr (\(i, c) a -> writeArray a (literal i) (literal c)) emptyGrid (zip [1..] initial) query $ loop (0 :: Int) initGrid [] diff --git a/Documentation/SBV/Examples/TP/Reverse.hs b/Documentation/SBV/Examples/TP/Reverse.hs --- a/Documentation/SBV/Examples/TP/Reverse.hs +++ b/Documentation/SBV/Examples/TP/Reverse.hs @@ -108,17 +108,16 @@ -- Step: 1.3.2 Q.E.D. -- Step: 1.3.3 Q.E.D. -- Step: 1.3.4 Q.E.D. --- Step: 1.3.5 Q.E.D. --- Step: 1.3.6 (simplify head) Q.E.D. --- Step: 1.3.7 Q.E.D. --- Step: 1.3.8 (simplify tail) Q.E.D. +-- Step: 1.3.5 (simplify head) Q.E.D. +-- Step: 1.3.6 Q.E.D. +-- Step: 1.3.7 (simplify tail) Q.E.D. +-- Step: 1.3.8 Q.E.D. -- Step: 1.3.9 Q.E.D. -- Step: 1.3.10 Q.E.D. --- Step: 1.3.11 Q.E.D. --- Step: 1.3.12 (substitute) Q.E.D. +-- Step: 1.3.11 (substitute) Q.E.D. +-- Step: 1.3.12 Q.E.D. -- Step: 1.3.13 Q.E.D. -- Step: 1.3.14 Q.E.D. --- Step: 1.3.15 Q.E.D. -- Step: 1.Completeness Q.E.D. -- Result: Q.E.D. -- Functions proven terminating: rev, sbv.reverse @@ -140,8 +139,7 @@ [] -> trivial [_] -> trivial a : as -> head (rev as) .: rev (a .: rev (tail (rev as))) - ?? ih `at` Inst @"xs" as - =: head (reverse as) .: rev (a .: rev (tail (rev as))) + -- Replace both occurrences of rev as together. ?? ih `at` Inst @"xs" as =: head (reverse as) .: rev (a .: rev (tail (reverse as))) ?? ih `at` Inst @"xs" (tail (rev as)) diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -116,7 +116,7 @@ **Theorem proving (TP)** — Semi-automated inductive proofs (including strong induction) with equational reasoning chains. Includes termination checking, recursive and mutually recursive definitions, productive (co-recursive) functions, and user-defined measures. -**Code generation** — Compile symbolic programs to C as straight-line programs or libraries (`compileToC`, `compileToCLib`), and generate test vectors (`genTest`). +**Code generation** — Compile symbolic programs to C functions or static libraries (`compileToC`, `compileToCLib`), including recursive functions, arbitrary-width arithmetic, structured values, and bounded regex compilation. The previous compiler remains available through `Data.SBV.Tools.CodeGen.Legacy`. Generate test vectors with `genTest`. **SMT interaction** — Incremental mode via `runSMT`/`query` for programmatic solver interaction with a high-level typed API. Run multiple solvers simultaneously with `proveWithAny`/`proveWithAll`. diff --git a/SBVTestSuite/GoldFiles/addSub.gold b/SBVTestSuite/GoldFiles/addSub.gold --- a/SBVTestSuite/GoldFiles/addSub.gold +++ b/SBVTestSuite/GoldFiles/addSub.gold @@ -12,11 +12,11 @@ addSub.o: addSub.c addSub.h ${CC} ${CCFLAGS} -c $< -o $@ -addSub_driver.o: addSub_driver.c +addSub_driver.o: addSub_driver.c addSub.h ${CC} ${CCFLAGS} -c $< -o $@ addSub_driver: addSub.o addSub_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "addSub.h" ================ /* Header file for addSub. Automatically generated by SBV. Do not edit! */ -#ifndef __addSub__HEADER_INCLUDED__ -#define __addSub__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_addSub_HEADER_INCLUDED +#define SBV_GENERATED_addSub_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -63,7 +71,7 @@ void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, SWord8 *dif); -#endif /* __addSub__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_addSub_HEADER_INCLUDED */ == END: "addSub.h" ================== == BEGIN: "addSub_driver.c" ================ /* Example driver program for addSub. */ @@ -74,14 +82,14 @@ int main(void) { - SWord8 sum; - SWord8 dif; + SWord8 sbv_driver_output_0; + SWord8 sbv_driver_output_1; - addSub(76, 92, &sum, &dif); + addSub(76, 92, &sbv_driver_output_0, &sbv_driver_output_1); printf("addSub(76, 92, &sum, &dif) ->\n"); - printf(" sum = %"PRIu8"\n", sum); - printf(" dif = %"PRIu8"\n", dif); + printf(" sum = %"PRIu8"\n", sbv_driver_output_0); + printf(" dif = %"PRIu8"\n", sbv_driver_output_1); return 0; } @@ -91,15 +99,37 @@ #include "addSub.h" -void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, - SWord8 *dif) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) { - const SWord8 s0 = x; - const SWord8 s1 = y; - const SWord8 s2 = s0 + s1; - const SWord8 s3 = s0 - s1; + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} - *sum = s2; - *dif = s3; +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_sub(SWord8 a, SWord8 b) +{ + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) - ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +void addSub(const SWord8 sbv_input_0, const SWord8 sbv_input_1, + SWord8 *sbv_output_0, SWord8 *sbv_output_1) +{ + const SWord8 s0 = sbv_input_0; + const SWord8 s1 = sbv_input_1; + const SWord8 s2 = sbv_bv_u8_add(s0, s1); + const SWord8 s3 = sbv_bv_u8_sub(s0, s1); + + *sbv_output_0 = s2; + *sbv_output_1 = s3; } == END: "addSub.c" ================== diff --git a/SBVTestSuite/GoldFiles/aes128Dec.gold b/SBVTestSuite/GoldFiles/aes128Dec.gold --- a/SBVTestSuite/GoldFiles/aes128Dec.gold +++ b/SBVTestSuite/GoldFiles/aes128Dec.gold @@ -12,2426 +12,4426 @@ 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 -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* Entry point prototype: */ -void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct); - -#endif /* __aes128Dec__HEADER_INCLUDED__ */ -== END: "aes128Dec.h" ================== -== BEGIN: "aes128Dec_driver.c" ================ -/* Example driver program for aes128Dec. */ -/* Automatically generated by SBV. Edit as you see fit! */ - -#include -#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[%1d] = 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[%1d] = 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[%1d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); - - return 0; -} -== END: "aes128Dec_driver.c" ================== -== BEGIN: "aes128Dec.c" ================ -/* File: "aes128Dec.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Dec.h" - -void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct) -{ - const SWord32 s0 = pt[0]; - const SWord32 s1 = pt[1]; - const SWord32 s2 = pt[2]; - const SWord32 s3 = pt[3]; - const SWord32 s4 = key[0]; - const SWord32 s5 = key[1]; - const SWord32 s6 = key[2]; - const SWord32 s7 = key[3]; - static const SWord8 table0[] = { - 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, - 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, - 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, - 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, - 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, - 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, - 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, - 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, - 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, - 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, - 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, - 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, - 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, - 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, - 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, - 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, - 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, - 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, - 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, - 38, 225, 105, 20, 99, 85, 33, 12, 125 - }; - static const SWord32 table1[] = { - 0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL, - 0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL, - 0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL, - 0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL, - 0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL, - 0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL, - 0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL, - 0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL, - 0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL, - 0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL, - 0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL, - 0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL, - 0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL, - 0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL, - 0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL, - 0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL, - 0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL, - 0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL, - 0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL, - 0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL, - 0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL, - 0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL, - 0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL, - 0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL, - 0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL, - 0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL, - 0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL, - 0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL, - 0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL, - 0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL, - 0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL, - 0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL, - 0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL, - 0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL, - 0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL, - 0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL, - 0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL, - 0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL, - 0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL, - 0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL, - 0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL, - 0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL, - 0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL, - 0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL, - 0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL, - 0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL, - 0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL, - 0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL, - 0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL, - 0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL, - 0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL, - 0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL, - 0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL, - 0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL, - 0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL, - 0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL, - 0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL, - 0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL, - 0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL, - 0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL, - 0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL, - 0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL, - 0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL, - 0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL - }; - static const SWord8 table2[] = { - 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, - 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, - 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, - 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, - 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, - 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, - 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, - 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, - 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, - 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, - 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, - 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, - 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, - 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, - 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, - 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, - 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, - 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, - 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, - 104, 65, 153, 45, 15, 176, 84, 187, 22 - }; - static const SWord32 table3[] = { - 0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL, - 0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL, - 0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL, - 0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL, - 0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL, - 0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL, - 0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL, - 0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL, - 0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL, - 0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL, - 0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL, - 0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL, - 0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL, - 0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL, - 0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL, - 0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL, - 0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL, - 0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL, - 0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL, - 0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL, - 0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL, - 0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL, - 0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL, - 0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL, - 0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL, - 0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL, - 0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL, - 0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL, - 0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL, - 0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL, - 0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL, - 0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL, - 0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL, - 0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL, - 0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL, - 0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL, - 0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL, - 0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL, - 0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL, - 0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL, - 0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL, - 0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL, - 0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL, - 0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL, - 0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL, - 0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL, - 0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL, - 0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL, - 0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL, - 0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL, - 0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL, - 0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL, - 0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL, - 0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL, - 0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL, - 0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL, - 0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL, - 0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL, - 0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL, - 0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL, - 0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL, - 0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL, - 0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL, - 0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL - }; - static const SWord32 table4[] = { - 0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL, - 0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL, - 0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL, - 0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL, - 0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL, - 0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL, - 0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL, - 0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL, - 0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL, - 0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL, - 0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL, - 0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL, - 0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL, - 0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL, - 0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL, - 0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL, - 0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL, - 0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL, - 0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL, - 0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL, - 0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL, - 0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL, - 0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL, - 0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL, - 0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL, - 0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL, - 0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL, - 0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL, - 0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL, - 0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL, - 0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL, - 0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL, - 0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL, - 0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL, - 0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL, - 0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL, - 0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL, - 0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL, - 0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL, - 0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL, - 0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL, - 0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL, - 0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL, - 0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL, - 0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL, - 0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL, - 0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL, - 0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL, - 0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL, - 0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL, - 0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL, - 0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL, - 0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL, - 0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL, - 0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL, - 0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL, - 0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL, - 0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL, - 0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL, - 0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL, - 0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL, - 0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL, - 0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL, - 0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL - }; - static const SWord32 table5[] = { - 0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL, - 0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL, - 0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL, - 0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL, - 0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL, - 0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL, - 0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL, - 0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL, - 0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL, - 0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL, - 0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL, - 0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL, - 0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL, - 0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL, - 0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL, - 0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL, - 0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL, - 0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL, - 0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL, - 0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL, - 0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL, - 0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL, - 0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL, - 0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL, - 0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL, - 0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL, - 0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL, - 0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL, - 0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL, - 0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL, - 0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL, - 0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL, - 0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL, - 0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL, - 0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL, - 0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL, - 0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL, - 0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL, - 0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL, - 0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL, - 0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL, - 0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL, - 0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL, - 0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL, - 0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL, - 0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL, - 0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL, - 0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL, - 0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL, - 0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL, - 0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL, - 0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL, - 0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL, - 0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL, - 0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL, - 0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL, - 0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL, - 0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL, - 0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL, - 0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL, - 0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL, - 0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL, - 0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL, - 0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL - }; - static const SWord8 table6[] = { - 0, 14, 28, 18, 56, 54, 36, 42, 112, 126, 108, 98, 72, - 70, 84, 90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158, - 140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255, - 241, 171, 165, 183, 185, 147, 157, 143, 129, 59, 53, 39, 41, - 3, 13, 31, 17, 75, 69, 87, 89, 115, 125, 111, 97, 173, - 163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235, - 249, 247, 77, 67, 81, 95, 117, 123, 105, 103, 61, 51, 33, - 47, 5, 11, 25, 23, 118, 120, 106, 100, 78, 64, 82, 92, - 6, 8, 26, 20, 62, 48, 34, 44, 150, 152, 138, 132, 174, - 160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204, 65, 79, - 93, 83, 121, 119, 101, 107, 49, 63, 45, 35, 9, 7, 21, - 27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195, - 233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234, - 228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104, 66, 76, - 94, 80, 10, 4, 22, 24, 50, 60, 46, 32, 236, 226, 240, - 254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182, - 12, 2, 16, 30, 52, 58, 40, 38, 124, 114, 96, 110, 68, - 74, 88, 86, 55, 57, 43, 37, 15, 1, 19, 29, 71, 73, - 91, 85, 127, 113, 99, 109, 215, 217, 203, 197, 239, 225, 243, - 253, 167, 169, 187, 181, 159, 145, 131, 141 - }; - static const SWord8 table7[] = { - 0, 11, 22, 29, 44, 39, 58, 49, 88, 83, 78, 69, 116, - 127, 98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227, - 254, 245, 196, 207, 210, 217, 123, 112, 109, 102, 87, 92, 65, - 74, 35, 40, 53, 62, 15, 4, 25, 18, 203, 192, 221, 214, - 231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246, - 253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137, - 148, 159, 70, 77, 80, 91, 106, 97, 124, 119, 30, 21, 8, - 3, 50, 57, 36, 47, 141, 134, 155, 144, 161, 170, 183, 188, - 213, 222, 195, 200, 249, 242, 239, 228, 61, 54, 43, 32, 17, - 26, 7, 12, 101, 110, 115, 120, 73, 66, 95, 84, 247, 252, - 225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149, - 158, 71, 76, 81, 90, 107, 96, 125, 118, 31, 20, 9, 2, - 51, 56, 37, 46, 140, 135, 154, 145, 160, 171, 182, 189, 212, - 223, 194, 201, 248, 243, 238, 229, 60, 55, 42, 33, 16, 27, - 6, 13, 100, 111, 114, 121, 72, 67, 94, 85, 1, 10, 23, - 28, 45, 38, 59, 48, 89, 82, 79, 68, 117, 126, 99, 104, - 177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197, - 206, 211, 216, 122, 113, 108, 103, 86, 93, 64, 75, 34, 41, - 52, 63, 14, 5, 24, 19, 202, 193, 220, 215, 230, 237, 240, - 251, 146, 153, 132, 143, 190, 181, 168, 163 - }; - static const SWord8 table8[] = { - 0, 13, 26, 23, 52, 57, 46, 35, 104, 101, 114, 127, 92, - 81, 70, 75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181, - 162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149, - 152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124, - 95, 82, 69, 72, 3, 14, 25, 20, 55, 58, 45, 32, 109, - 96, 119, 122, 89, 84, 67, 78, 5, 8, 31, 18, 49, 60, - 43, 38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207, - 194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245, - 190, 179, 164, 169, 138, 135, 144, 157, 6, 11, 28, 17, 50, - 63, 40, 37, 110, 99, 116, 121, 90, 87, 64, 77, 218, 215, - 192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156, - 145, 10, 7, 16, 29, 62, 51, 36, 41, 98, 111, 120, 117, - 86, 91, 76, 65, 97, 108, 123, 118, 85, 88, 79, 66, 9, - 4, 19, 30, 61, 48, 39, 42, 177, 188, 171, 166, 133, 136, - 159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173, - 160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252, - 103, 106, 125, 112, 83, 94, 73, 68, 15, 2, 21, 24, 59, - 54, 33, 44, 12, 1, 22, 27, 56, 53, 34, 47, 100, 105, - 126, 115, 80, 93, 74, 71, 220, 209, 198, 203, 232, 229, 242, - 255, 180, 185, 174, 163, 128, 141, 154, 151 - }; - static const SWord8 table9[] = { - 0, 9, 18, 27, 36, 45, 54, 63, 72, 65, 90, 83, 108, - 101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209, - 202, 195, 252, 245, 238, 231, 59, 50, 41, 32, 31, 22, 13, - 4, 115, 122, 97, 104, 87, 94, 69, 76, 171, 162, 185, 176, - 143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118, - 127, 100, 109, 82, 91, 64, 73, 62, 55, 44, 37, 26, 19, - 8, 1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188, - 181, 138, 131, 152, 145, 77, 68, 95, 86, 105, 96, 123, 114, - 5, 12, 23, 30, 33, 40, 51, 58, 221, 212, 207, 198, 249, - 240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229, - 254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146, - 155, 124, 117, 110, 103, 88, 81, 74, 67, 52, 61, 38, 47, - 16, 25, 2, 11, 215, 222, 197, 204, 243, 250, 225, 232, 159, - 150, 141, 132, 187, 178, 169, 160, 71, 78, 85, 92, 99, 106, - 113, 120, 15, 6, 29, 20, 43, 34, 57, 48, 154, 147, 136, - 129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237, - 10, 3, 24, 17, 46, 39, 60, 53, 66, 75, 80, 89, 102, - 111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224, - 251, 242, 205, 196, 223, 214, 49, 56, 35, 42, 21, 28, 7, - 14, 121, 112, 107, 98, 93, 84, 79, 70 - }; - const SWord32 s520 = (s7 << 8) | (s7 >> 24); - const SWord8 s521 = (SWord8) (s520 >> 24); - const SWord8 s522 = table2[s521]; - const SWord8 s523 = 1 ^ s522; - const SWord8 s524 = (SWord8) (s520 >> 16); - const SWord8 s525 = table2[s524]; - const SWord16 s526 = (((SWord16) s523) << 8) | ((SWord16) s525); - const SWord8 s527 = (SWord8) (s520 >> 8); - const SWord8 s528 = table2[s527]; - const SWord8 s529 = (SWord8) s520; - const SWord8 s530 = table2[s529]; - const SWord16 s531 = (((SWord16) s528) << 8) | ((SWord16) s530); - const SWord32 s532 = (((SWord32) s526) << 16) | ((SWord32) s531); - const SWord32 s533 = s4 ^ s532; - const SWord32 s534 = s5 ^ s533; - const SWord32 s535 = s6 ^ s534; - const SWord32 s536 = s7 ^ s535; - const SWord32 s537 = (s536 << 8) | (s536 >> 24); - const SWord8 s538 = (SWord8) (s537 >> 24); - const SWord8 s539 = table2[s538]; - const SWord8 s540 = 2 ^ s539; - const SWord8 s541 = (SWord8) (s537 >> 16); - const SWord8 s542 = table2[s541]; - const SWord16 s543 = (((SWord16) s540) << 8) | ((SWord16) s542); - const SWord8 s544 = (SWord8) (s537 >> 8); - const SWord8 s545 = table2[s544]; - const SWord8 s546 = (SWord8) s537; - const SWord8 s547 = table2[s546]; - const SWord16 s548 = (((SWord16) s545) << 8) | ((SWord16) s547); - const SWord32 s549 = (((SWord32) s543) << 16) | ((SWord32) s548); - const SWord32 s550 = s533 ^ s549; - const SWord32 s551 = s534 ^ s550; - const SWord32 s552 = s535 ^ s551; - const SWord32 s553 = s536 ^ s552; - const SWord32 s554 = (s553 << 8) | (s553 >> 24); - const SWord8 s555 = (SWord8) (s554 >> 24); - const SWord8 s556 = table2[s555]; - const SWord8 s557 = 4 ^ s556; - const SWord8 s558 = (SWord8) (s554 >> 16); - const SWord8 s559 = table2[s558]; - const SWord16 s560 = (((SWord16) s557) << 8) | ((SWord16) s559); - const SWord8 s561 = (SWord8) (s554 >> 8); - const SWord8 s562 = table2[s561]; - const SWord8 s563 = (SWord8) s554; - const SWord8 s564 = table2[s563]; - const SWord16 s565 = (((SWord16) s562) << 8) | ((SWord16) s564); - const SWord32 s566 = (((SWord32) s560) << 16) | ((SWord32) s565); - const SWord32 s567 = s550 ^ s566; - const SWord32 s568 = s551 ^ s567; - const SWord32 s569 = s552 ^ s568; - const SWord32 s570 = s553 ^ s569; - const SWord32 s571 = (s570 << 8) | (s570 >> 24); - const SWord8 s572 = (SWord8) (s571 >> 24); - const SWord8 s573 = table2[s572]; - const SWord8 s574 = 8 ^ s573; - const SWord8 s575 = (SWord8) (s571 >> 16); - const SWord8 s576 = table2[s575]; - const SWord16 s577 = (((SWord16) s574) << 8) | ((SWord16) s576); - const SWord8 s578 = (SWord8) (s571 >> 8); - const SWord8 s579 = table2[s578]; - const SWord8 s580 = (SWord8) s571; - const SWord8 s581 = table2[s580]; - const SWord16 s582 = (((SWord16) s579) << 8) | ((SWord16) s581); - const SWord32 s583 = (((SWord32) s577) << 16) | ((SWord32) s582); - const SWord32 s584 = s567 ^ s583; - const SWord32 s585 = s568 ^ s584; - const SWord32 s586 = s569 ^ s585; - const SWord32 s587 = s570 ^ s586; - const SWord32 s588 = (s587 << 8) | (s587 >> 24); - const SWord8 s589 = (SWord8) (s588 >> 24); - const SWord8 s590 = table2[s589]; - const SWord8 s591 = 16 ^ s590; - const SWord8 s592 = (SWord8) (s588 >> 16); - const SWord8 s593 = table2[s592]; - const SWord16 s594 = (((SWord16) s591) << 8) | ((SWord16) s593); - const SWord8 s595 = (SWord8) (s588 >> 8); - const SWord8 s596 = table2[s595]; - const SWord8 s597 = (SWord8) s588; - const SWord8 s598 = table2[s597]; - const SWord16 s599 = (((SWord16) s596) << 8) | ((SWord16) s598); - const SWord32 s600 = (((SWord32) s594) << 16) | ((SWord32) s599); - const SWord32 s601 = s584 ^ s600; - const SWord32 s602 = s585 ^ s601; - const SWord32 s603 = s586 ^ s602; - const SWord32 s604 = s587 ^ s603; - const SWord32 s605 = (s604 << 8) | (s604 >> 24); - const SWord8 s606 = (SWord8) (s605 >> 24); - const SWord8 s607 = table2[s606]; - const SWord8 s608 = 32 ^ s607; - const SWord8 s609 = (SWord8) (s605 >> 16); - const SWord8 s610 = table2[s609]; - const SWord16 s611 = (((SWord16) s608) << 8) | ((SWord16) s610); - const SWord8 s612 = (SWord8) (s605 >> 8); - const SWord8 s613 = table2[s612]; - const SWord8 s614 = (SWord8) s605; - const SWord8 s615 = table2[s614]; - const SWord16 s616 = (((SWord16) s613) << 8) | ((SWord16) s615); - const SWord32 s617 = (((SWord32) s611) << 16) | ((SWord32) s616); - const SWord32 s618 = s601 ^ s617; - const SWord32 s619 = s602 ^ s618; - const SWord32 s620 = s603 ^ s619; - const SWord32 s621 = s604 ^ s620; - const SWord32 s622 = (s621 << 8) | (s621 >> 24); - const SWord8 s623 = (SWord8) (s622 >> 24); - const SWord8 s624 = table2[s623]; - const SWord8 s625 = 64 ^ s624; - const SWord8 s626 = (SWord8) (s622 >> 16); - const SWord8 s627 = table2[s626]; - const SWord16 s628 = (((SWord16) s625) << 8) | ((SWord16) s627); - const SWord8 s629 = (SWord8) (s622 >> 8); - const SWord8 s630 = table2[s629]; - const SWord8 s631 = (SWord8) s622; - const SWord8 s632 = table2[s631]; - const SWord16 s633 = (((SWord16) s630) << 8) | ((SWord16) s632); - const SWord32 s634 = (((SWord32) s628) << 16) | ((SWord32) s633); - const SWord32 s635 = s618 ^ s634; - const SWord32 s636 = s619 ^ s635; - const SWord32 s637 = s620 ^ s636; - const SWord32 s638 = s621 ^ s637; - const SWord32 s639 = (s638 << 8) | (s638 >> 24); - const SWord8 s640 = (SWord8) (s639 >> 24); - const SWord8 s641 = table2[s640]; - const SWord8 s642 = 128 ^ s641; - const SWord8 s643 = (SWord8) (s639 >> 16); - const SWord8 s644 = table2[s643]; - const SWord16 s645 = (((SWord16) s642) << 8) | ((SWord16) s644); - const SWord8 s646 = (SWord8) (s639 >> 8); - const SWord8 s647 = table2[s646]; - const SWord8 s648 = (SWord8) s639; - const SWord8 s649 = table2[s648]; - const SWord16 s650 = (((SWord16) s647) << 8) | ((SWord16) s649); - const SWord32 s651 = (((SWord32) s645) << 16) | ((SWord32) s650); - const SWord32 s652 = s635 ^ s651; - const SWord32 s653 = s636 ^ s652; - const SWord32 s654 = s637 ^ s653; - const SWord32 s655 = s638 ^ s654; - const SWord32 s656 = (s655 << 8) | (s655 >> 24); - const SWord8 s657 = (SWord8) (s656 >> 24); - const SWord8 s658 = table2[s657]; - const SWord8 s659 = 27 ^ s658; - const SWord8 s660 = (SWord8) (s656 >> 16); - const SWord8 s661 = table2[s660]; - const SWord16 s662 = (((SWord16) s659) << 8) | ((SWord16) s661); - const SWord8 s663 = (SWord8) (s656 >> 8); - const SWord8 s664 = table2[s663]; - const SWord8 s665 = (SWord8) s656; - const SWord8 s666 = table2[s665]; - const SWord16 s667 = (((SWord16) s664) << 8) | ((SWord16) s666); - const SWord32 s668 = (((SWord32) s662) << 16) | ((SWord32) s667); - const SWord32 s669 = s652 ^ s668; - const SWord32 s670 = s653 ^ s669; - const SWord32 s671 = s654 ^ s670; - const SWord32 s672 = s655 ^ s671; - const SWord32 s673 = (s672 << 8) | (s672 >> 24); - const SWord8 s674 = (SWord8) (s673 >> 24); - const SWord8 s675 = table2[s674]; - const SWord8 s676 = 54 ^ s675; - const SWord8 s677 = (SWord8) (s673 >> 16); - const SWord8 s678 = table2[s677]; - const SWord16 s679 = (((SWord16) s676) << 8) | ((SWord16) s678); - const SWord8 s680 = (SWord8) (s673 >> 8); - const SWord8 s681 = table2[s680]; - const SWord8 s682 = (SWord8) s673; - const SWord8 s683 = table2[s682]; - const SWord16 s684 = (((SWord16) s681) << 8) | ((SWord16) s683); - const SWord32 s685 = (((SWord32) s679) << 16) | ((SWord32) s684); - const SWord32 s686 = s669 ^ s685; - const SWord32 s687 = s0 ^ s686; - const SWord8 s688 = (SWord8) (s687 >> 24); - const SWord32 s689 = table1[s688]; - const SWord32 s945 = s670 ^ s686; - const SWord32 s946 = s671 ^ s945; - const SWord32 s947 = s672 ^ s946; - const SWord32 s948 = s3 ^ s947; - const SWord8 s949 = (SWord8) (s948 >> 16); - const SWord32 s950 = table3[s949]; - const SWord32 s951 = s689 ^ s950; - const SWord32 s1207 = s2 ^ s946; - const SWord8 s1208 = (SWord8) (s1207 >> 8); - const SWord32 s1209 = table4[s1208]; - const SWord32 s1210 = s951 ^ s1209; - const SWord32 s1466 = s1 ^ s945; - const SWord8 s1467 = (SWord8) s1466; - const SWord32 s1468 = table5[s1467]; - const SWord32 s1469 = s1210 ^ s1468; - const SWord8 s1470 = (SWord8) (s669 >> 24); - const SWord8 s1471 = table6[s1470]; - const SWord8 s1472 = (SWord8) (s669 >> 16); - const SWord8 s1473 = table7[s1472]; - const SWord8 s1474 = (SWord8) (s669 >> 8); - const SWord8 s1475 = table8[s1474]; - const SWord8 s1476 = (SWord8) s669; - const SWord8 s1477 = table9[s1476]; - const SWord8 s1478 = s1475 ^ s1477; - const SWord8 s1479 = s1473 ^ s1478; - const SWord8 s1480 = s1471 ^ s1479; - const SWord8 s1481 = table9[s1470]; - const SWord8 s1482 = table6[s1472]; - const SWord8 s1483 = table7[s1474]; - const SWord8 s1484 = table8[s1476]; - const SWord8 s1485 = s1483 ^ s1484; - const SWord8 s1486 = s1482 ^ s1485; - const SWord8 s1487 = s1481 ^ s1486; - const SWord16 s1488 = (((SWord16) s1480) << 8) | ((SWord16) s1487); - const SWord8 s1489 = table8[s1470]; - const SWord8 s1490 = table9[s1472]; - const SWord8 s1491 = table6[s1474]; - const SWord8 s1492 = table7[s1476]; - const SWord8 s1493 = s1491 ^ s1492; - const SWord8 s1494 = s1490 ^ s1493; - const SWord8 s1495 = s1489 ^ s1494; - const SWord8 s1496 = table7[s1470]; - const SWord8 s1497 = table8[s1472]; - const SWord8 s1498 = table9[s1474]; - const SWord8 s1499 = table6[s1476]; - const SWord8 s1500 = s1498 ^ s1499; - const SWord8 s1501 = s1497 ^ s1500; - const SWord8 s1502 = s1496 ^ s1501; - const SWord16 s1503 = (((SWord16) s1495) << 8) | ((SWord16) s1502); - const SWord32 s1504 = (((SWord32) s1488) << 16) | ((SWord32) s1503); - const SWord32 s1505 = s1469 ^ s1504; - const SWord8 s1506 = (SWord8) (s1505 >> 24); - const SWord32 s1507 = table1[s1506]; - const SWord8 s1508 = (SWord8) (s948 >> 24); - const SWord32 s1509 = table1[s1508]; - const SWord8 s1510 = (SWord8) (s1207 >> 16); - const SWord32 s1511 = table3[s1510]; - const SWord32 s1512 = s1509 ^ s1511; - const SWord8 s1513 = (SWord8) (s1466 >> 8); - const SWord32 s1514 = table4[s1513]; - const SWord32 s1515 = s1512 ^ s1514; - const SWord8 s1516 = (SWord8) s687; - const SWord32 s1517 = table5[s1516]; - const SWord32 s1518 = s1515 ^ s1517; - const SWord8 s1519 = (SWord8) (s672 >> 24); - const SWord8 s1520 = table6[s1519]; - const SWord8 s1521 = (SWord8) (s672 >> 16); - const SWord8 s1522 = table7[s1521]; - const SWord8 s1523 = (SWord8) (s672 >> 8); - const SWord8 s1524 = table8[s1523]; - const SWord8 s1525 = (SWord8) s672; - const SWord8 s1526 = table9[s1525]; - const SWord8 s1527 = s1524 ^ s1526; - const SWord8 s1528 = s1522 ^ s1527; - const SWord8 s1529 = s1520 ^ s1528; - const SWord8 s1530 = table9[s1519]; - const SWord8 s1531 = table6[s1521]; - const SWord8 s1532 = table7[s1523]; - const SWord8 s1533 = table8[s1525]; - const SWord8 s1534 = s1532 ^ s1533; - const SWord8 s1535 = s1531 ^ s1534; - const SWord8 s1536 = s1530 ^ s1535; - const SWord16 s1537 = (((SWord16) s1529) << 8) | ((SWord16) s1536); - const SWord8 s1538 = table8[s1519]; - const SWord8 s1539 = table9[s1521]; - const SWord8 s1540 = table6[s1523]; - const SWord8 s1541 = table7[s1525]; - const SWord8 s1542 = s1540 ^ s1541; - const SWord8 s1543 = s1539 ^ s1542; - const SWord8 s1544 = s1538 ^ s1543; - const SWord8 s1545 = table7[s1519]; - const SWord8 s1546 = table8[s1521]; - const SWord8 s1547 = table9[s1523]; - const SWord8 s1548 = table6[s1525]; - const SWord8 s1549 = s1547 ^ s1548; - const SWord8 s1550 = s1546 ^ s1549; - const SWord8 s1551 = s1545 ^ s1550; - const SWord16 s1552 = (((SWord16) s1544) << 8) | ((SWord16) s1551); - const SWord32 s1553 = (((SWord32) s1537) << 16) | ((SWord32) s1552); - const SWord32 s1554 = s1518 ^ s1553; - const SWord8 s1555 = (SWord8) (s1554 >> 16); - const SWord32 s1556 = table3[s1555]; - const SWord32 s1557 = s1507 ^ s1556; - const SWord8 s1558 = (SWord8) (s1207 >> 24); - const SWord32 s1559 = table1[s1558]; - const SWord8 s1560 = (SWord8) (s1466 >> 16); - const SWord32 s1561 = table3[s1560]; - const SWord32 s1562 = s1559 ^ s1561; - const SWord8 s1563 = (SWord8) (s687 >> 8); - const SWord32 s1564 = table4[s1563]; - const SWord32 s1565 = s1562 ^ s1564; - const SWord8 s1566 = (SWord8) s948; - const SWord32 s1567 = table5[s1566]; - const SWord32 s1568 = s1565 ^ s1567; - const SWord8 s1569 = (SWord8) (s671 >> 24); - const SWord8 s1570 = table6[s1569]; - const SWord8 s1571 = (SWord8) (s671 >> 16); - const SWord8 s1572 = table7[s1571]; - const SWord8 s1573 = (SWord8) (s671 >> 8); - const SWord8 s1574 = table8[s1573]; - const SWord8 s1575 = (SWord8) s671; - const SWord8 s1576 = table9[s1575]; - const SWord8 s1577 = s1574 ^ s1576; - const SWord8 s1578 = s1572 ^ s1577; - const SWord8 s1579 = s1570 ^ s1578; - const SWord8 s1580 = table9[s1569]; - const SWord8 s1581 = table6[s1571]; - const SWord8 s1582 = table7[s1573]; - const SWord8 s1583 = table8[s1575]; - const SWord8 s1584 = s1582 ^ s1583; - const SWord8 s1585 = s1581 ^ s1584; - const SWord8 s1586 = s1580 ^ s1585; - const SWord16 s1587 = (((SWord16) s1579) << 8) | ((SWord16) s1586); - const SWord8 s1588 = table8[s1569]; - const SWord8 s1589 = table9[s1571]; - const SWord8 s1590 = table6[s1573]; - const SWord8 s1591 = table7[s1575]; - const SWord8 s1592 = s1590 ^ s1591; - const SWord8 s1593 = s1589 ^ s1592; - const SWord8 s1594 = s1588 ^ s1593; - const SWord8 s1595 = table7[s1569]; - const SWord8 s1596 = table8[s1571]; - const SWord8 s1597 = table9[s1573]; - const SWord8 s1598 = table6[s1575]; - const SWord8 s1599 = s1597 ^ s1598; - const SWord8 s1600 = s1596 ^ s1599; - const SWord8 s1601 = s1595 ^ s1600; - const SWord16 s1602 = (((SWord16) s1594) << 8) | ((SWord16) s1601); - const SWord32 s1603 = (((SWord32) s1587) << 16) | ((SWord32) s1602); - const SWord32 s1604 = s1568 ^ s1603; - const SWord8 s1605 = (SWord8) (s1604 >> 8); - const SWord32 s1606 = table4[s1605]; - const SWord32 s1607 = s1557 ^ s1606; - const SWord8 s1608 = (SWord8) (s1466 >> 24); - const SWord32 s1609 = table1[s1608]; - const SWord8 s1610 = (SWord8) (s687 >> 16); - const SWord32 s1611 = table3[s1610]; - const SWord32 s1612 = s1609 ^ s1611; - const SWord8 s1613 = (SWord8) (s948 >> 8); - const SWord32 s1614 = table4[s1613]; - const SWord32 s1615 = s1612 ^ s1614; - const SWord8 s1616 = (SWord8) s1207; - const SWord32 s1617 = table5[s1616]; - const SWord32 s1618 = s1615 ^ s1617; - const SWord8 s1619 = (SWord8) (s670 >> 24); - const SWord8 s1620 = table6[s1619]; - const SWord8 s1621 = (SWord8) (s670 >> 16); - const SWord8 s1622 = table7[s1621]; - const SWord8 s1623 = (SWord8) (s670 >> 8); - const SWord8 s1624 = table8[s1623]; - const SWord8 s1625 = (SWord8) s670; - const SWord8 s1626 = table9[s1625]; - const SWord8 s1627 = s1624 ^ s1626; - const SWord8 s1628 = s1622 ^ s1627; - const SWord8 s1629 = s1620 ^ s1628; - const SWord8 s1630 = table9[s1619]; - const SWord8 s1631 = table6[s1621]; - const SWord8 s1632 = table7[s1623]; - const SWord8 s1633 = table8[s1625]; - const SWord8 s1634 = s1632 ^ s1633; - const SWord8 s1635 = s1631 ^ s1634; - const SWord8 s1636 = s1630 ^ s1635; - const SWord16 s1637 = (((SWord16) s1629) << 8) | ((SWord16) s1636); - const SWord8 s1638 = table8[s1619]; - const SWord8 s1639 = table9[s1621]; - const SWord8 s1640 = table6[s1623]; - const SWord8 s1641 = table7[s1625]; - const SWord8 s1642 = s1640 ^ s1641; - const SWord8 s1643 = s1639 ^ s1642; - const SWord8 s1644 = s1638 ^ s1643; - const SWord8 s1645 = table7[s1619]; - const SWord8 s1646 = table8[s1621]; - const SWord8 s1647 = table9[s1623]; - const SWord8 s1648 = table6[s1625]; - const SWord8 s1649 = s1647 ^ s1648; - const SWord8 s1650 = s1646 ^ s1649; - const SWord8 s1651 = s1645 ^ s1650; - const SWord16 s1652 = (((SWord16) s1644) << 8) | ((SWord16) s1651); - const SWord32 s1653 = (((SWord32) s1637) << 16) | ((SWord32) s1652); - const SWord32 s1654 = s1618 ^ s1653; - const SWord8 s1655 = (SWord8) s1654; - const SWord32 s1656 = table5[s1655]; - const SWord32 s1657 = s1607 ^ s1656; - const SWord8 s1658 = (SWord8) (s652 >> 24); - const SWord8 s1659 = table6[s1658]; - const SWord8 s1660 = (SWord8) (s652 >> 16); - const SWord8 s1661 = table7[s1660]; - const SWord8 s1662 = (SWord8) (s652 >> 8); - const SWord8 s1663 = table8[s1662]; - const SWord8 s1664 = (SWord8) s652; - const SWord8 s1665 = table9[s1664]; - const SWord8 s1666 = s1663 ^ s1665; - const SWord8 s1667 = s1661 ^ s1666; - const SWord8 s1668 = s1659 ^ s1667; - const SWord8 s1669 = table9[s1658]; - const SWord8 s1670 = table6[s1660]; - 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[s1658]; - const SWord8 s1678 = table9[s1660]; - 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[s1658]; - const SWord8 s1685 = table8[s1660]; - 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 = s1657 ^ s1692; - const SWord8 s1694 = (SWord8) (s1693 >> 24); - const SWord32 s1695 = table1[s1694]; - const SWord8 s1696 = (SWord8) (s1554 >> 24); - const SWord32 s1697 = table1[s1696]; - const SWord8 s1698 = (SWord8) (s1604 >> 16); - const SWord32 s1699 = table3[s1698]; - const SWord32 s1700 = s1697 ^ s1699; - const SWord8 s1701 = (SWord8) (s1654 >> 8); - const SWord32 s1702 = table4[s1701]; - const SWord32 s1703 = s1700 ^ s1702; - const SWord8 s1704 = (SWord8) s1505; - const SWord32 s1705 = table5[s1704]; - const SWord32 s1706 = s1703 ^ s1705; - const SWord8 s1707 = (SWord8) (s655 >> 24); - const SWord8 s1708 = table6[s1707]; - const SWord8 s1709 = (SWord8) (s655 >> 16); - const SWord8 s1710 = table7[s1709]; - const SWord8 s1711 = (SWord8) (s655 >> 8); - const SWord8 s1712 = table8[s1711]; - const SWord8 s1713 = (SWord8) s655; - const SWord8 s1714 = table9[s1713]; - const SWord8 s1715 = s1712 ^ s1714; - const SWord8 s1716 = s1710 ^ s1715; - const SWord8 s1717 = s1708 ^ s1716; - const SWord8 s1718 = table9[s1707]; - const SWord8 s1719 = table6[s1709]; - const SWord8 s1720 = table7[s1711]; - const SWord8 s1721 = table8[s1713]; - const SWord8 s1722 = s1720 ^ s1721; - const SWord8 s1723 = s1719 ^ s1722; - const SWord8 s1724 = s1718 ^ s1723; - const SWord16 s1725 = (((SWord16) s1717) << 8) | ((SWord16) s1724); - const SWord8 s1726 = table8[s1707]; - const SWord8 s1727 = table9[s1709]; - const SWord8 s1728 = table6[s1711]; - const SWord8 s1729 = table7[s1713]; - const SWord8 s1730 = s1728 ^ s1729; - const SWord8 s1731 = s1727 ^ s1730; - const SWord8 s1732 = s1726 ^ s1731; - const SWord8 s1733 = table7[s1707]; - const SWord8 s1734 = table8[s1709]; - const SWord8 s1735 = table9[s1711]; - const SWord8 s1736 = table6[s1713]; - const SWord8 s1737 = s1735 ^ s1736; - const SWord8 s1738 = s1734 ^ s1737; - const SWord8 s1739 = s1733 ^ s1738; - const SWord16 s1740 = (((SWord16) s1732) << 8) | ((SWord16) s1739); - const SWord32 s1741 = (((SWord32) s1725) << 16) | ((SWord32) s1740); - const SWord32 s1742 = s1706 ^ s1741; - const SWord8 s1743 = (SWord8) (s1742 >> 16); - const SWord32 s1744 = table3[s1743]; - const SWord32 s1745 = s1695 ^ s1744; - const SWord8 s1746 = (SWord8) (s1604 >> 24); - const SWord32 s1747 = table1[s1746]; - const SWord8 s1748 = (SWord8) (s1654 >> 16); - const SWord32 s1749 = table3[s1748]; - const SWord32 s1750 = s1747 ^ s1749; - const SWord8 s1751 = (SWord8) (s1505 >> 8); - const SWord32 s1752 = table4[s1751]; - const SWord32 s1753 = s1750 ^ s1752; - const SWord8 s1754 = (SWord8) s1554; - const SWord32 s1755 = table5[s1754]; - const SWord32 s1756 = s1753 ^ s1755; - const SWord8 s1757 = (SWord8) (s654 >> 24); - const SWord8 s1758 = table6[s1757]; - const SWord8 s1759 = (SWord8) (s654 >> 16); - const SWord8 s1760 = table7[s1759]; - const SWord8 s1761 = (SWord8) (s654 >> 8); - const SWord8 s1762 = table8[s1761]; - const SWord8 s1763 = (SWord8) s654; - const SWord8 s1764 = table9[s1763]; - const SWord8 s1765 = s1762 ^ s1764; - const SWord8 s1766 = s1760 ^ s1765; - const SWord8 s1767 = s1758 ^ s1766; - const SWord8 s1768 = table9[s1757]; - const SWord8 s1769 = table6[s1759]; - const SWord8 s1770 = table7[s1761]; - const SWord8 s1771 = table8[s1763]; - const SWord8 s1772 = s1770 ^ s1771; - const SWord8 s1773 = s1769 ^ s1772; - const SWord8 s1774 = s1768 ^ s1773; - const SWord16 s1775 = (((SWord16) s1767) << 8) | ((SWord16) s1774); - const SWord8 s1776 = table8[s1757]; - const SWord8 s1777 = table9[s1759]; - const SWord8 s1778 = table6[s1761]; - const SWord8 s1779 = table7[s1763]; - const SWord8 s1780 = s1778 ^ s1779; - const SWord8 s1781 = s1777 ^ s1780; - const SWord8 s1782 = s1776 ^ s1781; - const SWord8 s1783 = table7[s1757]; - const SWord8 s1784 = table8[s1759]; - const SWord8 s1785 = table9[s1761]; - const SWord8 s1786 = table6[s1763]; - const SWord8 s1787 = s1785 ^ s1786; - const SWord8 s1788 = s1784 ^ s1787; - const SWord8 s1789 = s1783 ^ s1788; - const SWord16 s1790 = (((SWord16) s1782) << 8) | ((SWord16) s1789); - const SWord32 s1791 = (((SWord32) s1775) << 16) | ((SWord32) s1790); - const SWord32 s1792 = s1756 ^ s1791; - const SWord8 s1793 = (SWord8) (s1792 >> 8); - const SWord32 s1794 = table4[s1793]; - const SWord32 s1795 = s1745 ^ s1794; - const SWord8 s1796 = (SWord8) (s1654 >> 24); - const SWord32 s1797 = table1[s1796]; - const SWord8 s1798 = (SWord8) (s1505 >> 16); - const SWord32 s1799 = table3[s1798]; - const SWord32 s1800 = s1797 ^ s1799; - const SWord8 s1801 = (SWord8) (s1554 >> 8); - const SWord32 s1802 = table4[s1801]; - const SWord32 s1803 = s1800 ^ s1802; - const SWord8 s1804 = (SWord8) s1604; - const SWord32 s1805 = table5[s1804]; - const SWord32 s1806 = s1803 ^ s1805; - const SWord8 s1807 = (SWord8) (s653 >> 24); - const SWord8 s1808 = table6[s1807]; - const SWord8 s1809 = (SWord8) (s653 >> 16); - const SWord8 s1810 = table7[s1809]; - const SWord8 s1811 = (SWord8) (s653 >> 8); - const SWord8 s1812 = table8[s1811]; - const SWord8 s1813 = (SWord8) s653; - const SWord8 s1814 = table9[s1813]; - const SWord8 s1815 = s1812 ^ s1814; - const SWord8 s1816 = s1810 ^ s1815; - const SWord8 s1817 = s1808 ^ s1816; - const SWord8 s1818 = table9[s1807]; - const SWord8 s1819 = table6[s1809]; - const SWord8 s1820 = table7[s1811]; - const SWord8 s1821 = table8[s1813]; - const SWord8 s1822 = s1820 ^ s1821; - const SWord8 s1823 = s1819 ^ s1822; - const SWord8 s1824 = s1818 ^ s1823; - const SWord16 s1825 = (((SWord16) s1817) << 8) | ((SWord16) s1824); - const SWord8 s1826 = table8[s1807]; - const SWord8 s1827 = table9[s1809]; - const SWord8 s1828 = table6[s1811]; - const SWord8 s1829 = table7[s1813]; - const SWord8 s1830 = s1828 ^ s1829; - const SWord8 s1831 = s1827 ^ s1830; - const SWord8 s1832 = s1826 ^ s1831; - const SWord8 s1833 = table7[s1807]; - const SWord8 s1834 = table8[s1809]; - const SWord8 s1835 = table9[s1811]; - const SWord8 s1836 = table6[s1813]; - const SWord8 s1837 = s1835 ^ s1836; - const SWord8 s1838 = s1834 ^ s1837; - const SWord8 s1839 = s1833 ^ s1838; - const SWord16 s1840 = (((SWord16) s1832) << 8) | ((SWord16) s1839); - const SWord32 s1841 = (((SWord32) s1825) << 16) | ((SWord32) s1840); - const SWord32 s1842 = s1806 ^ s1841; - const SWord8 s1843 = (SWord8) s1842; - const SWord32 s1844 = table5[s1843]; - const SWord32 s1845 = s1795 ^ s1844; - const SWord8 s1846 = (SWord8) (s635 >> 24); - const SWord8 s1847 = table6[s1846]; - const SWord8 s1848 = (SWord8) (s635 >> 16); - const SWord8 s1849 = table7[s1848]; - const SWord8 s1850 = (SWord8) (s635 >> 8); - const SWord8 s1851 = table8[s1850]; - const SWord8 s1852 = (SWord8) s635; - const SWord8 s1853 = table9[s1852]; - const SWord8 s1854 = s1851 ^ s1853; - const SWord8 s1855 = s1849 ^ s1854; - const SWord8 s1856 = s1847 ^ s1855; - const SWord8 s1857 = table9[s1846]; - const SWord8 s1858 = table6[s1848]; - const SWord8 s1859 = table7[s1850]; - const SWord8 s1860 = table8[s1852]; - const SWord8 s1861 = s1859 ^ s1860; - const SWord8 s1862 = s1858 ^ s1861; - const SWord8 s1863 = s1857 ^ s1862; - const SWord16 s1864 = (((SWord16) s1856) << 8) | ((SWord16) s1863); - const SWord8 s1865 = table8[s1846]; - const SWord8 s1866 = table9[s1848]; - const SWord8 s1867 = table6[s1850]; - const SWord8 s1868 = table7[s1852]; - const SWord8 s1869 = s1867 ^ s1868; - const SWord8 s1870 = s1866 ^ s1869; - const SWord8 s1871 = s1865 ^ s1870; - const SWord8 s1872 = table7[s1846]; - const SWord8 s1873 = table8[s1848]; - const SWord8 s1874 = table9[s1850]; - const SWord8 s1875 = table6[s1852]; - const SWord8 s1876 = s1874 ^ s1875; - const SWord8 s1877 = s1873 ^ s1876; - const SWord8 s1878 = s1872 ^ s1877; - const SWord16 s1879 = (((SWord16) s1871) << 8) | ((SWord16) s1878); - const SWord32 s1880 = (((SWord32) s1864) << 16) | ((SWord32) s1879); - const SWord32 s1881 = s1845 ^ s1880; - const SWord8 s1882 = (SWord8) (s1881 >> 24); - const SWord32 s1883 = table1[s1882]; - const SWord8 s1884 = (SWord8) (s1742 >> 24); - const SWord32 s1885 = table1[s1884]; - const SWord8 s1886 = (SWord8) (s1792 >> 16); - const SWord32 s1887 = table3[s1886]; - const SWord32 s1888 = s1885 ^ s1887; - const SWord8 s1889 = (SWord8) (s1842 >> 8); - const SWord32 s1890 = table4[s1889]; - const SWord32 s1891 = s1888 ^ s1890; - const SWord8 s1892 = (SWord8) s1693; - const SWord32 s1893 = table5[s1892]; - const SWord32 s1894 = s1891 ^ s1893; - const SWord8 s1895 = (SWord8) (s638 >> 24); - const SWord8 s1896 = table6[s1895]; - const SWord8 s1897 = (SWord8) (s638 >> 16); - const SWord8 s1898 = table7[s1897]; - const SWord8 s1899 = (SWord8) (s638 >> 8); - const SWord8 s1900 = table8[s1899]; - const SWord8 s1901 = (SWord8) s638; - const SWord8 s1902 = table9[s1901]; - const SWord8 s1903 = s1900 ^ s1902; - const SWord8 s1904 = s1898 ^ s1903; - const SWord8 s1905 = s1896 ^ s1904; - const SWord8 s1906 = table9[s1895]; - const SWord8 s1907 = table6[s1897]; - const SWord8 s1908 = table7[s1899]; - const SWord8 s1909 = table8[s1901]; - const SWord8 s1910 = s1908 ^ s1909; - const SWord8 s1911 = s1907 ^ s1910; - const SWord8 s1912 = s1906 ^ s1911; - const SWord16 s1913 = (((SWord16) s1905) << 8) | ((SWord16) s1912); - const SWord8 s1914 = table8[s1895]; - const SWord8 s1915 = table9[s1897]; - const SWord8 s1916 = table6[s1899]; - const SWord8 s1917 = table7[s1901]; - const SWord8 s1918 = s1916 ^ s1917; - const SWord8 s1919 = s1915 ^ s1918; - const SWord8 s1920 = s1914 ^ s1919; - const SWord8 s1921 = table7[s1895]; - const SWord8 s1922 = table8[s1897]; - const SWord8 s1923 = table9[s1899]; - const SWord8 s1924 = table6[s1901]; - const SWord8 s1925 = s1923 ^ s1924; - const SWord8 s1926 = s1922 ^ s1925; - const SWord8 s1927 = s1921 ^ s1926; - const SWord16 s1928 = (((SWord16) s1920) << 8) | ((SWord16) s1927); - const SWord32 s1929 = (((SWord32) s1913) << 16) | ((SWord32) s1928); - const SWord32 s1930 = s1894 ^ s1929; - const SWord8 s1931 = (SWord8) (s1930 >> 16); - const SWord32 s1932 = table3[s1931]; - const SWord32 s1933 = s1883 ^ s1932; - const SWord8 s1934 = (SWord8) (s1792 >> 24); - const SWord32 s1935 = table1[s1934]; - const SWord8 s1936 = (SWord8) (s1842 >> 16); - const SWord32 s1937 = table3[s1936]; - const SWord32 s1938 = s1935 ^ s1937; - const SWord8 s1939 = (SWord8) (s1693 >> 8); - const SWord32 s1940 = table4[s1939]; - const SWord32 s1941 = s1938 ^ s1940; - const SWord8 s1942 = (SWord8) s1742; - const SWord32 s1943 = table5[s1942]; - const SWord32 s1944 = s1941 ^ s1943; - const SWord8 s1945 = (SWord8) (s637 >> 24); - const SWord8 s1946 = table6[s1945]; - const SWord8 s1947 = (SWord8) (s637 >> 16); - const SWord8 s1948 = table7[s1947]; - const SWord8 s1949 = (SWord8) (s637 >> 8); - const SWord8 s1950 = table8[s1949]; - const SWord8 s1951 = (SWord8) s637; - const SWord8 s1952 = table9[s1951]; - const SWord8 s1953 = s1950 ^ s1952; - const SWord8 s1954 = s1948 ^ s1953; - const SWord8 s1955 = s1946 ^ s1954; - const SWord8 s1956 = table9[s1945]; - const SWord8 s1957 = table6[s1947]; - const SWord8 s1958 = table7[s1949]; - const SWord8 s1959 = table8[s1951]; - const SWord8 s1960 = s1958 ^ s1959; - const SWord8 s1961 = s1957 ^ s1960; - const SWord8 s1962 = s1956 ^ s1961; - const SWord16 s1963 = (((SWord16) s1955) << 8) | ((SWord16) s1962); - const SWord8 s1964 = table8[s1945]; - const SWord8 s1965 = table9[s1947]; - const SWord8 s1966 = table6[s1949]; - const SWord8 s1967 = table7[s1951]; - const SWord8 s1968 = s1966 ^ s1967; - const SWord8 s1969 = s1965 ^ s1968; - const SWord8 s1970 = s1964 ^ s1969; - const SWord8 s1971 = table7[s1945]; - const SWord8 s1972 = table8[s1947]; - const SWord8 s1973 = table9[s1949]; - const SWord8 s1974 = table6[s1951]; - const SWord8 s1975 = s1973 ^ s1974; - const SWord8 s1976 = s1972 ^ s1975; - const SWord8 s1977 = s1971 ^ s1976; - const SWord16 s1978 = (((SWord16) s1970) << 8) | ((SWord16) s1977); - const SWord32 s1979 = (((SWord32) s1963) << 16) | ((SWord32) s1978); - const SWord32 s1980 = s1944 ^ s1979; - const SWord8 s1981 = (SWord8) (s1980 >> 8); - const SWord32 s1982 = table4[s1981]; - const SWord32 s1983 = s1933 ^ s1982; - const SWord8 s1984 = (SWord8) (s1842 >> 24); - const SWord32 s1985 = table1[s1984]; - const SWord8 s1986 = (SWord8) (s1693 >> 16); - const SWord32 s1987 = table3[s1986]; - const SWord32 s1988 = s1985 ^ s1987; - const SWord8 s1989 = (SWord8) (s1742 >> 8); - const SWord32 s1990 = table4[s1989]; - const SWord32 s1991 = s1988 ^ s1990; - const SWord8 s1992 = (SWord8) s1792; - const SWord32 s1993 = table5[s1992]; - const SWord32 s1994 = s1991 ^ s1993; - const SWord8 s1995 = (SWord8) (s636 >> 24); - const SWord8 s1996 = table6[s1995]; - const SWord8 s1997 = (SWord8) (s636 >> 16); - const SWord8 s1998 = table7[s1997]; - const SWord8 s1999 = (SWord8) (s636 >> 8); - const SWord8 s2000 = table8[s1999]; - const SWord8 s2001 = (SWord8) s636; - const SWord8 s2002 = table9[s2001]; - const SWord8 s2003 = s2000 ^ s2002; - const SWord8 s2004 = s1998 ^ s2003; - const SWord8 s2005 = s1996 ^ s2004; - const SWord8 s2006 = table9[s1995]; - const SWord8 s2007 = table6[s1997]; - const SWord8 s2008 = table7[s1999]; - const SWord8 s2009 = table8[s2001]; - const SWord8 s2010 = s2008 ^ s2009; - const SWord8 s2011 = s2007 ^ s2010; - const SWord8 s2012 = s2006 ^ s2011; - const SWord16 s2013 = (((SWord16) s2005) << 8) | ((SWord16) s2012); - const SWord8 s2014 = table8[s1995]; - const SWord8 s2015 = table9[s1997]; - const SWord8 s2016 = table6[s1999]; - const SWord8 s2017 = table7[s2001]; - const SWord8 s2018 = s2016 ^ s2017; - const SWord8 s2019 = s2015 ^ s2018; - const SWord8 s2020 = s2014 ^ s2019; - const SWord8 s2021 = table7[s1995]; - const SWord8 s2022 = table8[s1997]; - const SWord8 s2023 = table9[s1999]; - const SWord8 s2024 = table6[s2001]; - const SWord8 s2025 = s2023 ^ s2024; - const SWord8 s2026 = s2022 ^ s2025; - const SWord8 s2027 = s2021 ^ s2026; - const SWord16 s2028 = (((SWord16) s2020) << 8) | ((SWord16) s2027); - const SWord32 s2029 = (((SWord32) s2013) << 16) | ((SWord32) s2028); - const SWord32 s2030 = s1994 ^ s2029; - const SWord8 s2031 = (SWord8) s2030; - const SWord32 s2032 = table5[s2031]; - const SWord32 s2033 = s1983 ^ s2032; - const SWord8 s2034 = (SWord8) (s618 >> 24); - const SWord8 s2035 = table6[s2034]; - const SWord8 s2036 = (SWord8) (s618 >> 16); - const SWord8 s2037 = table7[s2036]; - const SWord8 s2038 = (SWord8) (s618 >> 8); - const SWord8 s2039 = table8[s2038]; - const SWord8 s2040 = (SWord8) s618; - const SWord8 s2041 = table9[s2040]; - const SWord8 s2042 = s2039 ^ s2041; - const SWord8 s2043 = s2037 ^ s2042; - const SWord8 s2044 = s2035 ^ s2043; - const SWord8 s2045 = table9[s2034]; - const SWord8 s2046 = table6[s2036]; - const SWord8 s2047 = table7[s2038]; - const SWord8 s2048 = table8[s2040]; - const SWord8 s2049 = s2047 ^ s2048; - const SWord8 s2050 = s2046 ^ s2049; - const SWord8 s2051 = s2045 ^ s2050; - const SWord16 s2052 = (((SWord16) s2044) << 8) | ((SWord16) s2051); - const SWord8 s2053 = table8[s2034]; - const SWord8 s2054 = table9[s2036]; - const SWord8 s2055 = table6[s2038]; - const SWord8 s2056 = table7[s2040]; - const SWord8 s2057 = s2055 ^ s2056; - const SWord8 s2058 = s2054 ^ s2057; - const SWord8 s2059 = s2053 ^ s2058; - const SWord8 s2060 = table7[s2034]; - const SWord8 s2061 = table8[s2036]; - const SWord8 s2062 = table9[s2038]; - const SWord8 s2063 = table6[s2040]; - const SWord8 s2064 = s2062 ^ s2063; - const SWord8 s2065 = s2061 ^ s2064; - const SWord8 s2066 = s2060 ^ s2065; - const SWord16 s2067 = (((SWord16) s2059) << 8) | ((SWord16) s2066); - const SWord32 s2068 = (((SWord32) s2052) << 16) | ((SWord32) s2067); - const SWord32 s2069 = s2033 ^ s2068; - const SWord8 s2070 = (SWord8) (s2069 >> 24); - const SWord32 s2071 = table1[s2070]; - const SWord8 s2072 = (SWord8) (s1930 >> 24); - const SWord32 s2073 = table1[s2072]; - const SWord8 s2074 = (SWord8) (s1980 >> 16); - const SWord32 s2075 = table3[s2074]; - const SWord32 s2076 = s2073 ^ s2075; - const SWord8 s2077 = (SWord8) (s2030 >> 8); - const SWord32 s2078 = table4[s2077]; - const SWord32 s2079 = s2076 ^ s2078; - const SWord8 s2080 = (SWord8) s1881; - const SWord32 s2081 = table5[s2080]; - const SWord32 s2082 = s2079 ^ s2081; - const SWord8 s2083 = (SWord8) (s621 >> 24); - const SWord8 s2084 = table6[s2083]; - const SWord8 s2085 = (SWord8) (s621 >> 16); - const SWord8 s2086 = table7[s2085]; - const SWord8 s2087 = (SWord8) (s621 >> 8); - const SWord8 s2088 = table8[s2087]; - const SWord8 s2089 = (SWord8) s621; - const SWord8 s2090 = table9[s2089]; - const SWord8 s2091 = s2088 ^ s2090; - const SWord8 s2092 = s2086 ^ s2091; - const SWord8 s2093 = s2084 ^ s2092; - const SWord8 s2094 = table9[s2083]; - const SWord8 s2095 = table6[s2085]; - const SWord8 s2096 = table7[s2087]; - const SWord8 s2097 = table8[s2089]; - const SWord8 s2098 = s2096 ^ s2097; - const SWord8 s2099 = s2095 ^ s2098; - const SWord8 s2100 = s2094 ^ s2099; - const SWord16 s2101 = (((SWord16) s2093) << 8) | ((SWord16) s2100); - const SWord8 s2102 = table8[s2083]; - const SWord8 s2103 = table9[s2085]; - const SWord8 s2104 = table6[s2087]; - const SWord8 s2105 = table7[s2089]; - const SWord8 s2106 = s2104 ^ s2105; - const SWord8 s2107 = s2103 ^ s2106; - const SWord8 s2108 = s2102 ^ s2107; - const SWord8 s2109 = table7[s2083]; - const SWord8 s2110 = table8[s2085]; - const SWord8 s2111 = table9[s2087]; - const SWord8 s2112 = table6[s2089]; - const SWord8 s2113 = s2111 ^ s2112; - const SWord8 s2114 = s2110 ^ s2113; - const SWord8 s2115 = s2109 ^ s2114; - const SWord16 s2116 = (((SWord16) s2108) << 8) | ((SWord16) s2115); - const SWord32 s2117 = (((SWord32) s2101) << 16) | ((SWord32) s2116); - const SWord32 s2118 = s2082 ^ s2117; - const SWord8 s2119 = (SWord8) (s2118 >> 16); - const SWord32 s2120 = table3[s2119]; - const SWord32 s2121 = s2071 ^ s2120; - const SWord8 s2122 = (SWord8) (s1980 >> 24); - const SWord32 s2123 = table1[s2122]; - const SWord8 s2124 = (SWord8) (s2030 >> 16); - const SWord32 s2125 = table3[s2124]; - const SWord32 s2126 = s2123 ^ s2125; - const SWord8 s2127 = (SWord8) (s1881 >> 8); - const SWord32 s2128 = table4[s2127]; - const SWord32 s2129 = s2126 ^ s2128; - const SWord8 s2130 = (SWord8) s1930; - const SWord32 s2131 = table5[s2130]; - const SWord32 s2132 = s2129 ^ s2131; - const SWord8 s2133 = (SWord8) (s620 >> 24); - const SWord8 s2134 = table6[s2133]; - const SWord8 s2135 = (SWord8) (s620 >> 16); - const SWord8 s2136 = table7[s2135]; - const SWord8 s2137 = (SWord8) (s620 >> 8); - const SWord8 s2138 = table8[s2137]; - const SWord8 s2139 = (SWord8) s620; - const SWord8 s2140 = table9[s2139]; - const SWord8 s2141 = s2138 ^ s2140; - const SWord8 s2142 = s2136 ^ s2141; - const SWord8 s2143 = s2134 ^ s2142; - const SWord8 s2144 = table9[s2133]; - const SWord8 s2145 = table6[s2135]; - const SWord8 s2146 = table7[s2137]; - const SWord8 s2147 = table8[s2139]; - const SWord8 s2148 = s2146 ^ s2147; - const SWord8 s2149 = s2145 ^ s2148; - const SWord8 s2150 = s2144 ^ s2149; - const SWord16 s2151 = (((SWord16) s2143) << 8) | ((SWord16) s2150); - const SWord8 s2152 = table8[s2133]; - const SWord8 s2153 = table9[s2135]; - const SWord8 s2154 = table6[s2137]; - const SWord8 s2155 = table7[s2139]; - const SWord8 s2156 = s2154 ^ s2155; - const SWord8 s2157 = s2153 ^ s2156; - const SWord8 s2158 = s2152 ^ s2157; - const SWord8 s2159 = table7[s2133]; - const SWord8 s2160 = table8[s2135]; - const SWord8 s2161 = table9[s2137]; - const SWord8 s2162 = table6[s2139]; - const SWord8 s2163 = s2161 ^ s2162; - const SWord8 s2164 = s2160 ^ s2163; - const SWord8 s2165 = s2159 ^ s2164; - const SWord16 s2166 = (((SWord16) s2158) << 8) | ((SWord16) s2165); - const SWord32 s2167 = (((SWord32) s2151) << 16) | ((SWord32) s2166); - const SWord32 s2168 = s2132 ^ s2167; - const SWord8 s2169 = (SWord8) (s2168 >> 8); - const SWord32 s2170 = table4[s2169]; - const SWord32 s2171 = s2121 ^ s2170; - const SWord8 s2172 = (SWord8) (s2030 >> 24); - const SWord32 s2173 = table1[s2172]; - const SWord8 s2174 = (SWord8) (s1881 >> 16); - const SWord32 s2175 = table3[s2174]; - const SWord32 s2176 = s2173 ^ s2175; - const SWord8 s2177 = (SWord8) (s1930 >> 8); - const SWord32 s2178 = table4[s2177]; - const SWord32 s2179 = s2176 ^ s2178; - const SWord8 s2180 = (SWord8) s1980; - const SWord32 s2181 = table5[s2180]; - const SWord32 s2182 = s2179 ^ s2181; - const SWord8 s2183 = (SWord8) (s619 >> 24); - const SWord8 s2184 = table6[s2183]; - const SWord8 s2185 = (SWord8) (s619 >> 16); - const SWord8 s2186 = table7[s2185]; - const SWord8 s2187 = (SWord8) (s619 >> 8); - const SWord8 s2188 = table8[s2187]; - const SWord8 s2189 = (SWord8) s619; - const SWord8 s2190 = table9[s2189]; - const SWord8 s2191 = s2188 ^ s2190; - const SWord8 s2192 = s2186 ^ s2191; - const SWord8 s2193 = s2184 ^ s2192; - const SWord8 s2194 = table9[s2183]; - const SWord8 s2195 = table6[s2185]; - const SWord8 s2196 = table7[s2187]; - const SWord8 s2197 = table8[s2189]; - const SWord8 s2198 = s2196 ^ s2197; - const SWord8 s2199 = s2195 ^ s2198; - const SWord8 s2200 = s2194 ^ s2199; - const SWord16 s2201 = (((SWord16) s2193) << 8) | ((SWord16) s2200); - const SWord8 s2202 = table8[s2183]; - const SWord8 s2203 = table9[s2185]; - const SWord8 s2204 = table6[s2187]; - const SWord8 s2205 = table7[s2189]; - const SWord8 s2206 = s2204 ^ s2205; - const SWord8 s2207 = s2203 ^ s2206; - const SWord8 s2208 = s2202 ^ s2207; - const SWord8 s2209 = table7[s2183]; - const SWord8 s2210 = table8[s2185]; - const SWord8 s2211 = table9[s2187]; - const SWord8 s2212 = table6[s2189]; - const SWord8 s2213 = s2211 ^ s2212; - const SWord8 s2214 = s2210 ^ s2213; - const SWord8 s2215 = s2209 ^ s2214; - const SWord16 s2216 = (((SWord16) s2208) << 8) | ((SWord16) s2215); - const SWord32 s2217 = (((SWord32) s2201) << 16) | ((SWord32) s2216); - const SWord32 s2218 = s2182 ^ s2217; - const SWord8 s2219 = (SWord8) s2218; - const SWord32 s2220 = table5[s2219]; - const SWord32 s2221 = s2171 ^ s2220; - const SWord8 s2222 = (SWord8) (s601 >> 24); - const SWord8 s2223 = table6[s2222]; - const SWord8 s2224 = (SWord8) (s601 >> 16); - const SWord8 s2225 = table7[s2224]; - const SWord8 s2226 = (SWord8) (s601 >> 8); - const SWord8 s2227 = table8[s2226]; - const SWord8 s2228 = (SWord8) s601; - const SWord8 s2229 = table9[s2228]; - const SWord8 s2230 = s2227 ^ s2229; - const SWord8 s2231 = s2225 ^ s2230; - const SWord8 s2232 = s2223 ^ s2231; - const SWord8 s2233 = table9[s2222]; - const SWord8 s2234 = table6[s2224]; - const SWord8 s2235 = table7[s2226]; - const SWord8 s2236 = table8[s2228]; - const SWord8 s2237 = s2235 ^ s2236; - const SWord8 s2238 = s2234 ^ s2237; - const SWord8 s2239 = s2233 ^ s2238; - const SWord16 s2240 = (((SWord16) s2232) << 8) | ((SWord16) s2239); - const SWord8 s2241 = table8[s2222]; - const SWord8 s2242 = table9[s2224]; - const SWord8 s2243 = table6[s2226]; - const SWord8 s2244 = table7[s2228]; - const SWord8 s2245 = s2243 ^ s2244; - const SWord8 s2246 = s2242 ^ s2245; - const SWord8 s2247 = s2241 ^ s2246; - const SWord8 s2248 = table7[s2222]; - const SWord8 s2249 = table8[s2224]; - const SWord8 s2250 = table9[s2226]; - const SWord8 s2251 = table6[s2228]; - const SWord8 s2252 = s2250 ^ s2251; - const SWord8 s2253 = s2249 ^ s2252; - const SWord8 s2254 = s2248 ^ s2253; - const SWord16 s2255 = (((SWord16) s2247) << 8) | ((SWord16) s2254); - const SWord32 s2256 = (((SWord32) s2240) << 16) | ((SWord32) s2255); - const SWord32 s2257 = s2221 ^ s2256; - const SWord8 s2258 = (SWord8) (s2257 >> 24); - const SWord32 s2259 = table1[s2258]; - const SWord8 s2260 = (SWord8) (s2118 >> 24); - const SWord32 s2261 = table1[s2260]; - const SWord8 s2262 = (SWord8) (s2168 >> 16); - const SWord32 s2263 = table3[s2262]; - const SWord32 s2264 = s2261 ^ s2263; - const SWord8 s2265 = (SWord8) (s2218 >> 8); - const SWord32 s2266 = table4[s2265]; - const SWord32 s2267 = s2264 ^ s2266; - const SWord8 s2268 = (SWord8) s2069; - const SWord32 s2269 = table5[s2268]; - const SWord32 s2270 = s2267 ^ s2269; - const SWord8 s2271 = (SWord8) (s604 >> 24); - const SWord8 s2272 = table6[s2271]; - const SWord8 s2273 = (SWord8) (s604 >> 16); - const SWord8 s2274 = table7[s2273]; - const SWord8 s2275 = (SWord8) (s604 >> 8); - const SWord8 s2276 = table8[s2275]; - const SWord8 s2277 = (SWord8) s604; - const SWord8 s2278 = table9[s2277]; - const SWord8 s2279 = s2276 ^ s2278; - const SWord8 s2280 = s2274 ^ s2279; - const SWord8 s2281 = s2272 ^ s2280; - const SWord8 s2282 = table9[s2271]; - const SWord8 s2283 = table6[s2273]; - const SWord8 s2284 = table7[s2275]; - const SWord8 s2285 = table8[s2277]; - const SWord8 s2286 = s2284 ^ s2285; - const SWord8 s2287 = s2283 ^ s2286; - const SWord8 s2288 = s2282 ^ s2287; - const SWord16 s2289 = (((SWord16) s2281) << 8) | ((SWord16) s2288); - const SWord8 s2290 = table8[s2271]; - const SWord8 s2291 = table9[s2273]; - const SWord8 s2292 = table6[s2275]; - const SWord8 s2293 = table7[s2277]; - const SWord8 s2294 = s2292 ^ s2293; - const SWord8 s2295 = s2291 ^ s2294; - const SWord8 s2296 = s2290 ^ s2295; - const SWord8 s2297 = table7[s2271]; - const SWord8 s2298 = table8[s2273]; - const SWord8 s2299 = table9[s2275]; - const SWord8 s2300 = table6[s2277]; - const SWord8 s2301 = s2299 ^ s2300; - const SWord8 s2302 = s2298 ^ s2301; - const SWord8 s2303 = s2297 ^ s2302; - const SWord16 s2304 = (((SWord16) s2296) << 8) | ((SWord16) s2303); - const SWord32 s2305 = (((SWord32) s2289) << 16) | ((SWord32) s2304); - const SWord32 s2306 = s2270 ^ s2305; - const SWord8 s2307 = (SWord8) (s2306 >> 16); - const SWord32 s2308 = table3[s2307]; - const SWord32 s2309 = s2259 ^ s2308; - const SWord8 s2310 = (SWord8) (s2168 >> 24); - const SWord32 s2311 = table1[s2310]; - const SWord8 s2312 = (SWord8) (s2218 >> 16); - const SWord32 s2313 = table3[s2312]; - const SWord32 s2314 = s2311 ^ s2313; - const SWord8 s2315 = (SWord8) (s2069 >> 8); - const SWord32 s2316 = table4[s2315]; - const SWord32 s2317 = s2314 ^ s2316; - const SWord8 s2318 = (SWord8) s2118; - const SWord32 s2319 = table5[s2318]; - const SWord32 s2320 = s2317 ^ s2319; - const SWord8 s2321 = (SWord8) (s603 >> 24); - const SWord8 s2322 = table6[s2321]; - const SWord8 s2323 = (SWord8) (s603 >> 16); - const SWord8 s2324 = table7[s2323]; - const SWord8 s2325 = (SWord8) (s603 >> 8); - const SWord8 s2326 = table8[s2325]; - const SWord8 s2327 = (SWord8) s603; - const SWord8 s2328 = table9[s2327]; - const SWord8 s2329 = s2326 ^ s2328; - const SWord8 s2330 = s2324 ^ s2329; - const SWord8 s2331 = s2322 ^ s2330; - const SWord8 s2332 = table9[s2321]; - const SWord8 s2333 = table6[s2323]; - const SWord8 s2334 = table7[s2325]; - const SWord8 s2335 = table8[s2327]; - const SWord8 s2336 = s2334 ^ s2335; - const SWord8 s2337 = s2333 ^ s2336; - const SWord8 s2338 = s2332 ^ s2337; - const SWord16 s2339 = (((SWord16) s2331) << 8) | ((SWord16) s2338); - const SWord8 s2340 = table8[s2321]; - const SWord8 s2341 = table9[s2323]; - const SWord8 s2342 = table6[s2325]; - const SWord8 s2343 = table7[s2327]; - const SWord8 s2344 = s2342 ^ s2343; - const SWord8 s2345 = s2341 ^ s2344; - const SWord8 s2346 = s2340 ^ s2345; - const SWord8 s2347 = table7[s2321]; - const SWord8 s2348 = table8[s2323]; - const SWord8 s2349 = table9[s2325]; - const SWord8 s2350 = table6[s2327]; - const SWord8 s2351 = s2349 ^ s2350; - const SWord8 s2352 = s2348 ^ s2351; - const SWord8 s2353 = s2347 ^ s2352; - const SWord16 s2354 = (((SWord16) s2346) << 8) | ((SWord16) s2353); - const SWord32 s2355 = (((SWord32) s2339) << 16) | ((SWord32) s2354); - const SWord32 s2356 = s2320 ^ s2355; - const SWord8 s2357 = (SWord8) (s2356 >> 8); - const SWord32 s2358 = table4[s2357]; - const SWord32 s2359 = s2309 ^ s2358; - const SWord8 s2360 = (SWord8) (s2218 >> 24); - const SWord32 s2361 = table1[s2360]; - const SWord8 s2362 = (SWord8) (s2069 >> 16); - const SWord32 s2363 = table3[s2362]; - const SWord32 s2364 = s2361 ^ s2363; - const SWord8 s2365 = (SWord8) (s2118 >> 8); - const SWord32 s2366 = table4[s2365]; - const SWord32 s2367 = s2364 ^ s2366; - const SWord8 s2368 = (SWord8) s2168; - const SWord32 s2369 = table5[s2368]; - const SWord32 s2370 = s2367 ^ s2369; - const SWord8 s2371 = (SWord8) (s602 >> 24); - const SWord8 s2372 = table6[s2371]; - const SWord8 s2373 = (SWord8) (s602 >> 16); - const SWord8 s2374 = table7[s2373]; - const SWord8 s2375 = (SWord8) (s602 >> 8); - const SWord8 s2376 = table8[s2375]; - const SWord8 s2377 = (SWord8) s602; - const SWord8 s2378 = table9[s2377]; - const SWord8 s2379 = s2376 ^ s2378; - const SWord8 s2380 = s2374 ^ s2379; - const SWord8 s2381 = s2372 ^ s2380; - const SWord8 s2382 = table9[s2371]; - const SWord8 s2383 = table6[s2373]; - const SWord8 s2384 = table7[s2375]; - const SWord8 s2385 = table8[s2377]; - const SWord8 s2386 = s2384 ^ s2385; - const SWord8 s2387 = s2383 ^ s2386; - const SWord8 s2388 = s2382 ^ s2387; - const SWord16 s2389 = (((SWord16) s2381) << 8) | ((SWord16) s2388); - const SWord8 s2390 = table8[s2371]; - const SWord8 s2391 = table9[s2373]; - const SWord8 s2392 = table6[s2375]; - const SWord8 s2393 = table7[s2377]; - const SWord8 s2394 = s2392 ^ s2393; - const SWord8 s2395 = s2391 ^ s2394; - const SWord8 s2396 = s2390 ^ s2395; - const SWord8 s2397 = table7[s2371]; - const SWord8 s2398 = table8[s2373]; - const SWord8 s2399 = table9[s2375]; - const SWord8 s2400 = table6[s2377]; - const SWord8 s2401 = s2399 ^ s2400; - const SWord8 s2402 = s2398 ^ s2401; - const SWord8 s2403 = s2397 ^ s2402; - const SWord16 s2404 = (((SWord16) s2396) << 8) | ((SWord16) s2403); - const SWord32 s2405 = (((SWord32) s2389) << 16) | ((SWord32) s2404); - const SWord32 s2406 = s2370 ^ s2405; - const SWord8 s2407 = (SWord8) s2406; - const SWord32 s2408 = table5[s2407]; - const SWord32 s2409 = s2359 ^ s2408; - const SWord8 s2410 = (SWord8) (s584 >> 24); - const SWord8 s2411 = table6[s2410]; - const SWord8 s2412 = (SWord8) (s584 >> 16); - const SWord8 s2413 = table7[s2412]; - const SWord8 s2414 = (SWord8) (s584 >> 8); - const SWord8 s2415 = table8[s2414]; - const SWord8 s2416 = (SWord8) s584; - const SWord8 s2417 = table9[s2416]; - const SWord8 s2418 = s2415 ^ s2417; - const SWord8 s2419 = s2413 ^ s2418; - const SWord8 s2420 = s2411 ^ s2419; - const SWord8 s2421 = table9[s2410]; - const SWord8 s2422 = table6[s2412]; - const SWord8 s2423 = table7[s2414]; - const SWord8 s2424 = table8[s2416]; - const SWord8 s2425 = s2423 ^ s2424; - const SWord8 s2426 = s2422 ^ s2425; - const SWord8 s2427 = s2421 ^ s2426; - const SWord16 s2428 = (((SWord16) s2420) << 8) | ((SWord16) s2427); - const SWord8 s2429 = table8[s2410]; - const SWord8 s2430 = table9[s2412]; - const SWord8 s2431 = table6[s2414]; - const SWord8 s2432 = table7[s2416]; - const SWord8 s2433 = s2431 ^ s2432; - const SWord8 s2434 = s2430 ^ s2433; - const SWord8 s2435 = s2429 ^ s2434; - const SWord8 s2436 = table7[s2410]; - const SWord8 s2437 = table8[s2412]; - const SWord8 s2438 = table9[s2414]; - const SWord8 s2439 = table6[s2416]; - const SWord8 s2440 = s2438 ^ s2439; - const SWord8 s2441 = s2437 ^ s2440; - const SWord8 s2442 = s2436 ^ s2441; - const SWord16 s2443 = (((SWord16) s2435) << 8) | ((SWord16) s2442); - const SWord32 s2444 = (((SWord32) s2428) << 16) | ((SWord32) s2443); - const SWord32 s2445 = s2409 ^ s2444; - const SWord8 s2446 = (SWord8) (s2445 >> 24); - const SWord32 s2447 = table1[s2446]; - const SWord8 s2448 = (SWord8) (s2306 >> 24); - const SWord32 s2449 = table1[s2448]; - const SWord8 s2450 = (SWord8) (s2356 >> 16); - const SWord32 s2451 = table3[s2450]; - const SWord32 s2452 = s2449 ^ s2451; - const SWord8 s2453 = (SWord8) (s2406 >> 8); - const SWord32 s2454 = table4[s2453]; - const SWord32 s2455 = s2452 ^ s2454; - const SWord8 s2456 = (SWord8) s2257; - const SWord32 s2457 = table5[s2456]; - const SWord32 s2458 = s2455 ^ s2457; - const SWord8 s2459 = (SWord8) (s587 >> 24); - const SWord8 s2460 = table6[s2459]; - const SWord8 s2461 = (SWord8) (s587 >> 16); - const SWord8 s2462 = table7[s2461]; - const SWord8 s2463 = (SWord8) (s587 >> 8); - const SWord8 s2464 = table8[s2463]; - const SWord8 s2465 = (SWord8) s587; - const SWord8 s2466 = table9[s2465]; - const SWord8 s2467 = s2464 ^ s2466; - const SWord8 s2468 = s2462 ^ s2467; - const SWord8 s2469 = s2460 ^ s2468; - const SWord8 s2470 = table9[s2459]; - const SWord8 s2471 = table6[s2461]; - const SWord8 s2472 = table7[s2463]; - const SWord8 s2473 = table8[s2465]; - const SWord8 s2474 = s2472 ^ s2473; - const SWord8 s2475 = s2471 ^ s2474; - const SWord8 s2476 = s2470 ^ s2475; - const SWord16 s2477 = (((SWord16) s2469) << 8) | ((SWord16) s2476); - const SWord8 s2478 = table8[s2459]; - const SWord8 s2479 = table9[s2461]; - const SWord8 s2480 = table6[s2463]; - const SWord8 s2481 = table7[s2465]; - const SWord8 s2482 = s2480 ^ s2481; - const SWord8 s2483 = s2479 ^ s2482; - const SWord8 s2484 = s2478 ^ s2483; - const SWord8 s2485 = table7[s2459]; - const SWord8 s2486 = table8[s2461]; - const SWord8 s2487 = table9[s2463]; - const SWord8 s2488 = table6[s2465]; - const SWord8 s2489 = s2487 ^ s2488; - const SWord8 s2490 = s2486 ^ s2489; - const SWord8 s2491 = s2485 ^ s2490; - const SWord16 s2492 = (((SWord16) s2484) << 8) | ((SWord16) s2491); - const SWord32 s2493 = (((SWord32) s2477) << 16) | ((SWord32) s2492); - const SWord32 s2494 = s2458 ^ s2493; - const SWord8 s2495 = (SWord8) (s2494 >> 16); - const SWord32 s2496 = table3[s2495]; - const SWord32 s2497 = s2447 ^ s2496; - const SWord8 s2498 = (SWord8) (s2356 >> 24); - const SWord32 s2499 = table1[s2498]; - const SWord8 s2500 = (SWord8) (s2406 >> 16); - const SWord32 s2501 = table3[s2500]; - const SWord32 s2502 = s2499 ^ s2501; - const SWord8 s2503 = (SWord8) (s2257 >> 8); - const SWord32 s2504 = table4[s2503]; - const SWord32 s2505 = s2502 ^ s2504; - const SWord8 s2506 = (SWord8) s2306; - const SWord32 s2507 = table5[s2506]; - const SWord32 s2508 = s2505 ^ s2507; - const SWord8 s2509 = (SWord8) (s586 >> 24); - const SWord8 s2510 = table6[s2509]; - const SWord8 s2511 = (SWord8) (s586 >> 16); - const SWord8 s2512 = table7[s2511]; - const SWord8 s2513 = (SWord8) (s586 >> 8); - const SWord8 s2514 = table8[s2513]; - const SWord8 s2515 = (SWord8) s586; - const SWord8 s2516 = table9[s2515]; - const SWord8 s2517 = s2514 ^ s2516; - const SWord8 s2518 = s2512 ^ s2517; - const SWord8 s2519 = s2510 ^ s2518; - const SWord8 s2520 = table9[s2509]; - const SWord8 s2521 = table6[s2511]; - const SWord8 s2522 = table7[s2513]; - const SWord8 s2523 = table8[s2515]; - const SWord8 s2524 = s2522 ^ s2523; - const SWord8 s2525 = s2521 ^ s2524; - const SWord8 s2526 = s2520 ^ s2525; - const SWord16 s2527 = (((SWord16) s2519) << 8) | ((SWord16) s2526); - const SWord8 s2528 = table8[s2509]; - const SWord8 s2529 = table9[s2511]; - const SWord8 s2530 = table6[s2513]; - const SWord8 s2531 = table7[s2515]; - const SWord8 s2532 = s2530 ^ s2531; - const SWord8 s2533 = s2529 ^ s2532; - const SWord8 s2534 = s2528 ^ s2533; - const SWord8 s2535 = table7[s2509]; - const SWord8 s2536 = table8[s2511]; - const SWord8 s2537 = table9[s2513]; - const SWord8 s2538 = table6[s2515]; - const SWord8 s2539 = s2537 ^ s2538; - const SWord8 s2540 = s2536 ^ s2539; - const SWord8 s2541 = s2535 ^ s2540; - const SWord16 s2542 = (((SWord16) s2534) << 8) | ((SWord16) s2541); - const SWord32 s2543 = (((SWord32) s2527) << 16) | ((SWord32) s2542); - const SWord32 s2544 = s2508 ^ s2543; - const SWord8 s2545 = (SWord8) (s2544 >> 8); - const SWord32 s2546 = table4[s2545]; - const SWord32 s2547 = s2497 ^ s2546; - const SWord8 s2548 = (SWord8) (s2406 >> 24); - const SWord32 s2549 = table1[s2548]; - const SWord8 s2550 = (SWord8) (s2257 >> 16); - const SWord32 s2551 = table3[s2550]; - const SWord32 s2552 = s2549 ^ s2551; - const SWord8 s2553 = (SWord8) (s2306 >> 8); - const SWord32 s2554 = table4[s2553]; - const SWord32 s2555 = s2552 ^ s2554; - const SWord8 s2556 = (SWord8) s2356; - const SWord32 s2557 = table5[s2556]; - const SWord32 s2558 = s2555 ^ s2557; - const SWord8 s2559 = (SWord8) (s585 >> 24); - const SWord8 s2560 = table6[s2559]; - const SWord8 s2561 = (SWord8) (s585 >> 16); - const SWord8 s2562 = table7[s2561]; - const SWord8 s2563 = (SWord8) (s585 >> 8); - const SWord8 s2564 = table8[s2563]; - const SWord8 s2565 = (SWord8) s585; - const SWord8 s2566 = table9[s2565]; - const SWord8 s2567 = s2564 ^ s2566; - const SWord8 s2568 = s2562 ^ s2567; - const SWord8 s2569 = s2560 ^ s2568; - const SWord8 s2570 = table9[s2559]; - const SWord8 s2571 = table6[s2561]; - const SWord8 s2572 = table7[s2563]; - const SWord8 s2573 = table8[s2565]; - const SWord8 s2574 = s2572 ^ s2573; - const SWord8 s2575 = s2571 ^ s2574; - const SWord8 s2576 = s2570 ^ s2575; - const SWord16 s2577 = (((SWord16) s2569) << 8) | ((SWord16) s2576); - const SWord8 s2578 = table8[s2559]; - const SWord8 s2579 = table9[s2561]; - const SWord8 s2580 = table6[s2563]; - const SWord8 s2581 = table7[s2565]; - const SWord8 s2582 = s2580 ^ s2581; - const SWord8 s2583 = s2579 ^ s2582; - const SWord8 s2584 = s2578 ^ s2583; - const SWord8 s2585 = table7[s2559]; - const SWord8 s2586 = table8[s2561]; - const SWord8 s2587 = table9[s2563]; - const SWord8 s2588 = table6[s2565]; - const SWord8 s2589 = s2587 ^ s2588; - const SWord8 s2590 = s2586 ^ s2589; - const SWord8 s2591 = s2585 ^ s2590; - const SWord16 s2592 = (((SWord16) s2584) << 8) | ((SWord16) s2591); - const SWord32 s2593 = (((SWord32) s2577) << 16) | ((SWord32) s2592); - const SWord32 s2594 = s2558 ^ s2593; - const SWord8 s2595 = (SWord8) s2594; - const SWord32 s2596 = table5[s2595]; - const SWord32 s2597 = s2547 ^ s2596; - const SWord8 s2598 = (SWord8) (s567 >> 24); - const SWord8 s2599 = table6[s2598]; - const SWord8 s2600 = (SWord8) (s567 >> 16); - const SWord8 s2601 = table7[s2600]; - const SWord8 s2602 = (SWord8) (s567 >> 8); - const SWord8 s2603 = table8[s2602]; - const SWord8 s2604 = (SWord8) s567; - const SWord8 s2605 = table9[s2604]; - const SWord8 s2606 = s2603 ^ s2605; - const SWord8 s2607 = s2601 ^ s2606; - const SWord8 s2608 = s2599 ^ s2607; - const SWord8 s2609 = table9[s2598]; - const SWord8 s2610 = table6[s2600]; - const SWord8 s2611 = table7[s2602]; - const SWord8 s2612 = table8[s2604]; - const SWord8 s2613 = s2611 ^ s2612; - const SWord8 s2614 = s2610 ^ s2613; - const SWord8 s2615 = s2609 ^ s2614; - const SWord16 s2616 = (((SWord16) s2608) << 8) | ((SWord16) s2615); - const SWord8 s2617 = table8[s2598]; - const SWord8 s2618 = table9[s2600]; - const SWord8 s2619 = table6[s2602]; - const SWord8 s2620 = table7[s2604]; - const SWord8 s2621 = s2619 ^ s2620; - const SWord8 s2622 = s2618 ^ s2621; - const SWord8 s2623 = s2617 ^ s2622; - const SWord8 s2624 = table7[s2598]; - const SWord8 s2625 = table8[s2600]; - const SWord8 s2626 = table9[s2602]; - const SWord8 s2627 = table6[s2604]; - const SWord8 s2628 = s2626 ^ s2627; - const SWord8 s2629 = s2625 ^ s2628; - const SWord8 s2630 = s2624 ^ s2629; - const SWord16 s2631 = (((SWord16) s2623) << 8) | ((SWord16) s2630); - const SWord32 s2632 = (((SWord32) s2616) << 16) | ((SWord32) s2631); - const SWord32 s2633 = s2597 ^ s2632; - const SWord8 s2634 = (SWord8) (s2633 >> 24); - const SWord32 s2635 = table1[s2634]; - const SWord8 s2636 = (SWord8) (s2494 >> 24); - const SWord32 s2637 = table1[s2636]; - const SWord8 s2638 = (SWord8) (s2544 >> 16); - const SWord32 s2639 = table3[s2638]; - const SWord32 s2640 = s2637 ^ s2639; - const SWord8 s2641 = (SWord8) (s2594 >> 8); - const SWord32 s2642 = table4[s2641]; - const SWord32 s2643 = s2640 ^ s2642; - const SWord8 s2644 = (SWord8) s2445; - const SWord32 s2645 = table5[s2644]; - const SWord32 s2646 = s2643 ^ s2645; - const SWord8 s2647 = (SWord8) (s570 >> 24); - const SWord8 s2648 = table6[s2647]; - const SWord8 s2649 = (SWord8) (s570 >> 16); - const SWord8 s2650 = table7[s2649]; - const SWord8 s2651 = (SWord8) (s570 >> 8); - const SWord8 s2652 = table8[s2651]; - const SWord8 s2653 = (SWord8) s570; - const SWord8 s2654 = table9[s2653]; - const SWord8 s2655 = s2652 ^ s2654; - const SWord8 s2656 = s2650 ^ s2655; - const SWord8 s2657 = s2648 ^ s2656; - const SWord8 s2658 = table9[s2647]; - const SWord8 s2659 = table6[s2649]; - const SWord8 s2660 = table7[s2651]; - const SWord8 s2661 = table8[s2653]; - const SWord8 s2662 = s2660 ^ s2661; - const SWord8 s2663 = s2659 ^ s2662; - const SWord8 s2664 = s2658 ^ s2663; - const SWord16 s2665 = (((SWord16) s2657) << 8) | ((SWord16) s2664); - const SWord8 s2666 = table8[s2647]; - const SWord8 s2667 = table9[s2649]; - const SWord8 s2668 = table6[s2651]; - const SWord8 s2669 = table7[s2653]; - const SWord8 s2670 = s2668 ^ s2669; - const SWord8 s2671 = s2667 ^ s2670; - const SWord8 s2672 = s2666 ^ s2671; - const SWord8 s2673 = table7[s2647]; - const SWord8 s2674 = table8[s2649]; - const SWord8 s2675 = table9[s2651]; - const SWord8 s2676 = table6[s2653]; - const SWord8 s2677 = s2675 ^ s2676; - const SWord8 s2678 = s2674 ^ s2677; - const SWord8 s2679 = s2673 ^ s2678; - const SWord16 s2680 = (((SWord16) s2672) << 8) | ((SWord16) s2679); - const SWord32 s2681 = (((SWord32) s2665) << 16) | ((SWord32) s2680); - const SWord32 s2682 = s2646 ^ s2681; - const SWord8 s2683 = (SWord8) (s2682 >> 16); - const SWord32 s2684 = table3[s2683]; - const SWord32 s2685 = s2635 ^ s2684; - const SWord8 s2686 = (SWord8) (s2544 >> 24); - const SWord32 s2687 = table1[s2686]; - const SWord8 s2688 = (SWord8) (s2594 >> 16); - const SWord32 s2689 = table3[s2688]; - const SWord32 s2690 = s2687 ^ s2689; - const SWord8 s2691 = (SWord8) (s2445 >> 8); - const SWord32 s2692 = table4[s2691]; - const SWord32 s2693 = s2690 ^ s2692; - const SWord8 s2694 = (SWord8) s2494; - const SWord32 s2695 = table5[s2694]; - const SWord32 s2696 = s2693 ^ s2695; - const SWord8 s2697 = (SWord8) (s569 >> 24); - const SWord8 s2698 = table6[s2697]; - const SWord8 s2699 = (SWord8) (s569 >> 16); - const SWord8 s2700 = table7[s2699]; - const SWord8 s2701 = (SWord8) (s569 >> 8); - const SWord8 s2702 = table8[s2701]; - const SWord8 s2703 = (SWord8) s569; - const SWord8 s2704 = table9[s2703]; - const SWord8 s2705 = s2702 ^ s2704; - const SWord8 s2706 = s2700 ^ s2705; - const SWord8 s2707 = s2698 ^ s2706; - const SWord8 s2708 = table9[s2697]; - const SWord8 s2709 = table6[s2699]; - const SWord8 s2710 = table7[s2701]; - const SWord8 s2711 = table8[s2703]; - const SWord8 s2712 = s2710 ^ s2711; - const SWord8 s2713 = s2709 ^ s2712; - const SWord8 s2714 = s2708 ^ s2713; - const SWord16 s2715 = (((SWord16) s2707) << 8) | ((SWord16) s2714); - const SWord8 s2716 = table8[s2697]; - const SWord8 s2717 = table9[s2699]; - const SWord8 s2718 = table6[s2701]; - const SWord8 s2719 = table7[s2703]; - const SWord8 s2720 = s2718 ^ s2719; - const SWord8 s2721 = s2717 ^ s2720; - const SWord8 s2722 = s2716 ^ s2721; - const SWord8 s2723 = table7[s2697]; - const SWord8 s2724 = table8[s2699]; - const SWord8 s2725 = table9[s2701]; - const SWord8 s2726 = table6[s2703]; - const SWord8 s2727 = s2725 ^ s2726; - const SWord8 s2728 = s2724 ^ s2727; - const SWord8 s2729 = s2723 ^ s2728; - const SWord16 s2730 = (((SWord16) s2722) << 8) | ((SWord16) s2729); - const SWord32 s2731 = (((SWord32) s2715) << 16) | ((SWord32) s2730); - const SWord32 s2732 = s2696 ^ s2731; - const SWord8 s2733 = (SWord8) (s2732 >> 8); - const SWord32 s2734 = table4[s2733]; - const SWord32 s2735 = s2685 ^ s2734; - const SWord8 s2736 = (SWord8) (s2594 >> 24); - const SWord32 s2737 = table1[s2736]; - const SWord8 s2738 = (SWord8) (s2445 >> 16); - const SWord32 s2739 = table3[s2738]; - const SWord32 s2740 = s2737 ^ s2739; - const SWord8 s2741 = (SWord8) (s2494 >> 8); - const SWord32 s2742 = table4[s2741]; - const SWord32 s2743 = s2740 ^ s2742; - const SWord8 s2744 = (SWord8) s2544; - const SWord32 s2745 = table5[s2744]; - const SWord32 s2746 = s2743 ^ s2745; - const SWord8 s2747 = (SWord8) (s568 >> 24); - const SWord8 s2748 = table6[s2747]; - const SWord8 s2749 = (SWord8) (s568 >> 16); - const SWord8 s2750 = table7[s2749]; - const SWord8 s2751 = (SWord8) (s568 >> 8); - const SWord8 s2752 = table8[s2751]; - const SWord8 s2753 = (SWord8) s568; - const SWord8 s2754 = table9[s2753]; - const SWord8 s2755 = s2752 ^ s2754; - const SWord8 s2756 = s2750 ^ s2755; - const SWord8 s2757 = s2748 ^ s2756; - const SWord8 s2758 = table9[s2747]; - const SWord8 s2759 = table6[s2749]; - const SWord8 s2760 = table7[s2751]; - const SWord8 s2761 = table8[s2753]; - const SWord8 s2762 = s2760 ^ s2761; - const SWord8 s2763 = s2759 ^ s2762; - const SWord8 s2764 = s2758 ^ s2763; - const SWord16 s2765 = (((SWord16) s2757) << 8) | ((SWord16) s2764); - const SWord8 s2766 = table8[s2747]; - const SWord8 s2767 = table9[s2749]; - const SWord8 s2768 = table6[s2751]; - const SWord8 s2769 = table7[s2753]; - const SWord8 s2770 = s2768 ^ s2769; - const SWord8 s2771 = s2767 ^ s2770; - const SWord8 s2772 = s2766 ^ s2771; - const SWord8 s2773 = table7[s2747]; - const SWord8 s2774 = table8[s2749]; - const SWord8 s2775 = table9[s2751]; - const SWord8 s2776 = table6[s2753]; - const SWord8 s2777 = s2775 ^ s2776; - const SWord8 s2778 = s2774 ^ s2777; - const SWord8 s2779 = s2773 ^ s2778; - const SWord16 s2780 = (((SWord16) s2772) << 8) | ((SWord16) s2779); - const SWord32 s2781 = (((SWord32) s2765) << 16) | ((SWord32) s2780); - const SWord32 s2782 = s2746 ^ s2781; - const SWord8 s2783 = (SWord8) s2782; - const SWord32 s2784 = table5[s2783]; - const SWord32 s2785 = s2735 ^ s2784; - const SWord8 s2786 = (SWord8) (s550 >> 24); - const SWord8 s2787 = table6[s2786]; - const SWord8 s2788 = (SWord8) (s550 >> 16); - const SWord8 s2789 = table7[s2788]; - const SWord8 s2790 = (SWord8) (s550 >> 8); - const SWord8 s2791 = table8[s2790]; - const SWord8 s2792 = (SWord8) s550; - const SWord8 s2793 = table9[s2792]; - const SWord8 s2794 = s2791 ^ s2793; - const SWord8 s2795 = s2789 ^ s2794; - const SWord8 s2796 = s2787 ^ s2795; - const SWord8 s2797 = table9[s2786]; - const SWord8 s2798 = table6[s2788]; - const SWord8 s2799 = table7[s2790]; - const SWord8 s2800 = table8[s2792]; - const SWord8 s2801 = s2799 ^ s2800; - const SWord8 s2802 = s2798 ^ s2801; - const SWord8 s2803 = s2797 ^ s2802; - const SWord16 s2804 = (((SWord16) s2796) << 8) | ((SWord16) s2803); - const SWord8 s2805 = table8[s2786]; - const SWord8 s2806 = table9[s2788]; - const SWord8 s2807 = table6[s2790]; - const SWord8 s2808 = table7[s2792]; - const SWord8 s2809 = s2807 ^ s2808; - const SWord8 s2810 = s2806 ^ s2809; - const SWord8 s2811 = s2805 ^ s2810; - const SWord8 s2812 = table7[s2786]; - const SWord8 s2813 = table8[s2788]; - const SWord8 s2814 = table9[s2790]; - const SWord8 s2815 = table6[s2792]; - const SWord8 s2816 = s2814 ^ s2815; - const SWord8 s2817 = s2813 ^ s2816; - const SWord8 s2818 = s2812 ^ s2817; - const SWord16 s2819 = (((SWord16) s2811) << 8) | ((SWord16) s2818); - const SWord32 s2820 = (((SWord32) s2804) << 16) | ((SWord32) s2819); - const SWord32 s2821 = s2785 ^ s2820; - const SWord8 s2822 = (SWord8) (s2821 >> 24); - const SWord32 s2823 = table1[s2822]; - const SWord8 s2824 = (SWord8) (s2682 >> 24); - const SWord32 s2825 = table1[s2824]; - const SWord8 s2826 = (SWord8) (s2732 >> 16); - const SWord32 s2827 = table3[s2826]; - const SWord32 s2828 = s2825 ^ s2827; - const SWord8 s2829 = (SWord8) (s2782 >> 8); - const SWord32 s2830 = table4[s2829]; - const SWord32 s2831 = s2828 ^ s2830; - const SWord8 s2832 = (SWord8) s2633; - const SWord32 s2833 = table5[s2832]; - const SWord32 s2834 = s2831 ^ s2833; - const SWord8 s2835 = (SWord8) (s553 >> 24); - const SWord8 s2836 = table6[s2835]; - const SWord8 s2837 = (SWord8) (s553 >> 16); - const SWord8 s2838 = table7[s2837]; - const SWord8 s2839 = (SWord8) (s553 >> 8); - const SWord8 s2840 = table8[s2839]; - const SWord8 s2841 = (SWord8) s553; - const SWord8 s2842 = table9[s2841]; - const SWord8 s2843 = s2840 ^ s2842; - const SWord8 s2844 = s2838 ^ s2843; - const SWord8 s2845 = s2836 ^ s2844; - const SWord8 s2846 = table9[s2835]; - const SWord8 s2847 = table6[s2837]; - const SWord8 s2848 = table7[s2839]; - const SWord8 s2849 = table8[s2841]; - const SWord8 s2850 = s2848 ^ s2849; - const SWord8 s2851 = s2847 ^ s2850; - const SWord8 s2852 = s2846 ^ s2851; - const SWord16 s2853 = (((SWord16) s2845) << 8) | ((SWord16) s2852); - const SWord8 s2854 = table8[s2835]; - const SWord8 s2855 = table9[s2837]; - const SWord8 s2856 = table6[s2839]; - const SWord8 s2857 = table7[s2841]; - const SWord8 s2858 = s2856 ^ s2857; - const SWord8 s2859 = s2855 ^ s2858; - const SWord8 s2860 = s2854 ^ s2859; - const SWord8 s2861 = table7[s2835]; - const SWord8 s2862 = table8[s2837]; - const SWord8 s2863 = table9[s2839]; - const SWord8 s2864 = table6[s2841]; - const SWord8 s2865 = s2863 ^ s2864; - const SWord8 s2866 = s2862 ^ s2865; - const SWord8 s2867 = s2861 ^ s2866; - const SWord16 s2868 = (((SWord16) s2860) << 8) | ((SWord16) s2867); - const SWord32 s2869 = (((SWord32) s2853) << 16) | ((SWord32) s2868); - const SWord32 s2870 = s2834 ^ s2869; - const SWord8 s2871 = (SWord8) (s2870 >> 16); - const SWord32 s2872 = table3[s2871]; - const SWord32 s2873 = s2823 ^ s2872; - const SWord8 s2874 = (SWord8) (s2732 >> 24); - const SWord32 s2875 = table1[s2874]; - const SWord8 s2876 = (SWord8) (s2782 >> 16); - const SWord32 s2877 = table3[s2876]; - const SWord32 s2878 = s2875 ^ s2877; - const SWord8 s2879 = (SWord8) (s2633 >> 8); - const SWord32 s2880 = table4[s2879]; - const SWord32 s2881 = s2878 ^ s2880; - const SWord8 s2882 = (SWord8) s2682; - const SWord32 s2883 = table5[s2882]; - const SWord32 s2884 = s2881 ^ s2883; - const SWord8 s2885 = (SWord8) (s552 >> 24); - const SWord8 s2886 = table6[s2885]; - const SWord8 s2887 = (SWord8) (s552 >> 16); - const SWord8 s2888 = table7[s2887]; - const SWord8 s2889 = (SWord8) (s552 >> 8); - const SWord8 s2890 = table8[s2889]; - const SWord8 s2891 = (SWord8) s552; - const SWord8 s2892 = table9[s2891]; - const SWord8 s2893 = s2890 ^ s2892; - const SWord8 s2894 = s2888 ^ s2893; - const SWord8 s2895 = s2886 ^ s2894; - const SWord8 s2896 = table9[s2885]; - const SWord8 s2897 = table6[s2887]; - const SWord8 s2898 = table7[s2889]; - const SWord8 s2899 = table8[s2891]; - const SWord8 s2900 = s2898 ^ s2899; - const SWord8 s2901 = s2897 ^ s2900; - const SWord8 s2902 = s2896 ^ s2901; - const SWord16 s2903 = (((SWord16) s2895) << 8) | ((SWord16) s2902); - const SWord8 s2904 = table8[s2885]; - const SWord8 s2905 = table9[s2887]; - const SWord8 s2906 = table6[s2889]; - const SWord8 s2907 = table7[s2891]; - const SWord8 s2908 = s2906 ^ s2907; - const SWord8 s2909 = s2905 ^ s2908; - const SWord8 s2910 = s2904 ^ s2909; - const SWord8 s2911 = table7[s2885]; - const SWord8 s2912 = table8[s2887]; - const SWord8 s2913 = table9[s2889]; - const SWord8 s2914 = table6[s2891]; - const SWord8 s2915 = s2913 ^ s2914; - const SWord8 s2916 = s2912 ^ s2915; - const SWord8 s2917 = s2911 ^ s2916; - const SWord16 s2918 = (((SWord16) s2910) << 8) | ((SWord16) s2917); - const SWord32 s2919 = (((SWord32) s2903) << 16) | ((SWord32) s2918); - const SWord32 s2920 = s2884 ^ s2919; - const SWord8 s2921 = (SWord8) (s2920 >> 8); - const SWord32 s2922 = table4[s2921]; - const SWord32 s2923 = s2873 ^ s2922; - const SWord8 s2924 = (SWord8) (s2782 >> 24); - const SWord32 s2925 = table1[s2924]; - const SWord8 s2926 = (SWord8) (s2633 >> 16); - const SWord32 s2927 = table3[s2926]; - const SWord32 s2928 = s2925 ^ s2927; - const SWord8 s2929 = (SWord8) (s2682 >> 8); - const SWord32 s2930 = table4[s2929]; - const SWord32 s2931 = s2928 ^ s2930; - const SWord8 s2932 = (SWord8) s2732; - const SWord32 s2933 = table5[s2932]; - const SWord32 s2934 = s2931 ^ s2933; - const SWord8 s2935 = (SWord8) (s551 >> 24); - const SWord8 s2936 = table6[s2935]; - const SWord8 s2937 = (SWord8) (s551 >> 16); - const SWord8 s2938 = table7[s2937]; - const SWord8 s2939 = (SWord8) (s551 >> 8); - const SWord8 s2940 = table8[s2939]; - const SWord8 s2941 = (SWord8) s551; - const SWord8 s2942 = table9[s2941]; - const SWord8 s2943 = s2940 ^ s2942; - const SWord8 s2944 = s2938 ^ s2943; - const SWord8 s2945 = s2936 ^ s2944; - const SWord8 s2946 = table9[s2935]; - const SWord8 s2947 = table6[s2937]; - const SWord8 s2948 = table7[s2939]; - const SWord8 s2949 = table8[s2941]; - const SWord8 s2950 = s2948 ^ s2949; - const SWord8 s2951 = s2947 ^ s2950; - const SWord8 s2952 = s2946 ^ s2951; - const SWord16 s2953 = (((SWord16) s2945) << 8) | ((SWord16) s2952); - const SWord8 s2954 = table8[s2935]; - const SWord8 s2955 = table9[s2937]; - const SWord8 s2956 = table6[s2939]; - const SWord8 s2957 = table7[s2941]; - const SWord8 s2958 = s2956 ^ s2957; - const SWord8 s2959 = s2955 ^ s2958; - const SWord8 s2960 = s2954 ^ s2959; - const SWord8 s2961 = table7[s2935]; - const SWord8 s2962 = table8[s2937]; - const SWord8 s2963 = table9[s2939]; - const SWord8 s2964 = table6[s2941]; - const SWord8 s2965 = s2963 ^ s2964; - const SWord8 s2966 = s2962 ^ s2965; - const SWord8 s2967 = s2961 ^ s2966; - const SWord16 s2968 = (((SWord16) s2960) << 8) | ((SWord16) s2967); - const SWord32 s2969 = (((SWord32) s2953) << 16) | ((SWord32) s2968); - const SWord32 s2970 = s2934 ^ s2969; - const SWord8 s2971 = (SWord8) s2970; - const SWord32 s2972 = table5[s2971]; - const SWord32 s2973 = s2923 ^ s2972; - const SWord8 s2974 = (SWord8) (s533 >> 24); - const SWord8 s2975 = table6[s2974]; - const SWord8 s2976 = (SWord8) (s533 >> 16); - const SWord8 s2977 = table7[s2976]; - const SWord8 s2978 = (SWord8) (s533 >> 8); - const SWord8 s2979 = table8[s2978]; - const SWord8 s2980 = (SWord8) s533; - const SWord8 s2981 = table9[s2980]; - const SWord8 s2982 = s2979 ^ s2981; - const SWord8 s2983 = s2977 ^ s2982; - const SWord8 s2984 = s2975 ^ s2983; - const SWord8 s2985 = table9[s2974]; - const SWord8 s2986 = table6[s2976]; - const SWord8 s2987 = table7[s2978]; - const SWord8 s2988 = table8[s2980]; - const SWord8 s2989 = s2987 ^ s2988; - const SWord8 s2990 = s2986 ^ s2989; - const SWord8 s2991 = s2985 ^ s2990; - const SWord16 s2992 = (((SWord16) s2984) << 8) | ((SWord16) s2991); - const SWord8 s2993 = table8[s2974]; - const SWord8 s2994 = table9[s2976]; - const SWord8 s2995 = table6[s2978]; - const SWord8 s2996 = table7[s2980]; - const SWord8 s2997 = s2995 ^ s2996; - const SWord8 s2998 = s2994 ^ s2997; - const SWord8 s2999 = s2993 ^ s2998; - const SWord8 s3000 = table7[s2974]; - const SWord8 s3001 = table8[s2976]; - const SWord8 s3002 = table9[s2978]; - const SWord8 s3003 = table6[s2980]; - const SWord8 s3004 = s3002 ^ s3003; - const SWord8 s3005 = s3001 ^ s3004; - const SWord8 s3006 = s3000 ^ s3005; - const SWord16 s3007 = (((SWord16) s2999) << 8) | ((SWord16) s3006); - const SWord32 s3008 = (((SWord32) s2992) << 16) | ((SWord32) s3007); - const SWord32 s3009 = s2973 ^ s3008; - const SWord8 s3010 = (SWord8) (s3009 >> 24); - const SWord8 s3011 = table0[s3010]; - const SWord8 s3012 = (SWord8) (s2870 >> 24); - const SWord32 s3013 = table1[s3012]; - const SWord8 s3014 = (SWord8) (s2920 >> 16); - const SWord32 s3015 = table3[s3014]; - const SWord32 s3016 = s3013 ^ s3015; - const SWord8 s3017 = (SWord8) (s2970 >> 8); - const SWord32 s3018 = table4[s3017]; - const SWord32 s3019 = s3016 ^ s3018; - const SWord8 s3020 = (SWord8) s2821; - const SWord32 s3021 = table5[s3020]; - const SWord32 s3022 = s3019 ^ s3021; - const SWord8 s3023 = (SWord8) (s536 >> 24); - const SWord8 s3024 = table6[s3023]; - const SWord8 s3025 = (SWord8) (s536 >> 16); - const SWord8 s3026 = table7[s3025]; - const SWord8 s3027 = (SWord8) (s536 >> 8); - const SWord8 s3028 = table8[s3027]; - const SWord8 s3029 = (SWord8) s536; - const SWord8 s3030 = table9[s3029]; - const SWord8 s3031 = s3028 ^ s3030; - const SWord8 s3032 = s3026 ^ s3031; - const SWord8 s3033 = s3024 ^ s3032; - const SWord8 s3034 = table9[s3023]; - const SWord8 s3035 = table6[s3025]; - const SWord8 s3036 = table7[s3027]; - const SWord8 s3037 = table8[s3029]; - const SWord8 s3038 = s3036 ^ s3037; - const SWord8 s3039 = s3035 ^ s3038; - const SWord8 s3040 = s3034 ^ s3039; - const SWord16 s3041 = (((SWord16) s3033) << 8) | ((SWord16) s3040); - const SWord8 s3042 = table8[s3023]; - const SWord8 s3043 = table9[s3025]; - const SWord8 s3044 = table6[s3027]; - const SWord8 s3045 = table7[s3029]; - const SWord8 s3046 = s3044 ^ s3045; - const SWord8 s3047 = s3043 ^ s3046; - const SWord8 s3048 = s3042 ^ s3047; - const SWord8 s3049 = table7[s3023]; - const SWord8 s3050 = table8[s3025]; - const SWord8 s3051 = table9[s3027]; - const SWord8 s3052 = table6[s3029]; - const SWord8 s3053 = s3051 ^ s3052; - const SWord8 s3054 = s3050 ^ s3053; - const SWord8 s3055 = s3049 ^ s3054; - const SWord16 s3056 = (((SWord16) s3048) << 8) | ((SWord16) s3055); - const SWord32 s3057 = (((SWord32) s3041) << 16) | ((SWord32) s3056); - const SWord32 s3058 = s3022 ^ s3057; - const SWord8 s3059 = (SWord8) (s3058 >> 16); - const SWord8 s3060 = table0[s3059]; - const SWord16 s3061 = (((SWord16) s3011) << 8) | ((SWord16) s3060); - const SWord8 s3062 = (SWord8) (s2920 >> 24); - const SWord32 s3063 = table1[s3062]; - const SWord8 s3064 = (SWord8) (s2970 >> 16); - const SWord32 s3065 = table3[s3064]; - const SWord32 s3066 = s3063 ^ s3065; - const SWord8 s3067 = (SWord8) (s2821 >> 8); - const SWord32 s3068 = table4[s3067]; - const SWord32 s3069 = s3066 ^ s3068; - const SWord8 s3070 = (SWord8) s2870; - const SWord32 s3071 = table5[s3070]; - const SWord32 s3072 = s3069 ^ s3071; - const SWord8 s3073 = (SWord8) (s535 >> 24); - const SWord8 s3074 = table6[s3073]; - const SWord8 s3075 = (SWord8) (s535 >> 16); - const SWord8 s3076 = table7[s3075]; - const SWord8 s3077 = (SWord8) (s535 >> 8); - const SWord8 s3078 = table8[s3077]; - const SWord8 s3079 = (SWord8) s535; - const SWord8 s3080 = table9[s3079]; - const SWord8 s3081 = s3078 ^ s3080; - const SWord8 s3082 = s3076 ^ s3081; - const SWord8 s3083 = s3074 ^ s3082; - const SWord8 s3084 = table9[s3073]; - const SWord8 s3085 = table6[s3075]; - const SWord8 s3086 = table7[s3077]; - const SWord8 s3087 = table8[s3079]; - const SWord8 s3088 = s3086 ^ s3087; - const SWord8 s3089 = s3085 ^ s3088; - const SWord8 s3090 = s3084 ^ s3089; - const SWord16 s3091 = (((SWord16) s3083) << 8) | ((SWord16) s3090); - const SWord8 s3092 = table8[s3073]; - const SWord8 s3093 = table9[s3075]; - const SWord8 s3094 = table6[s3077]; - const SWord8 s3095 = table7[s3079]; - const SWord8 s3096 = s3094 ^ s3095; - const SWord8 s3097 = s3093 ^ s3096; - const SWord8 s3098 = s3092 ^ s3097; - const SWord8 s3099 = table7[s3073]; - const SWord8 s3100 = table8[s3075]; - const SWord8 s3101 = table9[s3077]; - const SWord8 s3102 = table6[s3079]; - const SWord8 s3103 = s3101 ^ s3102; - const SWord8 s3104 = s3100 ^ s3103; - const SWord8 s3105 = s3099 ^ s3104; - const SWord16 s3106 = (((SWord16) s3098) << 8) | ((SWord16) s3105); - const SWord32 s3107 = (((SWord32) s3091) << 16) | ((SWord32) s3106); - const SWord32 s3108 = s3072 ^ s3107; - const SWord8 s3109 = (SWord8) (s3108 >> 8); - const SWord8 s3110 = table0[s3109]; - const SWord8 s3111 = (SWord8) (s2970 >> 24); - const SWord32 s3112 = table1[s3111]; - const SWord8 s3113 = (SWord8) (s2821 >> 16); - const SWord32 s3114 = table3[s3113]; - const SWord32 s3115 = s3112 ^ s3114; - const SWord8 s3116 = (SWord8) (s2870 >> 8); - const SWord32 s3117 = table4[s3116]; - const SWord32 s3118 = s3115 ^ s3117; - const SWord8 s3119 = (SWord8) s2920; - const SWord32 s3120 = table5[s3119]; - const SWord32 s3121 = s3118 ^ s3120; - const SWord8 s3122 = (SWord8) (s534 >> 24); - const SWord8 s3123 = table6[s3122]; - const SWord8 s3124 = (SWord8) (s534 >> 16); - const SWord8 s3125 = table7[s3124]; - const SWord8 s3126 = (SWord8) (s534 >> 8); - const SWord8 s3127 = table8[s3126]; - const SWord8 s3128 = (SWord8) s534; - const SWord8 s3129 = table9[s3128]; - const SWord8 s3130 = s3127 ^ s3129; - const SWord8 s3131 = s3125 ^ s3130; - const SWord8 s3132 = s3123 ^ s3131; - const SWord8 s3133 = table9[s3122]; - const SWord8 s3134 = table6[s3124]; - const SWord8 s3135 = table7[s3126]; - const SWord8 s3136 = table8[s3128]; - const SWord8 s3137 = s3135 ^ s3136; - const SWord8 s3138 = s3134 ^ s3137; - const SWord8 s3139 = s3133 ^ s3138; - const SWord16 s3140 = (((SWord16) s3132) << 8) | ((SWord16) s3139); - const SWord8 s3141 = table8[s3122]; - const SWord8 s3142 = table9[s3124]; - const SWord8 s3143 = table6[s3126]; - const SWord8 s3144 = table7[s3128]; - const SWord8 s3145 = s3143 ^ s3144; - const SWord8 s3146 = s3142 ^ s3145; - const SWord8 s3147 = s3141 ^ s3146; - const SWord8 s3148 = table7[s3122]; - const SWord8 s3149 = table8[s3124]; - const SWord8 s3150 = table9[s3126]; - const SWord8 s3151 = table6[s3128]; - const SWord8 s3152 = s3150 ^ s3151; - const SWord8 s3153 = s3149 ^ s3152; - const SWord8 s3154 = s3148 ^ s3153; - const SWord16 s3155 = (((SWord16) s3147) << 8) | ((SWord16) s3154); - const SWord32 s3156 = (((SWord32) s3140) << 16) | ((SWord32) s3155); - const SWord32 s3157 = s3121 ^ s3156; - const SWord8 s3158 = (SWord8) s3157; - const SWord8 s3159 = table0[s3158]; - const SWord16 s3160 = (((SWord16) s3110) << 8) | ((SWord16) s3159); - const SWord32 s3161 = (((SWord32) s3061) << 16) | ((SWord32) s3160); - const SWord32 s3162 = s4 ^ s3161; - const SWord8 s3163 = (SWord8) (s3157 >> 24); - const SWord8 s3164 = table0[s3163]; - const SWord8 s3165 = (SWord8) (s3009 >> 16); - const SWord8 s3166 = table0[s3165]; - const SWord16 s3167 = (((SWord16) s3164) << 8) | ((SWord16) s3166); - const SWord8 s3168 = (SWord8) (s3058 >> 8); - const SWord8 s3169 = table0[s3168]; - const SWord8 s3170 = (SWord8) s3108; - const SWord8 s3171 = table0[s3170]; - const SWord16 s3172 = (((SWord16) s3169) << 8) | ((SWord16) s3171); - const SWord32 s3173 = (((SWord32) s3167) << 16) | ((SWord32) s3172); - const SWord32 s3174 = s5 ^ s3173; - const SWord8 s3175 = (SWord8) (s3108 >> 24); - const SWord8 s3176 = table0[s3175]; - const SWord8 s3177 = (SWord8) (s3157 >> 16); - const SWord8 s3178 = table0[s3177]; - const SWord16 s3179 = (((SWord16) s3176) << 8) | ((SWord16) s3178); - const SWord8 s3180 = (SWord8) (s3009 >> 8); - const SWord8 s3181 = table0[s3180]; - const SWord8 s3182 = (SWord8) s3058; - const SWord8 s3183 = table0[s3182]; - const SWord16 s3184 = (((SWord16) s3181) << 8) | ((SWord16) s3183); - const SWord32 s3185 = (((SWord32) s3179) << 16) | ((SWord32) s3184); - const SWord32 s3186 = s6 ^ s3185; - const SWord8 s3187 = (SWord8) (s3058 >> 24); - const SWord8 s3188 = table0[s3187]; - const SWord8 s3189 = (SWord8) (s3108 >> 16); - const SWord8 s3190 = table0[s3189]; - const SWord16 s3191 = (((SWord16) s3188) << 8) | ((SWord16) s3190); - const SWord8 s3192 = (SWord8) (s3157 >> 8); - const SWord8 s3193 = table0[s3192]; - const SWord8 s3194 = (SWord8) s3009; - const SWord8 s3195 = table0[s3194]; - const SWord16 s3196 = (((SWord16) s3193) << 8) | ((SWord16) s3195); - const SWord32 s3197 = (((SWord32) s3191) << 16) | ((SWord32) s3196); - const SWord32 s3198 = s7 ^ s3197; - - ct[0] = s3162; - ct[1] = s3174; - ct[2] = s3186; - ct[3] = s3198; +aes128Dec_driver.o: aes128Dec_driver.c aes128Dec.h + ${CC} ${CCFLAGS} -c $< -o $@ + +aes128Dec_driver: aes128Dec.o aes128Dec_driver.o + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} + +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 SBV_GENERATED_aes128Dec_HEADER_INCLUDED +#define SBV_GENERATED_aes128Dec_HEADER_INCLUDED + + +#include +#include +#include +#include +#include +#include +#include + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* Entry point prototype: */ +void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct); + +#endif /* SBV_GENERATED_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 +#include "aes128Dec.h" + +int main(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array pt:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" pt[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord32 sbv_driver_input_1[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array key:\n"); + int sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 4 ; ++sbv_driver_input_1_ctr) + { printf(" key[%1d] = ", sbv_driver_input_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[4]; + + aes128Dec(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("aes128Dec(pt, key, ct) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 4 ; ++sbv_driver_output_0_ctr) + { printf(" ct[%1d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } + + return 0; +} +== END: "aes128Dec_driver.c" ================== +== BEGIN: "aes128Dec.c" ================ +/* File: "aes128Dec.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Dec.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotl(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) << amount) | (((uint64_t) (SWord32) a) >> (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotr(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) >> amount) | (((uint64_t) (SWord32) a) << (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128Dec(const SWord32 *sbv_input_0, + const SWord32 *sbv_input_1, SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s4 = sbv_input_1[0]; + const SWord32 s5 = sbv_input_1[1]; + const SWord32 s6 = sbv_input_1[2]; + const SWord32 s7 = sbv_input_1[3]; + const SWord32 s520 = sbv_bv_u32_rotl(s7, 8); + const SWord8 s521 = sbv_bv_extract_u32_31_24_u8(s520); + const SWord8 s524 = sbv_bv_extract_u32_23_16_u8(s520); + const SWord8 s527 = sbv_bv_extract_u32_15_8_u8(s520); + const SWord8 s529 = sbv_bv_extract_u32_7_0_u8(s520); + SWord8 s522; + SWord8 s523; + SWord8 s525; + SWord16 s526; + SWord8 s528; + SWord8 s530; + SWord16 s531; + SWord32 s532; + SWord32 s533; + SWord32 s534; + SWord32 s535; + SWord32 s536; + SWord32 s537; + SWord8 s538; + SWord8 s539; + SWord8 s540; + SWord8 s541; + SWord8 s542; + SWord16 s543; + SWord8 s544; + SWord8 s545; + SWord8 s546; + SWord8 s547; + SWord16 s548; + SWord32 s549; + SWord32 s550; + SWord32 s551; + SWord32 s552; + SWord32 s553; + SWord32 s554; + SWord8 s555; + SWord8 s556; + SWord8 s557; + SWord8 s558; + SWord8 s559; + SWord16 s560; + SWord8 s561; + SWord8 s562; + SWord8 s563; + SWord8 s564; + SWord16 s565; + SWord32 s566; + SWord32 s567; + SWord32 s568; + SWord32 s569; + SWord32 s570; + SWord32 s571; + SWord8 s572; + SWord8 s573; + SWord8 s574; + SWord8 s575; + SWord8 s576; + SWord16 s577; + SWord8 s578; + SWord8 s579; + SWord8 s580; + SWord8 s581; + SWord16 s582; + SWord32 s583; + SWord32 s584; + SWord32 s585; + SWord32 s586; + SWord32 s587; + SWord32 s588; + SWord8 s589; + SWord8 s590; + SWord8 s591; + SWord8 s592; + SWord8 s593; + SWord16 s594; + SWord8 s595; + SWord8 s596; + SWord8 s597; + SWord8 s598; + SWord16 s599; + SWord32 s600; + SWord32 s601; + SWord32 s602; + SWord32 s603; + SWord32 s604; + SWord32 s605; + SWord8 s606; + SWord8 s607; + SWord8 s608; + SWord8 s609; + SWord8 s610; + SWord16 s611; + SWord8 s612; + SWord8 s613; + SWord8 s614; + SWord8 s615; + SWord16 s616; + SWord32 s617; + SWord32 s618; + SWord32 s619; + SWord32 s620; + SWord32 s621; + SWord32 s622; + SWord8 s623; + SWord8 s624; + SWord8 s625; + SWord8 s626; + SWord8 s627; + SWord16 s628; + SWord8 s629; + SWord8 s630; + SWord8 s631; + SWord8 s632; + SWord16 s633; + SWord32 s634; + SWord32 s635; + SWord32 s636; + SWord32 s637; + SWord32 s638; + SWord32 s639; + SWord8 s640; + SWord8 s641; + SWord8 s642; + SWord8 s643; + SWord8 s644; + SWord16 s645; + SWord8 s646; + SWord8 s647; + SWord8 s648; + SWord8 s649; + SWord16 s650; + SWord32 s651; + SWord32 s652; + SWord32 s653; + SWord32 s654; + SWord32 s655; + SWord32 s656; + SWord8 s657; + SWord8 s658; + SWord8 s659; + SWord8 s660; + SWord8 s661; + SWord16 s662; + SWord8 s663; + SWord8 s664; + SWord8 s665; + SWord8 s666; + SWord16 s667; + SWord32 s668; + SWord32 s669; + SWord32 s670; + SWord32 s671; + SWord32 s672; + SWord32 s673; + SWord8 s674; + SWord8 s675; + SWord8 s676; + SWord8 s677; + SWord8 s678; + SWord16 s679; + SWord8 s680; + SWord8 s681; + SWord8 s682; + SWord8 s683; + SWord16 s684; + SWord32 s685; + SWord32 s686; + SWord32 s687; + SWord8 s688; + SWord32 s689; + SWord32 s945; + SWord32 s946; + SWord32 s947; + SWord32 s948; + SWord8 s949; + SWord32 s950; + SWord32 s951; + SWord32 s1207; + SWord8 s1208; + SWord32 s1209; + SWord32 s1210; + SWord32 s1466; + SWord8 s1467; + SWord32 s1468; + SWord32 s1469; + SWord8 s1470; + SWord8 s1471; + SWord8 s1472; + SWord8 s1473; + SWord8 s1474; + SWord8 s1475; + SWord8 s1476; + SWord8 s1477; + SWord8 s1478; + SWord8 s1479; + SWord8 s1480; + SWord8 s1481; + SWord8 s1482; + SWord8 s1483; + SWord8 s1484; + SWord8 s1485; + SWord8 s1486; + SWord8 s1487; + SWord16 s1488; + SWord8 s1489; + SWord8 s1490; + SWord8 s1491; + SWord8 s1492; + SWord8 s1493; + SWord8 s1494; + SWord8 s1495; + SWord8 s1496; + SWord8 s1497; + SWord8 s1498; + SWord8 s1499; + SWord8 s1500; + SWord8 s1501; + SWord8 s1502; + SWord16 s1503; + SWord32 s1504; + SWord32 s1505; + SWord8 s1506; + SWord32 s1507; + SWord8 s1508; + SWord32 s1509; + SWord8 s1510; + SWord32 s1511; + SWord32 s1512; + SWord8 s1513; + SWord32 s1514; + SWord32 s1515; + SWord8 s1516; + SWord32 s1517; + SWord32 s1518; + SWord8 s1519; + SWord8 s1520; + SWord8 s1521; + SWord8 s1522; + SWord8 s1523; + SWord8 s1524; + SWord8 s1525; + SWord8 s1526; + SWord8 s1527; + SWord8 s1528; + SWord8 s1529; + SWord8 s1530; + SWord8 s1531; + SWord8 s1532; + SWord8 s1533; + SWord8 s1534; + SWord8 s1535; + SWord8 s1536; + SWord16 s1537; + SWord8 s1538; + SWord8 s1539; + SWord8 s1540; + SWord8 s1541; + SWord8 s1542; + SWord8 s1543; + SWord8 s1544; + SWord8 s1545; + SWord8 s1546; + SWord8 s1547; + SWord8 s1548; + SWord8 s1549; + SWord8 s1550; + SWord8 s1551; + SWord16 s1552; + SWord32 s1553; + SWord32 s1554; + SWord8 s1555; + SWord32 s1556; + SWord32 s1557; + SWord8 s1558; + SWord32 s1559; + SWord8 s1560; + SWord32 s1561; + SWord32 s1562; + SWord8 s1563; + SWord32 s1564; + SWord32 s1565; + SWord8 s1566; + SWord32 s1567; + SWord32 s1568; + SWord8 s1569; + SWord8 s1570; + SWord8 s1571; + SWord8 s1572; + SWord8 s1573; + SWord8 s1574; + SWord8 s1575; + SWord8 s1576; + SWord8 s1577; + SWord8 s1578; + SWord8 s1579; + SWord8 s1580; + SWord8 s1581; + SWord8 s1582; + SWord8 s1583; + SWord8 s1584; + SWord8 s1585; + SWord8 s1586; + SWord16 s1587; + SWord8 s1588; + SWord8 s1589; + SWord8 s1590; + SWord8 s1591; + SWord8 s1592; + SWord8 s1593; + SWord8 s1594; + SWord8 s1595; + SWord8 s1596; + SWord8 s1597; + SWord8 s1598; + SWord8 s1599; + SWord8 s1600; + SWord8 s1601; + SWord16 s1602; + SWord32 s1603; + SWord32 s1604; + SWord8 s1605; + SWord32 s1606; + SWord32 s1607; + SWord8 s1608; + SWord32 s1609; + SWord8 s1610; + SWord32 s1611; + SWord32 s1612; + SWord8 s1613; + SWord32 s1614; + SWord32 s1615; + SWord8 s1616; + SWord32 s1617; + SWord32 s1618; + SWord8 s1619; + SWord8 s1620; + SWord8 s1621; + SWord8 s1622; + SWord8 s1623; + SWord8 s1624; + SWord8 s1625; + SWord8 s1626; + SWord8 s1627; + SWord8 s1628; + SWord8 s1629; + SWord8 s1630; + SWord8 s1631; + SWord8 s1632; + SWord8 s1633; + SWord8 s1634; + SWord8 s1635; + SWord8 s1636; + SWord16 s1637; + SWord8 s1638; + SWord8 s1639; + SWord8 s1640; + SWord8 s1641; + SWord8 s1642; + SWord8 s1643; + SWord8 s1644; + SWord8 s1645; + SWord8 s1646; + SWord8 s1647; + SWord8 s1648; + SWord8 s1649; + SWord8 s1650; + SWord8 s1651; + SWord16 s1652; + SWord32 s1653; + SWord32 s1654; + SWord8 s1655; + SWord32 s1656; + SWord32 s1657; + SWord8 s1658; + SWord8 s1659; + SWord8 s1660; + SWord8 s1661; + SWord8 s1662; + SWord8 s1663; + SWord8 s1664; + SWord8 s1665; + SWord8 s1666; + SWord8 s1667; + SWord8 s1668; + SWord8 s1669; + SWord8 s1670; + SWord8 s1671; + SWord8 s1672; + SWord8 s1673; + SWord8 s1674; + SWord8 s1675; + SWord16 s1676; + SWord8 s1677; + SWord8 s1678; + SWord8 s1679; + SWord8 s1680; + SWord8 s1681; + SWord8 s1682; + SWord8 s1683; + SWord8 s1684; + SWord8 s1685; + SWord8 s1686; + SWord8 s1687; + SWord8 s1688; + SWord8 s1689; + SWord8 s1690; + SWord16 s1691; + SWord32 s1692; + SWord32 s1693; + SWord8 s1694; + SWord32 s1695; + SWord8 s1696; + SWord32 s1697; + SWord8 s1698; + SWord32 s1699; + SWord32 s1700; + SWord8 s1701; + SWord32 s1702; + SWord32 s1703; + SWord8 s1704; + SWord32 s1705; + SWord32 s1706; + SWord8 s1707; + SWord8 s1708; + SWord8 s1709; + SWord8 s1710; + SWord8 s1711; + SWord8 s1712; + SWord8 s1713; + SWord8 s1714; + SWord8 s1715; + SWord8 s1716; + SWord8 s1717; + SWord8 s1718; + SWord8 s1719; + SWord8 s1720; + SWord8 s1721; + SWord8 s1722; + SWord8 s1723; + SWord8 s1724; + SWord16 s1725; + SWord8 s1726; + SWord8 s1727; + SWord8 s1728; + SWord8 s1729; + SWord8 s1730; + SWord8 s1731; + SWord8 s1732; + SWord8 s1733; + SWord8 s1734; + SWord8 s1735; + SWord8 s1736; + SWord8 s1737; + SWord8 s1738; + SWord8 s1739; + SWord16 s1740; + SWord32 s1741; + SWord32 s1742; + SWord8 s1743; + SWord32 s1744; + SWord32 s1745; + SWord8 s1746; + SWord32 s1747; + SWord8 s1748; + SWord32 s1749; + SWord32 s1750; + SWord8 s1751; + SWord32 s1752; + SWord32 s1753; + SWord8 s1754; + SWord32 s1755; + SWord32 s1756; + SWord8 s1757; + SWord8 s1758; + SWord8 s1759; + SWord8 s1760; + SWord8 s1761; + SWord8 s1762; + SWord8 s1763; + SWord8 s1764; + SWord8 s1765; + SWord8 s1766; + SWord8 s1767; + SWord8 s1768; + SWord8 s1769; + SWord8 s1770; + SWord8 s1771; + SWord8 s1772; + SWord8 s1773; + SWord8 s1774; + SWord16 s1775; + SWord8 s1776; + SWord8 s1777; + SWord8 s1778; + SWord8 s1779; + SWord8 s1780; + SWord8 s1781; + SWord8 s1782; + SWord8 s1783; + SWord8 s1784; + SWord8 s1785; + SWord8 s1786; + SWord8 s1787; + SWord8 s1788; + SWord8 s1789; + SWord16 s1790; + SWord32 s1791; + SWord32 s1792; + SWord8 s1793; + SWord32 s1794; + SWord32 s1795; + SWord8 s1796; + SWord32 s1797; + SWord8 s1798; + SWord32 s1799; + SWord32 s1800; + SWord8 s1801; + SWord32 s1802; + SWord32 s1803; + SWord8 s1804; + SWord32 s1805; + SWord32 s1806; + SWord8 s1807; + SWord8 s1808; + SWord8 s1809; + SWord8 s1810; + SWord8 s1811; + SWord8 s1812; + SWord8 s1813; + SWord8 s1814; + SWord8 s1815; + SWord8 s1816; + SWord8 s1817; + SWord8 s1818; + SWord8 s1819; + SWord8 s1820; + SWord8 s1821; + SWord8 s1822; + SWord8 s1823; + SWord8 s1824; + SWord16 s1825; + SWord8 s1826; + SWord8 s1827; + SWord8 s1828; + SWord8 s1829; + SWord8 s1830; + SWord8 s1831; + SWord8 s1832; + SWord8 s1833; + SWord8 s1834; + SWord8 s1835; + SWord8 s1836; + SWord8 s1837; + SWord8 s1838; + SWord8 s1839; + SWord16 s1840; + SWord32 s1841; + SWord32 s1842; + SWord8 s1843; + SWord32 s1844; + SWord32 s1845; + SWord8 s1846; + SWord8 s1847; + SWord8 s1848; + SWord8 s1849; + SWord8 s1850; + SWord8 s1851; + SWord8 s1852; + SWord8 s1853; + SWord8 s1854; + SWord8 s1855; + SWord8 s1856; + SWord8 s1857; + SWord8 s1858; + SWord8 s1859; + SWord8 s1860; + SWord8 s1861; + SWord8 s1862; + SWord8 s1863; + SWord16 s1864; + SWord8 s1865; + SWord8 s1866; + SWord8 s1867; + SWord8 s1868; + SWord8 s1869; + SWord8 s1870; + SWord8 s1871; + SWord8 s1872; + SWord8 s1873; + SWord8 s1874; + SWord8 s1875; + SWord8 s1876; + SWord8 s1877; + SWord8 s1878; + SWord16 s1879; + SWord32 s1880; + SWord32 s1881; + SWord8 s1882; + SWord32 s1883; + SWord8 s1884; + SWord32 s1885; + SWord8 s1886; + SWord32 s1887; + SWord32 s1888; + SWord8 s1889; + SWord32 s1890; + SWord32 s1891; + SWord8 s1892; + SWord32 s1893; + SWord32 s1894; + SWord8 s1895; + SWord8 s1896; + SWord8 s1897; + SWord8 s1898; + SWord8 s1899; + SWord8 s1900; + SWord8 s1901; + SWord8 s1902; + SWord8 s1903; + SWord8 s1904; + SWord8 s1905; + SWord8 s1906; + SWord8 s1907; + SWord8 s1908; + SWord8 s1909; + SWord8 s1910; + SWord8 s1911; + SWord8 s1912; + SWord16 s1913; + SWord8 s1914; + SWord8 s1915; + SWord8 s1916; + SWord8 s1917; + SWord8 s1918; + SWord8 s1919; + SWord8 s1920; + SWord8 s1921; + SWord8 s1922; + SWord8 s1923; + SWord8 s1924; + SWord8 s1925; + SWord8 s1926; + SWord8 s1927; + SWord16 s1928; + SWord32 s1929; + SWord32 s1930; + SWord8 s1931; + SWord32 s1932; + SWord32 s1933; + SWord8 s1934; + SWord32 s1935; + SWord8 s1936; + SWord32 s1937; + SWord32 s1938; + SWord8 s1939; + SWord32 s1940; + SWord32 s1941; + SWord8 s1942; + SWord32 s1943; + SWord32 s1944; + SWord8 s1945; + SWord8 s1946; + SWord8 s1947; + SWord8 s1948; + SWord8 s1949; + SWord8 s1950; + SWord8 s1951; + SWord8 s1952; + SWord8 s1953; + SWord8 s1954; + SWord8 s1955; + SWord8 s1956; + SWord8 s1957; + SWord8 s1958; + SWord8 s1959; + SWord8 s1960; + SWord8 s1961; + SWord8 s1962; + SWord16 s1963; + SWord8 s1964; + SWord8 s1965; + SWord8 s1966; + SWord8 s1967; + SWord8 s1968; + SWord8 s1969; + SWord8 s1970; + SWord8 s1971; + SWord8 s1972; + SWord8 s1973; + SWord8 s1974; + SWord8 s1975; + SWord8 s1976; + SWord8 s1977; + SWord16 s1978; + SWord32 s1979; + SWord32 s1980; + SWord8 s1981; + SWord32 s1982; + SWord32 s1983; + SWord8 s1984; + SWord32 s1985; + SWord8 s1986; + SWord32 s1987; + SWord32 s1988; + SWord8 s1989; + SWord32 s1990; + SWord32 s1991; + SWord8 s1992; + SWord32 s1993; + SWord32 s1994; + SWord8 s1995; + SWord8 s1996; + SWord8 s1997; + SWord8 s1998; + SWord8 s1999; + SWord8 s2000; + SWord8 s2001; + SWord8 s2002; + SWord8 s2003; + SWord8 s2004; + SWord8 s2005; + SWord8 s2006; + SWord8 s2007; + SWord8 s2008; + SWord8 s2009; + SWord8 s2010; + SWord8 s2011; + SWord8 s2012; + SWord16 s2013; + SWord8 s2014; + SWord8 s2015; + SWord8 s2016; + SWord8 s2017; + SWord8 s2018; + SWord8 s2019; + SWord8 s2020; + SWord8 s2021; + SWord8 s2022; + SWord8 s2023; + SWord8 s2024; + SWord8 s2025; + SWord8 s2026; + SWord8 s2027; + SWord16 s2028; + SWord32 s2029; + SWord32 s2030; + SWord8 s2031; + SWord32 s2032; + SWord32 s2033; + SWord8 s2034; + SWord8 s2035; + SWord8 s2036; + SWord8 s2037; + SWord8 s2038; + SWord8 s2039; + SWord8 s2040; + SWord8 s2041; + SWord8 s2042; + SWord8 s2043; + SWord8 s2044; + SWord8 s2045; + SWord8 s2046; + SWord8 s2047; + SWord8 s2048; + SWord8 s2049; + SWord8 s2050; + SWord8 s2051; + SWord16 s2052; + SWord8 s2053; + SWord8 s2054; + SWord8 s2055; + SWord8 s2056; + SWord8 s2057; + SWord8 s2058; + SWord8 s2059; + SWord8 s2060; + SWord8 s2061; + SWord8 s2062; + SWord8 s2063; + SWord8 s2064; + SWord8 s2065; + SWord8 s2066; + SWord16 s2067; + SWord32 s2068; + SWord32 s2069; + SWord8 s2070; + SWord32 s2071; + SWord8 s2072; + SWord32 s2073; + SWord8 s2074; + SWord32 s2075; + SWord32 s2076; + SWord8 s2077; + SWord32 s2078; + SWord32 s2079; + SWord8 s2080; + SWord32 s2081; + SWord32 s2082; + SWord8 s2083; + SWord8 s2084; + SWord8 s2085; + SWord8 s2086; + SWord8 s2087; + SWord8 s2088; + SWord8 s2089; + SWord8 s2090; + SWord8 s2091; + SWord8 s2092; + SWord8 s2093; + SWord8 s2094; + SWord8 s2095; + SWord8 s2096; + SWord8 s2097; + SWord8 s2098; + SWord8 s2099; + SWord8 s2100; + SWord16 s2101; + SWord8 s2102; + SWord8 s2103; + SWord8 s2104; + SWord8 s2105; + SWord8 s2106; + SWord8 s2107; + SWord8 s2108; + SWord8 s2109; + SWord8 s2110; + SWord8 s2111; + SWord8 s2112; + SWord8 s2113; + SWord8 s2114; + SWord8 s2115; + SWord16 s2116; + SWord32 s2117; + SWord32 s2118; + SWord8 s2119; + SWord32 s2120; + SWord32 s2121; + SWord8 s2122; + SWord32 s2123; + SWord8 s2124; + SWord32 s2125; + SWord32 s2126; + SWord8 s2127; + SWord32 s2128; + SWord32 s2129; + SWord8 s2130; + SWord32 s2131; + SWord32 s2132; + SWord8 s2133; + SWord8 s2134; + SWord8 s2135; + SWord8 s2136; + SWord8 s2137; + SWord8 s2138; + SWord8 s2139; + SWord8 s2140; + SWord8 s2141; + SWord8 s2142; + SWord8 s2143; + SWord8 s2144; + SWord8 s2145; + SWord8 s2146; + SWord8 s2147; + SWord8 s2148; + SWord8 s2149; + SWord8 s2150; + SWord16 s2151; + SWord8 s2152; + SWord8 s2153; + SWord8 s2154; + SWord8 s2155; + SWord8 s2156; + SWord8 s2157; + SWord8 s2158; + SWord8 s2159; + SWord8 s2160; + SWord8 s2161; + SWord8 s2162; + SWord8 s2163; + SWord8 s2164; + SWord8 s2165; + SWord16 s2166; + SWord32 s2167; + SWord32 s2168; + SWord8 s2169; + SWord32 s2170; + SWord32 s2171; + SWord8 s2172; + SWord32 s2173; + SWord8 s2174; + SWord32 s2175; + SWord32 s2176; + SWord8 s2177; + SWord32 s2178; + SWord32 s2179; + SWord8 s2180; + SWord32 s2181; + SWord32 s2182; + SWord8 s2183; + SWord8 s2184; + SWord8 s2185; + SWord8 s2186; + SWord8 s2187; + SWord8 s2188; + SWord8 s2189; + SWord8 s2190; + SWord8 s2191; + SWord8 s2192; + SWord8 s2193; + SWord8 s2194; + SWord8 s2195; + SWord8 s2196; + SWord8 s2197; + SWord8 s2198; + SWord8 s2199; + SWord8 s2200; + SWord16 s2201; + SWord8 s2202; + SWord8 s2203; + SWord8 s2204; + SWord8 s2205; + SWord8 s2206; + SWord8 s2207; + SWord8 s2208; + SWord8 s2209; + SWord8 s2210; + SWord8 s2211; + SWord8 s2212; + SWord8 s2213; + SWord8 s2214; + SWord8 s2215; + SWord16 s2216; + SWord32 s2217; + SWord32 s2218; + SWord8 s2219; + SWord32 s2220; + SWord32 s2221; + SWord8 s2222; + SWord8 s2223; + SWord8 s2224; + SWord8 s2225; + SWord8 s2226; + SWord8 s2227; + SWord8 s2228; + SWord8 s2229; + SWord8 s2230; + SWord8 s2231; + SWord8 s2232; + SWord8 s2233; + SWord8 s2234; + SWord8 s2235; + SWord8 s2236; + SWord8 s2237; + SWord8 s2238; + SWord8 s2239; + SWord16 s2240; + SWord8 s2241; + SWord8 s2242; + SWord8 s2243; + SWord8 s2244; + SWord8 s2245; + SWord8 s2246; + SWord8 s2247; + SWord8 s2248; + SWord8 s2249; + SWord8 s2250; + SWord8 s2251; + SWord8 s2252; + SWord8 s2253; + SWord8 s2254; + SWord16 s2255; + SWord32 s2256; + SWord32 s2257; + SWord8 s2258; + SWord32 s2259; + SWord8 s2260; + SWord32 s2261; + SWord8 s2262; + SWord32 s2263; + SWord32 s2264; + SWord8 s2265; + SWord32 s2266; + SWord32 s2267; + SWord8 s2268; + SWord32 s2269; + SWord32 s2270; + SWord8 s2271; + SWord8 s2272; + SWord8 s2273; + SWord8 s2274; + SWord8 s2275; + SWord8 s2276; + SWord8 s2277; + SWord8 s2278; + SWord8 s2279; + SWord8 s2280; + SWord8 s2281; + SWord8 s2282; + SWord8 s2283; + SWord8 s2284; + SWord8 s2285; + SWord8 s2286; + SWord8 s2287; + SWord8 s2288; + SWord16 s2289; + SWord8 s2290; + SWord8 s2291; + SWord8 s2292; + SWord8 s2293; + SWord8 s2294; + SWord8 s2295; + SWord8 s2296; + SWord8 s2297; + SWord8 s2298; + SWord8 s2299; + SWord8 s2300; + SWord8 s2301; + SWord8 s2302; + SWord8 s2303; + SWord16 s2304; + SWord32 s2305; + SWord32 s2306; + SWord8 s2307; + SWord32 s2308; + SWord32 s2309; + SWord8 s2310; + SWord32 s2311; + SWord8 s2312; + SWord32 s2313; + SWord32 s2314; + SWord8 s2315; + SWord32 s2316; + SWord32 s2317; + SWord8 s2318; + SWord32 s2319; + SWord32 s2320; + SWord8 s2321; + SWord8 s2322; + SWord8 s2323; + SWord8 s2324; + SWord8 s2325; + SWord8 s2326; + SWord8 s2327; + SWord8 s2328; + SWord8 s2329; + SWord8 s2330; + SWord8 s2331; + SWord8 s2332; + SWord8 s2333; + SWord8 s2334; + SWord8 s2335; + SWord8 s2336; + SWord8 s2337; + SWord8 s2338; + SWord16 s2339; + SWord8 s2340; + SWord8 s2341; + SWord8 s2342; + SWord8 s2343; + SWord8 s2344; + SWord8 s2345; + SWord8 s2346; + SWord8 s2347; + SWord8 s2348; + SWord8 s2349; + SWord8 s2350; + SWord8 s2351; + SWord8 s2352; + SWord8 s2353; + SWord16 s2354; + SWord32 s2355; + SWord32 s2356; + SWord8 s2357; + SWord32 s2358; + SWord32 s2359; + SWord8 s2360; + SWord32 s2361; + SWord8 s2362; + SWord32 s2363; + SWord32 s2364; + SWord8 s2365; + SWord32 s2366; + SWord32 s2367; + SWord8 s2368; + SWord32 s2369; + SWord32 s2370; + SWord8 s2371; + SWord8 s2372; + SWord8 s2373; + SWord8 s2374; + SWord8 s2375; + SWord8 s2376; + SWord8 s2377; + SWord8 s2378; + SWord8 s2379; + SWord8 s2380; + SWord8 s2381; + SWord8 s2382; + SWord8 s2383; + SWord8 s2384; + SWord8 s2385; + SWord8 s2386; + SWord8 s2387; + SWord8 s2388; + SWord16 s2389; + SWord8 s2390; + SWord8 s2391; + SWord8 s2392; + SWord8 s2393; + SWord8 s2394; + SWord8 s2395; + SWord8 s2396; + SWord8 s2397; + SWord8 s2398; + SWord8 s2399; + SWord8 s2400; + SWord8 s2401; + SWord8 s2402; + SWord8 s2403; + SWord16 s2404; + SWord32 s2405; + SWord32 s2406; + SWord8 s2407; + SWord32 s2408; + SWord32 s2409; + SWord8 s2410; + SWord8 s2411; + SWord8 s2412; + SWord8 s2413; + SWord8 s2414; + SWord8 s2415; + SWord8 s2416; + SWord8 s2417; + SWord8 s2418; + SWord8 s2419; + SWord8 s2420; + SWord8 s2421; + SWord8 s2422; + SWord8 s2423; + SWord8 s2424; + SWord8 s2425; + SWord8 s2426; + SWord8 s2427; + SWord16 s2428; + SWord8 s2429; + SWord8 s2430; + SWord8 s2431; + SWord8 s2432; + SWord8 s2433; + SWord8 s2434; + SWord8 s2435; + SWord8 s2436; + SWord8 s2437; + SWord8 s2438; + SWord8 s2439; + SWord8 s2440; + SWord8 s2441; + SWord8 s2442; + SWord16 s2443; + SWord32 s2444; + SWord32 s2445; + SWord8 s2446; + SWord32 s2447; + SWord8 s2448; + SWord32 s2449; + SWord8 s2450; + SWord32 s2451; + SWord32 s2452; + SWord8 s2453; + SWord32 s2454; + SWord32 s2455; + SWord8 s2456; + SWord32 s2457; + SWord32 s2458; + SWord8 s2459; + SWord8 s2460; + SWord8 s2461; + SWord8 s2462; + SWord8 s2463; + SWord8 s2464; + SWord8 s2465; + SWord8 s2466; + SWord8 s2467; + SWord8 s2468; + SWord8 s2469; + SWord8 s2470; + SWord8 s2471; + SWord8 s2472; + SWord8 s2473; + SWord8 s2474; + SWord8 s2475; + SWord8 s2476; + SWord16 s2477; + SWord8 s2478; + SWord8 s2479; + SWord8 s2480; + SWord8 s2481; + SWord8 s2482; + SWord8 s2483; + SWord8 s2484; + SWord8 s2485; + SWord8 s2486; + SWord8 s2487; + SWord8 s2488; + SWord8 s2489; + SWord8 s2490; + SWord8 s2491; + SWord16 s2492; + SWord32 s2493; + SWord32 s2494; + SWord8 s2495; + SWord32 s2496; + SWord32 s2497; + SWord8 s2498; + SWord32 s2499; + SWord8 s2500; + SWord32 s2501; + SWord32 s2502; + SWord8 s2503; + SWord32 s2504; + SWord32 s2505; + SWord8 s2506; + SWord32 s2507; + SWord32 s2508; + SWord8 s2509; + SWord8 s2510; + SWord8 s2511; + SWord8 s2512; + SWord8 s2513; + SWord8 s2514; + SWord8 s2515; + SWord8 s2516; + SWord8 s2517; + SWord8 s2518; + SWord8 s2519; + SWord8 s2520; + SWord8 s2521; + SWord8 s2522; + SWord8 s2523; + SWord8 s2524; + SWord8 s2525; + SWord8 s2526; + SWord16 s2527; + SWord8 s2528; + SWord8 s2529; + SWord8 s2530; + SWord8 s2531; + SWord8 s2532; + SWord8 s2533; + SWord8 s2534; + SWord8 s2535; + SWord8 s2536; + SWord8 s2537; + SWord8 s2538; + SWord8 s2539; + SWord8 s2540; + SWord8 s2541; + SWord16 s2542; + SWord32 s2543; + SWord32 s2544; + SWord8 s2545; + SWord32 s2546; + SWord32 s2547; + SWord8 s2548; + SWord32 s2549; + SWord8 s2550; + SWord32 s2551; + SWord32 s2552; + SWord8 s2553; + SWord32 s2554; + SWord32 s2555; + SWord8 s2556; + SWord32 s2557; + SWord32 s2558; + SWord8 s2559; + SWord8 s2560; + SWord8 s2561; + SWord8 s2562; + SWord8 s2563; + SWord8 s2564; + SWord8 s2565; + SWord8 s2566; + SWord8 s2567; + SWord8 s2568; + SWord8 s2569; + SWord8 s2570; + SWord8 s2571; + SWord8 s2572; + SWord8 s2573; + SWord8 s2574; + SWord8 s2575; + SWord8 s2576; + SWord16 s2577; + SWord8 s2578; + SWord8 s2579; + SWord8 s2580; + SWord8 s2581; + SWord8 s2582; + SWord8 s2583; + SWord8 s2584; + SWord8 s2585; + SWord8 s2586; + SWord8 s2587; + SWord8 s2588; + SWord8 s2589; + SWord8 s2590; + SWord8 s2591; + SWord16 s2592; + SWord32 s2593; + SWord32 s2594; + SWord8 s2595; + SWord32 s2596; + SWord32 s2597; + SWord8 s2598; + SWord8 s2599; + SWord8 s2600; + SWord8 s2601; + SWord8 s2602; + SWord8 s2603; + SWord8 s2604; + SWord8 s2605; + SWord8 s2606; + SWord8 s2607; + SWord8 s2608; + SWord8 s2609; + SWord8 s2610; + SWord8 s2611; + SWord8 s2612; + SWord8 s2613; + SWord8 s2614; + SWord8 s2615; + SWord16 s2616; + SWord8 s2617; + SWord8 s2618; + SWord8 s2619; + SWord8 s2620; + SWord8 s2621; + SWord8 s2622; + SWord8 s2623; + SWord8 s2624; + SWord8 s2625; + SWord8 s2626; + SWord8 s2627; + SWord8 s2628; + SWord8 s2629; + SWord8 s2630; + SWord16 s2631; + SWord32 s2632; + SWord32 s2633; + SWord8 s2634; + SWord32 s2635; + SWord8 s2636; + SWord32 s2637; + SWord8 s2638; + SWord32 s2639; + SWord32 s2640; + SWord8 s2641; + SWord32 s2642; + SWord32 s2643; + SWord8 s2644; + SWord32 s2645; + SWord32 s2646; + SWord8 s2647; + SWord8 s2648; + SWord8 s2649; + SWord8 s2650; + SWord8 s2651; + SWord8 s2652; + SWord8 s2653; + SWord8 s2654; + SWord8 s2655; + SWord8 s2656; + SWord8 s2657; + SWord8 s2658; + SWord8 s2659; + SWord8 s2660; + SWord8 s2661; + SWord8 s2662; + SWord8 s2663; + SWord8 s2664; + SWord16 s2665; + SWord8 s2666; + SWord8 s2667; + SWord8 s2668; + SWord8 s2669; + SWord8 s2670; + SWord8 s2671; + SWord8 s2672; + SWord8 s2673; + SWord8 s2674; + SWord8 s2675; + SWord8 s2676; + SWord8 s2677; + SWord8 s2678; + SWord8 s2679; + SWord16 s2680; + SWord32 s2681; + SWord32 s2682; + SWord8 s2683; + SWord32 s2684; + SWord32 s2685; + SWord8 s2686; + SWord32 s2687; + SWord8 s2688; + SWord32 s2689; + SWord32 s2690; + SWord8 s2691; + SWord32 s2692; + SWord32 s2693; + SWord8 s2694; + SWord32 s2695; + SWord32 s2696; + SWord8 s2697; + SWord8 s2698; + SWord8 s2699; + SWord8 s2700; + SWord8 s2701; + SWord8 s2702; + SWord8 s2703; + SWord8 s2704; + SWord8 s2705; + SWord8 s2706; + SWord8 s2707; + SWord8 s2708; + SWord8 s2709; + SWord8 s2710; + SWord8 s2711; + SWord8 s2712; + SWord8 s2713; + SWord8 s2714; + SWord16 s2715; + SWord8 s2716; + SWord8 s2717; + SWord8 s2718; + SWord8 s2719; + SWord8 s2720; + SWord8 s2721; + SWord8 s2722; + SWord8 s2723; + SWord8 s2724; + SWord8 s2725; + SWord8 s2726; + SWord8 s2727; + SWord8 s2728; + SWord8 s2729; + SWord16 s2730; + SWord32 s2731; + SWord32 s2732; + SWord8 s2733; + SWord32 s2734; + SWord32 s2735; + SWord8 s2736; + SWord32 s2737; + SWord8 s2738; + SWord32 s2739; + SWord32 s2740; + SWord8 s2741; + SWord32 s2742; + SWord32 s2743; + SWord8 s2744; + SWord32 s2745; + SWord32 s2746; + SWord8 s2747; + SWord8 s2748; + SWord8 s2749; + SWord8 s2750; + SWord8 s2751; + SWord8 s2752; + SWord8 s2753; + SWord8 s2754; + SWord8 s2755; + SWord8 s2756; + SWord8 s2757; + SWord8 s2758; + SWord8 s2759; + SWord8 s2760; + SWord8 s2761; + SWord8 s2762; + SWord8 s2763; + SWord8 s2764; + SWord16 s2765; + SWord8 s2766; + SWord8 s2767; + SWord8 s2768; + SWord8 s2769; + SWord8 s2770; + SWord8 s2771; + SWord8 s2772; + SWord8 s2773; + SWord8 s2774; + SWord8 s2775; + SWord8 s2776; + SWord8 s2777; + SWord8 s2778; + SWord8 s2779; + SWord16 s2780; + SWord32 s2781; + SWord32 s2782; + SWord8 s2783; + SWord32 s2784; + SWord32 s2785; + SWord8 s2786; + SWord8 s2787; + SWord8 s2788; + SWord8 s2789; + SWord8 s2790; + SWord8 s2791; + SWord8 s2792; + SWord8 s2793; + SWord8 s2794; + SWord8 s2795; + SWord8 s2796; + SWord8 s2797; + SWord8 s2798; + SWord8 s2799; + SWord8 s2800; + SWord8 s2801; + SWord8 s2802; + SWord8 s2803; + SWord16 s2804; + SWord8 s2805; + SWord8 s2806; + SWord8 s2807; + SWord8 s2808; + SWord8 s2809; + SWord8 s2810; + SWord8 s2811; + SWord8 s2812; + SWord8 s2813; + SWord8 s2814; + SWord8 s2815; + SWord8 s2816; + SWord8 s2817; + SWord8 s2818; + SWord16 s2819; + SWord32 s2820; + SWord32 s2821; + SWord8 s2822; + SWord32 s2823; + SWord8 s2824; + SWord32 s2825; + SWord8 s2826; + SWord32 s2827; + SWord32 s2828; + SWord8 s2829; + SWord32 s2830; + SWord32 s2831; + SWord8 s2832; + SWord32 s2833; + SWord32 s2834; + SWord8 s2835; + SWord8 s2836; + SWord8 s2837; + SWord8 s2838; + SWord8 s2839; + SWord8 s2840; + SWord8 s2841; + SWord8 s2842; + SWord8 s2843; + SWord8 s2844; + SWord8 s2845; + SWord8 s2846; + SWord8 s2847; + SWord8 s2848; + SWord8 s2849; + SWord8 s2850; + SWord8 s2851; + SWord8 s2852; + SWord16 s2853; + SWord8 s2854; + SWord8 s2855; + SWord8 s2856; + SWord8 s2857; + SWord8 s2858; + SWord8 s2859; + SWord8 s2860; + SWord8 s2861; + SWord8 s2862; + SWord8 s2863; + SWord8 s2864; + SWord8 s2865; + SWord8 s2866; + SWord8 s2867; + SWord16 s2868; + SWord32 s2869; + SWord32 s2870; + SWord8 s2871; + SWord32 s2872; + SWord32 s2873; + SWord8 s2874; + SWord32 s2875; + SWord8 s2876; + SWord32 s2877; + SWord32 s2878; + SWord8 s2879; + SWord32 s2880; + SWord32 s2881; + SWord8 s2882; + SWord32 s2883; + SWord32 s2884; + SWord8 s2885; + SWord8 s2886; + SWord8 s2887; + SWord8 s2888; + SWord8 s2889; + SWord8 s2890; + SWord8 s2891; + SWord8 s2892; + SWord8 s2893; + SWord8 s2894; + SWord8 s2895; + SWord8 s2896; + SWord8 s2897; + SWord8 s2898; + SWord8 s2899; + SWord8 s2900; + SWord8 s2901; + SWord8 s2902; + SWord16 s2903; + SWord8 s2904; + SWord8 s2905; + SWord8 s2906; + SWord8 s2907; + SWord8 s2908; + SWord8 s2909; + SWord8 s2910; + SWord8 s2911; + SWord8 s2912; + SWord8 s2913; + SWord8 s2914; + SWord8 s2915; + SWord8 s2916; + SWord8 s2917; + SWord16 s2918; + SWord32 s2919; + SWord32 s2920; + SWord8 s2921; + SWord32 s2922; + SWord32 s2923; + SWord8 s2924; + SWord32 s2925; + SWord8 s2926; + SWord32 s2927; + SWord32 s2928; + SWord8 s2929; + SWord32 s2930; + SWord32 s2931; + SWord8 s2932; + SWord32 s2933; + SWord32 s2934; + SWord8 s2935; + SWord8 s2936; + SWord8 s2937; + SWord8 s2938; + SWord8 s2939; + SWord8 s2940; + SWord8 s2941; + SWord8 s2942; + SWord8 s2943; + SWord8 s2944; + SWord8 s2945; + SWord8 s2946; + SWord8 s2947; + SWord8 s2948; + SWord8 s2949; + SWord8 s2950; + SWord8 s2951; + SWord8 s2952; + SWord16 s2953; + SWord8 s2954; + SWord8 s2955; + SWord8 s2956; + SWord8 s2957; + SWord8 s2958; + SWord8 s2959; + SWord8 s2960; + SWord8 s2961; + SWord8 s2962; + SWord8 s2963; + SWord8 s2964; + SWord8 s2965; + SWord8 s2966; + SWord8 s2967; + SWord16 s2968; + SWord32 s2969; + SWord32 s2970; + SWord8 s2971; + SWord32 s2972; + SWord32 s2973; + SWord8 s2974; + SWord8 s2975; + SWord8 s2976; + SWord8 s2977; + SWord8 s2978; + SWord8 s2979; + SWord8 s2980; + SWord8 s2981; + SWord8 s2982; + SWord8 s2983; + SWord8 s2984; + SWord8 s2985; + SWord8 s2986; + SWord8 s2987; + SWord8 s2988; + SWord8 s2989; + SWord8 s2990; + SWord8 s2991; + SWord16 s2992; + SWord8 s2993; + SWord8 s2994; + SWord8 s2995; + SWord8 s2996; + SWord8 s2997; + SWord8 s2998; + SWord8 s2999; + SWord8 s3000; + SWord8 s3001; + SWord8 s3002; + SWord8 s3003; + SWord8 s3004; + SWord8 s3005; + SWord8 s3006; + SWord16 s3007; + SWord32 s3008; + SWord32 s3009; + SWord8 s3010; + SWord8 s3011; + SWord8 s3012; + SWord32 s3013; + SWord8 s3014; + SWord32 s3015; + SWord32 s3016; + SWord8 s3017; + SWord32 s3018; + SWord32 s3019; + SWord8 s3020; + SWord32 s3021; + SWord32 s3022; + SWord8 s3023; + SWord8 s3024; + SWord8 s3025; + SWord8 s3026; + SWord8 s3027; + SWord8 s3028; + SWord8 s3029; + SWord8 s3030; + SWord8 s3031; + SWord8 s3032; + SWord8 s3033; + SWord8 s3034; + SWord8 s3035; + SWord8 s3036; + SWord8 s3037; + SWord8 s3038; + SWord8 s3039; + SWord8 s3040; + SWord16 s3041; + SWord8 s3042; + SWord8 s3043; + SWord8 s3044; + SWord8 s3045; + SWord8 s3046; + SWord8 s3047; + SWord8 s3048; + SWord8 s3049; + SWord8 s3050; + SWord8 s3051; + SWord8 s3052; + SWord8 s3053; + SWord8 s3054; + SWord8 s3055; + SWord16 s3056; + SWord32 s3057; + SWord32 s3058; + SWord8 s3059; + SWord8 s3060; + SWord16 s3061; + SWord8 s3062; + SWord32 s3063; + SWord8 s3064; + SWord32 s3065; + SWord32 s3066; + SWord8 s3067; + SWord32 s3068; + SWord32 s3069; + SWord8 s3070; + SWord32 s3071; + SWord32 s3072; + SWord8 s3073; + SWord8 s3074; + SWord8 s3075; + SWord8 s3076; + SWord8 s3077; + SWord8 s3078; + SWord8 s3079; + SWord8 s3080; + SWord8 s3081; + SWord8 s3082; + SWord8 s3083; + SWord8 s3084; + SWord8 s3085; + SWord8 s3086; + SWord8 s3087; + SWord8 s3088; + SWord8 s3089; + SWord8 s3090; + SWord16 s3091; + SWord8 s3092; + SWord8 s3093; + SWord8 s3094; + SWord8 s3095; + SWord8 s3096; + SWord8 s3097; + SWord8 s3098; + SWord8 s3099; + SWord8 s3100; + SWord8 s3101; + SWord8 s3102; + SWord8 s3103; + SWord8 s3104; + SWord8 s3105; + SWord16 s3106; + SWord32 s3107; + SWord32 s3108; + SWord8 s3109; + SWord8 s3110; + SWord8 s3111; + SWord32 s3112; + SWord8 s3113; + SWord32 s3114; + SWord32 s3115; + SWord8 s3116; + SWord32 s3117; + SWord32 s3118; + SWord8 s3119; + SWord32 s3120; + SWord32 s3121; + SWord8 s3122; + SWord8 s3123; + SWord8 s3124; + SWord8 s3125; + SWord8 s3126; + SWord8 s3127; + SWord8 s3128; + SWord8 s3129; + SWord8 s3130; + SWord8 s3131; + SWord8 s3132; + SWord8 s3133; + SWord8 s3134; + SWord8 s3135; + SWord8 s3136; + SWord8 s3137; + SWord8 s3138; + SWord8 s3139; + SWord16 s3140; + SWord8 s3141; + SWord8 s3142; + SWord8 s3143; + SWord8 s3144; + SWord8 s3145; + SWord8 s3146; + SWord8 s3147; + SWord8 s3148; + SWord8 s3149; + SWord8 s3150; + SWord8 s3151; + SWord8 s3152; + SWord8 s3153; + SWord8 s3154; + SWord16 s3155; + SWord32 s3156; + SWord32 s3157; + SWord8 s3158; + SWord8 s3159; + SWord16 s3160; + SWord32 s3161; + SWord32 s3162; + SWord8 s3163; + SWord8 s3164; + SWord8 s3165; + SWord8 s3166; + SWord16 s3167; + SWord8 s3168; + SWord8 s3169; + SWord8 s3170; + SWord8 s3171; + SWord16 s3172; + SWord32 s3173; + SWord32 s3174; + SWord8 s3175; + SWord8 s3176; + SWord8 s3177; + SWord8 s3178; + SWord16 s3179; + SWord8 s3180; + SWord8 s3181; + SWord8 s3182; + SWord8 s3183; + SWord16 s3184; + SWord32 s3185; + SWord32 s3186; + SWord8 s3187; + SWord8 s3188; + SWord8 s3189; + SWord8 s3190; + SWord16 s3191; + SWord8 s3192; + SWord8 s3193; + SWord8 s3194; + SWord8 s3195; + SWord16 s3196; + SWord32 s3197; + SWord32 s3198; + 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 + }; + s522 = table2[s521]; + s523 = 1 ^ s522; + s525 = table2[s524]; + s526 = sbv_bv_join_u8_u8_u16(s523, s525); + s528 = table2[s527]; + s530 = table2[s529]; + s531 = sbv_bv_join_u8_u8_u16(s528, s530); + s532 = sbv_bv_join_u16_u16_u32(s526, s531); + s533 = s4 ^ s532; + s534 = s5 ^ s533; + s535 = s6 ^ s534; + s536 = s7 ^ s535; + s537 = sbv_bv_u32_rotl(s536, 8); + s538 = sbv_bv_extract_u32_31_24_u8(s537); + s539 = table2[s538]; + s540 = 2 ^ s539; + s541 = sbv_bv_extract_u32_23_16_u8(s537); + s542 = table2[s541]; + s543 = sbv_bv_join_u8_u8_u16(s540, s542); + s544 = sbv_bv_extract_u32_15_8_u8(s537); + s545 = table2[s544]; + s546 = sbv_bv_extract_u32_7_0_u8(s537); + s547 = table2[s546]; + s548 = sbv_bv_join_u8_u8_u16(s545, s547); + s549 = sbv_bv_join_u16_u16_u32(s543, s548); + s550 = s533 ^ s549; + s551 = s534 ^ s550; + s552 = s535 ^ s551; + s553 = s536 ^ s552; + s554 = sbv_bv_u32_rotl(s553, 8); + s555 = sbv_bv_extract_u32_31_24_u8(s554); + s556 = table2[s555]; + s557 = 4 ^ s556; + s558 = sbv_bv_extract_u32_23_16_u8(s554); + s559 = table2[s558]; + s560 = sbv_bv_join_u8_u8_u16(s557, s559); + s561 = sbv_bv_extract_u32_15_8_u8(s554); + s562 = table2[s561]; + s563 = sbv_bv_extract_u32_7_0_u8(s554); + s564 = table2[s563]; + s565 = sbv_bv_join_u8_u8_u16(s562, s564); + s566 = sbv_bv_join_u16_u16_u32(s560, s565); + s567 = s550 ^ s566; + s568 = s551 ^ s567; + s569 = s552 ^ s568; + s570 = s553 ^ s569; + s571 = sbv_bv_u32_rotl(s570, 8); + s572 = sbv_bv_extract_u32_31_24_u8(s571); + s573 = table2[s572]; + s574 = 8 ^ s573; + s575 = sbv_bv_extract_u32_23_16_u8(s571); + s576 = table2[s575]; + s577 = sbv_bv_join_u8_u8_u16(s574, s576); + s578 = sbv_bv_extract_u32_15_8_u8(s571); + s579 = table2[s578]; + s580 = sbv_bv_extract_u32_7_0_u8(s571); + s581 = table2[s580]; + s582 = sbv_bv_join_u8_u8_u16(s579, s581); + s583 = sbv_bv_join_u16_u16_u32(s577, s582); + s584 = s567 ^ s583; + s585 = s568 ^ s584; + s586 = s569 ^ s585; + s587 = s570 ^ s586; + s588 = sbv_bv_u32_rotl(s587, 8); + s589 = sbv_bv_extract_u32_31_24_u8(s588); + s590 = table2[s589]; + s591 = 16 ^ s590; + s592 = sbv_bv_extract_u32_23_16_u8(s588); + s593 = table2[s592]; + s594 = sbv_bv_join_u8_u8_u16(s591, s593); + s595 = sbv_bv_extract_u32_15_8_u8(s588); + s596 = table2[s595]; + s597 = sbv_bv_extract_u32_7_0_u8(s588); + s598 = table2[s597]; + s599 = sbv_bv_join_u8_u8_u16(s596, s598); + s600 = sbv_bv_join_u16_u16_u32(s594, s599); + s601 = s584 ^ s600; + s602 = s585 ^ s601; + s603 = s586 ^ s602; + s604 = s587 ^ s603; + s605 = sbv_bv_u32_rotl(s604, 8); + s606 = sbv_bv_extract_u32_31_24_u8(s605); + s607 = table2[s606]; + s608 = 32 ^ s607; + s609 = sbv_bv_extract_u32_23_16_u8(s605); + s610 = table2[s609]; + s611 = sbv_bv_join_u8_u8_u16(s608, s610); + s612 = sbv_bv_extract_u32_15_8_u8(s605); + s613 = table2[s612]; + s614 = sbv_bv_extract_u32_7_0_u8(s605); + s615 = table2[s614]; + s616 = sbv_bv_join_u8_u8_u16(s613, s615); + s617 = sbv_bv_join_u16_u16_u32(s611, s616); + s618 = s601 ^ s617; + s619 = s602 ^ s618; + s620 = s603 ^ s619; + s621 = s604 ^ s620; + s622 = sbv_bv_u32_rotl(s621, 8); + s623 = sbv_bv_extract_u32_31_24_u8(s622); + s624 = table2[s623]; + s625 = 64 ^ s624; + s626 = sbv_bv_extract_u32_23_16_u8(s622); + s627 = table2[s626]; + s628 = sbv_bv_join_u8_u8_u16(s625, s627); + s629 = sbv_bv_extract_u32_15_8_u8(s622); + s630 = table2[s629]; + s631 = sbv_bv_extract_u32_7_0_u8(s622); + s632 = table2[s631]; + s633 = sbv_bv_join_u8_u8_u16(s630, s632); + s634 = sbv_bv_join_u16_u16_u32(s628, s633); + s635 = s618 ^ s634; + s636 = s619 ^ s635; + s637 = s620 ^ s636; + s638 = s621 ^ s637; + s639 = sbv_bv_u32_rotl(s638, 8); + s640 = sbv_bv_extract_u32_31_24_u8(s639); + s641 = table2[s640]; + s642 = 128 ^ s641; + s643 = sbv_bv_extract_u32_23_16_u8(s639); + s644 = table2[s643]; + s645 = sbv_bv_join_u8_u8_u16(s642, s644); + s646 = sbv_bv_extract_u32_15_8_u8(s639); + s647 = table2[s646]; + s648 = sbv_bv_extract_u32_7_0_u8(s639); + s649 = table2[s648]; + s650 = sbv_bv_join_u8_u8_u16(s647, s649); + s651 = sbv_bv_join_u16_u16_u32(s645, s650); + s652 = s635 ^ s651; + s653 = s636 ^ s652; + s654 = s637 ^ s653; + s655 = s638 ^ s654; + s656 = sbv_bv_u32_rotl(s655, 8); + s657 = sbv_bv_extract_u32_31_24_u8(s656); + s658 = table2[s657]; + s659 = 27 ^ s658; + s660 = sbv_bv_extract_u32_23_16_u8(s656); + s661 = table2[s660]; + s662 = sbv_bv_join_u8_u8_u16(s659, s661); + s663 = sbv_bv_extract_u32_15_8_u8(s656); + s664 = table2[s663]; + s665 = sbv_bv_extract_u32_7_0_u8(s656); + s666 = table2[s665]; + s667 = sbv_bv_join_u8_u8_u16(s664, s666); + s668 = sbv_bv_join_u16_u16_u32(s662, s667); + s669 = s652 ^ s668; + s670 = s653 ^ s669; + s671 = s654 ^ s670; + s672 = s655 ^ s671; + s673 = sbv_bv_u32_rotl(s672, 8); + s674 = sbv_bv_extract_u32_31_24_u8(s673); + s675 = table2[s674]; + s676 = 54 ^ s675; + s677 = sbv_bv_extract_u32_23_16_u8(s673); + s678 = table2[s677]; + s679 = sbv_bv_join_u8_u8_u16(s676, s678); + s680 = sbv_bv_extract_u32_15_8_u8(s673); + s681 = table2[s680]; + s682 = sbv_bv_extract_u32_7_0_u8(s673); + s683 = table2[s682]; + s684 = sbv_bv_join_u8_u8_u16(s681, s683); + s685 = sbv_bv_join_u16_u16_u32(s679, s684); + s686 = s669 ^ s685; + s687 = s0 ^ s686; + s688 = sbv_bv_extract_u32_31_24_u8(s687); + 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 + }; + s689 = table1[s688]; + s945 = s670 ^ s686; + s946 = s671 ^ s945; + s947 = s672 ^ s946; + s948 = s3 ^ s947; + s949 = sbv_bv_extract_u32_23_16_u8(s948); + 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 + }; + s950 = table3[s949]; + s951 = s689 ^ s950; + s1207 = s2 ^ s946; + s1208 = sbv_bv_extract_u32_15_8_u8(s1207); + 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 + }; + s1209 = table4[s1208]; + s1210 = s951 ^ s1209; + s1466 = s1 ^ s945; + s1467 = sbv_bv_extract_u32_7_0_u8(s1466); + 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 + }; + s1468 = table5[s1467]; + s1469 = s1210 ^ s1468; + s1470 = sbv_bv_extract_u32_31_24_u8(s669); + 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 + }; + s1471 = table6[s1470]; + s1472 = sbv_bv_extract_u32_23_16_u8(s669); + 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 + }; + s1473 = table7[s1472]; + s1474 = sbv_bv_extract_u32_15_8_u8(s669); + 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 + }; + s1475 = table8[s1474]; + s1476 = sbv_bv_extract_u32_7_0_u8(s669); + 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 + }; + s1477 = table9[s1476]; + s1478 = s1475 ^ s1477; + s1479 = s1473 ^ s1478; + s1480 = s1471 ^ s1479; + s1481 = table9[s1470]; + s1482 = table6[s1472]; + s1483 = table7[s1474]; + s1484 = table8[s1476]; + s1485 = s1483 ^ s1484; + s1486 = s1482 ^ s1485; + s1487 = s1481 ^ s1486; + s1488 = sbv_bv_join_u8_u8_u16(s1480, s1487); + s1489 = table8[s1470]; + s1490 = table9[s1472]; + s1491 = table6[s1474]; + s1492 = table7[s1476]; + s1493 = s1491 ^ s1492; + s1494 = s1490 ^ s1493; + s1495 = s1489 ^ s1494; + s1496 = table7[s1470]; + s1497 = table8[s1472]; + s1498 = table9[s1474]; + s1499 = table6[s1476]; + s1500 = s1498 ^ s1499; + s1501 = s1497 ^ s1500; + s1502 = s1496 ^ s1501; + s1503 = sbv_bv_join_u8_u8_u16(s1495, s1502); + s1504 = sbv_bv_join_u16_u16_u32(s1488, s1503); + s1505 = s1469 ^ s1504; + s1506 = sbv_bv_extract_u32_31_24_u8(s1505); + s1507 = table1[s1506]; + s1508 = sbv_bv_extract_u32_31_24_u8(s948); + s1509 = table1[s1508]; + s1510 = sbv_bv_extract_u32_23_16_u8(s1207); + s1511 = table3[s1510]; + s1512 = s1509 ^ s1511; + s1513 = sbv_bv_extract_u32_15_8_u8(s1466); + s1514 = table4[s1513]; + s1515 = s1512 ^ s1514; + s1516 = sbv_bv_extract_u32_7_0_u8(s687); + s1517 = table5[s1516]; + s1518 = s1515 ^ s1517; + s1519 = sbv_bv_extract_u32_31_24_u8(s672); + s1520 = table6[s1519]; + s1521 = sbv_bv_extract_u32_23_16_u8(s672); + s1522 = table7[s1521]; + s1523 = sbv_bv_extract_u32_15_8_u8(s672); + s1524 = table8[s1523]; + s1525 = sbv_bv_extract_u32_7_0_u8(s672); + s1526 = table9[s1525]; + s1527 = s1524 ^ s1526; + s1528 = s1522 ^ s1527; + s1529 = s1520 ^ s1528; + s1530 = table9[s1519]; + s1531 = table6[s1521]; + s1532 = table7[s1523]; + s1533 = table8[s1525]; + s1534 = s1532 ^ s1533; + s1535 = s1531 ^ s1534; + s1536 = s1530 ^ s1535; + s1537 = sbv_bv_join_u8_u8_u16(s1529, s1536); + s1538 = table8[s1519]; + s1539 = table9[s1521]; + s1540 = table6[s1523]; + s1541 = table7[s1525]; + s1542 = s1540 ^ s1541; + s1543 = s1539 ^ s1542; + s1544 = s1538 ^ s1543; + s1545 = table7[s1519]; + s1546 = table8[s1521]; + s1547 = table9[s1523]; + s1548 = table6[s1525]; + s1549 = s1547 ^ s1548; + s1550 = s1546 ^ s1549; + s1551 = s1545 ^ s1550; + s1552 = sbv_bv_join_u8_u8_u16(s1544, s1551); + s1553 = sbv_bv_join_u16_u16_u32(s1537, s1552); + s1554 = s1518 ^ s1553; + s1555 = sbv_bv_extract_u32_23_16_u8(s1554); + s1556 = table3[s1555]; + s1557 = s1507 ^ s1556; + s1558 = sbv_bv_extract_u32_31_24_u8(s1207); + s1559 = table1[s1558]; + s1560 = sbv_bv_extract_u32_23_16_u8(s1466); + s1561 = table3[s1560]; + s1562 = s1559 ^ s1561; + s1563 = sbv_bv_extract_u32_15_8_u8(s687); + s1564 = table4[s1563]; + s1565 = s1562 ^ s1564; + s1566 = sbv_bv_extract_u32_7_0_u8(s948); + s1567 = table5[s1566]; + s1568 = s1565 ^ s1567; + s1569 = sbv_bv_extract_u32_31_24_u8(s671); + s1570 = table6[s1569]; + s1571 = sbv_bv_extract_u32_23_16_u8(s671); + s1572 = table7[s1571]; + s1573 = sbv_bv_extract_u32_15_8_u8(s671); + s1574 = table8[s1573]; + s1575 = sbv_bv_extract_u32_7_0_u8(s671); + s1576 = table9[s1575]; + s1577 = s1574 ^ s1576; + s1578 = s1572 ^ s1577; + s1579 = s1570 ^ s1578; + s1580 = table9[s1569]; + s1581 = table6[s1571]; + s1582 = table7[s1573]; + s1583 = table8[s1575]; + s1584 = s1582 ^ s1583; + s1585 = s1581 ^ s1584; + s1586 = s1580 ^ s1585; + s1587 = sbv_bv_join_u8_u8_u16(s1579, s1586); + s1588 = table8[s1569]; + s1589 = table9[s1571]; + s1590 = table6[s1573]; + s1591 = table7[s1575]; + s1592 = s1590 ^ s1591; + s1593 = s1589 ^ s1592; + s1594 = s1588 ^ s1593; + s1595 = table7[s1569]; + s1596 = table8[s1571]; + s1597 = table9[s1573]; + s1598 = table6[s1575]; + s1599 = s1597 ^ s1598; + s1600 = s1596 ^ s1599; + s1601 = s1595 ^ s1600; + s1602 = sbv_bv_join_u8_u8_u16(s1594, s1601); + s1603 = sbv_bv_join_u16_u16_u32(s1587, s1602); + s1604 = s1568 ^ s1603; + s1605 = sbv_bv_extract_u32_15_8_u8(s1604); + s1606 = table4[s1605]; + s1607 = s1557 ^ s1606; + s1608 = sbv_bv_extract_u32_31_24_u8(s1466); + s1609 = table1[s1608]; + s1610 = sbv_bv_extract_u32_23_16_u8(s687); + s1611 = table3[s1610]; + s1612 = s1609 ^ s1611; + s1613 = sbv_bv_extract_u32_15_8_u8(s948); + s1614 = table4[s1613]; + s1615 = s1612 ^ s1614; + s1616 = sbv_bv_extract_u32_7_0_u8(s1207); + s1617 = table5[s1616]; + s1618 = s1615 ^ s1617; + s1619 = sbv_bv_extract_u32_31_24_u8(s670); + s1620 = table6[s1619]; + s1621 = sbv_bv_extract_u32_23_16_u8(s670); + s1622 = table7[s1621]; + s1623 = sbv_bv_extract_u32_15_8_u8(s670); + s1624 = table8[s1623]; + s1625 = sbv_bv_extract_u32_7_0_u8(s670); + s1626 = table9[s1625]; + s1627 = s1624 ^ s1626; + s1628 = s1622 ^ s1627; + s1629 = s1620 ^ s1628; + s1630 = table9[s1619]; + s1631 = table6[s1621]; + s1632 = table7[s1623]; + s1633 = table8[s1625]; + s1634 = s1632 ^ s1633; + s1635 = s1631 ^ s1634; + s1636 = s1630 ^ s1635; + s1637 = sbv_bv_join_u8_u8_u16(s1629, s1636); + s1638 = table8[s1619]; + s1639 = table9[s1621]; + s1640 = table6[s1623]; + s1641 = table7[s1625]; + s1642 = s1640 ^ s1641; + s1643 = s1639 ^ s1642; + s1644 = s1638 ^ s1643; + s1645 = table7[s1619]; + s1646 = table8[s1621]; + s1647 = table9[s1623]; + s1648 = table6[s1625]; + s1649 = s1647 ^ s1648; + s1650 = s1646 ^ s1649; + s1651 = s1645 ^ s1650; + s1652 = sbv_bv_join_u8_u8_u16(s1644, s1651); + s1653 = sbv_bv_join_u16_u16_u32(s1637, s1652); + s1654 = s1618 ^ s1653; + s1655 = sbv_bv_extract_u32_7_0_u8(s1654); + s1656 = table5[s1655]; + s1657 = s1607 ^ s1656; + s1658 = sbv_bv_extract_u32_31_24_u8(s652); + s1659 = table6[s1658]; + s1660 = sbv_bv_extract_u32_23_16_u8(s652); + s1661 = table7[s1660]; + s1662 = sbv_bv_extract_u32_15_8_u8(s652); + s1663 = table8[s1662]; + s1664 = sbv_bv_extract_u32_7_0_u8(s652); + s1665 = table9[s1664]; + s1666 = s1663 ^ s1665; + s1667 = s1661 ^ s1666; + s1668 = s1659 ^ s1667; + s1669 = table9[s1658]; + s1670 = table6[s1660]; + s1671 = table7[s1662]; + s1672 = table8[s1664]; + s1673 = s1671 ^ s1672; + s1674 = s1670 ^ s1673; + s1675 = s1669 ^ s1674; + s1676 = sbv_bv_join_u8_u8_u16(s1668, s1675); + s1677 = table8[s1658]; + s1678 = table9[s1660]; + s1679 = table6[s1662]; + s1680 = table7[s1664]; + s1681 = s1679 ^ s1680; + s1682 = s1678 ^ s1681; + s1683 = s1677 ^ s1682; + s1684 = table7[s1658]; + s1685 = table8[s1660]; + s1686 = table9[s1662]; + s1687 = table6[s1664]; + s1688 = s1686 ^ s1687; + s1689 = s1685 ^ s1688; + s1690 = s1684 ^ s1689; + s1691 = sbv_bv_join_u8_u8_u16(s1683, s1690); + s1692 = sbv_bv_join_u16_u16_u32(s1676, s1691); + s1693 = s1657 ^ s1692; + s1694 = sbv_bv_extract_u32_31_24_u8(s1693); + s1695 = table1[s1694]; + s1696 = sbv_bv_extract_u32_31_24_u8(s1554); + s1697 = table1[s1696]; + s1698 = sbv_bv_extract_u32_23_16_u8(s1604); + s1699 = table3[s1698]; + s1700 = s1697 ^ s1699; + s1701 = sbv_bv_extract_u32_15_8_u8(s1654); + s1702 = table4[s1701]; + s1703 = s1700 ^ s1702; + s1704 = sbv_bv_extract_u32_7_0_u8(s1505); + s1705 = table5[s1704]; + s1706 = s1703 ^ s1705; + s1707 = sbv_bv_extract_u32_31_24_u8(s655); + s1708 = table6[s1707]; + s1709 = sbv_bv_extract_u32_23_16_u8(s655); + s1710 = table7[s1709]; + s1711 = sbv_bv_extract_u32_15_8_u8(s655); + s1712 = table8[s1711]; + s1713 = sbv_bv_extract_u32_7_0_u8(s655); + s1714 = table9[s1713]; + s1715 = s1712 ^ s1714; + s1716 = s1710 ^ s1715; + s1717 = s1708 ^ s1716; + s1718 = table9[s1707]; + s1719 = table6[s1709]; + s1720 = table7[s1711]; + s1721 = table8[s1713]; + s1722 = s1720 ^ s1721; + s1723 = s1719 ^ s1722; + s1724 = s1718 ^ s1723; + s1725 = sbv_bv_join_u8_u8_u16(s1717, s1724); + s1726 = table8[s1707]; + s1727 = table9[s1709]; + s1728 = table6[s1711]; + s1729 = table7[s1713]; + s1730 = s1728 ^ s1729; + s1731 = s1727 ^ s1730; + s1732 = s1726 ^ s1731; + s1733 = table7[s1707]; + s1734 = table8[s1709]; + s1735 = table9[s1711]; + s1736 = table6[s1713]; + s1737 = s1735 ^ s1736; + s1738 = s1734 ^ s1737; + s1739 = s1733 ^ s1738; + s1740 = sbv_bv_join_u8_u8_u16(s1732, s1739); + s1741 = sbv_bv_join_u16_u16_u32(s1725, s1740); + s1742 = s1706 ^ s1741; + s1743 = sbv_bv_extract_u32_23_16_u8(s1742); + s1744 = table3[s1743]; + s1745 = s1695 ^ s1744; + s1746 = sbv_bv_extract_u32_31_24_u8(s1604); + s1747 = table1[s1746]; + s1748 = sbv_bv_extract_u32_23_16_u8(s1654); + s1749 = table3[s1748]; + s1750 = s1747 ^ s1749; + s1751 = sbv_bv_extract_u32_15_8_u8(s1505); + s1752 = table4[s1751]; + s1753 = s1750 ^ s1752; + s1754 = sbv_bv_extract_u32_7_0_u8(s1554); + s1755 = table5[s1754]; + s1756 = s1753 ^ s1755; + s1757 = sbv_bv_extract_u32_31_24_u8(s654); + s1758 = table6[s1757]; + s1759 = sbv_bv_extract_u32_23_16_u8(s654); + s1760 = table7[s1759]; + s1761 = sbv_bv_extract_u32_15_8_u8(s654); + s1762 = table8[s1761]; + s1763 = sbv_bv_extract_u32_7_0_u8(s654); + s1764 = table9[s1763]; + s1765 = s1762 ^ s1764; + s1766 = s1760 ^ s1765; + s1767 = s1758 ^ s1766; + s1768 = table9[s1757]; + s1769 = table6[s1759]; + s1770 = table7[s1761]; + s1771 = table8[s1763]; + s1772 = s1770 ^ s1771; + s1773 = s1769 ^ s1772; + s1774 = s1768 ^ s1773; + s1775 = sbv_bv_join_u8_u8_u16(s1767, s1774); + s1776 = table8[s1757]; + s1777 = table9[s1759]; + s1778 = table6[s1761]; + s1779 = table7[s1763]; + s1780 = s1778 ^ s1779; + s1781 = s1777 ^ s1780; + s1782 = s1776 ^ s1781; + s1783 = table7[s1757]; + s1784 = table8[s1759]; + s1785 = table9[s1761]; + s1786 = table6[s1763]; + s1787 = s1785 ^ s1786; + s1788 = s1784 ^ s1787; + s1789 = s1783 ^ s1788; + s1790 = sbv_bv_join_u8_u8_u16(s1782, s1789); + s1791 = sbv_bv_join_u16_u16_u32(s1775, s1790); + s1792 = s1756 ^ s1791; + s1793 = sbv_bv_extract_u32_15_8_u8(s1792); + s1794 = table4[s1793]; + s1795 = s1745 ^ s1794; + s1796 = sbv_bv_extract_u32_31_24_u8(s1654); + s1797 = table1[s1796]; + s1798 = sbv_bv_extract_u32_23_16_u8(s1505); + s1799 = table3[s1798]; + s1800 = s1797 ^ s1799; + s1801 = sbv_bv_extract_u32_15_8_u8(s1554); + s1802 = table4[s1801]; + s1803 = s1800 ^ s1802; + s1804 = sbv_bv_extract_u32_7_0_u8(s1604); + s1805 = table5[s1804]; + s1806 = s1803 ^ s1805; + s1807 = sbv_bv_extract_u32_31_24_u8(s653); + s1808 = table6[s1807]; + s1809 = sbv_bv_extract_u32_23_16_u8(s653); + s1810 = table7[s1809]; + s1811 = sbv_bv_extract_u32_15_8_u8(s653); + s1812 = table8[s1811]; + s1813 = sbv_bv_extract_u32_7_0_u8(s653); + s1814 = table9[s1813]; + s1815 = s1812 ^ s1814; + s1816 = s1810 ^ s1815; + s1817 = s1808 ^ s1816; + s1818 = table9[s1807]; + s1819 = table6[s1809]; + s1820 = table7[s1811]; + s1821 = table8[s1813]; + s1822 = s1820 ^ s1821; + s1823 = s1819 ^ s1822; + s1824 = s1818 ^ s1823; + s1825 = sbv_bv_join_u8_u8_u16(s1817, s1824); + s1826 = table8[s1807]; + s1827 = table9[s1809]; + s1828 = table6[s1811]; + s1829 = table7[s1813]; + s1830 = s1828 ^ s1829; + s1831 = s1827 ^ s1830; + s1832 = s1826 ^ s1831; + s1833 = table7[s1807]; + s1834 = table8[s1809]; + s1835 = table9[s1811]; + s1836 = table6[s1813]; + s1837 = s1835 ^ s1836; + s1838 = s1834 ^ s1837; + s1839 = s1833 ^ s1838; + s1840 = sbv_bv_join_u8_u8_u16(s1832, s1839); + s1841 = sbv_bv_join_u16_u16_u32(s1825, s1840); + s1842 = s1806 ^ s1841; + s1843 = sbv_bv_extract_u32_7_0_u8(s1842); + s1844 = table5[s1843]; + s1845 = s1795 ^ s1844; + s1846 = sbv_bv_extract_u32_31_24_u8(s635); + s1847 = table6[s1846]; + s1848 = sbv_bv_extract_u32_23_16_u8(s635); + s1849 = table7[s1848]; + s1850 = sbv_bv_extract_u32_15_8_u8(s635); + s1851 = table8[s1850]; + s1852 = sbv_bv_extract_u32_7_0_u8(s635); + s1853 = table9[s1852]; + s1854 = s1851 ^ s1853; + s1855 = s1849 ^ s1854; + s1856 = s1847 ^ s1855; + s1857 = table9[s1846]; + s1858 = table6[s1848]; + s1859 = table7[s1850]; + s1860 = table8[s1852]; + s1861 = s1859 ^ s1860; + s1862 = s1858 ^ s1861; + s1863 = s1857 ^ s1862; + s1864 = sbv_bv_join_u8_u8_u16(s1856, s1863); + s1865 = table8[s1846]; + s1866 = table9[s1848]; + s1867 = table6[s1850]; + s1868 = table7[s1852]; + s1869 = s1867 ^ s1868; + s1870 = s1866 ^ s1869; + s1871 = s1865 ^ s1870; + s1872 = table7[s1846]; + s1873 = table8[s1848]; + s1874 = table9[s1850]; + s1875 = table6[s1852]; + s1876 = s1874 ^ s1875; + s1877 = s1873 ^ s1876; + s1878 = s1872 ^ s1877; + s1879 = sbv_bv_join_u8_u8_u16(s1871, s1878); + s1880 = sbv_bv_join_u16_u16_u32(s1864, s1879); + s1881 = s1845 ^ s1880; + s1882 = sbv_bv_extract_u32_31_24_u8(s1881); + s1883 = table1[s1882]; + s1884 = sbv_bv_extract_u32_31_24_u8(s1742); + s1885 = table1[s1884]; + s1886 = sbv_bv_extract_u32_23_16_u8(s1792); + s1887 = table3[s1886]; + s1888 = s1885 ^ s1887; + s1889 = sbv_bv_extract_u32_15_8_u8(s1842); + s1890 = table4[s1889]; + s1891 = s1888 ^ s1890; + s1892 = sbv_bv_extract_u32_7_0_u8(s1693); + s1893 = table5[s1892]; + s1894 = s1891 ^ s1893; + s1895 = sbv_bv_extract_u32_31_24_u8(s638); + s1896 = table6[s1895]; + s1897 = sbv_bv_extract_u32_23_16_u8(s638); + s1898 = table7[s1897]; + s1899 = sbv_bv_extract_u32_15_8_u8(s638); + s1900 = table8[s1899]; + s1901 = sbv_bv_extract_u32_7_0_u8(s638); + s1902 = table9[s1901]; + s1903 = s1900 ^ s1902; + s1904 = s1898 ^ s1903; + s1905 = s1896 ^ s1904; + s1906 = table9[s1895]; + s1907 = table6[s1897]; + s1908 = table7[s1899]; + s1909 = table8[s1901]; + s1910 = s1908 ^ s1909; + s1911 = s1907 ^ s1910; + s1912 = s1906 ^ s1911; + s1913 = sbv_bv_join_u8_u8_u16(s1905, s1912); + s1914 = table8[s1895]; + s1915 = table9[s1897]; + s1916 = table6[s1899]; + s1917 = table7[s1901]; + s1918 = s1916 ^ s1917; + s1919 = s1915 ^ s1918; + s1920 = s1914 ^ s1919; + s1921 = table7[s1895]; + s1922 = table8[s1897]; + s1923 = table9[s1899]; + s1924 = table6[s1901]; + s1925 = s1923 ^ s1924; + s1926 = s1922 ^ s1925; + s1927 = s1921 ^ s1926; + s1928 = sbv_bv_join_u8_u8_u16(s1920, s1927); + s1929 = sbv_bv_join_u16_u16_u32(s1913, s1928); + s1930 = s1894 ^ s1929; + s1931 = sbv_bv_extract_u32_23_16_u8(s1930); + s1932 = table3[s1931]; + s1933 = s1883 ^ s1932; + s1934 = sbv_bv_extract_u32_31_24_u8(s1792); + s1935 = table1[s1934]; + s1936 = sbv_bv_extract_u32_23_16_u8(s1842); + s1937 = table3[s1936]; + s1938 = s1935 ^ s1937; + s1939 = sbv_bv_extract_u32_15_8_u8(s1693); + s1940 = table4[s1939]; + s1941 = s1938 ^ s1940; + s1942 = sbv_bv_extract_u32_7_0_u8(s1742); + s1943 = table5[s1942]; + s1944 = s1941 ^ s1943; + s1945 = sbv_bv_extract_u32_31_24_u8(s637); + s1946 = table6[s1945]; + s1947 = sbv_bv_extract_u32_23_16_u8(s637); + s1948 = table7[s1947]; + s1949 = sbv_bv_extract_u32_15_8_u8(s637); + s1950 = table8[s1949]; + s1951 = sbv_bv_extract_u32_7_0_u8(s637); + s1952 = table9[s1951]; + s1953 = s1950 ^ s1952; + s1954 = s1948 ^ s1953; + s1955 = s1946 ^ s1954; + s1956 = table9[s1945]; + s1957 = table6[s1947]; + s1958 = table7[s1949]; + s1959 = table8[s1951]; + s1960 = s1958 ^ s1959; + s1961 = s1957 ^ s1960; + s1962 = s1956 ^ s1961; + s1963 = sbv_bv_join_u8_u8_u16(s1955, s1962); + s1964 = table8[s1945]; + s1965 = table9[s1947]; + s1966 = table6[s1949]; + s1967 = table7[s1951]; + s1968 = s1966 ^ s1967; + s1969 = s1965 ^ s1968; + s1970 = s1964 ^ s1969; + s1971 = table7[s1945]; + s1972 = table8[s1947]; + s1973 = table9[s1949]; + s1974 = table6[s1951]; + s1975 = s1973 ^ s1974; + s1976 = s1972 ^ s1975; + s1977 = s1971 ^ s1976; + s1978 = sbv_bv_join_u8_u8_u16(s1970, s1977); + s1979 = sbv_bv_join_u16_u16_u32(s1963, s1978); + s1980 = s1944 ^ s1979; + s1981 = sbv_bv_extract_u32_15_8_u8(s1980); + s1982 = table4[s1981]; + s1983 = s1933 ^ s1982; + s1984 = sbv_bv_extract_u32_31_24_u8(s1842); + s1985 = table1[s1984]; + s1986 = sbv_bv_extract_u32_23_16_u8(s1693); + s1987 = table3[s1986]; + s1988 = s1985 ^ s1987; + s1989 = sbv_bv_extract_u32_15_8_u8(s1742); + s1990 = table4[s1989]; + s1991 = s1988 ^ s1990; + s1992 = sbv_bv_extract_u32_7_0_u8(s1792); + s1993 = table5[s1992]; + s1994 = s1991 ^ s1993; + s1995 = sbv_bv_extract_u32_31_24_u8(s636); + s1996 = table6[s1995]; + s1997 = sbv_bv_extract_u32_23_16_u8(s636); + s1998 = table7[s1997]; + s1999 = sbv_bv_extract_u32_15_8_u8(s636); + s2000 = table8[s1999]; + s2001 = sbv_bv_extract_u32_7_0_u8(s636); + s2002 = table9[s2001]; + s2003 = s2000 ^ s2002; + s2004 = s1998 ^ s2003; + s2005 = s1996 ^ s2004; + s2006 = table9[s1995]; + s2007 = table6[s1997]; + s2008 = table7[s1999]; + s2009 = table8[s2001]; + s2010 = s2008 ^ s2009; + s2011 = s2007 ^ s2010; + s2012 = s2006 ^ s2011; + s2013 = sbv_bv_join_u8_u8_u16(s2005, s2012); + s2014 = table8[s1995]; + s2015 = table9[s1997]; + s2016 = table6[s1999]; + s2017 = table7[s2001]; + s2018 = s2016 ^ s2017; + s2019 = s2015 ^ s2018; + s2020 = s2014 ^ s2019; + s2021 = table7[s1995]; + s2022 = table8[s1997]; + s2023 = table9[s1999]; + s2024 = table6[s2001]; + s2025 = s2023 ^ s2024; + s2026 = s2022 ^ s2025; + s2027 = s2021 ^ s2026; + s2028 = sbv_bv_join_u8_u8_u16(s2020, s2027); + s2029 = sbv_bv_join_u16_u16_u32(s2013, s2028); + s2030 = s1994 ^ s2029; + s2031 = sbv_bv_extract_u32_7_0_u8(s2030); + s2032 = table5[s2031]; + s2033 = s1983 ^ s2032; + s2034 = sbv_bv_extract_u32_31_24_u8(s618); + s2035 = table6[s2034]; + s2036 = sbv_bv_extract_u32_23_16_u8(s618); + s2037 = table7[s2036]; + s2038 = sbv_bv_extract_u32_15_8_u8(s618); + s2039 = table8[s2038]; + s2040 = sbv_bv_extract_u32_7_0_u8(s618); + s2041 = table9[s2040]; + s2042 = s2039 ^ s2041; + s2043 = s2037 ^ s2042; + s2044 = s2035 ^ s2043; + s2045 = table9[s2034]; + s2046 = table6[s2036]; + s2047 = table7[s2038]; + s2048 = table8[s2040]; + s2049 = s2047 ^ s2048; + s2050 = s2046 ^ s2049; + s2051 = s2045 ^ s2050; + s2052 = sbv_bv_join_u8_u8_u16(s2044, s2051); + s2053 = table8[s2034]; + s2054 = table9[s2036]; + s2055 = table6[s2038]; + s2056 = table7[s2040]; + s2057 = s2055 ^ s2056; + s2058 = s2054 ^ s2057; + s2059 = s2053 ^ s2058; + s2060 = table7[s2034]; + s2061 = table8[s2036]; + s2062 = table9[s2038]; + s2063 = table6[s2040]; + s2064 = s2062 ^ s2063; + s2065 = s2061 ^ s2064; + s2066 = s2060 ^ s2065; + s2067 = sbv_bv_join_u8_u8_u16(s2059, s2066); + s2068 = sbv_bv_join_u16_u16_u32(s2052, s2067); + s2069 = s2033 ^ s2068; + s2070 = sbv_bv_extract_u32_31_24_u8(s2069); + s2071 = table1[s2070]; + s2072 = sbv_bv_extract_u32_31_24_u8(s1930); + s2073 = table1[s2072]; + s2074 = sbv_bv_extract_u32_23_16_u8(s1980); + s2075 = table3[s2074]; + s2076 = s2073 ^ s2075; + s2077 = sbv_bv_extract_u32_15_8_u8(s2030); + s2078 = table4[s2077]; + s2079 = s2076 ^ s2078; + s2080 = sbv_bv_extract_u32_7_0_u8(s1881); + s2081 = table5[s2080]; + s2082 = s2079 ^ s2081; + s2083 = sbv_bv_extract_u32_31_24_u8(s621); + s2084 = table6[s2083]; + s2085 = sbv_bv_extract_u32_23_16_u8(s621); + s2086 = table7[s2085]; + s2087 = sbv_bv_extract_u32_15_8_u8(s621); + s2088 = table8[s2087]; + s2089 = sbv_bv_extract_u32_7_0_u8(s621); + s2090 = table9[s2089]; + s2091 = s2088 ^ s2090; + s2092 = s2086 ^ s2091; + s2093 = s2084 ^ s2092; + s2094 = table9[s2083]; + s2095 = table6[s2085]; + s2096 = table7[s2087]; + s2097 = table8[s2089]; + s2098 = s2096 ^ s2097; + s2099 = s2095 ^ s2098; + s2100 = s2094 ^ s2099; + s2101 = sbv_bv_join_u8_u8_u16(s2093, s2100); + s2102 = table8[s2083]; + s2103 = table9[s2085]; + s2104 = table6[s2087]; + s2105 = table7[s2089]; + s2106 = s2104 ^ s2105; + s2107 = s2103 ^ s2106; + s2108 = s2102 ^ s2107; + s2109 = table7[s2083]; + s2110 = table8[s2085]; + s2111 = table9[s2087]; + s2112 = table6[s2089]; + s2113 = s2111 ^ s2112; + s2114 = s2110 ^ s2113; + s2115 = s2109 ^ s2114; + s2116 = sbv_bv_join_u8_u8_u16(s2108, s2115); + s2117 = sbv_bv_join_u16_u16_u32(s2101, s2116); + s2118 = s2082 ^ s2117; + s2119 = sbv_bv_extract_u32_23_16_u8(s2118); + s2120 = table3[s2119]; + s2121 = s2071 ^ s2120; + s2122 = sbv_bv_extract_u32_31_24_u8(s1980); + s2123 = table1[s2122]; + s2124 = sbv_bv_extract_u32_23_16_u8(s2030); + s2125 = table3[s2124]; + s2126 = s2123 ^ s2125; + s2127 = sbv_bv_extract_u32_15_8_u8(s1881); + s2128 = table4[s2127]; + s2129 = s2126 ^ s2128; + s2130 = sbv_bv_extract_u32_7_0_u8(s1930); + s2131 = table5[s2130]; + s2132 = s2129 ^ s2131; + s2133 = sbv_bv_extract_u32_31_24_u8(s620); + s2134 = table6[s2133]; + s2135 = sbv_bv_extract_u32_23_16_u8(s620); + s2136 = table7[s2135]; + s2137 = sbv_bv_extract_u32_15_8_u8(s620); + s2138 = table8[s2137]; + s2139 = sbv_bv_extract_u32_7_0_u8(s620); + s2140 = table9[s2139]; + s2141 = s2138 ^ s2140; + s2142 = s2136 ^ s2141; + s2143 = s2134 ^ s2142; + s2144 = table9[s2133]; + s2145 = table6[s2135]; + s2146 = table7[s2137]; + s2147 = table8[s2139]; + s2148 = s2146 ^ s2147; + s2149 = s2145 ^ s2148; + s2150 = s2144 ^ s2149; + s2151 = sbv_bv_join_u8_u8_u16(s2143, s2150); + s2152 = table8[s2133]; + s2153 = table9[s2135]; + s2154 = table6[s2137]; + s2155 = table7[s2139]; + s2156 = s2154 ^ s2155; + s2157 = s2153 ^ s2156; + s2158 = s2152 ^ s2157; + s2159 = table7[s2133]; + s2160 = table8[s2135]; + s2161 = table9[s2137]; + s2162 = table6[s2139]; + s2163 = s2161 ^ s2162; + s2164 = s2160 ^ s2163; + s2165 = s2159 ^ s2164; + s2166 = sbv_bv_join_u8_u8_u16(s2158, s2165); + s2167 = sbv_bv_join_u16_u16_u32(s2151, s2166); + s2168 = s2132 ^ s2167; + s2169 = sbv_bv_extract_u32_15_8_u8(s2168); + s2170 = table4[s2169]; + s2171 = s2121 ^ s2170; + s2172 = sbv_bv_extract_u32_31_24_u8(s2030); + s2173 = table1[s2172]; + s2174 = sbv_bv_extract_u32_23_16_u8(s1881); + s2175 = table3[s2174]; + s2176 = s2173 ^ s2175; + s2177 = sbv_bv_extract_u32_15_8_u8(s1930); + s2178 = table4[s2177]; + s2179 = s2176 ^ s2178; + s2180 = sbv_bv_extract_u32_7_0_u8(s1980); + s2181 = table5[s2180]; + s2182 = s2179 ^ s2181; + s2183 = sbv_bv_extract_u32_31_24_u8(s619); + s2184 = table6[s2183]; + s2185 = sbv_bv_extract_u32_23_16_u8(s619); + s2186 = table7[s2185]; + s2187 = sbv_bv_extract_u32_15_8_u8(s619); + s2188 = table8[s2187]; + s2189 = sbv_bv_extract_u32_7_0_u8(s619); + s2190 = table9[s2189]; + s2191 = s2188 ^ s2190; + s2192 = s2186 ^ s2191; + s2193 = s2184 ^ s2192; + s2194 = table9[s2183]; + s2195 = table6[s2185]; + s2196 = table7[s2187]; + s2197 = table8[s2189]; + s2198 = s2196 ^ s2197; + s2199 = s2195 ^ s2198; + s2200 = s2194 ^ s2199; + s2201 = sbv_bv_join_u8_u8_u16(s2193, s2200); + s2202 = table8[s2183]; + s2203 = table9[s2185]; + s2204 = table6[s2187]; + s2205 = table7[s2189]; + s2206 = s2204 ^ s2205; + s2207 = s2203 ^ s2206; + s2208 = s2202 ^ s2207; + s2209 = table7[s2183]; + s2210 = table8[s2185]; + s2211 = table9[s2187]; + s2212 = table6[s2189]; + s2213 = s2211 ^ s2212; + s2214 = s2210 ^ s2213; + s2215 = s2209 ^ s2214; + s2216 = sbv_bv_join_u8_u8_u16(s2208, s2215); + s2217 = sbv_bv_join_u16_u16_u32(s2201, s2216); + s2218 = s2182 ^ s2217; + s2219 = sbv_bv_extract_u32_7_0_u8(s2218); + s2220 = table5[s2219]; + s2221 = s2171 ^ s2220; + s2222 = sbv_bv_extract_u32_31_24_u8(s601); + s2223 = table6[s2222]; + s2224 = sbv_bv_extract_u32_23_16_u8(s601); + s2225 = table7[s2224]; + s2226 = sbv_bv_extract_u32_15_8_u8(s601); + s2227 = table8[s2226]; + s2228 = sbv_bv_extract_u32_7_0_u8(s601); + s2229 = table9[s2228]; + s2230 = s2227 ^ s2229; + s2231 = s2225 ^ s2230; + s2232 = s2223 ^ s2231; + s2233 = table9[s2222]; + s2234 = table6[s2224]; + s2235 = table7[s2226]; + s2236 = table8[s2228]; + s2237 = s2235 ^ s2236; + s2238 = s2234 ^ s2237; + s2239 = s2233 ^ s2238; + s2240 = sbv_bv_join_u8_u8_u16(s2232, s2239); + s2241 = table8[s2222]; + s2242 = table9[s2224]; + s2243 = table6[s2226]; + s2244 = table7[s2228]; + s2245 = s2243 ^ s2244; + s2246 = s2242 ^ s2245; + s2247 = s2241 ^ s2246; + s2248 = table7[s2222]; + s2249 = table8[s2224]; + s2250 = table9[s2226]; + s2251 = table6[s2228]; + s2252 = s2250 ^ s2251; + s2253 = s2249 ^ s2252; + s2254 = s2248 ^ s2253; + s2255 = sbv_bv_join_u8_u8_u16(s2247, s2254); + s2256 = sbv_bv_join_u16_u16_u32(s2240, s2255); + s2257 = s2221 ^ s2256; + s2258 = sbv_bv_extract_u32_31_24_u8(s2257); + s2259 = table1[s2258]; + s2260 = sbv_bv_extract_u32_31_24_u8(s2118); + s2261 = table1[s2260]; + s2262 = sbv_bv_extract_u32_23_16_u8(s2168); + s2263 = table3[s2262]; + s2264 = s2261 ^ s2263; + s2265 = sbv_bv_extract_u32_15_8_u8(s2218); + s2266 = table4[s2265]; + s2267 = s2264 ^ s2266; + s2268 = sbv_bv_extract_u32_7_0_u8(s2069); + s2269 = table5[s2268]; + s2270 = s2267 ^ s2269; + s2271 = sbv_bv_extract_u32_31_24_u8(s604); + s2272 = table6[s2271]; + s2273 = sbv_bv_extract_u32_23_16_u8(s604); + s2274 = table7[s2273]; + s2275 = sbv_bv_extract_u32_15_8_u8(s604); + s2276 = table8[s2275]; + s2277 = sbv_bv_extract_u32_7_0_u8(s604); + s2278 = table9[s2277]; + s2279 = s2276 ^ s2278; + s2280 = s2274 ^ s2279; + s2281 = s2272 ^ s2280; + s2282 = table9[s2271]; + s2283 = table6[s2273]; + s2284 = table7[s2275]; + s2285 = table8[s2277]; + s2286 = s2284 ^ s2285; + s2287 = s2283 ^ s2286; + s2288 = s2282 ^ s2287; + s2289 = sbv_bv_join_u8_u8_u16(s2281, s2288); + s2290 = table8[s2271]; + s2291 = table9[s2273]; + s2292 = table6[s2275]; + s2293 = table7[s2277]; + s2294 = s2292 ^ s2293; + s2295 = s2291 ^ s2294; + s2296 = s2290 ^ s2295; + s2297 = table7[s2271]; + s2298 = table8[s2273]; + s2299 = table9[s2275]; + s2300 = table6[s2277]; + s2301 = s2299 ^ s2300; + s2302 = s2298 ^ s2301; + s2303 = s2297 ^ s2302; + s2304 = sbv_bv_join_u8_u8_u16(s2296, s2303); + s2305 = sbv_bv_join_u16_u16_u32(s2289, s2304); + s2306 = s2270 ^ s2305; + s2307 = sbv_bv_extract_u32_23_16_u8(s2306); + s2308 = table3[s2307]; + s2309 = s2259 ^ s2308; + s2310 = sbv_bv_extract_u32_31_24_u8(s2168); + s2311 = table1[s2310]; + s2312 = sbv_bv_extract_u32_23_16_u8(s2218); + s2313 = table3[s2312]; + s2314 = s2311 ^ s2313; + s2315 = sbv_bv_extract_u32_15_8_u8(s2069); + s2316 = table4[s2315]; + s2317 = s2314 ^ s2316; + s2318 = sbv_bv_extract_u32_7_0_u8(s2118); + s2319 = table5[s2318]; + s2320 = s2317 ^ s2319; + s2321 = sbv_bv_extract_u32_31_24_u8(s603); + s2322 = table6[s2321]; + s2323 = sbv_bv_extract_u32_23_16_u8(s603); + s2324 = table7[s2323]; + s2325 = sbv_bv_extract_u32_15_8_u8(s603); + s2326 = table8[s2325]; + s2327 = sbv_bv_extract_u32_7_0_u8(s603); + s2328 = table9[s2327]; + s2329 = s2326 ^ s2328; + s2330 = s2324 ^ s2329; + s2331 = s2322 ^ s2330; + s2332 = table9[s2321]; + s2333 = table6[s2323]; + s2334 = table7[s2325]; + s2335 = table8[s2327]; + s2336 = s2334 ^ s2335; + s2337 = s2333 ^ s2336; + s2338 = s2332 ^ s2337; + s2339 = sbv_bv_join_u8_u8_u16(s2331, s2338); + s2340 = table8[s2321]; + s2341 = table9[s2323]; + s2342 = table6[s2325]; + s2343 = table7[s2327]; + s2344 = s2342 ^ s2343; + s2345 = s2341 ^ s2344; + s2346 = s2340 ^ s2345; + s2347 = table7[s2321]; + s2348 = table8[s2323]; + s2349 = table9[s2325]; + s2350 = table6[s2327]; + s2351 = s2349 ^ s2350; + s2352 = s2348 ^ s2351; + s2353 = s2347 ^ s2352; + s2354 = sbv_bv_join_u8_u8_u16(s2346, s2353); + s2355 = sbv_bv_join_u16_u16_u32(s2339, s2354); + s2356 = s2320 ^ s2355; + s2357 = sbv_bv_extract_u32_15_8_u8(s2356); + s2358 = table4[s2357]; + s2359 = s2309 ^ s2358; + s2360 = sbv_bv_extract_u32_31_24_u8(s2218); + s2361 = table1[s2360]; + s2362 = sbv_bv_extract_u32_23_16_u8(s2069); + s2363 = table3[s2362]; + s2364 = s2361 ^ s2363; + s2365 = sbv_bv_extract_u32_15_8_u8(s2118); + s2366 = table4[s2365]; + s2367 = s2364 ^ s2366; + s2368 = sbv_bv_extract_u32_7_0_u8(s2168); + s2369 = table5[s2368]; + s2370 = s2367 ^ s2369; + s2371 = sbv_bv_extract_u32_31_24_u8(s602); + s2372 = table6[s2371]; + s2373 = sbv_bv_extract_u32_23_16_u8(s602); + s2374 = table7[s2373]; + s2375 = sbv_bv_extract_u32_15_8_u8(s602); + s2376 = table8[s2375]; + s2377 = sbv_bv_extract_u32_7_0_u8(s602); + s2378 = table9[s2377]; + s2379 = s2376 ^ s2378; + s2380 = s2374 ^ s2379; + s2381 = s2372 ^ s2380; + s2382 = table9[s2371]; + s2383 = table6[s2373]; + s2384 = table7[s2375]; + s2385 = table8[s2377]; + s2386 = s2384 ^ s2385; + s2387 = s2383 ^ s2386; + s2388 = s2382 ^ s2387; + s2389 = sbv_bv_join_u8_u8_u16(s2381, s2388); + s2390 = table8[s2371]; + s2391 = table9[s2373]; + s2392 = table6[s2375]; + s2393 = table7[s2377]; + s2394 = s2392 ^ s2393; + s2395 = s2391 ^ s2394; + s2396 = s2390 ^ s2395; + s2397 = table7[s2371]; + s2398 = table8[s2373]; + s2399 = table9[s2375]; + s2400 = table6[s2377]; + s2401 = s2399 ^ s2400; + s2402 = s2398 ^ s2401; + s2403 = s2397 ^ s2402; + s2404 = sbv_bv_join_u8_u8_u16(s2396, s2403); + s2405 = sbv_bv_join_u16_u16_u32(s2389, s2404); + s2406 = s2370 ^ s2405; + s2407 = sbv_bv_extract_u32_7_0_u8(s2406); + s2408 = table5[s2407]; + s2409 = s2359 ^ s2408; + s2410 = sbv_bv_extract_u32_31_24_u8(s584); + s2411 = table6[s2410]; + s2412 = sbv_bv_extract_u32_23_16_u8(s584); + s2413 = table7[s2412]; + s2414 = sbv_bv_extract_u32_15_8_u8(s584); + s2415 = table8[s2414]; + s2416 = sbv_bv_extract_u32_7_0_u8(s584); + s2417 = table9[s2416]; + s2418 = s2415 ^ s2417; + s2419 = s2413 ^ s2418; + s2420 = s2411 ^ s2419; + s2421 = table9[s2410]; + s2422 = table6[s2412]; + s2423 = table7[s2414]; + s2424 = table8[s2416]; + s2425 = s2423 ^ s2424; + s2426 = s2422 ^ s2425; + s2427 = s2421 ^ s2426; + s2428 = sbv_bv_join_u8_u8_u16(s2420, s2427); + s2429 = table8[s2410]; + s2430 = table9[s2412]; + s2431 = table6[s2414]; + s2432 = table7[s2416]; + s2433 = s2431 ^ s2432; + s2434 = s2430 ^ s2433; + s2435 = s2429 ^ s2434; + s2436 = table7[s2410]; + s2437 = table8[s2412]; + s2438 = table9[s2414]; + s2439 = table6[s2416]; + s2440 = s2438 ^ s2439; + s2441 = s2437 ^ s2440; + s2442 = s2436 ^ s2441; + s2443 = sbv_bv_join_u8_u8_u16(s2435, s2442); + s2444 = sbv_bv_join_u16_u16_u32(s2428, s2443); + s2445 = s2409 ^ s2444; + s2446 = sbv_bv_extract_u32_31_24_u8(s2445); + s2447 = table1[s2446]; + s2448 = sbv_bv_extract_u32_31_24_u8(s2306); + s2449 = table1[s2448]; + s2450 = sbv_bv_extract_u32_23_16_u8(s2356); + s2451 = table3[s2450]; + s2452 = s2449 ^ s2451; + s2453 = sbv_bv_extract_u32_15_8_u8(s2406); + s2454 = table4[s2453]; + s2455 = s2452 ^ s2454; + s2456 = sbv_bv_extract_u32_7_0_u8(s2257); + s2457 = table5[s2456]; + s2458 = s2455 ^ s2457; + s2459 = sbv_bv_extract_u32_31_24_u8(s587); + s2460 = table6[s2459]; + s2461 = sbv_bv_extract_u32_23_16_u8(s587); + s2462 = table7[s2461]; + s2463 = sbv_bv_extract_u32_15_8_u8(s587); + s2464 = table8[s2463]; + s2465 = sbv_bv_extract_u32_7_0_u8(s587); + s2466 = table9[s2465]; + s2467 = s2464 ^ s2466; + s2468 = s2462 ^ s2467; + s2469 = s2460 ^ s2468; + s2470 = table9[s2459]; + s2471 = table6[s2461]; + s2472 = table7[s2463]; + s2473 = table8[s2465]; + s2474 = s2472 ^ s2473; + s2475 = s2471 ^ s2474; + s2476 = s2470 ^ s2475; + s2477 = sbv_bv_join_u8_u8_u16(s2469, s2476); + s2478 = table8[s2459]; + s2479 = table9[s2461]; + s2480 = table6[s2463]; + s2481 = table7[s2465]; + s2482 = s2480 ^ s2481; + s2483 = s2479 ^ s2482; + s2484 = s2478 ^ s2483; + s2485 = table7[s2459]; + s2486 = table8[s2461]; + s2487 = table9[s2463]; + s2488 = table6[s2465]; + s2489 = s2487 ^ s2488; + s2490 = s2486 ^ s2489; + s2491 = s2485 ^ s2490; + s2492 = sbv_bv_join_u8_u8_u16(s2484, s2491); + s2493 = sbv_bv_join_u16_u16_u32(s2477, s2492); + s2494 = s2458 ^ s2493; + s2495 = sbv_bv_extract_u32_23_16_u8(s2494); + s2496 = table3[s2495]; + s2497 = s2447 ^ s2496; + s2498 = sbv_bv_extract_u32_31_24_u8(s2356); + s2499 = table1[s2498]; + s2500 = sbv_bv_extract_u32_23_16_u8(s2406); + s2501 = table3[s2500]; + s2502 = s2499 ^ s2501; + s2503 = sbv_bv_extract_u32_15_8_u8(s2257); + s2504 = table4[s2503]; + s2505 = s2502 ^ s2504; + s2506 = sbv_bv_extract_u32_7_0_u8(s2306); + s2507 = table5[s2506]; + s2508 = s2505 ^ s2507; + s2509 = sbv_bv_extract_u32_31_24_u8(s586); + s2510 = table6[s2509]; + s2511 = sbv_bv_extract_u32_23_16_u8(s586); + s2512 = table7[s2511]; + s2513 = sbv_bv_extract_u32_15_8_u8(s586); + s2514 = table8[s2513]; + s2515 = sbv_bv_extract_u32_7_0_u8(s586); + s2516 = table9[s2515]; + s2517 = s2514 ^ s2516; + s2518 = s2512 ^ s2517; + s2519 = s2510 ^ s2518; + s2520 = table9[s2509]; + s2521 = table6[s2511]; + s2522 = table7[s2513]; + s2523 = table8[s2515]; + s2524 = s2522 ^ s2523; + s2525 = s2521 ^ s2524; + s2526 = s2520 ^ s2525; + s2527 = sbv_bv_join_u8_u8_u16(s2519, s2526); + s2528 = table8[s2509]; + s2529 = table9[s2511]; + s2530 = table6[s2513]; + s2531 = table7[s2515]; + s2532 = s2530 ^ s2531; + s2533 = s2529 ^ s2532; + s2534 = s2528 ^ s2533; + s2535 = table7[s2509]; + s2536 = table8[s2511]; + s2537 = table9[s2513]; + s2538 = table6[s2515]; + s2539 = s2537 ^ s2538; + s2540 = s2536 ^ s2539; + s2541 = s2535 ^ s2540; + s2542 = sbv_bv_join_u8_u8_u16(s2534, s2541); + s2543 = sbv_bv_join_u16_u16_u32(s2527, s2542); + s2544 = s2508 ^ s2543; + s2545 = sbv_bv_extract_u32_15_8_u8(s2544); + s2546 = table4[s2545]; + s2547 = s2497 ^ s2546; + s2548 = sbv_bv_extract_u32_31_24_u8(s2406); + s2549 = table1[s2548]; + s2550 = sbv_bv_extract_u32_23_16_u8(s2257); + s2551 = table3[s2550]; + s2552 = s2549 ^ s2551; + s2553 = sbv_bv_extract_u32_15_8_u8(s2306); + s2554 = table4[s2553]; + s2555 = s2552 ^ s2554; + s2556 = sbv_bv_extract_u32_7_0_u8(s2356); + s2557 = table5[s2556]; + s2558 = s2555 ^ s2557; + s2559 = sbv_bv_extract_u32_31_24_u8(s585); + s2560 = table6[s2559]; + s2561 = sbv_bv_extract_u32_23_16_u8(s585); + s2562 = table7[s2561]; + s2563 = sbv_bv_extract_u32_15_8_u8(s585); + s2564 = table8[s2563]; + s2565 = sbv_bv_extract_u32_7_0_u8(s585); + s2566 = table9[s2565]; + s2567 = s2564 ^ s2566; + s2568 = s2562 ^ s2567; + s2569 = s2560 ^ s2568; + s2570 = table9[s2559]; + s2571 = table6[s2561]; + s2572 = table7[s2563]; + s2573 = table8[s2565]; + s2574 = s2572 ^ s2573; + s2575 = s2571 ^ s2574; + s2576 = s2570 ^ s2575; + s2577 = sbv_bv_join_u8_u8_u16(s2569, s2576); + s2578 = table8[s2559]; + s2579 = table9[s2561]; + s2580 = table6[s2563]; + s2581 = table7[s2565]; + s2582 = s2580 ^ s2581; + s2583 = s2579 ^ s2582; + s2584 = s2578 ^ s2583; + s2585 = table7[s2559]; + s2586 = table8[s2561]; + s2587 = table9[s2563]; + s2588 = table6[s2565]; + s2589 = s2587 ^ s2588; + s2590 = s2586 ^ s2589; + s2591 = s2585 ^ s2590; + s2592 = sbv_bv_join_u8_u8_u16(s2584, s2591); + s2593 = sbv_bv_join_u16_u16_u32(s2577, s2592); + s2594 = s2558 ^ s2593; + s2595 = sbv_bv_extract_u32_7_0_u8(s2594); + s2596 = table5[s2595]; + s2597 = s2547 ^ s2596; + s2598 = sbv_bv_extract_u32_31_24_u8(s567); + s2599 = table6[s2598]; + s2600 = sbv_bv_extract_u32_23_16_u8(s567); + s2601 = table7[s2600]; + s2602 = sbv_bv_extract_u32_15_8_u8(s567); + s2603 = table8[s2602]; + s2604 = sbv_bv_extract_u32_7_0_u8(s567); + s2605 = table9[s2604]; + s2606 = s2603 ^ s2605; + s2607 = s2601 ^ s2606; + s2608 = s2599 ^ s2607; + s2609 = table9[s2598]; + s2610 = table6[s2600]; + s2611 = table7[s2602]; + s2612 = table8[s2604]; + s2613 = s2611 ^ s2612; + s2614 = s2610 ^ s2613; + s2615 = s2609 ^ s2614; + s2616 = sbv_bv_join_u8_u8_u16(s2608, s2615); + s2617 = table8[s2598]; + s2618 = table9[s2600]; + s2619 = table6[s2602]; + s2620 = table7[s2604]; + s2621 = s2619 ^ s2620; + s2622 = s2618 ^ s2621; + s2623 = s2617 ^ s2622; + s2624 = table7[s2598]; + s2625 = table8[s2600]; + s2626 = table9[s2602]; + s2627 = table6[s2604]; + s2628 = s2626 ^ s2627; + s2629 = s2625 ^ s2628; + s2630 = s2624 ^ s2629; + s2631 = sbv_bv_join_u8_u8_u16(s2623, s2630); + s2632 = sbv_bv_join_u16_u16_u32(s2616, s2631); + s2633 = s2597 ^ s2632; + s2634 = sbv_bv_extract_u32_31_24_u8(s2633); + s2635 = table1[s2634]; + s2636 = sbv_bv_extract_u32_31_24_u8(s2494); + s2637 = table1[s2636]; + s2638 = sbv_bv_extract_u32_23_16_u8(s2544); + s2639 = table3[s2638]; + s2640 = s2637 ^ s2639; + s2641 = sbv_bv_extract_u32_15_8_u8(s2594); + s2642 = table4[s2641]; + s2643 = s2640 ^ s2642; + s2644 = sbv_bv_extract_u32_7_0_u8(s2445); + s2645 = table5[s2644]; + s2646 = s2643 ^ s2645; + s2647 = sbv_bv_extract_u32_31_24_u8(s570); + s2648 = table6[s2647]; + s2649 = sbv_bv_extract_u32_23_16_u8(s570); + s2650 = table7[s2649]; + s2651 = sbv_bv_extract_u32_15_8_u8(s570); + s2652 = table8[s2651]; + s2653 = sbv_bv_extract_u32_7_0_u8(s570); + s2654 = table9[s2653]; + s2655 = s2652 ^ s2654; + s2656 = s2650 ^ s2655; + s2657 = s2648 ^ s2656; + s2658 = table9[s2647]; + s2659 = table6[s2649]; + s2660 = table7[s2651]; + s2661 = table8[s2653]; + s2662 = s2660 ^ s2661; + s2663 = s2659 ^ s2662; + s2664 = s2658 ^ s2663; + s2665 = sbv_bv_join_u8_u8_u16(s2657, s2664); + s2666 = table8[s2647]; + s2667 = table9[s2649]; + s2668 = table6[s2651]; + s2669 = table7[s2653]; + s2670 = s2668 ^ s2669; + s2671 = s2667 ^ s2670; + s2672 = s2666 ^ s2671; + s2673 = table7[s2647]; + s2674 = table8[s2649]; + s2675 = table9[s2651]; + s2676 = table6[s2653]; + s2677 = s2675 ^ s2676; + s2678 = s2674 ^ s2677; + s2679 = s2673 ^ s2678; + s2680 = sbv_bv_join_u8_u8_u16(s2672, s2679); + s2681 = sbv_bv_join_u16_u16_u32(s2665, s2680); + s2682 = s2646 ^ s2681; + s2683 = sbv_bv_extract_u32_23_16_u8(s2682); + s2684 = table3[s2683]; + s2685 = s2635 ^ s2684; + s2686 = sbv_bv_extract_u32_31_24_u8(s2544); + s2687 = table1[s2686]; + s2688 = sbv_bv_extract_u32_23_16_u8(s2594); + s2689 = table3[s2688]; + s2690 = s2687 ^ s2689; + s2691 = sbv_bv_extract_u32_15_8_u8(s2445); + s2692 = table4[s2691]; + s2693 = s2690 ^ s2692; + s2694 = sbv_bv_extract_u32_7_0_u8(s2494); + s2695 = table5[s2694]; + s2696 = s2693 ^ s2695; + s2697 = sbv_bv_extract_u32_31_24_u8(s569); + s2698 = table6[s2697]; + s2699 = sbv_bv_extract_u32_23_16_u8(s569); + s2700 = table7[s2699]; + s2701 = sbv_bv_extract_u32_15_8_u8(s569); + s2702 = table8[s2701]; + s2703 = sbv_bv_extract_u32_7_0_u8(s569); + s2704 = table9[s2703]; + s2705 = s2702 ^ s2704; + s2706 = s2700 ^ s2705; + s2707 = s2698 ^ s2706; + s2708 = table9[s2697]; + s2709 = table6[s2699]; + s2710 = table7[s2701]; + s2711 = table8[s2703]; + s2712 = s2710 ^ s2711; + s2713 = s2709 ^ s2712; + s2714 = s2708 ^ s2713; + s2715 = sbv_bv_join_u8_u8_u16(s2707, s2714); + s2716 = table8[s2697]; + s2717 = table9[s2699]; + s2718 = table6[s2701]; + s2719 = table7[s2703]; + s2720 = s2718 ^ s2719; + s2721 = s2717 ^ s2720; + s2722 = s2716 ^ s2721; + s2723 = table7[s2697]; + s2724 = table8[s2699]; + s2725 = table9[s2701]; + s2726 = table6[s2703]; + s2727 = s2725 ^ s2726; + s2728 = s2724 ^ s2727; + s2729 = s2723 ^ s2728; + s2730 = sbv_bv_join_u8_u8_u16(s2722, s2729); + s2731 = sbv_bv_join_u16_u16_u32(s2715, s2730); + s2732 = s2696 ^ s2731; + s2733 = sbv_bv_extract_u32_15_8_u8(s2732); + s2734 = table4[s2733]; + s2735 = s2685 ^ s2734; + s2736 = sbv_bv_extract_u32_31_24_u8(s2594); + s2737 = table1[s2736]; + s2738 = sbv_bv_extract_u32_23_16_u8(s2445); + s2739 = table3[s2738]; + s2740 = s2737 ^ s2739; + s2741 = sbv_bv_extract_u32_15_8_u8(s2494); + s2742 = table4[s2741]; + s2743 = s2740 ^ s2742; + s2744 = sbv_bv_extract_u32_7_0_u8(s2544); + s2745 = table5[s2744]; + s2746 = s2743 ^ s2745; + s2747 = sbv_bv_extract_u32_31_24_u8(s568); + s2748 = table6[s2747]; + s2749 = sbv_bv_extract_u32_23_16_u8(s568); + s2750 = table7[s2749]; + s2751 = sbv_bv_extract_u32_15_8_u8(s568); + s2752 = table8[s2751]; + s2753 = sbv_bv_extract_u32_7_0_u8(s568); + s2754 = table9[s2753]; + s2755 = s2752 ^ s2754; + s2756 = s2750 ^ s2755; + s2757 = s2748 ^ s2756; + s2758 = table9[s2747]; + s2759 = table6[s2749]; + s2760 = table7[s2751]; + s2761 = table8[s2753]; + s2762 = s2760 ^ s2761; + s2763 = s2759 ^ s2762; + s2764 = s2758 ^ s2763; + s2765 = sbv_bv_join_u8_u8_u16(s2757, s2764); + s2766 = table8[s2747]; + s2767 = table9[s2749]; + s2768 = table6[s2751]; + s2769 = table7[s2753]; + s2770 = s2768 ^ s2769; + s2771 = s2767 ^ s2770; + s2772 = s2766 ^ s2771; + s2773 = table7[s2747]; + s2774 = table8[s2749]; + s2775 = table9[s2751]; + s2776 = table6[s2753]; + s2777 = s2775 ^ s2776; + s2778 = s2774 ^ s2777; + s2779 = s2773 ^ s2778; + s2780 = sbv_bv_join_u8_u8_u16(s2772, s2779); + s2781 = sbv_bv_join_u16_u16_u32(s2765, s2780); + s2782 = s2746 ^ s2781; + s2783 = sbv_bv_extract_u32_7_0_u8(s2782); + s2784 = table5[s2783]; + s2785 = s2735 ^ s2784; + s2786 = sbv_bv_extract_u32_31_24_u8(s550); + s2787 = table6[s2786]; + s2788 = sbv_bv_extract_u32_23_16_u8(s550); + s2789 = table7[s2788]; + s2790 = sbv_bv_extract_u32_15_8_u8(s550); + s2791 = table8[s2790]; + s2792 = sbv_bv_extract_u32_7_0_u8(s550); + s2793 = table9[s2792]; + s2794 = s2791 ^ s2793; + s2795 = s2789 ^ s2794; + s2796 = s2787 ^ s2795; + s2797 = table9[s2786]; + s2798 = table6[s2788]; + s2799 = table7[s2790]; + s2800 = table8[s2792]; + s2801 = s2799 ^ s2800; + s2802 = s2798 ^ s2801; + s2803 = s2797 ^ s2802; + s2804 = sbv_bv_join_u8_u8_u16(s2796, s2803); + s2805 = table8[s2786]; + s2806 = table9[s2788]; + s2807 = table6[s2790]; + s2808 = table7[s2792]; + s2809 = s2807 ^ s2808; + s2810 = s2806 ^ s2809; + s2811 = s2805 ^ s2810; + s2812 = table7[s2786]; + s2813 = table8[s2788]; + s2814 = table9[s2790]; + s2815 = table6[s2792]; + s2816 = s2814 ^ s2815; + s2817 = s2813 ^ s2816; + s2818 = s2812 ^ s2817; + s2819 = sbv_bv_join_u8_u8_u16(s2811, s2818); + s2820 = sbv_bv_join_u16_u16_u32(s2804, s2819); + s2821 = s2785 ^ s2820; + s2822 = sbv_bv_extract_u32_31_24_u8(s2821); + s2823 = table1[s2822]; + s2824 = sbv_bv_extract_u32_31_24_u8(s2682); + s2825 = table1[s2824]; + s2826 = sbv_bv_extract_u32_23_16_u8(s2732); + s2827 = table3[s2826]; + s2828 = s2825 ^ s2827; + s2829 = sbv_bv_extract_u32_15_8_u8(s2782); + s2830 = table4[s2829]; + s2831 = s2828 ^ s2830; + s2832 = sbv_bv_extract_u32_7_0_u8(s2633); + s2833 = table5[s2832]; + s2834 = s2831 ^ s2833; + s2835 = sbv_bv_extract_u32_31_24_u8(s553); + s2836 = table6[s2835]; + s2837 = sbv_bv_extract_u32_23_16_u8(s553); + s2838 = table7[s2837]; + s2839 = sbv_bv_extract_u32_15_8_u8(s553); + s2840 = table8[s2839]; + s2841 = sbv_bv_extract_u32_7_0_u8(s553); + s2842 = table9[s2841]; + s2843 = s2840 ^ s2842; + s2844 = s2838 ^ s2843; + s2845 = s2836 ^ s2844; + s2846 = table9[s2835]; + s2847 = table6[s2837]; + s2848 = table7[s2839]; + s2849 = table8[s2841]; + s2850 = s2848 ^ s2849; + s2851 = s2847 ^ s2850; + s2852 = s2846 ^ s2851; + s2853 = sbv_bv_join_u8_u8_u16(s2845, s2852); + s2854 = table8[s2835]; + s2855 = table9[s2837]; + s2856 = table6[s2839]; + s2857 = table7[s2841]; + s2858 = s2856 ^ s2857; + s2859 = s2855 ^ s2858; + s2860 = s2854 ^ s2859; + s2861 = table7[s2835]; + s2862 = table8[s2837]; + s2863 = table9[s2839]; + s2864 = table6[s2841]; + s2865 = s2863 ^ s2864; + s2866 = s2862 ^ s2865; + s2867 = s2861 ^ s2866; + s2868 = sbv_bv_join_u8_u8_u16(s2860, s2867); + s2869 = sbv_bv_join_u16_u16_u32(s2853, s2868); + s2870 = s2834 ^ s2869; + s2871 = sbv_bv_extract_u32_23_16_u8(s2870); + s2872 = table3[s2871]; + s2873 = s2823 ^ s2872; + s2874 = sbv_bv_extract_u32_31_24_u8(s2732); + s2875 = table1[s2874]; + s2876 = sbv_bv_extract_u32_23_16_u8(s2782); + s2877 = table3[s2876]; + s2878 = s2875 ^ s2877; + s2879 = sbv_bv_extract_u32_15_8_u8(s2633); + s2880 = table4[s2879]; + s2881 = s2878 ^ s2880; + s2882 = sbv_bv_extract_u32_7_0_u8(s2682); + s2883 = table5[s2882]; + s2884 = s2881 ^ s2883; + s2885 = sbv_bv_extract_u32_31_24_u8(s552); + s2886 = table6[s2885]; + s2887 = sbv_bv_extract_u32_23_16_u8(s552); + s2888 = table7[s2887]; + s2889 = sbv_bv_extract_u32_15_8_u8(s552); + s2890 = table8[s2889]; + s2891 = sbv_bv_extract_u32_7_0_u8(s552); + s2892 = table9[s2891]; + s2893 = s2890 ^ s2892; + s2894 = s2888 ^ s2893; + s2895 = s2886 ^ s2894; + s2896 = table9[s2885]; + s2897 = table6[s2887]; + s2898 = table7[s2889]; + s2899 = table8[s2891]; + s2900 = s2898 ^ s2899; + s2901 = s2897 ^ s2900; + s2902 = s2896 ^ s2901; + s2903 = sbv_bv_join_u8_u8_u16(s2895, s2902); + s2904 = table8[s2885]; + s2905 = table9[s2887]; + s2906 = table6[s2889]; + s2907 = table7[s2891]; + s2908 = s2906 ^ s2907; + s2909 = s2905 ^ s2908; + s2910 = s2904 ^ s2909; + s2911 = table7[s2885]; + s2912 = table8[s2887]; + s2913 = table9[s2889]; + s2914 = table6[s2891]; + s2915 = s2913 ^ s2914; + s2916 = s2912 ^ s2915; + s2917 = s2911 ^ s2916; + s2918 = sbv_bv_join_u8_u8_u16(s2910, s2917); + s2919 = sbv_bv_join_u16_u16_u32(s2903, s2918); + s2920 = s2884 ^ s2919; + s2921 = sbv_bv_extract_u32_15_8_u8(s2920); + s2922 = table4[s2921]; + s2923 = s2873 ^ s2922; + s2924 = sbv_bv_extract_u32_31_24_u8(s2782); + s2925 = table1[s2924]; + s2926 = sbv_bv_extract_u32_23_16_u8(s2633); + s2927 = table3[s2926]; + s2928 = s2925 ^ s2927; + s2929 = sbv_bv_extract_u32_15_8_u8(s2682); + s2930 = table4[s2929]; + s2931 = s2928 ^ s2930; + s2932 = sbv_bv_extract_u32_7_0_u8(s2732); + s2933 = table5[s2932]; + s2934 = s2931 ^ s2933; + s2935 = sbv_bv_extract_u32_31_24_u8(s551); + s2936 = table6[s2935]; + s2937 = sbv_bv_extract_u32_23_16_u8(s551); + s2938 = table7[s2937]; + s2939 = sbv_bv_extract_u32_15_8_u8(s551); + s2940 = table8[s2939]; + s2941 = sbv_bv_extract_u32_7_0_u8(s551); + s2942 = table9[s2941]; + s2943 = s2940 ^ s2942; + s2944 = s2938 ^ s2943; + s2945 = s2936 ^ s2944; + s2946 = table9[s2935]; + s2947 = table6[s2937]; + s2948 = table7[s2939]; + s2949 = table8[s2941]; + s2950 = s2948 ^ s2949; + s2951 = s2947 ^ s2950; + s2952 = s2946 ^ s2951; + s2953 = sbv_bv_join_u8_u8_u16(s2945, s2952); + s2954 = table8[s2935]; + s2955 = table9[s2937]; + s2956 = table6[s2939]; + s2957 = table7[s2941]; + s2958 = s2956 ^ s2957; + s2959 = s2955 ^ s2958; + s2960 = s2954 ^ s2959; + s2961 = table7[s2935]; + s2962 = table8[s2937]; + s2963 = table9[s2939]; + s2964 = table6[s2941]; + s2965 = s2963 ^ s2964; + s2966 = s2962 ^ s2965; + s2967 = s2961 ^ s2966; + s2968 = sbv_bv_join_u8_u8_u16(s2960, s2967); + s2969 = sbv_bv_join_u16_u16_u32(s2953, s2968); + s2970 = s2934 ^ s2969; + s2971 = sbv_bv_extract_u32_7_0_u8(s2970); + s2972 = table5[s2971]; + s2973 = s2923 ^ s2972; + s2974 = sbv_bv_extract_u32_31_24_u8(s533); + s2975 = table6[s2974]; + s2976 = sbv_bv_extract_u32_23_16_u8(s533); + s2977 = table7[s2976]; + s2978 = sbv_bv_extract_u32_15_8_u8(s533); + s2979 = table8[s2978]; + s2980 = sbv_bv_extract_u32_7_0_u8(s533); + s2981 = table9[s2980]; + s2982 = s2979 ^ s2981; + s2983 = s2977 ^ s2982; + s2984 = s2975 ^ s2983; + s2985 = table9[s2974]; + s2986 = table6[s2976]; + s2987 = table7[s2978]; + s2988 = table8[s2980]; + s2989 = s2987 ^ s2988; + s2990 = s2986 ^ s2989; + s2991 = s2985 ^ s2990; + s2992 = sbv_bv_join_u8_u8_u16(s2984, s2991); + s2993 = table8[s2974]; + s2994 = table9[s2976]; + s2995 = table6[s2978]; + s2996 = table7[s2980]; + s2997 = s2995 ^ s2996; + s2998 = s2994 ^ s2997; + s2999 = s2993 ^ s2998; + s3000 = table7[s2974]; + s3001 = table8[s2976]; + s3002 = table9[s2978]; + s3003 = table6[s2980]; + s3004 = s3002 ^ s3003; + s3005 = s3001 ^ s3004; + s3006 = s3000 ^ s3005; + s3007 = sbv_bv_join_u8_u8_u16(s2999, s3006); + s3008 = sbv_bv_join_u16_u16_u32(s2992, s3007); + s3009 = s2973 ^ s3008; + s3010 = sbv_bv_extract_u32_31_24_u8(s3009); + 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 + }; + s3011 = table0[s3010]; + s3012 = sbv_bv_extract_u32_31_24_u8(s2870); + s3013 = table1[s3012]; + s3014 = sbv_bv_extract_u32_23_16_u8(s2920); + s3015 = table3[s3014]; + s3016 = s3013 ^ s3015; + s3017 = sbv_bv_extract_u32_15_8_u8(s2970); + s3018 = table4[s3017]; + s3019 = s3016 ^ s3018; + s3020 = sbv_bv_extract_u32_7_0_u8(s2821); + s3021 = table5[s3020]; + s3022 = s3019 ^ s3021; + s3023 = sbv_bv_extract_u32_31_24_u8(s536); + s3024 = table6[s3023]; + s3025 = sbv_bv_extract_u32_23_16_u8(s536); + s3026 = table7[s3025]; + s3027 = sbv_bv_extract_u32_15_8_u8(s536); + s3028 = table8[s3027]; + s3029 = sbv_bv_extract_u32_7_0_u8(s536); + s3030 = table9[s3029]; + s3031 = s3028 ^ s3030; + s3032 = s3026 ^ s3031; + s3033 = s3024 ^ s3032; + s3034 = table9[s3023]; + s3035 = table6[s3025]; + s3036 = table7[s3027]; + s3037 = table8[s3029]; + s3038 = s3036 ^ s3037; + s3039 = s3035 ^ s3038; + s3040 = s3034 ^ s3039; + s3041 = sbv_bv_join_u8_u8_u16(s3033, s3040); + s3042 = table8[s3023]; + s3043 = table9[s3025]; + s3044 = table6[s3027]; + s3045 = table7[s3029]; + s3046 = s3044 ^ s3045; + s3047 = s3043 ^ s3046; + s3048 = s3042 ^ s3047; + s3049 = table7[s3023]; + s3050 = table8[s3025]; + s3051 = table9[s3027]; + s3052 = table6[s3029]; + s3053 = s3051 ^ s3052; + s3054 = s3050 ^ s3053; + s3055 = s3049 ^ s3054; + s3056 = sbv_bv_join_u8_u8_u16(s3048, s3055); + s3057 = sbv_bv_join_u16_u16_u32(s3041, s3056); + s3058 = s3022 ^ s3057; + s3059 = sbv_bv_extract_u32_23_16_u8(s3058); + s3060 = table0[s3059]; + s3061 = sbv_bv_join_u8_u8_u16(s3011, s3060); + s3062 = sbv_bv_extract_u32_31_24_u8(s2920); + s3063 = table1[s3062]; + s3064 = sbv_bv_extract_u32_23_16_u8(s2970); + s3065 = table3[s3064]; + s3066 = s3063 ^ s3065; + s3067 = sbv_bv_extract_u32_15_8_u8(s2821); + s3068 = table4[s3067]; + s3069 = s3066 ^ s3068; + s3070 = sbv_bv_extract_u32_7_0_u8(s2870); + s3071 = table5[s3070]; + s3072 = s3069 ^ s3071; + s3073 = sbv_bv_extract_u32_31_24_u8(s535); + s3074 = table6[s3073]; + s3075 = sbv_bv_extract_u32_23_16_u8(s535); + s3076 = table7[s3075]; + s3077 = sbv_bv_extract_u32_15_8_u8(s535); + s3078 = table8[s3077]; + s3079 = sbv_bv_extract_u32_7_0_u8(s535); + s3080 = table9[s3079]; + s3081 = s3078 ^ s3080; + s3082 = s3076 ^ s3081; + s3083 = s3074 ^ s3082; + s3084 = table9[s3073]; + s3085 = table6[s3075]; + s3086 = table7[s3077]; + s3087 = table8[s3079]; + s3088 = s3086 ^ s3087; + s3089 = s3085 ^ s3088; + s3090 = s3084 ^ s3089; + s3091 = sbv_bv_join_u8_u8_u16(s3083, s3090); + s3092 = table8[s3073]; + s3093 = table9[s3075]; + s3094 = table6[s3077]; + s3095 = table7[s3079]; + s3096 = s3094 ^ s3095; + s3097 = s3093 ^ s3096; + s3098 = s3092 ^ s3097; + s3099 = table7[s3073]; + s3100 = table8[s3075]; + s3101 = table9[s3077]; + s3102 = table6[s3079]; + s3103 = s3101 ^ s3102; + s3104 = s3100 ^ s3103; + s3105 = s3099 ^ s3104; + s3106 = sbv_bv_join_u8_u8_u16(s3098, s3105); + s3107 = sbv_bv_join_u16_u16_u32(s3091, s3106); + s3108 = s3072 ^ s3107; + s3109 = sbv_bv_extract_u32_15_8_u8(s3108); + s3110 = table0[s3109]; + s3111 = sbv_bv_extract_u32_31_24_u8(s2970); + s3112 = table1[s3111]; + s3113 = sbv_bv_extract_u32_23_16_u8(s2821); + s3114 = table3[s3113]; + s3115 = s3112 ^ s3114; + s3116 = sbv_bv_extract_u32_15_8_u8(s2870); + s3117 = table4[s3116]; + s3118 = s3115 ^ s3117; + s3119 = sbv_bv_extract_u32_7_0_u8(s2920); + s3120 = table5[s3119]; + s3121 = s3118 ^ s3120; + s3122 = sbv_bv_extract_u32_31_24_u8(s534); + s3123 = table6[s3122]; + s3124 = sbv_bv_extract_u32_23_16_u8(s534); + s3125 = table7[s3124]; + s3126 = sbv_bv_extract_u32_15_8_u8(s534); + s3127 = table8[s3126]; + s3128 = sbv_bv_extract_u32_7_0_u8(s534); + s3129 = table9[s3128]; + s3130 = s3127 ^ s3129; + s3131 = s3125 ^ s3130; + s3132 = s3123 ^ s3131; + s3133 = table9[s3122]; + s3134 = table6[s3124]; + s3135 = table7[s3126]; + s3136 = table8[s3128]; + s3137 = s3135 ^ s3136; + s3138 = s3134 ^ s3137; + s3139 = s3133 ^ s3138; + s3140 = sbv_bv_join_u8_u8_u16(s3132, s3139); + s3141 = table8[s3122]; + s3142 = table9[s3124]; + s3143 = table6[s3126]; + s3144 = table7[s3128]; + s3145 = s3143 ^ s3144; + s3146 = s3142 ^ s3145; + s3147 = s3141 ^ s3146; + s3148 = table7[s3122]; + s3149 = table8[s3124]; + s3150 = table9[s3126]; + s3151 = table6[s3128]; + s3152 = s3150 ^ s3151; + s3153 = s3149 ^ s3152; + s3154 = s3148 ^ s3153; + s3155 = sbv_bv_join_u8_u8_u16(s3147, s3154); + s3156 = sbv_bv_join_u16_u16_u32(s3140, s3155); + s3157 = s3121 ^ s3156; + s3158 = sbv_bv_extract_u32_7_0_u8(s3157); + s3159 = table0[s3158]; + s3160 = sbv_bv_join_u8_u8_u16(s3110, s3159); + s3161 = sbv_bv_join_u16_u16_u32(s3061, s3160); + s3162 = s4 ^ s3161; + s3163 = sbv_bv_extract_u32_31_24_u8(s3157); + s3164 = table0[s3163]; + s3165 = sbv_bv_extract_u32_23_16_u8(s3009); + s3166 = table0[s3165]; + s3167 = sbv_bv_join_u8_u8_u16(s3164, s3166); + s3168 = sbv_bv_extract_u32_15_8_u8(s3058); + s3169 = table0[s3168]; + s3170 = sbv_bv_extract_u32_7_0_u8(s3108); + s3171 = table0[s3170]; + s3172 = sbv_bv_join_u8_u8_u16(s3169, s3171); + s3173 = sbv_bv_join_u16_u16_u32(s3167, s3172); + s3174 = s5 ^ s3173; + s3175 = sbv_bv_extract_u32_31_24_u8(s3108); + s3176 = table0[s3175]; + s3177 = sbv_bv_extract_u32_23_16_u8(s3157); + s3178 = table0[s3177]; + s3179 = sbv_bv_join_u8_u8_u16(s3176, s3178); + s3180 = sbv_bv_extract_u32_15_8_u8(s3009); + s3181 = table0[s3180]; + s3182 = sbv_bv_extract_u32_7_0_u8(s3058); + s3183 = table0[s3182]; + s3184 = sbv_bv_join_u8_u8_u16(s3181, s3183); + s3185 = sbv_bv_join_u16_u16_u32(s3179, s3184); + s3186 = s6 ^ s3185; + s3187 = sbv_bv_extract_u32_31_24_u8(s3058); + s3188 = table0[s3187]; + s3189 = sbv_bv_extract_u32_23_16_u8(s3108); + s3190 = table0[s3189]; + s3191 = sbv_bv_join_u8_u8_u16(s3188, s3190); + s3192 = sbv_bv_extract_u32_15_8_u8(s3157); + s3193 = table0[s3192]; + s3194 = sbv_bv_extract_u32_7_0_u8(s3009); + s3195 = table0[s3194]; + s3196 = sbv_bv_join_u8_u8_u16(s3193, s3195); + s3197 = sbv_bv_join_u16_u16_u32(s3191, s3196); + s3198 = s7 ^ s3197; + + sbv_output_0[0] = s3162; + sbv_output_0[1] = s3174; + sbv_output_0[2] = s3186; + sbv_output_0[3] = s3198; } == END: "aes128Dec.c" ================== diff --git a/SBVTestSuite/GoldFiles/aes128Enc.gold b/SBVTestSuite/GoldFiles/aes128Enc.gold --- a/SBVTestSuite/GoldFiles/aes128Enc.gold +++ b/SBVTestSuite/GoldFiles/aes128Enc.gold @@ -12,1056 +12,1776 @@ 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 -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* Entry point prototype: */ -void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct); - -#endif /* __aes128Enc__HEADER_INCLUDED__ */ -== END: "aes128Enc.h" ================== -== BEGIN: "aes128Enc_driver.c" ================ -/* Example driver program for aes128Enc. */ -/* Automatically generated by SBV. Edit as you see fit! */ - -#include -#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[%1d] = 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[%1d] = 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[%1d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); - - return 0; -} -== END: "aes128Enc_driver.c" ================== -== BEGIN: "aes128Enc.c" ================ -/* File: "aes128Enc.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Enc.h" - -void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct) -{ - const SWord32 s0 = pt[0]; - const SWord32 s1 = pt[1]; - const SWord32 s2 = pt[2]; - const SWord32 s3 = pt[3]; - const SWord32 s4 = key[0]; - const SWord32 s5 = key[1]; - const SWord32 s6 = key[2]; - const SWord32 s7 = key[3]; - static const SWord8 table0[] = { - 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, - 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, - 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, - 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, - 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, - 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, - 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, - 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, - 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, - 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, - 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, - 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, - 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, - 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, - 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, - 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, - 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, - 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, - 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, - 104, 65, 153, 45, 15, 176, 84, 187, 22 - }; - static const SWord32 table1[] = { - 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, - 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, - 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, - 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, - 0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL, - 0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL, - 0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL, - 0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL, - 0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL, - 0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL, - 0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL, - 0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL, - 0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL, - 0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL, - 0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL, - 0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL, - 0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL, - 0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL, - 0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL, - 0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL, - 0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL, - 0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL, - 0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL, - 0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL, - 0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL, - 0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL, - 0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL, - 0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL, - 0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL, - 0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL, - 0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL, - 0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL, - 0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL, - 0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL, - 0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL, - 0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL, - 0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL, - 0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL, - 0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL, - 0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL, - 0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL, - 0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL, - 0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL, - 0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL, - 0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL, - 0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL, - 0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL, - 0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL, - 0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL, - 0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL, - 0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL, - 0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL, - 0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL, - 0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL, - 0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL, - 0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL, - 0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL, - 0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL, - 0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL, - 0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL, - 0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL, - 0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL, - 0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL, - 0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL - }; - static const SWord32 table2[] = { - 0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL, - 0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL, - 0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL, - 0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL, - 0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL, - 0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL, - 0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL, - 0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL, - 0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL, - 0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL, - 0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL, - 0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL, - 0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL, - 0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL, - 0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL, - 0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL, - 0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL, - 0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL, - 0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL, - 0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL, - 0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL, - 0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL, - 0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL, - 0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL, - 0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL, - 0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL, - 0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL, - 0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL, - 0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL, - 0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL, - 0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL, - 0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL, - 0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL, - 0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL, - 0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL, - 0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL, - 0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL, - 0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL, - 0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL, - 0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL, - 0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL, - 0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL, - 0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL, - 0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL, - 0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL, - 0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL, - 0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL, - 0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL, - 0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL, - 0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL, - 0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL, - 0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL, - 0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL, - 0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL, - 0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL, - 0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL, - 0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL, - 0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL, - 0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL, - 0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL, - 0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL, - 0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL, - 0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL, - 0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL - }; - static const SWord32 table3[] = { - 0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL, - 0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL, - 0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL, - 0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL, - 0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL, - 0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL, - 0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL, - 0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL, - 0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL, - 0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL, - 0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL, - 0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL, - 0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL, - 0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL, - 0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL, - 0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL, - 0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL, - 0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL, - 0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL, - 0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL, - 0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL, - 0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL, - 0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL, - 0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL, - 0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL, - 0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL, - 0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL, - 0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL, - 0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL, - 0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL, - 0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL, - 0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL, - 0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL, - 0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL, - 0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL, - 0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL, - 0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL, - 0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL, - 0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL, - 0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL, - 0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL, - 0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL, - 0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL, - 0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL, - 0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL, - 0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL, - 0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL, - 0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL, - 0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL, - 0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL, - 0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL, - 0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL, - 0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL, - 0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL, - 0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL, - 0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL, - 0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL, - 0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL, - 0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL, - 0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL, - 0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL, - 0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL, - 0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL, - 0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL - }; - static const SWord32 table4[] = { - 0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL, - 0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL, - 0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL, - 0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL, - 0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL, - 0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL, - 0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL, - 0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL, - 0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL, - 0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL, - 0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL, - 0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL, - 0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL, - 0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL, - 0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL, - 0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL, - 0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL, - 0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL, - 0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL, - 0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL, - 0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL, - 0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL, - 0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL, - 0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL, - 0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL, - 0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL, - 0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL, - 0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL, - 0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL, - 0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL, - 0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL, - 0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL, - 0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL, - 0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL, - 0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL, - 0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL, - 0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL, - 0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL, - 0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL, - 0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL, - 0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL, - 0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL, - 0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL, - 0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL, - 0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL, - 0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL, - 0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL, - 0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL, - 0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL, - 0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL, - 0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL, - 0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL, - 0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL, - 0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL, - 0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL, - 0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL, - 0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL, - 0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL, - 0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL, - 0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL, - 0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL, - 0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL, - 0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL, - 0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL - }; - const SWord32 s520 = s0 ^ s4; - const SWord8 s521 = (SWord8) (s520 >> 24); - const SWord32 s522 = table1[s521]; - const SWord32 s778 = s1 ^ s5; - const SWord8 s779 = (SWord8) (s778 >> 16); - const SWord32 s780 = table2[s779]; - const SWord32 s781 = s522 ^ s780; - const SWord32 s1037 = s2 ^ s6; - const SWord8 s1038 = (SWord8) (s1037 >> 8); - const SWord32 s1039 = table3[s1038]; - const SWord32 s1040 = s781 ^ s1039; - const SWord32 s1296 = s3 ^ s7; - const SWord8 s1297 = (SWord8) s1296; - const SWord32 s1298 = table4[s1297]; - const SWord32 s1299 = s1040 ^ s1298; - const SWord32 s1300 = (s7 << 8) | (s7 >> 24); - const SWord8 s1301 = (SWord8) (s1300 >> 24); - const SWord8 s1302 = table0[s1301]; - const SWord8 s1303 = 1 ^ s1302; - const SWord8 s1304 = (SWord8) (s1300 >> 16); - const SWord8 s1305 = table0[s1304]; - const SWord16 s1306 = (((SWord16) s1303) << 8) | ((SWord16) s1305); - const SWord8 s1307 = (SWord8) (s1300 >> 8); - const SWord8 s1308 = table0[s1307]; - const SWord8 s1309 = (SWord8) s1300; - const SWord8 s1310 = table0[s1309]; - const SWord16 s1311 = (((SWord16) s1308) << 8) | ((SWord16) s1310); - const SWord32 s1312 = (((SWord32) s1306) << 16) | ((SWord32) s1311); - const SWord32 s1313 = s4 ^ s1312; - const SWord32 s1314 = s1299 ^ s1313; - const SWord8 s1315 = (SWord8) (s1314 >> 24); - const SWord32 s1316 = table1[s1315]; - const SWord8 s1317 = (SWord8) (s778 >> 24); - const SWord32 s1318 = table1[s1317]; - const SWord8 s1319 = (SWord8) (s1037 >> 16); - const SWord32 s1320 = table2[s1319]; - const SWord32 s1321 = s1318 ^ s1320; - const SWord8 s1322 = (SWord8) (s1296 >> 8); - const SWord32 s1323 = table3[s1322]; - const SWord32 s1324 = s1321 ^ s1323; - const SWord8 s1325 = (SWord8) s520; - const SWord32 s1326 = table4[s1325]; - const SWord32 s1327 = s1324 ^ s1326; - const SWord32 s1328 = s5 ^ s1313; - const SWord32 s1329 = s1327 ^ s1328; - const SWord8 s1330 = (SWord8) (s1329 >> 16); - const SWord32 s1331 = table2[s1330]; - const SWord32 s1332 = s1316 ^ s1331; - const SWord8 s1333 = (SWord8) (s1037 >> 24); - const SWord32 s1334 = table1[s1333]; - const SWord8 s1335 = (SWord8) (s1296 >> 16); - const SWord32 s1336 = table2[s1335]; - const SWord32 s1337 = s1334 ^ s1336; - const SWord8 s1338 = (SWord8) (s520 >> 8); - const SWord32 s1339 = table3[s1338]; - const SWord32 s1340 = s1337 ^ s1339; - const SWord8 s1341 = (SWord8) s778; - const SWord32 s1342 = table4[s1341]; - const SWord32 s1343 = s1340 ^ s1342; - const SWord32 s1344 = s6 ^ s1328; - const SWord32 s1345 = s1343 ^ s1344; - const SWord8 s1346 = (SWord8) (s1345 >> 8); - const SWord32 s1347 = table3[s1346]; - const SWord32 s1348 = s1332 ^ s1347; - const SWord8 s1349 = (SWord8) (s1296 >> 24); - const SWord32 s1350 = table1[s1349]; - const SWord8 s1351 = (SWord8) (s520 >> 16); - const SWord32 s1352 = table2[s1351]; - const SWord32 s1353 = s1350 ^ s1352; - const SWord8 s1354 = (SWord8) (s778 >> 8); - const SWord32 s1355 = table3[s1354]; - const SWord32 s1356 = s1353 ^ s1355; - const SWord8 s1357 = (SWord8) s1037; - const SWord32 s1358 = table4[s1357]; - const SWord32 s1359 = s1356 ^ s1358; - const SWord32 s1360 = s7 ^ s1344; - const SWord32 s1361 = s1359 ^ s1360; - const SWord8 s1362 = (SWord8) s1361; - const SWord32 s1363 = table4[s1362]; - const SWord32 s1364 = s1348 ^ s1363; - const SWord32 s1365 = (s1360 << 8) | (s1360 >> 24); - const SWord8 s1366 = (SWord8) (s1365 >> 24); - const SWord8 s1367 = table0[s1366]; - const SWord8 s1368 = 2 ^ s1367; - const SWord8 s1369 = (SWord8) (s1365 >> 16); - const SWord8 s1370 = table0[s1369]; - const SWord16 s1371 = (((SWord16) s1368) << 8) | ((SWord16) s1370); - const SWord8 s1372 = (SWord8) (s1365 >> 8); - const SWord8 s1373 = table0[s1372]; - const SWord8 s1374 = (SWord8) s1365; - const SWord8 s1375 = table0[s1374]; - const SWord16 s1376 = (((SWord16) s1373) << 8) | ((SWord16) s1375); - const SWord32 s1377 = (((SWord32) s1371) << 16) | ((SWord32) s1376); - const SWord32 s1378 = s1313 ^ s1377; - const SWord32 s1379 = s1364 ^ s1378; - const SWord8 s1380 = (SWord8) (s1379 >> 24); - const SWord32 s1381 = table1[s1380]; - const SWord8 s1382 = (SWord8) (s1329 >> 24); - const SWord32 s1383 = table1[s1382]; - const SWord8 s1384 = (SWord8) (s1345 >> 16); - const SWord32 s1385 = table2[s1384]; - const SWord32 s1386 = s1383 ^ s1385; - const SWord8 s1387 = (SWord8) (s1361 >> 8); - const SWord32 s1388 = table3[s1387]; - const SWord32 s1389 = s1386 ^ s1388; - const SWord8 s1390 = (SWord8) s1314; - const SWord32 s1391 = table4[s1390]; - const SWord32 s1392 = s1389 ^ s1391; - const SWord32 s1393 = s1328 ^ s1378; - const SWord32 s1394 = s1392 ^ s1393; - const SWord8 s1395 = (SWord8) (s1394 >> 16); - const SWord32 s1396 = table2[s1395]; - const SWord32 s1397 = s1381 ^ s1396; - const SWord8 s1398 = (SWord8) (s1345 >> 24); - const SWord32 s1399 = table1[s1398]; - const SWord8 s1400 = (SWord8) (s1361 >> 16); - const SWord32 s1401 = table2[s1400]; - const SWord32 s1402 = s1399 ^ s1401; - const SWord8 s1403 = (SWord8) (s1314 >> 8); - const SWord32 s1404 = table3[s1403]; - const SWord32 s1405 = s1402 ^ s1404; - const SWord8 s1406 = (SWord8) s1329; - const SWord32 s1407 = table4[s1406]; - const SWord32 s1408 = s1405 ^ s1407; - const SWord32 s1409 = s1344 ^ s1393; - const SWord32 s1410 = s1408 ^ s1409; - const SWord8 s1411 = (SWord8) (s1410 >> 8); - const SWord32 s1412 = table3[s1411]; - const SWord32 s1413 = s1397 ^ s1412; - const SWord8 s1414 = (SWord8) (s1361 >> 24); - const SWord32 s1415 = table1[s1414]; - const SWord8 s1416 = (SWord8) (s1314 >> 16); - const SWord32 s1417 = table2[s1416]; - const SWord32 s1418 = s1415 ^ s1417; - const SWord8 s1419 = (SWord8) (s1329 >> 8); - const SWord32 s1420 = table3[s1419]; - const SWord32 s1421 = s1418 ^ s1420; - const SWord8 s1422 = (SWord8) s1345; - const SWord32 s1423 = table4[s1422]; - const SWord32 s1424 = s1421 ^ s1423; - const SWord32 s1425 = s1360 ^ s1409; - const SWord32 s1426 = s1424 ^ s1425; - const SWord8 s1427 = (SWord8) s1426; - const SWord32 s1428 = table4[s1427]; - const SWord32 s1429 = s1413 ^ s1428; - const SWord32 s1430 = (s1425 << 8) | (s1425 >> 24); - const SWord8 s1431 = (SWord8) (s1430 >> 24); - const SWord8 s1432 = table0[s1431]; - const SWord8 s1433 = 4 ^ s1432; - const SWord8 s1434 = (SWord8) (s1430 >> 16); - const SWord8 s1435 = table0[s1434]; - const SWord16 s1436 = (((SWord16) s1433) << 8) | ((SWord16) s1435); - const SWord8 s1437 = (SWord8) (s1430 >> 8); - const SWord8 s1438 = table0[s1437]; - const SWord8 s1439 = (SWord8) s1430; - const SWord8 s1440 = table0[s1439]; - const SWord16 s1441 = (((SWord16) s1438) << 8) | ((SWord16) s1440); - const SWord32 s1442 = (((SWord32) s1436) << 16) | ((SWord32) s1441); - const SWord32 s1443 = s1378 ^ s1442; - const SWord32 s1444 = s1429 ^ s1443; - const SWord8 s1445 = (SWord8) (s1444 >> 24); - const SWord32 s1446 = table1[s1445]; - const SWord8 s1447 = (SWord8) (s1394 >> 24); - const SWord32 s1448 = table1[s1447]; - const SWord8 s1449 = (SWord8) (s1410 >> 16); - const SWord32 s1450 = table2[s1449]; - const SWord32 s1451 = s1448 ^ s1450; - const SWord8 s1452 = (SWord8) (s1426 >> 8); - const SWord32 s1453 = table3[s1452]; - const SWord32 s1454 = s1451 ^ s1453; - const SWord8 s1455 = (SWord8) s1379; - const SWord32 s1456 = table4[s1455]; - const SWord32 s1457 = s1454 ^ s1456; - const SWord32 s1458 = s1393 ^ s1443; - const SWord32 s1459 = s1457 ^ s1458; - const SWord8 s1460 = (SWord8) (s1459 >> 16); - const SWord32 s1461 = table2[s1460]; - const SWord32 s1462 = s1446 ^ s1461; - const SWord8 s1463 = (SWord8) (s1410 >> 24); - const SWord32 s1464 = table1[s1463]; - const SWord8 s1465 = (SWord8) (s1426 >> 16); - const SWord32 s1466 = table2[s1465]; - const SWord32 s1467 = s1464 ^ s1466; - const SWord8 s1468 = (SWord8) (s1379 >> 8); - const SWord32 s1469 = table3[s1468]; - const SWord32 s1470 = s1467 ^ s1469; - const SWord8 s1471 = (SWord8) s1394; - const SWord32 s1472 = table4[s1471]; - const SWord32 s1473 = s1470 ^ s1472; - const SWord32 s1474 = s1409 ^ s1458; - const SWord32 s1475 = s1473 ^ s1474; - const SWord8 s1476 = (SWord8) (s1475 >> 8); - const SWord32 s1477 = table3[s1476]; - const SWord32 s1478 = s1462 ^ s1477; - const SWord8 s1479 = (SWord8) (s1426 >> 24); - const SWord32 s1480 = table1[s1479]; - const SWord8 s1481 = (SWord8) (s1379 >> 16); - const SWord32 s1482 = table2[s1481]; - const SWord32 s1483 = s1480 ^ s1482; - const SWord8 s1484 = (SWord8) (s1394 >> 8); - const SWord32 s1485 = table3[s1484]; - const SWord32 s1486 = s1483 ^ s1485; - const SWord8 s1487 = (SWord8) s1410; - const SWord32 s1488 = table4[s1487]; - const SWord32 s1489 = s1486 ^ s1488; - const SWord32 s1490 = s1425 ^ s1474; - const SWord32 s1491 = s1489 ^ s1490; - const SWord8 s1492 = (SWord8) s1491; - const SWord32 s1493 = table4[s1492]; - const SWord32 s1494 = s1478 ^ s1493; - const SWord32 s1495 = (s1490 << 8) | (s1490 >> 24); - const SWord8 s1496 = (SWord8) (s1495 >> 24); - const SWord8 s1497 = table0[s1496]; - const SWord8 s1498 = 8 ^ s1497; - const SWord8 s1499 = (SWord8) (s1495 >> 16); - const SWord8 s1500 = table0[s1499]; - const SWord16 s1501 = (((SWord16) s1498) << 8) | ((SWord16) s1500); - const SWord8 s1502 = (SWord8) (s1495 >> 8); - const SWord8 s1503 = table0[s1502]; - const SWord8 s1504 = (SWord8) s1495; - const SWord8 s1505 = table0[s1504]; - const SWord16 s1506 = (((SWord16) s1503) << 8) | ((SWord16) s1505); - const SWord32 s1507 = (((SWord32) s1501) << 16) | ((SWord32) s1506); - const SWord32 s1508 = s1443 ^ s1507; - const SWord32 s1509 = s1494 ^ s1508; - const SWord8 s1510 = (SWord8) (s1509 >> 24); - const SWord32 s1511 = table1[s1510]; - const SWord8 s1512 = (SWord8) (s1459 >> 24); - const SWord32 s1513 = table1[s1512]; - const SWord8 s1514 = (SWord8) (s1475 >> 16); - const SWord32 s1515 = table2[s1514]; - const SWord32 s1516 = s1513 ^ s1515; - const SWord8 s1517 = (SWord8) (s1491 >> 8); - const SWord32 s1518 = table3[s1517]; - const SWord32 s1519 = s1516 ^ s1518; - const SWord8 s1520 = (SWord8) s1444; - const SWord32 s1521 = table4[s1520]; - const SWord32 s1522 = s1519 ^ s1521; - const SWord32 s1523 = s1458 ^ s1508; - const SWord32 s1524 = s1522 ^ s1523; - const SWord8 s1525 = (SWord8) (s1524 >> 16); - const SWord32 s1526 = table2[s1525]; - const SWord32 s1527 = s1511 ^ s1526; - const SWord8 s1528 = (SWord8) (s1475 >> 24); - const SWord32 s1529 = table1[s1528]; - const SWord8 s1530 = (SWord8) (s1491 >> 16); - const SWord32 s1531 = table2[s1530]; - const SWord32 s1532 = s1529 ^ s1531; - const SWord8 s1533 = (SWord8) (s1444 >> 8); - const SWord32 s1534 = table3[s1533]; - const SWord32 s1535 = s1532 ^ s1534; - const SWord8 s1536 = (SWord8) s1459; - const SWord32 s1537 = table4[s1536]; - const SWord32 s1538 = s1535 ^ s1537; - const SWord32 s1539 = s1474 ^ s1523; - const SWord32 s1540 = s1538 ^ s1539; - const SWord8 s1541 = (SWord8) (s1540 >> 8); - const SWord32 s1542 = table3[s1541]; - const SWord32 s1543 = s1527 ^ s1542; - const SWord8 s1544 = (SWord8) (s1491 >> 24); - const SWord32 s1545 = table1[s1544]; - const SWord8 s1546 = (SWord8) (s1444 >> 16); - const SWord32 s1547 = table2[s1546]; - const SWord32 s1548 = s1545 ^ s1547; - const SWord8 s1549 = (SWord8) (s1459 >> 8); - const SWord32 s1550 = table3[s1549]; - const SWord32 s1551 = s1548 ^ s1550; - const SWord8 s1552 = (SWord8) s1475; - const SWord32 s1553 = table4[s1552]; - const SWord32 s1554 = s1551 ^ s1553; - const SWord32 s1555 = s1490 ^ s1539; - const SWord32 s1556 = s1554 ^ s1555; - const SWord8 s1557 = (SWord8) s1556; - const SWord32 s1558 = table4[s1557]; - const SWord32 s1559 = s1543 ^ s1558; - const SWord32 s1560 = (s1555 << 8) | (s1555 >> 24); - const SWord8 s1561 = (SWord8) (s1560 >> 24); - const SWord8 s1562 = table0[s1561]; - const SWord8 s1563 = 16 ^ s1562; - const SWord8 s1564 = (SWord8) (s1560 >> 16); - const SWord8 s1565 = table0[s1564]; - const SWord16 s1566 = (((SWord16) s1563) << 8) | ((SWord16) s1565); - const SWord8 s1567 = (SWord8) (s1560 >> 8); - const SWord8 s1568 = table0[s1567]; - const SWord8 s1569 = (SWord8) s1560; - const SWord8 s1570 = table0[s1569]; - const SWord16 s1571 = (((SWord16) s1568) << 8) | ((SWord16) s1570); - const SWord32 s1572 = (((SWord32) s1566) << 16) | ((SWord32) s1571); - const SWord32 s1573 = s1508 ^ s1572; - const SWord32 s1574 = s1559 ^ s1573; - const SWord8 s1575 = (SWord8) (s1574 >> 24); - const SWord32 s1576 = table1[s1575]; - const SWord8 s1577 = (SWord8) (s1524 >> 24); - const SWord32 s1578 = table1[s1577]; - const SWord8 s1579 = (SWord8) (s1540 >> 16); - const SWord32 s1580 = table2[s1579]; - const SWord32 s1581 = s1578 ^ s1580; - const SWord8 s1582 = (SWord8) (s1556 >> 8); - const SWord32 s1583 = table3[s1582]; - const SWord32 s1584 = s1581 ^ s1583; - const SWord8 s1585 = (SWord8) s1509; - const SWord32 s1586 = table4[s1585]; - const SWord32 s1587 = s1584 ^ s1586; - const SWord32 s1588 = s1523 ^ s1573; - const SWord32 s1589 = s1587 ^ s1588; - const SWord8 s1590 = (SWord8) (s1589 >> 16); - const SWord32 s1591 = table2[s1590]; - const SWord32 s1592 = s1576 ^ s1591; - const SWord8 s1593 = (SWord8) (s1540 >> 24); - const SWord32 s1594 = table1[s1593]; - const SWord8 s1595 = (SWord8) (s1556 >> 16); - const SWord32 s1596 = table2[s1595]; - const SWord32 s1597 = s1594 ^ s1596; - const SWord8 s1598 = (SWord8) (s1509 >> 8); - const SWord32 s1599 = table3[s1598]; - const SWord32 s1600 = s1597 ^ s1599; - const SWord8 s1601 = (SWord8) s1524; - const SWord32 s1602 = table4[s1601]; - const SWord32 s1603 = s1600 ^ s1602; - const SWord32 s1604 = s1539 ^ s1588; - const SWord32 s1605 = s1603 ^ s1604; - const SWord8 s1606 = (SWord8) (s1605 >> 8); - const SWord32 s1607 = table3[s1606]; - const SWord32 s1608 = s1592 ^ s1607; - const SWord8 s1609 = (SWord8) (s1556 >> 24); - const SWord32 s1610 = table1[s1609]; - const SWord8 s1611 = (SWord8) (s1509 >> 16); - const SWord32 s1612 = table2[s1611]; - const SWord32 s1613 = s1610 ^ s1612; - const SWord8 s1614 = (SWord8) (s1524 >> 8); - const SWord32 s1615 = table3[s1614]; - const SWord32 s1616 = s1613 ^ s1615; - const SWord8 s1617 = (SWord8) s1540; - const SWord32 s1618 = table4[s1617]; - const SWord32 s1619 = s1616 ^ s1618; - const SWord32 s1620 = s1555 ^ s1604; - const SWord32 s1621 = s1619 ^ s1620; - const SWord8 s1622 = (SWord8) s1621; - const SWord32 s1623 = table4[s1622]; - const SWord32 s1624 = s1608 ^ s1623; - const SWord32 s1625 = (s1620 << 8) | (s1620 >> 24); - const SWord8 s1626 = (SWord8) (s1625 >> 24); - const SWord8 s1627 = table0[s1626]; - const SWord8 s1628 = 32 ^ s1627; - const SWord8 s1629 = (SWord8) (s1625 >> 16); - const SWord8 s1630 = table0[s1629]; - const SWord16 s1631 = (((SWord16) s1628) << 8) | ((SWord16) s1630); - const SWord8 s1632 = (SWord8) (s1625 >> 8); - const SWord8 s1633 = table0[s1632]; - const SWord8 s1634 = (SWord8) s1625; - const SWord8 s1635 = table0[s1634]; - const SWord16 s1636 = (((SWord16) s1633) << 8) | ((SWord16) s1635); - const SWord32 s1637 = (((SWord32) s1631) << 16) | ((SWord32) s1636); - const SWord32 s1638 = s1573 ^ s1637; - const SWord32 s1639 = s1624 ^ s1638; - const SWord8 s1640 = (SWord8) (s1639 >> 24); - const SWord32 s1641 = table1[s1640]; - const SWord8 s1642 = (SWord8) (s1589 >> 24); - const SWord32 s1643 = table1[s1642]; - const SWord8 s1644 = (SWord8) (s1605 >> 16); - const SWord32 s1645 = table2[s1644]; - const SWord32 s1646 = s1643 ^ s1645; - const SWord8 s1647 = (SWord8) (s1621 >> 8); - const SWord32 s1648 = table3[s1647]; - const SWord32 s1649 = s1646 ^ s1648; - const SWord8 s1650 = (SWord8) s1574; - const SWord32 s1651 = table4[s1650]; - const SWord32 s1652 = s1649 ^ s1651; - const SWord32 s1653 = s1588 ^ s1638; - const SWord32 s1654 = s1652 ^ s1653; - const SWord8 s1655 = (SWord8) (s1654 >> 16); - const SWord32 s1656 = table2[s1655]; - const SWord32 s1657 = s1641 ^ s1656; - const SWord8 s1658 = (SWord8) (s1605 >> 24); - const SWord32 s1659 = table1[s1658]; - const SWord8 s1660 = (SWord8) (s1621 >> 16); - const SWord32 s1661 = table2[s1660]; - const SWord32 s1662 = s1659 ^ s1661; - const SWord8 s1663 = (SWord8) (s1574 >> 8); - const SWord32 s1664 = table3[s1663]; - const SWord32 s1665 = s1662 ^ s1664; - const SWord8 s1666 = (SWord8) s1589; - const SWord32 s1667 = table4[s1666]; - const SWord32 s1668 = s1665 ^ s1667; - const SWord32 s1669 = s1604 ^ s1653; - const SWord32 s1670 = s1668 ^ s1669; - const SWord8 s1671 = (SWord8) (s1670 >> 8); - const SWord32 s1672 = table3[s1671]; - const SWord32 s1673 = s1657 ^ s1672; - const SWord8 s1674 = (SWord8) (s1621 >> 24); - const SWord32 s1675 = table1[s1674]; - const SWord8 s1676 = (SWord8) (s1574 >> 16); - const SWord32 s1677 = table2[s1676]; - const SWord32 s1678 = s1675 ^ s1677; - const SWord8 s1679 = (SWord8) (s1589 >> 8); - const SWord32 s1680 = table3[s1679]; - const SWord32 s1681 = s1678 ^ s1680; - const SWord8 s1682 = (SWord8) s1605; - const SWord32 s1683 = table4[s1682]; - const SWord32 s1684 = s1681 ^ s1683; - const SWord32 s1685 = s1620 ^ s1669; - const SWord32 s1686 = s1684 ^ s1685; - const SWord8 s1687 = (SWord8) s1686; - const SWord32 s1688 = table4[s1687]; - const SWord32 s1689 = s1673 ^ s1688; - const SWord32 s1690 = (s1685 << 8) | (s1685 >> 24); - const SWord8 s1691 = (SWord8) (s1690 >> 24); - const SWord8 s1692 = table0[s1691]; - const SWord8 s1693 = 64 ^ s1692; - const SWord8 s1694 = (SWord8) (s1690 >> 16); - const SWord8 s1695 = table0[s1694]; - const SWord16 s1696 = (((SWord16) s1693) << 8) | ((SWord16) s1695); - const SWord8 s1697 = (SWord8) (s1690 >> 8); - const SWord8 s1698 = table0[s1697]; - const SWord8 s1699 = (SWord8) s1690; - const SWord8 s1700 = table0[s1699]; - const SWord16 s1701 = (((SWord16) s1698) << 8) | ((SWord16) s1700); - const SWord32 s1702 = (((SWord32) s1696) << 16) | ((SWord32) s1701); - const SWord32 s1703 = s1638 ^ s1702; - const SWord32 s1704 = s1689 ^ s1703; - const SWord8 s1705 = (SWord8) (s1704 >> 24); - const SWord32 s1706 = table1[s1705]; - const SWord8 s1707 = (SWord8) (s1654 >> 24); - const SWord32 s1708 = table1[s1707]; - const SWord8 s1709 = (SWord8) (s1670 >> 16); - const SWord32 s1710 = table2[s1709]; - const SWord32 s1711 = s1708 ^ s1710; - const SWord8 s1712 = (SWord8) (s1686 >> 8); - const SWord32 s1713 = table3[s1712]; - const SWord32 s1714 = s1711 ^ s1713; - const SWord8 s1715 = (SWord8) s1639; - const SWord32 s1716 = table4[s1715]; - const SWord32 s1717 = s1714 ^ s1716; - const SWord32 s1718 = s1653 ^ s1703; - const SWord32 s1719 = s1717 ^ s1718; - const SWord8 s1720 = (SWord8) (s1719 >> 16); - const SWord32 s1721 = table2[s1720]; - const SWord32 s1722 = s1706 ^ s1721; - const SWord8 s1723 = (SWord8) (s1670 >> 24); - const SWord32 s1724 = table1[s1723]; - const SWord8 s1725 = (SWord8) (s1686 >> 16); - const SWord32 s1726 = table2[s1725]; - const SWord32 s1727 = s1724 ^ s1726; - const SWord8 s1728 = (SWord8) (s1639 >> 8); - const SWord32 s1729 = table3[s1728]; - const SWord32 s1730 = s1727 ^ s1729; - const SWord8 s1731 = (SWord8) s1654; - const SWord32 s1732 = table4[s1731]; - const SWord32 s1733 = s1730 ^ s1732; - const SWord32 s1734 = s1669 ^ s1718; - const SWord32 s1735 = s1733 ^ s1734; - const SWord8 s1736 = (SWord8) (s1735 >> 8); - const SWord32 s1737 = table3[s1736]; - const SWord32 s1738 = s1722 ^ s1737; - const SWord8 s1739 = (SWord8) (s1686 >> 24); - const SWord32 s1740 = table1[s1739]; - const SWord8 s1741 = (SWord8) (s1639 >> 16); - const SWord32 s1742 = table2[s1741]; - const SWord32 s1743 = s1740 ^ s1742; - const SWord8 s1744 = (SWord8) (s1654 >> 8); - const SWord32 s1745 = table3[s1744]; - const SWord32 s1746 = s1743 ^ s1745; - const SWord8 s1747 = (SWord8) s1670; - const SWord32 s1748 = table4[s1747]; - const SWord32 s1749 = s1746 ^ s1748; - const SWord32 s1750 = s1685 ^ s1734; - const SWord32 s1751 = s1749 ^ s1750; - const SWord8 s1752 = (SWord8) s1751; - const SWord32 s1753 = table4[s1752]; - const SWord32 s1754 = s1738 ^ s1753; - const SWord32 s1755 = (s1750 << 8) | (s1750 >> 24); - const SWord8 s1756 = (SWord8) (s1755 >> 24); - const SWord8 s1757 = table0[s1756]; - const SWord8 s1758 = 128 ^ s1757; - const SWord8 s1759 = (SWord8) (s1755 >> 16); - const SWord8 s1760 = table0[s1759]; - const SWord16 s1761 = (((SWord16) s1758) << 8) | ((SWord16) s1760); - const SWord8 s1762 = (SWord8) (s1755 >> 8); - const SWord8 s1763 = table0[s1762]; - const SWord8 s1764 = (SWord8) s1755; - const SWord8 s1765 = table0[s1764]; - const SWord16 s1766 = (((SWord16) s1763) << 8) | ((SWord16) s1765); - const SWord32 s1767 = (((SWord32) s1761) << 16) | ((SWord32) s1766); - const SWord32 s1768 = s1703 ^ s1767; - const SWord32 s1769 = s1754 ^ s1768; - const SWord8 s1770 = (SWord8) (s1769 >> 24); - const SWord32 s1771 = table1[s1770]; - const SWord8 s1772 = (SWord8) (s1719 >> 24); - const SWord32 s1773 = table1[s1772]; - const SWord8 s1774 = (SWord8) (s1735 >> 16); - const SWord32 s1775 = table2[s1774]; - const SWord32 s1776 = s1773 ^ s1775; - const SWord8 s1777 = (SWord8) (s1751 >> 8); - const SWord32 s1778 = table3[s1777]; - const SWord32 s1779 = s1776 ^ s1778; - const SWord8 s1780 = (SWord8) s1704; - const SWord32 s1781 = table4[s1780]; - const SWord32 s1782 = s1779 ^ s1781; - const SWord32 s1783 = s1718 ^ s1768; - const SWord32 s1784 = s1782 ^ s1783; - const SWord8 s1785 = (SWord8) (s1784 >> 16); - const SWord32 s1786 = table2[s1785]; - const SWord32 s1787 = s1771 ^ s1786; - const SWord8 s1788 = (SWord8) (s1735 >> 24); - const SWord32 s1789 = table1[s1788]; - const SWord8 s1790 = (SWord8) (s1751 >> 16); - const SWord32 s1791 = table2[s1790]; - const SWord32 s1792 = s1789 ^ s1791; - const SWord8 s1793 = (SWord8) (s1704 >> 8); - const SWord32 s1794 = table3[s1793]; - const SWord32 s1795 = s1792 ^ s1794; - const SWord8 s1796 = (SWord8) s1719; - const SWord32 s1797 = table4[s1796]; - const SWord32 s1798 = s1795 ^ s1797; - const SWord32 s1799 = s1734 ^ s1783; - const SWord32 s1800 = s1798 ^ s1799; - const SWord8 s1801 = (SWord8) (s1800 >> 8); - const SWord32 s1802 = table3[s1801]; - const SWord32 s1803 = s1787 ^ s1802; - const SWord8 s1804 = (SWord8) (s1751 >> 24); - const SWord32 s1805 = table1[s1804]; - const SWord8 s1806 = (SWord8) (s1704 >> 16); - const SWord32 s1807 = table2[s1806]; - const SWord32 s1808 = s1805 ^ s1807; - const SWord8 s1809 = (SWord8) (s1719 >> 8); - const SWord32 s1810 = table3[s1809]; - const SWord32 s1811 = s1808 ^ s1810; - const SWord8 s1812 = (SWord8) s1735; - const SWord32 s1813 = table4[s1812]; - const SWord32 s1814 = s1811 ^ s1813; - const SWord32 s1815 = s1750 ^ s1799; - const SWord32 s1816 = s1814 ^ s1815; - const SWord8 s1817 = (SWord8) s1816; - const SWord32 s1818 = table4[s1817]; - const SWord32 s1819 = s1803 ^ s1818; - const SWord32 s1820 = (s1815 << 8) | (s1815 >> 24); - const SWord8 s1821 = (SWord8) (s1820 >> 24); - const SWord8 s1822 = table0[s1821]; - const SWord8 s1823 = 27 ^ s1822; - const SWord8 s1824 = (SWord8) (s1820 >> 16); - const SWord8 s1825 = table0[s1824]; - const SWord16 s1826 = (((SWord16) s1823) << 8) | ((SWord16) s1825); - const SWord8 s1827 = (SWord8) (s1820 >> 8); - const SWord8 s1828 = table0[s1827]; - const SWord8 s1829 = (SWord8) s1820; - const SWord8 s1830 = table0[s1829]; - const SWord16 s1831 = (((SWord16) s1828) << 8) | ((SWord16) s1830); - const SWord32 s1832 = (((SWord32) s1826) << 16) | ((SWord32) s1831); - const SWord32 s1833 = s1768 ^ s1832; - const SWord32 s1834 = s1819 ^ s1833; - const SWord8 s1835 = (SWord8) (s1834 >> 24); - const SWord8 s1836 = table0[s1835]; - const SWord8 s1837 = (SWord8) (s1784 >> 24); - const SWord32 s1838 = table1[s1837]; - const SWord8 s1839 = (SWord8) (s1800 >> 16); - const SWord32 s1840 = table2[s1839]; - const SWord32 s1841 = s1838 ^ s1840; - const SWord8 s1842 = (SWord8) (s1816 >> 8); - const SWord32 s1843 = table3[s1842]; - const SWord32 s1844 = s1841 ^ s1843; - const SWord8 s1845 = (SWord8) s1769; - const SWord32 s1846 = table4[s1845]; - const SWord32 s1847 = s1844 ^ s1846; - const SWord32 s1848 = s1783 ^ s1833; - const SWord32 s1849 = s1847 ^ s1848; - const SWord8 s1850 = (SWord8) (s1849 >> 16); - const SWord8 s1851 = table0[s1850]; - const SWord16 s1852 = (((SWord16) s1836) << 8) | ((SWord16) s1851); - const SWord8 s1853 = (SWord8) (s1800 >> 24); - const SWord32 s1854 = table1[s1853]; - const SWord8 s1855 = (SWord8) (s1816 >> 16); - const SWord32 s1856 = table2[s1855]; - const SWord32 s1857 = s1854 ^ s1856; - const SWord8 s1858 = (SWord8) (s1769 >> 8); - const SWord32 s1859 = table3[s1858]; - const SWord32 s1860 = s1857 ^ s1859; - const SWord8 s1861 = (SWord8) s1784; - const SWord32 s1862 = table4[s1861]; - const SWord32 s1863 = s1860 ^ s1862; - const SWord32 s1864 = s1799 ^ s1848; - const SWord32 s1865 = s1863 ^ s1864; - const SWord8 s1866 = (SWord8) (s1865 >> 8); - const SWord8 s1867 = table0[s1866]; - const SWord8 s1868 = (SWord8) (s1816 >> 24); - const SWord32 s1869 = table1[s1868]; - const SWord8 s1870 = (SWord8) (s1769 >> 16); - const SWord32 s1871 = table2[s1870]; - const SWord32 s1872 = s1869 ^ s1871; - const SWord8 s1873 = (SWord8) (s1784 >> 8); - const SWord32 s1874 = table3[s1873]; - const SWord32 s1875 = s1872 ^ s1874; - const SWord8 s1876 = (SWord8) s1800; - const SWord32 s1877 = table4[s1876]; - const SWord32 s1878 = s1875 ^ s1877; - const SWord32 s1879 = s1815 ^ s1864; - const SWord32 s1880 = s1878 ^ s1879; - const SWord8 s1881 = (SWord8) s1880; - const SWord8 s1882 = table0[s1881]; - const SWord16 s1883 = (((SWord16) s1867) << 8) | ((SWord16) s1882); - const SWord32 s1884 = (((SWord32) s1852) << 16) | ((SWord32) s1883); - const SWord32 s1885 = (s1879 << 8) | (s1879 >> 24); - const SWord8 s1886 = (SWord8) (s1885 >> 24); - const SWord8 s1887 = table0[s1886]; - const SWord8 s1888 = 54 ^ s1887; - const SWord8 s1889 = (SWord8) (s1885 >> 16); - const SWord8 s1890 = table0[s1889]; - const SWord16 s1891 = (((SWord16) s1888) << 8) | ((SWord16) s1890); - const SWord8 s1892 = (SWord8) (s1885 >> 8); - const SWord8 s1893 = table0[s1892]; - const SWord8 s1894 = (SWord8) s1885; - const SWord8 s1895 = table0[s1894]; - const SWord16 s1896 = (((SWord16) s1893) << 8) | ((SWord16) s1895); - const SWord32 s1897 = (((SWord32) s1891) << 16) | ((SWord32) s1896); - const SWord32 s1898 = s1833 ^ s1897; - const SWord32 s1899 = s1884 ^ s1898; - const SWord8 s1900 = (SWord8) (s1849 >> 24); - const SWord8 s1901 = table0[s1900]; - const SWord8 s1902 = (SWord8) (s1865 >> 16); - const SWord8 s1903 = table0[s1902]; - const SWord16 s1904 = (((SWord16) s1901) << 8) | ((SWord16) s1903); - const SWord8 s1905 = (SWord8) (s1880 >> 8); - const SWord8 s1906 = table0[s1905]; - const SWord8 s1907 = (SWord8) s1834; - const SWord8 s1908 = table0[s1907]; - const SWord16 s1909 = (((SWord16) s1906) << 8) | ((SWord16) s1908); - const SWord32 s1910 = (((SWord32) s1904) << 16) | ((SWord32) s1909); - const SWord32 s1911 = s1848 ^ s1898; - const SWord32 s1912 = s1910 ^ s1911; - const SWord8 s1913 = (SWord8) (s1865 >> 24); - const SWord8 s1914 = table0[s1913]; - const SWord8 s1915 = (SWord8) (s1880 >> 16); - const SWord8 s1916 = table0[s1915]; - const SWord16 s1917 = (((SWord16) s1914) << 8) | ((SWord16) s1916); - const SWord8 s1918 = (SWord8) (s1834 >> 8); - const SWord8 s1919 = table0[s1918]; - const SWord8 s1920 = (SWord8) s1849; - const SWord8 s1921 = table0[s1920]; - const SWord16 s1922 = (((SWord16) s1919) << 8) | ((SWord16) s1921); - const SWord32 s1923 = (((SWord32) s1917) << 16) | ((SWord32) s1922); - const SWord32 s1924 = s1864 ^ s1911; - const SWord32 s1925 = s1923 ^ s1924; - const SWord8 s1926 = (SWord8) (s1880 >> 24); - const SWord8 s1927 = table0[s1926]; - const SWord8 s1928 = (SWord8) (s1834 >> 16); - const SWord8 s1929 = table0[s1928]; - const SWord16 s1930 = (((SWord16) s1927) << 8) | ((SWord16) s1929); - const SWord8 s1931 = (SWord8) (s1849 >> 8); - const SWord8 s1932 = table0[s1931]; - const SWord8 s1933 = (SWord8) s1865; - const SWord8 s1934 = table0[s1933]; - const SWord16 s1935 = (((SWord16) s1932) << 8) | ((SWord16) s1934); - const SWord32 s1936 = (((SWord32) s1930) << 16) | ((SWord32) s1935); - const SWord32 s1937 = s1879 ^ s1924; - const SWord32 s1938 = s1936 ^ s1937; - - ct[0] = s1899; - ct[1] = s1912; - ct[2] = s1925; - ct[3] = s1938; +aes128Enc_driver.o: aes128Enc_driver.c aes128Enc.h + ${CC} ${CCFLAGS} -c $< -o $@ + +aes128Enc_driver: aes128Enc.o aes128Enc_driver.o + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} + +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 SBV_GENERATED_aes128Enc_HEADER_INCLUDED +#define SBV_GENERATED_aes128Enc_HEADER_INCLUDED + + +#include +#include +#include +#include +#include +#include +#include + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* Entry point prototype: */ +void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct); + +#endif /* SBV_GENERATED_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 +#include "aes128Enc.h" + +int main(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array pt:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" pt[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord32 sbv_driver_input_1[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array key:\n"); + int sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 4 ; ++sbv_driver_input_1_ctr) + { printf(" key[%1d] = ", sbv_driver_input_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[4]; + + aes128Enc(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("aes128Enc(pt, key, ct) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 4 ; ++sbv_driver_output_0_ctr) + { printf(" ct[%1d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } + + return 0; +} +== END: "aes128Enc_driver.c" ================== +== BEGIN: "aes128Enc.c" ================ +/* File: "aes128Enc.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Enc.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotl(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) << amount) | (((uint64_t) (SWord32) a) >> (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotr(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) >> amount) | (((uint64_t) (SWord32) a) << (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128Enc(const SWord32 *sbv_input_0, + const SWord32 *sbv_input_1, SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s4 = sbv_input_1[0]; + const SWord32 s5 = sbv_input_1[1]; + const SWord32 s6 = sbv_input_1[2]; + const SWord32 s7 = sbv_input_1[3]; + const SWord32 s520 = s0 ^ s4; + const SWord8 s521 = sbv_bv_extract_u32_31_24_u8(s520); + const SWord32 s778 = s1 ^ s5; + const SWord8 s779 = sbv_bv_extract_u32_23_16_u8(s778); + const SWord32 s1037 = s2 ^ s6; + const SWord8 s1038 = sbv_bv_extract_u32_15_8_u8(s1037); + const SWord32 s1296 = s3 ^ s7; + const SWord8 s1297 = sbv_bv_extract_u32_7_0_u8(s1296); + const SWord32 s1300 = sbv_bv_u32_rotl(s7, 8); + const SWord8 s1301 = sbv_bv_extract_u32_31_24_u8(s1300); + const SWord8 s1304 = sbv_bv_extract_u32_23_16_u8(s1300); + const SWord8 s1307 = sbv_bv_extract_u32_15_8_u8(s1300); + const SWord8 s1309 = sbv_bv_extract_u32_7_0_u8(s1300); + const SWord8 s1317 = sbv_bv_extract_u32_31_24_u8(s778); + const SWord8 s1319 = sbv_bv_extract_u32_23_16_u8(s1037); + const SWord8 s1322 = sbv_bv_extract_u32_15_8_u8(s1296); + const SWord8 s1325 = sbv_bv_extract_u32_7_0_u8(s520); + const SWord8 s1333 = sbv_bv_extract_u32_31_24_u8(s1037); + const SWord8 s1335 = sbv_bv_extract_u32_23_16_u8(s1296); + const SWord8 s1338 = sbv_bv_extract_u32_15_8_u8(s520); + const SWord8 s1341 = sbv_bv_extract_u32_7_0_u8(s778); + const SWord8 s1349 = sbv_bv_extract_u32_31_24_u8(s1296); + const SWord8 s1351 = sbv_bv_extract_u32_23_16_u8(s520); + const SWord8 s1354 = sbv_bv_extract_u32_15_8_u8(s778); + const SWord8 s1357 = sbv_bv_extract_u32_7_0_u8(s1037); + SWord32 s522; + SWord32 s780; + SWord32 s781; + SWord32 s1039; + SWord32 s1040; + SWord32 s1298; + SWord32 s1299; + SWord8 s1302; + SWord8 s1303; + SWord8 s1305; + SWord16 s1306; + SWord8 s1308; + SWord8 s1310; + SWord16 s1311; + SWord32 s1312; + SWord32 s1313; + SWord32 s1314; + SWord8 s1315; + SWord32 s1316; + SWord32 s1318; + SWord32 s1320; + SWord32 s1321; + SWord32 s1323; + SWord32 s1324; + SWord32 s1326; + SWord32 s1327; + SWord32 s1328; + SWord32 s1329; + SWord8 s1330; + SWord32 s1331; + SWord32 s1332; + SWord32 s1334; + SWord32 s1336; + SWord32 s1337; + SWord32 s1339; + SWord32 s1340; + SWord32 s1342; + SWord32 s1343; + SWord32 s1344; + SWord32 s1345; + SWord8 s1346; + SWord32 s1347; + SWord32 s1348; + SWord32 s1350; + SWord32 s1352; + SWord32 s1353; + SWord32 s1355; + SWord32 s1356; + SWord32 s1358; + SWord32 s1359; + SWord32 s1360; + SWord32 s1361; + SWord8 s1362; + SWord32 s1363; + SWord32 s1364; + SWord32 s1365; + SWord8 s1366; + SWord8 s1367; + SWord8 s1368; + SWord8 s1369; + SWord8 s1370; + SWord16 s1371; + SWord8 s1372; + SWord8 s1373; + SWord8 s1374; + SWord8 s1375; + SWord16 s1376; + SWord32 s1377; + SWord32 s1378; + SWord32 s1379; + SWord8 s1380; + SWord32 s1381; + SWord8 s1382; + SWord32 s1383; + SWord8 s1384; + SWord32 s1385; + SWord32 s1386; + SWord8 s1387; + SWord32 s1388; + SWord32 s1389; + SWord8 s1390; + SWord32 s1391; + SWord32 s1392; + SWord32 s1393; + SWord32 s1394; + SWord8 s1395; + SWord32 s1396; + SWord32 s1397; + SWord8 s1398; + SWord32 s1399; + SWord8 s1400; + SWord32 s1401; + SWord32 s1402; + SWord8 s1403; + SWord32 s1404; + SWord32 s1405; + SWord8 s1406; + SWord32 s1407; + SWord32 s1408; + SWord32 s1409; + SWord32 s1410; + SWord8 s1411; + SWord32 s1412; + SWord32 s1413; + SWord8 s1414; + SWord32 s1415; + SWord8 s1416; + SWord32 s1417; + SWord32 s1418; + SWord8 s1419; + SWord32 s1420; + SWord32 s1421; + SWord8 s1422; + SWord32 s1423; + SWord32 s1424; + SWord32 s1425; + SWord32 s1426; + SWord8 s1427; + SWord32 s1428; + SWord32 s1429; + SWord32 s1430; + SWord8 s1431; + SWord8 s1432; + SWord8 s1433; + SWord8 s1434; + SWord8 s1435; + SWord16 s1436; + SWord8 s1437; + SWord8 s1438; + SWord8 s1439; + SWord8 s1440; + SWord16 s1441; + SWord32 s1442; + SWord32 s1443; + SWord32 s1444; + SWord8 s1445; + SWord32 s1446; + SWord8 s1447; + SWord32 s1448; + SWord8 s1449; + SWord32 s1450; + SWord32 s1451; + SWord8 s1452; + SWord32 s1453; + SWord32 s1454; + SWord8 s1455; + SWord32 s1456; + SWord32 s1457; + SWord32 s1458; + SWord32 s1459; + SWord8 s1460; + SWord32 s1461; + SWord32 s1462; + SWord8 s1463; + SWord32 s1464; + SWord8 s1465; + SWord32 s1466; + SWord32 s1467; + SWord8 s1468; + SWord32 s1469; + SWord32 s1470; + SWord8 s1471; + SWord32 s1472; + SWord32 s1473; + SWord32 s1474; + SWord32 s1475; + SWord8 s1476; + SWord32 s1477; + SWord32 s1478; + SWord8 s1479; + SWord32 s1480; + SWord8 s1481; + SWord32 s1482; + SWord32 s1483; + SWord8 s1484; + SWord32 s1485; + SWord32 s1486; + SWord8 s1487; + SWord32 s1488; + SWord32 s1489; + SWord32 s1490; + SWord32 s1491; + SWord8 s1492; + SWord32 s1493; + SWord32 s1494; + SWord32 s1495; + SWord8 s1496; + SWord8 s1497; + SWord8 s1498; + SWord8 s1499; + SWord8 s1500; + SWord16 s1501; + SWord8 s1502; + SWord8 s1503; + SWord8 s1504; + SWord8 s1505; + SWord16 s1506; + SWord32 s1507; + SWord32 s1508; + SWord32 s1509; + SWord8 s1510; + SWord32 s1511; + SWord8 s1512; + SWord32 s1513; + SWord8 s1514; + SWord32 s1515; + SWord32 s1516; + SWord8 s1517; + SWord32 s1518; + SWord32 s1519; + SWord8 s1520; + SWord32 s1521; + SWord32 s1522; + SWord32 s1523; + SWord32 s1524; + SWord8 s1525; + SWord32 s1526; + SWord32 s1527; + SWord8 s1528; + SWord32 s1529; + SWord8 s1530; + SWord32 s1531; + SWord32 s1532; + SWord8 s1533; + SWord32 s1534; + SWord32 s1535; + SWord8 s1536; + SWord32 s1537; + SWord32 s1538; + SWord32 s1539; + SWord32 s1540; + SWord8 s1541; + SWord32 s1542; + SWord32 s1543; + SWord8 s1544; + SWord32 s1545; + SWord8 s1546; + SWord32 s1547; + SWord32 s1548; + SWord8 s1549; + SWord32 s1550; + SWord32 s1551; + SWord8 s1552; + SWord32 s1553; + SWord32 s1554; + SWord32 s1555; + SWord32 s1556; + SWord8 s1557; + SWord32 s1558; + SWord32 s1559; + SWord32 s1560; + SWord8 s1561; + SWord8 s1562; + SWord8 s1563; + SWord8 s1564; + SWord8 s1565; + SWord16 s1566; + SWord8 s1567; + SWord8 s1568; + SWord8 s1569; + SWord8 s1570; + SWord16 s1571; + SWord32 s1572; + SWord32 s1573; + SWord32 s1574; + SWord8 s1575; + SWord32 s1576; + SWord8 s1577; + SWord32 s1578; + SWord8 s1579; + SWord32 s1580; + SWord32 s1581; + SWord8 s1582; + SWord32 s1583; + SWord32 s1584; + SWord8 s1585; + SWord32 s1586; + SWord32 s1587; + SWord32 s1588; + SWord32 s1589; + SWord8 s1590; + SWord32 s1591; + SWord32 s1592; + SWord8 s1593; + SWord32 s1594; + SWord8 s1595; + SWord32 s1596; + SWord32 s1597; + SWord8 s1598; + SWord32 s1599; + SWord32 s1600; + SWord8 s1601; + SWord32 s1602; + SWord32 s1603; + SWord32 s1604; + SWord32 s1605; + SWord8 s1606; + SWord32 s1607; + SWord32 s1608; + SWord8 s1609; + SWord32 s1610; + SWord8 s1611; + SWord32 s1612; + SWord32 s1613; + SWord8 s1614; + SWord32 s1615; + SWord32 s1616; + SWord8 s1617; + SWord32 s1618; + SWord32 s1619; + SWord32 s1620; + SWord32 s1621; + SWord8 s1622; + SWord32 s1623; + SWord32 s1624; + SWord32 s1625; + SWord8 s1626; + SWord8 s1627; + SWord8 s1628; + SWord8 s1629; + SWord8 s1630; + SWord16 s1631; + SWord8 s1632; + SWord8 s1633; + SWord8 s1634; + SWord8 s1635; + SWord16 s1636; + SWord32 s1637; + SWord32 s1638; + SWord32 s1639; + SWord8 s1640; + SWord32 s1641; + SWord8 s1642; + SWord32 s1643; + SWord8 s1644; + SWord32 s1645; + SWord32 s1646; + SWord8 s1647; + SWord32 s1648; + SWord32 s1649; + SWord8 s1650; + SWord32 s1651; + SWord32 s1652; + SWord32 s1653; + SWord32 s1654; + SWord8 s1655; + SWord32 s1656; + SWord32 s1657; + SWord8 s1658; + SWord32 s1659; + SWord8 s1660; + SWord32 s1661; + SWord32 s1662; + SWord8 s1663; + SWord32 s1664; + SWord32 s1665; + SWord8 s1666; + SWord32 s1667; + SWord32 s1668; + SWord32 s1669; + SWord32 s1670; + SWord8 s1671; + SWord32 s1672; + SWord32 s1673; + SWord8 s1674; + SWord32 s1675; + SWord8 s1676; + SWord32 s1677; + SWord32 s1678; + SWord8 s1679; + SWord32 s1680; + SWord32 s1681; + SWord8 s1682; + SWord32 s1683; + SWord32 s1684; + SWord32 s1685; + SWord32 s1686; + SWord8 s1687; + SWord32 s1688; + SWord32 s1689; + SWord32 s1690; + SWord8 s1691; + SWord8 s1692; + SWord8 s1693; + SWord8 s1694; + SWord8 s1695; + SWord16 s1696; + SWord8 s1697; + SWord8 s1698; + SWord8 s1699; + SWord8 s1700; + SWord16 s1701; + SWord32 s1702; + SWord32 s1703; + SWord32 s1704; + SWord8 s1705; + SWord32 s1706; + SWord8 s1707; + SWord32 s1708; + SWord8 s1709; + SWord32 s1710; + SWord32 s1711; + SWord8 s1712; + SWord32 s1713; + SWord32 s1714; + SWord8 s1715; + SWord32 s1716; + SWord32 s1717; + SWord32 s1718; + SWord32 s1719; + SWord8 s1720; + SWord32 s1721; + SWord32 s1722; + SWord8 s1723; + SWord32 s1724; + SWord8 s1725; + SWord32 s1726; + SWord32 s1727; + SWord8 s1728; + SWord32 s1729; + SWord32 s1730; + SWord8 s1731; + SWord32 s1732; + SWord32 s1733; + SWord32 s1734; + SWord32 s1735; + SWord8 s1736; + SWord32 s1737; + SWord32 s1738; + SWord8 s1739; + SWord32 s1740; + SWord8 s1741; + SWord32 s1742; + SWord32 s1743; + SWord8 s1744; + SWord32 s1745; + SWord32 s1746; + SWord8 s1747; + SWord32 s1748; + SWord32 s1749; + SWord32 s1750; + SWord32 s1751; + SWord8 s1752; + SWord32 s1753; + SWord32 s1754; + SWord32 s1755; + SWord8 s1756; + SWord8 s1757; + SWord8 s1758; + SWord8 s1759; + SWord8 s1760; + SWord16 s1761; + SWord8 s1762; + SWord8 s1763; + SWord8 s1764; + SWord8 s1765; + SWord16 s1766; + SWord32 s1767; + SWord32 s1768; + SWord32 s1769; + SWord8 s1770; + SWord32 s1771; + SWord8 s1772; + SWord32 s1773; + SWord8 s1774; + SWord32 s1775; + SWord32 s1776; + SWord8 s1777; + SWord32 s1778; + SWord32 s1779; + SWord8 s1780; + SWord32 s1781; + SWord32 s1782; + SWord32 s1783; + SWord32 s1784; + SWord8 s1785; + SWord32 s1786; + SWord32 s1787; + SWord8 s1788; + SWord32 s1789; + SWord8 s1790; + SWord32 s1791; + SWord32 s1792; + SWord8 s1793; + SWord32 s1794; + SWord32 s1795; + SWord8 s1796; + SWord32 s1797; + SWord32 s1798; + SWord32 s1799; + SWord32 s1800; + SWord8 s1801; + SWord32 s1802; + SWord32 s1803; + SWord8 s1804; + SWord32 s1805; + SWord8 s1806; + SWord32 s1807; + SWord32 s1808; + SWord8 s1809; + SWord32 s1810; + SWord32 s1811; + SWord8 s1812; + SWord32 s1813; + SWord32 s1814; + SWord32 s1815; + SWord32 s1816; + SWord8 s1817; + SWord32 s1818; + SWord32 s1819; + SWord32 s1820; + SWord8 s1821; + SWord8 s1822; + SWord8 s1823; + SWord8 s1824; + SWord8 s1825; + SWord16 s1826; + SWord8 s1827; + SWord8 s1828; + SWord8 s1829; + SWord8 s1830; + SWord16 s1831; + SWord32 s1832; + SWord32 s1833; + SWord32 s1834; + SWord8 s1835; + SWord8 s1836; + SWord8 s1837; + SWord32 s1838; + SWord8 s1839; + SWord32 s1840; + SWord32 s1841; + SWord8 s1842; + SWord32 s1843; + SWord32 s1844; + SWord8 s1845; + SWord32 s1846; + SWord32 s1847; + SWord32 s1848; + SWord32 s1849; + SWord8 s1850; + SWord8 s1851; + SWord16 s1852; + SWord8 s1853; + SWord32 s1854; + SWord8 s1855; + SWord32 s1856; + SWord32 s1857; + SWord8 s1858; + SWord32 s1859; + SWord32 s1860; + SWord8 s1861; + SWord32 s1862; + SWord32 s1863; + SWord32 s1864; + SWord32 s1865; + SWord8 s1866; + SWord8 s1867; + SWord8 s1868; + SWord32 s1869; + SWord8 s1870; + SWord32 s1871; + SWord32 s1872; + SWord8 s1873; + SWord32 s1874; + SWord32 s1875; + SWord8 s1876; + SWord32 s1877; + SWord32 s1878; + SWord32 s1879; + SWord32 s1880; + SWord8 s1881; + SWord8 s1882; + SWord16 s1883; + SWord32 s1884; + SWord32 s1885; + SWord8 s1886; + SWord8 s1887; + SWord8 s1888; + SWord8 s1889; + SWord8 s1890; + SWord16 s1891; + SWord8 s1892; + SWord8 s1893; + SWord8 s1894; + SWord8 s1895; + SWord16 s1896; + SWord32 s1897; + SWord32 s1898; + SWord32 s1899; + SWord8 s1900; + SWord8 s1901; + SWord8 s1902; + SWord8 s1903; + SWord16 s1904; + SWord8 s1905; + SWord8 s1906; + SWord8 s1907; + SWord8 s1908; + SWord16 s1909; + SWord32 s1910; + SWord32 s1911; + SWord32 s1912; + SWord8 s1913; + SWord8 s1914; + SWord8 s1915; + SWord8 s1916; + SWord16 s1917; + SWord8 s1918; + SWord8 s1919; + SWord8 s1920; + SWord8 s1921; + SWord16 s1922; + SWord32 s1923; + SWord32 s1924; + SWord32 s1925; + SWord8 s1926; + SWord8 s1927; + SWord8 s1928; + SWord8 s1929; + SWord16 s1930; + SWord8 s1931; + SWord8 s1932; + SWord8 s1933; + SWord8 s1934; + SWord16 s1935; + SWord32 s1936; + SWord32 s1937; + SWord32 s1938; + 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 + }; + s522 = table1[s521]; + 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 + }; + s780 = table2[s779]; + s781 = s522 ^ s780; + 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 + }; + s1039 = table3[s1038]; + s1040 = s781 ^ s1039; + 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 + }; + s1298 = table4[s1297]; + s1299 = s1040 ^ s1298; + 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 + }; + s1302 = table0[s1301]; + s1303 = 1 ^ s1302; + s1305 = table0[s1304]; + s1306 = sbv_bv_join_u8_u8_u16(s1303, s1305); + s1308 = table0[s1307]; + s1310 = table0[s1309]; + s1311 = sbv_bv_join_u8_u8_u16(s1308, s1310); + s1312 = sbv_bv_join_u16_u16_u32(s1306, s1311); + s1313 = s4 ^ s1312; + s1314 = s1299 ^ s1313; + s1315 = sbv_bv_extract_u32_31_24_u8(s1314); + s1316 = table1[s1315]; + s1318 = table1[s1317]; + s1320 = table2[s1319]; + s1321 = s1318 ^ s1320; + s1323 = table3[s1322]; + s1324 = s1321 ^ s1323; + s1326 = table4[s1325]; + s1327 = s1324 ^ s1326; + s1328 = s5 ^ s1313; + s1329 = s1327 ^ s1328; + s1330 = sbv_bv_extract_u32_23_16_u8(s1329); + s1331 = table2[s1330]; + s1332 = s1316 ^ s1331; + s1334 = table1[s1333]; + s1336 = table2[s1335]; + s1337 = s1334 ^ s1336; + s1339 = table3[s1338]; + s1340 = s1337 ^ s1339; + s1342 = table4[s1341]; + s1343 = s1340 ^ s1342; + s1344 = s6 ^ s1328; + s1345 = s1343 ^ s1344; + s1346 = sbv_bv_extract_u32_15_8_u8(s1345); + s1347 = table3[s1346]; + s1348 = s1332 ^ s1347; + s1350 = table1[s1349]; + s1352 = table2[s1351]; + s1353 = s1350 ^ s1352; + s1355 = table3[s1354]; + s1356 = s1353 ^ s1355; + s1358 = table4[s1357]; + s1359 = s1356 ^ s1358; + s1360 = s7 ^ s1344; + s1361 = s1359 ^ s1360; + s1362 = sbv_bv_extract_u32_7_0_u8(s1361); + s1363 = table4[s1362]; + s1364 = s1348 ^ s1363; + s1365 = sbv_bv_u32_rotl(s1360, 8); + s1366 = sbv_bv_extract_u32_31_24_u8(s1365); + s1367 = table0[s1366]; + s1368 = 2 ^ s1367; + s1369 = sbv_bv_extract_u32_23_16_u8(s1365); + s1370 = table0[s1369]; + s1371 = sbv_bv_join_u8_u8_u16(s1368, s1370); + s1372 = sbv_bv_extract_u32_15_8_u8(s1365); + s1373 = table0[s1372]; + s1374 = sbv_bv_extract_u32_7_0_u8(s1365); + s1375 = table0[s1374]; + s1376 = sbv_bv_join_u8_u8_u16(s1373, s1375); + s1377 = sbv_bv_join_u16_u16_u32(s1371, s1376); + s1378 = s1313 ^ s1377; + s1379 = s1364 ^ s1378; + s1380 = sbv_bv_extract_u32_31_24_u8(s1379); + s1381 = table1[s1380]; + s1382 = sbv_bv_extract_u32_31_24_u8(s1329); + s1383 = table1[s1382]; + s1384 = sbv_bv_extract_u32_23_16_u8(s1345); + s1385 = table2[s1384]; + s1386 = s1383 ^ s1385; + s1387 = sbv_bv_extract_u32_15_8_u8(s1361); + s1388 = table3[s1387]; + s1389 = s1386 ^ s1388; + s1390 = sbv_bv_extract_u32_7_0_u8(s1314); + s1391 = table4[s1390]; + s1392 = s1389 ^ s1391; + s1393 = s1328 ^ s1378; + s1394 = s1392 ^ s1393; + s1395 = sbv_bv_extract_u32_23_16_u8(s1394); + s1396 = table2[s1395]; + s1397 = s1381 ^ s1396; + s1398 = sbv_bv_extract_u32_31_24_u8(s1345); + s1399 = table1[s1398]; + s1400 = sbv_bv_extract_u32_23_16_u8(s1361); + s1401 = table2[s1400]; + s1402 = s1399 ^ s1401; + s1403 = sbv_bv_extract_u32_15_8_u8(s1314); + s1404 = table3[s1403]; + s1405 = s1402 ^ s1404; + s1406 = sbv_bv_extract_u32_7_0_u8(s1329); + s1407 = table4[s1406]; + s1408 = s1405 ^ s1407; + s1409 = s1344 ^ s1393; + s1410 = s1408 ^ s1409; + s1411 = sbv_bv_extract_u32_15_8_u8(s1410); + s1412 = table3[s1411]; + s1413 = s1397 ^ s1412; + s1414 = sbv_bv_extract_u32_31_24_u8(s1361); + s1415 = table1[s1414]; + s1416 = sbv_bv_extract_u32_23_16_u8(s1314); + s1417 = table2[s1416]; + s1418 = s1415 ^ s1417; + s1419 = sbv_bv_extract_u32_15_8_u8(s1329); + s1420 = table3[s1419]; + s1421 = s1418 ^ s1420; + s1422 = sbv_bv_extract_u32_7_0_u8(s1345); + s1423 = table4[s1422]; + s1424 = s1421 ^ s1423; + s1425 = s1360 ^ s1409; + s1426 = s1424 ^ s1425; + s1427 = sbv_bv_extract_u32_7_0_u8(s1426); + s1428 = table4[s1427]; + s1429 = s1413 ^ s1428; + s1430 = sbv_bv_u32_rotl(s1425, 8); + s1431 = sbv_bv_extract_u32_31_24_u8(s1430); + s1432 = table0[s1431]; + s1433 = 4 ^ s1432; + s1434 = sbv_bv_extract_u32_23_16_u8(s1430); + s1435 = table0[s1434]; + s1436 = sbv_bv_join_u8_u8_u16(s1433, s1435); + s1437 = sbv_bv_extract_u32_15_8_u8(s1430); + s1438 = table0[s1437]; + s1439 = sbv_bv_extract_u32_7_0_u8(s1430); + s1440 = table0[s1439]; + s1441 = sbv_bv_join_u8_u8_u16(s1438, s1440); + s1442 = sbv_bv_join_u16_u16_u32(s1436, s1441); + s1443 = s1378 ^ s1442; + s1444 = s1429 ^ s1443; + s1445 = sbv_bv_extract_u32_31_24_u8(s1444); + s1446 = table1[s1445]; + s1447 = sbv_bv_extract_u32_31_24_u8(s1394); + s1448 = table1[s1447]; + s1449 = sbv_bv_extract_u32_23_16_u8(s1410); + s1450 = table2[s1449]; + s1451 = s1448 ^ s1450; + s1452 = sbv_bv_extract_u32_15_8_u8(s1426); + s1453 = table3[s1452]; + s1454 = s1451 ^ s1453; + s1455 = sbv_bv_extract_u32_7_0_u8(s1379); + s1456 = table4[s1455]; + s1457 = s1454 ^ s1456; + s1458 = s1393 ^ s1443; + s1459 = s1457 ^ s1458; + s1460 = sbv_bv_extract_u32_23_16_u8(s1459); + s1461 = table2[s1460]; + s1462 = s1446 ^ s1461; + s1463 = sbv_bv_extract_u32_31_24_u8(s1410); + s1464 = table1[s1463]; + s1465 = sbv_bv_extract_u32_23_16_u8(s1426); + s1466 = table2[s1465]; + s1467 = s1464 ^ s1466; + s1468 = sbv_bv_extract_u32_15_8_u8(s1379); + s1469 = table3[s1468]; + s1470 = s1467 ^ s1469; + s1471 = sbv_bv_extract_u32_7_0_u8(s1394); + s1472 = table4[s1471]; + s1473 = s1470 ^ s1472; + s1474 = s1409 ^ s1458; + s1475 = s1473 ^ s1474; + s1476 = sbv_bv_extract_u32_15_8_u8(s1475); + s1477 = table3[s1476]; + s1478 = s1462 ^ s1477; + s1479 = sbv_bv_extract_u32_31_24_u8(s1426); + s1480 = table1[s1479]; + s1481 = sbv_bv_extract_u32_23_16_u8(s1379); + s1482 = table2[s1481]; + s1483 = s1480 ^ s1482; + s1484 = sbv_bv_extract_u32_15_8_u8(s1394); + s1485 = table3[s1484]; + s1486 = s1483 ^ s1485; + s1487 = sbv_bv_extract_u32_7_0_u8(s1410); + s1488 = table4[s1487]; + s1489 = s1486 ^ s1488; + s1490 = s1425 ^ s1474; + s1491 = s1489 ^ s1490; + s1492 = sbv_bv_extract_u32_7_0_u8(s1491); + s1493 = table4[s1492]; + s1494 = s1478 ^ s1493; + s1495 = sbv_bv_u32_rotl(s1490, 8); + s1496 = sbv_bv_extract_u32_31_24_u8(s1495); + s1497 = table0[s1496]; + s1498 = 8 ^ s1497; + s1499 = sbv_bv_extract_u32_23_16_u8(s1495); + s1500 = table0[s1499]; + s1501 = sbv_bv_join_u8_u8_u16(s1498, s1500); + s1502 = sbv_bv_extract_u32_15_8_u8(s1495); + s1503 = table0[s1502]; + s1504 = sbv_bv_extract_u32_7_0_u8(s1495); + s1505 = table0[s1504]; + s1506 = sbv_bv_join_u8_u8_u16(s1503, s1505); + s1507 = sbv_bv_join_u16_u16_u32(s1501, s1506); + s1508 = s1443 ^ s1507; + s1509 = s1494 ^ s1508; + s1510 = sbv_bv_extract_u32_31_24_u8(s1509); + s1511 = table1[s1510]; + s1512 = sbv_bv_extract_u32_31_24_u8(s1459); + s1513 = table1[s1512]; + s1514 = sbv_bv_extract_u32_23_16_u8(s1475); + s1515 = table2[s1514]; + s1516 = s1513 ^ s1515; + s1517 = sbv_bv_extract_u32_15_8_u8(s1491); + s1518 = table3[s1517]; + s1519 = s1516 ^ s1518; + s1520 = sbv_bv_extract_u32_7_0_u8(s1444); + s1521 = table4[s1520]; + s1522 = s1519 ^ s1521; + s1523 = s1458 ^ s1508; + s1524 = s1522 ^ s1523; + s1525 = sbv_bv_extract_u32_23_16_u8(s1524); + s1526 = table2[s1525]; + s1527 = s1511 ^ s1526; + s1528 = sbv_bv_extract_u32_31_24_u8(s1475); + s1529 = table1[s1528]; + s1530 = sbv_bv_extract_u32_23_16_u8(s1491); + s1531 = table2[s1530]; + s1532 = s1529 ^ s1531; + s1533 = sbv_bv_extract_u32_15_8_u8(s1444); + s1534 = table3[s1533]; + s1535 = s1532 ^ s1534; + s1536 = sbv_bv_extract_u32_7_0_u8(s1459); + s1537 = table4[s1536]; + s1538 = s1535 ^ s1537; + s1539 = s1474 ^ s1523; + s1540 = s1538 ^ s1539; + s1541 = sbv_bv_extract_u32_15_8_u8(s1540); + s1542 = table3[s1541]; + s1543 = s1527 ^ s1542; + s1544 = sbv_bv_extract_u32_31_24_u8(s1491); + s1545 = table1[s1544]; + s1546 = sbv_bv_extract_u32_23_16_u8(s1444); + s1547 = table2[s1546]; + s1548 = s1545 ^ s1547; + s1549 = sbv_bv_extract_u32_15_8_u8(s1459); + s1550 = table3[s1549]; + s1551 = s1548 ^ s1550; + s1552 = sbv_bv_extract_u32_7_0_u8(s1475); + s1553 = table4[s1552]; + s1554 = s1551 ^ s1553; + s1555 = s1490 ^ s1539; + s1556 = s1554 ^ s1555; + s1557 = sbv_bv_extract_u32_7_0_u8(s1556); + s1558 = table4[s1557]; + s1559 = s1543 ^ s1558; + s1560 = sbv_bv_u32_rotl(s1555, 8); + s1561 = sbv_bv_extract_u32_31_24_u8(s1560); + s1562 = table0[s1561]; + s1563 = 16 ^ s1562; + s1564 = sbv_bv_extract_u32_23_16_u8(s1560); + s1565 = table0[s1564]; + s1566 = sbv_bv_join_u8_u8_u16(s1563, s1565); + s1567 = sbv_bv_extract_u32_15_8_u8(s1560); + s1568 = table0[s1567]; + s1569 = sbv_bv_extract_u32_7_0_u8(s1560); + s1570 = table0[s1569]; + s1571 = sbv_bv_join_u8_u8_u16(s1568, s1570); + s1572 = sbv_bv_join_u16_u16_u32(s1566, s1571); + s1573 = s1508 ^ s1572; + s1574 = s1559 ^ s1573; + s1575 = sbv_bv_extract_u32_31_24_u8(s1574); + s1576 = table1[s1575]; + s1577 = sbv_bv_extract_u32_31_24_u8(s1524); + s1578 = table1[s1577]; + s1579 = sbv_bv_extract_u32_23_16_u8(s1540); + s1580 = table2[s1579]; + s1581 = s1578 ^ s1580; + s1582 = sbv_bv_extract_u32_15_8_u8(s1556); + s1583 = table3[s1582]; + s1584 = s1581 ^ s1583; + s1585 = sbv_bv_extract_u32_7_0_u8(s1509); + s1586 = table4[s1585]; + s1587 = s1584 ^ s1586; + s1588 = s1523 ^ s1573; + s1589 = s1587 ^ s1588; + s1590 = sbv_bv_extract_u32_23_16_u8(s1589); + s1591 = table2[s1590]; + s1592 = s1576 ^ s1591; + s1593 = sbv_bv_extract_u32_31_24_u8(s1540); + s1594 = table1[s1593]; + s1595 = sbv_bv_extract_u32_23_16_u8(s1556); + s1596 = table2[s1595]; + s1597 = s1594 ^ s1596; + s1598 = sbv_bv_extract_u32_15_8_u8(s1509); + s1599 = table3[s1598]; + s1600 = s1597 ^ s1599; + s1601 = sbv_bv_extract_u32_7_0_u8(s1524); + s1602 = table4[s1601]; + s1603 = s1600 ^ s1602; + s1604 = s1539 ^ s1588; + s1605 = s1603 ^ s1604; + s1606 = sbv_bv_extract_u32_15_8_u8(s1605); + s1607 = table3[s1606]; + s1608 = s1592 ^ s1607; + s1609 = sbv_bv_extract_u32_31_24_u8(s1556); + s1610 = table1[s1609]; + s1611 = sbv_bv_extract_u32_23_16_u8(s1509); + s1612 = table2[s1611]; + s1613 = s1610 ^ s1612; + s1614 = sbv_bv_extract_u32_15_8_u8(s1524); + s1615 = table3[s1614]; + s1616 = s1613 ^ s1615; + s1617 = sbv_bv_extract_u32_7_0_u8(s1540); + s1618 = table4[s1617]; + s1619 = s1616 ^ s1618; + s1620 = s1555 ^ s1604; + s1621 = s1619 ^ s1620; + s1622 = sbv_bv_extract_u32_7_0_u8(s1621); + s1623 = table4[s1622]; + s1624 = s1608 ^ s1623; + s1625 = sbv_bv_u32_rotl(s1620, 8); + s1626 = sbv_bv_extract_u32_31_24_u8(s1625); + s1627 = table0[s1626]; + s1628 = 32 ^ s1627; + s1629 = sbv_bv_extract_u32_23_16_u8(s1625); + s1630 = table0[s1629]; + s1631 = sbv_bv_join_u8_u8_u16(s1628, s1630); + s1632 = sbv_bv_extract_u32_15_8_u8(s1625); + s1633 = table0[s1632]; + s1634 = sbv_bv_extract_u32_7_0_u8(s1625); + s1635 = table0[s1634]; + s1636 = sbv_bv_join_u8_u8_u16(s1633, s1635); + s1637 = sbv_bv_join_u16_u16_u32(s1631, s1636); + s1638 = s1573 ^ s1637; + s1639 = s1624 ^ s1638; + s1640 = sbv_bv_extract_u32_31_24_u8(s1639); + s1641 = table1[s1640]; + s1642 = sbv_bv_extract_u32_31_24_u8(s1589); + s1643 = table1[s1642]; + s1644 = sbv_bv_extract_u32_23_16_u8(s1605); + s1645 = table2[s1644]; + s1646 = s1643 ^ s1645; + s1647 = sbv_bv_extract_u32_15_8_u8(s1621); + s1648 = table3[s1647]; + s1649 = s1646 ^ s1648; + s1650 = sbv_bv_extract_u32_7_0_u8(s1574); + s1651 = table4[s1650]; + s1652 = s1649 ^ s1651; + s1653 = s1588 ^ s1638; + s1654 = s1652 ^ s1653; + s1655 = sbv_bv_extract_u32_23_16_u8(s1654); + s1656 = table2[s1655]; + s1657 = s1641 ^ s1656; + s1658 = sbv_bv_extract_u32_31_24_u8(s1605); + s1659 = table1[s1658]; + s1660 = sbv_bv_extract_u32_23_16_u8(s1621); + s1661 = table2[s1660]; + s1662 = s1659 ^ s1661; + s1663 = sbv_bv_extract_u32_15_8_u8(s1574); + s1664 = table3[s1663]; + s1665 = s1662 ^ s1664; + s1666 = sbv_bv_extract_u32_7_0_u8(s1589); + s1667 = table4[s1666]; + s1668 = s1665 ^ s1667; + s1669 = s1604 ^ s1653; + s1670 = s1668 ^ s1669; + s1671 = sbv_bv_extract_u32_15_8_u8(s1670); + s1672 = table3[s1671]; + s1673 = s1657 ^ s1672; + s1674 = sbv_bv_extract_u32_31_24_u8(s1621); + s1675 = table1[s1674]; + s1676 = sbv_bv_extract_u32_23_16_u8(s1574); + s1677 = table2[s1676]; + s1678 = s1675 ^ s1677; + s1679 = sbv_bv_extract_u32_15_8_u8(s1589); + s1680 = table3[s1679]; + s1681 = s1678 ^ s1680; + s1682 = sbv_bv_extract_u32_7_0_u8(s1605); + s1683 = table4[s1682]; + s1684 = s1681 ^ s1683; + s1685 = s1620 ^ s1669; + s1686 = s1684 ^ s1685; + s1687 = sbv_bv_extract_u32_7_0_u8(s1686); + s1688 = table4[s1687]; + s1689 = s1673 ^ s1688; + s1690 = sbv_bv_u32_rotl(s1685, 8); + s1691 = sbv_bv_extract_u32_31_24_u8(s1690); + s1692 = table0[s1691]; + s1693 = 64 ^ s1692; + s1694 = sbv_bv_extract_u32_23_16_u8(s1690); + s1695 = table0[s1694]; + s1696 = sbv_bv_join_u8_u8_u16(s1693, s1695); + s1697 = sbv_bv_extract_u32_15_8_u8(s1690); + s1698 = table0[s1697]; + s1699 = sbv_bv_extract_u32_7_0_u8(s1690); + s1700 = table0[s1699]; + s1701 = sbv_bv_join_u8_u8_u16(s1698, s1700); + s1702 = sbv_bv_join_u16_u16_u32(s1696, s1701); + s1703 = s1638 ^ s1702; + s1704 = s1689 ^ s1703; + s1705 = sbv_bv_extract_u32_31_24_u8(s1704); + s1706 = table1[s1705]; + s1707 = sbv_bv_extract_u32_31_24_u8(s1654); + s1708 = table1[s1707]; + s1709 = sbv_bv_extract_u32_23_16_u8(s1670); + s1710 = table2[s1709]; + s1711 = s1708 ^ s1710; + s1712 = sbv_bv_extract_u32_15_8_u8(s1686); + s1713 = table3[s1712]; + s1714 = s1711 ^ s1713; + s1715 = sbv_bv_extract_u32_7_0_u8(s1639); + s1716 = table4[s1715]; + s1717 = s1714 ^ s1716; + s1718 = s1653 ^ s1703; + s1719 = s1717 ^ s1718; + s1720 = sbv_bv_extract_u32_23_16_u8(s1719); + s1721 = table2[s1720]; + s1722 = s1706 ^ s1721; + s1723 = sbv_bv_extract_u32_31_24_u8(s1670); + s1724 = table1[s1723]; + s1725 = sbv_bv_extract_u32_23_16_u8(s1686); + s1726 = table2[s1725]; + s1727 = s1724 ^ s1726; + s1728 = sbv_bv_extract_u32_15_8_u8(s1639); + s1729 = table3[s1728]; + s1730 = s1727 ^ s1729; + s1731 = sbv_bv_extract_u32_7_0_u8(s1654); + s1732 = table4[s1731]; + s1733 = s1730 ^ s1732; + s1734 = s1669 ^ s1718; + s1735 = s1733 ^ s1734; + s1736 = sbv_bv_extract_u32_15_8_u8(s1735); + s1737 = table3[s1736]; + s1738 = s1722 ^ s1737; + s1739 = sbv_bv_extract_u32_31_24_u8(s1686); + s1740 = table1[s1739]; + s1741 = sbv_bv_extract_u32_23_16_u8(s1639); + s1742 = table2[s1741]; + s1743 = s1740 ^ s1742; + s1744 = sbv_bv_extract_u32_15_8_u8(s1654); + s1745 = table3[s1744]; + s1746 = s1743 ^ s1745; + s1747 = sbv_bv_extract_u32_7_0_u8(s1670); + s1748 = table4[s1747]; + s1749 = s1746 ^ s1748; + s1750 = s1685 ^ s1734; + s1751 = s1749 ^ s1750; + s1752 = sbv_bv_extract_u32_7_0_u8(s1751); + s1753 = table4[s1752]; + s1754 = s1738 ^ s1753; + s1755 = sbv_bv_u32_rotl(s1750, 8); + s1756 = sbv_bv_extract_u32_31_24_u8(s1755); + s1757 = table0[s1756]; + s1758 = 128 ^ s1757; + s1759 = sbv_bv_extract_u32_23_16_u8(s1755); + s1760 = table0[s1759]; + s1761 = sbv_bv_join_u8_u8_u16(s1758, s1760); + s1762 = sbv_bv_extract_u32_15_8_u8(s1755); + s1763 = table0[s1762]; + s1764 = sbv_bv_extract_u32_7_0_u8(s1755); + s1765 = table0[s1764]; + s1766 = sbv_bv_join_u8_u8_u16(s1763, s1765); + s1767 = sbv_bv_join_u16_u16_u32(s1761, s1766); + s1768 = s1703 ^ s1767; + s1769 = s1754 ^ s1768; + s1770 = sbv_bv_extract_u32_31_24_u8(s1769); + s1771 = table1[s1770]; + s1772 = sbv_bv_extract_u32_31_24_u8(s1719); + s1773 = table1[s1772]; + s1774 = sbv_bv_extract_u32_23_16_u8(s1735); + s1775 = table2[s1774]; + s1776 = s1773 ^ s1775; + s1777 = sbv_bv_extract_u32_15_8_u8(s1751); + s1778 = table3[s1777]; + s1779 = s1776 ^ s1778; + s1780 = sbv_bv_extract_u32_7_0_u8(s1704); + s1781 = table4[s1780]; + s1782 = s1779 ^ s1781; + s1783 = s1718 ^ s1768; + s1784 = s1782 ^ s1783; + s1785 = sbv_bv_extract_u32_23_16_u8(s1784); + s1786 = table2[s1785]; + s1787 = s1771 ^ s1786; + s1788 = sbv_bv_extract_u32_31_24_u8(s1735); + s1789 = table1[s1788]; + s1790 = sbv_bv_extract_u32_23_16_u8(s1751); + s1791 = table2[s1790]; + s1792 = s1789 ^ s1791; + s1793 = sbv_bv_extract_u32_15_8_u8(s1704); + s1794 = table3[s1793]; + s1795 = s1792 ^ s1794; + s1796 = sbv_bv_extract_u32_7_0_u8(s1719); + s1797 = table4[s1796]; + s1798 = s1795 ^ s1797; + s1799 = s1734 ^ s1783; + s1800 = s1798 ^ s1799; + s1801 = sbv_bv_extract_u32_15_8_u8(s1800); + s1802 = table3[s1801]; + s1803 = s1787 ^ s1802; + s1804 = sbv_bv_extract_u32_31_24_u8(s1751); + s1805 = table1[s1804]; + s1806 = sbv_bv_extract_u32_23_16_u8(s1704); + s1807 = table2[s1806]; + s1808 = s1805 ^ s1807; + s1809 = sbv_bv_extract_u32_15_8_u8(s1719); + s1810 = table3[s1809]; + s1811 = s1808 ^ s1810; + s1812 = sbv_bv_extract_u32_7_0_u8(s1735); + s1813 = table4[s1812]; + s1814 = s1811 ^ s1813; + s1815 = s1750 ^ s1799; + s1816 = s1814 ^ s1815; + s1817 = sbv_bv_extract_u32_7_0_u8(s1816); + s1818 = table4[s1817]; + s1819 = s1803 ^ s1818; + s1820 = sbv_bv_u32_rotl(s1815, 8); + s1821 = sbv_bv_extract_u32_31_24_u8(s1820); + s1822 = table0[s1821]; + s1823 = 27 ^ s1822; + s1824 = sbv_bv_extract_u32_23_16_u8(s1820); + s1825 = table0[s1824]; + s1826 = sbv_bv_join_u8_u8_u16(s1823, s1825); + s1827 = sbv_bv_extract_u32_15_8_u8(s1820); + s1828 = table0[s1827]; + s1829 = sbv_bv_extract_u32_7_0_u8(s1820); + s1830 = table0[s1829]; + s1831 = sbv_bv_join_u8_u8_u16(s1828, s1830); + s1832 = sbv_bv_join_u16_u16_u32(s1826, s1831); + s1833 = s1768 ^ s1832; + s1834 = s1819 ^ s1833; + s1835 = sbv_bv_extract_u32_31_24_u8(s1834); + s1836 = table0[s1835]; + s1837 = sbv_bv_extract_u32_31_24_u8(s1784); + s1838 = table1[s1837]; + s1839 = sbv_bv_extract_u32_23_16_u8(s1800); + s1840 = table2[s1839]; + s1841 = s1838 ^ s1840; + s1842 = sbv_bv_extract_u32_15_8_u8(s1816); + s1843 = table3[s1842]; + s1844 = s1841 ^ s1843; + s1845 = sbv_bv_extract_u32_7_0_u8(s1769); + s1846 = table4[s1845]; + s1847 = s1844 ^ s1846; + s1848 = s1783 ^ s1833; + s1849 = s1847 ^ s1848; + s1850 = sbv_bv_extract_u32_23_16_u8(s1849); + s1851 = table0[s1850]; + s1852 = sbv_bv_join_u8_u8_u16(s1836, s1851); + s1853 = sbv_bv_extract_u32_31_24_u8(s1800); + s1854 = table1[s1853]; + s1855 = sbv_bv_extract_u32_23_16_u8(s1816); + s1856 = table2[s1855]; + s1857 = s1854 ^ s1856; + s1858 = sbv_bv_extract_u32_15_8_u8(s1769); + s1859 = table3[s1858]; + s1860 = s1857 ^ s1859; + s1861 = sbv_bv_extract_u32_7_0_u8(s1784); + s1862 = table4[s1861]; + s1863 = s1860 ^ s1862; + s1864 = s1799 ^ s1848; + s1865 = s1863 ^ s1864; + s1866 = sbv_bv_extract_u32_15_8_u8(s1865); + s1867 = table0[s1866]; + s1868 = sbv_bv_extract_u32_31_24_u8(s1816); + s1869 = table1[s1868]; + s1870 = sbv_bv_extract_u32_23_16_u8(s1769); + s1871 = table2[s1870]; + s1872 = s1869 ^ s1871; + s1873 = sbv_bv_extract_u32_15_8_u8(s1784); + s1874 = table3[s1873]; + s1875 = s1872 ^ s1874; + s1876 = sbv_bv_extract_u32_7_0_u8(s1800); + s1877 = table4[s1876]; + s1878 = s1875 ^ s1877; + s1879 = s1815 ^ s1864; + s1880 = s1878 ^ s1879; + s1881 = sbv_bv_extract_u32_7_0_u8(s1880); + s1882 = table0[s1881]; + s1883 = sbv_bv_join_u8_u8_u16(s1867, s1882); + s1884 = sbv_bv_join_u16_u16_u32(s1852, s1883); + s1885 = sbv_bv_u32_rotl(s1879, 8); + s1886 = sbv_bv_extract_u32_31_24_u8(s1885); + s1887 = table0[s1886]; + s1888 = 54 ^ s1887; + s1889 = sbv_bv_extract_u32_23_16_u8(s1885); + s1890 = table0[s1889]; + s1891 = sbv_bv_join_u8_u8_u16(s1888, s1890); + s1892 = sbv_bv_extract_u32_15_8_u8(s1885); + s1893 = table0[s1892]; + s1894 = sbv_bv_extract_u32_7_0_u8(s1885); + s1895 = table0[s1894]; + s1896 = sbv_bv_join_u8_u8_u16(s1893, s1895); + s1897 = sbv_bv_join_u16_u16_u32(s1891, s1896); + s1898 = s1833 ^ s1897; + s1899 = s1884 ^ s1898; + s1900 = sbv_bv_extract_u32_31_24_u8(s1849); + s1901 = table0[s1900]; + s1902 = sbv_bv_extract_u32_23_16_u8(s1865); + s1903 = table0[s1902]; + s1904 = sbv_bv_join_u8_u8_u16(s1901, s1903); + s1905 = sbv_bv_extract_u32_15_8_u8(s1880); + s1906 = table0[s1905]; + s1907 = sbv_bv_extract_u32_7_0_u8(s1834); + s1908 = table0[s1907]; + s1909 = sbv_bv_join_u8_u8_u16(s1906, s1908); + s1910 = sbv_bv_join_u16_u16_u32(s1904, s1909); + s1911 = s1848 ^ s1898; + s1912 = s1910 ^ s1911; + s1913 = sbv_bv_extract_u32_31_24_u8(s1865); + s1914 = table0[s1913]; + s1915 = sbv_bv_extract_u32_23_16_u8(s1880); + s1916 = table0[s1915]; + s1917 = sbv_bv_join_u8_u8_u16(s1914, s1916); + s1918 = sbv_bv_extract_u32_15_8_u8(s1834); + s1919 = table0[s1918]; + s1920 = sbv_bv_extract_u32_7_0_u8(s1849); + s1921 = table0[s1920]; + s1922 = sbv_bv_join_u8_u8_u16(s1919, s1921); + s1923 = sbv_bv_join_u16_u16_u32(s1917, s1922); + s1924 = s1864 ^ s1911; + s1925 = s1923 ^ s1924; + s1926 = sbv_bv_extract_u32_31_24_u8(s1880); + s1927 = table0[s1926]; + s1928 = sbv_bv_extract_u32_23_16_u8(s1834); + s1929 = table0[s1928]; + s1930 = sbv_bv_join_u8_u8_u16(s1927, s1929); + s1931 = sbv_bv_extract_u32_15_8_u8(s1849); + s1932 = table0[s1931]; + s1933 = sbv_bv_extract_u32_7_0_u8(s1865); + s1934 = table0[s1933]; + s1935 = sbv_bv_join_u8_u8_u16(s1932, s1934); + s1936 = sbv_bv_join_u16_u16_u32(s1930, s1935); + s1937 = s1879 ^ s1924; + s1938 = s1936 ^ s1937; + + sbv_output_0[0] = s1899; + sbv_output_0[1] = s1912; + sbv_output_0[2] = s1925; + sbv_output_0[3] = s1938; } == END: "aes128Enc.c" ================== diff --git a/SBVTestSuite/GoldFiles/aes128Lib.gold b/SBVTestSuite/GoldFiles/aes128Lib.gold --- a/SBVTestSuite/GoldFiles/aes128Lib.gold +++ b/SBVTestSuite/GoldFiles/aes128Lib.gold @@ -3,5077 +3,8670 @@ #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 SWord8 s261 = (SWord8) (s260 >> 24); - const SWord8 s262 = table0[s261]; - const SWord8 s263 = 1 ^ s262; - const SWord8 s264 = (SWord8) (s260 >> 16); - const SWord8 s265 = table0[s264]; - const SWord16 s266 = (((SWord16) s263) << 8) | ((SWord16) s265); - const SWord8 s267 = (SWord8) (s260 >> 8); - const SWord8 s268 = table0[s267]; - const SWord8 s269 = (SWord8) s260; - const SWord8 s270 = table0[s269]; - const SWord16 s271 = (((SWord16) s268) << 8) | ((SWord16) s270); - const SWord32 s272 = (((SWord32) s266) << 16) | ((SWord32) s271); - const SWord32 s273 = s0 ^ s272; - const SWord32 s274 = s1 ^ s273; - const SWord32 s275 = s2 ^ s274; - const SWord32 s276 = s3 ^ s275; - const SWord32 s277 = (s276 << 8) | (s276 >> 24); - const SWord8 s278 = (SWord8) (s277 >> 24); - const SWord8 s279 = table0[s278]; - const SWord8 s280 = 2 ^ s279; - const SWord8 s281 = (SWord8) (s277 >> 16); - const SWord8 s282 = table0[s281]; - const SWord16 s283 = (((SWord16) s280) << 8) | ((SWord16) s282); - const SWord8 s284 = (SWord8) (s277 >> 8); - const SWord8 s285 = table0[s284]; - const SWord8 s286 = (SWord8) s277; - const SWord8 s287 = table0[s286]; - const SWord16 s288 = (((SWord16) s285) << 8) | ((SWord16) s287); - const SWord32 s289 = (((SWord32) s283) << 16) | ((SWord32) s288); - const SWord32 s290 = s273 ^ s289; - const SWord32 s291 = s274 ^ s290; - const SWord32 s292 = s275 ^ s291; - const SWord32 s293 = s276 ^ s292; - const SWord32 s294 = (s293 << 8) | (s293 >> 24); - const SWord8 s295 = (SWord8) (s294 >> 24); - const SWord8 s296 = table0[s295]; - const SWord8 s297 = 4 ^ s296; - const SWord8 s298 = (SWord8) (s294 >> 16); - const SWord8 s299 = table0[s298]; - const SWord16 s300 = (((SWord16) s297) << 8) | ((SWord16) s299); - const SWord8 s301 = (SWord8) (s294 >> 8); - const SWord8 s302 = table0[s301]; - const SWord8 s303 = (SWord8) s294; - const SWord8 s304 = table0[s303]; - const SWord16 s305 = (((SWord16) s302) << 8) | ((SWord16) s304); - const SWord32 s306 = (((SWord32) s300) << 16) | ((SWord32) s305); - const SWord32 s307 = s290 ^ s306; - const SWord32 s308 = s291 ^ s307; - const SWord32 s309 = s292 ^ s308; - const SWord32 s310 = s293 ^ s309; - const SWord32 s311 = (s310 << 8) | (s310 >> 24); - const SWord8 s312 = (SWord8) (s311 >> 24); - const SWord8 s313 = table0[s312]; - const SWord8 s314 = 8 ^ s313; - const SWord8 s315 = (SWord8) (s311 >> 16); - const SWord8 s316 = table0[s315]; - const SWord16 s317 = (((SWord16) s314) << 8) | ((SWord16) s316); - const SWord8 s318 = (SWord8) (s311 >> 8); - const SWord8 s319 = table0[s318]; - const SWord8 s320 = (SWord8) s311; - const SWord8 s321 = table0[s320]; - const SWord16 s322 = (((SWord16) s319) << 8) | ((SWord16) s321); - const SWord32 s323 = (((SWord32) s317) << 16) | ((SWord32) s322); - const SWord32 s324 = s307 ^ s323; - const SWord32 s325 = s308 ^ s324; - const SWord32 s326 = s309 ^ s325; - const SWord32 s327 = s310 ^ s326; - const SWord32 s328 = (s327 << 8) | (s327 >> 24); - const SWord8 s329 = (SWord8) (s328 >> 24); - const SWord8 s330 = table0[s329]; - const SWord8 s331 = 16 ^ s330; - const SWord8 s332 = (SWord8) (s328 >> 16); - const SWord8 s333 = table0[s332]; - const SWord16 s334 = (((SWord16) s331) << 8) | ((SWord16) s333); - const SWord8 s335 = (SWord8) (s328 >> 8); - const SWord8 s336 = table0[s335]; - const SWord8 s337 = (SWord8) s328; - const SWord8 s338 = table0[s337]; - const SWord16 s339 = (((SWord16) s336) << 8) | ((SWord16) s338); - const SWord32 s340 = (((SWord32) s334) << 16) | ((SWord32) s339); - const SWord32 s341 = s324 ^ s340; - const SWord32 s342 = s325 ^ s341; - const SWord32 s343 = s326 ^ s342; - const SWord32 s344 = s327 ^ s343; - const SWord32 s345 = (s344 << 8) | (s344 >> 24); - const SWord8 s346 = (SWord8) (s345 >> 24); - const SWord8 s347 = table0[s346]; - const SWord8 s348 = 32 ^ s347; - const SWord8 s349 = (SWord8) (s345 >> 16); - const SWord8 s350 = table0[s349]; - const SWord16 s351 = (((SWord16) s348) << 8) | ((SWord16) s350); - const SWord8 s352 = (SWord8) (s345 >> 8); - const SWord8 s353 = table0[s352]; - const SWord8 s354 = (SWord8) s345; - const SWord8 s355 = table0[s354]; - const SWord16 s356 = (((SWord16) s353) << 8) | ((SWord16) s355); - const SWord32 s357 = (((SWord32) s351) << 16) | ((SWord32) s356); - const SWord32 s358 = s341 ^ s357; - const SWord32 s359 = s342 ^ s358; - const SWord32 s360 = s343 ^ s359; - const SWord32 s361 = s344 ^ s360; - const SWord32 s362 = (s361 << 8) | (s361 >> 24); - const SWord8 s363 = (SWord8) (s362 >> 24); - const SWord8 s364 = table0[s363]; - const SWord8 s365 = 64 ^ s364; - const SWord8 s366 = (SWord8) (s362 >> 16); - const SWord8 s367 = table0[s366]; - const SWord16 s368 = (((SWord16) s365) << 8) | ((SWord16) s367); - const SWord8 s369 = (SWord8) (s362 >> 8); - const SWord8 s370 = table0[s369]; - const SWord8 s371 = (SWord8) s362; - const SWord8 s372 = table0[s371]; - const SWord16 s373 = (((SWord16) s370) << 8) | ((SWord16) s372); - const SWord32 s374 = (((SWord32) s368) << 16) | ((SWord32) s373); - const SWord32 s375 = s358 ^ s374; - const SWord32 s376 = s359 ^ s375; - const SWord32 s377 = s360 ^ s376; - const SWord32 s378 = s361 ^ s377; - const SWord32 s379 = (s378 << 8) | (s378 >> 24); - const SWord8 s380 = (SWord8) (s379 >> 24); - const SWord8 s381 = table0[s380]; - const SWord8 s382 = 128 ^ s381; - const SWord8 s383 = (SWord8) (s379 >> 16); - const SWord8 s384 = table0[s383]; - const SWord16 s385 = (((SWord16) s382) << 8) | ((SWord16) s384); - const SWord8 s386 = (SWord8) (s379 >> 8); - const SWord8 s387 = table0[s386]; - const SWord8 s388 = (SWord8) s379; - const SWord8 s389 = table0[s388]; - const SWord16 s390 = (((SWord16) s387) << 8) | ((SWord16) s389); - const SWord32 s391 = (((SWord32) s385) << 16) | ((SWord32) s390); - const SWord32 s392 = s375 ^ s391; - const SWord32 s393 = s376 ^ s392; - const SWord32 s394 = s377 ^ s393; - const SWord32 s395 = s378 ^ s394; - const SWord32 s396 = (s395 << 8) | (s395 >> 24); - const SWord8 s397 = (SWord8) (s396 >> 24); - const SWord8 s398 = table0[s397]; - const SWord8 s399 = 27 ^ s398; - const SWord8 s400 = (SWord8) (s396 >> 16); - const SWord8 s401 = table0[s400]; - const SWord16 s402 = (((SWord16) s399) << 8) | ((SWord16) s401); - const SWord8 s403 = (SWord8) (s396 >> 8); - const SWord8 s404 = table0[s403]; - const SWord8 s405 = (SWord8) s396; - const SWord8 s406 = table0[s405]; - const SWord16 s407 = (((SWord16) s404) << 8) | ((SWord16) s406); - const SWord32 s408 = (((SWord32) s402) << 16) | ((SWord32) s407); - const SWord32 s409 = s392 ^ s408; - const SWord32 s410 = s393 ^ s409; - const SWord32 s411 = s394 ^ s410; - const SWord32 s412 = s395 ^ s411; - const SWord32 s413 = (s412 << 8) | (s412 >> 24); - const SWord8 s414 = (SWord8) (s413 >> 24); - const SWord8 s415 = table0[s414]; - const SWord8 s416 = 54 ^ s415; - const SWord8 s417 = (SWord8) (s413 >> 16); - const SWord8 s418 = table0[s417]; - const SWord16 s419 = (((SWord16) s416) << 8) | ((SWord16) s418); - const SWord8 s420 = (SWord8) (s413 >> 8); - const SWord8 s421 = table0[s420]; - const SWord8 s422 = (SWord8) s413; - const SWord8 s423 = table0[s422]; - const SWord16 s424 = (((SWord16) s421) << 8) | ((SWord16) s423); - const SWord32 s425 = (((SWord32) s419) << 16) | ((SWord32) s424); - const SWord32 s426 = s409 ^ s425; - const SWord32 s427 = s410 ^ s426; - const SWord32 s428 = s411 ^ s427; - const SWord32 s429 = s412 ^ s428; - const SWord8 s430 = (SWord8) (s409 >> 24); - const SWord8 s431 = table1[s430]; - const SWord8 s432 = (SWord8) (s409 >> 16); - const SWord8 s433 = table2[s432]; - const SWord8 s434 = (SWord8) (s409 >> 8); - const SWord8 s435 = table3[s434]; - const SWord8 s436 = (SWord8) s409; - const SWord8 s437 = table4[s436]; - const SWord8 s438 = s435 ^ s437; - const SWord8 s439 = s433 ^ s438; - const SWord8 s440 = s431 ^ s439; - const SWord8 s441 = table4[s430]; - const SWord8 s442 = table1[s432]; - const SWord8 s443 = table2[s434]; - const SWord8 s444 = table3[s436]; - const SWord8 s445 = s443 ^ s444; - const SWord8 s446 = s442 ^ s445; - const SWord8 s447 = s441 ^ s446; - const SWord16 s448 = (((SWord16) s440) << 8) | ((SWord16) s447); - const SWord8 s449 = table3[s430]; - const SWord8 s450 = table4[s432]; - const SWord8 s451 = table1[s434]; - const SWord8 s452 = table2[s436]; - const SWord8 s453 = s451 ^ s452; - const SWord8 s454 = s450 ^ s453; - const SWord8 s455 = s449 ^ s454; - const SWord8 s456 = table2[s430]; - const SWord8 s457 = table3[s432]; - const SWord8 s458 = table4[s434]; - const SWord8 s459 = table1[s436]; - const SWord8 s460 = s458 ^ s459; - const SWord8 s461 = s457 ^ s460; - const SWord8 s462 = s456 ^ s461; - const SWord16 s463 = (((SWord16) s455) << 8) | ((SWord16) s462); - const SWord32 s464 = (((SWord32) s448) << 16) | ((SWord32) s463); - const SWord8 s465 = (SWord8) (s410 >> 24); - const SWord8 s466 = table1[s465]; - const SWord8 s467 = (SWord8) (s410 >> 16); - const SWord8 s468 = table2[s467]; - const SWord8 s469 = (SWord8) (s410 >> 8); - const SWord8 s470 = table3[s469]; - const SWord8 s471 = (SWord8) s410; - const SWord8 s472 = table4[s471]; - const SWord8 s473 = s470 ^ s472; - const SWord8 s474 = s468 ^ s473; - const SWord8 s475 = s466 ^ s474; - const SWord8 s476 = table4[s465]; - const SWord8 s477 = table1[s467]; - const SWord8 s478 = table2[s469]; - const SWord8 s479 = table3[s471]; - const SWord8 s480 = s478 ^ s479; - const SWord8 s481 = s477 ^ s480; - const SWord8 s482 = s476 ^ s481; - const SWord16 s483 = (((SWord16) s475) << 8) | ((SWord16) s482); - const SWord8 s484 = table3[s465]; - const SWord8 s485 = table4[s467]; - const SWord8 s486 = table1[s469]; - const SWord8 s487 = table2[s471]; - const SWord8 s488 = s486 ^ s487; - const SWord8 s489 = s485 ^ s488; - const SWord8 s490 = s484 ^ s489; - const SWord8 s491 = table2[s465]; - const SWord8 s492 = table3[s467]; - const SWord8 s493 = table4[s469]; - const SWord8 s494 = table1[s471]; - const SWord8 s495 = s493 ^ s494; - const SWord8 s496 = s492 ^ s495; - const SWord8 s497 = s491 ^ s496; - const SWord16 s498 = (((SWord16) s490) << 8) | ((SWord16) s497); - const SWord32 s499 = (((SWord32) s483) << 16) | ((SWord32) s498); - const SWord8 s500 = (SWord8) (s411 >> 24); - const SWord8 s501 = table1[s500]; - const SWord8 s502 = (SWord8) (s411 >> 16); - const SWord8 s503 = table2[s502]; - const SWord8 s504 = (SWord8) (s411 >> 8); - const SWord8 s505 = table3[s504]; - const SWord8 s506 = (SWord8) s411; - const SWord8 s507 = table4[s506]; - const SWord8 s508 = s505 ^ s507; - const SWord8 s509 = s503 ^ s508; - const SWord8 s510 = s501 ^ s509; - const SWord8 s511 = table4[s500]; - const SWord8 s512 = table1[s502]; - const SWord8 s513 = table2[s504]; - const SWord8 s514 = table3[s506]; - const SWord8 s515 = s513 ^ s514; - const SWord8 s516 = s512 ^ s515; - const SWord8 s517 = s511 ^ s516; - const SWord16 s518 = (((SWord16) s510) << 8) | ((SWord16) s517); - const SWord8 s519 = table3[s500]; - const SWord8 s520 = table4[s502]; - const SWord8 s521 = table1[s504]; - const SWord8 s522 = table2[s506]; - const SWord8 s523 = s521 ^ s522; - const SWord8 s524 = s520 ^ s523; - const SWord8 s525 = s519 ^ s524; - const SWord8 s526 = table2[s500]; - const SWord8 s527 = table3[s502]; - const SWord8 s528 = table4[s504]; - const SWord8 s529 = table1[s506]; - const SWord8 s530 = s528 ^ s529; - const SWord8 s531 = s527 ^ s530; - const SWord8 s532 = s526 ^ s531; - const SWord16 s533 = (((SWord16) s525) << 8) | ((SWord16) s532); - const SWord32 s534 = (((SWord32) s518) << 16) | ((SWord32) s533); - const SWord8 s535 = (SWord8) (s412 >> 24); - const SWord8 s536 = table1[s535]; - const SWord8 s537 = (SWord8) (s412 >> 16); - const SWord8 s538 = table2[s537]; - const SWord8 s539 = (SWord8) (s412 >> 8); - const SWord8 s540 = table3[s539]; - const SWord8 s541 = (SWord8) s412; - const SWord8 s542 = table4[s541]; - const SWord8 s543 = s540 ^ s542; - const SWord8 s544 = s538 ^ s543; - const SWord8 s545 = s536 ^ s544; - const SWord8 s546 = table4[s535]; - const SWord8 s547 = table1[s537]; - const SWord8 s548 = table2[s539]; - const SWord8 s549 = table3[s541]; - const SWord8 s550 = s548 ^ s549; - const SWord8 s551 = s547 ^ s550; - const SWord8 s552 = s546 ^ s551; - const SWord16 s553 = (((SWord16) s545) << 8) | ((SWord16) s552); - const SWord8 s554 = table3[s535]; - const SWord8 s555 = table4[s537]; - const SWord8 s556 = table1[s539]; - const SWord8 s557 = table2[s541]; - const SWord8 s558 = s556 ^ s557; - const SWord8 s559 = s555 ^ s558; - const SWord8 s560 = s554 ^ s559; - const SWord8 s561 = table2[s535]; - const SWord8 s562 = table3[s537]; - const SWord8 s563 = table4[s539]; - const SWord8 s564 = table1[s541]; - const SWord8 s565 = s563 ^ s564; - const SWord8 s566 = s562 ^ s565; - const SWord8 s567 = s561 ^ s566; - const SWord16 s568 = (((SWord16) s560) << 8) | ((SWord16) s567); - const SWord32 s569 = (((SWord32) s553) << 16) | ((SWord32) s568); - const SWord8 s570 = (SWord8) (s392 >> 24); - const SWord8 s571 = table1[s570]; - const SWord8 s572 = (SWord8) (s392 >> 16); - const SWord8 s573 = table2[s572]; - const SWord8 s574 = (SWord8) (s392 >> 8); - const SWord8 s575 = table3[s574]; - const SWord8 s576 = (SWord8) s392; - const SWord8 s577 = table4[s576]; - const SWord8 s578 = s575 ^ s577; - const SWord8 s579 = s573 ^ s578; - const SWord8 s580 = s571 ^ s579; - const SWord8 s581 = table4[s570]; - const SWord8 s582 = table1[s572]; - const SWord8 s583 = table2[s574]; - const SWord8 s584 = table3[s576]; - const SWord8 s585 = s583 ^ s584; - const SWord8 s586 = s582 ^ s585; - const SWord8 s587 = s581 ^ s586; - const SWord16 s588 = (((SWord16) s580) << 8) | ((SWord16) s587); - const SWord8 s589 = table3[s570]; - const SWord8 s590 = table4[s572]; - const SWord8 s591 = table1[s574]; - const SWord8 s592 = table2[s576]; - const SWord8 s593 = s591 ^ s592; - const SWord8 s594 = s590 ^ s593; - const SWord8 s595 = s589 ^ s594; - const SWord8 s596 = table2[s570]; - const SWord8 s597 = table3[s572]; - const SWord8 s598 = table4[s574]; - const SWord8 s599 = table1[s576]; - const SWord8 s600 = s598 ^ s599; - const SWord8 s601 = s597 ^ s600; - const SWord8 s602 = s596 ^ s601; - const SWord16 s603 = (((SWord16) s595) << 8) | ((SWord16) s602); - const SWord32 s604 = (((SWord32) s588) << 16) | ((SWord32) s603); - const SWord8 s605 = (SWord8) (s393 >> 24); - const SWord8 s606 = table1[s605]; - const SWord8 s607 = (SWord8) (s393 >> 16); - const SWord8 s608 = table2[s607]; - const SWord8 s609 = (SWord8) (s393 >> 8); - const SWord8 s610 = table3[s609]; - const SWord8 s611 = (SWord8) s393; - const SWord8 s612 = table4[s611]; - const SWord8 s613 = s610 ^ s612; - const SWord8 s614 = s608 ^ s613; - const SWord8 s615 = s606 ^ s614; - const SWord8 s616 = table4[s605]; - const SWord8 s617 = table1[s607]; - const SWord8 s618 = table2[s609]; - const SWord8 s619 = table3[s611]; - const SWord8 s620 = s618 ^ s619; - const SWord8 s621 = s617 ^ s620; - const SWord8 s622 = s616 ^ s621; - const SWord16 s623 = (((SWord16) s615) << 8) | ((SWord16) s622); - const SWord8 s624 = table3[s605]; - const SWord8 s625 = table4[s607]; - const SWord8 s626 = table1[s609]; - const SWord8 s627 = table2[s611]; - const SWord8 s628 = s626 ^ s627; - const SWord8 s629 = s625 ^ s628; - const SWord8 s630 = s624 ^ s629; - const SWord8 s631 = table2[s605]; - const SWord8 s632 = table3[s607]; - const SWord8 s633 = table4[s609]; - const SWord8 s634 = table1[s611]; - const SWord8 s635 = s633 ^ s634; - const SWord8 s636 = s632 ^ s635; - const SWord8 s637 = s631 ^ s636; - const SWord16 s638 = (((SWord16) s630) << 8) | ((SWord16) s637); - const SWord32 s639 = (((SWord32) s623) << 16) | ((SWord32) s638); - const SWord8 s640 = (SWord8) (s394 >> 24); - const SWord8 s641 = table1[s640]; - const SWord8 s642 = (SWord8) (s394 >> 16); - const SWord8 s643 = table2[s642]; - const SWord8 s644 = (SWord8) (s394 >> 8); - const SWord8 s645 = table3[s644]; - const SWord8 s646 = (SWord8) s394; - const SWord8 s647 = table4[s646]; - const SWord8 s648 = s645 ^ s647; - const SWord8 s649 = s643 ^ s648; - const SWord8 s650 = s641 ^ s649; - const SWord8 s651 = table4[s640]; - const SWord8 s652 = table1[s642]; - const SWord8 s653 = table2[s644]; - const SWord8 s654 = table3[s646]; - const SWord8 s655 = s653 ^ s654; - const SWord8 s656 = s652 ^ s655; - const SWord8 s657 = s651 ^ s656; - const SWord16 s658 = (((SWord16) s650) << 8) | ((SWord16) s657); - const SWord8 s659 = table3[s640]; - const SWord8 s660 = table4[s642]; - const SWord8 s661 = table1[s644]; - const SWord8 s662 = table2[s646]; - const SWord8 s663 = s661 ^ s662; - const SWord8 s664 = s660 ^ s663; - const SWord8 s665 = s659 ^ s664; - const SWord8 s666 = table2[s640]; - const SWord8 s667 = table3[s642]; - const SWord8 s668 = table4[s644]; - const SWord8 s669 = table1[s646]; - const SWord8 s670 = s668 ^ s669; - const SWord8 s671 = s667 ^ s670; - const SWord8 s672 = s666 ^ s671; - const SWord16 s673 = (((SWord16) s665) << 8) | ((SWord16) s672); - const SWord32 s674 = (((SWord32) s658) << 16) | ((SWord32) s673); - const SWord8 s675 = (SWord8) (s395 >> 24); - const SWord8 s676 = table1[s675]; - const SWord8 s677 = (SWord8) (s395 >> 16); - const SWord8 s678 = table2[s677]; - const SWord8 s679 = (SWord8) (s395 >> 8); - const SWord8 s680 = table3[s679]; - const SWord8 s681 = (SWord8) s395; - const SWord8 s682 = table4[s681]; - const SWord8 s683 = s680 ^ s682; - const SWord8 s684 = s678 ^ s683; - const SWord8 s685 = s676 ^ s684; - const SWord8 s686 = table4[s675]; - const SWord8 s687 = table1[s677]; - const SWord8 s688 = table2[s679]; - const SWord8 s689 = table3[s681]; - const SWord8 s690 = s688 ^ s689; - const SWord8 s691 = s687 ^ s690; - const SWord8 s692 = s686 ^ s691; - const SWord16 s693 = (((SWord16) s685) << 8) | ((SWord16) s692); - const SWord8 s694 = table3[s675]; - const SWord8 s695 = table4[s677]; - const SWord8 s696 = table1[s679]; - const SWord8 s697 = table2[s681]; - const SWord8 s698 = s696 ^ s697; - const SWord8 s699 = s695 ^ s698; - const SWord8 s700 = s694 ^ s699; - const SWord8 s701 = table2[s675]; - const SWord8 s702 = table3[s677]; - const SWord8 s703 = table4[s679]; - const SWord8 s704 = table1[s681]; - const SWord8 s705 = s703 ^ s704; - const SWord8 s706 = s702 ^ s705; - const SWord8 s707 = s701 ^ s706; - const SWord16 s708 = (((SWord16) s700) << 8) | ((SWord16) s707); - const SWord32 s709 = (((SWord32) s693) << 16) | ((SWord32) s708); - const SWord8 s710 = (SWord8) (s375 >> 24); - const SWord8 s711 = table1[s710]; - const SWord8 s712 = (SWord8) (s375 >> 16); - const SWord8 s713 = table2[s712]; - const SWord8 s714 = (SWord8) (s375 >> 8); - const SWord8 s715 = table3[s714]; - const SWord8 s716 = (SWord8) s375; - const SWord8 s717 = table4[s716]; - const SWord8 s718 = s715 ^ s717; - const SWord8 s719 = s713 ^ s718; - const SWord8 s720 = s711 ^ s719; - const SWord8 s721 = table4[s710]; - const SWord8 s722 = table1[s712]; - const SWord8 s723 = table2[s714]; - const SWord8 s724 = table3[s716]; - const SWord8 s725 = s723 ^ s724; - const SWord8 s726 = s722 ^ s725; - const SWord8 s727 = s721 ^ s726; - const SWord16 s728 = (((SWord16) s720) << 8) | ((SWord16) s727); - const SWord8 s729 = table3[s710]; - const SWord8 s730 = table4[s712]; - const SWord8 s731 = table1[s714]; - const SWord8 s732 = table2[s716]; - const SWord8 s733 = s731 ^ s732; - const SWord8 s734 = s730 ^ s733; - const SWord8 s735 = s729 ^ s734; - const SWord8 s736 = table2[s710]; - const SWord8 s737 = table3[s712]; - const SWord8 s738 = table4[s714]; - const SWord8 s739 = table1[s716]; - const SWord8 s740 = s738 ^ s739; - const SWord8 s741 = s737 ^ s740; - const SWord8 s742 = s736 ^ s741; - const SWord16 s743 = (((SWord16) s735) << 8) | ((SWord16) s742); - const SWord32 s744 = (((SWord32) s728) << 16) | ((SWord32) s743); - const SWord8 s745 = (SWord8) (s376 >> 24); - const SWord8 s746 = table1[s745]; - const SWord8 s747 = (SWord8) (s376 >> 16); - const SWord8 s748 = table2[s747]; - const SWord8 s749 = (SWord8) (s376 >> 8); - const SWord8 s750 = table3[s749]; - const SWord8 s751 = (SWord8) s376; - const SWord8 s752 = table4[s751]; - const SWord8 s753 = s750 ^ s752; - const SWord8 s754 = s748 ^ s753; - const SWord8 s755 = s746 ^ s754; - const SWord8 s756 = table4[s745]; - const SWord8 s757 = table1[s747]; - const SWord8 s758 = table2[s749]; - const SWord8 s759 = table3[s751]; - const SWord8 s760 = s758 ^ s759; - const SWord8 s761 = s757 ^ s760; - const SWord8 s762 = s756 ^ s761; - const SWord16 s763 = (((SWord16) s755) << 8) | ((SWord16) s762); - const SWord8 s764 = table3[s745]; - const SWord8 s765 = table4[s747]; - const SWord8 s766 = table1[s749]; - const SWord8 s767 = table2[s751]; - const SWord8 s768 = s766 ^ s767; - const SWord8 s769 = s765 ^ s768; - const SWord8 s770 = s764 ^ s769; - const SWord8 s771 = table2[s745]; - const SWord8 s772 = table3[s747]; - const SWord8 s773 = table4[s749]; - const SWord8 s774 = table1[s751]; - const SWord8 s775 = s773 ^ s774; - const SWord8 s776 = s772 ^ s775; - const SWord8 s777 = s771 ^ s776; - const SWord16 s778 = (((SWord16) s770) << 8) | ((SWord16) s777); - const SWord32 s779 = (((SWord32) s763) << 16) | ((SWord32) s778); - const SWord8 s780 = (SWord8) (s377 >> 24); - const SWord8 s781 = table1[s780]; - const SWord8 s782 = (SWord8) (s377 >> 16); - const SWord8 s783 = table2[s782]; - const SWord8 s784 = (SWord8) (s377 >> 8); - const SWord8 s785 = table3[s784]; - const SWord8 s786 = (SWord8) s377; - const SWord8 s787 = table4[s786]; - const SWord8 s788 = s785 ^ s787; - const SWord8 s789 = s783 ^ s788; - const SWord8 s790 = s781 ^ s789; - const SWord8 s791 = table4[s780]; - const SWord8 s792 = table1[s782]; - const SWord8 s793 = table2[s784]; - const SWord8 s794 = table3[s786]; - const SWord8 s795 = s793 ^ s794; - const SWord8 s796 = s792 ^ s795; - const SWord8 s797 = s791 ^ s796; - const SWord16 s798 = (((SWord16) s790) << 8) | ((SWord16) s797); - const SWord8 s799 = table3[s780]; - const SWord8 s800 = table4[s782]; - const SWord8 s801 = table1[s784]; - const SWord8 s802 = table2[s786]; - const SWord8 s803 = s801 ^ s802; - const SWord8 s804 = s800 ^ s803; - const SWord8 s805 = s799 ^ s804; - const SWord8 s806 = table2[s780]; - const SWord8 s807 = table3[s782]; - const SWord8 s808 = table4[s784]; - const SWord8 s809 = table1[s786]; - const SWord8 s810 = s808 ^ s809; - const SWord8 s811 = s807 ^ s810; - const SWord8 s812 = s806 ^ s811; - const SWord16 s813 = (((SWord16) s805) << 8) | ((SWord16) s812); - const SWord32 s814 = (((SWord32) s798) << 16) | ((SWord32) s813); - const SWord8 s815 = (SWord8) (s378 >> 24); - const SWord8 s816 = table1[s815]; - const SWord8 s817 = (SWord8) (s378 >> 16); - const SWord8 s818 = table2[s817]; - const SWord8 s819 = (SWord8) (s378 >> 8); - const SWord8 s820 = table3[s819]; - const SWord8 s821 = (SWord8) s378; - const SWord8 s822 = table4[s821]; - const SWord8 s823 = s820 ^ s822; - const SWord8 s824 = s818 ^ s823; - const SWord8 s825 = s816 ^ s824; - const SWord8 s826 = table4[s815]; - const SWord8 s827 = table1[s817]; - const SWord8 s828 = table2[s819]; - const SWord8 s829 = table3[s821]; - const SWord8 s830 = s828 ^ s829; - const SWord8 s831 = s827 ^ s830; - const SWord8 s832 = s826 ^ s831; - const SWord16 s833 = (((SWord16) s825) << 8) | ((SWord16) s832); - const SWord8 s834 = table3[s815]; - const SWord8 s835 = table4[s817]; - const SWord8 s836 = table1[s819]; - const SWord8 s837 = table2[s821]; - const SWord8 s838 = s836 ^ s837; - const SWord8 s839 = s835 ^ s838; - const SWord8 s840 = s834 ^ s839; - const SWord8 s841 = table2[s815]; - const SWord8 s842 = table3[s817]; - const SWord8 s843 = table4[s819]; - const SWord8 s844 = table1[s821]; - const SWord8 s845 = s843 ^ s844; - const SWord8 s846 = s842 ^ s845; - const SWord8 s847 = s841 ^ s846; - const SWord16 s848 = (((SWord16) s840) << 8) | ((SWord16) s847); - const SWord32 s849 = (((SWord32) s833) << 16) | ((SWord32) s848); - const SWord8 s850 = (SWord8) (s358 >> 24); - const SWord8 s851 = table1[s850]; - const SWord8 s852 = (SWord8) (s358 >> 16); - const SWord8 s853 = table2[s852]; - const SWord8 s854 = (SWord8) (s358 >> 8); - const SWord8 s855 = table3[s854]; - const SWord8 s856 = (SWord8) s358; - const SWord8 s857 = table4[s856]; - const SWord8 s858 = s855 ^ s857; - const SWord8 s859 = s853 ^ s858; - const SWord8 s860 = s851 ^ s859; - const SWord8 s861 = table4[s850]; - const SWord8 s862 = table1[s852]; - const SWord8 s863 = table2[s854]; - const SWord8 s864 = table3[s856]; - const SWord8 s865 = s863 ^ s864; - const SWord8 s866 = s862 ^ s865; - const SWord8 s867 = s861 ^ s866; - const SWord16 s868 = (((SWord16) s860) << 8) | ((SWord16) s867); - const SWord8 s869 = table3[s850]; - const SWord8 s870 = table4[s852]; - const SWord8 s871 = table1[s854]; - const SWord8 s872 = table2[s856]; - const SWord8 s873 = s871 ^ s872; - const SWord8 s874 = s870 ^ s873; - const SWord8 s875 = s869 ^ s874; - const SWord8 s876 = table2[s850]; - const SWord8 s877 = table3[s852]; - const SWord8 s878 = table4[s854]; - const SWord8 s879 = table1[s856]; - const SWord8 s880 = s878 ^ s879; - const SWord8 s881 = s877 ^ s880; - const SWord8 s882 = s876 ^ s881; - const SWord16 s883 = (((SWord16) s875) << 8) | ((SWord16) s882); - const SWord32 s884 = (((SWord32) s868) << 16) | ((SWord32) s883); - const SWord8 s885 = (SWord8) (s359 >> 24); - const SWord8 s886 = table1[s885]; - const SWord8 s887 = (SWord8) (s359 >> 16); - const SWord8 s888 = table2[s887]; - const SWord8 s889 = (SWord8) (s359 >> 8); - const SWord8 s890 = table3[s889]; - const SWord8 s891 = (SWord8) s359; - const SWord8 s892 = table4[s891]; - const SWord8 s893 = s890 ^ s892; - const SWord8 s894 = s888 ^ s893; - const SWord8 s895 = s886 ^ s894; - const SWord8 s896 = table4[s885]; - const SWord8 s897 = table1[s887]; - const SWord8 s898 = table2[s889]; - const SWord8 s899 = table3[s891]; - const SWord8 s900 = s898 ^ s899; - const SWord8 s901 = s897 ^ s900; - const SWord8 s902 = s896 ^ s901; - const SWord16 s903 = (((SWord16) s895) << 8) | ((SWord16) s902); - const SWord8 s904 = table3[s885]; - const SWord8 s905 = table4[s887]; - const SWord8 s906 = table1[s889]; - const SWord8 s907 = table2[s891]; - const SWord8 s908 = s906 ^ s907; - const SWord8 s909 = s905 ^ s908; - const SWord8 s910 = s904 ^ s909; - const SWord8 s911 = table2[s885]; - const SWord8 s912 = table3[s887]; - const SWord8 s913 = table4[s889]; - const SWord8 s914 = table1[s891]; - const SWord8 s915 = s913 ^ s914; - const SWord8 s916 = s912 ^ s915; - const SWord8 s917 = s911 ^ s916; - const SWord16 s918 = (((SWord16) s910) << 8) | ((SWord16) s917); - const SWord32 s919 = (((SWord32) s903) << 16) | ((SWord32) s918); - const SWord8 s920 = (SWord8) (s360 >> 24); - const SWord8 s921 = table1[s920]; - const SWord8 s922 = (SWord8) (s360 >> 16); - const SWord8 s923 = table2[s922]; - const SWord8 s924 = (SWord8) (s360 >> 8); - const SWord8 s925 = table3[s924]; - const SWord8 s926 = (SWord8) s360; - const SWord8 s927 = table4[s926]; - const SWord8 s928 = s925 ^ s927; - const SWord8 s929 = s923 ^ s928; - const SWord8 s930 = s921 ^ s929; - const SWord8 s931 = table4[s920]; - const SWord8 s932 = table1[s922]; - const SWord8 s933 = table2[s924]; - const SWord8 s934 = table3[s926]; - const SWord8 s935 = s933 ^ s934; - const SWord8 s936 = s932 ^ s935; - const SWord8 s937 = s931 ^ s936; - const SWord16 s938 = (((SWord16) s930) << 8) | ((SWord16) s937); - const SWord8 s939 = table3[s920]; - const SWord8 s940 = table4[s922]; - const SWord8 s941 = table1[s924]; - const SWord8 s942 = table2[s926]; - const SWord8 s943 = s941 ^ s942; - const SWord8 s944 = s940 ^ s943; - const SWord8 s945 = s939 ^ s944; - const SWord8 s946 = table2[s920]; - const SWord8 s947 = table3[s922]; - const SWord8 s948 = table4[s924]; - const SWord8 s949 = table1[s926]; - const SWord8 s950 = s948 ^ s949; - const SWord8 s951 = s947 ^ s950; - const SWord8 s952 = s946 ^ s951; - const SWord16 s953 = (((SWord16) s945) << 8) | ((SWord16) s952); - const SWord32 s954 = (((SWord32) s938) << 16) | ((SWord32) s953); - const SWord8 s955 = (SWord8) (s361 >> 24); - const SWord8 s956 = table1[s955]; - const SWord8 s957 = (SWord8) (s361 >> 16); - const SWord8 s958 = table2[s957]; - const SWord8 s959 = (SWord8) (s361 >> 8); - const SWord8 s960 = table3[s959]; - const SWord8 s961 = (SWord8) s361; - const SWord8 s962 = table4[s961]; - const SWord8 s963 = s960 ^ s962; - const SWord8 s964 = s958 ^ s963; - const SWord8 s965 = s956 ^ s964; - const SWord8 s966 = table4[s955]; - const SWord8 s967 = table1[s957]; - const SWord8 s968 = table2[s959]; - const SWord8 s969 = table3[s961]; - const SWord8 s970 = s968 ^ s969; - const SWord8 s971 = s967 ^ s970; - const SWord8 s972 = s966 ^ s971; - const SWord16 s973 = (((SWord16) s965) << 8) | ((SWord16) s972); - const SWord8 s974 = table3[s955]; - const SWord8 s975 = table4[s957]; - const SWord8 s976 = table1[s959]; - const SWord8 s977 = table2[s961]; - const SWord8 s978 = s976 ^ s977; - const SWord8 s979 = s975 ^ s978; - const SWord8 s980 = s974 ^ s979; - const SWord8 s981 = table2[s955]; - const SWord8 s982 = table3[s957]; - const SWord8 s983 = table4[s959]; - const SWord8 s984 = table1[s961]; - const SWord8 s985 = s983 ^ s984; - const SWord8 s986 = s982 ^ s985; - const SWord8 s987 = s981 ^ s986; - const SWord16 s988 = (((SWord16) s980) << 8) | ((SWord16) s987); - const SWord32 s989 = (((SWord32) s973) << 16) | ((SWord32) s988); - const SWord8 s990 = (SWord8) (s341 >> 24); - const SWord8 s991 = table1[s990]; - const SWord8 s992 = (SWord8) (s341 >> 16); - const SWord8 s993 = table2[s992]; - const SWord8 s994 = (SWord8) (s341 >> 8); - const SWord8 s995 = table3[s994]; - const SWord8 s996 = (SWord8) s341; - const SWord8 s997 = table4[s996]; - const SWord8 s998 = s995 ^ s997; - const SWord8 s999 = s993 ^ s998; - const SWord8 s1000 = s991 ^ s999; - const SWord8 s1001 = table4[s990]; - const SWord8 s1002 = table1[s992]; - const SWord8 s1003 = table2[s994]; - const SWord8 s1004 = table3[s996]; - const SWord8 s1005 = s1003 ^ s1004; - const SWord8 s1006 = s1002 ^ s1005; - const SWord8 s1007 = s1001 ^ s1006; - const SWord16 s1008 = (((SWord16) s1000) << 8) | ((SWord16) s1007); - const SWord8 s1009 = table3[s990]; - const SWord8 s1010 = table4[s992]; - const SWord8 s1011 = table1[s994]; - const SWord8 s1012 = table2[s996]; - const SWord8 s1013 = s1011 ^ s1012; - const SWord8 s1014 = s1010 ^ s1013; - const SWord8 s1015 = s1009 ^ s1014; - const SWord8 s1016 = table2[s990]; - const SWord8 s1017 = table3[s992]; - const SWord8 s1018 = table4[s994]; - const SWord8 s1019 = table1[s996]; - const SWord8 s1020 = s1018 ^ s1019; - const SWord8 s1021 = s1017 ^ s1020; - const SWord8 s1022 = s1016 ^ s1021; - const SWord16 s1023 = (((SWord16) s1015) << 8) | ((SWord16) s1022); - const SWord32 s1024 = (((SWord32) s1008) << 16) | ((SWord32) s1023); - const SWord8 s1025 = (SWord8) (s342 >> 24); - const SWord8 s1026 = table1[s1025]; - const SWord8 s1027 = (SWord8) (s342 >> 16); - const SWord8 s1028 = table2[s1027]; - const SWord8 s1029 = (SWord8) (s342 >> 8); - const SWord8 s1030 = table3[s1029]; - const SWord8 s1031 = (SWord8) s342; - const SWord8 s1032 = table4[s1031]; - const SWord8 s1033 = s1030 ^ s1032; - const SWord8 s1034 = s1028 ^ s1033; - const SWord8 s1035 = s1026 ^ s1034; - const SWord8 s1036 = table4[s1025]; - const SWord8 s1037 = table1[s1027]; - const SWord8 s1038 = table2[s1029]; - const SWord8 s1039 = table3[s1031]; - const SWord8 s1040 = s1038 ^ s1039; - const SWord8 s1041 = s1037 ^ s1040; - const SWord8 s1042 = s1036 ^ s1041; - const SWord16 s1043 = (((SWord16) s1035) << 8) | ((SWord16) s1042); - const SWord8 s1044 = table3[s1025]; - const SWord8 s1045 = table4[s1027]; - const SWord8 s1046 = table1[s1029]; - const SWord8 s1047 = table2[s1031]; - const SWord8 s1048 = s1046 ^ s1047; - const SWord8 s1049 = s1045 ^ s1048; - const SWord8 s1050 = s1044 ^ s1049; - const SWord8 s1051 = table2[s1025]; - const SWord8 s1052 = table3[s1027]; - const SWord8 s1053 = table4[s1029]; - const SWord8 s1054 = table1[s1031]; - const SWord8 s1055 = s1053 ^ s1054; - const SWord8 s1056 = s1052 ^ s1055; - const SWord8 s1057 = s1051 ^ s1056; - const SWord16 s1058 = (((SWord16) s1050) << 8) | ((SWord16) s1057); - const SWord32 s1059 = (((SWord32) s1043) << 16) | ((SWord32) s1058); - const SWord8 s1060 = (SWord8) (s343 >> 24); - const SWord8 s1061 = table1[s1060]; - const SWord8 s1062 = (SWord8) (s343 >> 16); - const SWord8 s1063 = table2[s1062]; - const SWord8 s1064 = (SWord8) (s343 >> 8); - const SWord8 s1065 = table3[s1064]; - const SWord8 s1066 = (SWord8) s343; - const SWord8 s1067 = table4[s1066]; - const SWord8 s1068 = s1065 ^ s1067; - const SWord8 s1069 = s1063 ^ s1068; - const SWord8 s1070 = s1061 ^ s1069; - const SWord8 s1071 = table4[s1060]; - const SWord8 s1072 = table1[s1062]; - const SWord8 s1073 = table2[s1064]; - const SWord8 s1074 = table3[s1066]; - const SWord8 s1075 = s1073 ^ s1074; - const SWord8 s1076 = s1072 ^ s1075; - const SWord8 s1077 = s1071 ^ s1076; - const SWord16 s1078 = (((SWord16) s1070) << 8) | ((SWord16) s1077); - const SWord8 s1079 = table3[s1060]; - const SWord8 s1080 = table4[s1062]; - const SWord8 s1081 = table1[s1064]; - const SWord8 s1082 = table2[s1066]; - const SWord8 s1083 = s1081 ^ s1082; - const SWord8 s1084 = s1080 ^ s1083; - const SWord8 s1085 = s1079 ^ s1084; - const SWord8 s1086 = table2[s1060]; - const SWord8 s1087 = table3[s1062]; - const SWord8 s1088 = table4[s1064]; - const SWord8 s1089 = table1[s1066]; - const SWord8 s1090 = s1088 ^ s1089; - const SWord8 s1091 = s1087 ^ s1090; - const SWord8 s1092 = s1086 ^ s1091; - const SWord16 s1093 = (((SWord16) s1085) << 8) | ((SWord16) s1092); - const SWord32 s1094 = (((SWord32) s1078) << 16) | ((SWord32) s1093); - const SWord8 s1095 = (SWord8) (s344 >> 24); - const SWord8 s1096 = table1[s1095]; - const SWord8 s1097 = (SWord8) (s344 >> 16); - const SWord8 s1098 = table2[s1097]; - const SWord8 s1099 = (SWord8) (s344 >> 8); - const SWord8 s1100 = table3[s1099]; - const SWord8 s1101 = (SWord8) s344; - const SWord8 s1102 = table4[s1101]; - const SWord8 s1103 = s1100 ^ s1102; - const SWord8 s1104 = s1098 ^ s1103; - const SWord8 s1105 = s1096 ^ s1104; - const SWord8 s1106 = table4[s1095]; - const SWord8 s1107 = table1[s1097]; - const SWord8 s1108 = table2[s1099]; - const SWord8 s1109 = table3[s1101]; - const SWord8 s1110 = s1108 ^ s1109; - const SWord8 s1111 = s1107 ^ s1110; - const SWord8 s1112 = s1106 ^ s1111; - const SWord16 s1113 = (((SWord16) s1105) << 8) | ((SWord16) s1112); - const SWord8 s1114 = table3[s1095]; - const SWord8 s1115 = table4[s1097]; - const SWord8 s1116 = table1[s1099]; - const SWord8 s1117 = table2[s1101]; - const SWord8 s1118 = s1116 ^ s1117; - const SWord8 s1119 = s1115 ^ s1118; - const SWord8 s1120 = s1114 ^ s1119; - const SWord8 s1121 = table2[s1095]; - const SWord8 s1122 = table3[s1097]; - const SWord8 s1123 = table4[s1099]; - const SWord8 s1124 = table1[s1101]; - const SWord8 s1125 = s1123 ^ s1124; - const SWord8 s1126 = s1122 ^ s1125; - const SWord8 s1127 = s1121 ^ s1126; - const SWord16 s1128 = (((SWord16) s1120) << 8) | ((SWord16) s1127); - const SWord32 s1129 = (((SWord32) s1113) << 16) | ((SWord32) s1128); - const SWord8 s1130 = (SWord8) (s324 >> 24); - const SWord8 s1131 = table1[s1130]; - const SWord8 s1132 = (SWord8) (s324 >> 16); - const SWord8 s1133 = table2[s1132]; - const SWord8 s1134 = (SWord8) (s324 >> 8); - const SWord8 s1135 = table3[s1134]; - const SWord8 s1136 = (SWord8) s324; - const SWord8 s1137 = table4[s1136]; - const SWord8 s1138 = s1135 ^ s1137; - const SWord8 s1139 = s1133 ^ s1138; - const SWord8 s1140 = s1131 ^ s1139; - const SWord8 s1141 = table4[s1130]; - const SWord8 s1142 = table1[s1132]; - const SWord8 s1143 = table2[s1134]; - const SWord8 s1144 = table3[s1136]; - const SWord8 s1145 = s1143 ^ s1144; - const SWord8 s1146 = s1142 ^ s1145; - const SWord8 s1147 = s1141 ^ s1146; - const SWord16 s1148 = (((SWord16) s1140) << 8) | ((SWord16) s1147); - const SWord8 s1149 = table3[s1130]; - const SWord8 s1150 = table4[s1132]; - const SWord8 s1151 = table1[s1134]; - const SWord8 s1152 = table2[s1136]; - const SWord8 s1153 = s1151 ^ s1152; - const SWord8 s1154 = s1150 ^ s1153; - const SWord8 s1155 = s1149 ^ s1154; - const SWord8 s1156 = table2[s1130]; - const SWord8 s1157 = table3[s1132]; - const SWord8 s1158 = table4[s1134]; - const SWord8 s1159 = table1[s1136]; - const SWord8 s1160 = s1158 ^ s1159; - const SWord8 s1161 = s1157 ^ s1160; - const SWord8 s1162 = s1156 ^ s1161; - const SWord16 s1163 = (((SWord16) s1155) << 8) | ((SWord16) s1162); - const SWord32 s1164 = (((SWord32) s1148) << 16) | ((SWord32) s1163); - const SWord8 s1165 = (SWord8) (s325 >> 24); - const SWord8 s1166 = table1[s1165]; - const SWord8 s1167 = (SWord8) (s325 >> 16); - const SWord8 s1168 = table2[s1167]; - const SWord8 s1169 = (SWord8) (s325 >> 8); - const SWord8 s1170 = table3[s1169]; - const SWord8 s1171 = (SWord8) s325; - const SWord8 s1172 = table4[s1171]; - const SWord8 s1173 = s1170 ^ s1172; - const SWord8 s1174 = s1168 ^ s1173; - const SWord8 s1175 = s1166 ^ s1174; - const SWord8 s1176 = table4[s1165]; - const SWord8 s1177 = table1[s1167]; - const SWord8 s1178 = table2[s1169]; - const SWord8 s1179 = table3[s1171]; - const SWord8 s1180 = s1178 ^ s1179; - const SWord8 s1181 = s1177 ^ s1180; - const SWord8 s1182 = s1176 ^ s1181; - const SWord16 s1183 = (((SWord16) s1175) << 8) | ((SWord16) s1182); - const SWord8 s1184 = table3[s1165]; - const SWord8 s1185 = table4[s1167]; - const SWord8 s1186 = table1[s1169]; - const SWord8 s1187 = table2[s1171]; - const SWord8 s1188 = s1186 ^ s1187; - const SWord8 s1189 = s1185 ^ s1188; - const SWord8 s1190 = s1184 ^ s1189; - const SWord8 s1191 = table2[s1165]; - const SWord8 s1192 = table3[s1167]; - const SWord8 s1193 = table4[s1169]; - const SWord8 s1194 = table1[s1171]; - const SWord8 s1195 = s1193 ^ s1194; - const SWord8 s1196 = s1192 ^ s1195; - const SWord8 s1197 = s1191 ^ s1196; - const SWord16 s1198 = (((SWord16) s1190) << 8) | ((SWord16) s1197); - const SWord32 s1199 = (((SWord32) s1183) << 16) | ((SWord32) s1198); - const SWord8 s1200 = (SWord8) (s326 >> 24); - const SWord8 s1201 = table1[s1200]; - const SWord8 s1202 = (SWord8) (s326 >> 16); - const SWord8 s1203 = table2[s1202]; - const SWord8 s1204 = (SWord8) (s326 >> 8); - const SWord8 s1205 = table3[s1204]; - const SWord8 s1206 = (SWord8) s326; - const SWord8 s1207 = table4[s1206]; - const SWord8 s1208 = s1205 ^ s1207; - const SWord8 s1209 = s1203 ^ s1208; - const SWord8 s1210 = s1201 ^ s1209; - const SWord8 s1211 = table4[s1200]; - const SWord8 s1212 = table1[s1202]; - const SWord8 s1213 = table2[s1204]; - const SWord8 s1214 = table3[s1206]; - const SWord8 s1215 = s1213 ^ s1214; - const SWord8 s1216 = s1212 ^ s1215; - const SWord8 s1217 = s1211 ^ s1216; - const SWord16 s1218 = (((SWord16) s1210) << 8) | ((SWord16) s1217); - const SWord8 s1219 = table3[s1200]; - const SWord8 s1220 = table4[s1202]; - const SWord8 s1221 = table1[s1204]; - const SWord8 s1222 = table2[s1206]; - const SWord8 s1223 = s1221 ^ s1222; - const SWord8 s1224 = s1220 ^ s1223; - const SWord8 s1225 = s1219 ^ s1224; - const SWord8 s1226 = table2[s1200]; - const SWord8 s1227 = table3[s1202]; - const SWord8 s1228 = table4[s1204]; - const SWord8 s1229 = table1[s1206]; - const SWord8 s1230 = s1228 ^ s1229; - const SWord8 s1231 = s1227 ^ s1230; - const SWord8 s1232 = s1226 ^ s1231; - const SWord16 s1233 = (((SWord16) s1225) << 8) | ((SWord16) s1232); - const SWord32 s1234 = (((SWord32) s1218) << 16) | ((SWord32) s1233); - const SWord8 s1235 = (SWord8) (s327 >> 24); - const SWord8 s1236 = table1[s1235]; - const SWord8 s1237 = (SWord8) (s327 >> 16); - const SWord8 s1238 = table2[s1237]; - const SWord8 s1239 = (SWord8) (s327 >> 8); - const SWord8 s1240 = table3[s1239]; - const SWord8 s1241 = (SWord8) s327; - const SWord8 s1242 = table4[s1241]; - const SWord8 s1243 = s1240 ^ s1242; - const SWord8 s1244 = s1238 ^ s1243; - const SWord8 s1245 = s1236 ^ s1244; - const SWord8 s1246 = table4[s1235]; - const SWord8 s1247 = table1[s1237]; - const SWord8 s1248 = table2[s1239]; - const SWord8 s1249 = table3[s1241]; - const SWord8 s1250 = s1248 ^ s1249; - const SWord8 s1251 = s1247 ^ s1250; - const SWord8 s1252 = s1246 ^ s1251; - const SWord16 s1253 = (((SWord16) s1245) << 8) | ((SWord16) s1252); - const SWord8 s1254 = table3[s1235]; - const SWord8 s1255 = table4[s1237]; - const SWord8 s1256 = table1[s1239]; - const SWord8 s1257 = table2[s1241]; - const SWord8 s1258 = s1256 ^ s1257; - const SWord8 s1259 = s1255 ^ s1258; - const SWord8 s1260 = s1254 ^ s1259; - const SWord8 s1261 = table2[s1235]; - const SWord8 s1262 = table3[s1237]; - const SWord8 s1263 = table4[s1239]; - const SWord8 s1264 = table1[s1241]; - const SWord8 s1265 = s1263 ^ s1264; - const SWord8 s1266 = s1262 ^ s1265; - const SWord8 s1267 = s1261 ^ s1266; - const SWord16 s1268 = (((SWord16) s1260) << 8) | ((SWord16) s1267); - const SWord32 s1269 = (((SWord32) s1253) << 16) | ((SWord32) s1268); - const SWord8 s1270 = (SWord8) (s307 >> 24); - const SWord8 s1271 = table1[s1270]; - const SWord8 s1272 = (SWord8) (s307 >> 16); - const SWord8 s1273 = table2[s1272]; - const SWord8 s1274 = (SWord8) (s307 >> 8); - const SWord8 s1275 = table3[s1274]; - const SWord8 s1276 = (SWord8) s307; - const SWord8 s1277 = table4[s1276]; - const SWord8 s1278 = s1275 ^ s1277; - const SWord8 s1279 = s1273 ^ s1278; - const SWord8 s1280 = s1271 ^ s1279; - const SWord8 s1281 = table4[s1270]; - const SWord8 s1282 = table1[s1272]; - const SWord8 s1283 = table2[s1274]; - const SWord8 s1284 = table3[s1276]; - const SWord8 s1285 = s1283 ^ s1284; - const SWord8 s1286 = s1282 ^ s1285; - const SWord8 s1287 = s1281 ^ s1286; - const SWord16 s1288 = (((SWord16) s1280) << 8) | ((SWord16) s1287); - const SWord8 s1289 = table3[s1270]; - const SWord8 s1290 = table4[s1272]; - const SWord8 s1291 = table1[s1274]; - const SWord8 s1292 = table2[s1276]; - const SWord8 s1293 = s1291 ^ s1292; - const SWord8 s1294 = s1290 ^ s1293; - const SWord8 s1295 = s1289 ^ s1294; - const SWord8 s1296 = table2[s1270]; - const SWord8 s1297 = table3[s1272]; - const SWord8 s1298 = table4[s1274]; - const SWord8 s1299 = table1[s1276]; - const SWord8 s1300 = s1298 ^ s1299; - const SWord8 s1301 = s1297 ^ s1300; - const SWord8 s1302 = s1296 ^ s1301; - const SWord16 s1303 = (((SWord16) s1295) << 8) | ((SWord16) s1302); - const SWord32 s1304 = (((SWord32) s1288) << 16) | ((SWord32) s1303); - const SWord8 s1305 = (SWord8) (s308 >> 24); - const SWord8 s1306 = table1[s1305]; - const SWord8 s1307 = (SWord8) (s308 >> 16); - const SWord8 s1308 = table2[s1307]; - const SWord8 s1309 = (SWord8) (s308 >> 8); - const SWord8 s1310 = table3[s1309]; - const SWord8 s1311 = (SWord8) s308; - const SWord8 s1312 = table4[s1311]; - const SWord8 s1313 = s1310 ^ s1312; - const SWord8 s1314 = s1308 ^ s1313; - const SWord8 s1315 = s1306 ^ s1314; - const SWord8 s1316 = table4[s1305]; - const SWord8 s1317 = table1[s1307]; - const SWord8 s1318 = table2[s1309]; - const SWord8 s1319 = table3[s1311]; - const SWord8 s1320 = s1318 ^ s1319; - const SWord8 s1321 = s1317 ^ s1320; - const SWord8 s1322 = s1316 ^ s1321; - const SWord16 s1323 = (((SWord16) s1315) << 8) | ((SWord16) s1322); - const SWord8 s1324 = table3[s1305]; - const SWord8 s1325 = table4[s1307]; - const SWord8 s1326 = table1[s1309]; - const SWord8 s1327 = table2[s1311]; - const SWord8 s1328 = s1326 ^ s1327; - const SWord8 s1329 = s1325 ^ s1328; - const SWord8 s1330 = s1324 ^ s1329; - const SWord8 s1331 = table2[s1305]; - const SWord8 s1332 = table3[s1307]; - const SWord8 s1333 = table4[s1309]; - const SWord8 s1334 = table1[s1311]; - const SWord8 s1335 = s1333 ^ s1334; - const SWord8 s1336 = s1332 ^ s1335; - const SWord8 s1337 = s1331 ^ s1336; - const SWord16 s1338 = (((SWord16) s1330) << 8) | ((SWord16) s1337); - const SWord32 s1339 = (((SWord32) s1323) << 16) | ((SWord32) s1338); - const SWord8 s1340 = (SWord8) (s309 >> 24); - const SWord8 s1341 = table1[s1340]; - const SWord8 s1342 = (SWord8) (s309 >> 16); - const SWord8 s1343 = table2[s1342]; - const SWord8 s1344 = (SWord8) (s309 >> 8); - const SWord8 s1345 = table3[s1344]; - const SWord8 s1346 = (SWord8) s309; - const SWord8 s1347 = table4[s1346]; - const SWord8 s1348 = s1345 ^ s1347; - const SWord8 s1349 = s1343 ^ s1348; - const SWord8 s1350 = s1341 ^ s1349; - const SWord8 s1351 = table4[s1340]; - const SWord8 s1352 = table1[s1342]; - 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[s1340]; - const SWord8 s1360 = table4[s1342]; - 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[s1340]; - const SWord8 s1367 = table3[s1342]; - 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 SWord8 s1375 = (SWord8) (s310 >> 24); - const SWord8 s1376 = table1[s1375]; - const SWord8 s1377 = (SWord8) (s310 >> 16); - const SWord8 s1378 = table2[s1377]; - const SWord8 s1379 = (SWord8) (s310 >> 8); - const SWord8 s1380 = table3[s1379]; - const SWord8 s1381 = (SWord8) s310; - const SWord8 s1382 = table4[s1381]; - const SWord8 s1383 = s1380 ^ s1382; - const SWord8 s1384 = s1378 ^ s1383; - const SWord8 s1385 = s1376 ^ s1384; - const SWord8 s1386 = table4[s1375]; - const SWord8 s1387 = table1[s1377]; - const SWord8 s1388 = table2[s1379]; - const SWord8 s1389 = table3[s1381]; - const SWord8 s1390 = s1388 ^ s1389; - const SWord8 s1391 = s1387 ^ s1390; - const SWord8 s1392 = s1386 ^ s1391; - const SWord16 s1393 = (((SWord16) s1385) << 8) | ((SWord16) s1392); - const SWord8 s1394 = table3[s1375]; - const SWord8 s1395 = table4[s1377]; - const SWord8 s1396 = table1[s1379]; - const SWord8 s1397 = table2[s1381]; - const SWord8 s1398 = s1396 ^ s1397; - const SWord8 s1399 = s1395 ^ s1398; - const SWord8 s1400 = s1394 ^ s1399; - const SWord8 s1401 = table2[s1375]; - const SWord8 s1402 = table3[s1377]; - const SWord8 s1403 = table4[s1379]; - const SWord8 s1404 = table1[s1381]; - const SWord8 s1405 = s1403 ^ s1404; - const SWord8 s1406 = s1402 ^ s1405; - const SWord8 s1407 = s1401 ^ s1406; - const SWord16 s1408 = (((SWord16) s1400) << 8) | ((SWord16) s1407); - const SWord32 s1409 = (((SWord32) s1393) << 16) | ((SWord32) s1408); - const SWord8 s1410 = (SWord8) (s290 >> 24); - const SWord8 s1411 = table1[s1410]; - const SWord8 s1412 = (SWord8) (s290 >> 16); - const SWord8 s1413 = table2[s1412]; - const SWord8 s1414 = (SWord8) (s290 >> 8); - const SWord8 s1415 = table3[s1414]; - const SWord8 s1416 = (SWord8) s290; - const SWord8 s1417 = table4[s1416]; - const SWord8 s1418 = s1415 ^ s1417; - const SWord8 s1419 = s1413 ^ s1418; - const SWord8 s1420 = s1411 ^ s1419; - const SWord8 s1421 = table4[s1410]; - const SWord8 s1422 = table1[s1412]; - const SWord8 s1423 = table2[s1414]; - const SWord8 s1424 = table3[s1416]; - const SWord8 s1425 = s1423 ^ s1424; - const SWord8 s1426 = s1422 ^ s1425; - const SWord8 s1427 = s1421 ^ s1426; - const SWord16 s1428 = (((SWord16) s1420) << 8) | ((SWord16) s1427); - const SWord8 s1429 = table3[s1410]; - const SWord8 s1430 = table4[s1412]; - const SWord8 s1431 = table1[s1414]; - const SWord8 s1432 = table2[s1416]; - const SWord8 s1433 = s1431 ^ s1432; - const SWord8 s1434 = s1430 ^ s1433; - const SWord8 s1435 = s1429 ^ s1434; - const SWord8 s1436 = table2[s1410]; - const SWord8 s1437 = table3[s1412]; - const SWord8 s1438 = table4[s1414]; - const SWord8 s1439 = table1[s1416]; - const SWord8 s1440 = s1438 ^ s1439; - const SWord8 s1441 = s1437 ^ s1440; - const SWord8 s1442 = s1436 ^ s1441; - const SWord16 s1443 = (((SWord16) s1435) << 8) | ((SWord16) s1442); - const SWord32 s1444 = (((SWord32) s1428) << 16) | ((SWord32) s1443); - const SWord8 s1445 = (SWord8) (s291 >> 24); - const SWord8 s1446 = table1[s1445]; - const SWord8 s1447 = (SWord8) (s291 >> 16); - const SWord8 s1448 = table2[s1447]; - const SWord8 s1449 = (SWord8) (s291 >> 8); - const SWord8 s1450 = table3[s1449]; - const SWord8 s1451 = (SWord8) s291; - const SWord8 s1452 = table4[s1451]; - const SWord8 s1453 = s1450 ^ s1452; - const SWord8 s1454 = s1448 ^ s1453; - const SWord8 s1455 = s1446 ^ s1454; - const SWord8 s1456 = table4[s1445]; - const SWord8 s1457 = table1[s1447]; - const SWord8 s1458 = table2[s1449]; - const SWord8 s1459 = table3[s1451]; - const SWord8 s1460 = s1458 ^ s1459; - const SWord8 s1461 = s1457 ^ s1460; - const SWord8 s1462 = s1456 ^ s1461; - const SWord16 s1463 = (((SWord16) s1455) << 8) | ((SWord16) s1462); - const SWord8 s1464 = table3[s1445]; - const SWord8 s1465 = table4[s1447]; - const SWord8 s1466 = table1[s1449]; - const SWord8 s1467 = table2[s1451]; - const SWord8 s1468 = s1466 ^ s1467; - const SWord8 s1469 = s1465 ^ s1468; - const SWord8 s1470 = s1464 ^ s1469; - const SWord8 s1471 = table2[s1445]; - const SWord8 s1472 = table3[s1447]; - const SWord8 s1473 = table4[s1449]; - const SWord8 s1474 = table1[s1451]; - const SWord8 s1475 = s1473 ^ s1474; - const SWord8 s1476 = s1472 ^ s1475; - const SWord8 s1477 = s1471 ^ s1476; - const SWord16 s1478 = (((SWord16) s1470) << 8) | ((SWord16) s1477); - const SWord32 s1479 = (((SWord32) s1463) << 16) | ((SWord32) s1478); - const SWord8 s1480 = (SWord8) (s292 >> 24); - const SWord8 s1481 = table1[s1480]; - const SWord8 s1482 = (SWord8) (s292 >> 16); - const SWord8 s1483 = table2[s1482]; - const SWord8 s1484 = (SWord8) (s292 >> 8); - const SWord8 s1485 = table3[s1484]; - const SWord8 s1486 = (SWord8) s292; - const SWord8 s1487 = table4[s1486]; - const SWord8 s1488 = s1485 ^ s1487; - const SWord8 s1489 = s1483 ^ s1488; - const SWord8 s1490 = s1481 ^ s1489; - const SWord8 s1491 = table4[s1480]; - const SWord8 s1492 = table1[s1482]; - const SWord8 s1493 = table2[s1484]; - const SWord8 s1494 = table3[s1486]; - const SWord8 s1495 = s1493 ^ s1494; - const SWord8 s1496 = s1492 ^ s1495; - const SWord8 s1497 = s1491 ^ s1496; - const SWord16 s1498 = (((SWord16) s1490) << 8) | ((SWord16) s1497); - const SWord8 s1499 = table3[s1480]; - const SWord8 s1500 = table4[s1482]; - const SWord8 s1501 = table1[s1484]; - const SWord8 s1502 = table2[s1486]; - const SWord8 s1503 = s1501 ^ s1502; - const SWord8 s1504 = s1500 ^ s1503; - const SWord8 s1505 = s1499 ^ s1504; - const SWord8 s1506 = table2[s1480]; - const SWord8 s1507 = table3[s1482]; - const SWord8 s1508 = table4[s1484]; - const SWord8 s1509 = table1[s1486]; - const SWord8 s1510 = s1508 ^ s1509; - const SWord8 s1511 = s1507 ^ s1510; - const SWord8 s1512 = s1506 ^ s1511; - const SWord16 s1513 = (((SWord16) s1505) << 8) | ((SWord16) s1512); - const SWord32 s1514 = (((SWord32) s1498) << 16) | ((SWord32) s1513); - const SWord8 s1515 = (SWord8) (s293 >> 24); - const SWord8 s1516 = table1[s1515]; - const SWord8 s1517 = (SWord8) (s293 >> 16); - const SWord8 s1518 = table2[s1517]; - const SWord8 s1519 = (SWord8) (s293 >> 8); - const SWord8 s1520 = table3[s1519]; - const SWord8 s1521 = (SWord8) s293; - const SWord8 s1522 = table4[s1521]; - const SWord8 s1523 = s1520 ^ s1522; - const SWord8 s1524 = s1518 ^ s1523; - const SWord8 s1525 = s1516 ^ s1524; - const SWord8 s1526 = table4[s1515]; - const SWord8 s1527 = table1[s1517]; - const SWord8 s1528 = table2[s1519]; - const SWord8 s1529 = table3[s1521]; - const SWord8 s1530 = s1528 ^ s1529; - const SWord8 s1531 = s1527 ^ s1530; - const SWord8 s1532 = s1526 ^ s1531; - const SWord16 s1533 = (((SWord16) s1525) << 8) | ((SWord16) s1532); - const SWord8 s1534 = table3[s1515]; - const SWord8 s1535 = table4[s1517]; - const SWord8 s1536 = table1[s1519]; - const SWord8 s1537 = table2[s1521]; - const SWord8 s1538 = s1536 ^ s1537; - const SWord8 s1539 = s1535 ^ s1538; - const SWord8 s1540 = s1534 ^ s1539; - const SWord8 s1541 = table2[s1515]; - const SWord8 s1542 = table3[s1517]; - const SWord8 s1543 = table4[s1519]; - const SWord8 s1544 = table1[s1521]; - const SWord8 s1545 = s1543 ^ s1544; - const SWord8 s1546 = s1542 ^ s1545; - const SWord8 s1547 = s1541 ^ s1546; - const SWord16 s1548 = (((SWord16) s1540) << 8) | ((SWord16) s1547); - const SWord32 s1549 = (((SWord32) s1533) << 16) | ((SWord32) s1548); - const SWord8 s1550 = (SWord8) (s273 >> 24); - const SWord8 s1551 = table1[s1550]; - const SWord8 s1552 = (SWord8) (s273 >> 16); - const SWord8 s1553 = table2[s1552]; - const SWord8 s1554 = (SWord8) (s273 >> 8); - const SWord8 s1555 = table3[s1554]; - const SWord8 s1556 = (SWord8) s273; - const SWord8 s1557 = table4[s1556]; - const SWord8 s1558 = s1555 ^ s1557; - const SWord8 s1559 = s1553 ^ s1558; - const SWord8 s1560 = s1551 ^ s1559; - const SWord8 s1561 = table4[s1550]; - const SWord8 s1562 = table1[s1552]; - const SWord8 s1563 = table2[s1554]; - const SWord8 s1564 = table3[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 = table3[s1550]; - const SWord8 s1570 = table4[s1552]; - const SWord8 s1571 = table1[s1554]; - const SWord8 s1572 = table2[s1556]; - const SWord8 s1573 = s1571 ^ s1572; - const SWord8 s1574 = s1570 ^ s1573; - const SWord8 s1575 = s1569 ^ s1574; - const SWord8 s1576 = table2[s1550]; - const SWord8 s1577 = table3[s1552]; - const SWord8 s1578 = table4[s1554]; - const SWord8 s1579 = table1[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 SWord8 s1585 = (SWord8) (s274 >> 24); - const SWord8 s1586 = table1[s1585]; - const SWord8 s1587 = (SWord8) (s274 >> 16); - const SWord8 s1588 = table2[s1587]; - const SWord8 s1589 = (SWord8) (s274 >> 8); - const SWord8 s1590 = table3[s1589]; - const SWord8 s1591 = (SWord8) s274; - const SWord8 s1592 = table4[s1591]; - const SWord8 s1593 = s1590 ^ s1592; - const SWord8 s1594 = s1588 ^ s1593; - const SWord8 s1595 = s1586 ^ s1594; - const SWord8 s1596 = table4[s1585]; - const SWord8 s1597 = table1[s1587]; - const SWord8 s1598 = table2[s1589]; - const SWord8 s1599 = table3[s1591]; - const SWord8 s1600 = s1598 ^ s1599; - const SWord8 s1601 = s1597 ^ s1600; - const SWord8 s1602 = s1596 ^ s1601; - const SWord16 s1603 = (((SWord16) s1595) << 8) | ((SWord16) s1602); - const SWord8 s1604 = table3[s1585]; - const SWord8 s1605 = table4[s1587]; - const SWord8 s1606 = table1[s1589]; - const SWord8 s1607 = table2[s1591]; - const SWord8 s1608 = s1606 ^ s1607; - const SWord8 s1609 = s1605 ^ s1608; - const SWord8 s1610 = s1604 ^ s1609; - const SWord8 s1611 = table2[s1585]; - const SWord8 s1612 = table3[s1587]; - const SWord8 s1613 = table4[s1589]; - const SWord8 s1614 = table1[s1591]; - const SWord8 s1615 = s1613 ^ s1614; - const SWord8 s1616 = s1612 ^ s1615; - const SWord8 s1617 = s1611 ^ s1616; - const SWord16 s1618 = (((SWord16) s1610) << 8) | ((SWord16) s1617); - const SWord32 s1619 = (((SWord32) s1603) << 16) | ((SWord32) s1618); - const SWord8 s1620 = (SWord8) (s275 >> 24); - const SWord8 s1621 = table1[s1620]; - const SWord8 s1622 = (SWord8) (s275 >> 16); - const SWord8 s1623 = table2[s1622]; - const SWord8 s1624 = (SWord8) (s275 >> 8); - const SWord8 s1625 = table3[s1624]; - const SWord8 s1626 = (SWord8) s275; - const SWord8 s1627 = table4[s1626]; - const SWord8 s1628 = s1625 ^ s1627; - const SWord8 s1629 = s1623 ^ s1628; - const SWord8 s1630 = s1621 ^ s1629; - const SWord8 s1631 = table4[s1620]; - const SWord8 s1632 = table1[s1622]; - const SWord8 s1633 = table2[s1624]; - const SWord8 s1634 = table3[s1626]; - const SWord8 s1635 = s1633 ^ s1634; - const SWord8 s1636 = s1632 ^ s1635; - const SWord8 s1637 = s1631 ^ s1636; - const SWord16 s1638 = (((SWord16) s1630) << 8) | ((SWord16) s1637); - const SWord8 s1639 = table3[s1620]; - const SWord8 s1640 = table4[s1622]; - const SWord8 s1641 = table1[s1624]; - const SWord8 s1642 = table2[s1626]; - const SWord8 s1643 = s1641 ^ s1642; - const SWord8 s1644 = s1640 ^ s1643; - const SWord8 s1645 = s1639 ^ s1644; - const SWord8 s1646 = table2[s1620]; - const SWord8 s1647 = table3[s1622]; - const SWord8 s1648 = table4[s1624]; - const SWord8 s1649 = table1[s1626]; - const SWord8 s1650 = s1648 ^ s1649; - const SWord8 s1651 = s1647 ^ s1650; - const SWord8 s1652 = s1646 ^ s1651; - const SWord16 s1653 = (((SWord16) s1645) << 8) | ((SWord16) s1652); - const SWord32 s1654 = (((SWord32) s1638) << 16) | ((SWord32) s1653); - const SWord8 s1655 = (SWord8) (s276 >> 24); - const SWord8 s1656 = table1[s1655]; - const SWord8 s1657 = (SWord8) (s276 >> 16); - const SWord8 s1658 = table2[s1657]; - const SWord8 s1659 = (SWord8) (s276 >> 8); - const SWord8 s1660 = table3[s1659]; - const SWord8 s1661 = (SWord8) s276; - const SWord8 s1662 = table4[s1661]; - const SWord8 s1663 = s1660 ^ s1662; - const SWord8 s1664 = s1658 ^ s1663; - const SWord8 s1665 = s1656 ^ s1664; - const SWord8 s1666 = table4[s1655]; - const SWord8 s1667 = table1[s1657]; - const SWord8 s1668 = table2[s1659]; - const SWord8 s1669 = table3[s1661]; - const SWord8 s1670 = s1668 ^ s1669; - const SWord8 s1671 = s1667 ^ s1670; - const SWord8 s1672 = s1666 ^ s1671; - const SWord16 s1673 = (((SWord16) s1665) << 8) | ((SWord16) s1672); - const SWord8 s1674 = table3[s1655]; - const SWord8 s1675 = table4[s1657]; - const SWord8 s1676 = table1[s1659]; - const SWord8 s1677 = table2[s1661]; - const SWord8 s1678 = s1676 ^ s1677; - const SWord8 s1679 = s1675 ^ s1678; - const SWord8 s1680 = s1674 ^ s1679; - const SWord8 s1681 = table2[s1655]; - const SWord8 s1682 = table3[s1657]; - const SWord8 s1683 = table4[s1659]; - const SWord8 s1684 = table1[s1661]; - const SWord8 s1685 = s1683 ^ s1684; - const SWord8 s1686 = s1682 ^ s1685; - const SWord8 s1687 = s1681 ^ s1686; - const SWord16 s1688 = (((SWord16) s1680) << 8) | ((SWord16) s1687); - const SWord32 s1689 = (((SWord32) s1673) << 16) | ((SWord32) s1688); - - encKS[0] = s0; - encKS[1] = s1; - encKS[2] = s2; - encKS[3] = s3; - encKS[4] = s273; - encKS[5] = s274; - encKS[6] = s275; - encKS[7] = s276; - encKS[8] = s290; - encKS[9] = s291; - encKS[10] = s292; - encKS[11] = s293; - encKS[12] = s307; - encKS[13] = s308; - encKS[14] = s309; - encKS[15] = s310; - encKS[16] = s324; - encKS[17] = s325; - encKS[18] = s326; - encKS[19] = s327; - encKS[20] = s341; - encKS[21] = s342; - encKS[22] = s343; - encKS[23] = s344; - encKS[24] = s358; - encKS[25] = s359; - encKS[26] = s360; - encKS[27] = s361; - encKS[28] = s375; - encKS[29] = s376; - encKS[30] = s377; - encKS[31] = s378; - encKS[32] = s392; - encKS[33] = s393; - encKS[34] = s394; - encKS[35] = s395; - encKS[36] = s409; - encKS[37] = s410; - encKS[38] = s411; - encKS[39] = s412; - encKS[40] = s426; - encKS[41] = s427; - encKS[42] = s428; - encKS[43] = s429; - decKS[0] = s426; - decKS[1] = s427; - decKS[2] = s428; - decKS[3] = s429; - decKS[4] = s464; - decKS[5] = s499; - decKS[6] = s534; - decKS[7] = s569; - decKS[8] = s604; - decKS[9] = s639; - decKS[10] = s674; - decKS[11] = s709; - decKS[12] = s744; - decKS[13] = s779; - decKS[14] = s814; - decKS[15] = s849; - decKS[16] = s884; - decKS[17] = s919; - decKS[18] = s954; - decKS[19] = s989; - decKS[20] = s1024; - decKS[21] = s1059; - decKS[22] = s1094; - decKS[23] = s1129; - decKS[24] = s1164; - decKS[25] = s1199; - decKS[26] = s1234; - decKS[27] = s1269; - decKS[28] = s1304; - decKS[29] = s1339; - decKS[30] = s1374; - decKS[31] = s1409; - decKS[32] = s1444; - decKS[33] = s1479; - decKS[34] = s1514; - decKS[35] = s1549; - decKS[36] = s1584; - decKS[37] = s1619; - decKS[38] = s1654; - decKS[39] = s1689; - decKS[40] = s0; - decKS[41] = s1; - decKS[42] = s2; - decKS[43] = s3; -} -== END: "aes128KeySchedule.c" ================== -== BEGIN: "aes128BlockEncrypt.c" ================ -/* File: "aes128BlockEncrypt.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Lib.h" - -void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey, - SWord32 *ct) -{ - const SWord32 s0 = pt[0]; - const SWord32 s1 = pt[1]; - const SWord32 s2 = pt[2]; - const SWord32 s3 = pt[3]; - const SWord32 s4 = xkey[0]; - const SWord32 s5 = xkey[1]; - const SWord32 s6 = xkey[2]; - const SWord32 s7 = xkey[3]; - const SWord32 s8 = xkey[4]; - const SWord32 s9 = xkey[5]; - const SWord32 s10 = xkey[6]; - const SWord32 s11 = xkey[7]; - const SWord32 s12 = xkey[8]; - const SWord32 s13 = xkey[9]; - const SWord32 s14 = xkey[10]; - const SWord32 s15 = xkey[11]; - const SWord32 s16 = xkey[12]; - const SWord32 s17 = xkey[13]; - const SWord32 s18 = xkey[14]; - const SWord32 s19 = xkey[15]; - const SWord32 s20 = xkey[16]; - const SWord32 s21 = xkey[17]; - const SWord32 s22 = xkey[18]; - const SWord32 s23 = xkey[19]; - const SWord32 s24 = xkey[20]; - const SWord32 s25 = xkey[21]; - const SWord32 s26 = xkey[22]; - const SWord32 s27 = xkey[23]; - const SWord32 s28 = xkey[24]; - const SWord32 s29 = xkey[25]; - const SWord32 s30 = xkey[26]; - const SWord32 s31 = xkey[27]; - const SWord32 s32 = xkey[28]; - const SWord32 s33 = xkey[29]; - const SWord32 s34 = xkey[30]; - const SWord32 s35 = xkey[31]; - const SWord32 s36 = xkey[32]; - const SWord32 s37 = xkey[33]; - const SWord32 s38 = xkey[34]; - const SWord32 s39 = xkey[35]; - const SWord32 s40 = xkey[36]; - const SWord32 s41 = xkey[37]; - const SWord32 s42 = xkey[38]; - const SWord32 s43 = xkey[39]; - const SWord32 s44 = xkey[40]; - const SWord32 s45 = xkey[41]; - const SWord32 s46 = xkey[42]; - const SWord32 s47 = xkey[43]; - static const SWord8 table0[] = { - 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, - 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, - 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, - 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, - 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, - 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, - 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, - 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, - 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, - 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, - 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, - 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, - 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, - 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, - 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, - 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, - 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, - 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, - 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, - 104, 65, 153, 45, 15, 176, 84, 187, 22 - }; - static const SWord32 table1[] = { - 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, - 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, - 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, - 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, - 0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL, - 0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL, - 0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL, - 0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL, - 0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL, - 0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL, - 0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL, - 0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL, - 0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL, - 0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL, - 0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL, - 0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL, - 0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL, - 0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL, - 0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL, - 0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL, - 0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL, - 0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL, - 0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL, - 0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL, - 0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL, - 0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL, - 0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL, - 0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL, - 0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL, - 0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL, - 0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL, - 0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL, - 0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL, - 0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL, - 0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL, - 0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL, - 0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL, - 0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL, - 0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL, - 0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL, - 0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL, - 0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL, - 0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL, - 0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL, - 0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL, - 0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL, - 0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL, - 0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL, - 0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL, - 0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL, - 0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL, - 0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL, - 0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL, - 0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL, - 0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL, - 0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL, - 0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL, - 0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL, - 0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL, - 0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL, - 0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL, - 0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL, - 0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL, - 0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL - }; - static const SWord32 table2[] = { - 0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL, - 0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL, - 0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL, - 0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL, - 0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL, - 0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL, - 0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL, - 0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL, - 0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL, - 0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL, - 0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL, - 0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL, - 0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL, - 0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL, - 0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL, - 0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL, - 0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL, - 0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL, - 0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL, - 0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL, - 0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL, - 0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL, - 0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL, - 0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL, - 0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL, - 0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL, - 0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL, - 0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL, - 0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL, - 0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL, - 0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL, - 0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL, - 0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL, - 0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL, - 0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL, - 0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL, - 0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL, - 0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL, - 0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL, - 0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL, - 0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL, - 0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL, - 0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL, - 0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL, - 0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL, - 0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL, - 0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL, - 0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL, - 0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL, - 0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL, - 0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL, - 0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL, - 0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL, - 0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL, - 0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL, - 0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL, - 0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL, - 0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL, - 0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL, - 0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL, - 0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL, - 0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL, - 0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL, - 0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL - }; - static const SWord32 table3[] = { - 0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL, - 0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL, - 0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL, - 0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL, - 0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL, - 0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL, - 0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL, - 0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL, - 0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL, - 0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL, - 0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL, - 0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL, - 0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL, - 0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL, - 0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL, - 0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL, - 0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL, - 0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL, - 0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL, - 0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL, - 0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL, - 0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL, - 0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL, - 0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL, - 0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL, - 0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL, - 0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL, - 0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL, - 0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL, - 0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL, - 0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL, - 0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL, - 0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL, - 0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL, - 0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL, - 0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL, - 0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL, - 0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL, - 0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL, - 0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL, - 0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL, - 0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL, - 0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL, - 0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL, - 0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL, - 0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL, - 0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL, - 0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL, - 0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL, - 0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL, - 0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL, - 0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL, - 0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL, - 0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL, - 0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL, - 0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL, - 0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL, - 0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL, - 0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL, - 0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL, - 0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL, - 0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL, - 0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL, - 0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL - }; - static const SWord32 table4[] = { - 0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL, - 0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL, - 0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL, - 0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL, - 0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL, - 0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL, - 0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL, - 0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL, - 0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL, - 0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL, - 0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL, - 0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL, - 0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL, - 0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL, - 0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL, - 0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL, - 0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL, - 0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL, - 0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL, - 0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL, - 0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL, - 0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL, - 0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL, - 0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL, - 0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL, - 0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL, - 0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL, - 0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL, - 0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL, - 0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL, - 0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL, - 0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL, - 0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL, - 0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL, - 0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL, - 0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL, - 0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL, - 0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL, - 0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL, - 0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL, - 0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL, - 0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL, - 0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL, - 0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL, - 0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL, - 0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL, - 0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL, - 0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL, - 0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL, - 0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL, - 0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL, - 0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL, - 0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL, - 0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL, - 0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL, - 0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL, - 0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL, - 0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL, - 0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL, - 0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL, - 0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL, - 0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL, - 0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL, - 0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL - }; - const SWord32 s560 = s0 ^ s4; - const SWord8 s561 = (SWord8) (s560 >> 24); - const SWord32 s562 = table1[s561]; - const SWord32 s818 = s1 ^ s5; - const SWord8 s819 = (SWord8) (s818 >> 16); - const SWord32 s820 = table2[s819]; - const SWord32 s821 = s562 ^ s820; - const SWord32 s1077 = s2 ^ s6; - const SWord8 s1078 = (SWord8) (s1077 >> 8); - const SWord32 s1079 = table3[s1078]; - const SWord32 s1080 = s821 ^ s1079; - const SWord32 s1336 = s3 ^ s7; - const SWord8 s1337 = (SWord8) s1336; - const SWord32 s1338 = table4[s1337]; - const SWord32 s1339 = s1080 ^ s1338; - const SWord32 s1340 = s8 ^ s1339; - const SWord8 s1341 = (SWord8) (s1340 >> 24); - const SWord32 s1342 = table1[s1341]; - const SWord8 s1343 = (SWord8) (s818 >> 24); - const SWord32 s1344 = table1[s1343]; - const SWord8 s1345 = (SWord8) (s1077 >> 16); - const SWord32 s1346 = table2[s1345]; - const SWord32 s1347 = s1344 ^ s1346; - const SWord8 s1348 = (SWord8) (s1336 >> 8); - const SWord32 s1349 = table3[s1348]; - const SWord32 s1350 = s1347 ^ s1349; - const SWord8 s1351 = (SWord8) s560; - const SWord32 s1352 = table4[s1351]; - const SWord32 s1353 = s1350 ^ s1352; - const SWord32 s1354 = s9 ^ s1353; - const SWord8 s1355 = (SWord8) (s1354 >> 16); - const SWord32 s1356 = table2[s1355]; - const SWord32 s1357 = s1342 ^ s1356; - const SWord8 s1358 = (SWord8) (s1077 >> 24); - const SWord32 s1359 = table1[s1358]; - const SWord8 s1360 = (SWord8) (s1336 >> 16); - const SWord32 s1361 = table2[s1360]; - const SWord32 s1362 = s1359 ^ s1361; - const SWord8 s1363 = (SWord8) (s560 >> 8); - const SWord32 s1364 = table3[s1363]; - const SWord32 s1365 = s1362 ^ s1364; - const SWord8 s1366 = (SWord8) s818; - const SWord32 s1367 = table4[s1366]; - const SWord32 s1368 = s1365 ^ s1367; - const SWord32 s1369 = s10 ^ s1368; - const SWord8 s1370 = (SWord8) (s1369 >> 8); - const SWord32 s1371 = table3[s1370]; - const SWord32 s1372 = s1357 ^ s1371; - const SWord8 s1373 = (SWord8) (s1336 >> 24); - const SWord32 s1374 = table1[s1373]; - const SWord8 s1375 = (SWord8) (s560 >> 16); - const SWord32 s1376 = table2[s1375]; - const SWord32 s1377 = s1374 ^ s1376; - const SWord8 s1378 = (SWord8) (s818 >> 8); - const SWord32 s1379 = table3[s1378]; - const SWord32 s1380 = s1377 ^ s1379; - const SWord8 s1381 = (SWord8) s1077; - const SWord32 s1382 = table4[s1381]; - const SWord32 s1383 = s1380 ^ s1382; - const SWord32 s1384 = s11 ^ s1383; - const SWord8 s1385 = (SWord8) s1384; - const SWord32 s1386 = table4[s1385]; - const SWord32 s1387 = s1372 ^ s1386; - const SWord32 s1388 = s12 ^ s1387; - const SWord8 s1389 = (SWord8) (s1388 >> 24); - const SWord32 s1390 = table1[s1389]; - const SWord8 s1391 = (SWord8) (s1354 >> 24); - const SWord32 s1392 = table1[s1391]; - const SWord8 s1393 = (SWord8) (s1369 >> 16); - const SWord32 s1394 = table2[s1393]; - const SWord32 s1395 = s1392 ^ s1394; - const SWord8 s1396 = (SWord8) (s1384 >> 8); - const SWord32 s1397 = table3[s1396]; - const SWord32 s1398 = s1395 ^ s1397; - const SWord8 s1399 = (SWord8) s1340; - const SWord32 s1400 = table4[s1399]; - const SWord32 s1401 = s1398 ^ s1400; - const SWord32 s1402 = s13 ^ s1401; - const SWord8 s1403 = (SWord8) (s1402 >> 16); - const SWord32 s1404 = table2[s1403]; - const SWord32 s1405 = s1390 ^ s1404; - const SWord8 s1406 = (SWord8) (s1369 >> 24); - const SWord32 s1407 = table1[s1406]; - const SWord8 s1408 = (SWord8) (s1384 >> 16); - const SWord32 s1409 = table2[s1408]; - const SWord32 s1410 = s1407 ^ s1409; - const SWord8 s1411 = (SWord8) (s1340 >> 8); - const SWord32 s1412 = table3[s1411]; - const SWord32 s1413 = s1410 ^ s1412; - const SWord8 s1414 = (SWord8) s1354; - const SWord32 s1415 = table4[s1414]; - const SWord32 s1416 = s1413 ^ s1415; - const SWord32 s1417 = s14 ^ s1416; - const SWord8 s1418 = (SWord8) (s1417 >> 8); - const SWord32 s1419 = table3[s1418]; - const SWord32 s1420 = s1405 ^ s1419; - const SWord8 s1421 = (SWord8) (s1384 >> 24); - const SWord32 s1422 = table1[s1421]; - const SWord8 s1423 = (SWord8) (s1340 >> 16); - const SWord32 s1424 = table2[s1423]; - const SWord32 s1425 = s1422 ^ s1424; - const SWord8 s1426 = (SWord8) (s1354 >> 8); - const SWord32 s1427 = table3[s1426]; - const SWord32 s1428 = s1425 ^ s1427; - const SWord8 s1429 = (SWord8) s1369; - const SWord32 s1430 = table4[s1429]; - const SWord32 s1431 = s1428 ^ s1430; - const SWord32 s1432 = s15 ^ s1431; - const SWord8 s1433 = (SWord8) s1432; - const SWord32 s1434 = table4[s1433]; - const SWord32 s1435 = s1420 ^ s1434; - const SWord32 s1436 = s16 ^ s1435; - const SWord8 s1437 = (SWord8) (s1436 >> 24); - const SWord32 s1438 = table1[s1437]; - const SWord8 s1439 = (SWord8) (s1402 >> 24); - const SWord32 s1440 = table1[s1439]; - const SWord8 s1441 = (SWord8) (s1417 >> 16); - const SWord32 s1442 = table2[s1441]; - const SWord32 s1443 = s1440 ^ s1442; - const SWord8 s1444 = (SWord8) (s1432 >> 8); - const SWord32 s1445 = table3[s1444]; - const SWord32 s1446 = s1443 ^ s1445; - const SWord8 s1447 = (SWord8) s1388; - const SWord32 s1448 = table4[s1447]; - const SWord32 s1449 = s1446 ^ s1448; - const SWord32 s1450 = s17 ^ s1449; - const SWord8 s1451 = (SWord8) (s1450 >> 16); - const SWord32 s1452 = table2[s1451]; - const SWord32 s1453 = s1438 ^ s1452; - const SWord8 s1454 = (SWord8) (s1417 >> 24); - const SWord32 s1455 = table1[s1454]; - const SWord8 s1456 = (SWord8) (s1432 >> 16); - const SWord32 s1457 = table2[s1456]; - const SWord32 s1458 = s1455 ^ s1457; - const SWord8 s1459 = (SWord8) (s1388 >> 8); - const SWord32 s1460 = table3[s1459]; - const SWord32 s1461 = s1458 ^ s1460; - const SWord8 s1462 = (SWord8) s1402; - const SWord32 s1463 = table4[s1462]; - const SWord32 s1464 = s1461 ^ s1463; - const SWord32 s1465 = s18 ^ s1464; - const SWord8 s1466 = (SWord8) (s1465 >> 8); - const SWord32 s1467 = table3[s1466]; - const SWord32 s1468 = s1453 ^ s1467; - const SWord8 s1469 = (SWord8) (s1432 >> 24); - const SWord32 s1470 = table1[s1469]; - const SWord8 s1471 = (SWord8) (s1388 >> 16); - const SWord32 s1472 = table2[s1471]; - const SWord32 s1473 = s1470 ^ s1472; - const SWord8 s1474 = (SWord8) (s1402 >> 8); - const SWord32 s1475 = table3[s1474]; - const SWord32 s1476 = s1473 ^ s1475; - const SWord8 s1477 = (SWord8) s1417; - const SWord32 s1478 = table4[s1477]; - const SWord32 s1479 = s1476 ^ s1478; - const SWord32 s1480 = s19 ^ s1479; - const SWord8 s1481 = (SWord8) s1480; - const SWord32 s1482 = table4[s1481]; - const SWord32 s1483 = s1468 ^ s1482; - const SWord32 s1484 = s20 ^ s1483; - const SWord8 s1485 = (SWord8) (s1484 >> 24); - const SWord32 s1486 = table1[s1485]; - const SWord8 s1487 = (SWord8) (s1450 >> 24); - const SWord32 s1488 = table1[s1487]; - const SWord8 s1489 = (SWord8) (s1465 >> 16); - const SWord32 s1490 = table2[s1489]; - const SWord32 s1491 = s1488 ^ s1490; - const SWord8 s1492 = (SWord8) (s1480 >> 8); - const SWord32 s1493 = table3[s1492]; - const SWord32 s1494 = s1491 ^ s1493; - const SWord8 s1495 = (SWord8) s1436; - const SWord32 s1496 = table4[s1495]; - const SWord32 s1497 = s1494 ^ s1496; - const SWord32 s1498 = s21 ^ s1497; - const SWord8 s1499 = (SWord8) (s1498 >> 16); - const SWord32 s1500 = table2[s1499]; - const SWord32 s1501 = s1486 ^ s1500; - const SWord8 s1502 = (SWord8) (s1465 >> 24); - const SWord32 s1503 = table1[s1502]; - const SWord8 s1504 = (SWord8) (s1480 >> 16); - const SWord32 s1505 = table2[s1504]; - const SWord32 s1506 = s1503 ^ s1505; - const SWord8 s1507 = (SWord8) (s1436 >> 8); - const SWord32 s1508 = table3[s1507]; - const SWord32 s1509 = s1506 ^ s1508; - const SWord8 s1510 = (SWord8) s1450; - const SWord32 s1511 = table4[s1510]; - const SWord32 s1512 = s1509 ^ s1511; - const SWord32 s1513 = s22 ^ s1512; - const SWord8 s1514 = (SWord8) (s1513 >> 8); - const SWord32 s1515 = table3[s1514]; - const SWord32 s1516 = s1501 ^ s1515; - const SWord8 s1517 = (SWord8) (s1480 >> 24); - const SWord32 s1518 = table1[s1517]; - const SWord8 s1519 = (SWord8) (s1436 >> 16); - const SWord32 s1520 = table2[s1519]; - const SWord32 s1521 = s1518 ^ s1520; - const SWord8 s1522 = (SWord8) (s1450 >> 8); - const SWord32 s1523 = table3[s1522]; - const SWord32 s1524 = s1521 ^ s1523; - const SWord8 s1525 = (SWord8) s1465; - const SWord32 s1526 = table4[s1525]; - const SWord32 s1527 = s1524 ^ s1526; - const SWord32 s1528 = s23 ^ s1527; - const SWord8 s1529 = (SWord8) s1528; - const SWord32 s1530 = table4[s1529]; - const SWord32 s1531 = s1516 ^ s1530; - const SWord32 s1532 = s24 ^ s1531; - const SWord8 s1533 = (SWord8) (s1532 >> 24); - const SWord32 s1534 = table1[s1533]; - const SWord8 s1535 = (SWord8) (s1498 >> 24); - const SWord32 s1536 = table1[s1535]; - const SWord8 s1537 = (SWord8) (s1513 >> 16); - const SWord32 s1538 = table2[s1537]; - const SWord32 s1539 = s1536 ^ s1538; - const SWord8 s1540 = (SWord8) (s1528 >> 8); - const SWord32 s1541 = table3[s1540]; - const SWord32 s1542 = s1539 ^ s1541; - const SWord8 s1543 = (SWord8) s1484; - const SWord32 s1544 = table4[s1543]; - const SWord32 s1545 = s1542 ^ s1544; - const SWord32 s1546 = s25 ^ s1545; - const SWord8 s1547 = (SWord8) (s1546 >> 16); - const SWord32 s1548 = table2[s1547]; - const SWord32 s1549 = s1534 ^ s1548; - const SWord8 s1550 = (SWord8) (s1513 >> 24); - const SWord32 s1551 = table1[s1550]; - const SWord8 s1552 = (SWord8) (s1528 >> 16); - const SWord32 s1553 = table2[s1552]; - const SWord32 s1554 = s1551 ^ s1553; - const SWord8 s1555 = (SWord8) (s1484 >> 8); - const SWord32 s1556 = table3[s1555]; - const SWord32 s1557 = s1554 ^ s1556; - const SWord8 s1558 = (SWord8) s1498; - const SWord32 s1559 = table4[s1558]; - const SWord32 s1560 = s1557 ^ s1559; - const SWord32 s1561 = s26 ^ s1560; - const SWord8 s1562 = (SWord8) (s1561 >> 8); - const SWord32 s1563 = table3[s1562]; - const SWord32 s1564 = s1549 ^ s1563; - const SWord8 s1565 = (SWord8) (s1528 >> 24); - const SWord32 s1566 = table1[s1565]; - const SWord8 s1567 = (SWord8) (s1484 >> 16); - const SWord32 s1568 = table2[s1567]; - const SWord32 s1569 = s1566 ^ s1568; - const SWord8 s1570 = (SWord8) (s1498 >> 8); - const SWord32 s1571 = table3[s1570]; - const SWord32 s1572 = s1569 ^ s1571; - const SWord8 s1573 = (SWord8) s1513; - const SWord32 s1574 = table4[s1573]; - const SWord32 s1575 = s1572 ^ s1574; - const SWord32 s1576 = s27 ^ s1575; - const SWord8 s1577 = (SWord8) s1576; - const SWord32 s1578 = table4[s1577]; - const SWord32 s1579 = s1564 ^ s1578; - const SWord32 s1580 = s28 ^ s1579; - const SWord8 s1581 = (SWord8) (s1580 >> 24); - const SWord32 s1582 = table1[s1581]; - const SWord8 s1583 = (SWord8) (s1546 >> 24); - const SWord32 s1584 = table1[s1583]; - const SWord8 s1585 = (SWord8) (s1561 >> 16); - const SWord32 s1586 = table2[s1585]; - const SWord32 s1587 = s1584 ^ s1586; - const SWord8 s1588 = (SWord8) (s1576 >> 8); - const SWord32 s1589 = table3[s1588]; - const SWord32 s1590 = s1587 ^ s1589; - const SWord8 s1591 = (SWord8) s1532; - const SWord32 s1592 = table4[s1591]; - const SWord32 s1593 = s1590 ^ s1592; - const SWord32 s1594 = s29 ^ s1593; - const SWord8 s1595 = (SWord8) (s1594 >> 16); - const SWord32 s1596 = table2[s1595]; - const SWord32 s1597 = s1582 ^ s1596; - const SWord8 s1598 = (SWord8) (s1561 >> 24); - const SWord32 s1599 = table1[s1598]; - const SWord8 s1600 = (SWord8) (s1576 >> 16); - const SWord32 s1601 = table2[s1600]; - const SWord32 s1602 = s1599 ^ s1601; - const SWord8 s1603 = (SWord8) (s1532 >> 8); - const SWord32 s1604 = table3[s1603]; - const SWord32 s1605 = s1602 ^ s1604; - const SWord8 s1606 = (SWord8) s1546; - const SWord32 s1607 = table4[s1606]; - const SWord32 s1608 = s1605 ^ s1607; - const SWord32 s1609 = s30 ^ s1608; - const SWord8 s1610 = (SWord8) (s1609 >> 8); - const SWord32 s1611 = table3[s1610]; - const SWord32 s1612 = s1597 ^ s1611; - const SWord8 s1613 = (SWord8) (s1576 >> 24); - const SWord32 s1614 = table1[s1613]; - const SWord8 s1615 = (SWord8) (s1532 >> 16); - const SWord32 s1616 = table2[s1615]; - const SWord32 s1617 = s1614 ^ s1616; - const SWord8 s1618 = (SWord8) (s1546 >> 8); - const SWord32 s1619 = table3[s1618]; - const SWord32 s1620 = s1617 ^ s1619; - const SWord8 s1621 = (SWord8) s1561; - const SWord32 s1622 = table4[s1621]; - const SWord32 s1623 = s1620 ^ s1622; - const SWord32 s1624 = s31 ^ s1623; - const SWord8 s1625 = (SWord8) s1624; - const SWord32 s1626 = table4[s1625]; - const SWord32 s1627 = s1612 ^ s1626; - const SWord32 s1628 = s32 ^ s1627; - const SWord8 s1629 = (SWord8) (s1628 >> 24); - const SWord32 s1630 = table1[s1629]; - const SWord8 s1631 = (SWord8) (s1594 >> 24); - const SWord32 s1632 = table1[s1631]; - const SWord8 s1633 = (SWord8) (s1609 >> 16); - const SWord32 s1634 = table2[s1633]; - const SWord32 s1635 = s1632 ^ s1634; - const SWord8 s1636 = (SWord8) (s1624 >> 8); - const SWord32 s1637 = table3[s1636]; - const SWord32 s1638 = s1635 ^ s1637; - const SWord8 s1639 = (SWord8) s1580; - const SWord32 s1640 = table4[s1639]; - const SWord32 s1641 = s1638 ^ s1640; - const SWord32 s1642 = s33 ^ s1641; - const SWord8 s1643 = (SWord8) (s1642 >> 16); - const SWord32 s1644 = table2[s1643]; - const SWord32 s1645 = s1630 ^ s1644; - const SWord8 s1646 = (SWord8) (s1609 >> 24); - const SWord32 s1647 = table1[s1646]; - const SWord8 s1648 = (SWord8) (s1624 >> 16); - const SWord32 s1649 = table2[s1648]; - const SWord32 s1650 = s1647 ^ s1649; - const SWord8 s1651 = (SWord8) (s1580 >> 8); - const SWord32 s1652 = table3[s1651]; - const SWord32 s1653 = s1650 ^ s1652; - const SWord8 s1654 = (SWord8) s1594; - const SWord32 s1655 = table4[s1654]; - const SWord32 s1656 = s1653 ^ s1655; - const SWord32 s1657 = s34 ^ s1656; - const SWord8 s1658 = (SWord8) (s1657 >> 8); - const SWord32 s1659 = table3[s1658]; - const SWord32 s1660 = s1645 ^ s1659; - const SWord8 s1661 = (SWord8) (s1624 >> 24); - const SWord32 s1662 = table1[s1661]; - const SWord8 s1663 = (SWord8) (s1580 >> 16); - const SWord32 s1664 = table2[s1663]; - const SWord32 s1665 = s1662 ^ s1664; - const SWord8 s1666 = (SWord8) (s1594 >> 8); - const SWord32 s1667 = table3[s1666]; - const SWord32 s1668 = s1665 ^ s1667; - const SWord8 s1669 = (SWord8) s1609; - const SWord32 s1670 = table4[s1669]; - const SWord32 s1671 = s1668 ^ s1670; - const SWord32 s1672 = s35 ^ s1671; - const SWord8 s1673 = (SWord8) s1672; - const SWord32 s1674 = table4[s1673]; - const SWord32 s1675 = s1660 ^ s1674; - const SWord32 s1676 = s36 ^ s1675; - const SWord8 s1677 = (SWord8) (s1676 >> 24); - const SWord32 s1678 = table1[s1677]; - const SWord8 s1679 = (SWord8) (s1642 >> 24); - const SWord32 s1680 = table1[s1679]; - const SWord8 s1681 = (SWord8) (s1657 >> 16); - const SWord32 s1682 = table2[s1681]; - const SWord32 s1683 = s1680 ^ s1682; - const SWord8 s1684 = (SWord8) (s1672 >> 8); - const SWord32 s1685 = table3[s1684]; - const SWord32 s1686 = s1683 ^ s1685; - const SWord8 s1687 = (SWord8) s1628; - const SWord32 s1688 = table4[s1687]; - const SWord32 s1689 = s1686 ^ s1688; - const SWord32 s1690 = s37 ^ s1689; - const SWord8 s1691 = (SWord8) (s1690 >> 16); - const SWord32 s1692 = table2[s1691]; - const SWord32 s1693 = s1678 ^ s1692; - const SWord8 s1694 = (SWord8) (s1657 >> 24); - const SWord32 s1695 = table1[s1694]; - const SWord8 s1696 = (SWord8) (s1672 >> 16); - const SWord32 s1697 = table2[s1696]; - const SWord32 s1698 = s1695 ^ s1697; - const SWord8 s1699 = (SWord8) (s1628 >> 8); - const SWord32 s1700 = table3[s1699]; - const SWord32 s1701 = s1698 ^ s1700; - const SWord8 s1702 = (SWord8) s1642; - const SWord32 s1703 = table4[s1702]; - const SWord32 s1704 = s1701 ^ s1703; - const SWord32 s1705 = s38 ^ s1704; - const SWord8 s1706 = (SWord8) (s1705 >> 8); - const SWord32 s1707 = table3[s1706]; - const SWord32 s1708 = s1693 ^ s1707; - const SWord8 s1709 = (SWord8) (s1672 >> 24); - const SWord32 s1710 = table1[s1709]; - const SWord8 s1711 = (SWord8) (s1628 >> 16); - const SWord32 s1712 = table2[s1711]; - const SWord32 s1713 = s1710 ^ s1712; - const SWord8 s1714 = (SWord8) (s1642 >> 8); - const SWord32 s1715 = table3[s1714]; - const SWord32 s1716 = s1713 ^ s1715; - const SWord8 s1717 = (SWord8) s1657; - const SWord32 s1718 = table4[s1717]; - const SWord32 s1719 = s1716 ^ s1718; - const SWord32 s1720 = s39 ^ s1719; - const SWord8 s1721 = (SWord8) s1720; - const SWord32 s1722 = table4[s1721]; - const SWord32 s1723 = s1708 ^ s1722; - const SWord32 s1724 = s40 ^ s1723; - const SWord8 s1725 = (SWord8) (s1724 >> 24); - const SWord8 s1726 = table0[s1725]; - const SWord8 s1727 = (SWord8) (s1690 >> 24); - const SWord32 s1728 = table1[s1727]; - const SWord8 s1729 = (SWord8) (s1705 >> 16); - const SWord32 s1730 = table2[s1729]; - const SWord32 s1731 = s1728 ^ s1730; - const SWord8 s1732 = (SWord8) (s1720 >> 8); - const SWord32 s1733 = table3[s1732]; - const SWord32 s1734 = s1731 ^ s1733; - const SWord8 s1735 = (SWord8) s1676; - const SWord32 s1736 = table4[s1735]; - const SWord32 s1737 = s1734 ^ s1736; - const SWord32 s1738 = s41 ^ s1737; - const SWord8 s1739 = (SWord8) (s1738 >> 16); - const SWord8 s1740 = table0[s1739]; - const SWord16 s1741 = (((SWord16) s1726) << 8) | ((SWord16) s1740); - const SWord8 s1742 = (SWord8) (s1705 >> 24); - const SWord32 s1743 = table1[s1742]; - const SWord8 s1744 = (SWord8) (s1720 >> 16); - const SWord32 s1745 = table2[s1744]; - const SWord32 s1746 = s1743 ^ s1745; - const SWord8 s1747 = (SWord8) (s1676 >> 8); - const SWord32 s1748 = table3[s1747]; - const SWord32 s1749 = s1746 ^ s1748; - const SWord8 s1750 = (SWord8) s1690; - const SWord32 s1751 = table4[s1750]; - const SWord32 s1752 = s1749 ^ s1751; - const SWord32 s1753 = s42 ^ s1752; - const SWord8 s1754 = (SWord8) (s1753 >> 8); - const SWord8 s1755 = table0[s1754]; - const SWord8 s1756 = (SWord8) (s1720 >> 24); - const SWord32 s1757 = table1[s1756]; - const SWord8 s1758 = (SWord8) (s1676 >> 16); - const SWord32 s1759 = table2[s1758]; - const SWord32 s1760 = s1757 ^ s1759; - const SWord8 s1761 = (SWord8) (s1690 >> 8); - const SWord32 s1762 = table3[s1761]; - const SWord32 s1763 = s1760 ^ s1762; - const SWord8 s1764 = (SWord8) s1705; - const SWord32 s1765 = table4[s1764]; - const SWord32 s1766 = s1763 ^ s1765; - const SWord32 s1767 = s43 ^ s1766; - const SWord8 s1768 = (SWord8) s1767; - const SWord8 s1769 = table0[s1768]; - const SWord16 s1770 = (((SWord16) s1755) << 8) | ((SWord16) s1769); - const SWord32 s1771 = (((SWord32) s1741) << 16) | ((SWord32) s1770); - const SWord32 s1772 = s44 ^ s1771; - const SWord8 s1773 = (SWord8) (s1738 >> 24); - const SWord8 s1774 = table0[s1773]; - const SWord8 s1775 = (SWord8) (s1753 >> 16); - const SWord8 s1776 = table0[s1775]; - const SWord16 s1777 = (((SWord16) s1774) << 8) | ((SWord16) s1776); - const SWord8 s1778 = (SWord8) (s1767 >> 8); - const SWord8 s1779 = table0[s1778]; - const SWord8 s1780 = (SWord8) s1724; - const SWord8 s1781 = table0[s1780]; - const SWord16 s1782 = (((SWord16) s1779) << 8) | ((SWord16) s1781); - const SWord32 s1783 = (((SWord32) s1777) << 16) | ((SWord32) s1782); - const SWord32 s1784 = s45 ^ s1783; - const SWord8 s1785 = (SWord8) (s1753 >> 24); - const SWord8 s1786 = table0[s1785]; - const SWord8 s1787 = (SWord8) (s1767 >> 16); - const SWord8 s1788 = table0[s1787]; - const SWord16 s1789 = (((SWord16) s1786) << 8) | ((SWord16) s1788); - const SWord8 s1790 = (SWord8) (s1724 >> 8); - const SWord8 s1791 = table0[s1790]; - const SWord8 s1792 = (SWord8) s1738; - const SWord8 s1793 = table0[s1792]; - const SWord16 s1794 = (((SWord16) s1791) << 8) | ((SWord16) s1793); - const SWord32 s1795 = (((SWord32) s1789) << 16) | ((SWord32) s1794); - const SWord32 s1796 = s46 ^ s1795; - const SWord8 s1797 = (SWord8) (s1767 >> 24); - const SWord8 s1798 = table0[s1797]; - const SWord8 s1799 = (SWord8) (s1724 >> 16); - const SWord8 s1800 = table0[s1799]; - const SWord16 s1801 = (((SWord16) s1798) << 8) | ((SWord16) s1800); - const SWord8 s1802 = (SWord8) (s1738 >> 8); - const SWord8 s1803 = table0[s1802]; - const SWord8 s1804 = (SWord8) s1753; - const SWord8 s1805 = table0[s1804]; - const SWord16 s1806 = (((SWord16) s1803) << 8) | ((SWord16) s1805); - const SWord32 s1807 = (((SWord32) s1801) << 16) | ((SWord32) s1806); - const SWord32 s1808 = s47 ^ s1807; - - ct[0] = s1772; - ct[1] = s1784; - ct[2] = s1796; - ct[3] = s1808; -} -== END: "aes128BlockEncrypt.c" ================== -== BEGIN: "aes128BlockDecrypt.c" ================ -/* File: "aes128BlockDecrypt.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Lib.h" - -void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey, - SWord32 *pt) -{ - const SWord32 s0 = ct[0]; - const SWord32 s1 = ct[1]; - const SWord32 s2 = ct[2]; - const SWord32 s3 = ct[3]; - const SWord32 s4 = xkey[0]; - const SWord32 s5 = xkey[1]; - const SWord32 s6 = xkey[2]; - const SWord32 s7 = xkey[3]; - const SWord32 s8 = xkey[4]; - const SWord32 s9 = xkey[5]; - const SWord32 s10 = xkey[6]; - const SWord32 s11 = xkey[7]; - const SWord32 s12 = xkey[8]; - const SWord32 s13 = xkey[9]; - const SWord32 s14 = xkey[10]; - const SWord32 s15 = xkey[11]; - const SWord32 s16 = xkey[12]; - const SWord32 s17 = xkey[13]; - const SWord32 s18 = xkey[14]; - const SWord32 s19 = xkey[15]; - const SWord32 s20 = xkey[16]; - const SWord32 s21 = xkey[17]; - const SWord32 s22 = xkey[18]; - const SWord32 s23 = xkey[19]; - const SWord32 s24 = xkey[20]; - const SWord32 s25 = xkey[21]; - const SWord32 s26 = xkey[22]; - const SWord32 s27 = xkey[23]; - const SWord32 s28 = xkey[24]; - const SWord32 s29 = xkey[25]; - const SWord32 s30 = xkey[26]; - const SWord32 s31 = xkey[27]; - const SWord32 s32 = xkey[28]; - const SWord32 s33 = xkey[29]; - const SWord32 s34 = xkey[30]; - const SWord32 s35 = xkey[31]; - const SWord32 s36 = xkey[32]; - const SWord32 s37 = xkey[33]; - const SWord32 s38 = xkey[34]; - const SWord32 s39 = xkey[35]; - const SWord32 s40 = xkey[36]; - const SWord32 s41 = xkey[37]; - const SWord32 s42 = xkey[38]; - const SWord32 s43 = xkey[39]; - const SWord32 s44 = xkey[40]; - const SWord32 s45 = xkey[41]; - const SWord32 s46 = xkey[42]; - const SWord32 s47 = xkey[43]; - static const SWord8 table0[] = { - 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, - 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, - 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, - 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, - 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, - 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, - 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, - 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, - 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, - 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, - 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, - 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, - 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, - 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, - 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, - 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, - 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, - 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, - 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, - 38, 225, 105, 20, 99, 85, 33, 12, 125 - }; - static const SWord32 table1[] = { - 0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL, - 0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL, - 0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL, - 0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL, - 0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL, - 0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL, - 0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL, - 0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL, - 0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL, - 0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL, - 0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL, - 0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL, - 0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL, - 0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL, - 0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL, - 0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL, - 0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL, - 0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL, - 0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL, - 0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL, - 0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL, - 0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL, - 0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL, - 0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL, - 0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL, - 0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL, - 0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL, - 0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL, - 0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL, - 0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL, - 0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL, - 0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL, - 0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL, - 0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL, - 0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL, - 0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL, - 0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL, - 0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL, - 0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL, - 0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL, - 0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL, - 0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL, - 0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL, - 0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL, - 0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL, - 0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL, - 0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL, - 0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL, - 0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL, - 0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL, - 0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL, - 0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL, - 0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL, - 0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL, - 0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL, - 0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL, - 0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL, - 0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL, - 0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL, - 0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL, - 0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL, - 0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL, - 0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL, - 0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL - }; - static const SWord32 table2[] = { - 0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL, - 0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL, - 0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL, - 0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL, - 0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL, - 0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL, - 0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL, - 0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL, - 0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL, - 0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL, - 0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL, - 0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL, - 0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL, - 0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL, - 0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL, - 0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL, - 0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL, - 0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL, - 0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL, - 0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL, - 0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL, - 0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL, - 0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL, - 0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL, - 0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL, - 0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL, - 0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL, - 0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL, - 0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL, - 0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL, - 0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL, - 0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL, - 0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL, - 0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL, - 0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL, - 0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL, - 0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL, - 0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL, - 0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL, - 0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL, - 0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL, - 0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL, - 0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL, - 0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL, - 0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL, - 0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL, - 0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL, - 0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL, - 0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL, - 0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL, - 0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL, - 0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL, - 0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL, - 0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL, - 0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL, - 0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL, - 0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL, - 0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL, - 0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL, - 0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL, - 0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL, - 0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL, - 0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL, - 0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL - }; - static const SWord32 table3[] = { - 0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL, - 0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL, - 0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL, - 0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL, - 0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL, - 0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL, - 0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL, - 0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL, - 0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL, - 0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL, - 0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL, - 0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL, - 0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL, - 0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL, - 0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL, - 0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL, - 0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL, - 0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL, - 0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL, - 0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL, - 0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL, - 0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL, - 0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL, - 0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL, - 0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL, - 0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL, - 0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL, - 0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL, - 0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL, - 0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL, - 0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL, - 0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL, - 0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL, - 0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL, - 0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL, - 0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL, - 0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL, - 0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL, - 0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL, - 0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL, - 0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL, - 0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL, - 0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL, - 0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL, - 0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL, - 0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL, - 0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL, - 0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL, - 0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL, - 0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL, - 0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL, - 0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL, - 0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL, - 0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL, - 0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL, - 0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL, - 0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL, - 0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL, - 0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL, - 0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL, - 0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL, - 0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL, - 0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL, - 0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL - }; - static const SWord32 table4[] = { - 0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL, - 0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL, - 0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL, - 0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL, - 0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL, - 0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL, - 0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL, - 0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL, - 0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL, - 0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL, - 0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL, - 0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL, - 0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL, - 0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL, - 0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL, - 0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL, - 0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL, - 0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL, - 0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL, - 0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL, - 0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL, - 0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL, - 0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL, - 0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL, - 0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL, - 0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL, - 0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL, - 0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL, - 0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL, - 0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL, - 0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL, - 0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL, - 0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL, - 0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL, - 0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL, - 0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL, - 0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL, - 0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL, - 0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL, - 0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL, - 0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL, - 0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL, - 0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL, - 0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL, - 0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL, - 0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL, - 0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL, - 0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL, - 0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL, - 0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL, - 0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL, - 0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL, - 0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL, - 0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL, - 0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL, - 0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL, - 0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL, - 0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL, - 0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL, - 0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL, - 0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL, - 0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL, - 0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL, - 0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL - }; - const SWord32 s560 = s0 ^ s4; - const SWord8 s561 = (SWord8) (s560 >> 24); - const SWord32 s562 = table1[s561]; - const SWord32 s818 = s3 ^ s7; - const SWord8 s819 = (SWord8) (s818 >> 16); - const SWord32 s820 = table2[s819]; - const SWord32 s821 = s562 ^ s820; - const SWord32 s1077 = s2 ^ s6; - const SWord8 s1078 = (SWord8) (s1077 >> 8); - const SWord32 s1079 = table3[s1078]; - const SWord32 s1080 = s821 ^ s1079; - const SWord32 s1336 = s1 ^ s5; - const SWord8 s1337 = (SWord8) s1336; - const SWord32 s1338 = table4[s1337]; - const SWord32 s1339 = s1080 ^ s1338; - const SWord32 s1340 = s8 ^ s1339; - const SWord8 s1341 = (SWord8) (s1340 >> 24); - const SWord32 s1342 = table1[s1341]; - const SWord8 s1343 = (SWord8) (s818 >> 24); - const SWord32 s1344 = table1[s1343]; - const SWord8 s1345 = (SWord8) (s1077 >> 16); - const SWord32 s1346 = table2[s1345]; - const SWord32 s1347 = s1344 ^ s1346; - const SWord8 s1348 = (SWord8) (s1336 >> 8); - const SWord32 s1349 = table3[s1348]; - const SWord32 s1350 = s1347 ^ s1349; - const SWord8 s1351 = (SWord8) s560; - const SWord32 s1352 = table4[s1351]; - const SWord32 s1353 = s1350 ^ s1352; - const SWord32 s1354 = s11 ^ s1353; - const SWord8 s1355 = (SWord8) (s1354 >> 16); - const SWord32 s1356 = table2[s1355]; - const SWord32 s1357 = s1342 ^ s1356; - const SWord8 s1358 = (SWord8) (s1077 >> 24); - const SWord32 s1359 = table1[s1358]; - const SWord8 s1360 = (SWord8) (s1336 >> 16); - const SWord32 s1361 = table2[s1360]; - const SWord32 s1362 = s1359 ^ s1361; - const SWord8 s1363 = (SWord8) (s560 >> 8); - const SWord32 s1364 = table3[s1363]; - const SWord32 s1365 = s1362 ^ s1364; - const SWord8 s1366 = (SWord8) s818; - const SWord32 s1367 = table4[s1366]; - const SWord32 s1368 = s1365 ^ s1367; - const SWord32 s1369 = s10 ^ s1368; - const SWord8 s1370 = (SWord8) (s1369 >> 8); - const SWord32 s1371 = table3[s1370]; - const SWord32 s1372 = s1357 ^ s1371; - const SWord8 s1373 = (SWord8) (s1336 >> 24); - const SWord32 s1374 = table1[s1373]; - const SWord8 s1375 = (SWord8) (s560 >> 16); - const SWord32 s1376 = table2[s1375]; - const SWord32 s1377 = s1374 ^ s1376; - const SWord8 s1378 = (SWord8) (s818 >> 8); - const SWord32 s1379 = table3[s1378]; - const SWord32 s1380 = s1377 ^ s1379; - const SWord8 s1381 = (SWord8) s1077; - const SWord32 s1382 = table4[s1381]; - const SWord32 s1383 = s1380 ^ s1382; - const SWord32 s1384 = s9 ^ s1383; - const SWord8 s1385 = (SWord8) s1384; - const SWord32 s1386 = table4[s1385]; - const SWord32 s1387 = s1372 ^ s1386; - const SWord32 s1388 = s12 ^ s1387; - const SWord8 s1389 = (SWord8) (s1388 >> 24); - const SWord32 s1390 = table1[s1389]; - const SWord8 s1391 = (SWord8) (s1354 >> 24); - const SWord32 s1392 = table1[s1391]; - const SWord8 s1393 = (SWord8) (s1369 >> 16); - const SWord32 s1394 = table2[s1393]; - const SWord32 s1395 = s1392 ^ s1394; - const SWord8 s1396 = (SWord8) (s1384 >> 8); - const SWord32 s1397 = table3[s1396]; - const SWord32 s1398 = s1395 ^ s1397; - const SWord8 s1399 = (SWord8) s1340; - const SWord32 s1400 = table4[s1399]; - const SWord32 s1401 = s1398 ^ s1400; - const SWord32 s1402 = s15 ^ s1401; - const SWord8 s1403 = (SWord8) (s1402 >> 16); - const SWord32 s1404 = table2[s1403]; - const SWord32 s1405 = s1390 ^ s1404; - const SWord8 s1406 = (SWord8) (s1369 >> 24); - const SWord32 s1407 = table1[s1406]; - const SWord8 s1408 = (SWord8) (s1384 >> 16); - const SWord32 s1409 = table2[s1408]; - const SWord32 s1410 = s1407 ^ s1409; - const SWord8 s1411 = (SWord8) (s1340 >> 8); - const SWord32 s1412 = table3[s1411]; - const SWord32 s1413 = s1410 ^ s1412; - const SWord8 s1414 = (SWord8) s1354; - const SWord32 s1415 = table4[s1414]; - const SWord32 s1416 = s1413 ^ s1415; - const SWord32 s1417 = s14 ^ s1416; - const SWord8 s1418 = (SWord8) (s1417 >> 8); - const SWord32 s1419 = table3[s1418]; - const SWord32 s1420 = s1405 ^ s1419; - const SWord8 s1421 = (SWord8) (s1384 >> 24); - const SWord32 s1422 = table1[s1421]; - const SWord8 s1423 = (SWord8) (s1340 >> 16); - const SWord32 s1424 = table2[s1423]; - const SWord32 s1425 = s1422 ^ s1424; - const SWord8 s1426 = (SWord8) (s1354 >> 8); - const SWord32 s1427 = table3[s1426]; - const SWord32 s1428 = s1425 ^ s1427; - const SWord8 s1429 = (SWord8) s1369; - const SWord32 s1430 = table4[s1429]; - const SWord32 s1431 = s1428 ^ s1430; - const SWord32 s1432 = s13 ^ s1431; - const SWord8 s1433 = (SWord8) s1432; - const SWord32 s1434 = table4[s1433]; - const SWord32 s1435 = s1420 ^ s1434; - const SWord32 s1436 = s16 ^ s1435; - const SWord8 s1437 = (SWord8) (s1436 >> 24); - const SWord32 s1438 = table1[s1437]; - const SWord8 s1439 = (SWord8) (s1402 >> 24); - const SWord32 s1440 = table1[s1439]; - const SWord8 s1441 = (SWord8) (s1417 >> 16); - const SWord32 s1442 = table2[s1441]; - const SWord32 s1443 = s1440 ^ s1442; - const SWord8 s1444 = (SWord8) (s1432 >> 8); - const SWord32 s1445 = table3[s1444]; - const SWord32 s1446 = s1443 ^ s1445; - const SWord8 s1447 = (SWord8) s1388; - const SWord32 s1448 = table4[s1447]; - const SWord32 s1449 = s1446 ^ s1448; - const SWord32 s1450 = s19 ^ s1449; - const SWord8 s1451 = (SWord8) (s1450 >> 16); - const SWord32 s1452 = table2[s1451]; - const SWord32 s1453 = s1438 ^ s1452; - const SWord8 s1454 = (SWord8) (s1417 >> 24); - const SWord32 s1455 = table1[s1454]; - const SWord8 s1456 = (SWord8) (s1432 >> 16); - const SWord32 s1457 = table2[s1456]; - const SWord32 s1458 = s1455 ^ s1457; - const SWord8 s1459 = (SWord8) (s1388 >> 8); - const SWord32 s1460 = table3[s1459]; - const SWord32 s1461 = s1458 ^ s1460; - const SWord8 s1462 = (SWord8) s1402; - const SWord32 s1463 = table4[s1462]; - const SWord32 s1464 = s1461 ^ s1463; - const SWord32 s1465 = s18 ^ s1464; - const SWord8 s1466 = (SWord8) (s1465 >> 8); - const SWord32 s1467 = table3[s1466]; - const SWord32 s1468 = s1453 ^ s1467; - const SWord8 s1469 = (SWord8) (s1432 >> 24); - const SWord32 s1470 = table1[s1469]; - const SWord8 s1471 = (SWord8) (s1388 >> 16); - const SWord32 s1472 = table2[s1471]; - const SWord32 s1473 = s1470 ^ s1472; - const SWord8 s1474 = (SWord8) (s1402 >> 8); - const SWord32 s1475 = table3[s1474]; - const SWord32 s1476 = s1473 ^ s1475; - const SWord8 s1477 = (SWord8) s1417; - const SWord32 s1478 = table4[s1477]; - const SWord32 s1479 = s1476 ^ s1478; - const SWord32 s1480 = s17 ^ s1479; - const SWord8 s1481 = (SWord8) s1480; - const SWord32 s1482 = table4[s1481]; - const SWord32 s1483 = s1468 ^ s1482; - const SWord32 s1484 = s20 ^ s1483; - const SWord8 s1485 = (SWord8) (s1484 >> 24); - const SWord32 s1486 = table1[s1485]; - const SWord8 s1487 = (SWord8) (s1450 >> 24); - const SWord32 s1488 = table1[s1487]; - const SWord8 s1489 = (SWord8) (s1465 >> 16); - const SWord32 s1490 = table2[s1489]; - const SWord32 s1491 = s1488 ^ s1490; - const SWord8 s1492 = (SWord8) (s1480 >> 8); - const SWord32 s1493 = table3[s1492]; - const SWord32 s1494 = s1491 ^ s1493; - const SWord8 s1495 = (SWord8) s1436; - const SWord32 s1496 = table4[s1495]; - const SWord32 s1497 = s1494 ^ s1496; - const SWord32 s1498 = s23 ^ s1497; - const SWord8 s1499 = (SWord8) (s1498 >> 16); - const SWord32 s1500 = table2[s1499]; - const SWord32 s1501 = s1486 ^ s1500; - const SWord8 s1502 = (SWord8) (s1465 >> 24); - const SWord32 s1503 = table1[s1502]; - const SWord8 s1504 = (SWord8) (s1480 >> 16); - const SWord32 s1505 = table2[s1504]; - const SWord32 s1506 = s1503 ^ s1505; - const SWord8 s1507 = (SWord8) (s1436 >> 8); - const SWord32 s1508 = table3[s1507]; - const SWord32 s1509 = s1506 ^ s1508; - const SWord8 s1510 = (SWord8) s1450; - const SWord32 s1511 = table4[s1510]; - const SWord32 s1512 = s1509 ^ s1511; - const SWord32 s1513 = s22 ^ s1512; - const SWord8 s1514 = (SWord8) (s1513 >> 8); - const SWord32 s1515 = table3[s1514]; - const SWord32 s1516 = s1501 ^ s1515; - const SWord8 s1517 = (SWord8) (s1480 >> 24); - const SWord32 s1518 = table1[s1517]; - const SWord8 s1519 = (SWord8) (s1436 >> 16); - const SWord32 s1520 = table2[s1519]; - const SWord32 s1521 = s1518 ^ s1520; - const SWord8 s1522 = (SWord8) (s1450 >> 8); - const SWord32 s1523 = table3[s1522]; - const SWord32 s1524 = s1521 ^ s1523; - const SWord8 s1525 = (SWord8) s1465; - const SWord32 s1526 = table4[s1525]; - const SWord32 s1527 = s1524 ^ s1526; - const SWord32 s1528 = s21 ^ s1527; - const SWord8 s1529 = (SWord8) s1528; - const SWord32 s1530 = table4[s1529]; - const SWord32 s1531 = s1516 ^ s1530; - const SWord32 s1532 = s24 ^ s1531; - const SWord8 s1533 = (SWord8) (s1532 >> 24); - const SWord32 s1534 = table1[s1533]; - const SWord8 s1535 = (SWord8) (s1498 >> 24); - const SWord32 s1536 = table1[s1535]; - const SWord8 s1537 = (SWord8) (s1513 >> 16); - const SWord32 s1538 = table2[s1537]; - const SWord32 s1539 = s1536 ^ s1538; - const SWord8 s1540 = (SWord8) (s1528 >> 8); - const SWord32 s1541 = table3[s1540]; - const SWord32 s1542 = s1539 ^ s1541; - const SWord8 s1543 = (SWord8) s1484; - const SWord32 s1544 = table4[s1543]; - const SWord32 s1545 = s1542 ^ s1544; - const SWord32 s1546 = s27 ^ s1545; - const SWord8 s1547 = (SWord8) (s1546 >> 16); - const SWord32 s1548 = table2[s1547]; - const SWord32 s1549 = s1534 ^ s1548; - const SWord8 s1550 = (SWord8) (s1513 >> 24); - const SWord32 s1551 = table1[s1550]; - const SWord8 s1552 = (SWord8) (s1528 >> 16); - const SWord32 s1553 = table2[s1552]; - const SWord32 s1554 = s1551 ^ s1553; - const SWord8 s1555 = (SWord8) (s1484 >> 8); - const SWord32 s1556 = table3[s1555]; - const SWord32 s1557 = s1554 ^ s1556; - const SWord8 s1558 = (SWord8) s1498; - const SWord32 s1559 = table4[s1558]; - const SWord32 s1560 = s1557 ^ s1559; - const SWord32 s1561 = s26 ^ s1560; - const SWord8 s1562 = (SWord8) (s1561 >> 8); - const SWord32 s1563 = table3[s1562]; - const SWord32 s1564 = s1549 ^ s1563; - const SWord8 s1565 = (SWord8) (s1528 >> 24); - const SWord32 s1566 = table1[s1565]; - const SWord8 s1567 = (SWord8) (s1484 >> 16); - const SWord32 s1568 = table2[s1567]; - const SWord32 s1569 = s1566 ^ s1568; - const SWord8 s1570 = (SWord8) (s1498 >> 8); - const SWord32 s1571 = table3[s1570]; - const SWord32 s1572 = s1569 ^ s1571; - const SWord8 s1573 = (SWord8) s1513; - const SWord32 s1574 = table4[s1573]; - const SWord32 s1575 = s1572 ^ s1574; - const SWord32 s1576 = s25 ^ s1575; - const SWord8 s1577 = (SWord8) s1576; - const SWord32 s1578 = table4[s1577]; - const SWord32 s1579 = s1564 ^ s1578; - const SWord32 s1580 = s28 ^ s1579; - const SWord8 s1581 = (SWord8) (s1580 >> 24); - const SWord32 s1582 = table1[s1581]; - const SWord8 s1583 = (SWord8) (s1546 >> 24); - const SWord32 s1584 = table1[s1583]; - const SWord8 s1585 = (SWord8) (s1561 >> 16); - const SWord32 s1586 = table2[s1585]; - const SWord32 s1587 = s1584 ^ s1586; - const SWord8 s1588 = (SWord8) (s1576 >> 8); - const SWord32 s1589 = table3[s1588]; - const SWord32 s1590 = s1587 ^ s1589; - const SWord8 s1591 = (SWord8) s1532; - const SWord32 s1592 = table4[s1591]; - const SWord32 s1593 = s1590 ^ s1592; - const SWord32 s1594 = s31 ^ s1593; - const SWord8 s1595 = (SWord8) (s1594 >> 16); - const SWord32 s1596 = table2[s1595]; - const SWord32 s1597 = s1582 ^ s1596; - const SWord8 s1598 = (SWord8) (s1561 >> 24); - const SWord32 s1599 = table1[s1598]; - const SWord8 s1600 = (SWord8) (s1576 >> 16); - const SWord32 s1601 = table2[s1600]; - const SWord32 s1602 = s1599 ^ s1601; - const SWord8 s1603 = (SWord8) (s1532 >> 8); - const SWord32 s1604 = table3[s1603]; - const SWord32 s1605 = s1602 ^ s1604; - const SWord8 s1606 = (SWord8) s1546; - const SWord32 s1607 = table4[s1606]; - const SWord32 s1608 = s1605 ^ s1607; - const SWord32 s1609 = s30 ^ s1608; - const SWord8 s1610 = (SWord8) (s1609 >> 8); - const SWord32 s1611 = table3[s1610]; - const SWord32 s1612 = s1597 ^ s1611; - const SWord8 s1613 = (SWord8) (s1576 >> 24); - const SWord32 s1614 = table1[s1613]; - const SWord8 s1615 = (SWord8) (s1532 >> 16); - const SWord32 s1616 = table2[s1615]; - const SWord32 s1617 = s1614 ^ s1616; - const SWord8 s1618 = (SWord8) (s1546 >> 8); - const SWord32 s1619 = table3[s1618]; - const SWord32 s1620 = s1617 ^ s1619; - const SWord8 s1621 = (SWord8) s1561; - const SWord32 s1622 = table4[s1621]; - const SWord32 s1623 = s1620 ^ s1622; - const SWord32 s1624 = s29 ^ s1623; - const SWord8 s1625 = (SWord8) s1624; - const SWord32 s1626 = table4[s1625]; - const SWord32 s1627 = s1612 ^ s1626; - const SWord32 s1628 = s32 ^ s1627; - const SWord8 s1629 = (SWord8) (s1628 >> 24); - const SWord32 s1630 = table1[s1629]; - const SWord8 s1631 = (SWord8) (s1594 >> 24); - const SWord32 s1632 = table1[s1631]; - const SWord8 s1633 = (SWord8) (s1609 >> 16); - const SWord32 s1634 = table2[s1633]; - const SWord32 s1635 = s1632 ^ s1634; - const SWord8 s1636 = (SWord8) (s1624 >> 8); - const SWord32 s1637 = table3[s1636]; - const SWord32 s1638 = s1635 ^ s1637; - const SWord8 s1639 = (SWord8) s1580; - const SWord32 s1640 = table4[s1639]; - const SWord32 s1641 = s1638 ^ s1640; - const SWord32 s1642 = s35 ^ s1641; - const SWord8 s1643 = (SWord8) (s1642 >> 16); - const SWord32 s1644 = table2[s1643]; - const SWord32 s1645 = s1630 ^ s1644; - const SWord8 s1646 = (SWord8) (s1609 >> 24); - const SWord32 s1647 = table1[s1646]; - const SWord8 s1648 = (SWord8) (s1624 >> 16); - const SWord32 s1649 = table2[s1648]; - const SWord32 s1650 = s1647 ^ s1649; - const SWord8 s1651 = (SWord8) (s1580 >> 8); - const SWord32 s1652 = table3[s1651]; - const SWord32 s1653 = s1650 ^ s1652; - const SWord8 s1654 = (SWord8) s1594; - const SWord32 s1655 = table4[s1654]; - const SWord32 s1656 = s1653 ^ s1655; - const SWord32 s1657 = s34 ^ s1656; - const SWord8 s1658 = (SWord8) (s1657 >> 8); - const SWord32 s1659 = table3[s1658]; - const SWord32 s1660 = s1645 ^ s1659; - const SWord8 s1661 = (SWord8) (s1624 >> 24); - const SWord32 s1662 = table1[s1661]; - const SWord8 s1663 = (SWord8) (s1580 >> 16); - const SWord32 s1664 = table2[s1663]; - const SWord32 s1665 = s1662 ^ s1664; - const SWord8 s1666 = (SWord8) (s1594 >> 8); - const SWord32 s1667 = table3[s1666]; - const SWord32 s1668 = s1665 ^ s1667; - const SWord8 s1669 = (SWord8) s1609; - const SWord32 s1670 = table4[s1669]; - const SWord32 s1671 = s1668 ^ s1670; - const SWord32 s1672 = s33 ^ s1671; - const SWord8 s1673 = (SWord8) s1672; - const SWord32 s1674 = table4[s1673]; - const SWord32 s1675 = s1660 ^ s1674; - const SWord32 s1676 = s36 ^ s1675; - const SWord8 s1677 = (SWord8) (s1676 >> 24); - const SWord32 s1678 = table1[s1677]; - const SWord8 s1679 = (SWord8) (s1642 >> 24); - const SWord32 s1680 = table1[s1679]; - const SWord8 s1681 = (SWord8) (s1657 >> 16); - const SWord32 s1682 = table2[s1681]; - const SWord32 s1683 = s1680 ^ s1682; - const SWord8 s1684 = (SWord8) (s1672 >> 8); - const SWord32 s1685 = table3[s1684]; - const SWord32 s1686 = s1683 ^ s1685; - const SWord8 s1687 = (SWord8) s1628; - const SWord32 s1688 = table4[s1687]; - const SWord32 s1689 = s1686 ^ s1688; - const SWord32 s1690 = s39 ^ s1689; - const SWord8 s1691 = (SWord8) (s1690 >> 16); - const SWord32 s1692 = table2[s1691]; - const SWord32 s1693 = s1678 ^ s1692; - const SWord8 s1694 = (SWord8) (s1657 >> 24); - const SWord32 s1695 = table1[s1694]; - const SWord8 s1696 = (SWord8) (s1672 >> 16); - const SWord32 s1697 = table2[s1696]; - const SWord32 s1698 = s1695 ^ s1697; - const SWord8 s1699 = (SWord8) (s1628 >> 8); - const SWord32 s1700 = table3[s1699]; - const SWord32 s1701 = s1698 ^ s1700; - const SWord8 s1702 = (SWord8) s1642; - const SWord32 s1703 = table4[s1702]; - const SWord32 s1704 = s1701 ^ s1703; - const SWord32 s1705 = s38 ^ s1704; - const SWord8 s1706 = (SWord8) (s1705 >> 8); - const SWord32 s1707 = table3[s1706]; - const SWord32 s1708 = s1693 ^ s1707; - const SWord8 s1709 = (SWord8) (s1672 >> 24); - const SWord32 s1710 = table1[s1709]; - const SWord8 s1711 = (SWord8) (s1628 >> 16); - const SWord32 s1712 = table2[s1711]; - const SWord32 s1713 = s1710 ^ s1712; - const SWord8 s1714 = (SWord8) (s1642 >> 8); - const SWord32 s1715 = table3[s1714]; - const SWord32 s1716 = s1713 ^ s1715; - const SWord8 s1717 = (SWord8) s1657; - const SWord32 s1718 = table4[s1717]; - const SWord32 s1719 = s1716 ^ s1718; - const SWord32 s1720 = s37 ^ s1719; - const SWord8 s1721 = (SWord8) s1720; - const SWord32 s1722 = table4[s1721]; - const SWord32 s1723 = s1708 ^ s1722; - const SWord32 s1724 = s40 ^ s1723; - const SWord8 s1725 = (SWord8) (s1724 >> 24); - const SWord8 s1726 = table0[s1725]; - const SWord8 s1727 = (SWord8) (s1690 >> 24); - const SWord32 s1728 = table1[s1727]; - const SWord8 s1729 = (SWord8) (s1705 >> 16); - const SWord32 s1730 = table2[s1729]; - const SWord32 s1731 = s1728 ^ s1730; - const SWord8 s1732 = (SWord8) (s1720 >> 8); - const SWord32 s1733 = table3[s1732]; - const SWord32 s1734 = s1731 ^ s1733; - const SWord8 s1735 = (SWord8) s1676; - const SWord32 s1736 = table4[s1735]; - const SWord32 s1737 = s1734 ^ s1736; - const SWord32 s1738 = s43 ^ s1737; - const SWord8 s1739 = (SWord8) (s1738 >> 16); - const SWord8 s1740 = table0[s1739]; - const SWord16 s1741 = (((SWord16) s1726) << 8) | ((SWord16) s1740); - const SWord8 s1742 = (SWord8) (s1705 >> 24); - const SWord32 s1743 = table1[s1742]; - const SWord8 s1744 = (SWord8) (s1720 >> 16); - const SWord32 s1745 = table2[s1744]; - const SWord32 s1746 = s1743 ^ s1745; - const SWord8 s1747 = (SWord8) (s1676 >> 8); - const SWord32 s1748 = table3[s1747]; - const SWord32 s1749 = s1746 ^ s1748; - const SWord8 s1750 = (SWord8) s1690; - const SWord32 s1751 = table4[s1750]; - const SWord32 s1752 = s1749 ^ s1751; - const SWord32 s1753 = s42 ^ s1752; - const SWord8 s1754 = (SWord8) (s1753 >> 8); - const SWord8 s1755 = table0[s1754]; - const SWord8 s1756 = (SWord8) (s1720 >> 24); - const SWord32 s1757 = table1[s1756]; - const SWord8 s1758 = (SWord8) (s1676 >> 16); - const SWord32 s1759 = table2[s1758]; - const SWord32 s1760 = s1757 ^ s1759; - const SWord8 s1761 = (SWord8) (s1690 >> 8); - const SWord32 s1762 = table3[s1761]; - const SWord32 s1763 = s1760 ^ s1762; - const SWord8 s1764 = (SWord8) s1705; - const SWord32 s1765 = table4[s1764]; - const SWord32 s1766 = s1763 ^ s1765; - const SWord32 s1767 = s41 ^ s1766; - const SWord8 s1768 = (SWord8) s1767; - const SWord8 s1769 = table0[s1768]; - const SWord16 s1770 = (((SWord16) s1755) << 8) | ((SWord16) s1769); - const SWord32 s1771 = (((SWord32) s1741) << 16) | ((SWord32) s1770); - const SWord32 s1772 = s44 ^ s1771; - const SWord8 s1773 = (SWord8) (s1767 >> 24); - const SWord8 s1774 = table0[s1773]; - const SWord8 s1775 = (SWord8) (s1724 >> 16); - const SWord8 s1776 = table0[s1775]; - const SWord16 s1777 = (((SWord16) s1774) << 8) | ((SWord16) s1776); - const SWord8 s1778 = (SWord8) (s1738 >> 8); - const SWord8 s1779 = table0[s1778]; - const SWord8 s1780 = (SWord8) s1753; - const SWord8 s1781 = table0[s1780]; - const SWord16 s1782 = (((SWord16) s1779) << 8) | ((SWord16) s1781); - const SWord32 s1783 = (((SWord32) s1777) << 16) | ((SWord32) s1782); - const SWord32 s1784 = s45 ^ s1783; - const SWord8 s1785 = (SWord8) (s1753 >> 24); - const SWord8 s1786 = table0[s1785]; - const SWord8 s1787 = (SWord8) (s1767 >> 16); - const SWord8 s1788 = table0[s1787]; - const SWord16 s1789 = (((SWord16) s1786) << 8) | ((SWord16) s1788); - const SWord8 s1790 = (SWord8) (s1724 >> 8); - const SWord8 s1791 = table0[s1790]; - const SWord8 s1792 = (SWord8) s1738; - const SWord8 s1793 = table0[s1792]; - const SWord16 s1794 = (((SWord16) s1791) << 8) | ((SWord16) s1793); - const SWord32 s1795 = (((SWord32) s1789) << 16) | ((SWord32) s1794); - const SWord32 s1796 = s46 ^ s1795; - const SWord8 s1797 = (SWord8) (s1738 >> 24); - const SWord8 s1798 = table0[s1797]; - const SWord8 s1799 = (SWord8) (s1753 >> 16); - const SWord8 s1800 = table0[s1799]; - const SWord16 s1801 = (((SWord16) s1798) << 8) | ((SWord16) s1800); - const SWord8 s1802 = (SWord8) (s1767 >> 8); - const SWord8 s1803 = table0[s1802]; - const SWord8 s1804 = (SWord8) s1724; - const SWord8 s1805 = table0[s1804]; - const SWord16 s1806 = (((SWord16) s1803) << 8) | ((SWord16) s1805); - const SWord32 s1807 = (((SWord32) s1801) << 16) | ((SWord32) s1806); - const SWord32 s1808 = s47 ^ s1807; - - pt[0] = s1772; - pt[1] = s1784; - pt[2] = s1796; - pt[3] = s1808; -} -== END: "aes128BlockDecrypt.c" ================== -== BEGIN: "aes128InvKeySchedule.c" ================ -/* File: "aes128InvKeySchedule.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Lib.h" - -void aes128InvKeySchedule(const SWord32 *key, 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 - }; - const SWord32 s260 = s2 ^ s3; - const SWord32 s261 = (s260 << 8) | (s260 >> 24); - const SWord8 s262 = (SWord8) (s261 >> 24); - const SWord8 s263 = table0[s262]; - const SWord8 s264 = 54 ^ s263; - const SWord8 s265 = (SWord8) (s261 >> 16); - const SWord8 s266 = table0[s265]; - const SWord16 s267 = (((SWord16) s264) << 8) | ((SWord16) s266); - const SWord8 s268 = (SWord8) (s261 >> 8); - const SWord8 s269 = table0[s268]; - const SWord8 s270 = (SWord8) s261; - const SWord8 s271 = table0[s270]; - const SWord16 s272 = (((SWord16) s269) << 8) | ((SWord16) s271); - const SWord32 s273 = (((SWord32) s267) << 16) | ((SWord32) s272); - const SWord32 s274 = s0 ^ s273; - const SWord32 s275 = s0 ^ s1; - const SWord32 s276 = s1 ^ s2; - const SWord32 s277 = s260 ^ s276; - const SWord32 s278 = (s277 << 8) | (s277 >> 24); - const SWord8 s279 = (SWord8) (s278 >> 24); - const SWord8 s280 = table0[s279]; - const SWord8 s281 = 27 ^ s280; - const SWord8 s282 = (SWord8) (s278 >> 16); - const SWord8 s283 = table0[s282]; - const SWord16 s284 = (((SWord16) s281) << 8) | ((SWord16) s283); - const SWord8 s285 = (SWord8) (s278 >> 8); - const SWord8 s286 = table0[s285]; - const SWord8 s287 = (SWord8) s278; - const SWord8 s288 = table0[s287]; - const SWord16 s289 = (((SWord16) s286) << 8) | ((SWord16) s288); - const SWord32 s290 = (((SWord32) s284) << 16) | ((SWord32) s289); - const SWord32 s291 = s274 ^ s290; - const SWord32 s292 = s274 ^ s275; - const SWord32 s293 = s275 ^ s276; - const SWord32 s294 = s277 ^ s293; - const SWord32 s295 = (s294 << 8) | (s294 >> 24); - const SWord8 s296 = (SWord8) (s295 >> 24); - const SWord8 s297 = table0[s296]; - const SWord8 s298 = 128 ^ s297; - const SWord8 s299 = (SWord8) (s295 >> 16); - const SWord8 s300 = table0[s299]; - const SWord16 s301 = (((SWord16) s298) << 8) | ((SWord16) s300); - const SWord8 s302 = (SWord8) (s295 >> 8); - const SWord8 s303 = table0[s302]; - const SWord8 s304 = (SWord8) s295; - const SWord8 s305 = table0[s304]; - const SWord16 s306 = (((SWord16) s303) << 8) | ((SWord16) s305); - const SWord32 s307 = (((SWord32) s301) << 16) | ((SWord32) s306); - const SWord32 s308 = s291 ^ s307; - const SWord32 s309 = s291 ^ s292; - const SWord32 s310 = s292 ^ s293; - const SWord32 s311 = s294 ^ s310; - const SWord32 s312 = (s311 << 8) | (s311 >> 24); - const SWord8 s313 = (SWord8) (s312 >> 24); - const SWord8 s314 = table0[s313]; - const SWord8 s315 = 64 ^ s314; - const SWord8 s316 = (SWord8) (s312 >> 16); - const SWord8 s317 = table0[s316]; - const SWord16 s318 = (((SWord16) s315) << 8) | ((SWord16) s317); - const SWord8 s319 = (SWord8) (s312 >> 8); - const SWord8 s320 = table0[s319]; - const SWord8 s321 = (SWord8) s312; - const SWord8 s322 = table0[s321]; - const SWord16 s323 = (((SWord16) s320) << 8) | ((SWord16) s322); - const SWord32 s324 = (((SWord32) s318) << 16) | ((SWord32) s323); - const SWord32 s325 = s308 ^ s324; - const SWord32 s326 = s308 ^ s309; - const SWord32 s327 = s309 ^ s310; - const SWord32 s328 = s311 ^ s327; - const SWord32 s329 = (s328 << 8) | (s328 >> 24); - const SWord8 s330 = (SWord8) (s329 >> 24); - const SWord8 s331 = table0[s330]; - const SWord8 s332 = 32 ^ s331; - const SWord8 s333 = (SWord8) (s329 >> 16); - const SWord8 s334 = table0[s333]; - const SWord16 s335 = (((SWord16) s332) << 8) | ((SWord16) s334); - const SWord8 s336 = (SWord8) (s329 >> 8); - const SWord8 s337 = table0[s336]; - const SWord8 s338 = (SWord8) s329; - const SWord8 s339 = table0[s338]; - const SWord16 s340 = (((SWord16) s337) << 8) | ((SWord16) s339); - const SWord32 s341 = (((SWord32) s335) << 16) | ((SWord32) s340); - const SWord32 s342 = s325 ^ s341; - const SWord32 s343 = s325 ^ s326; - const SWord32 s344 = s326 ^ s327; - const SWord32 s345 = s328 ^ s344; - const SWord32 s346 = (s345 << 8) | (s345 >> 24); - const SWord8 s347 = (SWord8) (s346 >> 24); - const SWord8 s348 = table0[s347]; - const SWord8 s349 = 16 ^ s348; - const SWord8 s350 = (SWord8) (s346 >> 16); - const SWord8 s351 = table0[s350]; - const SWord16 s352 = (((SWord16) s349) << 8) | ((SWord16) s351); - const SWord8 s353 = (SWord8) (s346 >> 8); - const SWord8 s354 = table0[s353]; - const SWord8 s355 = (SWord8) s346; - const SWord8 s356 = table0[s355]; - const SWord16 s357 = (((SWord16) s354) << 8) | ((SWord16) s356); - const SWord32 s358 = (((SWord32) s352) << 16) | ((SWord32) s357); - const SWord32 s359 = s342 ^ s358; - const SWord32 s360 = s342 ^ s343; - const SWord32 s361 = s343 ^ s344; - const SWord32 s362 = s345 ^ s361; - const SWord32 s363 = (s362 << 8) | (s362 >> 24); - const SWord8 s364 = (SWord8) (s363 >> 24); - const SWord8 s365 = table0[s364]; - const SWord8 s366 = 8 ^ s365; - const SWord8 s367 = (SWord8) (s363 >> 16); - const SWord8 s368 = table0[s367]; - const SWord16 s369 = (((SWord16) s366) << 8) | ((SWord16) s368); - const SWord8 s370 = (SWord8) (s363 >> 8); - const SWord8 s371 = table0[s370]; - const SWord8 s372 = (SWord8) s363; - const SWord8 s373 = table0[s372]; - const SWord16 s374 = (((SWord16) s371) << 8) | ((SWord16) s373); - const SWord32 s375 = (((SWord32) s369) << 16) | ((SWord32) s374); - const SWord32 s376 = s359 ^ s375; - const SWord32 s377 = s359 ^ s360; - const SWord32 s378 = s360 ^ s361; - const SWord32 s379 = s362 ^ s378; - const SWord32 s380 = (s379 << 8) | (s379 >> 24); - const SWord8 s381 = (SWord8) (s380 >> 24); - const SWord8 s382 = table0[s381]; - const SWord8 s383 = 4 ^ s382; - const SWord8 s384 = (SWord8) (s380 >> 16); - const SWord8 s385 = table0[s384]; - const SWord16 s386 = (((SWord16) s383) << 8) | ((SWord16) s385); - const SWord8 s387 = (SWord8) (s380 >> 8); - const SWord8 s388 = table0[s387]; - const SWord8 s389 = (SWord8) s380; - const SWord8 s390 = table0[s389]; - const SWord16 s391 = (((SWord16) s388) << 8) | ((SWord16) s390); - const SWord32 s392 = (((SWord32) s386) << 16) | ((SWord32) s391); - const SWord32 s393 = s376 ^ s392; - const SWord32 s394 = s376 ^ s377; - const SWord32 s395 = s377 ^ s378; - const SWord32 s396 = s379 ^ s395; - const SWord32 s397 = (s396 << 8) | (s396 >> 24); - const SWord8 s398 = (SWord8) (s397 >> 24); - const SWord8 s399 = table0[s398]; - const SWord8 s400 = 2 ^ s399; - const SWord8 s401 = (SWord8) (s397 >> 16); - const SWord8 s402 = table0[s401]; - const SWord16 s403 = (((SWord16) s400) << 8) | ((SWord16) s402); - const SWord8 s404 = (SWord8) (s397 >> 8); - const SWord8 s405 = table0[s404]; - const SWord8 s406 = (SWord8) s397; - const SWord8 s407 = table0[s406]; - const SWord16 s408 = (((SWord16) s405) << 8) | ((SWord16) s407); - const SWord32 s409 = (((SWord32) s403) << 16) | ((SWord32) s408); - const SWord32 s410 = s393 ^ s409; - const SWord32 s411 = s393 ^ s394; - const SWord32 s412 = s394 ^ s395; - const SWord32 s413 = s396 ^ s412; - const SWord32 s414 = (s413 << 8) | (s413 >> 24); - const SWord8 s415 = (SWord8) (s414 >> 24); - const SWord8 s416 = table0[s415]; - const SWord8 s417 = 1 ^ s416; - const SWord8 s418 = (SWord8) (s414 >> 16); - const SWord8 s419 = table0[s418]; - const SWord16 s420 = (((SWord16) s417) << 8) | ((SWord16) s419); - const SWord8 s421 = (SWord8) (s414 >> 8); - const SWord8 s422 = table0[s421]; - const SWord8 s423 = (SWord8) s414; - const SWord8 s424 = table0[s423]; - const SWord16 s425 = (((SWord16) s422) << 8) | ((SWord16) s424); - const SWord32 s426 = (((SWord32) s420) << 16) | ((SWord32) s425); - const SWord32 s427 = s410 ^ s426; - const SWord32 s428 = s410 ^ s411; - const SWord32 s429 = s411 ^ s412; - - decKS[0] = s0; - decKS[1] = s1; - decKS[2] = s2; - decKS[3] = s3; - decKS[4] = s274; - decKS[5] = s275; - decKS[6] = s276; - decKS[7] = s260; - decKS[8] = s291; - decKS[9] = s292; - decKS[10] = s293; - decKS[11] = s277; - decKS[12] = s308; - decKS[13] = s309; - decKS[14] = s310; - decKS[15] = s294; - decKS[16] = s325; - decKS[17] = s326; - decKS[18] = s327; - decKS[19] = s311; - decKS[20] = s342; - decKS[21] = s343; - decKS[22] = s344; - decKS[23] = s328; - decKS[24] = s359; - decKS[25] = s360; - decKS[26] = s361; - decKS[27] = s345; - decKS[28] = s376; - decKS[29] = s377; - decKS[30] = s378; - decKS[31] = s362; - decKS[32] = s393; - decKS[33] = s394; - decKS[34] = s395; - decKS[35] = s379; - decKS[36] = s410; - decKS[37] = s411; - decKS[38] = s412; - decKS[39] = s396; - decKS[40] = s427; - decKS[41] = s428; - decKS[42] = s429; - decKS[43] = s413; -} -== END: "aes128InvKeySchedule.c" ================== -== BEGIN: "aes128OTFDecrypt.c" ================ -/* File: "aes128OTFDecrypt.c". Automatically generated by SBV. Do not edit! */ - -#include "aes128Lib.h" - -void aes128OTFDecrypt(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[] = { - 0x00000000UL, 0x0e090d0bUL, 0x1c121a16UL, 0x121b171dUL, - 0x3824342cUL, 0x362d3927UL, 0x24362e3aUL, 0x2a3f2331UL, - 0x70486858UL, 0x7e416553UL, 0x6c5a724eUL, 0x62537f45UL, - 0x486c5c74UL, 0x4665517fUL, 0x547e4662UL, 0x5a774b69UL, - 0xe090d0b0UL, 0xee99ddbbUL, 0xfc82caa6UL, 0xf28bc7adUL, - 0xd8b4e49cUL, 0xd6bde997UL, 0xc4a6fe8aUL, 0xcaaff381UL, - 0x90d8b8e8UL, 0x9ed1b5e3UL, 0x8ccaa2feUL, 0x82c3aff5UL, - 0xa8fc8cc4UL, 0xa6f581cfUL, 0xb4ee96d2UL, 0xbae79bd9UL, - 0xdb3bbb7bUL, 0xd532b670UL, 0xc729a16dUL, 0xc920ac66UL, - 0xe31f8f57UL, 0xed16825cUL, 0xff0d9541UL, 0xf104984aUL, - 0xab73d323UL, 0xa57ade28UL, 0xb761c935UL, 0xb968c43eUL, - 0x9357e70fUL, 0x9d5eea04UL, 0x8f45fd19UL, 0x814cf012UL, - 0x3bab6bcbUL, 0x35a266c0UL, 0x27b971ddUL, 0x29b07cd6UL, - 0x038f5fe7UL, 0x0d8652ecUL, 0x1f9d45f1UL, 0x119448faUL, - 0x4be30393UL, 0x45ea0e98UL, 0x57f11985UL, 0x59f8148eUL, - 0x73c737bfUL, 0x7dce3ab4UL, 0x6fd52da9UL, 0x61dc20a2UL, - 0xad766df6UL, 0xa37f60fdUL, 0xb16477e0UL, 0xbf6d7aebUL, - 0x955259daUL, 0x9b5b54d1UL, 0x894043ccUL, 0x87494ec7UL, - 0xdd3e05aeUL, 0xd33708a5UL, 0xc12c1fb8UL, 0xcf2512b3UL, - 0xe51a3182UL, 0xeb133c89UL, 0xf9082b94UL, 0xf701269fUL, - 0x4de6bd46UL, 0x43efb04dUL, 0x51f4a750UL, 0x5ffdaa5bUL, - 0x75c2896aUL, 0x7bcb8461UL, 0x69d0937cUL, 0x67d99e77UL, - 0x3daed51eUL, 0x33a7d815UL, 0x21bccf08UL, 0x2fb5c203UL, - 0x058ae132UL, 0x0b83ec39UL, 0x1998fb24UL, 0x1791f62fUL, - 0x764dd68dUL, 0x7844db86UL, 0x6a5fcc9bUL, 0x6456c190UL, - 0x4e69e2a1UL, 0x4060efaaUL, 0x527bf8b7UL, 0x5c72f5bcUL, - 0x0605bed5UL, 0x080cb3deUL, 0x1a17a4c3UL, 0x141ea9c8UL, - 0x3e218af9UL, 0x302887f2UL, 0x223390efUL, 0x2c3a9de4UL, - 0x96dd063dUL, 0x98d40b36UL, 0x8acf1c2bUL, 0x84c61120UL, - 0xaef93211UL, 0xa0f03f1aUL, 0xb2eb2807UL, 0xbce2250cUL, - 0xe6956e65UL, 0xe89c636eUL, 0xfa877473UL, 0xf48e7978UL, - 0xdeb15a49UL, 0xd0b85742UL, 0xc2a3405fUL, 0xccaa4d54UL, - 0x41ecdaf7UL, 0x4fe5d7fcUL, 0x5dfec0e1UL, 0x53f7cdeaUL, - 0x79c8eedbUL, 0x77c1e3d0UL, 0x65daf4cdUL, 0x6bd3f9c6UL, - 0x31a4b2afUL, 0x3fadbfa4UL, 0x2db6a8b9UL, 0x23bfa5b2UL, - 0x09808683UL, 0x07898b88UL, 0x15929c95UL, 0x1b9b919eUL, - 0xa17c0a47UL, 0xaf75074cUL, 0xbd6e1051UL, 0xb3671d5aUL, - 0x99583e6bUL, 0x97513360UL, 0x854a247dUL, 0x8b432976UL, - 0xd134621fUL, 0xdf3d6f14UL, 0xcd267809UL, 0xc32f7502UL, - 0xe9105633UL, 0xe7195b38UL, 0xf5024c25UL, 0xfb0b412eUL, - 0x9ad7618cUL, 0x94de6c87UL, 0x86c57b9aUL, 0x88cc7691UL, - 0xa2f355a0UL, 0xacfa58abUL, 0xbee14fb6UL, 0xb0e842bdUL, - 0xea9f09d4UL, 0xe49604dfUL, 0xf68d13c2UL, 0xf8841ec9UL, - 0xd2bb3df8UL, 0xdcb230f3UL, 0xcea927eeUL, 0xc0a02ae5UL, - 0x7a47b13cUL, 0x744ebc37UL, 0x6655ab2aUL, 0x685ca621UL, - 0x42638510UL, 0x4c6a881bUL, 0x5e719f06UL, 0x5078920dUL, - 0x0a0fd964UL, 0x0406d46fUL, 0x161dc372UL, 0x1814ce79UL, - 0x322bed48UL, 0x3c22e043UL, 0x2e39f75eUL, 0x2030fa55UL, - 0xec9ab701UL, 0xe293ba0aUL, 0xf088ad17UL, 0xfe81a01cUL, - 0xd4be832dUL, 0xdab78e26UL, 0xc8ac993bUL, 0xc6a59430UL, - 0x9cd2df59UL, 0x92dbd252UL, 0x80c0c54fUL, 0x8ec9c844UL, - 0xa4f6eb75UL, 0xaaffe67eUL, 0xb8e4f163UL, 0xb6edfc68UL, - 0x0c0a67b1UL, 0x02036abaUL, 0x10187da7UL, 0x1e1170acUL, - 0x342e539dUL, 0x3a275e96UL, 0x283c498bUL, 0x26354480UL, - 0x7c420fe9UL, 0x724b02e2UL, 0x605015ffUL, 0x6e5918f4UL, - 0x44663bc5UL, 0x4a6f36ceUL, 0x587421d3UL, 0x567d2cd8UL, - 0x37a10c7aUL, 0x39a80171UL, 0x2bb3166cUL, 0x25ba1b67UL, - 0x0f853856UL, 0x018c355dUL, 0x13972240UL, 0x1d9e2f4bUL, - 0x47e96422UL, 0x49e06929UL, 0x5bfb7e34UL, 0x55f2733fUL, - 0x7fcd500eUL, 0x71c45d05UL, 0x63df4a18UL, 0x6dd64713UL, - 0xd731dccaUL, 0xd938d1c1UL, 0xcb23c6dcUL, 0xc52acbd7UL, - 0xef15e8e6UL, 0xe11ce5edUL, 0xf307f2f0UL, 0xfd0efffbUL, - 0xa779b492UL, 0xa970b999UL, 0xbb6bae84UL, 0xb562a38fUL, - 0x9f5d80beUL, 0x91548db5UL, 0x834f9aa8UL, 0x8d4697a3UL - }; - static const SWord32 table2[] = { - 0x00000000UL, 0x0b0e090dUL, 0x161c121aUL, 0x1d121b17UL, - 0x2c382434UL, 0x27362d39UL, 0x3a24362eUL, 0x312a3f23UL, - 0x58704868UL, 0x537e4165UL, 0x4e6c5a72UL, 0x4562537fUL, - 0x74486c5cUL, 0x7f466551UL, 0x62547e46UL, 0x695a774bUL, - 0xb0e090d0UL, 0xbbee99ddUL, 0xa6fc82caUL, 0xadf28bc7UL, - 0x9cd8b4e4UL, 0x97d6bde9UL, 0x8ac4a6feUL, 0x81caaff3UL, - 0xe890d8b8UL, 0xe39ed1b5UL, 0xfe8ccaa2UL, 0xf582c3afUL, - 0xc4a8fc8cUL, 0xcfa6f581UL, 0xd2b4ee96UL, 0xd9bae79bUL, - 0x7bdb3bbbUL, 0x70d532b6UL, 0x6dc729a1UL, 0x66c920acUL, - 0x57e31f8fUL, 0x5ced1682UL, 0x41ff0d95UL, 0x4af10498UL, - 0x23ab73d3UL, 0x28a57adeUL, 0x35b761c9UL, 0x3eb968c4UL, - 0x0f9357e7UL, 0x049d5eeaUL, 0x198f45fdUL, 0x12814cf0UL, - 0xcb3bab6bUL, 0xc035a266UL, 0xdd27b971UL, 0xd629b07cUL, - 0xe7038f5fUL, 0xec0d8652UL, 0xf11f9d45UL, 0xfa119448UL, - 0x934be303UL, 0x9845ea0eUL, 0x8557f119UL, 0x8e59f814UL, - 0xbf73c737UL, 0xb47dce3aUL, 0xa96fd52dUL, 0xa261dc20UL, - 0xf6ad766dUL, 0xfda37f60UL, 0xe0b16477UL, 0xebbf6d7aUL, - 0xda955259UL, 0xd19b5b54UL, 0xcc894043UL, 0xc787494eUL, - 0xaedd3e05UL, 0xa5d33708UL, 0xb8c12c1fUL, 0xb3cf2512UL, - 0x82e51a31UL, 0x89eb133cUL, 0x94f9082bUL, 0x9ff70126UL, - 0x464de6bdUL, 0x4d43efb0UL, 0x5051f4a7UL, 0x5b5ffdaaUL, - 0x6a75c289UL, 0x617bcb84UL, 0x7c69d093UL, 0x7767d99eUL, - 0x1e3daed5UL, 0x1533a7d8UL, 0x0821bccfUL, 0x032fb5c2UL, - 0x32058ae1UL, 0x390b83ecUL, 0x241998fbUL, 0x2f1791f6UL, - 0x8d764dd6UL, 0x867844dbUL, 0x9b6a5fccUL, 0x906456c1UL, - 0xa14e69e2UL, 0xaa4060efUL, 0xb7527bf8UL, 0xbc5c72f5UL, - 0xd50605beUL, 0xde080cb3UL, 0xc31a17a4UL, 0xc8141ea9UL, - 0xf93e218aUL, 0xf2302887UL, 0xef223390UL, 0xe42c3a9dUL, - 0x3d96dd06UL, 0x3698d40bUL, 0x2b8acf1cUL, 0x2084c611UL, - 0x11aef932UL, 0x1aa0f03fUL, 0x07b2eb28UL, 0x0cbce225UL, - 0x65e6956eUL, 0x6ee89c63UL, 0x73fa8774UL, 0x78f48e79UL, - 0x49deb15aUL, 0x42d0b857UL, 0x5fc2a340UL, 0x54ccaa4dUL, - 0xf741ecdaUL, 0xfc4fe5d7UL, 0xe15dfec0UL, 0xea53f7cdUL, - 0xdb79c8eeUL, 0xd077c1e3UL, 0xcd65daf4UL, 0xc66bd3f9UL, - 0xaf31a4b2UL, 0xa43fadbfUL, 0xb92db6a8UL, 0xb223bfa5UL, - 0x83098086UL, 0x8807898bUL, 0x9515929cUL, 0x9e1b9b91UL, - 0x47a17c0aUL, 0x4caf7507UL, 0x51bd6e10UL, 0x5ab3671dUL, - 0x6b99583eUL, 0x60975133UL, 0x7d854a24UL, 0x768b4329UL, - 0x1fd13462UL, 0x14df3d6fUL, 0x09cd2678UL, 0x02c32f75UL, - 0x33e91056UL, 0x38e7195bUL, 0x25f5024cUL, 0x2efb0b41UL, - 0x8c9ad761UL, 0x8794de6cUL, 0x9a86c57bUL, 0x9188cc76UL, - 0xa0a2f355UL, 0xabacfa58UL, 0xb6bee14fUL, 0xbdb0e842UL, - 0xd4ea9f09UL, 0xdfe49604UL, 0xc2f68d13UL, 0xc9f8841eUL, - 0xf8d2bb3dUL, 0xf3dcb230UL, 0xeecea927UL, 0xe5c0a02aUL, - 0x3c7a47b1UL, 0x37744ebcUL, 0x2a6655abUL, 0x21685ca6UL, - 0x10426385UL, 0x1b4c6a88UL, 0x065e719fUL, 0x0d507892UL, - 0x640a0fd9UL, 0x6f0406d4UL, 0x72161dc3UL, 0x791814ceUL, - 0x48322bedUL, 0x433c22e0UL, 0x5e2e39f7UL, 0x552030faUL, - 0x01ec9ab7UL, 0x0ae293baUL, 0x17f088adUL, 0x1cfe81a0UL, - 0x2dd4be83UL, 0x26dab78eUL, 0x3bc8ac99UL, 0x30c6a594UL, - 0x599cd2dfUL, 0x5292dbd2UL, 0x4f80c0c5UL, 0x448ec9c8UL, - 0x75a4f6ebUL, 0x7eaaffe6UL, 0x63b8e4f1UL, 0x68b6edfcUL, - 0xb10c0a67UL, 0xba02036aUL, 0xa710187dUL, 0xac1e1170UL, - 0x9d342e53UL, 0x963a275eUL, 0x8b283c49UL, 0x80263544UL, - 0xe97c420fUL, 0xe2724b02UL, 0xff605015UL, 0xf46e5918UL, - 0xc544663bUL, 0xce4a6f36UL, 0xd3587421UL, 0xd8567d2cUL, - 0x7a37a10cUL, 0x7139a801UL, 0x6c2bb316UL, 0x6725ba1bUL, - 0x560f8538UL, 0x5d018c35UL, 0x40139722UL, 0x4b1d9e2fUL, - 0x2247e964UL, 0x2949e069UL, 0x345bfb7eUL, 0x3f55f273UL, - 0x0e7fcd50UL, 0x0571c45dUL, 0x1863df4aUL, 0x136dd647UL, - 0xcad731dcUL, 0xc1d938d1UL, 0xdccb23c6UL, 0xd7c52acbUL, - 0xe6ef15e8UL, 0xede11ce5UL, 0xf0f307f2UL, 0xfbfd0effUL, - 0x92a779b4UL, 0x99a970b9UL, 0x84bb6baeUL, 0x8fb562a3UL, - 0xbe9f5d80UL, 0xb591548dUL, 0xa8834f9aUL, 0xa38d4697UL - }; - static const SWord32 table3[] = { - 0x00000000UL, 0x0d0b0e09UL, 0x1a161c12UL, 0x171d121bUL, - 0x342c3824UL, 0x3927362dUL, 0x2e3a2436UL, 0x23312a3fUL, - 0x68587048UL, 0x65537e41UL, 0x724e6c5aUL, 0x7f456253UL, - 0x5c74486cUL, 0x517f4665UL, 0x4662547eUL, 0x4b695a77UL, - 0xd0b0e090UL, 0xddbbee99UL, 0xcaa6fc82UL, 0xc7adf28bUL, - 0xe49cd8b4UL, 0xe997d6bdUL, 0xfe8ac4a6UL, 0xf381caafUL, - 0xb8e890d8UL, 0xb5e39ed1UL, 0xa2fe8ccaUL, 0xaff582c3UL, - 0x8cc4a8fcUL, 0x81cfa6f5UL, 0x96d2b4eeUL, 0x9bd9bae7UL, - 0xbb7bdb3bUL, 0xb670d532UL, 0xa16dc729UL, 0xac66c920UL, - 0x8f57e31fUL, 0x825ced16UL, 0x9541ff0dUL, 0x984af104UL, - 0xd323ab73UL, 0xde28a57aUL, 0xc935b761UL, 0xc43eb968UL, - 0xe70f9357UL, 0xea049d5eUL, 0xfd198f45UL, 0xf012814cUL, - 0x6bcb3babUL, 0x66c035a2UL, 0x71dd27b9UL, 0x7cd629b0UL, - 0x5fe7038fUL, 0x52ec0d86UL, 0x45f11f9dUL, 0x48fa1194UL, - 0x03934be3UL, 0x0e9845eaUL, 0x198557f1UL, 0x148e59f8UL, - 0x37bf73c7UL, 0x3ab47dceUL, 0x2da96fd5UL, 0x20a261dcUL, - 0x6df6ad76UL, 0x60fda37fUL, 0x77e0b164UL, 0x7aebbf6dUL, - 0x59da9552UL, 0x54d19b5bUL, 0x43cc8940UL, 0x4ec78749UL, - 0x05aedd3eUL, 0x08a5d337UL, 0x1fb8c12cUL, 0x12b3cf25UL, - 0x3182e51aUL, 0x3c89eb13UL, 0x2b94f908UL, 0x269ff701UL, - 0xbd464de6UL, 0xb04d43efUL, 0xa75051f4UL, 0xaa5b5ffdUL, - 0x896a75c2UL, 0x84617bcbUL, 0x937c69d0UL, 0x9e7767d9UL, - 0xd51e3daeUL, 0xd81533a7UL, 0xcf0821bcUL, 0xc2032fb5UL, - 0xe132058aUL, 0xec390b83UL, 0xfb241998UL, 0xf62f1791UL, - 0xd68d764dUL, 0xdb867844UL, 0xcc9b6a5fUL, 0xc1906456UL, - 0xe2a14e69UL, 0xefaa4060UL, 0xf8b7527bUL, 0xf5bc5c72UL, - 0xbed50605UL, 0xb3de080cUL, 0xa4c31a17UL, 0xa9c8141eUL, - 0x8af93e21UL, 0x87f23028UL, 0x90ef2233UL, 0x9de42c3aUL, - 0x063d96ddUL, 0x0b3698d4UL, 0x1c2b8acfUL, 0x112084c6UL, - 0x3211aef9UL, 0x3f1aa0f0UL, 0x2807b2ebUL, 0x250cbce2UL, - 0x6e65e695UL, 0x636ee89cUL, 0x7473fa87UL, 0x7978f48eUL, - 0x5a49deb1UL, 0x5742d0b8UL, 0x405fc2a3UL, 0x4d54ccaaUL, - 0xdaf741ecUL, 0xd7fc4fe5UL, 0xc0e15dfeUL, 0xcdea53f7UL, - 0xeedb79c8UL, 0xe3d077c1UL, 0xf4cd65daUL, 0xf9c66bd3UL, - 0xb2af31a4UL, 0xbfa43fadUL, 0xa8b92db6UL, 0xa5b223bfUL, - 0x86830980UL, 0x8b880789UL, 0x9c951592UL, 0x919e1b9bUL, - 0x0a47a17cUL, 0x074caf75UL, 0x1051bd6eUL, 0x1d5ab367UL, - 0x3e6b9958UL, 0x33609751UL, 0x247d854aUL, 0x29768b43UL, - 0x621fd134UL, 0x6f14df3dUL, 0x7809cd26UL, 0x7502c32fUL, - 0x5633e910UL, 0x5b38e719UL, 0x4c25f502UL, 0x412efb0bUL, - 0x618c9ad7UL, 0x6c8794deUL, 0x7b9a86c5UL, 0x769188ccUL, - 0x55a0a2f3UL, 0x58abacfaUL, 0x4fb6bee1UL, 0x42bdb0e8UL, - 0x09d4ea9fUL, 0x04dfe496UL, 0x13c2f68dUL, 0x1ec9f884UL, - 0x3df8d2bbUL, 0x30f3dcb2UL, 0x27eecea9UL, 0x2ae5c0a0UL, - 0xb13c7a47UL, 0xbc37744eUL, 0xab2a6655UL, 0xa621685cUL, - 0x85104263UL, 0x881b4c6aUL, 0x9f065e71UL, 0x920d5078UL, - 0xd9640a0fUL, 0xd46f0406UL, 0xc372161dUL, 0xce791814UL, - 0xed48322bUL, 0xe0433c22UL, 0xf75e2e39UL, 0xfa552030UL, - 0xb701ec9aUL, 0xba0ae293UL, 0xad17f088UL, 0xa01cfe81UL, - 0x832dd4beUL, 0x8e26dab7UL, 0x993bc8acUL, 0x9430c6a5UL, - 0xdf599cd2UL, 0xd25292dbUL, 0xc54f80c0UL, 0xc8448ec9UL, - 0xeb75a4f6UL, 0xe67eaaffUL, 0xf163b8e4UL, 0xfc68b6edUL, - 0x67b10c0aUL, 0x6aba0203UL, 0x7da71018UL, 0x70ac1e11UL, - 0x539d342eUL, 0x5e963a27UL, 0x498b283cUL, 0x44802635UL, - 0x0fe97c42UL, 0x02e2724bUL, 0x15ff6050UL, 0x18f46e59UL, - 0x3bc54466UL, 0x36ce4a6fUL, 0x21d35874UL, 0x2cd8567dUL, - 0x0c7a37a1UL, 0x017139a8UL, 0x166c2bb3UL, 0x1b6725baUL, - 0x38560f85UL, 0x355d018cUL, 0x22401397UL, 0x2f4b1d9eUL, - 0x642247e9UL, 0x692949e0UL, 0x7e345bfbUL, 0x733f55f2UL, - 0x500e7fcdUL, 0x5d0571c4UL, 0x4a1863dfUL, 0x47136dd6UL, - 0xdccad731UL, 0xd1c1d938UL, 0xc6dccb23UL, 0xcbd7c52aUL, - 0xe8e6ef15UL, 0xe5ede11cUL, 0xf2f0f307UL, 0xfffbfd0eUL, - 0xb492a779UL, 0xb999a970UL, 0xae84bb6bUL, 0xa38fb562UL, - 0x80be9f5dUL, 0x8db59154UL, 0x9aa8834fUL, 0x97a38d46UL - }; - static const SWord32 table4[] = { - 0x00000000UL, 0x090d0b0eUL, 0x121a161cUL, 0x1b171d12UL, - 0x24342c38UL, 0x2d392736UL, 0x362e3a24UL, 0x3f23312aUL, - 0x48685870UL, 0x4165537eUL, 0x5a724e6cUL, 0x537f4562UL, - 0x6c5c7448UL, 0x65517f46UL, 0x7e466254UL, 0x774b695aUL, - 0x90d0b0e0UL, 0x99ddbbeeUL, 0x82caa6fcUL, 0x8bc7adf2UL, - 0xb4e49cd8UL, 0xbde997d6UL, 0xa6fe8ac4UL, 0xaff381caUL, - 0xd8b8e890UL, 0xd1b5e39eUL, 0xcaa2fe8cUL, 0xc3aff582UL, - 0xfc8cc4a8UL, 0xf581cfa6UL, 0xee96d2b4UL, 0xe79bd9baUL, - 0x3bbb7bdbUL, 0x32b670d5UL, 0x29a16dc7UL, 0x20ac66c9UL, - 0x1f8f57e3UL, 0x16825cedUL, 0x0d9541ffUL, 0x04984af1UL, - 0x73d323abUL, 0x7ade28a5UL, 0x61c935b7UL, 0x68c43eb9UL, - 0x57e70f93UL, 0x5eea049dUL, 0x45fd198fUL, 0x4cf01281UL, - 0xab6bcb3bUL, 0xa266c035UL, 0xb971dd27UL, 0xb07cd629UL, - 0x8f5fe703UL, 0x8652ec0dUL, 0x9d45f11fUL, 0x9448fa11UL, - 0xe303934bUL, 0xea0e9845UL, 0xf1198557UL, 0xf8148e59UL, - 0xc737bf73UL, 0xce3ab47dUL, 0xd52da96fUL, 0xdc20a261UL, - 0x766df6adUL, 0x7f60fda3UL, 0x6477e0b1UL, 0x6d7aebbfUL, - 0x5259da95UL, 0x5b54d19bUL, 0x4043cc89UL, 0x494ec787UL, - 0x3e05aeddUL, 0x3708a5d3UL, 0x2c1fb8c1UL, 0x2512b3cfUL, - 0x1a3182e5UL, 0x133c89ebUL, 0x082b94f9UL, 0x01269ff7UL, - 0xe6bd464dUL, 0xefb04d43UL, 0xf4a75051UL, 0xfdaa5b5fUL, - 0xc2896a75UL, 0xcb84617bUL, 0xd0937c69UL, 0xd99e7767UL, - 0xaed51e3dUL, 0xa7d81533UL, 0xbccf0821UL, 0xb5c2032fUL, - 0x8ae13205UL, 0x83ec390bUL, 0x98fb2419UL, 0x91f62f17UL, - 0x4dd68d76UL, 0x44db8678UL, 0x5fcc9b6aUL, 0x56c19064UL, - 0x69e2a14eUL, 0x60efaa40UL, 0x7bf8b752UL, 0x72f5bc5cUL, - 0x05bed506UL, 0x0cb3de08UL, 0x17a4c31aUL, 0x1ea9c814UL, - 0x218af93eUL, 0x2887f230UL, 0x3390ef22UL, 0x3a9de42cUL, - 0xdd063d96UL, 0xd40b3698UL, 0xcf1c2b8aUL, 0xc6112084UL, - 0xf93211aeUL, 0xf03f1aa0UL, 0xeb2807b2UL, 0xe2250cbcUL, - 0x956e65e6UL, 0x9c636ee8UL, 0x877473faUL, 0x8e7978f4UL, - 0xb15a49deUL, 0xb85742d0UL, 0xa3405fc2UL, 0xaa4d54ccUL, - 0xecdaf741UL, 0xe5d7fc4fUL, 0xfec0e15dUL, 0xf7cdea53UL, - 0xc8eedb79UL, 0xc1e3d077UL, 0xdaf4cd65UL, 0xd3f9c66bUL, - 0xa4b2af31UL, 0xadbfa43fUL, 0xb6a8b92dUL, 0xbfa5b223UL, - 0x80868309UL, 0x898b8807UL, 0x929c9515UL, 0x9b919e1bUL, - 0x7c0a47a1UL, 0x75074cafUL, 0x6e1051bdUL, 0x671d5ab3UL, - 0x583e6b99UL, 0x51336097UL, 0x4a247d85UL, 0x4329768bUL, - 0x34621fd1UL, 0x3d6f14dfUL, 0x267809cdUL, 0x2f7502c3UL, - 0x105633e9UL, 0x195b38e7UL, 0x024c25f5UL, 0x0b412efbUL, - 0xd7618c9aUL, 0xde6c8794UL, 0xc57b9a86UL, 0xcc769188UL, - 0xf355a0a2UL, 0xfa58abacUL, 0xe14fb6beUL, 0xe842bdb0UL, - 0x9f09d4eaUL, 0x9604dfe4UL, 0x8d13c2f6UL, 0x841ec9f8UL, - 0xbb3df8d2UL, 0xb230f3dcUL, 0xa927eeceUL, 0xa02ae5c0UL, - 0x47b13c7aUL, 0x4ebc3774UL, 0x55ab2a66UL, 0x5ca62168UL, - 0x63851042UL, 0x6a881b4cUL, 0x719f065eUL, 0x78920d50UL, - 0x0fd9640aUL, 0x06d46f04UL, 0x1dc37216UL, 0x14ce7918UL, - 0x2bed4832UL, 0x22e0433cUL, 0x39f75e2eUL, 0x30fa5520UL, - 0x9ab701ecUL, 0x93ba0ae2UL, 0x88ad17f0UL, 0x81a01cfeUL, - 0xbe832dd4UL, 0xb78e26daUL, 0xac993bc8UL, 0xa59430c6UL, - 0xd2df599cUL, 0xdbd25292UL, 0xc0c54f80UL, 0xc9c8448eUL, - 0xf6eb75a4UL, 0xffe67eaaUL, 0xe4f163b8UL, 0xedfc68b6UL, - 0x0a67b10cUL, 0x036aba02UL, 0x187da710UL, 0x1170ac1eUL, - 0x2e539d34UL, 0x275e963aUL, 0x3c498b28UL, 0x35448026UL, - 0x420fe97cUL, 0x4b02e272UL, 0x5015ff60UL, 0x5918f46eUL, - 0x663bc544UL, 0x6f36ce4aUL, 0x7421d358UL, 0x7d2cd856UL, - 0xa10c7a37UL, 0xa8017139UL, 0xb3166c2bUL, 0xba1b6725UL, - 0x8538560fUL, 0x8c355d01UL, 0x97224013UL, 0x9e2f4b1dUL, - 0xe9642247UL, 0xe0692949UL, 0xfb7e345bUL, 0xf2733f55UL, - 0xcd500e7fUL, 0xc45d0571UL, 0xdf4a1863UL, 0xd647136dUL, - 0x31dccad7UL, 0x38d1c1d9UL, 0x23c6dccbUL, 0x2acbd7c5UL, - 0x15e8e6efUL, 0x1ce5ede1UL, 0x07f2f0f3UL, 0x0efffbfdUL, - 0x79b492a7UL, 0x70b999a9UL, 0x6bae84bbUL, 0x62a38fb5UL, - 0x5d80be9fUL, 0x548db591UL, 0x4f9aa883UL, 0x4697a38dUL - }; - const SWord32 s560 = s0 ^ s4; - const SWord8 s561 = (SWord8) (s560 >> 24); - const SWord8 s562 = table0[s561]; - const SWord8 s563 = (SWord8) (s8 >> 24); - const SWord8 s564 = s562 ^ s563; - const SWord32 s565 = table1[s564]; - const SWord32 s821 = s3 ^ s7; - const SWord8 s822 = (SWord8) (s821 >> 16); - const SWord8 s823 = table0[s822]; - const SWord8 s824 = (SWord8) (s8 >> 16); - const SWord8 s825 = s823 ^ s824; - const SWord32 s826 = table2[s825]; - const SWord32 s827 = s565 ^ s826; - const SWord32 s1083 = s2 ^ s6; - const SWord8 s1084 = (SWord8) (s1083 >> 8); - const SWord8 s1085 = table0[s1084]; - const SWord8 s1086 = (SWord8) (s8 >> 8); - const SWord8 s1087 = s1085 ^ s1086; - const SWord32 s1088 = table3[s1087]; - const SWord32 s1089 = s827 ^ s1088; - const SWord32 s1345 = s1 ^ s5; - const SWord8 s1346 = (SWord8) s1345; - const SWord8 s1347 = table0[s1346]; - const SWord8 s1348 = (SWord8) s8; - const SWord8 s1349 = s1347 ^ s1348; - const SWord32 s1350 = table4[s1349]; - const SWord32 s1351 = s1089 ^ s1350; - const SWord8 s1352 = (SWord8) (s1351 >> 24); - const SWord8 s1353 = table0[s1352]; - const SWord8 s1354 = (SWord8) (s12 >> 24); - const SWord8 s1355 = s1353 ^ s1354; - const SWord32 s1356 = table1[s1355]; - const SWord8 s1357 = (SWord8) (s821 >> 24); - const SWord8 s1358 = table0[s1357]; - const SWord8 s1359 = (SWord8) (s11 >> 24); - const SWord8 s1360 = s1358 ^ s1359; - const SWord32 s1361 = table1[s1360]; - const SWord8 s1362 = (SWord8) (s1083 >> 16); - const SWord8 s1363 = table0[s1362]; - const SWord8 s1364 = (SWord8) (s11 >> 16); - const SWord8 s1365 = s1363 ^ s1364; - const SWord32 s1366 = table2[s1365]; - const SWord32 s1367 = s1361 ^ s1366; - const SWord8 s1368 = (SWord8) (s1345 >> 8); - const SWord8 s1369 = table0[s1368]; - const SWord8 s1370 = (SWord8) (s11 >> 8); - const SWord8 s1371 = s1369 ^ s1370; - const SWord32 s1372 = table3[s1371]; - const SWord32 s1373 = s1367 ^ s1372; - const SWord8 s1374 = (SWord8) s560; - const SWord8 s1375 = table0[s1374]; - const SWord8 s1376 = (SWord8) s11; - const SWord8 s1377 = s1375 ^ s1376; - const SWord32 s1378 = table4[s1377]; - const SWord32 s1379 = s1373 ^ s1378; - const SWord8 s1380 = (SWord8) (s1379 >> 16); - const SWord8 s1381 = table0[s1380]; - const SWord8 s1382 = (SWord8) (s12 >> 16); - const SWord8 s1383 = s1381 ^ s1382; - const SWord32 s1384 = table2[s1383]; - const SWord32 s1385 = s1356 ^ s1384; - const SWord8 s1386 = (SWord8) (s1083 >> 24); - const SWord8 s1387 = table0[s1386]; - const SWord8 s1388 = (SWord8) (s10 >> 24); - const SWord8 s1389 = s1387 ^ s1388; - const SWord32 s1390 = table1[s1389]; - const SWord8 s1391 = (SWord8) (s1345 >> 16); - const SWord8 s1392 = table0[s1391]; - const SWord8 s1393 = (SWord8) (s10 >> 16); - const SWord8 s1394 = s1392 ^ s1393; - const SWord32 s1395 = table2[s1394]; - const SWord32 s1396 = s1390 ^ s1395; - const SWord8 s1397 = (SWord8) (s560 >> 8); - const SWord8 s1398 = table0[s1397]; - const SWord8 s1399 = (SWord8) (s10 >> 8); - const SWord8 s1400 = s1398 ^ s1399; - const SWord32 s1401 = table3[s1400]; - const SWord32 s1402 = s1396 ^ s1401; - const SWord8 s1403 = (SWord8) s821; - const SWord8 s1404 = table0[s1403]; - const SWord8 s1405 = (SWord8) s10; - const SWord8 s1406 = s1404 ^ s1405; - const SWord32 s1407 = table4[s1406]; - const SWord32 s1408 = s1402 ^ s1407; - const SWord8 s1409 = (SWord8) (s1408 >> 8); - const SWord8 s1410 = table0[s1409]; - const SWord8 s1411 = (SWord8) (s12 >> 8); - const SWord8 s1412 = s1410 ^ s1411; - const SWord32 s1413 = table3[s1412]; - const SWord32 s1414 = s1385 ^ s1413; - const SWord8 s1415 = (SWord8) (s1345 >> 24); - const SWord8 s1416 = table0[s1415]; - const SWord8 s1417 = (SWord8) (s9 >> 24); - const SWord8 s1418 = s1416 ^ s1417; - const SWord32 s1419 = table1[s1418]; - const SWord8 s1420 = (SWord8) (s560 >> 16); - const SWord8 s1421 = table0[s1420]; - const SWord8 s1422 = (SWord8) (s9 >> 16); - const SWord8 s1423 = s1421 ^ s1422; - const SWord32 s1424 = table2[s1423]; - const SWord32 s1425 = s1419 ^ s1424; - const SWord8 s1426 = (SWord8) (s821 >> 8); - const SWord8 s1427 = table0[s1426]; - const SWord8 s1428 = (SWord8) (s9 >> 8); - const SWord8 s1429 = s1427 ^ s1428; - const SWord32 s1430 = table3[s1429]; - const SWord32 s1431 = s1425 ^ s1430; - const SWord8 s1432 = (SWord8) s1083; - const SWord8 s1433 = table0[s1432]; - const SWord8 s1434 = (SWord8) s9; - const SWord8 s1435 = s1433 ^ s1434; - const SWord32 s1436 = table4[s1435]; - const SWord32 s1437 = s1431 ^ s1436; - const SWord8 s1438 = (SWord8) s1437; - const SWord8 s1439 = table0[s1438]; - const SWord8 s1440 = (SWord8) s12; - const SWord8 s1441 = s1439 ^ s1440; - const SWord32 s1442 = table4[s1441]; - const SWord32 s1443 = s1414 ^ s1442; - const SWord8 s1444 = (SWord8) (s1443 >> 24); - const SWord8 s1445 = table0[s1444]; - const SWord8 s1446 = (SWord8) (s16 >> 24); - const SWord8 s1447 = s1445 ^ s1446; - const SWord32 s1448 = table1[s1447]; - const SWord8 s1449 = (SWord8) (s1379 >> 24); - const SWord8 s1450 = table0[s1449]; - const SWord8 s1451 = (SWord8) (s15 >> 24); - const SWord8 s1452 = s1450 ^ s1451; - const SWord32 s1453 = table1[s1452]; - const SWord8 s1454 = (SWord8) (s1408 >> 16); - const SWord8 s1455 = table0[s1454]; - const SWord8 s1456 = (SWord8) (s15 >> 16); - const SWord8 s1457 = s1455 ^ s1456; - const SWord32 s1458 = table2[s1457]; - const SWord32 s1459 = s1453 ^ s1458; - const SWord8 s1460 = (SWord8) (s1437 >> 8); - const SWord8 s1461 = table0[s1460]; - const SWord8 s1462 = (SWord8) (s15 >> 8); - const SWord8 s1463 = s1461 ^ s1462; - const SWord32 s1464 = table3[s1463]; - const SWord32 s1465 = s1459 ^ s1464; - const SWord8 s1466 = (SWord8) s1351; - const SWord8 s1467 = table0[s1466]; - const SWord8 s1468 = (SWord8) s15; - const SWord8 s1469 = s1467 ^ s1468; - const SWord32 s1470 = table4[s1469]; - const SWord32 s1471 = s1465 ^ s1470; - const SWord8 s1472 = (SWord8) (s1471 >> 16); - const SWord8 s1473 = table0[s1472]; - const SWord8 s1474 = (SWord8) (s16 >> 16); - const SWord8 s1475 = s1473 ^ s1474; - const SWord32 s1476 = table2[s1475]; - const SWord32 s1477 = s1448 ^ s1476; - const SWord8 s1478 = (SWord8) (s1408 >> 24); - const SWord8 s1479 = table0[s1478]; - const SWord8 s1480 = (SWord8) (s14 >> 24); - const SWord8 s1481 = s1479 ^ s1480; - const SWord32 s1482 = table1[s1481]; - const SWord8 s1483 = (SWord8) (s1437 >> 16); - const SWord8 s1484 = table0[s1483]; - const SWord8 s1485 = (SWord8) (s14 >> 16); - const SWord8 s1486 = s1484 ^ s1485; - const SWord32 s1487 = table2[s1486]; - const SWord32 s1488 = s1482 ^ s1487; - const SWord8 s1489 = (SWord8) (s1351 >> 8); - const SWord8 s1490 = table0[s1489]; - const SWord8 s1491 = (SWord8) (s14 >> 8); - const SWord8 s1492 = s1490 ^ s1491; - const SWord32 s1493 = table3[s1492]; - const SWord32 s1494 = s1488 ^ s1493; - const SWord8 s1495 = (SWord8) s1379; - const SWord8 s1496 = table0[s1495]; - const SWord8 s1497 = (SWord8) s14; - const SWord8 s1498 = s1496 ^ s1497; - const SWord32 s1499 = table4[s1498]; - const SWord32 s1500 = s1494 ^ s1499; - const SWord8 s1501 = (SWord8) (s1500 >> 8); - const SWord8 s1502 = table0[s1501]; - const SWord8 s1503 = (SWord8) (s16 >> 8); - const SWord8 s1504 = s1502 ^ s1503; - const SWord32 s1505 = table3[s1504]; - const SWord32 s1506 = s1477 ^ s1505; - const SWord8 s1507 = (SWord8) (s1437 >> 24); - const SWord8 s1508 = table0[s1507]; - const SWord8 s1509 = (SWord8) (s13 >> 24); - const SWord8 s1510 = s1508 ^ s1509; - const SWord32 s1511 = table1[s1510]; - const SWord8 s1512 = (SWord8) (s1351 >> 16); - const SWord8 s1513 = table0[s1512]; - const SWord8 s1514 = (SWord8) (s13 >> 16); - const SWord8 s1515 = s1513 ^ s1514; - const SWord32 s1516 = table2[s1515]; - const SWord32 s1517 = s1511 ^ s1516; - const SWord8 s1518 = (SWord8) (s1379 >> 8); - const SWord8 s1519 = table0[s1518]; - const SWord8 s1520 = (SWord8) (s13 >> 8); - const SWord8 s1521 = s1519 ^ s1520; - const SWord32 s1522 = table3[s1521]; - const SWord32 s1523 = s1517 ^ s1522; - const SWord8 s1524 = (SWord8) s1408; - const SWord8 s1525 = table0[s1524]; - const SWord8 s1526 = (SWord8) s13; - const SWord8 s1527 = s1525 ^ s1526; - const SWord32 s1528 = table4[s1527]; - const SWord32 s1529 = s1523 ^ s1528; - const SWord8 s1530 = (SWord8) s1529; - const SWord8 s1531 = table0[s1530]; - const SWord8 s1532 = (SWord8) s16; - const SWord8 s1533 = s1531 ^ s1532; - const SWord32 s1534 = table4[s1533]; - const SWord32 s1535 = s1506 ^ s1534; - const SWord8 s1536 = (SWord8) (s1535 >> 24); - const SWord8 s1537 = table0[s1536]; - const SWord8 s1538 = (SWord8) (s20 >> 24); - const SWord8 s1539 = s1537 ^ s1538; - const SWord32 s1540 = table1[s1539]; - const SWord8 s1541 = (SWord8) (s1471 >> 24); - const SWord8 s1542 = table0[s1541]; - const SWord8 s1543 = (SWord8) (s19 >> 24); - const SWord8 s1544 = s1542 ^ s1543; - const SWord32 s1545 = table1[s1544]; - const SWord8 s1546 = (SWord8) (s1500 >> 16); - const SWord8 s1547 = table0[s1546]; - const SWord8 s1548 = (SWord8) (s19 >> 16); - const SWord8 s1549 = s1547 ^ s1548; - const SWord32 s1550 = table2[s1549]; - const SWord32 s1551 = s1545 ^ s1550; - const SWord8 s1552 = (SWord8) (s1529 >> 8); - const SWord8 s1553 = table0[s1552]; - const SWord8 s1554 = (SWord8) (s19 >> 8); - const SWord8 s1555 = s1553 ^ s1554; - const SWord32 s1556 = table3[s1555]; - const SWord32 s1557 = s1551 ^ s1556; - const SWord8 s1558 = (SWord8) s1443; - const SWord8 s1559 = table0[s1558]; - const SWord8 s1560 = (SWord8) s19; - const SWord8 s1561 = s1559 ^ s1560; - const SWord32 s1562 = table4[s1561]; - const SWord32 s1563 = s1557 ^ s1562; - const SWord8 s1564 = (SWord8) (s1563 >> 16); - const SWord8 s1565 = table0[s1564]; - const SWord8 s1566 = (SWord8) (s20 >> 16); - const SWord8 s1567 = s1565 ^ s1566; - const SWord32 s1568 = table2[s1567]; - const SWord32 s1569 = s1540 ^ s1568; - const SWord8 s1570 = (SWord8) (s1500 >> 24); - const SWord8 s1571 = table0[s1570]; - const SWord8 s1572 = (SWord8) (s18 >> 24); - const SWord8 s1573 = s1571 ^ s1572; - const SWord32 s1574 = table1[s1573]; - const SWord8 s1575 = (SWord8) (s1529 >> 16); - const SWord8 s1576 = table0[s1575]; - const SWord8 s1577 = (SWord8) (s18 >> 16); - const SWord8 s1578 = s1576 ^ s1577; - const SWord32 s1579 = table2[s1578]; - const SWord32 s1580 = s1574 ^ s1579; - const SWord8 s1581 = (SWord8) (s1443 >> 8); - const SWord8 s1582 = table0[s1581]; - const SWord8 s1583 = (SWord8) (s18 >> 8); - const SWord8 s1584 = s1582 ^ s1583; - const SWord32 s1585 = table3[s1584]; - const SWord32 s1586 = s1580 ^ s1585; - const SWord8 s1587 = (SWord8) s1471; - const SWord8 s1588 = table0[s1587]; - const SWord8 s1589 = (SWord8) s18; - const SWord8 s1590 = s1588 ^ s1589; - const SWord32 s1591 = table4[s1590]; - const SWord32 s1592 = s1586 ^ s1591; - const SWord8 s1593 = (SWord8) (s1592 >> 8); - const SWord8 s1594 = table0[s1593]; - const SWord8 s1595 = (SWord8) (s20 >> 8); - const SWord8 s1596 = s1594 ^ s1595; - const SWord32 s1597 = table3[s1596]; - const SWord32 s1598 = s1569 ^ s1597; - const SWord8 s1599 = (SWord8) (s1529 >> 24); - const SWord8 s1600 = table0[s1599]; - const SWord8 s1601 = (SWord8) (s17 >> 24); - const SWord8 s1602 = s1600 ^ s1601; - const SWord32 s1603 = table1[s1602]; - const SWord8 s1604 = (SWord8) (s1443 >> 16); - const SWord8 s1605 = table0[s1604]; - const SWord8 s1606 = (SWord8) (s17 >> 16); - const SWord8 s1607 = s1605 ^ s1606; - const SWord32 s1608 = table2[s1607]; - const SWord32 s1609 = s1603 ^ s1608; - const SWord8 s1610 = (SWord8) (s1471 >> 8); - const SWord8 s1611 = table0[s1610]; - const SWord8 s1612 = (SWord8) (s17 >> 8); - const SWord8 s1613 = s1611 ^ s1612; - const SWord32 s1614 = table3[s1613]; - const SWord32 s1615 = s1609 ^ s1614; - const SWord8 s1616 = (SWord8) s1500; - const SWord8 s1617 = table0[s1616]; - const SWord8 s1618 = (SWord8) s17; - const SWord8 s1619 = s1617 ^ s1618; - const SWord32 s1620 = table4[s1619]; - const SWord32 s1621 = s1615 ^ s1620; - const SWord8 s1622 = (SWord8) s1621; - const SWord8 s1623 = table0[s1622]; - const SWord8 s1624 = (SWord8) s20; - const SWord8 s1625 = s1623 ^ s1624; - const SWord32 s1626 = table4[s1625]; - const SWord32 s1627 = s1598 ^ s1626; - const SWord8 s1628 = (SWord8) (s1627 >> 24); - const SWord8 s1629 = table0[s1628]; - const SWord8 s1630 = (SWord8) (s24 >> 24); - const SWord8 s1631 = s1629 ^ s1630; - const SWord32 s1632 = table1[s1631]; - const SWord8 s1633 = (SWord8) (s1563 >> 24); - const SWord8 s1634 = table0[s1633]; - const SWord8 s1635 = (SWord8) (s23 >> 24); - const SWord8 s1636 = s1634 ^ s1635; - const SWord32 s1637 = table1[s1636]; - const SWord8 s1638 = (SWord8) (s1592 >> 16); - const SWord8 s1639 = table0[s1638]; - const SWord8 s1640 = (SWord8) (s23 >> 16); - const SWord8 s1641 = s1639 ^ s1640; - const SWord32 s1642 = table2[s1641]; - const SWord32 s1643 = s1637 ^ s1642; - const SWord8 s1644 = (SWord8) (s1621 >> 8); - const SWord8 s1645 = table0[s1644]; - const SWord8 s1646 = (SWord8) (s23 >> 8); - const SWord8 s1647 = s1645 ^ s1646; - const SWord32 s1648 = table3[s1647]; - const SWord32 s1649 = s1643 ^ s1648; - const SWord8 s1650 = (SWord8) s1535; - const SWord8 s1651 = table0[s1650]; - const SWord8 s1652 = (SWord8) s23; - const SWord8 s1653 = s1651 ^ s1652; - const SWord32 s1654 = table4[s1653]; - const SWord32 s1655 = s1649 ^ s1654; - const SWord8 s1656 = (SWord8) (s1655 >> 16); - const SWord8 s1657 = table0[s1656]; - const SWord8 s1658 = (SWord8) (s24 >> 16); - const SWord8 s1659 = s1657 ^ s1658; - const SWord32 s1660 = table2[s1659]; - const SWord32 s1661 = s1632 ^ s1660; - const SWord8 s1662 = (SWord8) (s1592 >> 24); - const SWord8 s1663 = table0[s1662]; - const SWord8 s1664 = (SWord8) (s22 >> 24); - const SWord8 s1665 = s1663 ^ s1664; - const SWord32 s1666 = table1[s1665]; - const SWord8 s1667 = (SWord8) (s1621 >> 16); - const SWord8 s1668 = table0[s1667]; - const SWord8 s1669 = (SWord8) (s22 >> 16); - const SWord8 s1670 = s1668 ^ s1669; - const SWord32 s1671 = table2[s1670]; - const SWord32 s1672 = s1666 ^ s1671; - const SWord8 s1673 = (SWord8) (s1535 >> 8); - const SWord8 s1674 = table0[s1673]; - const SWord8 s1675 = (SWord8) (s22 >> 8); - const SWord8 s1676 = s1674 ^ s1675; - const SWord32 s1677 = table3[s1676]; - const SWord32 s1678 = s1672 ^ s1677; - const SWord8 s1679 = (SWord8) s1563; - const SWord8 s1680 = table0[s1679]; - const SWord8 s1681 = (SWord8) s22; - const SWord8 s1682 = s1680 ^ s1681; - const SWord32 s1683 = table4[s1682]; - const SWord32 s1684 = s1678 ^ s1683; - const SWord8 s1685 = (SWord8) (s1684 >> 8); - const SWord8 s1686 = table0[s1685]; - const SWord8 s1687 = (SWord8) (s24 >> 8); - const SWord8 s1688 = s1686 ^ s1687; - const SWord32 s1689 = table3[s1688]; - const SWord32 s1690 = s1661 ^ s1689; - const SWord8 s1691 = (SWord8) (s1621 >> 24); - const SWord8 s1692 = table0[s1691]; - const SWord8 s1693 = (SWord8) (s21 >> 24); - const SWord8 s1694 = s1692 ^ s1693; - const SWord32 s1695 = table1[s1694]; - const SWord8 s1696 = (SWord8) (s1535 >> 16); - const SWord8 s1697 = table0[s1696]; - const SWord8 s1698 = (SWord8) (s21 >> 16); - const SWord8 s1699 = s1697 ^ s1698; - const SWord32 s1700 = table2[s1699]; - const SWord32 s1701 = s1695 ^ s1700; - const SWord8 s1702 = (SWord8) (s1563 >> 8); - const SWord8 s1703 = table0[s1702]; - const SWord8 s1704 = (SWord8) (s21 >> 8); - const SWord8 s1705 = s1703 ^ s1704; - const SWord32 s1706 = table3[s1705]; - const SWord32 s1707 = s1701 ^ s1706; - const SWord8 s1708 = (SWord8) s1592; - const SWord8 s1709 = table0[s1708]; - const SWord8 s1710 = (SWord8) s21; - const SWord8 s1711 = s1709 ^ s1710; - const SWord32 s1712 = table4[s1711]; - const SWord32 s1713 = s1707 ^ s1712; - const SWord8 s1714 = (SWord8) s1713; - const SWord8 s1715 = table0[s1714]; - const SWord8 s1716 = (SWord8) s24; - const SWord8 s1717 = s1715 ^ s1716; - const SWord32 s1718 = table4[s1717]; - const SWord32 s1719 = s1690 ^ s1718; - const SWord8 s1720 = (SWord8) (s1719 >> 24); - const SWord8 s1721 = table0[s1720]; - const SWord8 s1722 = (SWord8) (s28 >> 24); - const SWord8 s1723 = s1721 ^ s1722; - const SWord32 s1724 = table1[s1723]; - const SWord8 s1725 = (SWord8) (s1655 >> 24); - const SWord8 s1726 = table0[s1725]; - const SWord8 s1727 = (SWord8) (s27 >> 24); - const SWord8 s1728 = s1726 ^ s1727; - const SWord32 s1729 = table1[s1728]; - const SWord8 s1730 = (SWord8) (s1684 >> 16); - const SWord8 s1731 = table0[s1730]; - const SWord8 s1732 = (SWord8) (s27 >> 16); - const SWord8 s1733 = s1731 ^ s1732; - const SWord32 s1734 = table2[s1733]; - const SWord32 s1735 = s1729 ^ s1734; - const SWord8 s1736 = (SWord8) (s1713 >> 8); - const SWord8 s1737 = table0[s1736]; - const SWord8 s1738 = (SWord8) (s27 >> 8); - const SWord8 s1739 = s1737 ^ s1738; - const SWord32 s1740 = table3[s1739]; - const SWord32 s1741 = s1735 ^ s1740; - const SWord8 s1742 = (SWord8) s1627; - const SWord8 s1743 = table0[s1742]; - const SWord8 s1744 = (SWord8) s27; - const SWord8 s1745 = s1743 ^ s1744; - const SWord32 s1746 = table4[s1745]; - const SWord32 s1747 = s1741 ^ s1746; - const SWord8 s1748 = (SWord8) (s1747 >> 16); - const SWord8 s1749 = table0[s1748]; - const SWord8 s1750 = (SWord8) (s28 >> 16); - const SWord8 s1751 = s1749 ^ s1750; - const SWord32 s1752 = table2[s1751]; - const SWord32 s1753 = s1724 ^ s1752; - const SWord8 s1754 = (SWord8) (s1684 >> 24); - const SWord8 s1755 = table0[s1754]; - const SWord8 s1756 = (SWord8) (s26 >> 24); - const SWord8 s1757 = s1755 ^ s1756; - const SWord32 s1758 = table1[s1757]; - const SWord8 s1759 = (SWord8) (s1713 >> 16); - const SWord8 s1760 = table0[s1759]; - const SWord8 s1761 = (SWord8) (s26 >> 16); - const SWord8 s1762 = s1760 ^ s1761; - const SWord32 s1763 = table2[s1762]; - const SWord32 s1764 = s1758 ^ s1763; - const SWord8 s1765 = (SWord8) (s1627 >> 8); - const SWord8 s1766 = table0[s1765]; - const SWord8 s1767 = (SWord8) (s26 >> 8); - const SWord8 s1768 = s1766 ^ s1767; - const SWord32 s1769 = table3[s1768]; - const SWord32 s1770 = s1764 ^ s1769; - const SWord8 s1771 = (SWord8) s1655; - const SWord8 s1772 = table0[s1771]; - const SWord8 s1773 = (SWord8) s26; - const SWord8 s1774 = s1772 ^ s1773; - const SWord32 s1775 = table4[s1774]; - const SWord32 s1776 = s1770 ^ s1775; - const SWord8 s1777 = (SWord8) (s1776 >> 8); - const SWord8 s1778 = table0[s1777]; - const SWord8 s1779 = (SWord8) (s28 >> 8); - const SWord8 s1780 = s1778 ^ s1779; - const SWord32 s1781 = table3[s1780]; - const SWord32 s1782 = s1753 ^ s1781; - const SWord8 s1783 = (SWord8) (s1713 >> 24); - const SWord8 s1784 = table0[s1783]; - const SWord8 s1785 = (SWord8) (s25 >> 24); - const SWord8 s1786 = s1784 ^ s1785; - const SWord32 s1787 = table1[s1786]; - const SWord8 s1788 = (SWord8) (s1627 >> 16); - const SWord8 s1789 = table0[s1788]; - const SWord8 s1790 = (SWord8) (s25 >> 16); - const SWord8 s1791 = s1789 ^ s1790; - const SWord32 s1792 = table2[s1791]; - const SWord32 s1793 = s1787 ^ s1792; - const SWord8 s1794 = (SWord8) (s1655 >> 8); - const SWord8 s1795 = table0[s1794]; - const SWord8 s1796 = (SWord8) (s25 >> 8); - const SWord8 s1797 = s1795 ^ s1796; - const SWord32 s1798 = table3[s1797]; - const SWord32 s1799 = s1793 ^ s1798; - const SWord8 s1800 = (SWord8) s1684; - const SWord8 s1801 = table0[s1800]; - const SWord8 s1802 = (SWord8) s25; - const SWord8 s1803 = s1801 ^ s1802; - const SWord32 s1804 = table4[s1803]; - const SWord32 s1805 = s1799 ^ s1804; - const SWord8 s1806 = (SWord8) s1805; - const SWord8 s1807 = table0[s1806]; - const SWord8 s1808 = (SWord8) s28; - const SWord8 s1809 = s1807 ^ s1808; - const SWord32 s1810 = table4[s1809]; - const SWord32 s1811 = s1782 ^ s1810; - const SWord8 s1812 = (SWord8) (s1811 >> 24); - const SWord8 s1813 = table0[s1812]; - const SWord8 s1814 = (SWord8) (s32 >> 24); - const SWord8 s1815 = s1813 ^ s1814; - const SWord32 s1816 = table1[s1815]; - const SWord8 s1817 = (SWord8) (s1747 >> 24); - const SWord8 s1818 = table0[s1817]; - const SWord8 s1819 = (SWord8) (s31 >> 24); - const SWord8 s1820 = s1818 ^ s1819; - const SWord32 s1821 = table1[s1820]; - const SWord8 s1822 = (SWord8) (s1776 >> 16); - const SWord8 s1823 = table0[s1822]; - const SWord8 s1824 = (SWord8) (s31 >> 16); - const SWord8 s1825 = s1823 ^ s1824; - const SWord32 s1826 = table2[s1825]; - const SWord32 s1827 = s1821 ^ s1826; - const SWord8 s1828 = (SWord8) (s1805 >> 8); - const SWord8 s1829 = table0[s1828]; - const SWord8 s1830 = (SWord8) (s31 >> 8); - const SWord8 s1831 = s1829 ^ s1830; - const SWord32 s1832 = table3[s1831]; - const SWord32 s1833 = s1827 ^ s1832; - const SWord8 s1834 = (SWord8) s1719; - const SWord8 s1835 = table0[s1834]; - const SWord8 s1836 = (SWord8) s31; - const SWord8 s1837 = s1835 ^ s1836; - const SWord32 s1838 = table4[s1837]; - const SWord32 s1839 = s1833 ^ s1838; - const SWord8 s1840 = (SWord8) (s1839 >> 16); - const SWord8 s1841 = table0[s1840]; - const SWord8 s1842 = (SWord8) (s32 >> 16); - const SWord8 s1843 = s1841 ^ s1842; - const SWord32 s1844 = table2[s1843]; - const SWord32 s1845 = s1816 ^ s1844; - const SWord8 s1846 = (SWord8) (s1776 >> 24); - const SWord8 s1847 = table0[s1846]; - const SWord8 s1848 = (SWord8) (s30 >> 24); - const SWord8 s1849 = s1847 ^ s1848; - const SWord32 s1850 = table1[s1849]; - const SWord8 s1851 = (SWord8) (s1805 >> 16); - const SWord8 s1852 = table0[s1851]; - const SWord8 s1853 = (SWord8) (s30 >> 16); - const SWord8 s1854 = s1852 ^ s1853; - const SWord32 s1855 = table2[s1854]; - const SWord32 s1856 = s1850 ^ s1855; - const SWord8 s1857 = (SWord8) (s1719 >> 8); - const SWord8 s1858 = table0[s1857]; - const SWord8 s1859 = (SWord8) (s30 >> 8); - const SWord8 s1860 = s1858 ^ s1859; - const SWord32 s1861 = table3[s1860]; - const SWord32 s1862 = s1856 ^ s1861; - const SWord8 s1863 = (SWord8) s1747; - const SWord8 s1864 = table0[s1863]; - const SWord8 s1865 = (SWord8) s30; - const SWord8 s1866 = s1864 ^ s1865; - const SWord32 s1867 = table4[s1866]; - const SWord32 s1868 = s1862 ^ s1867; - const SWord8 s1869 = (SWord8) (s1868 >> 8); - const SWord8 s1870 = table0[s1869]; - const SWord8 s1871 = (SWord8) (s32 >> 8); - const SWord8 s1872 = s1870 ^ s1871; - const SWord32 s1873 = table3[s1872]; - const SWord32 s1874 = s1845 ^ s1873; - const SWord8 s1875 = (SWord8) (s1805 >> 24); - const SWord8 s1876 = table0[s1875]; - const SWord8 s1877 = (SWord8) (s29 >> 24); - const SWord8 s1878 = s1876 ^ s1877; - const SWord32 s1879 = table1[s1878]; - const SWord8 s1880 = (SWord8) (s1719 >> 16); - const SWord8 s1881 = table0[s1880]; - const SWord8 s1882 = (SWord8) (s29 >> 16); - const SWord8 s1883 = s1881 ^ s1882; - const SWord32 s1884 = table2[s1883]; - const SWord32 s1885 = s1879 ^ s1884; - const SWord8 s1886 = (SWord8) (s1747 >> 8); - const SWord8 s1887 = table0[s1886]; - const SWord8 s1888 = (SWord8) (s29 >> 8); - const SWord8 s1889 = s1887 ^ s1888; - const SWord32 s1890 = table3[s1889]; - const SWord32 s1891 = s1885 ^ s1890; - const SWord8 s1892 = (SWord8) s1776; - const SWord8 s1893 = table0[s1892]; - const SWord8 s1894 = (SWord8) s29; - const SWord8 s1895 = s1893 ^ s1894; - const SWord32 s1896 = table4[s1895]; - const SWord32 s1897 = s1891 ^ s1896; - const SWord8 s1898 = (SWord8) s1897; - const SWord8 s1899 = table0[s1898]; - const SWord8 s1900 = (SWord8) s32; - const SWord8 s1901 = s1899 ^ s1900; - const SWord32 s1902 = table4[s1901]; - const SWord32 s1903 = s1874 ^ s1902; - const SWord8 s1904 = (SWord8) (s1903 >> 24); - const SWord8 s1905 = table0[s1904]; - const SWord8 s1906 = (SWord8) (s36 >> 24); - const SWord8 s1907 = s1905 ^ s1906; - const SWord32 s1908 = table1[s1907]; - const SWord8 s1909 = (SWord8) (s1839 >> 24); - const SWord8 s1910 = table0[s1909]; - const SWord8 s1911 = (SWord8) (s35 >> 24); - const SWord8 s1912 = s1910 ^ s1911; - const SWord32 s1913 = table1[s1912]; - const SWord8 s1914 = (SWord8) (s1868 >> 16); - const SWord8 s1915 = table0[s1914]; - const SWord8 s1916 = (SWord8) (s35 >> 16); - const SWord8 s1917 = s1915 ^ s1916; - const SWord32 s1918 = table2[s1917]; - const SWord32 s1919 = s1913 ^ s1918; - const SWord8 s1920 = (SWord8) (s1897 >> 8); - const SWord8 s1921 = table0[s1920]; - const SWord8 s1922 = (SWord8) (s35 >> 8); - const SWord8 s1923 = s1921 ^ s1922; - const SWord32 s1924 = table3[s1923]; - const SWord32 s1925 = s1919 ^ s1924; - const SWord8 s1926 = (SWord8) s1811; - const SWord8 s1927 = table0[s1926]; - const SWord8 s1928 = (SWord8) s35; - const SWord8 s1929 = s1927 ^ s1928; - const SWord32 s1930 = table4[s1929]; - const SWord32 s1931 = s1925 ^ s1930; - const SWord8 s1932 = (SWord8) (s1931 >> 16); - const SWord8 s1933 = table0[s1932]; - const SWord8 s1934 = (SWord8) (s36 >> 16); - const SWord8 s1935 = s1933 ^ s1934; - const SWord32 s1936 = table2[s1935]; - const SWord32 s1937 = s1908 ^ s1936; - const SWord8 s1938 = (SWord8) (s1868 >> 24); - const SWord8 s1939 = table0[s1938]; - const SWord8 s1940 = (SWord8) (s34 >> 24); - const SWord8 s1941 = s1939 ^ s1940; - const SWord32 s1942 = table1[s1941]; - const SWord8 s1943 = (SWord8) (s1897 >> 16); - const SWord8 s1944 = table0[s1943]; - const SWord8 s1945 = (SWord8) (s34 >> 16); - const SWord8 s1946 = s1944 ^ s1945; - const SWord32 s1947 = table2[s1946]; - const SWord32 s1948 = s1942 ^ s1947; - const SWord8 s1949 = (SWord8) (s1811 >> 8); - const SWord8 s1950 = table0[s1949]; - const SWord8 s1951 = (SWord8) (s34 >> 8); - const SWord8 s1952 = s1950 ^ s1951; - const SWord32 s1953 = table3[s1952]; - const SWord32 s1954 = s1948 ^ s1953; - const SWord8 s1955 = (SWord8) s1839; - const SWord8 s1956 = table0[s1955]; - const SWord8 s1957 = (SWord8) s34; - const SWord8 s1958 = s1956 ^ s1957; - const SWord32 s1959 = table4[s1958]; - const SWord32 s1960 = s1954 ^ s1959; - const SWord8 s1961 = (SWord8) (s1960 >> 8); - const SWord8 s1962 = table0[s1961]; - const SWord8 s1963 = (SWord8) (s36 >> 8); - const SWord8 s1964 = s1962 ^ s1963; - const SWord32 s1965 = table3[s1964]; - const SWord32 s1966 = s1937 ^ s1965; - const SWord8 s1967 = (SWord8) (s1897 >> 24); - const SWord8 s1968 = table0[s1967]; - const SWord8 s1969 = (SWord8) (s33 >> 24); - const SWord8 s1970 = s1968 ^ s1969; - const SWord32 s1971 = table1[s1970]; - const SWord8 s1972 = (SWord8) (s1811 >> 16); - const SWord8 s1973 = table0[s1972]; - const SWord8 s1974 = (SWord8) (s33 >> 16); - const SWord8 s1975 = s1973 ^ s1974; - const SWord32 s1976 = table2[s1975]; - const SWord32 s1977 = s1971 ^ s1976; - const SWord8 s1978 = (SWord8) (s1839 >> 8); - const SWord8 s1979 = table0[s1978]; - const SWord8 s1980 = (SWord8) (s33 >> 8); - const SWord8 s1981 = s1979 ^ s1980; - const SWord32 s1982 = table3[s1981]; - const SWord32 s1983 = s1977 ^ s1982; - const SWord8 s1984 = (SWord8) s1868; - const SWord8 s1985 = table0[s1984]; - const SWord8 s1986 = (SWord8) s33; - const SWord8 s1987 = s1985 ^ s1986; - const SWord32 s1988 = table4[s1987]; - const SWord32 s1989 = s1983 ^ s1988; - const SWord8 s1990 = (SWord8) s1989; - const SWord8 s1991 = table0[s1990]; - const SWord8 s1992 = (SWord8) s36; - const SWord8 s1993 = s1991 ^ s1992; - const SWord32 s1994 = table4[s1993]; - const SWord32 s1995 = s1966 ^ s1994; - const SWord8 s1996 = (SWord8) (s1995 >> 24); - const SWord8 s1997 = table0[s1996]; - const SWord8 s1998 = (SWord8) (s40 >> 24); - const SWord8 s1999 = s1997 ^ s1998; - const SWord32 s2000 = table1[s1999]; - const SWord8 s2001 = (SWord8) (s1931 >> 24); - const SWord8 s2002 = table0[s2001]; - const SWord8 s2003 = (SWord8) (s39 >> 24); - const SWord8 s2004 = s2002 ^ s2003; - const SWord32 s2005 = table1[s2004]; - const SWord8 s2006 = (SWord8) (s1960 >> 16); - const SWord8 s2007 = table0[s2006]; - const SWord8 s2008 = (SWord8) (s39 >> 16); - const SWord8 s2009 = s2007 ^ s2008; - const SWord32 s2010 = table2[s2009]; - const SWord32 s2011 = s2005 ^ s2010; - const SWord8 s2012 = (SWord8) (s1989 >> 8); - const SWord8 s2013 = table0[s2012]; - const SWord8 s2014 = (SWord8) (s39 >> 8); - const SWord8 s2015 = s2013 ^ s2014; - const SWord32 s2016 = table3[s2015]; - const SWord32 s2017 = s2011 ^ s2016; - const SWord8 s2018 = (SWord8) s1903; - const SWord8 s2019 = table0[s2018]; - const SWord8 s2020 = (SWord8) s39; - const SWord8 s2021 = s2019 ^ s2020; - const SWord32 s2022 = table4[s2021]; - const SWord32 s2023 = s2017 ^ s2022; - const SWord8 s2024 = (SWord8) (s2023 >> 16); - const SWord8 s2025 = table0[s2024]; - const SWord8 s2026 = (SWord8) (s40 >> 16); - const SWord8 s2027 = s2025 ^ s2026; - const SWord32 s2028 = table2[s2027]; - const SWord32 s2029 = s2000 ^ s2028; - const SWord8 s2030 = (SWord8) (s1960 >> 24); - const SWord8 s2031 = table0[s2030]; - const SWord8 s2032 = (SWord8) (s38 >> 24); - const SWord8 s2033 = s2031 ^ s2032; - const SWord32 s2034 = table1[s2033]; - const SWord8 s2035 = (SWord8) (s1989 >> 16); - const SWord8 s2036 = table0[s2035]; - const SWord8 s2037 = (SWord8) (s38 >> 16); - const SWord8 s2038 = s2036 ^ s2037; - const SWord32 s2039 = table2[s2038]; - const SWord32 s2040 = s2034 ^ s2039; - const SWord8 s2041 = (SWord8) (s1903 >> 8); - const SWord8 s2042 = table0[s2041]; - const SWord8 s2043 = (SWord8) (s38 >> 8); - const SWord8 s2044 = s2042 ^ s2043; - const SWord32 s2045 = table3[s2044]; - const SWord32 s2046 = s2040 ^ s2045; - const SWord8 s2047 = (SWord8) s1931; - const SWord8 s2048 = table0[s2047]; - const SWord8 s2049 = (SWord8) s38; - const SWord8 s2050 = s2048 ^ s2049; - const SWord32 s2051 = table4[s2050]; - const SWord32 s2052 = s2046 ^ s2051; - const SWord8 s2053 = (SWord8) (s2052 >> 8); - const SWord8 s2054 = table0[s2053]; - const SWord8 s2055 = (SWord8) (s40 >> 8); - const SWord8 s2056 = s2054 ^ s2055; - const SWord32 s2057 = table3[s2056]; - const SWord32 s2058 = s2029 ^ s2057; - const SWord8 s2059 = (SWord8) (s1989 >> 24); - const SWord8 s2060 = table0[s2059]; - const SWord8 s2061 = (SWord8) (s37 >> 24); - const SWord8 s2062 = s2060 ^ s2061; - const SWord32 s2063 = table1[s2062]; - const SWord8 s2064 = (SWord8) (s1903 >> 16); - const SWord8 s2065 = table0[s2064]; - const SWord8 s2066 = (SWord8) (s37 >> 16); - const SWord8 s2067 = s2065 ^ s2066; - const SWord32 s2068 = table2[s2067]; - const SWord32 s2069 = s2063 ^ s2068; - const SWord8 s2070 = (SWord8) (s1931 >> 8); - const SWord8 s2071 = table0[s2070]; - const SWord8 s2072 = (SWord8) (s37 >> 8); - const SWord8 s2073 = s2071 ^ s2072; - const SWord32 s2074 = table3[s2073]; - const SWord32 s2075 = s2069 ^ s2074; - const SWord8 s2076 = (SWord8) s1960; - const SWord8 s2077 = table0[s2076]; - const SWord8 s2078 = (SWord8) s37; - const SWord8 s2079 = s2077 ^ s2078; - const SWord32 s2080 = table4[s2079]; - const SWord32 s2081 = s2075 ^ s2080; - const SWord8 s2082 = (SWord8) s2081; - const SWord8 s2083 = table0[s2082]; - const SWord8 s2084 = (SWord8) s40; - const SWord8 s2085 = s2083 ^ s2084; - const SWord32 s2086 = table4[s2085]; - const SWord32 s2087 = s2058 ^ s2086; - const SWord8 s2088 = (SWord8) (s2087 >> 24); - const SWord8 s2089 = table0[s2088]; - const SWord8 s2090 = (SWord8) (s2023 >> 24); - const SWord8 s2091 = table0[s2090]; - const SWord8 s2092 = (SWord8) (s43 >> 24); - const SWord8 s2093 = s2091 ^ s2092; - const SWord32 s2094 = table1[s2093]; - const SWord8 s2095 = (SWord8) (s2052 >> 16); - const SWord8 s2096 = table0[s2095]; - const SWord8 s2097 = (SWord8) (s43 >> 16); - const SWord8 s2098 = s2096 ^ s2097; - const SWord32 s2099 = table2[s2098]; - const SWord32 s2100 = s2094 ^ s2099; - const SWord8 s2101 = (SWord8) (s2081 >> 8); - const SWord8 s2102 = table0[s2101]; - const SWord8 s2103 = (SWord8) (s43 >> 8); - const SWord8 s2104 = s2102 ^ s2103; - const SWord32 s2105 = table3[s2104]; - const SWord32 s2106 = s2100 ^ s2105; - const SWord8 s2107 = (SWord8) s1995; - const SWord8 s2108 = table0[s2107]; - const SWord8 s2109 = (SWord8) s43; - const SWord8 s2110 = s2108 ^ s2109; - const SWord32 s2111 = table4[s2110]; - const SWord32 s2112 = s2106 ^ s2111; - const SWord8 s2113 = (SWord8) (s2112 >> 16); - const SWord8 s2114 = table0[s2113]; - const SWord16 s2115 = (((SWord16) s2089) << 8) | ((SWord16) s2114); - const SWord8 s2116 = (SWord8) (s2052 >> 24); - const SWord8 s2117 = table0[s2116]; - const SWord8 s2118 = (SWord8) (s42 >> 24); - const SWord8 s2119 = s2117 ^ s2118; - const SWord32 s2120 = table1[s2119]; - const SWord8 s2121 = (SWord8) (s2081 >> 16); - const SWord8 s2122 = table0[s2121]; - const SWord8 s2123 = (SWord8) (s42 >> 16); - const SWord8 s2124 = s2122 ^ s2123; - const SWord32 s2125 = table2[s2124]; - const SWord32 s2126 = s2120 ^ s2125; - const SWord8 s2127 = (SWord8) (s1995 >> 8); - const SWord8 s2128 = table0[s2127]; - const SWord8 s2129 = (SWord8) (s42 >> 8); - const SWord8 s2130 = s2128 ^ s2129; - const SWord32 s2131 = table3[s2130]; - const SWord32 s2132 = s2126 ^ s2131; - const SWord8 s2133 = (SWord8) s2023; - const SWord8 s2134 = table0[s2133]; - const SWord8 s2135 = (SWord8) s42; - const SWord8 s2136 = s2134 ^ s2135; - const SWord32 s2137 = table4[s2136]; - const SWord32 s2138 = s2132 ^ s2137; - const SWord8 s2139 = (SWord8) (s2138 >> 8); - const SWord8 s2140 = table0[s2139]; - const SWord8 s2141 = (SWord8) (s2081 >> 24); - const SWord8 s2142 = table0[s2141]; - const SWord8 s2143 = (SWord8) (s41 >> 24); - const SWord8 s2144 = s2142 ^ s2143; - const SWord32 s2145 = table1[s2144]; - const SWord8 s2146 = (SWord8) (s1995 >> 16); - const SWord8 s2147 = table0[s2146]; - const SWord8 s2148 = (SWord8) (s41 >> 16); - const SWord8 s2149 = s2147 ^ s2148; - const SWord32 s2150 = table2[s2149]; - const SWord32 s2151 = s2145 ^ s2150; - const SWord8 s2152 = (SWord8) (s2023 >> 8); - const SWord8 s2153 = table0[s2152]; - const SWord8 s2154 = (SWord8) (s41 >> 8); - const SWord8 s2155 = s2153 ^ s2154; - const SWord32 s2156 = table3[s2155]; - const SWord32 s2157 = s2151 ^ s2156; - const SWord8 s2158 = (SWord8) s2052; - const SWord8 s2159 = table0[s2158]; - const SWord8 s2160 = (SWord8) s41; - const SWord8 s2161 = s2159 ^ s2160; - const SWord32 s2162 = table4[s2161]; - const SWord32 s2163 = s2157 ^ s2162; - const SWord8 s2164 = (SWord8) s2163; - const SWord8 s2165 = table0[s2164]; - const SWord16 s2166 = (((SWord16) s2140) << 8) | ((SWord16) s2165); - const SWord32 s2167 = (((SWord32) s2115) << 16) | ((SWord32) s2166); - const SWord32 s2168 = s44 ^ s2167; - const SWord8 s2169 = (SWord8) (s2163 >> 24); - const SWord8 s2170 = table0[s2169]; - const SWord8 s2171 = (SWord8) (s2087 >> 16); - const SWord8 s2172 = table0[s2171]; - const SWord16 s2173 = (((SWord16) s2170) << 8) | ((SWord16) s2172); - const SWord8 s2174 = (SWord8) (s2112 >> 8); - const SWord8 s2175 = table0[s2174]; - const SWord8 s2176 = (SWord8) s2138; - const SWord8 s2177 = table0[s2176]; - const SWord16 s2178 = (((SWord16) s2175) << 8) | ((SWord16) s2177); - const SWord32 s2179 = (((SWord32) s2173) << 16) | ((SWord32) s2178); - const SWord32 s2180 = s45 ^ s2179; - const SWord8 s2181 = (SWord8) (s2138 >> 24); - const SWord8 s2182 = table0[s2181]; - const SWord8 s2183 = (SWord8) (s2163 >> 16); - const SWord8 s2184 = table0[s2183]; - const SWord16 s2185 = (((SWord16) s2182) << 8) | ((SWord16) s2184); - const SWord8 s2186 = (SWord8) (s2087 >> 8); - const SWord8 s2187 = table0[s2186]; - const SWord8 s2188 = (SWord8) s2112; - const SWord8 s2189 = table0[s2188]; - const SWord16 s2190 = (((SWord16) s2187) << 8) | ((SWord16) s2189); - const SWord32 s2191 = (((SWord32) s2185) << 16) | ((SWord32) s2190); - const SWord32 s2192 = s46 ^ s2191; - const SWord8 s2193 = (SWord8) (s2112 >> 24); - const SWord8 s2194 = table0[s2193]; - const SWord8 s2195 = (SWord8) (s2138 >> 16); - const SWord8 s2196 = table0[s2195]; - const SWord16 s2197 = (((SWord16) s2194) << 8) | ((SWord16) s2196); - const SWord8 s2198 = (SWord8) (s2163 >> 8); - const SWord8 s2199 = table0[s2198]; - const SWord8 s2200 = (SWord8) s2087; - const SWord8 s2201 = table0[s2200]; - const SWord16 s2202 = (((SWord16) s2199) << 8) | ((SWord16) s2201); - const SWord32 s2203 = (((SWord32) s2197) << 16) | ((SWord32) s2202); - const SWord32 s2204 = s47 ^ s2203; - - pt[0] = s2168; - pt[1] = s2180; - pt[2] = s2192; - pt[3] = s2204; -} -== END: "aes128OTFDecrypt.c" ================== -== BEGIN: "aes128Lib.h" ================ -/* Header file for aes128Lib. Automatically generated by SBV. Do not edit! */ - -#ifndef __aes128Lib__HEADER_INCLUDED__ -#define __aes128Lib__HEADER_INCLUDED__ - -#include -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* Entry point prototypes: */ -void aes128KeySchedule(const SWord32 *key, SWord32 *encKS, - SWord32 *decKS); -void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey, - SWord32 *ct); -void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey, - SWord32 *pt); -void aes128InvKeySchedule(const SWord32 *key, SWord32 *decKS); -void aes128OTFDecrypt(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 -#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[%1d] = 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[%2d] = 0x%08"PRIx32"UL\n", encKS_ctr ,encKS[encKS_ctr]); - int decKS_ctr; - for(decKS_ctr = 0; decKS_ctr < 44 ; ++decKS_ctr) - printf(" decKS[%2d] = 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[%1d] = 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[%2d] = 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[%1d] = 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[%1d] = 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[%2d] = 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[%1d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]); -} - -void aes128InvKeySchedule_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[%1d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]); - - SWord32 decKS[44]; - - aes128InvKeySchedule(key, decKS); - - printf("aes128InvKeySchedule(key, decKS) ->\n"); - int decKS_ctr; - for(decKS_ctr = 0; decKS_ctr < 44 ; ++decKS_ctr) - printf(" decKS[%2d] = 0x%08"PRIx32"UL\n", decKS_ctr ,decKS[decKS_ctr]); -} - -void aes128OTFDecrypt_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[%1d] = 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[%2d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]); - - SWord32 pt[4]; - - aes128OTFDecrypt(ct, xkey, pt); - - printf("aes128OTFDecrypt(ct, xkey, pt) ->\n"); - int pt_ctr; - for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr) - printf(" pt[%1d] = 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(); - - printf("=======================================\n"); - printf("** Driver run for aes128InvKeySchedule:\n"); - printf("=======================================\n"); - aes128InvKeySchedule_driver(); - - printf("===================================\n"); - printf("** Driver run for aes128OTFDecrypt:\n"); - printf("===================================\n"); - aes128OTFDecrypt_driver(); - - return 0; -} -== END: "aes128Lib_driver.c" ================== -== BEGIN: "Makefile" ================ -# Makefile for aes128Lib. Automatically generated by SBV. Do not edit! - -# include any user-defined .mk file in the current directory. --include *.mk - -CC?=gcc -CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer -AR?=ar -ARFLAGS?=cr - -all: aes128Lib.a aes128Lib_driver - -aes128Lib.a: aes128KeySchedule.o aes128BlockEncrypt.o aes128BlockDecrypt.o aes128InvKeySchedule.o aes128OTFDecrypt.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 $@ - -aes128InvKeySchedule.o: aes128InvKeySchedule.c aes128Lib.h - ${CC} ${CCFLAGS} -c $< -o $@ - -aes128OTFDecrypt.o: aes128OTFDecrypt.c aes128Lib.h - ${CC} ${CCFLAGS} -c $< -o $@ - -clean: - rm -f *.o - -veryclean: clean - rm -f aes128Lib.a aes128Lib_driver +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotl(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) << amount) | (((uint64_t) (SWord32) a) >> (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotr(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) >> amount) | (((uint64_t) (SWord32) a) << (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128KeySchedule(const SWord32 *sbv_input_0, + SWord32 *sbv_output_0, SWord32 *sbv_output_1) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s260 = sbv_bv_u32_rotl(s3, 8); + const SWord8 s261 = sbv_bv_extract_u32_31_24_u8(s260); + const SWord8 s264 = sbv_bv_extract_u32_23_16_u8(s260); + const SWord8 s267 = sbv_bv_extract_u32_15_8_u8(s260); + const SWord8 s269 = sbv_bv_extract_u32_7_0_u8(s260); + SWord8 s262; + SWord8 s263; + SWord8 s265; + SWord16 s266; + SWord8 s268; + SWord8 s270; + SWord16 s271; + SWord32 s272; + SWord32 s273; + SWord32 s274; + SWord32 s275; + SWord32 s276; + SWord32 s277; + SWord8 s278; + SWord8 s279; + SWord8 s280; + SWord8 s281; + SWord8 s282; + SWord16 s283; + SWord8 s284; + SWord8 s285; + SWord8 s286; + SWord8 s287; + SWord16 s288; + SWord32 s289; + SWord32 s290; + SWord32 s291; + SWord32 s292; + SWord32 s293; + SWord32 s294; + SWord8 s295; + SWord8 s296; + SWord8 s297; + SWord8 s298; + SWord8 s299; + SWord16 s300; + SWord8 s301; + SWord8 s302; + SWord8 s303; + SWord8 s304; + SWord16 s305; + SWord32 s306; + SWord32 s307; + SWord32 s308; + SWord32 s309; + SWord32 s310; + SWord32 s311; + SWord8 s312; + SWord8 s313; + SWord8 s314; + SWord8 s315; + SWord8 s316; + SWord16 s317; + SWord8 s318; + SWord8 s319; + SWord8 s320; + SWord8 s321; + SWord16 s322; + SWord32 s323; + SWord32 s324; + SWord32 s325; + SWord32 s326; + SWord32 s327; + SWord32 s328; + SWord8 s329; + SWord8 s330; + SWord8 s331; + SWord8 s332; + SWord8 s333; + SWord16 s334; + SWord8 s335; + SWord8 s336; + SWord8 s337; + SWord8 s338; + SWord16 s339; + SWord32 s340; + SWord32 s341; + SWord32 s342; + SWord32 s343; + SWord32 s344; + SWord32 s345; + SWord8 s346; + SWord8 s347; + SWord8 s348; + SWord8 s349; + SWord8 s350; + SWord16 s351; + SWord8 s352; + SWord8 s353; + SWord8 s354; + SWord8 s355; + SWord16 s356; + SWord32 s357; + SWord32 s358; + SWord32 s359; + SWord32 s360; + SWord32 s361; + SWord32 s362; + SWord8 s363; + SWord8 s364; + SWord8 s365; + SWord8 s366; + SWord8 s367; + SWord16 s368; + SWord8 s369; + SWord8 s370; + SWord8 s371; + SWord8 s372; + SWord16 s373; + SWord32 s374; + SWord32 s375; + SWord32 s376; + SWord32 s377; + SWord32 s378; + SWord32 s379; + SWord8 s380; + SWord8 s381; + SWord8 s382; + SWord8 s383; + SWord8 s384; + SWord16 s385; + SWord8 s386; + SWord8 s387; + SWord8 s388; + SWord8 s389; + SWord16 s390; + SWord32 s391; + SWord32 s392; + SWord32 s393; + SWord32 s394; + SWord32 s395; + SWord32 s396; + SWord8 s397; + SWord8 s398; + SWord8 s399; + SWord8 s400; + SWord8 s401; + SWord16 s402; + SWord8 s403; + SWord8 s404; + SWord8 s405; + SWord8 s406; + SWord16 s407; + SWord32 s408; + SWord32 s409; + SWord32 s410; + SWord32 s411; + SWord32 s412; + SWord32 s413; + SWord8 s414; + SWord8 s415; + SWord8 s416; + SWord8 s417; + SWord8 s418; + SWord16 s419; + SWord8 s420; + SWord8 s421; + SWord8 s422; + SWord8 s423; + SWord16 s424; + SWord32 s425; + SWord32 s426; + SWord32 s427; + SWord32 s428; + SWord32 s429; + SWord8 s430; + SWord8 s431; + SWord8 s432; + SWord8 s433; + SWord8 s434; + SWord8 s435; + SWord8 s436; + SWord8 s437; + SWord8 s438; + SWord8 s439; + SWord8 s440; + SWord8 s441; + SWord8 s442; + SWord8 s443; + SWord8 s444; + SWord8 s445; + SWord8 s446; + SWord8 s447; + SWord16 s448; + SWord8 s449; + SWord8 s450; + SWord8 s451; + SWord8 s452; + SWord8 s453; + SWord8 s454; + SWord8 s455; + SWord8 s456; + SWord8 s457; + SWord8 s458; + SWord8 s459; + SWord8 s460; + SWord8 s461; + SWord8 s462; + SWord16 s463; + SWord32 s464; + SWord8 s465; + SWord8 s466; + SWord8 s467; + SWord8 s468; + SWord8 s469; + SWord8 s470; + SWord8 s471; + SWord8 s472; + SWord8 s473; + SWord8 s474; + SWord8 s475; + SWord8 s476; + SWord8 s477; + SWord8 s478; + SWord8 s479; + SWord8 s480; + SWord8 s481; + SWord8 s482; + SWord16 s483; + SWord8 s484; + SWord8 s485; + SWord8 s486; + SWord8 s487; + SWord8 s488; + SWord8 s489; + SWord8 s490; + SWord8 s491; + SWord8 s492; + SWord8 s493; + SWord8 s494; + SWord8 s495; + SWord8 s496; + SWord8 s497; + SWord16 s498; + SWord32 s499; + SWord8 s500; + SWord8 s501; + SWord8 s502; + SWord8 s503; + SWord8 s504; + SWord8 s505; + SWord8 s506; + SWord8 s507; + SWord8 s508; + SWord8 s509; + SWord8 s510; + SWord8 s511; + SWord8 s512; + SWord8 s513; + SWord8 s514; + SWord8 s515; + SWord8 s516; + SWord8 s517; + SWord16 s518; + SWord8 s519; + SWord8 s520; + SWord8 s521; + SWord8 s522; + SWord8 s523; + SWord8 s524; + SWord8 s525; + SWord8 s526; + SWord8 s527; + SWord8 s528; + SWord8 s529; + SWord8 s530; + SWord8 s531; + SWord8 s532; + SWord16 s533; + SWord32 s534; + SWord8 s535; + SWord8 s536; + SWord8 s537; + SWord8 s538; + SWord8 s539; + SWord8 s540; + SWord8 s541; + SWord8 s542; + SWord8 s543; + SWord8 s544; + SWord8 s545; + SWord8 s546; + SWord8 s547; + SWord8 s548; + SWord8 s549; + SWord8 s550; + SWord8 s551; + SWord8 s552; + SWord16 s553; + SWord8 s554; + SWord8 s555; + SWord8 s556; + SWord8 s557; + SWord8 s558; + SWord8 s559; + SWord8 s560; + SWord8 s561; + SWord8 s562; + SWord8 s563; + SWord8 s564; + SWord8 s565; + SWord8 s566; + SWord8 s567; + SWord16 s568; + SWord32 s569; + SWord8 s570; + SWord8 s571; + SWord8 s572; + SWord8 s573; + SWord8 s574; + SWord8 s575; + SWord8 s576; + SWord8 s577; + SWord8 s578; + SWord8 s579; + SWord8 s580; + SWord8 s581; + SWord8 s582; + SWord8 s583; + SWord8 s584; + SWord8 s585; + SWord8 s586; + SWord8 s587; + SWord16 s588; + SWord8 s589; + SWord8 s590; + SWord8 s591; + SWord8 s592; + SWord8 s593; + SWord8 s594; + SWord8 s595; + SWord8 s596; + SWord8 s597; + SWord8 s598; + SWord8 s599; + SWord8 s600; + SWord8 s601; + SWord8 s602; + SWord16 s603; + SWord32 s604; + SWord8 s605; + SWord8 s606; + SWord8 s607; + SWord8 s608; + SWord8 s609; + SWord8 s610; + SWord8 s611; + SWord8 s612; + SWord8 s613; + SWord8 s614; + SWord8 s615; + SWord8 s616; + SWord8 s617; + SWord8 s618; + SWord8 s619; + SWord8 s620; + SWord8 s621; + SWord8 s622; + SWord16 s623; + SWord8 s624; + SWord8 s625; + SWord8 s626; + SWord8 s627; + SWord8 s628; + SWord8 s629; + SWord8 s630; + SWord8 s631; + SWord8 s632; + SWord8 s633; + SWord8 s634; + SWord8 s635; + SWord8 s636; + SWord8 s637; + SWord16 s638; + SWord32 s639; + SWord8 s640; + SWord8 s641; + SWord8 s642; + SWord8 s643; + SWord8 s644; + SWord8 s645; + SWord8 s646; + SWord8 s647; + SWord8 s648; + SWord8 s649; + SWord8 s650; + SWord8 s651; + SWord8 s652; + SWord8 s653; + SWord8 s654; + SWord8 s655; + SWord8 s656; + SWord8 s657; + SWord16 s658; + SWord8 s659; + SWord8 s660; + SWord8 s661; + SWord8 s662; + SWord8 s663; + SWord8 s664; + SWord8 s665; + SWord8 s666; + SWord8 s667; + SWord8 s668; + SWord8 s669; + SWord8 s670; + SWord8 s671; + SWord8 s672; + SWord16 s673; + SWord32 s674; + SWord8 s675; + SWord8 s676; + SWord8 s677; + SWord8 s678; + SWord8 s679; + SWord8 s680; + SWord8 s681; + SWord8 s682; + SWord8 s683; + SWord8 s684; + SWord8 s685; + SWord8 s686; + SWord8 s687; + SWord8 s688; + SWord8 s689; + SWord8 s690; + SWord8 s691; + SWord8 s692; + SWord16 s693; + SWord8 s694; + SWord8 s695; + SWord8 s696; + SWord8 s697; + SWord8 s698; + SWord8 s699; + SWord8 s700; + SWord8 s701; + SWord8 s702; + SWord8 s703; + SWord8 s704; + SWord8 s705; + SWord8 s706; + SWord8 s707; + SWord16 s708; + SWord32 s709; + SWord8 s710; + SWord8 s711; + SWord8 s712; + SWord8 s713; + SWord8 s714; + SWord8 s715; + SWord8 s716; + SWord8 s717; + SWord8 s718; + SWord8 s719; + SWord8 s720; + SWord8 s721; + SWord8 s722; + SWord8 s723; + SWord8 s724; + SWord8 s725; + SWord8 s726; + SWord8 s727; + SWord16 s728; + SWord8 s729; + SWord8 s730; + SWord8 s731; + SWord8 s732; + SWord8 s733; + SWord8 s734; + SWord8 s735; + SWord8 s736; + SWord8 s737; + SWord8 s738; + SWord8 s739; + SWord8 s740; + SWord8 s741; + SWord8 s742; + SWord16 s743; + SWord32 s744; + SWord8 s745; + SWord8 s746; + SWord8 s747; + SWord8 s748; + SWord8 s749; + SWord8 s750; + SWord8 s751; + SWord8 s752; + SWord8 s753; + SWord8 s754; + SWord8 s755; + SWord8 s756; + SWord8 s757; + SWord8 s758; + SWord8 s759; + SWord8 s760; + SWord8 s761; + SWord8 s762; + SWord16 s763; + SWord8 s764; + SWord8 s765; + SWord8 s766; + SWord8 s767; + SWord8 s768; + SWord8 s769; + SWord8 s770; + SWord8 s771; + SWord8 s772; + SWord8 s773; + SWord8 s774; + SWord8 s775; + SWord8 s776; + SWord8 s777; + SWord16 s778; + SWord32 s779; + SWord8 s780; + SWord8 s781; + SWord8 s782; + SWord8 s783; + SWord8 s784; + SWord8 s785; + SWord8 s786; + SWord8 s787; + SWord8 s788; + SWord8 s789; + SWord8 s790; + SWord8 s791; + SWord8 s792; + SWord8 s793; + SWord8 s794; + SWord8 s795; + SWord8 s796; + SWord8 s797; + SWord16 s798; + SWord8 s799; + SWord8 s800; + SWord8 s801; + SWord8 s802; + SWord8 s803; + SWord8 s804; + SWord8 s805; + SWord8 s806; + SWord8 s807; + SWord8 s808; + SWord8 s809; + SWord8 s810; + SWord8 s811; + SWord8 s812; + SWord16 s813; + SWord32 s814; + SWord8 s815; + SWord8 s816; + SWord8 s817; + SWord8 s818; + SWord8 s819; + SWord8 s820; + SWord8 s821; + SWord8 s822; + SWord8 s823; + SWord8 s824; + SWord8 s825; + SWord8 s826; + SWord8 s827; + SWord8 s828; + SWord8 s829; + SWord8 s830; + SWord8 s831; + SWord8 s832; + SWord16 s833; + SWord8 s834; + SWord8 s835; + SWord8 s836; + SWord8 s837; + SWord8 s838; + SWord8 s839; + SWord8 s840; + SWord8 s841; + SWord8 s842; + SWord8 s843; + SWord8 s844; + SWord8 s845; + SWord8 s846; + SWord8 s847; + SWord16 s848; + SWord32 s849; + SWord8 s850; + SWord8 s851; + SWord8 s852; + SWord8 s853; + SWord8 s854; + SWord8 s855; + SWord8 s856; + SWord8 s857; + SWord8 s858; + SWord8 s859; + SWord8 s860; + SWord8 s861; + SWord8 s862; + SWord8 s863; + SWord8 s864; + SWord8 s865; + SWord8 s866; + SWord8 s867; + SWord16 s868; + SWord8 s869; + SWord8 s870; + SWord8 s871; + SWord8 s872; + SWord8 s873; + SWord8 s874; + SWord8 s875; + SWord8 s876; + SWord8 s877; + SWord8 s878; + SWord8 s879; + SWord8 s880; + SWord8 s881; + SWord8 s882; + SWord16 s883; + SWord32 s884; + SWord8 s885; + SWord8 s886; + SWord8 s887; + SWord8 s888; + SWord8 s889; + SWord8 s890; + SWord8 s891; + SWord8 s892; + SWord8 s893; + SWord8 s894; + SWord8 s895; + SWord8 s896; + SWord8 s897; + SWord8 s898; + SWord8 s899; + SWord8 s900; + SWord8 s901; + SWord8 s902; + SWord16 s903; + SWord8 s904; + SWord8 s905; + SWord8 s906; + SWord8 s907; + SWord8 s908; + SWord8 s909; + SWord8 s910; + SWord8 s911; + SWord8 s912; + SWord8 s913; + SWord8 s914; + SWord8 s915; + SWord8 s916; + SWord8 s917; + SWord16 s918; + SWord32 s919; + SWord8 s920; + SWord8 s921; + SWord8 s922; + SWord8 s923; + SWord8 s924; + SWord8 s925; + SWord8 s926; + SWord8 s927; + SWord8 s928; + SWord8 s929; + SWord8 s930; + SWord8 s931; + SWord8 s932; + SWord8 s933; + SWord8 s934; + SWord8 s935; + SWord8 s936; + SWord8 s937; + SWord16 s938; + SWord8 s939; + SWord8 s940; + SWord8 s941; + SWord8 s942; + SWord8 s943; + SWord8 s944; + SWord8 s945; + SWord8 s946; + SWord8 s947; + SWord8 s948; + SWord8 s949; + SWord8 s950; + SWord8 s951; + SWord8 s952; + SWord16 s953; + SWord32 s954; + SWord8 s955; + SWord8 s956; + SWord8 s957; + SWord8 s958; + SWord8 s959; + SWord8 s960; + SWord8 s961; + SWord8 s962; + SWord8 s963; + SWord8 s964; + SWord8 s965; + SWord8 s966; + SWord8 s967; + SWord8 s968; + SWord8 s969; + SWord8 s970; + SWord8 s971; + SWord8 s972; + SWord16 s973; + SWord8 s974; + SWord8 s975; + SWord8 s976; + SWord8 s977; + SWord8 s978; + SWord8 s979; + SWord8 s980; + SWord8 s981; + SWord8 s982; + SWord8 s983; + SWord8 s984; + SWord8 s985; + SWord8 s986; + SWord8 s987; + SWord16 s988; + SWord32 s989; + SWord8 s990; + SWord8 s991; + SWord8 s992; + SWord8 s993; + SWord8 s994; + SWord8 s995; + SWord8 s996; + SWord8 s997; + SWord8 s998; + SWord8 s999; + SWord8 s1000; + SWord8 s1001; + SWord8 s1002; + SWord8 s1003; + SWord8 s1004; + SWord8 s1005; + SWord8 s1006; + SWord8 s1007; + SWord16 s1008; + SWord8 s1009; + SWord8 s1010; + SWord8 s1011; + SWord8 s1012; + SWord8 s1013; + SWord8 s1014; + SWord8 s1015; + SWord8 s1016; + SWord8 s1017; + SWord8 s1018; + SWord8 s1019; + SWord8 s1020; + SWord8 s1021; + SWord8 s1022; + SWord16 s1023; + SWord32 s1024; + SWord8 s1025; + SWord8 s1026; + SWord8 s1027; + SWord8 s1028; + SWord8 s1029; + SWord8 s1030; + SWord8 s1031; + SWord8 s1032; + SWord8 s1033; + SWord8 s1034; + SWord8 s1035; + SWord8 s1036; + SWord8 s1037; + SWord8 s1038; + SWord8 s1039; + SWord8 s1040; + SWord8 s1041; + SWord8 s1042; + SWord16 s1043; + SWord8 s1044; + SWord8 s1045; + SWord8 s1046; + SWord8 s1047; + SWord8 s1048; + SWord8 s1049; + SWord8 s1050; + SWord8 s1051; + SWord8 s1052; + SWord8 s1053; + SWord8 s1054; + SWord8 s1055; + SWord8 s1056; + SWord8 s1057; + SWord16 s1058; + SWord32 s1059; + SWord8 s1060; + SWord8 s1061; + SWord8 s1062; + SWord8 s1063; + SWord8 s1064; + SWord8 s1065; + SWord8 s1066; + SWord8 s1067; + SWord8 s1068; + SWord8 s1069; + SWord8 s1070; + SWord8 s1071; + SWord8 s1072; + SWord8 s1073; + SWord8 s1074; + SWord8 s1075; + SWord8 s1076; + SWord8 s1077; + SWord16 s1078; + SWord8 s1079; + SWord8 s1080; + SWord8 s1081; + SWord8 s1082; + SWord8 s1083; + SWord8 s1084; + SWord8 s1085; + SWord8 s1086; + SWord8 s1087; + SWord8 s1088; + SWord8 s1089; + SWord8 s1090; + SWord8 s1091; + SWord8 s1092; + SWord16 s1093; + SWord32 s1094; + SWord8 s1095; + SWord8 s1096; + SWord8 s1097; + SWord8 s1098; + SWord8 s1099; + SWord8 s1100; + SWord8 s1101; + SWord8 s1102; + SWord8 s1103; + SWord8 s1104; + SWord8 s1105; + SWord8 s1106; + SWord8 s1107; + SWord8 s1108; + SWord8 s1109; + SWord8 s1110; + SWord8 s1111; + SWord8 s1112; + SWord16 s1113; + SWord8 s1114; + SWord8 s1115; + SWord8 s1116; + SWord8 s1117; + SWord8 s1118; + SWord8 s1119; + SWord8 s1120; + SWord8 s1121; + SWord8 s1122; + SWord8 s1123; + SWord8 s1124; + SWord8 s1125; + SWord8 s1126; + SWord8 s1127; + SWord16 s1128; + SWord32 s1129; + SWord8 s1130; + SWord8 s1131; + SWord8 s1132; + SWord8 s1133; + SWord8 s1134; + SWord8 s1135; + SWord8 s1136; + SWord8 s1137; + SWord8 s1138; + SWord8 s1139; + SWord8 s1140; + SWord8 s1141; + SWord8 s1142; + SWord8 s1143; + SWord8 s1144; + SWord8 s1145; + SWord8 s1146; + SWord8 s1147; + SWord16 s1148; + SWord8 s1149; + SWord8 s1150; + SWord8 s1151; + SWord8 s1152; + SWord8 s1153; + SWord8 s1154; + SWord8 s1155; + SWord8 s1156; + SWord8 s1157; + SWord8 s1158; + SWord8 s1159; + SWord8 s1160; + SWord8 s1161; + SWord8 s1162; + SWord16 s1163; + SWord32 s1164; + SWord8 s1165; + SWord8 s1166; + SWord8 s1167; + SWord8 s1168; + SWord8 s1169; + SWord8 s1170; + SWord8 s1171; + SWord8 s1172; + SWord8 s1173; + SWord8 s1174; + SWord8 s1175; + SWord8 s1176; + SWord8 s1177; + SWord8 s1178; + SWord8 s1179; + SWord8 s1180; + SWord8 s1181; + SWord8 s1182; + SWord16 s1183; + SWord8 s1184; + SWord8 s1185; + SWord8 s1186; + SWord8 s1187; + SWord8 s1188; + SWord8 s1189; + SWord8 s1190; + SWord8 s1191; + SWord8 s1192; + SWord8 s1193; + SWord8 s1194; + SWord8 s1195; + SWord8 s1196; + SWord8 s1197; + SWord16 s1198; + SWord32 s1199; + SWord8 s1200; + SWord8 s1201; + SWord8 s1202; + SWord8 s1203; + SWord8 s1204; + SWord8 s1205; + SWord8 s1206; + SWord8 s1207; + SWord8 s1208; + SWord8 s1209; + SWord8 s1210; + SWord8 s1211; + SWord8 s1212; + SWord8 s1213; + SWord8 s1214; + SWord8 s1215; + SWord8 s1216; + SWord8 s1217; + SWord16 s1218; + SWord8 s1219; + SWord8 s1220; + SWord8 s1221; + SWord8 s1222; + SWord8 s1223; + SWord8 s1224; + SWord8 s1225; + SWord8 s1226; + SWord8 s1227; + SWord8 s1228; + SWord8 s1229; + SWord8 s1230; + SWord8 s1231; + SWord8 s1232; + SWord16 s1233; + SWord32 s1234; + SWord8 s1235; + SWord8 s1236; + SWord8 s1237; + SWord8 s1238; + SWord8 s1239; + SWord8 s1240; + SWord8 s1241; + SWord8 s1242; + SWord8 s1243; + SWord8 s1244; + SWord8 s1245; + SWord8 s1246; + SWord8 s1247; + SWord8 s1248; + SWord8 s1249; + SWord8 s1250; + SWord8 s1251; + SWord8 s1252; + SWord16 s1253; + SWord8 s1254; + SWord8 s1255; + SWord8 s1256; + SWord8 s1257; + SWord8 s1258; + SWord8 s1259; + SWord8 s1260; + SWord8 s1261; + SWord8 s1262; + SWord8 s1263; + SWord8 s1264; + SWord8 s1265; + SWord8 s1266; + SWord8 s1267; + SWord16 s1268; + SWord32 s1269; + SWord8 s1270; + SWord8 s1271; + SWord8 s1272; + SWord8 s1273; + SWord8 s1274; + SWord8 s1275; + SWord8 s1276; + SWord8 s1277; + SWord8 s1278; + SWord8 s1279; + SWord8 s1280; + SWord8 s1281; + SWord8 s1282; + SWord8 s1283; + SWord8 s1284; + SWord8 s1285; + SWord8 s1286; + SWord8 s1287; + SWord16 s1288; + SWord8 s1289; + SWord8 s1290; + SWord8 s1291; + SWord8 s1292; + SWord8 s1293; + SWord8 s1294; + SWord8 s1295; + SWord8 s1296; + SWord8 s1297; + SWord8 s1298; + SWord8 s1299; + SWord8 s1300; + SWord8 s1301; + SWord8 s1302; + SWord16 s1303; + SWord32 s1304; + SWord8 s1305; + SWord8 s1306; + SWord8 s1307; + SWord8 s1308; + SWord8 s1309; + SWord8 s1310; + SWord8 s1311; + SWord8 s1312; + SWord8 s1313; + SWord8 s1314; + SWord8 s1315; + SWord8 s1316; + SWord8 s1317; + SWord8 s1318; + SWord8 s1319; + SWord8 s1320; + SWord8 s1321; + SWord8 s1322; + SWord16 s1323; + SWord8 s1324; + SWord8 s1325; + SWord8 s1326; + SWord8 s1327; + SWord8 s1328; + SWord8 s1329; + SWord8 s1330; + SWord8 s1331; + SWord8 s1332; + SWord8 s1333; + SWord8 s1334; + SWord8 s1335; + SWord8 s1336; + SWord8 s1337; + SWord16 s1338; + SWord32 s1339; + SWord8 s1340; + SWord8 s1341; + SWord8 s1342; + SWord8 s1343; + SWord8 s1344; + SWord8 s1345; + SWord8 s1346; + SWord8 s1347; + SWord8 s1348; + SWord8 s1349; + SWord8 s1350; + SWord8 s1351; + SWord8 s1352; + SWord8 s1353; + SWord8 s1354; + SWord8 s1355; + SWord8 s1356; + SWord8 s1357; + SWord16 s1358; + SWord8 s1359; + SWord8 s1360; + SWord8 s1361; + SWord8 s1362; + SWord8 s1363; + SWord8 s1364; + SWord8 s1365; + SWord8 s1366; + SWord8 s1367; + SWord8 s1368; + SWord8 s1369; + SWord8 s1370; + SWord8 s1371; + SWord8 s1372; + SWord16 s1373; + SWord32 s1374; + SWord8 s1375; + SWord8 s1376; + SWord8 s1377; + SWord8 s1378; + SWord8 s1379; + SWord8 s1380; + SWord8 s1381; + SWord8 s1382; + SWord8 s1383; + SWord8 s1384; + SWord8 s1385; + SWord8 s1386; + SWord8 s1387; + SWord8 s1388; + SWord8 s1389; + SWord8 s1390; + SWord8 s1391; + SWord8 s1392; + SWord16 s1393; + SWord8 s1394; + SWord8 s1395; + SWord8 s1396; + SWord8 s1397; + SWord8 s1398; + SWord8 s1399; + SWord8 s1400; + SWord8 s1401; + SWord8 s1402; + SWord8 s1403; + SWord8 s1404; + SWord8 s1405; + SWord8 s1406; + SWord8 s1407; + SWord16 s1408; + SWord32 s1409; + SWord8 s1410; + SWord8 s1411; + SWord8 s1412; + SWord8 s1413; + SWord8 s1414; + SWord8 s1415; + SWord8 s1416; + SWord8 s1417; + SWord8 s1418; + SWord8 s1419; + SWord8 s1420; + SWord8 s1421; + SWord8 s1422; + SWord8 s1423; + SWord8 s1424; + SWord8 s1425; + SWord8 s1426; + SWord8 s1427; + SWord16 s1428; + SWord8 s1429; + SWord8 s1430; + SWord8 s1431; + SWord8 s1432; + SWord8 s1433; + SWord8 s1434; + SWord8 s1435; + SWord8 s1436; + SWord8 s1437; + SWord8 s1438; + SWord8 s1439; + SWord8 s1440; + SWord8 s1441; + SWord8 s1442; + SWord16 s1443; + SWord32 s1444; + SWord8 s1445; + SWord8 s1446; + SWord8 s1447; + SWord8 s1448; + SWord8 s1449; + SWord8 s1450; + SWord8 s1451; + SWord8 s1452; + SWord8 s1453; + SWord8 s1454; + SWord8 s1455; + SWord8 s1456; + SWord8 s1457; + SWord8 s1458; + SWord8 s1459; + SWord8 s1460; + SWord8 s1461; + SWord8 s1462; + SWord16 s1463; + SWord8 s1464; + SWord8 s1465; + SWord8 s1466; + SWord8 s1467; + SWord8 s1468; + SWord8 s1469; + SWord8 s1470; + SWord8 s1471; + SWord8 s1472; + SWord8 s1473; + SWord8 s1474; + SWord8 s1475; + SWord8 s1476; + SWord8 s1477; + SWord16 s1478; + SWord32 s1479; + SWord8 s1480; + SWord8 s1481; + SWord8 s1482; + SWord8 s1483; + SWord8 s1484; + SWord8 s1485; + SWord8 s1486; + SWord8 s1487; + SWord8 s1488; + SWord8 s1489; + SWord8 s1490; + SWord8 s1491; + SWord8 s1492; + SWord8 s1493; + SWord8 s1494; + SWord8 s1495; + SWord8 s1496; + SWord8 s1497; + SWord16 s1498; + SWord8 s1499; + SWord8 s1500; + SWord8 s1501; + SWord8 s1502; + SWord8 s1503; + SWord8 s1504; + SWord8 s1505; + SWord8 s1506; + SWord8 s1507; + SWord8 s1508; + SWord8 s1509; + SWord8 s1510; + SWord8 s1511; + SWord8 s1512; + SWord16 s1513; + SWord32 s1514; + SWord8 s1515; + SWord8 s1516; + SWord8 s1517; + SWord8 s1518; + SWord8 s1519; + SWord8 s1520; + SWord8 s1521; + SWord8 s1522; + SWord8 s1523; + SWord8 s1524; + SWord8 s1525; + SWord8 s1526; + SWord8 s1527; + SWord8 s1528; + SWord8 s1529; + SWord8 s1530; + SWord8 s1531; + SWord8 s1532; + SWord16 s1533; + SWord8 s1534; + SWord8 s1535; + SWord8 s1536; + SWord8 s1537; + SWord8 s1538; + SWord8 s1539; + SWord8 s1540; + SWord8 s1541; + SWord8 s1542; + SWord8 s1543; + SWord8 s1544; + SWord8 s1545; + SWord8 s1546; + SWord8 s1547; + SWord16 s1548; + SWord32 s1549; + SWord8 s1550; + SWord8 s1551; + SWord8 s1552; + SWord8 s1553; + SWord8 s1554; + SWord8 s1555; + SWord8 s1556; + SWord8 s1557; + SWord8 s1558; + SWord8 s1559; + SWord8 s1560; + SWord8 s1561; + SWord8 s1562; + SWord8 s1563; + SWord8 s1564; + SWord8 s1565; + SWord8 s1566; + SWord8 s1567; + SWord16 s1568; + SWord8 s1569; + SWord8 s1570; + SWord8 s1571; + SWord8 s1572; + SWord8 s1573; + SWord8 s1574; + SWord8 s1575; + SWord8 s1576; + SWord8 s1577; + SWord8 s1578; + SWord8 s1579; + SWord8 s1580; + SWord8 s1581; + SWord8 s1582; + SWord16 s1583; + SWord32 s1584; + SWord8 s1585; + SWord8 s1586; + SWord8 s1587; + SWord8 s1588; + SWord8 s1589; + SWord8 s1590; + SWord8 s1591; + SWord8 s1592; + SWord8 s1593; + SWord8 s1594; + SWord8 s1595; + SWord8 s1596; + SWord8 s1597; + SWord8 s1598; + SWord8 s1599; + SWord8 s1600; + SWord8 s1601; + SWord8 s1602; + SWord16 s1603; + SWord8 s1604; + SWord8 s1605; + SWord8 s1606; + SWord8 s1607; + SWord8 s1608; + SWord8 s1609; + SWord8 s1610; + SWord8 s1611; + SWord8 s1612; + SWord8 s1613; + SWord8 s1614; + SWord8 s1615; + SWord8 s1616; + SWord8 s1617; + SWord16 s1618; + SWord32 s1619; + SWord8 s1620; + SWord8 s1621; + SWord8 s1622; + SWord8 s1623; + SWord8 s1624; + SWord8 s1625; + SWord8 s1626; + SWord8 s1627; + SWord8 s1628; + SWord8 s1629; + SWord8 s1630; + SWord8 s1631; + SWord8 s1632; + SWord8 s1633; + SWord8 s1634; + SWord8 s1635; + SWord8 s1636; + SWord8 s1637; + SWord16 s1638; + SWord8 s1639; + SWord8 s1640; + SWord8 s1641; + SWord8 s1642; + SWord8 s1643; + SWord8 s1644; + SWord8 s1645; + SWord8 s1646; + SWord8 s1647; + SWord8 s1648; + SWord8 s1649; + SWord8 s1650; + SWord8 s1651; + SWord8 s1652; + SWord16 s1653; + SWord32 s1654; + SWord8 s1655; + SWord8 s1656; + SWord8 s1657; + SWord8 s1658; + SWord8 s1659; + SWord8 s1660; + SWord8 s1661; + SWord8 s1662; + SWord8 s1663; + SWord8 s1664; + SWord8 s1665; + SWord8 s1666; + SWord8 s1667; + SWord8 s1668; + SWord8 s1669; + SWord8 s1670; + SWord8 s1671; + SWord8 s1672; + SWord16 s1673; + SWord8 s1674; + SWord8 s1675; + SWord8 s1676; + SWord8 s1677; + SWord8 s1678; + SWord8 s1679; + SWord8 s1680; + SWord8 s1681; + SWord8 s1682; + SWord8 s1683; + SWord8 s1684; + SWord8 s1685; + SWord8 s1686; + SWord8 s1687; + SWord16 s1688; + SWord32 s1689; + 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 + }; + s262 = table0[s261]; + s263 = 1 ^ s262; + s265 = table0[s264]; + s266 = sbv_bv_join_u8_u8_u16(s263, s265); + s268 = table0[s267]; + s270 = table0[s269]; + s271 = sbv_bv_join_u8_u8_u16(s268, s270); + s272 = sbv_bv_join_u16_u16_u32(s266, s271); + s273 = s0 ^ s272; + s274 = s1 ^ s273; + s275 = s2 ^ s274; + s276 = s3 ^ s275; + s277 = sbv_bv_u32_rotl(s276, 8); + s278 = sbv_bv_extract_u32_31_24_u8(s277); + s279 = table0[s278]; + s280 = 2 ^ s279; + s281 = sbv_bv_extract_u32_23_16_u8(s277); + s282 = table0[s281]; + s283 = sbv_bv_join_u8_u8_u16(s280, s282); + s284 = sbv_bv_extract_u32_15_8_u8(s277); + s285 = table0[s284]; + s286 = sbv_bv_extract_u32_7_0_u8(s277); + s287 = table0[s286]; + s288 = sbv_bv_join_u8_u8_u16(s285, s287); + s289 = sbv_bv_join_u16_u16_u32(s283, s288); + s290 = s273 ^ s289; + s291 = s274 ^ s290; + s292 = s275 ^ s291; + s293 = s276 ^ s292; + s294 = sbv_bv_u32_rotl(s293, 8); + s295 = sbv_bv_extract_u32_31_24_u8(s294); + s296 = table0[s295]; + s297 = 4 ^ s296; + s298 = sbv_bv_extract_u32_23_16_u8(s294); + s299 = table0[s298]; + s300 = sbv_bv_join_u8_u8_u16(s297, s299); + s301 = sbv_bv_extract_u32_15_8_u8(s294); + s302 = table0[s301]; + s303 = sbv_bv_extract_u32_7_0_u8(s294); + s304 = table0[s303]; + s305 = sbv_bv_join_u8_u8_u16(s302, s304); + s306 = sbv_bv_join_u16_u16_u32(s300, s305); + s307 = s290 ^ s306; + s308 = s291 ^ s307; + s309 = s292 ^ s308; + s310 = s293 ^ s309; + s311 = sbv_bv_u32_rotl(s310, 8); + s312 = sbv_bv_extract_u32_31_24_u8(s311); + s313 = table0[s312]; + s314 = 8 ^ s313; + s315 = sbv_bv_extract_u32_23_16_u8(s311); + s316 = table0[s315]; + s317 = sbv_bv_join_u8_u8_u16(s314, s316); + s318 = sbv_bv_extract_u32_15_8_u8(s311); + s319 = table0[s318]; + s320 = sbv_bv_extract_u32_7_0_u8(s311); + s321 = table0[s320]; + s322 = sbv_bv_join_u8_u8_u16(s319, s321); + s323 = sbv_bv_join_u16_u16_u32(s317, s322); + s324 = s307 ^ s323; + s325 = s308 ^ s324; + s326 = s309 ^ s325; + s327 = s310 ^ s326; + s328 = sbv_bv_u32_rotl(s327, 8); + s329 = sbv_bv_extract_u32_31_24_u8(s328); + s330 = table0[s329]; + s331 = 16 ^ s330; + s332 = sbv_bv_extract_u32_23_16_u8(s328); + s333 = table0[s332]; + s334 = sbv_bv_join_u8_u8_u16(s331, s333); + s335 = sbv_bv_extract_u32_15_8_u8(s328); + s336 = table0[s335]; + s337 = sbv_bv_extract_u32_7_0_u8(s328); + s338 = table0[s337]; + s339 = sbv_bv_join_u8_u8_u16(s336, s338); + s340 = sbv_bv_join_u16_u16_u32(s334, s339); + s341 = s324 ^ s340; + s342 = s325 ^ s341; + s343 = s326 ^ s342; + s344 = s327 ^ s343; + s345 = sbv_bv_u32_rotl(s344, 8); + s346 = sbv_bv_extract_u32_31_24_u8(s345); + s347 = table0[s346]; + s348 = 32 ^ s347; + s349 = sbv_bv_extract_u32_23_16_u8(s345); + s350 = table0[s349]; + s351 = sbv_bv_join_u8_u8_u16(s348, s350); + s352 = sbv_bv_extract_u32_15_8_u8(s345); + s353 = table0[s352]; + s354 = sbv_bv_extract_u32_7_0_u8(s345); + s355 = table0[s354]; + s356 = sbv_bv_join_u8_u8_u16(s353, s355); + s357 = sbv_bv_join_u16_u16_u32(s351, s356); + s358 = s341 ^ s357; + s359 = s342 ^ s358; + s360 = s343 ^ s359; + s361 = s344 ^ s360; + s362 = sbv_bv_u32_rotl(s361, 8); + s363 = sbv_bv_extract_u32_31_24_u8(s362); + s364 = table0[s363]; + s365 = 64 ^ s364; + s366 = sbv_bv_extract_u32_23_16_u8(s362); + s367 = table0[s366]; + s368 = sbv_bv_join_u8_u8_u16(s365, s367); + s369 = sbv_bv_extract_u32_15_8_u8(s362); + s370 = table0[s369]; + s371 = sbv_bv_extract_u32_7_0_u8(s362); + s372 = table0[s371]; + s373 = sbv_bv_join_u8_u8_u16(s370, s372); + s374 = sbv_bv_join_u16_u16_u32(s368, s373); + s375 = s358 ^ s374; + s376 = s359 ^ s375; + s377 = s360 ^ s376; + s378 = s361 ^ s377; + s379 = sbv_bv_u32_rotl(s378, 8); + s380 = sbv_bv_extract_u32_31_24_u8(s379); + s381 = table0[s380]; + s382 = 128 ^ s381; + s383 = sbv_bv_extract_u32_23_16_u8(s379); + s384 = table0[s383]; + s385 = sbv_bv_join_u8_u8_u16(s382, s384); + s386 = sbv_bv_extract_u32_15_8_u8(s379); + s387 = table0[s386]; + s388 = sbv_bv_extract_u32_7_0_u8(s379); + s389 = table0[s388]; + s390 = sbv_bv_join_u8_u8_u16(s387, s389); + s391 = sbv_bv_join_u16_u16_u32(s385, s390); + s392 = s375 ^ s391; + s393 = s376 ^ s392; + s394 = s377 ^ s393; + s395 = s378 ^ s394; + s396 = sbv_bv_u32_rotl(s395, 8); + s397 = sbv_bv_extract_u32_31_24_u8(s396); + s398 = table0[s397]; + s399 = 27 ^ s398; + s400 = sbv_bv_extract_u32_23_16_u8(s396); + s401 = table0[s400]; + s402 = sbv_bv_join_u8_u8_u16(s399, s401); + s403 = sbv_bv_extract_u32_15_8_u8(s396); + s404 = table0[s403]; + s405 = sbv_bv_extract_u32_7_0_u8(s396); + s406 = table0[s405]; + s407 = sbv_bv_join_u8_u8_u16(s404, s406); + s408 = sbv_bv_join_u16_u16_u32(s402, s407); + s409 = s392 ^ s408; + s410 = s393 ^ s409; + s411 = s394 ^ s410; + s412 = s395 ^ s411; + s413 = sbv_bv_u32_rotl(s412, 8); + s414 = sbv_bv_extract_u32_31_24_u8(s413); + s415 = table0[s414]; + s416 = 54 ^ s415; + s417 = sbv_bv_extract_u32_23_16_u8(s413); + s418 = table0[s417]; + s419 = sbv_bv_join_u8_u8_u16(s416, s418); + s420 = sbv_bv_extract_u32_15_8_u8(s413); + s421 = table0[s420]; + s422 = sbv_bv_extract_u32_7_0_u8(s413); + s423 = table0[s422]; + s424 = sbv_bv_join_u8_u8_u16(s421, s423); + s425 = sbv_bv_join_u16_u16_u32(s419, s424); + s426 = s409 ^ s425; + s427 = s410 ^ s426; + s428 = s411 ^ s427; + s429 = s412 ^ s428; + s430 = sbv_bv_extract_u32_31_24_u8(s409); + 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 + }; + s431 = table1[s430]; + s432 = sbv_bv_extract_u32_23_16_u8(s409); + 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 + }; + s433 = table2[s432]; + s434 = sbv_bv_extract_u32_15_8_u8(s409); + 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 + }; + s435 = table3[s434]; + s436 = sbv_bv_extract_u32_7_0_u8(s409); + 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 + }; + s437 = table4[s436]; + s438 = s435 ^ s437; + s439 = s433 ^ s438; + s440 = s431 ^ s439; + s441 = table4[s430]; + s442 = table1[s432]; + s443 = table2[s434]; + s444 = table3[s436]; + s445 = s443 ^ s444; + s446 = s442 ^ s445; + s447 = s441 ^ s446; + s448 = sbv_bv_join_u8_u8_u16(s440, s447); + s449 = table3[s430]; + s450 = table4[s432]; + s451 = table1[s434]; + s452 = table2[s436]; + s453 = s451 ^ s452; + s454 = s450 ^ s453; + s455 = s449 ^ s454; + s456 = table2[s430]; + s457 = table3[s432]; + s458 = table4[s434]; + s459 = table1[s436]; + s460 = s458 ^ s459; + s461 = s457 ^ s460; + s462 = s456 ^ s461; + s463 = sbv_bv_join_u8_u8_u16(s455, s462); + s464 = sbv_bv_join_u16_u16_u32(s448, s463); + s465 = sbv_bv_extract_u32_31_24_u8(s410); + s466 = table1[s465]; + s467 = sbv_bv_extract_u32_23_16_u8(s410); + s468 = table2[s467]; + s469 = sbv_bv_extract_u32_15_8_u8(s410); + s470 = table3[s469]; + s471 = sbv_bv_extract_u32_7_0_u8(s410); + s472 = table4[s471]; + s473 = s470 ^ s472; + s474 = s468 ^ s473; + s475 = s466 ^ s474; + s476 = table4[s465]; + s477 = table1[s467]; + s478 = table2[s469]; + s479 = table3[s471]; + s480 = s478 ^ s479; + s481 = s477 ^ s480; + s482 = s476 ^ s481; + s483 = sbv_bv_join_u8_u8_u16(s475, s482); + s484 = table3[s465]; + s485 = table4[s467]; + s486 = table1[s469]; + s487 = table2[s471]; + s488 = s486 ^ s487; + s489 = s485 ^ s488; + s490 = s484 ^ s489; + s491 = table2[s465]; + s492 = table3[s467]; + s493 = table4[s469]; + s494 = table1[s471]; + s495 = s493 ^ s494; + s496 = s492 ^ s495; + s497 = s491 ^ s496; + s498 = sbv_bv_join_u8_u8_u16(s490, s497); + s499 = sbv_bv_join_u16_u16_u32(s483, s498); + s500 = sbv_bv_extract_u32_31_24_u8(s411); + s501 = table1[s500]; + s502 = sbv_bv_extract_u32_23_16_u8(s411); + s503 = table2[s502]; + s504 = sbv_bv_extract_u32_15_8_u8(s411); + s505 = table3[s504]; + s506 = sbv_bv_extract_u32_7_0_u8(s411); + s507 = table4[s506]; + s508 = s505 ^ s507; + s509 = s503 ^ s508; + s510 = s501 ^ s509; + s511 = table4[s500]; + s512 = table1[s502]; + s513 = table2[s504]; + s514 = table3[s506]; + s515 = s513 ^ s514; + s516 = s512 ^ s515; + s517 = s511 ^ s516; + s518 = sbv_bv_join_u8_u8_u16(s510, s517); + s519 = table3[s500]; + s520 = table4[s502]; + s521 = table1[s504]; + s522 = table2[s506]; + s523 = s521 ^ s522; + s524 = s520 ^ s523; + s525 = s519 ^ s524; + s526 = table2[s500]; + s527 = table3[s502]; + s528 = table4[s504]; + s529 = table1[s506]; + s530 = s528 ^ s529; + s531 = s527 ^ s530; + s532 = s526 ^ s531; + s533 = sbv_bv_join_u8_u8_u16(s525, s532); + s534 = sbv_bv_join_u16_u16_u32(s518, s533); + s535 = sbv_bv_extract_u32_31_24_u8(s412); + s536 = table1[s535]; + s537 = sbv_bv_extract_u32_23_16_u8(s412); + s538 = table2[s537]; + s539 = sbv_bv_extract_u32_15_8_u8(s412); + s540 = table3[s539]; + s541 = sbv_bv_extract_u32_7_0_u8(s412); + s542 = table4[s541]; + s543 = s540 ^ s542; + s544 = s538 ^ s543; + s545 = s536 ^ s544; + s546 = table4[s535]; + s547 = table1[s537]; + s548 = table2[s539]; + s549 = table3[s541]; + s550 = s548 ^ s549; + s551 = s547 ^ s550; + s552 = s546 ^ s551; + s553 = sbv_bv_join_u8_u8_u16(s545, s552); + s554 = table3[s535]; + s555 = table4[s537]; + s556 = table1[s539]; + s557 = table2[s541]; + s558 = s556 ^ s557; + s559 = s555 ^ s558; + s560 = s554 ^ s559; + s561 = table2[s535]; + s562 = table3[s537]; + s563 = table4[s539]; + s564 = table1[s541]; + s565 = s563 ^ s564; + s566 = s562 ^ s565; + s567 = s561 ^ s566; + s568 = sbv_bv_join_u8_u8_u16(s560, s567); + s569 = sbv_bv_join_u16_u16_u32(s553, s568); + s570 = sbv_bv_extract_u32_31_24_u8(s392); + s571 = table1[s570]; + s572 = sbv_bv_extract_u32_23_16_u8(s392); + s573 = table2[s572]; + s574 = sbv_bv_extract_u32_15_8_u8(s392); + s575 = table3[s574]; + s576 = sbv_bv_extract_u32_7_0_u8(s392); + s577 = table4[s576]; + s578 = s575 ^ s577; + s579 = s573 ^ s578; + s580 = s571 ^ s579; + s581 = table4[s570]; + s582 = table1[s572]; + s583 = table2[s574]; + s584 = table3[s576]; + s585 = s583 ^ s584; + s586 = s582 ^ s585; + s587 = s581 ^ s586; + s588 = sbv_bv_join_u8_u8_u16(s580, s587); + s589 = table3[s570]; + s590 = table4[s572]; + s591 = table1[s574]; + s592 = table2[s576]; + s593 = s591 ^ s592; + s594 = s590 ^ s593; + s595 = s589 ^ s594; + s596 = table2[s570]; + s597 = table3[s572]; + s598 = table4[s574]; + s599 = table1[s576]; + s600 = s598 ^ s599; + s601 = s597 ^ s600; + s602 = s596 ^ s601; + s603 = sbv_bv_join_u8_u8_u16(s595, s602); + s604 = sbv_bv_join_u16_u16_u32(s588, s603); + s605 = sbv_bv_extract_u32_31_24_u8(s393); + s606 = table1[s605]; + s607 = sbv_bv_extract_u32_23_16_u8(s393); + s608 = table2[s607]; + s609 = sbv_bv_extract_u32_15_8_u8(s393); + s610 = table3[s609]; + s611 = sbv_bv_extract_u32_7_0_u8(s393); + s612 = table4[s611]; + s613 = s610 ^ s612; + s614 = s608 ^ s613; + s615 = s606 ^ s614; + s616 = table4[s605]; + s617 = table1[s607]; + s618 = table2[s609]; + s619 = table3[s611]; + s620 = s618 ^ s619; + s621 = s617 ^ s620; + s622 = s616 ^ s621; + s623 = sbv_bv_join_u8_u8_u16(s615, s622); + s624 = table3[s605]; + s625 = table4[s607]; + s626 = table1[s609]; + s627 = table2[s611]; + s628 = s626 ^ s627; + s629 = s625 ^ s628; + s630 = s624 ^ s629; + s631 = table2[s605]; + s632 = table3[s607]; + s633 = table4[s609]; + s634 = table1[s611]; + s635 = s633 ^ s634; + s636 = s632 ^ s635; + s637 = s631 ^ s636; + s638 = sbv_bv_join_u8_u8_u16(s630, s637); + s639 = sbv_bv_join_u16_u16_u32(s623, s638); + s640 = sbv_bv_extract_u32_31_24_u8(s394); + s641 = table1[s640]; + s642 = sbv_bv_extract_u32_23_16_u8(s394); + s643 = table2[s642]; + s644 = sbv_bv_extract_u32_15_8_u8(s394); + s645 = table3[s644]; + s646 = sbv_bv_extract_u32_7_0_u8(s394); + s647 = table4[s646]; + s648 = s645 ^ s647; + s649 = s643 ^ s648; + s650 = s641 ^ s649; + s651 = table4[s640]; + s652 = table1[s642]; + s653 = table2[s644]; + s654 = table3[s646]; + s655 = s653 ^ s654; + s656 = s652 ^ s655; + s657 = s651 ^ s656; + s658 = sbv_bv_join_u8_u8_u16(s650, s657); + s659 = table3[s640]; + s660 = table4[s642]; + s661 = table1[s644]; + s662 = table2[s646]; + s663 = s661 ^ s662; + s664 = s660 ^ s663; + s665 = s659 ^ s664; + s666 = table2[s640]; + s667 = table3[s642]; + s668 = table4[s644]; + s669 = table1[s646]; + s670 = s668 ^ s669; + s671 = s667 ^ s670; + s672 = s666 ^ s671; + s673 = sbv_bv_join_u8_u8_u16(s665, s672); + s674 = sbv_bv_join_u16_u16_u32(s658, s673); + s675 = sbv_bv_extract_u32_31_24_u8(s395); + s676 = table1[s675]; + s677 = sbv_bv_extract_u32_23_16_u8(s395); + s678 = table2[s677]; + s679 = sbv_bv_extract_u32_15_8_u8(s395); + s680 = table3[s679]; + s681 = sbv_bv_extract_u32_7_0_u8(s395); + s682 = table4[s681]; + s683 = s680 ^ s682; + s684 = s678 ^ s683; + s685 = s676 ^ s684; + s686 = table4[s675]; + s687 = table1[s677]; + s688 = table2[s679]; + s689 = table3[s681]; + s690 = s688 ^ s689; + s691 = s687 ^ s690; + s692 = s686 ^ s691; + s693 = sbv_bv_join_u8_u8_u16(s685, s692); + s694 = table3[s675]; + s695 = table4[s677]; + s696 = table1[s679]; + s697 = table2[s681]; + s698 = s696 ^ s697; + s699 = s695 ^ s698; + s700 = s694 ^ s699; + s701 = table2[s675]; + s702 = table3[s677]; + s703 = table4[s679]; + s704 = table1[s681]; + s705 = s703 ^ s704; + s706 = s702 ^ s705; + s707 = s701 ^ s706; + s708 = sbv_bv_join_u8_u8_u16(s700, s707); + s709 = sbv_bv_join_u16_u16_u32(s693, s708); + s710 = sbv_bv_extract_u32_31_24_u8(s375); + s711 = table1[s710]; + s712 = sbv_bv_extract_u32_23_16_u8(s375); + s713 = table2[s712]; + s714 = sbv_bv_extract_u32_15_8_u8(s375); + s715 = table3[s714]; + s716 = sbv_bv_extract_u32_7_0_u8(s375); + s717 = table4[s716]; + s718 = s715 ^ s717; + s719 = s713 ^ s718; + s720 = s711 ^ s719; + s721 = table4[s710]; + s722 = table1[s712]; + s723 = table2[s714]; + s724 = table3[s716]; + s725 = s723 ^ s724; + s726 = s722 ^ s725; + s727 = s721 ^ s726; + s728 = sbv_bv_join_u8_u8_u16(s720, s727); + s729 = table3[s710]; + s730 = table4[s712]; + s731 = table1[s714]; + s732 = table2[s716]; + s733 = s731 ^ s732; + s734 = s730 ^ s733; + s735 = s729 ^ s734; + s736 = table2[s710]; + s737 = table3[s712]; + s738 = table4[s714]; + s739 = table1[s716]; + s740 = s738 ^ s739; + s741 = s737 ^ s740; + s742 = s736 ^ s741; + s743 = sbv_bv_join_u8_u8_u16(s735, s742); + s744 = sbv_bv_join_u16_u16_u32(s728, s743); + s745 = sbv_bv_extract_u32_31_24_u8(s376); + s746 = table1[s745]; + s747 = sbv_bv_extract_u32_23_16_u8(s376); + s748 = table2[s747]; + s749 = sbv_bv_extract_u32_15_8_u8(s376); + s750 = table3[s749]; + s751 = sbv_bv_extract_u32_7_0_u8(s376); + s752 = table4[s751]; + s753 = s750 ^ s752; + s754 = s748 ^ s753; + s755 = s746 ^ s754; + s756 = table4[s745]; + s757 = table1[s747]; + s758 = table2[s749]; + s759 = table3[s751]; + s760 = s758 ^ s759; + s761 = s757 ^ s760; + s762 = s756 ^ s761; + s763 = sbv_bv_join_u8_u8_u16(s755, s762); + s764 = table3[s745]; + s765 = table4[s747]; + s766 = table1[s749]; + s767 = table2[s751]; + s768 = s766 ^ s767; + s769 = s765 ^ s768; + s770 = s764 ^ s769; + s771 = table2[s745]; + s772 = table3[s747]; + s773 = table4[s749]; + s774 = table1[s751]; + s775 = s773 ^ s774; + s776 = s772 ^ s775; + s777 = s771 ^ s776; + s778 = sbv_bv_join_u8_u8_u16(s770, s777); + s779 = sbv_bv_join_u16_u16_u32(s763, s778); + s780 = sbv_bv_extract_u32_31_24_u8(s377); + s781 = table1[s780]; + s782 = sbv_bv_extract_u32_23_16_u8(s377); + s783 = table2[s782]; + s784 = sbv_bv_extract_u32_15_8_u8(s377); + s785 = table3[s784]; + s786 = sbv_bv_extract_u32_7_0_u8(s377); + s787 = table4[s786]; + s788 = s785 ^ s787; + s789 = s783 ^ s788; + s790 = s781 ^ s789; + s791 = table4[s780]; + s792 = table1[s782]; + s793 = table2[s784]; + s794 = table3[s786]; + s795 = s793 ^ s794; + s796 = s792 ^ s795; + s797 = s791 ^ s796; + s798 = sbv_bv_join_u8_u8_u16(s790, s797); + s799 = table3[s780]; + s800 = table4[s782]; + s801 = table1[s784]; + s802 = table2[s786]; + s803 = s801 ^ s802; + s804 = s800 ^ s803; + s805 = s799 ^ s804; + s806 = table2[s780]; + s807 = table3[s782]; + s808 = table4[s784]; + s809 = table1[s786]; + s810 = s808 ^ s809; + s811 = s807 ^ s810; + s812 = s806 ^ s811; + s813 = sbv_bv_join_u8_u8_u16(s805, s812); + s814 = sbv_bv_join_u16_u16_u32(s798, s813); + s815 = sbv_bv_extract_u32_31_24_u8(s378); + s816 = table1[s815]; + s817 = sbv_bv_extract_u32_23_16_u8(s378); + s818 = table2[s817]; + s819 = sbv_bv_extract_u32_15_8_u8(s378); + s820 = table3[s819]; + s821 = sbv_bv_extract_u32_7_0_u8(s378); + s822 = table4[s821]; + s823 = s820 ^ s822; + s824 = s818 ^ s823; + s825 = s816 ^ s824; + s826 = table4[s815]; + s827 = table1[s817]; + s828 = table2[s819]; + s829 = table3[s821]; + s830 = s828 ^ s829; + s831 = s827 ^ s830; + s832 = s826 ^ s831; + s833 = sbv_bv_join_u8_u8_u16(s825, s832); + s834 = table3[s815]; + s835 = table4[s817]; + s836 = table1[s819]; + s837 = table2[s821]; + s838 = s836 ^ s837; + s839 = s835 ^ s838; + s840 = s834 ^ s839; + s841 = table2[s815]; + s842 = table3[s817]; + s843 = table4[s819]; + s844 = table1[s821]; + s845 = s843 ^ s844; + s846 = s842 ^ s845; + s847 = s841 ^ s846; + s848 = sbv_bv_join_u8_u8_u16(s840, s847); + s849 = sbv_bv_join_u16_u16_u32(s833, s848); + s850 = sbv_bv_extract_u32_31_24_u8(s358); + s851 = table1[s850]; + s852 = sbv_bv_extract_u32_23_16_u8(s358); + s853 = table2[s852]; + s854 = sbv_bv_extract_u32_15_8_u8(s358); + s855 = table3[s854]; + s856 = sbv_bv_extract_u32_7_0_u8(s358); + s857 = table4[s856]; + s858 = s855 ^ s857; + s859 = s853 ^ s858; + s860 = s851 ^ s859; + s861 = table4[s850]; + s862 = table1[s852]; + s863 = table2[s854]; + s864 = table3[s856]; + s865 = s863 ^ s864; + s866 = s862 ^ s865; + s867 = s861 ^ s866; + s868 = sbv_bv_join_u8_u8_u16(s860, s867); + s869 = table3[s850]; + s870 = table4[s852]; + s871 = table1[s854]; + s872 = table2[s856]; + s873 = s871 ^ s872; + s874 = s870 ^ s873; + s875 = s869 ^ s874; + s876 = table2[s850]; + s877 = table3[s852]; + s878 = table4[s854]; + s879 = table1[s856]; + s880 = s878 ^ s879; + s881 = s877 ^ s880; + s882 = s876 ^ s881; + s883 = sbv_bv_join_u8_u8_u16(s875, s882); + s884 = sbv_bv_join_u16_u16_u32(s868, s883); + s885 = sbv_bv_extract_u32_31_24_u8(s359); + s886 = table1[s885]; + s887 = sbv_bv_extract_u32_23_16_u8(s359); + s888 = table2[s887]; + s889 = sbv_bv_extract_u32_15_8_u8(s359); + s890 = table3[s889]; + s891 = sbv_bv_extract_u32_7_0_u8(s359); + s892 = table4[s891]; + s893 = s890 ^ s892; + s894 = s888 ^ s893; + s895 = s886 ^ s894; + s896 = table4[s885]; + s897 = table1[s887]; + s898 = table2[s889]; + s899 = table3[s891]; + s900 = s898 ^ s899; + s901 = s897 ^ s900; + s902 = s896 ^ s901; + s903 = sbv_bv_join_u8_u8_u16(s895, s902); + s904 = table3[s885]; + s905 = table4[s887]; + s906 = table1[s889]; + s907 = table2[s891]; + s908 = s906 ^ s907; + s909 = s905 ^ s908; + s910 = s904 ^ s909; + s911 = table2[s885]; + s912 = table3[s887]; + s913 = table4[s889]; + s914 = table1[s891]; + s915 = s913 ^ s914; + s916 = s912 ^ s915; + s917 = s911 ^ s916; + s918 = sbv_bv_join_u8_u8_u16(s910, s917); + s919 = sbv_bv_join_u16_u16_u32(s903, s918); + s920 = sbv_bv_extract_u32_31_24_u8(s360); + s921 = table1[s920]; + s922 = sbv_bv_extract_u32_23_16_u8(s360); + s923 = table2[s922]; + s924 = sbv_bv_extract_u32_15_8_u8(s360); + s925 = table3[s924]; + s926 = sbv_bv_extract_u32_7_0_u8(s360); + s927 = table4[s926]; + s928 = s925 ^ s927; + s929 = s923 ^ s928; + s930 = s921 ^ s929; + s931 = table4[s920]; + s932 = table1[s922]; + s933 = table2[s924]; + s934 = table3[s926]; + s935 = s933 ^ s934; + s936 = s932 ^ s935; + s937 = s931 ^ s936; + s938 = sbv_bv_join_u8_u8_u16(s930, s937); + s939 = table3[s920]; + s940 = table4[s922]; + s941 = table1[s924]; + s942 = table2[s926]; + s943 = s941 ^ s942; + s944 = s940 ^ s943; + s945 = s939 ^ s944; + s946 = table2[s920]; + s947 = table3[s922]; + s948 = table4[s924]; + s949 = table1[s926]; + s950 = s948 ^ s949; + s951 = s947 ^ s950; + s952 = s946 ^ s951; + s953 = sbv_bv_join_u8_u8_u16(s945, s952); + s954 = sbv_bv_join_u16_u16_u32(s938, s953); + s955 = sbv_bv_extract_u32_31_24_u8(s361); + s956 = table1[s955]; + s957 = sbv_bv_extract_u32_23_16_u8(s361); + s958 = table2[s957]; + s959 = sbv_bv_extract_u32_15_8_u8(s361); + s960 = table3[s959]; + s961 = sbv_bv_extract_u32_7_0_u8(s361); + s962 = table4[s961]; + s963 = s960 ^ s962; + s964 = s958 ^ s963; + s965 = s956 ^ s964; + s966 = table4[s955]; + s967 = table1[s957]; + s968 = table2[s959]; + s969 = table3[s961]; + s970 = s968 ^ s969; + s971 = s967 ^ s970; + s972 = s966 ^ s971; + s973 = sbv_bv_join_u8_u8_u16(s965, s972); + s974 = table3[s955]; + s975 = table4[s957]; + s976 = table1[s959]; + s977 = table2[s961]; + s978 = s976 ^ s977; + s979 = s975 ^ s978; + s980 = s974 ^ s979; + s981 = table2[s955]; + s982 = table3[s957]; + s983 = table4[s959]; + s984 = table1[s961]; + s985 = s983 ^ s984; + s986 = s982 ^ s985; + s987 = s981 ^ s986; + s988 = sbv_bv_join_u8_u8_u16(s980, s987); + s989 = sbv_bv_join_u16_u16_u32(s973, s988); + s990 = sbv_bv_extract_u32_31_24_u8(s341); + s991 = table1[s990]; + s992 = sbv_bv_extract_u32_23_16_u8(s341); + s993 = table2[s992]; + s994 = sbv_bv_extract_u32_15_8_u8(s341); + s995 = table3[s994]; + s996 = sbv_bv_extract_u32_7_0_u8(s341); + s997 = table4[s996]; + s998 = s995 ^ s997; + s999 = s993 ^ s998; + s1000 = s991 ^ s999; + s1001 = table4[s990]; + s1002 = table1[s992]; + s1003 = table2[s994]; + s1004 = table3[s996]; + s1005 = s1003 ^ s1004; + s1006 = s1002 ^ s1005; + s1007 = s1001 ^ s1006; + s1008 = sbv_bv_join_u8_u8_u16(s1000, s1007); + s1009 = table3[s990]; + s1010 = table4[s992]; + s1011 = table1[s994]; + s1012 = table2[s996]; + s1013 = s1011 ^ s1012; + s1014 = s1010 ^ s1013; + s1015 = s1009 ^ s1014; + s1016 = table2[s990]; + s1017 = table3[s992]; + s1018 = table4[s994]; + s1019 = table1[s996]; + s1020 = s1018 ^ s1019; + s1021 = s1017 ^ s1020; + s1022 = s1016 ^ s1021; + s1023 = sbv_bv_join_u8_u8_u16(s1015, s1022); + s1024 = sbv_bv_join_u16_u16_u32(s1008, s1023); + s1025 = sbv_bv_extract_u32_31_24_u8(s342); + s1026 = table1[s1025]; + s1027 = sbv_bv_extract_u32_23_16_u8(s342); + s1028 = table2[s1027]; + s1029 = sbv_bv_extract_u32_15_8_u8(s342); + s1030 = table3[s1029]; + s1031 = sbv_bv_extract_u32_7_0_u8(s342); + s1032 = table4[s1031]; + s1033 = s1030 ^ s1032; + s1034 = s1028 ^ s1033; + s1035 = s1026 ^ s1034; + s1036 = table4[s1025]; + s1037 = table1[s1027]; + s1038 = table2[s1029]; + s1039 = table3[s1031]; + s1040 = s1038 ^ s1039; + s1041 = s1037 ^ s1040; + s1042 = s1036 ^ s1041; + s1043 = sbv_bv_join_u8_u8_u16(s1035, s1042); + s1044 = table3[s1025]; + s1045 = table4[s1027]; + s1046 = table1[s1029]; + s1047 = table2[s1031]; + s1048 = s1046 ^ s1047; + s1049 = s1045 ^ s1048; + s1050 = s1044 ^ s1049; + s1051 = table2[s1025]; + s1052 = table3[s1027]; + s1053 = table4[s1029]; + s1054 = table1[s1031]; + s1055 = s1053 ^ s1054; + s1056 = s1052 ^ s1055; + s1057 = s1051 ^ s1056; + s1058 = sbv_bv_join_u8_u8_u16(s1050, s1057); + s1059 = sbv_bv_join_u16_u16_u32(s1043, s1058); + s1060 = sbv_bv_extract_u32_31_24_u8(s343); + s1061 = table1[s1060]; + s1062 = sbv_bv_extract_u32_23_16_u8(s343); + s1063 = table2[s1062]; + s1064 = sbv_bv_extract_u32_15_8_u8(s343); + s1065 = table3[s1064]; + s1066 = sbv_bv_extract_u32_7_0_u8(s343); + s1067 = table4[s1066]; + s1068 = s1065 ^ s1067; + s1069 = s1063 ^ s1068; + s1070 = s1061 ^ s1069; + s1071 = table4[s1060]; + s1072 = table1[s1062]; + s1073 = table2[s1064]; + s1074 = table3[s1066]; + s1075 = s1073 ^ s1074; + s1076 = s1072 ^ s1075; + s1077 = s1071 ^ s1076; + s1078 = sbv_bv_join_u8_u8_u16(s1070, s1077); + s1079 = table3[s1060]; + s1080 = table4[s1062]; + s1081 = table1[s1064]; + s1082 = table2[s1066]; + s1083 = s1081 ^ s1082; + s1084 = s1080 ^ s1083; + s1085 = s1079 ^ s1084; + s1086 = table2[s1060]; + s1087 = table3[s1062]; + s1088 = table4[s1064]; + s1089 = table1[s1066]; + s1090 = s1088 ^ s1089; + s1091 = s1087 ^ s1090; + s1092 = s1086 ^ s1091; + s1093 = sbv_bv_join_u8_u8_u16(s1085, s1092); + s1094 = sbv_bv_join_u16_u16_u32(s1078, s1093); + s1095 = sbv_bv_extract_u32_31_24_u8(s344); + s1096 = table1[s1095]; + s1097 = sbv_bv_extract_u32_23_16_u8(s344); + s1098 = table2[s1097]; + s1099 = sbv_bv_extract_u32_15_8_u8(s344); + s1100 = table3[s1099]; + s1101 = sbv_bv_extract_u32_7_0_u8(s344); + s1102 = table4[s1101]; + s1103 = s1100 ^ s1102; + s1104 = s1098 ^ s1103; + s1105 = s1096 ^ s1104; + s1106 = table4[s1095]; + s1107 = table1[s1097]; + s1108 = table2[s1099]; + s1109 = table3[s1101]; + s1110 = s1108 ^ s1109; + s1111 = s1107 ^ s1110; + s1112 = s1106 ^ s1111; + s1113 = sbv_bv_join_u8_u8_u16(s1105, s1112); + s1114 = table3[s1095]; + s1115 = table4[s1097]; + s1116 = table1[s1099]; + s1117 = table2[s1101]; + s1118 = s1116 ^ s1117; + s1119 = s1115 ^ s1118; + s1120 = s1114 ^ s1119; + s1121 = table2[s1095]; + s1122 = table3[s1097]; + s1123 = table4[s1099]; + s1124 = table1[s1101]; + s1125 = s1123 ^ s1124; + s1126 = s1122 ^ s1125; + s1127 = s1121 ^ s1126; + s1128 = sbv_bv_join_u8_u8_u16(s1120, s1127); + s1129 = sbv_bv_join_u16_u16_u32(s1113, s1128); + s1130 = sbv_bv_extract_u32_31_24_u8(s324); + s1131 = table1[s1130]; + s1132 = sbv_bv_extract_u32_23_16_u8(s324); + s1133 = table2[s1132]; + s1134 = sbv_bv_extract_u32_15_8_u8(s324); + s1135 = table3[s1134]; + s1136 = sbv_bv_extract_u32_7_0_u8(s324); + s1137 = table4[s1136]; + s1138 = s1135 ^ s1137; + s1139 = s1133 ^ s1138; + s1140 = s1131 ^ s1139; + s1141 = table4[s1130]; + s1142 = table1[s1132]; + s1143 = table2[s1134]; + s1144 = table3[s1136]; + s1145 = s1143 ^ s1144; + s1146 = s1142 ^ s1145; + s1147 = s1141 ^ s1146; + s1148 = sbv_bv_join_u8_u8_u16(s1140, s1147); + s1149 = table3[s1130]; + s1150 = table4[s1132]; + s1151 = table1[s1134]; + s1152 = table2[s1136]; + s1153 = s1151 ^ s1152; + s1154 = s1150 ^ s1153; + s1155 = s1149 ^ s1154; + s1156 = table2[s1130]; + s1157 = table3[s1132]; + s1158 = table4[s1134]; + s1159 = table1[s1136]; + s1160 = s1158 ^ s1159; + s1161 = s1157 ^ s1160; + s1162 = s1156 ^ s1161; + s1163 = sbv_bv_join_u8_u8_u16(s1155, s1162); + s1164 = sbv_bv_join_u16_u16_u32(s1148, s1163); + s1165 = sbv_bv_extract_u32_31_24_u8(s325); + s1166 = table1[s1165]; + s1167 = sbv_bv_extract_u32_23_16_u8(s325); + s1168 = table2[s1167]; + s1169 = sbv_bv_extract_u32_15_8_u8(s325); + s1170 = table3[s1169]; + s1171 = sbv_bv_extract_u32_7_0_u8(s325); + s1172 = table4[s1171]; + s1173 = s1170 ^ s1172; + s1174 = s1168 ^ s1173; + s1175 = s1166 ^ s1174; + s1176 = table4[s1165]; + s1177 = table1[s1167]; + s1178 = table2[s1169]; + s1179 = table3[s1171]; + s1180 = s1178 ^ s1179; + s1181 = s1177 ^ s1180; + s1182 = s1176 ^ s1181; + s1183 = sbv_bv_join_u8_u8_u16(s1175, s1182); + s1184 = table3[s1165]; + s1185 = table4[s1167]; + s1186 = table1[s1169]; + s1187 = table2[s1171]; + s1188 = s1186 ^ s1187; + s1189 = s1185 ^ s1188; + s1190 = s1184 ^ s1189; + s1191 = table2[s1165]; + s1192 = table3[s1167]; + s1193 = table4[s1169]; + s1194 = table1[s1171]; + s1195 = s1193 ^ s1194; + s1196 = s1192 ^ s1195; + s1197 = s1191 ^ s1196; + s1198 = sbv_bv_join_u8_u8_u16(s1190, s1197); + s1199 = sbv_bv_join_u16_u16_u32(s1183, s1198); + s1200 = sbv_bv_extract_u32_31_24_u8(s326); + s1201 = table1[s1200]; + s1202 = sbv_bv_extract_u32_23_16_u8(s326); + s1203 = table2[s1202]; + s1204 = sbv_bv_extract_u32_15_8_u8(s326); + s1205 = table3[s1204]; + s1206 = sbv_bv_extract_u32_7_0_u8(s326); + s1207 = table4[s1206]; + s1208 = s1205 ^ s1207; + s1209 = s1203 ^ s1208; + s1210 = s1201 ^ s1209; + s1211 = table4[s1200]; + s1212 = table1[s1202]; + s1213 = table2[s1204]; + s1214 = table3[s1206]; + s1215 = s1213 ^ s1214; + s1216 = s1212 ^ s1215; + s1217 = s1211 ^ s1216; + s1218 = sbv_bv_join_u8_u8_u16(s1210, s1217); + s1219 = table3[s1200]; + s1220 = table4[s1202]; + s1221 = table1[s1204]; + s1222 = table2[s1206]; + s1223 = s1221 ^ s1222; + s1224 = s1220 ^ s1223; + s1225 = s1219 ^ s1224; + s1226 = table2[s1200]; + s1227 = table3[s1202]; + s1228 = table4[s1204]; + s1229 = table1[s1206]; + s1230 = s1228 ^ s1229; + s1231 = s1227 ^ s1230; + s1232 = s1226 ^ s1231; + s1233 = sbv_bv_join_u8_u8_u16(s1225, s1232); + s1234 = sbv_bv_join_u16_u16_u32(s1218, s1233); + s1235 = sbv_bv_extract_u32_31_24_u8(s327); + s1236 = table1[s1235]; + s1237 = sbv_bv_extract_u32_23_16_u8(s327); + s1238 = table2[s1237]; + s1239 = sbv_bv_extract_u32_15_8_u8(s327); + s1240 = table3[s1239]; + s1241 = sbv_bv_extract_u32_7_0_u8(s327); + s1242 = table4[s1241]; + s1243 = s1240 ^ s1242; + s1244 = s1238 ^ s1243; + s1245 = s1236 ^ s1244; + s1246 = table4[s1235]; + s1247 = table1[s1237]; + s1248 = table2[s1239]; + s1249 = table3[s1241]; + s1250 = s1248 ^ s1249; + s1251 = s1247 ^ s1250; + s1252 = s1246 ^ s1251; + s1253 = sbv_bv_join_u8_u8_u16(s1245, s1252); + s1254 = table3[s1235]; + s1255 = table4[s1237]; + s1256 = table1[s1239]; + s1257 = table2[s1241]; + s1258 = s1256 ^ s1257; + s1259 = s1255 ^ s1258; + s1260 = s1254 ^ s1259; + s1261 = table2[s1235]; + s1262 = table3[s1237]; + s1263 = table4[s1239]; + s1264 = table1[s1241]; + s1265 = s1263 ^ s1264; + s1266 = s1262 ^ s1265; + s1267 = s1261 ^ s1266; + s1268 = sbv_bv_join_u8_u8_u16(s1260, s1267); + s1269 = sbv_bv_join_u16_u16_u32(s1253, s1268); + s1270 = sbv_bv_extract_u32_31_24_u8(s307); + s1271 = table1[s1270]; + s1272 = sbv_bv_extract_u32_23_16_u8(s307); + s1273 = table2[s1272]; + s1274 = sbv_bv_extract_u32_15_8_u8(s307); + s1275 = table3[s1274]; + s1276 = sbv_bv_extract_u32_7_0_u8(s307); + s1277 = table4[s1276]; + s1278 = s1275 ^ s1277; + s1279 = s1273 ^ s1278; + s1280 = s1271 ^ s1279; + s1281 = table4[s1270]; + s1282 = table1[s1272]; + s1283 = table2[s1274]; + s1284 = table3[s1276]; + s1285 = s1283 ^ s1284; + s1286 = s1282 ^ s1285; + s1287 = s1281 ^ s1286; + s1288 = sbv_bv_join_u8_u8_u16(s1280, s1287); + s1289 = table3[s1270]; + s1290 = table4[s1272]; + s1291 = table1[s1274]; + s1292 = table2[s1276]; + s1293 = s1291 ^ s1292; + s1294 = s1290 ^ s1293; + s1295 = s1289 ^ s1294; + s1296 = table2[s1270]; + s1297 = table3[s1272]; + s1298 = table4[s1274]; + s1299 = table1[s1276]; + s1300 = s1298 ^ s1299; + s1301 = s1297 ^ s1300; + s1302 = s1296 ^ s1301; + s1303 = sbv_bv_join_u8_u8_u16(s1295, s1302); + s1304 = sbv_bv_join_u16_u16_u32(s1288, s1303); + s1305 = sbv_bv_extract_u32_31_24_u8(s308); + s1306 = table1[s1305]; + s1307 = sbv_bv_extract_u32_23_16_u8(s308); + s1308 = table2[s1307]; + s1309 = sbv_bv_extract_u32_15_8_u8(s308); + s1310 = table3[s1309]; + s1311 = sbv_bv_extract_u32_7_0_u8(s308); + s1312 = table4[s1311]; + s1313 = s1310 ^ s1312; + s1314 = s1308 ^ s1313; + s1315 = s1306 ^ s1314; + s1316 = table4[s1305]; + s1317 = table1[s1307]; + s1318 = table2[s1309]; + s1319 = table3[s1311]; + s1320 = s1318 ^ s1319; + s1321 = s1317 ^ s1320; + s1322 = s1316 ^ s1321; + s1323 = sbv_bv_join_u8_u8_u16(s1315, s1322); + s1324 = table3[s1305]; + s1325 = table4[s1307]; + s1326 = table1[s1309]; + s1327 = table2[s1311]; + s1328 = s1326 ^ s1327; + s1329 = s1325 ^ s1328; + s1330 = s1324 ^ s1329; + s1331 = table2[s1305]; + s1332 = table3[s1307]; + s1333 = table4[s1309]; + s1334 = table1[s1311]; + s1335 = s1333 ^ s1334; + s1336 = s1332 ^ s1335; + s1337 = s1331 ^ s1336; + s1338 = sbv_bv_join_u8_u8_u16(s1330, s1337); + s1339 = sbv_bv_join_u16_u16_u32(s1323, s1338); + s1340 = sbv_bv_extract_u32_31_24_u8(s309); + s1341 = table1[s1340]; + s1342 = sbv_bv_extract_u32_23_16_u8(s309); + s1343 = table2[s1342]; + s1344 = sbv_bv_extract_u32_15_8_u8(s309); + s1345 = table3[s1344]; + s1346 = sbv_bv_extract_u32_7_0_u8(s309); + s1347 = table4[s1346]; + s1348 = s1345 ^ s1347; + s1349 = s1343 ^ s1348; + s1350 = s1341 ^ s1349; + s1351 = table4[s1340]; + s1352 = table1[s1342]; + s1353 = table2[s1344]; + s1354 = table3[s1346]; + s1355 = s1353 ^ s1354; + s1356 = s1352 ^ s1355; + s1357 = s1351 ^ s1356; + s1358 = sbv_bv_join_u8_u8_u16(s1350, s1357); + s1359 = table3[s1340]; + s1360 = table4[s1342]; + s1361 = table1[s1344]; + s1362 = table2[s1346]; + s1363 = s1361 ^ s1362; + s1364 = s1360 ^ s1363; + s1365 = s1359 ^ s1364; + s1366 = table2[s1340]; + s1367 = table3[s1342]; + s1368 = table4[s1344]; + s1369 = table1[s1346]; + s1370 = s1368 ^ s1369; + s1371 = s1367 ^ s1370; + s1372 = s1366 ^ s1371; + s1373 = sbv_bv_join_u8_u8_u16(s1365, s1372); + s1374 = sbv_bv_join_u16_u16_u32(s1358, s1373); + s1375 = sbv_bv_extract_u32_31_24_u8(s310); + s1376 = table1[s1375]; + s1377 = sbv_bv_extract_u32_23_16_u8(s310); + s1378 = table2[s1377]; + s1379 = sbv_bv_extract_u32_15_8_u8(s310); + s1380 = table3[s1379]; + s1381 = sbv_bv_extract_u32_7_0_u8(s310); + s1382 = table4[s1381]; + s1383 = s1380 ^ s1382; + s1384 = s1378 ^ s1383; + s1385 = s1376 ^ s1384; + s1386 = table4[s1375]; + s1387 = table1[s1377]; + s1388 = table2[s1379]; + s1389 = table3[s1381]; + s1390 = s1388 ^ s1389; + s1391 = s1387 ^ s1390; + s1392 = s1386 ^ s1391; + s1393 = sbv_bv_join_u8_u8_u16(s1385, s1392); + s1394 = table3[s1375]; + s1395 = table4[s1377]; + s1396 = table1[s1379]; + s1397 = table2[s1381]; + s1398 = s1396 ^ s1397; + s1399 = s1395 ^ s1398; + s1400 = s1394 ^ s1399; + s1401 = table2[s1375]; + s1402 = table3[s1377]; + s1403 = table4[s1379]; + s1404 = table1[s1381]; + s1405 = s1403 ^ s1404; + s1406 = s1402 ^ s1405; + s1407 = s1401 ^ s1406; + s1408 = sbv_bv_join_u8_u8_u16(s1400, s1407); + s1409 = sbv_bv_join_u16_u16_u32(s1393, s1408); + s1410 = sbv_bv_extract_u32_31_24_u8(s290); + s1411 = table1[s1410]; + s1412 = sbv_bv_extract_u32_23_16_u8(s290); + s1413 = table2[s1412]; + s1414 = sbv_bv_extract_u32_15_8_u8(s290); + s1415 = table3[s1414]; + s1416 = sbv_bv_extract_u32_7_0_u8(s290); + s1417 = table4[s1416]; + s1418 = s1415 ^ s1417; + s1419 = s1413 ^ s1418; + s1420 = s1411 ^ s1419; + s1421 = table4[s1410]; + s1422 = table1[s1412]; + s1423 = table2[s1414]; + s1424 = table3[s1416]; + s1425 = s1423 ^ s1424; + s1426 = s1422 ^ s1425; + s1427 = s1421 ^ s1426; + s1428 = sbv_bv_join_u8_u8_u16(s1420, s1427); + s1429 = table3[s1410]; + s1430 = table4[s1412]; + s1431 = table1[s1414]; + s1432 = table2[s1416]; + s1433 = s1431 ^ s1432; + s1434 = s1430 ^ s1433; + s1435 = s1429 ^ s1434; + s1436 = table2[s1410]; + s1437 = table3[s1412]; + s1438 = table4[s1414]; + s1439 = table1[s1416]; + s1440 = s1438 ^ s1439; + s1441 = s1437 ^ s1440; + s1442 = s1436 ^ s1441; + s1443 = sbv_bv_join_u8_u8_u16(s1435, s1442); + s1444 = sbv_bv_join_u16_u16_u32(s1428, s1443); + s1445 = sbv_bv_extract_u32_31_24_u8(s291); + s1446 = table1[s1445]; + s1447 = sbv_bv_extract_u32_23_16_u8(s291); + s1448 = table2[s1447]; + s1449 = sbv_bv_extract_u32_15_8_u8(s291); + s1450 = table3[s1449]; + s1451 = sbv_bv_extract_u32_7_0_u8(s291); + s1452 = table4[s1451]; + s1453 = s1450 ^ s1452; + s1454 = s1448 ^ s1453; + s1455 = s1446 ^ s1454; + s1456 = table4[s1445]; + s1457 = table1[s1447]; + s1458 = table2[s1449]; + s1459 = table3[s1451]; + s1460 = s1458 ^ s1459; + s1461 = s1457 ^ s1460; + s1462 = s1456 ^ s1461; + s1463 = sbv_bv_join_u8_u8_u16(s1455, s1462); + s1464 = table3[s1445]; + s1465 = table4[s1447]; + s1466 = table1[s1449]; + s1467 = table2[s1451]; + s1468 = s1466 ^ s1467; + s1469 = s1465 ^ s1468; + s1470 = s1464 ^ s1469; + s1471 = table2[s1445]; + s1472 = table3[s1447]; + s1473 = table4[s1449]; + s1474 = table1[s1451]; + s1475 = s1473 ^ s1474; + s1476 = s1472 ^ s1475; + s1477 = s1471 ^ s1476; + s1478 = sbv_bv_join_u8_u8_u16(s1470, s1477); + s1479 = sbv_bv_join_u16_u16_u32(s1463, s1478); + s1480 = sbv_bv_extract_u32_31_24_u8(s292); + s1481 = table1[s1480]; + s1482 = sbv_bv_extract_u32_23_16_u8(s292); + s1483 = table2[s1482]; + s1484 = sbv_bv_extract_u32_15_8_u8(s292); + s1485 = table3[s1484]; + s1486 = sbv_bv_extract_u32_7_0_u8(s292); + s1487 = table4[s1486]; + s1488 = s1485 ^ s1487; + s1489 = s1483 ^ s1488; + s1490 = s1481 ^ s1489; + s1491 = table4[s1480]; + s1492 = table1[s1482]; + s1493 = table2[s1484]; + s1494 = table3[s1486]; + s1495 = s1493 ^ s1494; + s1496 = s1492 ^ s1495; + s1497 = s1491 ^ s1496; + s1498 = sbv_bv_join_u8_u8_u16(s1490, s1497); + s1499 = table3[s1480]; + s1500 = table4[s1482]; + s1501 = table1[s1484]; + s1502 = table2[s1486]; + s1503 = s1501 ^ s1502; + s1504 = s1500 ^ s1503; + s1505 = s1499 ^ s1504; + s1506 = table2[s1480]; + s1507 = table3[s1482]; + s1508 = table4[s1484]; + s1509 = table1[s1486]; + s1510 = s1508 ^ s1509; + s1511 = s1507 ^ s1510; + s1512 = s1506 ^ s1511; + s1513 = sbv_bv_join_u8_u8_u16(s1505, s1512); + s1514 = sbv_bv_join_u16_u16_u32(s1498, s1513); + s1515 = sbv_bv_extract_u32_31_24_u8(s293); + s1516 = table1[s1515]; + s1517 = sbv_bv_extract_u32_23_16_u8(s293); + s1518 = table2[s1517]; + s1519 = sbv_bv_extract_u32_15_8_u8(s293); + s1520 = table3[s1519]; + s1521 = sbv_bv_extract_u32_7_0_u8(s293); + s1522 = table4[s1521]; + s1523 = s1520 ^ s1522; + s1524 = s1518 ^ s1523; + s1525 = s1516 ^ s1524; + s1526 = table4[s1515]; + s1527 = table1[s1517]; + s1528 = table2[s1519]; + s1529 = table3[s1521]; + s1530 = s1528 ^ s1529; + s1531 = s1527 ^ s1530; + s1532 = s1526 ^ s1531; + s1533 = sbv_bv_join_u8_u8_u16(s1525, s1532); + s1534 = table3[s1515]; + s1535 = table4[s1517]; + s1536 = table1[s1519]; + s1537 = table2[s1521]; + s1538 = s1536 ^ s1537; + s1539 = s1535 ^ s1538; + s1540 = s1534 ^ s1539; + s1541 = table2[s1515]; + s1542 = table3[s1517]; + s1543 = table4[s1519]; + s1544 = table1[s1521]; + s1545 = s1543 ^ s1544; + s1546 = s1542 ^ s1545; + s1547 = s1541 ^ s1546; + s1548 = sbv_bv_join_u8_u8_u16(s1540, s1547); + s1549 = sbv_bv_join_u16_u16_u32(s1533, s1548); + s1550 = sbv_bv_extract_u32_31_24_u8(s273); + s1551 = table1[s1550]; + s1552 = sbv_bv_extract_u32_23_16_u8(s273); + s1553 = table2[s1552]; + s1554 = sbv_bv_extract_u32_15_8_u8(s273); + s1555 = table3[s1554]; + s1556 = sbv_bv_extract_u32_7_0_u8(s273); + s1557 = table4[s1556]; + s1558 = s1555 ^ s1557; + s1559 = s1553 ^ s1558; + s1560 = s1551 ^ s1559; + s1561 = table4[s1550]; + s1562 = table1[s1552]; + s1563 = table2[s1554]; + s1564 = table3[s1556]; + s1565 = s1563 ^ s1564; + s1566 = s1562 ^ s1565; + s1567 = s1561 ^ s1566; + s1568 = sbv_bv_join_u8_u8_u16(s1560, s1567); + s1569 = table3[s1550]; + s1570 = table4[s1552]; + s1571 = table1[s1554]; + s1572 = table2[s1556]; + s1573 = s1571 ^ s1572; + s1574 = s1570 ^ s1573; + s1575 = s1569 ^ s1574; + s1576 = table2[s1550]; + s1577 = table3[s1552]; + s1578 = table4[s1554]; + s1579 = table1[s1556]; + s1580 = s1578 ^ s1579; + s1581 = s1577 ^ s1580; + s1582 = s1576 ^ s1581; + s1583 = sbv_bv_join_u8_u8_u16(s1575, s1582); + s1584 = sbv_bv_join_u16_u16_u32(s1568, s1583); + s1585 = sbv_bv_extract_u32_31_24_u8(s274); + s1586 = table1[s1585]; + s1587 = sbv_bv_extract_u32_23_16_u8(s274); + s1588 = table2[s1587]; + s1589 = sbv_bv_extract_u32_15_8_u8(s274); + s1590 = table3[s1589]; + s1591 = sbv_bv_extract_u32_7_0_u8(s274); + s1592 = table4[s1591]; + s1593 = s1590 ^ s1592; + s1594 = s1588 ^ s1593; + s1595 = s1586 ^ s1594; + s1596 = table4[s1585]; + s1597 = table1[s1587]; + s1598 = table2[s1589]; + s1599 = table3[s1591]; + s1600 = s1598 ^ s1599; + s1601 = s1597 ^ s1600; + s1602 = s1596 ^ s1601; + s1603 = sbv_bv_join_u8_u8_u16(s1595, s1602); + s1604 = table3[s1585]; + s1605 = table4[s1587]; + s1606 = table1[s1589]; + s1607 = table2[s1591]; + s1608 = s1606 ^ s1607; + s1609 = s1605 ^ s1608; + s1610 = s1604 ^ s1609; + s1611 = table2[s1585]; + s1612 = table3[s1587]; + s1613 = table4[s1589]; + s1614 = table1[s1591]; + s1615 = s1613 ^ s1614; + s1616 = s1612 ^ s1615; + s1617 = s1611 ^ s1616; + s1618 = sbv_bv_join_u8_u8_u16(s1610, s1617); + s1619 = sbv_bv_join_u16_u16_u32(s1603, s1618); + s1620 = sbv_bv_extract_u32_31_24_u8(s275); + s1621 = table1[s1620]; + s1622 = sbv_bv_extract_u32_23_16_u8(s275); + s1623 = table2[s1622]; + s1624 = sbv_bv_extract_u32_15_8_u8(s275); + s1625 = table3[s1624]; + s1626 = sbv_bv_extract_u32_7_0_u8(s275); + s1627 = table4[s1626]; + s1628 = s1625 ^ s1627; + s1629 = s1623 ^ s1628; + s1630 = s1621 ^ s1629; + s1631 = table4[s1620]; + s1632 = table1[s1622]; + s1633 = table2[s1624]; + s1634 = table3[s1626]; + s1635 = s1633 ^ s1634; + s1636 = s1632 ^ s1635; + s1637 = s1631 ^ s1636; + s1638 = sbv_bv_join_u8_u8_u16(s1630, s1637); + s1639 = table3[s1620]; + s1640 = table4[s1622]; + s1641 = table1[s1624]; + s1642 = table2[s1626]; + s1643 = s1641 ^ s1642; + s1644 = s1640 ^ s1643; + s1645 = s1639 ^ s1644; + s1646 = table2[s1620]; + s1647 = table3[s1622]; + s1648 = table4[s1624]; + s1649 = table1[s1626]; + s1650 = s1648 ^ s1649; + s1651 = s1647 ^ s1650; + s1652 = s1646 ^ s1651; + s1653 = sbv_bv_join_u8_u8_u16(s1645, s1652); + s1654 = sbv_bv_join_u16_u16_u32(s1638, s1653); + s1655 = sbv_bv_extract_u32_31_24_u8(s276); + s1656 = table1[s1655]; + s1657 = sbv_bv_extract_u32_23_16_u8(s276); + s1658 = table2[s1657]; + s1659 = sbv_bv_extract_u32_15_8_u8(s276); + s1660 = table3[s1659]; + s1661 = sbv_bv_extract_u32_7_0_u8(s276); + s1662 = table4[s1661]; + s1663 = s1660 ^ s1662; + s1664 = s1658 ^ s1663; + s1665 = s1656 ^ s1664; + s1666 = table4[s1655]; + s1667 = table1[s1657]; + s1668 = table2[s1659]; + s1669 = table3[s1661]; + s1670 = s1668 ^ s1669; + s1671 = s1667 ^ s1670; + s1672 = s1666 ^ s1671; + s1673 = sbv_bv_join_u8_u8_u16(s1665, s1672); + s1674 = table3[s1655]; + s1675 = table4[s1657]; + s1676 = table1[s1659]; + s1677 = table2[s1661]; + s1678 = s1676 ^ s1677; + s1679 = s1675 ^ s1678; + s1680 = s1674 ^ s1679; + s1681 = table2[s1655]; + s1682 = table3[s1657]; + s1683 = table4[s1659]; + s1684 = table1[s1661]; + s1685 = s1683 ^ s1684; + s1686 = s1682 ^ s1685; + s1687 = s1681 ^ s1686; + s1688 = sbv_bv_join_u8_u8_u16(s1680, s1687); + s1689 = sbv_bv_join_u16_u16_u32(s1673, s1688); + + sbv_output_0[0] = s0; + sbv_output_0[1] = s1; + sbv_output_0[2] = s2; + sbv_output_0[3] = s3; + sbv_output_0[4] = s273; + sbv_output_0[5] = s274; + sbv_output_0[6] = s275; + sbv_output_0[7] = s276; + sbv_output_0[8] = s290; + sbv_output_0[9] = s291; + sbv_output_0[10] = s292; + sbv_output_0[11] = s293; + sbv_output_0[12] = s307; + sbv_output_0[13] = s308; + sbv_output_0[14] = s309; + sbv_output_0[15] = s310; + sbv_output_0[16] = s324; + sbv_output_0[17] = s325; + sbv_output_0[18] = s326; + sbv_output_0[19] = s327; + sbv_output_0[20] = s341; + sbv_output_0[21] = s342; + sbv_output_0[22] = s343; + sbv_output_0[23] = s344; + sbv_output_0[24] = s358; + sbv_output_0[25] = s359; + sbv_output_0[26] = s360; + sbv_output_0[27] = s361; + sbv_output_0[28] = s375; + sbv_output_0[29] = s376; + sbv_output_0[30] = s377; + sbv_output_0[31] = s378; + sbv_output_0[32] = s392; + sbv_output_0[33] = s393; + sbv_output_0[34] = s394; + sbv_output_0[35] = s395; + sbv_output_0[36] = s409; + sbv_output_0[37] = s410; + sbv_output_0[38] = s411; + sbv_output_0[39] = s412; + sbv_output_0[40] = s426; + sbv_output_0[41] = s427; + sbv_output_0[42] = s428; + sbv_output_0[43] = s429; + sbv_output_1[0] = s426; + sbv_output_1[1] = s427; + sbv_output_1[2] = s428; + sbv_output_1[3] = s429; + sbv_output_1[4] = s464; + sbv_output_1[5] = s499; + sbv_output_1[6] = s534; + sbv_output_1[7] = s569; + sbv_output_1[8] = s604; + sbv_output_1[9] = s639; + sbv_output_1[10] = s674; + sbv_output_1[11] = s709; + sbv_output_1[12] = s744; + sbv_output_1[13] = s779; + sbv_output_1[14] = s814; + sbv_output_1[15] = s849; + sbv_output_1[16] = s884; + sbv_output_1[17] = s919; + sbv_output_1[18] = s954; + sbv_output_1[19] = s989; + sbv_output_1[20] = s1024; + sbv_output_1[21] = s1059; + sbv_output_1[22] = s1094; + sbv_output_1[23] = s1129; + sbv_output_1[24] = s1164; + sbv_output_1[25] = s1199; + sbv_output_1[26] = s1234; + sbv_output_1[27] = s1269; + sbv_output_1[28] = s1304; + sbv_output_1[29] = s1339; + sbv_output_1[30] = s1374; + sbv_output_1[31] = s1409; + sbv_output_1[32] = s1444; + sbv_output_1[33] = s1479; + sbv_output_1[34] = s1514; + sbv_output_1[35] = s1549; + sbv_output_1[36] = s1584; + sbv_output_1[37] = s1619; + sbv_output_1[38] = s1654; + sbv_output_1[39] = s1689; + sbv_output_1[40] = s0; + sbv_output_1[41] = s1; + sbv_output_1[42] = s2; + sbv_output_1[43] = s3; +} +== END: "aes128KeySchedule.c" ================== +== BEGIN: "aes128BlockEncrypt.c" ================ +/* File: "aes128BlockEncrypt.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Lib.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128BlockEncrypt(const SWord32 *sbv_input_0, + const SWord32 *sbv_input_1, SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s4 = sbv_input_1[0]; + const SWord32 s5 = sbv_input_1[1]; + const SWord32 s6 = sbv_input_1[2]; + const SWord32 s7 = sbv_input_1[3]; + const SWord32 s8 = sbv_input_1[4]; + const SWord32 s9 = sbv_input_1[5]; + const SWord32 s10 = sbv_input_1[6]; + const SWord32 s11 = sbv_input_1[7]; + const SWord32 s12 = sbv_input_1[8]; + const SWord32 s13 = sbv_input_1[9]; + const SWord32 s14 = sbv_input_1[10]; + const SWord32 s15 = sbv_input_1[11]; + const SWord32 s16 = sbv_input_1[12]; + const SWord32 s17 = sbv_input_1[13]; + const SWord32 s18 = sbv_input_1[14]; + const SWord32 s19 = sbv_input_1[15]; + const SWord32 s20 = sbv_input_1[16]; + const SWord32 s21 = sbv_input_1[17]; + const SWord32 s22 = sbv_input_1[18]; + const SWord32 s23 = sbv_input_1[19]; + const SWord32 s24 = sbv_input_1[20]; + const SWord32 s25 = sbv_input_1[21]; + const SWord32 s26 = sbv_input_1[22]; + const SWord32 s27 = sbv_input_1[23]; + const SWord32 s28 = sbv_input_1[24]; + const SWord32 s29 = sbv_input_1[25]; + const SWord32 s30 = sbv_input_1[26]; + const SWord32 s31 = sbv_input_1[27]; + const SWord32 s32 = sbv_input_1[28]; + const SWord32 s33 = sbv_input_1[29]; + const SWord32 s34 = sbv_input_1[30]; + const SWord32 s35 = sbv_input_1[31]; + const SWord32 s36 = sbv_input_1[32]; + const SWord32 s37 = sbv_input_1[33]; + const SWord32 s38 = sbv_input_1[34]; + const SWord32 s39 = sbv_input_1[35]; + const SWord32 s40 = sbv_input_1[36]; + const SWord32 s41 = sbv_input_1[37]; + const SWord32 s42 = sbv_input_1[38]; + const SWord32 s43 = sbv_input_1[39]; + const SWord32 s44 = sbv_input_1[40]; + const SWord32 s45 = sbv_input_1[41]; + const SWord32 s46 = sbv_input_1[42]; + const SWord32 s47 = sbv_input_1[43]; + const SWord32 s560 = s0 ^ s4; + const SWord8 s561 = sbv_bv_extract_u32_31_24_u8(s560); + const SWord32 s818 = s1 ^ s5; + const SWord8 s819 = sbv_bv_extract_u32_23_16_u8(s818); + const SWord32 s1077 = s2 ^ s6; + const SWord8 s1078 = sbv_bv_extract_u32_15_8_u8(s1077); + const SWord32 s1336 = s3 ^ s7; + const SWord8 s1337 = sbv_bv_extract_u32_7_0_u8(s1336); + const SWord8 s1343 = sbv_bv_extract_u32_31_24_u8(s818); + const SWord8 s1345 = sbv_bv_extract_u32_23_16_u8(s1077); + const SWord8 s1348 = sbv_bv_extract_u32_15_8_u8(s1336); + const SWord8 s1351 = sbv_bv_extract_u32_7_0_u8(s560); + const SWord8 s1358 = sbv_bv_extract_u32_31_24_u8(s1077); + const SWord8 s1360 = sbv_bv_extract_u32_23_16_u8(s1336); + const SWord8 s1363 = sbv_bv_extract_u32_15_8_u8(s560); + const SWord8 s1366 = sbv_bv_extract_u32_7_0_u8(s818); + const SWord8 s1373 = sbv_bv_extract_u32_31_24_u8(s1336); + const SWord8 s1375 = sbv_bv_extract_u32_23_16_u8(s560); + const SWord8 s1378 = sbv_bv_extract_u32_15_8_u8(s818); + const SWord8 s1381 = sbv_bv_extract_u32_7_0_u8(s1077); + SWord32 s562; + SWord32 s820; + SWord32 s821; + SWord32 s1079; + SWord32 s1080; + SWord32 s1338; + SWord32 s1339; + SWord32 s1340; + SWord8 s1341; + SWord32 s1342; + SWord32 s1344; + SWord32 s1346; + SWord32 s1347; + SWord32 s1349; + SWord32 s1350; + SWord32 s1352; + SWord32 s1353; + SWord32 s1354; + SWord8 s1355; + SWord32 s1356; + SWord32 s1357; + SWord32 s1359; + SWord32 s1361; + SWord32 s1362; + SWord32 s1364; + SWord32 s1365; + SWord32 s1367; + SWord32 s1368; + SWord32 s1369; + SWord8 s1370; + SWord32 s1371; + SWord32 s1372; + SWord32 s1374; + SWord32 s1376; + SWord32 s1377; + SWord32 s1379; + SWord32 s1380; + SWord32 s1382; + SWord32 s1383; + SWord32 s1384; + SWord8 s1385; + SWord32 s1386; + SWord32 s1387; + SWord32 s1388; + SWord8 s1389; + SWord32 s1390; + SWord8 s1391; + SWord32 s1392; + SWord8 s1393; + SWord32 s1394; + SWord32 s1395; + SWord8 s1396; + SWord32 s1397; + SWord32 s1398; + SWord8 s1399; + SWord32 s1400; + SWord32 s1401; + SWord32 s1402; + SWord8 s1403; + SWord32 s1404; + SWord32 s1405; + SWord8 s1406; + SWord32 s1407; + SWord8 s1408; + SWord32 s1409; + SWord32 s1410; + SWord8 s1411; + SWord32 s1412; + SWord32 s1413; + SWord8 s1414; + SWord32 s1415; + SWord32 s1416; + SWord32 s1417; + SWord8 s1418; + SWord32 s1419; + SWord32 s1420; + SWord8 s1421; + SWord32 s1422; + SWord8 s1423; + SWord32 s1424; + SWord32 s1425; + SWord8 s1426; + SWord32 s1427; + SWord32 s1428; + SWord8 s1429; + SWord32 s1430; + SWord32 s1431; + SWord32 s1432; + SWord8 s1433; + SWord32 s1434; + SWord32 s1435; + SWord32 s1436; + SWord8 s1437; + SWord32 s1438; + SWord8 s1439; + SWord32 s1440; + SWord8 s1441; + SWord32 s1442; + SWord32 s1443; + SWord8 s1444; + SWord32 s1445; + SWord32 s1446; + SWord8 s1447; + SWord32 s1448; + SWord32 s1449; + SWord32 s1450; + SWord8 s1451; + SWord32 s1452; + SWord32 s1453; + SWord8 s1454; + SWord32 s1455; + SWord8 s1456; + SWord32 s1457; + SWord32 s1458; + SWord8 s1459; + SWord32 s1460; + SWord32 s1461; + SWord8 s1462; + SWord32 s1463; + SWord32 s1464; + SWord32 s1465; + SWord8 s1466; + SWord32 s1467; + SWord32 s1468; + SWord8 s1469; + SWord32 s1470; + SWord8 s1471; + SWord32 s1472; + SWord32 s1473; + SWord8 s1474; + SWord32 s1475; + SWord32 s1476; + SWord8 s1477; + SWord32 s1478; + SWord32 s1479; + SWord32 s1480; + SWord8 s1481; + SWord32 s1482; + SWord32 s1483; + SWord32 s1484; + SWord8 s1485; + SWord32 s1486; + SWord8 s1487; + SWord32 s1488; + SWord8 s1489; + SWord32 s1490; + SWord32 s1491; + SWord8 s1492; + SWord32 s1493; + SWord32 s1494; + SWord8 s1495; + SWord32 s1496; + SWord32 s1497; + SWord32 s1498; + SWord8 s1499; + SWord32 s1500; + SWord32 s1501; + SWord8 s1502; + SWord32 s1503; + SWord8 s1504; + SWord32 s1505; + SWord32 s1506; + SWord8 s1507; + SWord32 s1508; + SWord32 s1509; + SWord8 s1510; + SWord32 s1511; + SWord32 s1512; + SWord32 s1513; + SWord8 s1514; + SWord32 s1515; + SWord32 s1516; + SWord8 s1517; + SWord32 s1518; + SWord8 s1519; + SWord32 s1520; + SWord32 s1521; + SWord8 s1522; + SWord32 s1523; + SWord32 s1524; + SWord8 s1525; + SWord32 s1526; + SWord32 s1527; + SWord32 s1528; + SWord8 s1529; + SWord32 s1530; + SWord32 s1531; + SWord32 s1532; + SWord8 s1533; + SWord32 s1534; + SWord8 s1535; + SWord32 s1536; + SWord8 s1537; + SWord32 s1538; + SWord32 s1539; + SWord8 s1540; + SWord32 s1541; + SWord32 s1542; + SWord8 s1543; + SWord32 s1544; + SWord32 s1545; + SWord32 s1546; + SWord8 s1547; + SWord32 s1548; + SWord32 s1549; + SWord8 s1550; + SWord32 s1551; + SWord8 s1552; + SWord32 s1553; + SWord32 s1554; + SWord8 s1555; + SWord32 s1556; + SWord32 s1557; + SWord8 s1558; + SWord32 s1559; + SWord32 s1560; + SWord32 s1561; + SWord8 s1562; + SWord32 s1563; + SWord32 s1564; + SWord8 s1565; + SWord32 s1566; + SWord8 s1567; + SWord32 s1568; + SWord32 s1569; + SWord8 s1570; + SWord32 s1571; + SWord32 s1572; + SWord8 s1573; + SWord32 s1574; + SWord32 s1575; + SWord32 s1576; + SWord8 s1577; + SWord32 s1578; + SWord32 s1579; + SWord32 s1580; + SWord8 s1581; + SWord32 s1582; + SWord8 s1583; + SWord32 s1584; + SWord8 s1585; + SWord32 s1586; + SWord32 s1587; + SWord8 s1588; + SWord32 s1589; + SWord32 s1590; + SWord8 s1591; + SWord32 s1592; + SWord32 s1593; + SWord32 s1594; + SWord8 s1595; + SWord32 s1596; + SWord32 s1597; + SWord8 s1598; + SWord32 s1599; + SWord8 s1600; + SWord32 s1601; + SWord32 s1602; + SWord8 s1603; + SWord32 s1604; + SWord32 s1605; + SWord8 s1606; + SWord32 s1607; + SWord32 s1608; + SWord32 s1609; + SWord8 s1610; + SWord32 s1611; + SWord32 s1612; + SWord8 s1613; + SWord32 s1614; + SWord8 s1615; + SWord32 s1616; + SWord32 s1617; + SWord8 s1618; + SWord32 s1619; + SWord32 s1620; + SWord8 s1621; + SWord32 s1622; + SWord32 s1623; + SWord32 s1624; + SWord8 s1625; + SWord32 s1626; + SWord32 s1627; + SWord32 s1628; + SWord8 s1629; + SWord32 s1630; + SWord8 s1631; + SWord32 s1632; + SWord8 s1633; + SWord32 s1634; + SWord32 s1635; + SWord8 s1636; + SWord32 s1637; + SWord32 s1638; + SWord8 s1639; + SWord32 s1640; + SWord32 s1641; + SWord32 s1642; + SWord8 s1643; + SWord32 s1644; + SWord32 s1645; + SWord8 s1646; + SWord32 s1647; + SWord8 s1648; + SWord32 s1649; + SWord32 s1650; + SWord8 s1651; + SWord32 s1652; + SWord32 s1653; + SWord8 s1654; + SWord32 s1655; + SWord32 s1656; + SWord32 s1657; + SWord8 s1658; + SWord32 s1659; + SWord32 s1660; + SWord8 s1661; + SWord32 s1662; + SWord8 s1663; + SWord32 s1664; + SWord32 s1665; + SWord8 s1666; + SWord32 s1667; + SWord32 s1668; + SWord8 s1669; + SWord32 s1670; + SWord32 s1671; + SWord32 s1672; + SWord8 s1673; + SWord32 s1674; + SWord32 s1675; + SWord32 s1676; + SWord8 s1677; + SWord32 s1678; + SWord8 s1679; + SWord32 s1680; + SWord8 s1681; + SWord32 s1682; + SWord32 s1683; + SWord8 s1684; + SWord32 s1685; + SWord32 s1686; + SWord8 s1687; + SWord32 s1688; + SWord32 s1689; + SWord32 s1690; + SWord8 s1691; + SWord32 s1692; + SWord32 s1693; + SWord8 s1694; + SWord32 s1695; + SWord8 s1696; + SWord32 s1697; + SWord32 s1698; + SWord8 s1699; + SWord32 s1700; + SWord32 s1701; + SWord8 s1702; + SWord32 s1703; + SWord32 s1704; + SWord32 s1705; + SWord8 s1706; + SWord32 s1707; + SWord32 s1708; + SWord8 s1709; + SWord32 s1710; + SWord8 s1711; + SWord32 s1712; + SWord32 s1713; + SWord8 s1714; + SWord32 s1715; + SWord32 s1716; + SWord8 s1717; + SWord32 s1718; + SWord32 s1719; + SWord32 s1720; + SWord8 s1721; + SWord32 s1722; + SWord32 s1723; + SWord32 s1724; + SWord8 s1725; + SWord8 s1726; + SWord8 s1727; + SWord32 s1728; + SWord8 s1729; + SWord32 s1730; + SWord32 s1731; + SWord8 s1732; + SWord32 s1733; + SWord32 s1734; + SWord8 s1735; + SWord32 s1736; + SWord32 s1737; + SWord32 s1738; + SWord8 s1739; + SWord8 s1740; + SWord16 s1741; + SWord8 s1742; + SWord32 s1743; + SWord8 s1744; + SWord32 s1745; + SWord32 s1746; + SWord8 s1747; + SWord32 s1748; + SWord32 s1749; + SWord8 s1750; + SWord32 s1751; + SWord32 s1752; + SWord32 s1753; + SWord8 s1754; + SWord8 s1755; + SWord8 s1756; + SWord32 s1757; + SWord8 s1758; + SWord32 s1759; + SWord32 s1760; + SWord8 s1761; + SWord32 s1762; + SWord32 s1763; + SWord8 s1764; + SWord32 s1765; + SWord32 s1766; + SWord32 s1767; + SWord8 s1768; + SWord8 s1769; + SWord16 s1770; + SWord32 s1771; + SWord32 s1772; + SWord8 s1773; + SWord8 s1774; + SWord8 s1775; + SWord8 s1776; + SWord16 s1777; + SWord8 s1778; + SWord8 s1779; + SWord8 s1780; + SWord8 s1781; + SWord16 s1782; + SWord32 s1783; + SWord32 s1784; + SWord8 s1785; + SWord8 s1786; + SWord8 s1787; + SWord8 s1788; + SWord16 s1789; + SWord8 s1790; + SWord8 s1791; + SWord8 s1792; + SWord8 s1793; + SWord16 s1794; + SWord32 s1795; + SWord32 s1796; + SWord8 s1797; + SWord8 s1798; + SWord8 s1799; + SWord8 s1800; + SWord16 s1801; + SWord8 s1802; + SWord8 s1803; + SWord8 s1804; + SWord8 s1805; + SWord16 s1806; + SWord32 s1807; + SWord32 s1808; + 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 + }; + s562 = table1[s561]; + 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 + }; + s820 = table2[s819]; + s821 = s562 ^ s820; + 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 + }; + s1079 = table3[s1078]; + s1080 = s821 ^ s1079; + 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 + }; + s1338 = table4[s1337]; + s1339 = s1080 ^ s1338; + s1340 = s8 ^ s1339; + s1341 = sbv_bv_extract_u32_31_24_u8(s1340); + s1342 = table1[s1341]; + s1344 = table1[s1343]; + s1346 = table2[s1345]; + s1347 = s1344 ^ s1346; + s1349 = table3[s1348]; + s1350 = s1347 ^ s1349; + s1352 = table4[s1351]; + s1353 = s1350 ^ s1352; + s1354 = s9 ^ s1353; + s1355 = sbv_bv_extract_u32_23_16_u8(s1354); + s1356 = table2[s1355]; + s1357 = s1342 ^ s1356; + s1359 = table1[s1358]; + s1361 = table2[s1360]; + s1362 = s1359 ^ s1361; + s1364 = table3[s1363]; + s1365 = s1362 ^ s1364; + s1367 = table4[s1366]; + s1368 = s1365 ^ s1367; + s1369 = s10 ^ s1368; + s1370 = sbv_bv_extract_u32_15_8_u8(s1369); + s1371 = table3[s1370]; + s1372 = s1357 ^ s1371; + s1374 = table1[s1373]; + s1376 = table2[s1375]; + s1377 = s1374 ^ s1376; + s1379 = table3[s1378]; + s1380 = s1377 ^ s1379; + s1382 = table4[s1381]; + s1383 = s1380 ^ s1382; + s1384 = s11 ^ s1383; + s1385 = sbv_bv_extract_u32_7_0_u8(s1384); + s1386 = table4[s1385]; + s1387 = s1372 ^ s1386; + s1388 = s12 ^ s1387; + s1389 = sbv_bv_extract_u32_31_24_u8(s1388); + s1390 = table1[s1389]; + s1391 = sbv_bv_extract_u32_31_24_u8(s1354); + s1392 = table1[s1391]; + s1393 = sbv_bv_extract_u32_23_16_u8(s1369); + s1394 = table2[s1393]; + s1395 = s1392 ^ s1394; + s1396 = sbv_bv_extract_u32_15_8_u8(s1384); + s1397 = table3[s1396]; + s1398 = s1395 ^ s1397; + s1399 = sbv_bv_extract_u32_7_0_u8(s1340); + s1400 = table4[s1399]; + s1401 = s1398 ^ s1400; + s1402 = s13 ^ s1401; + s1403 = sbv_bv_extract_u32_23_16_u8(s1402); + s1404 = table2[s1403]; + s1405 = s1390 ^ s1404; + s1406 = sbv_bv_extract_u32_31_24_u8(s1369); + s1407 = table1[s1406]; + s1408 = sbv_bv_extract_u32_23_16_u8(s1384); + s1409 = table2[s1408]; + s1410 = s1407 ^ s1409; + s1411 = sbv_bv_extract_u32_15_8_u8(s1340); + s1412 = table3[s1411]; + s1413 = s1410 ^ s1412; + s1414 = sbv_bv_extract_u32_7_0_u8(s1354); + s1415 = table4[s1414]; + s1416 = s1413 ^ s1415; + s1417 = s14 ^ s1416; + s1418 = sbv_bv_extract_u32_15_8_u8(s1417); + s1419 = table3[s1418]; + s1420 = s1405 ^ s1419; + s1421 = sbv_bv_extract_u32_31_24_u8(s1384); + s1422 = table1[s1421]; + s1423 = sbv_bv_extract_u32_23_16_u8(s1340); + s1424 = table2[s1423]; + s1425 = s1422 ^ s1424; + s1426 = sbv_bv_extract_u32_15_8_u8(s1354); + s1427 = table3[s1426]; + s1428 = s1425 ^ s1427; + s1429 = sbv_bv_extract_u32_7_0_u8(s1369); + s1430 = table4[s1429]; + s1431 = s1428 ^ s1430; + s1432 = s15 ^ s1431; + s1433 = sbv_bv_extract_u32_7_0_u8(s1432); + s1434 = table4[s1433]; + s1435 = s1420 ^ s1434; + s1436 = s16 ^ s1435; + s1437 = sbv_bv_extract_u32_31_24_u8(s1436); + s1438 = table1[s1437]; + s1439 = sbv_bv_extract_u32_31_24_u8(s1402); + s1440 = table1[s1439]; + s1441 = sbv_bv_extract_u32_23_16_u8(s1417); + s1442 = table2[s1441]; + s1443 = s1440 ^ s1442; + s1444 = sbv_bv_extract_u32_15_8_u8(s1432); + s1445 = table3[s1444]; + s1446 = s1443 ^ s1445; + s1447 = sbv_bv_extract_u32_7_0_u8(s1388); + s1448 = table4[s1447]; + s1449 = s1446 ^ s1448; + s1450 = s17 ^ s1449; + s1451 = sbv_bv_extract_u32_23_16_u8(s1450); + s1452 = table2[s1451]; + s1453 = s1438 ^ s1452; + s1454 = sbv_bv_extract_u32_31_24_u8(s1417); + s1455 = table1[s1454]; + s1456 = sbv_bv_extract_u32_23_16_u8(s1432); + s1457 = table2[s1456]; + s1458 = s1455 ^ s1457; + s1459 = sbv_bv_extract_u32_15_8_u8(s1388); + s1460 = table3[s1459]; + s1461 = s1458 ^ s1460; + s1462 = sbv_bv_extract_u32_7_0_u8(s1402); + s1463 = table4[s1462]; + s1464 = s1461 ^ s1463; + s1465 = s18 ^ s1464; + s1466 = sbv_bv_extract_u32_15_8_u8(s1465); + s1467 = table3[s1466]; + s1468 = s1453 ^ s1467; + s1469 = sbv_bv_extract_u32_31_24_u8(s1432); + s1470 = table1[s1469]; + s1471 = sbv_bv_extract_u32_23_16_u8(s1388); + s1472 = table2[s1471]; + s1473 = s1470 ^ s1472; + s1474 = sbv_bv_extract_u32_15_8_u8(s1402); + s1475 = table3[s1474]; + s1476 = s1473 ^ s1475; + s1477 = sbv_bv_extract_u32_7_0_u8(s1417); + s1478 = table4[s1477]; + s1479 = s1476 ^ s1478; + s1480 = s19 ^ s1479; + s1481 = sbv_bv_extract_u32_7_0_u8(s1480); + s1482 = table4[s1481]; + s1483 = s1468 ^ s1482; + s1484 = s20 ^ s1483; + s1485 = sbv_bv_extract_u32_31_24_u8(s1484); + s1486 = table1[s1485]; + s1487 = sbv_bv_extract_u32_31_24_u8(s1450); + s1488 = table1[s1487]; + s1489 = sbv_bv_extract_u32_23_16_u8(s1465); + s1490 = table2[s1489]; + s1491 = s1488 ^ s1490; + s1492 = sbv_bv_extract_u32_15_8_u8(s1480); + s1493 = table3[s1492]; + s1494 = s1491 ^ s1493; + s1495 = sbv_bv_extract_u32_7_0_u8(s1436); + s1496 = table4[s1495]; + s1497 = s1494 ^ s1496; + s1498 = s21 ^ s1497; + s1499 = sbv_bv_extract_u32_23_16_u8(s1498); + s1500 = table2[s1499]; + s1501 = s1486 ^ s1500; + s1502 = sbv_bv_extract_u32_31_24_u8(s1465); + s1503 = table1[s1502]; + s1504 = sbv_bv_extract_u32_23_16_u8(s1480); + s1505 = table2[s1504]; + s1506 = s1503 ^ s1505; + s1507 = sbv_bv_extract_u32_15_8_u8(s1436); + s1508 = table3[s1507]; + s1509 = s1506 ^ s1508; + s1510 = sbv_bv_extract_u32_7_0_u8(s1450); + s1511 = table4[s1510]; + s1512 = s1509 ^ s1511; + s1513 = s22 ^ s1512; + s1514 = sbv_bv_extract_u32_15_8_u8(s1513); + s1515 = table3[s1514]; + s1516 = s1501 ^ s1515; + s1517 = sbv_bv_extract_u32_31_24_u8(s1480); + s1518 = table1[s1517]; + s1519 = sbv_bv_extract_u32_23_16_u8(s1436); + s1520 = table2[s1519]; + s1521 = s1518 ^ s1520; + s1522 = sbv_bv_extract_u32_15_8_u8(s1450); + s1523 = table3[s1522]; + s1524 = s1521 ^ s1523; + s1525 = sbv_bv_extract_u32_7_0_u8(s1465); + s1526 = table4[s1525]; + s1527 = s1524 ^ s1526; + s1528 = s23 ^ s1527; + s1529 = sbv_bv_extract_u32_7_0_u8(s1528); + s1530 = table4[s1529]; + s1531 = s1516 ^ s1530; + s1532 = s24 ^ s1531; + s1533 = sbv_bv_extract_u32_31_24_u8(s1532); + s1534 = table1[s1533]; + s1535 = sbv_bv_extract_u32_31_24_u8(s1498); + s1536 = table1[s1535]; + s1537 = sbv_bv_extract_u32_23_16_u8(s1513); + s1538 = table2[s1537]; + s1539 = s1536 ^ s1538; + s1540 = sbv_bv_extract_u32_15_8_u8(s1528); + s1541 = table3[s1540]; + s1542 = s1539 ^ s1541; + s1543 = sbv_bv_extract_u32_7_0_u8(s1484); + s1544 = table4[s1543]; + s1545 = s1542 ^ s1544; + s1546 = s25 ^ s1545; + s1547 = sbv_bv_extract_u32_23_16_u8(s1546); + s1548 = table2[s1547]; + s1549 = s1534 ^ s1548; + s1550 = sbv_bv_extract_u32_31_24_u8(s1513); + s1551 = table1[s1550]; + s1552 = sbv_bv_extract_u32_23_16_u8(s1528); + s1553 = table2[s1552]; + s1554 = s1551 ^ s1553; + s1555 = sbv_bv_extract_u32_15_8_u8(s1484); + s1556 = table3[s1555]; + s1557 = s1554 ^ s1556; + s1558 = sbv_bv_extract_u32_7_0_u8(s1498); + s1559 = table4[s1558]; + s1560 = s1557 ^ s1559; + s1561 = s26 ^ s1560; + s1562 = sbv_bv_extract_u32_15_8_u8(s1561); + s1563 = table3[s1562]; + s1564 = s1549 ^ s1563; + s1565 = sbv_bv_extract_u32_31_24_u8(s1528); + s1566 = table1[s1565]; + s1567 = sbv_bv_extract_u32_23_16_u8(s1484); + s1568 = table2[s1567]; + s1569 = s1566 ^ s1568; + s1570 = sbv_bv_extract_u32_15_8_u8(s1498); + s1571 = table3[s1570]; + s1572 = s1569 ^ s1571; + s1573 = sbv_bv_extract_u32_7_0_u8(s1513); + s1574 = table4[s1573]; + s1575 = s1572 ^ s1574; + s1576 = s27 ^ s1575; + s1577 = sbv_bv_extract_u32_7_0_u8(s1576); + s1578 = table4[s1577]; + s1579 = s1564 ^ s1578; + s1580 = s28 ^ s1579; + s1581 = sbv_bv_extract_u32_31_24_u8(s1580); + s1582 = table1[s1581]; + s1583 = sbv_bv_extract_u32_31_24_u8(s1546); + s1584 = table1[s1583]; + s1585 = sbv_bv_extract_u32_23_16_u8(s1561); + s1586 = table2[s1585]; + s1587 = s1584 ^ s1586; + s1588 = sbv_bv_extract_u32_15_8_u8(s1576); + s1589 = table3[s1588]; + s1590 = s1587 ^ s1589; + s1591 = sbv_bv_extract_u32_7_0_u8(s1532); + s1592 = table4[s1591]; + s1593 = s1590 ^ s1592; + s1594 = s29 ^ s1593; + s1595 = sbv_bv_extract_u32_23_16_u8(s1594); + s1596 = table2[s1595]; + s1597 = s1582 ^ s1596; + s1598 = sbv_bv_extract_u32_31_24_u8(s1561); + s1599 = table1[s1598]; + s1600 = sbv_bv_extract_u32_23_16_u8(s1576); + s1601 = table2[s1600]; + s1602 = s1599 ^ s1601; + s1603 = sbv_bv_extract_u32_15_8_u8(s1532); + s1604 = table3[s1603]; + s1605 = s1602 ^ s1604; + s1606 = sbv_bv_extract_u32_7_0_u8(s1546); + s1607 = table4[s1606]; + s1608 = s1605 ^ s1607; + s1609 = s30 ^ s1608; + s1610 = sbv_bv_extract_u32_15_8_u8(s1609); + s1611 = table3[s1610]; + s1612 = s1597 ^ s1611; + s1613 = sbv_bv_extract_u32_31_24_u8(s1576); + s1614 = table1[s1613]; + s1615 = sbv_bv_extract_u32_23_16_u8(s1532); + s1616 = table2[s1615]; + s1617 = s1614 ^ s1616; + s1618 = sbv_bv_extract_u32_15_8_u8(s1546); + s1619 = table3[s1618]; + s1620 = s1617 ^ s1619; + s1621 = sbv_bv_extract_u32_7_0_u8(s1561); + s1622 = table4[s1621]; + s1623 = s1620 ^ s1622; + s1624 = s31 ^ s1623; + s1625 = sbv_bv_extract_u32_7_0_u8(s1624); + s1626 = table4[s1625]; + s1627 = s1612 ^ s1626; + s1628 = s32 ^ s1627; + s1629 = sbv_bv_extract_u32_31_24_u8(s1628); + s1630 = table1[s1629]; + s1631 = sbv_bv_extract_u32_31_24_u8(s1594); + s1632 = table1[s1631]; + s1633 = sbv_bv_extract_u32_23_16_u8(s1609); + s1634 = table2[s1633]; + s1635 = s1632 ^ s1634; + s1636 = sbv_bv_extract_u32_15_8_u8(s1624); + s1637 = table3[s1636]; + s1638 = s1635 ^ s1637; + s1639 = sbv_bv_extract_u32_7_0_u8(s1580); + s1640 = table4[s1639]; + s1641 = s1638 ^ s1640; + s1642 = s33 ^ s1641; + s1643 = sbv_bv_extract_u32_23_16_u8(s1642); + s1644 = table2[s1643]; + s1645 = s1630 ^ s1644; + s1646 = sbv_bv_extract_u32_31_24_u8(s1609); + s1647 = table1[s1646]; + s1648 = sbv_bv_extract_u32_23_16_u8(s1624); + s1649 = table2[s1648]; + s1650 = s1647 ^ s1649; + s1651 = sbv_bv_extract_u32_15_8_u8(s1580); + s1652 = table3[s1651]; + s1653 = s1650 ^ s1652; + s1654 = sbv_bv_extract_u32_7_0_u8(s1594); + s1655 = table4[s1654]; + s1656 = s1653 ^ s1655; + s1657 = s34 ^ s1656; + s1658 = sbv_bv_extract_u32_15_8_u8(s1657); + s1659 = table3[s1658]; + s1660 = s1645 ^ s1659; + s1661 = sbv_bv_extract_u32_31_24_u8(s1624); + s1662 = table1[s1661]; + s1663 = sbv_bv_extract_u32_23_16_u8(s1580); + s1664 = table2[s1663]; + s1665 = s1662 ^ s1664; + s1666 = sbv_bv_extract_u32_15_8_u8(s1594); + s1667 = table3[s1666]; + s1668 = s1665 ^ s1667; + s1669 = sbv_bv_extract_u32_7_0_u8(s1609); + s1670 = table4[s1669]; + s1671 = s1668 ^ s1670; + s1672 = s35 ^ s1671; + s1673 = sbv_bv_extract_u32_7_0_u8(s1672); + s1674 = table4[s1673]; + s1675 = s1660 ^ s1674; + s1676 = s36 ^ s1675; + s1677 = sbv_bv_extract_u32_31_24_u8(s1676); + s1678 = table1[s1677]; + s1679 = sbv_bv_extract_u32_31_24_u8(s1642); + s1680 = table1[s1679]; + s1681 = sbv_bv_extract_u32_23_16_u8(s1657); + s1682 = table2[s1681]; + s1683 = s1680 ^ s1682; + s1684 = sbv_bv_extract_u32_15_8_u8(s1672); + s1685 = table3[s1684]; + s1686 = s1683 ^ s1685; + s1687 = sbv_bv_extract_u32_7_0_u8(s1628); + s1688 = table4[s1687]; + s1689 = s1686 ^ s1688; + s1690 = s37 ^ s1689; + s1691 = sbv_bv_extract_u32_23_16_u8(s1690); + s1692 = table2[s1691]; + s1693 = s1678 ^ s1692; + s1694 = sbv_bv_extract_u32_31_24_u8(s1657); + s1695 = table1[s1694]; + s1696 = sbv_bv_extract_u32_23_16_u8(s1672); + s1697 = table2[s1696]; + s1698 = s1695 ^ s1697; + s1699 = sbv_bv_extract_u32_15_8_u8(s1628); + s1700 = table3[s1699]; + s1701 = s1698 ^ s1700; + s1702 = sbv_bv_extract_u32_7_0_u8(s1642); + s1703 = table4[s1702]; + s1704 = s1701 ^ s1703; + s1705 = s38 ^ s1704; + s1706 = sbv_bv_extract_u32_15_8_u8(s1705); + s1707 = table3[s1706]; + s1708 = s1693 ^ s1707; + s1709 = sbv_bv_extract_u32_31_24_u8(s1672); + s1710 = table1[s1709]; + s1711 = sbv_bv_extract_u32_23_16_u8(s1628); + s1712 = table2[s1711]; + s1713 = s1710 ^ s1712; + s1714 = sbv_bv_extract_u32_15_8_u8(s1642); + s1715 = table3[s1714]; + s1716 = s1713 ^ s1715; + s1717 = sbv_bv_extract_u32_7_0_u8(s1657); + s1718 = table4[s1717]; + s1719 = s1716 ^ s1718; + s1720 = s39 ^ s1719; + s1721 = sbv_bv_extract_u32_7_0_u8(s1720); + s1722 = table4[s1721]; + s1723 = s1708 ^ s1722; + s1724 = s40 ^ s1723; + s1725 = sbv_bv_extract_u32_31_24_u8(s1724); + 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 + }; + s1726 = table0[s1725]; + s1727 = sbv_bv_extract_u32_31_24_u8(s1690); + s1728 = table1[s1727]; + s1729 = sbv_bv_extract_u32_23_16_u8(s1705); + s1730 = table2[s1729]; + s1731 = s1728 ^ s1730; + s1732 = sbv_bv_extract_u32_15_8_u8(s1720); + s1733 = table3[s1732]; + s1734 = s1731 ^ s1733; + s1735 = sbv_bv_extract_u32_7_0_u8(s1676); + s1736 = table4[s1735]; + s1737 = s1734 ^ s1736; + s1738 = s41 ^ s1737; + s1739 = sbv_bv_extract_u32_23_16_u8(s1738); + s1740 = table0[s1739]; + s1741 = sbv_bv_join_u8_u8_u16(s1726, s1740); + s1742 = sbv_bv_extract_u32_31_24_u8(s1705); + s1743 = table1[s1742]; + s1744 = sbv_bv_extract_u32_23_16_u8(s1720); + s1745 = table2[s1744]; + s1746 = s1743 ^ s1745; + s1747 = sbv_bv_extract_u32_15_8_u8(s1676); + s1748 = table3[s1747]; + s1749 = s1746 ^ s1748; + s1750 = sbv_bv_extract_u32_7_0_u8(s1690); + s1751 = table4[s1750]; + s1752 = s1749 ^ s1751; + s1753 = s42 ^ s1752; + s1754 = sbv_bv_extract_u32_15_8_u8(s1753); + s1755 = table0[s1754]; + s1756 = sbv_bv_extract_u32_31_24_u8(s1720); + s1757 = table1[s1756]; + s1758 = sbv_bv_extract_u32_23_16_u8(s1676); + s1759 = table2[s1758]; + s1760 = s1757 ^ s1759; + s1761 = sbv_bv_extract_u32_15_8_u8(s1690); + s1762 = table3[s1761]; + s1763 = s1760 ^ s1762; + s1764 = sbv_bv_extract_u32_7_0_u8(s1705); + s1765 = table4[s1764]; + s1766 = s1763 ^ s1765; + s1767 = s43 ^ s1766; + s1768 = sbv_bv_extract_u32_7_0_u8(s1767); + s1769 = table0[s1768]; + s1770 = sbv_bv_join_u8_u8_u16(s1755, s1769); + s1771 = sbv_bv_join_u16_u16_u32(s1741, s1770); + s1772 = s44 ^ s1771; + s1773 = sbv_bv_extract_u32_31_24_u8(s1738); + s1774 = table0[s1773]; + s1775 = sbv_bv_extract_u32_23_16_u8(s1753); + s1776 = table0[s1775]; + s1777 = sbv_bv_join_u8_u8_u16(s1774, s1776); + s1778 = sbv_bv_extract_u32_15_8_u8(s1767); + s1779 = table0[s1778]; + s1780 = sbv_bv_extract_u32_7_0_u8(s1724); + s1781 = table0[s1780]; + s1782 = sbv_bv_join_u8_u8_u16(s1779, s1781); + s1783 = sbv_bv_join_u16_u16_u32(s1777, s1782); + s1784 = s45 ^ s1783; + s1785 = sbv_bv_extract_u32_31_24_u8(s1753); + s1786 = table0[s1785]; + s1787 = sbv_bv_extract_u32_23_16_u8(s1767); + s1788 = table0[s1787]; + s1789 = sbv_bv_join_u8_u8_u16(s1786, s1788); + s1790 = sbv_bv_extract_u32_15_8_u8(s1724); + s1791 = table0[s1790]; + s1792 = sbv_bv_extract_u32_7_0_u8(s1738); + s1793 = table0[s1792]; + s1794 = sbv_bv_join_u8_u8_u16(s1791, s1793); + s1795 = sbv_bv_join_u16_u16_u32(s1789, s1794); + s1796 = s46 ^ s1795; + s1797 = sbv_bv_extract_u32_31_24_u8(s1767); + s1798 = table0[s1797]; + s1799 = sbv_bv_extract_u32_23_16_u8(s1724); + s1800 = table0[s1799]; + s1801 = sbv_bv_join_u8_u8_u16(s1798, s1800); + s1802 = sbv_bv_extract_u32_15_8_u8(s1738); + s1803 = table0[s1802]; + s1804 = sbv_bv_extract_u32_7_0_u8(s1753); + s1805 = table0[s1804]; + s1806 = sbv_bv_join_u8_u8_u16(s1803, s1805); + s1807 = sbv_bv_join_u16_u16_u32(s1801, s1806); + s1808 = s47 ^ s1807; + + sbv_output_0[0] = s1772; + sbv_output_0[1] = s1784; + sbv_output_0[2] = s1796; + sbv_output_0[3] = s1808; +} +== END: "aes128BlockEncrypt.c" ================== +== BEGIN: "aes128BlockDecrypt.c" ================ +/* File: "aes128BlockDecrypt.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Lib.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128BlockDecrypt(const SWord32 *sbv_input_0, + const SWord32 *sbv_input_1, SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s4 = sbv_input_1[0]; + const SWord32 s5 = sbv_input_1[1]; + const SWord32 s6 = sbv_input_1[2]; + const SWord32 s7 = sbv_input_1[3]; + const SWord32 s8 = sbv_input_1[4]; + const SWord32 s9 = sbv_input_1[5]; + const SWord32 s10 = sbv_input_1[6]; + const SWord32 s11 = sbv_input_1[7]; + const SWord32 s12 = sbv_input_1[8]; + const SWord32 s13 = sbv_input_1[9]; + const SWord32 s14 = sbv_input_1[10]; + const SWord32 s15 = sbv_input_1[11]; + const SWord32 s16 = sbv_input_1[12]; + const SWord32 s17 = sbv_input_1[13]; + const SWord32 s18 = sbv_input_1[14]; + const SWord32 s19 = sbv_input_1[15]; + const SWord32 s20 = sbv_input_1[16]; + const SWord32 s21 = sbv_input_1[17]; + const SWord32 s22 = sbv_input_1[18]; + const SWord32 s23 = sbv_input_1[19]; + const SWord32 s24 = sbv_input_1[20]; + const SWord32 s25 = sbv_input_1[21]; + const SWord32 s26 = sbv_input_1[22]; + const SWord32 s27 = sbv_input_1[23]; + const SWord32 s28 = sbv_input_1[24]; + const SWord32 s29 = sbv_input_1[25]; + const SWord32 s30 = sbv_input_1[26]; + const SWord32 s31 = sbv_input_1[27]; + const SWord32 s32 = sbv_input_1[28]; + const SWord32 s33 = sbv_input_1[29]; + const SWord32 s34 = sbv_input_1[30]; + const SWord32 s35 = sbv_input_1[31]; + const SWord32 s36 = sbv_input_1[32]; + const SWord32 s37 = sbv_input_1[33]; + const SWord32 s38 = sbv_input_1[34]; + const SWord32 s39 = sbv_input_1[35]; + const SWord32 s40 = sbv_input_1[36]; + const SWord32 s41 = sbv_input_1[37]; + const SWord32 s42 = sbv_input_1[38]; + const SWord32 s43 = sbv_input_1[39]; + const SWord32 s44 = sbv_input_1[40]; + const SWord32 s45 = sbv_input_1[41]; + const SWord32 s46 = sbv_input_1[42]; + const SWord32 s47 = sbv_input_1[43]; + const SWord32 s560 = s0 ^ s4; + const SWord8 s561 = sbv_bv_extract_u32_31_24_u8(s560); + const SWord32 s818 = s3 ^ s7; + const SWord8 s819 = sbv_bv_extract_u32_23_16_u8(s818); + const SWord32 s1077 = s2 ^ s6; + const SWord8 s1078 = sbv_bv_extract_u32_15_8_u8(s1077); + const SWord32 s1336 = s1 ^ s5; + const SWord8 s1337 = sbv_bv_extract_u32_7_0_u8(s1336); + const SWord8 s1343 = sbv_bv_extract_u32_31_24_u8(s818); + const SWord8 s1345 = sbv_bv_extract_u32_23_16_u8(s1077); + const SWord8 s1348 = sbv_bv_extract_u32_15_8_u8(s1336); + const SWord8 s1351 = sbv_bv_extract_u32_7_0_u8(s560); + const SWord8 s1358 = sbv_bv_extract_u32_31_24_u8(s1077); + const SWord8 s1360 = sbv_bv_extract_u32_23_16_u8(s1336); + const SWord8 s1363 = sbv_bv_extract_u32_15_8_u8(s560); + const SWord8 s1366 = sbv_bv_extract_u32_7_0_u8(s818); + const SWord8 s1373 = sbv_bv_extract_u32_31_24_u8(s1336); + const SWord8 s1375 = sbv_bv_extract_u32_23_16_u8(s560); + const SWord8 s1378 = sbv_bv_extract_u32_15_8_u8(s818); + const SWord8 s1381 = sbv_bv_extract_u32_7_0_u8(s1077); + SWord32 s562; + SWord32 s820; + SWord32 s821; + SWord32 s1079; + SWord32 s1080; + SWord32 s1338; + SWord32 s1339; + SWord32 s1340; + SWord8 s1341; + SWord32 s1342; + SWord32 s1344; + SWord32 s1346; + SWord32 s1347; + SWord32 s1349; + SWord32 s1350; + SWord32 s1352; + SWord32 s1353; + SWord32 s1354; + SWord8 s1355; + SWord32 s1356; + SWord32 s1357; + SWord32 s1359; + SWord32 s1361; + SWord32 s1362; + SWord32 s1364; + SWord32 s1365; + SWord32 s1367; + SWord32 s1368; + SWord32 s1369; + SWord8 s1370; + SWord32 s1371; + SWord32 s1372; + SWord32 s1374; + SWord32 s1376; + SWord32 s1377; + SWord32 s1379; + SWord32 s1380; + SWord32 s1382; + SWord32 s1383; + SWord32 s1384; + SWord8 s1385; + SWord32 s1386; + SWord32 s1387; + SWord32 s1388; + SWord8 s1389; + SWord32 s1390; + SWord8 s1391; + SWord32 s1392; + SWord8 s1393; + SWord32 s1394; + SWord32 s1395; + SWord8 s1396; + SWord32 s1397; + SWord32 s1398; + SWord8 s1399; + SWord32 s1400; + SWord32 s1401; + SWord32 s1402; + SWord8 s1403; + SWord32 s1404; + SWord32 s1405; + SWord8 s1406; + SWord32 s1407; + SWord8 s1408; + SWord32 s1409; + SWord32 s1410; + SWord8 s1411; + SWord32 s1412; + SWord32 s1413; + SWord8 s1414; + SWord32 s1415; + SWord32 s1416; + SWord32 s1417; + SWord8 s1418; + SWord32 s1419; + SWord32 s1420; + SWord8 s1421; + SWord32 s1422; + SWord8 s1423; + SWord32 s1424; + SWord32 s1425; + SWord8 s1426; + SWord32 s1427; + SWord32 s1428; + SWord8 s1429; + SWord32 s1430; + SWord32 s1431; + SWord32 s1432; + SWord8 s1433; + SWord32 s1434; + SWord32 s1435; + SWord32 s1436; + SWord8 s1437; + SWord32 s1438; + SWord8 s1439; + SWord32 s1440; + SWord8 s1441; + SWord32 s1442; + SWord32 s1443; + SWord8 s1444; + SWord32 s1445; + SWord32 s1446; + SWord8 s1447; + SWord32 s1448; + SWord32 s1449; + SWord32 s1450; + SWord8 s1451; + SWord32 s1452; + SWord32 s1453; + SWord8 s1454; + SWord32 s1455; + SWord8 s1456; + SWord32 s1457; + SWord32 s1458; + SWord8 s1459; + SWord32 s1460; + SWord32 s1461; + SWord8 s1462; + SWord32 s1463; + SWord32 s1464; + SWord32 s1465; + SWord8 s1466; + SWord32 s1467; + SWord32 s1468; + SWord8 s1469; + SWord32 s1470; + SWord8 s1471; + SWord32 s1472; + SWord32 s1473; + SWord8 s1474; + SWord32 s1475; + SWord32 s1476; + SWord8 s1477; + SWord32 s1478; + SWord32 s1479; + SWord32 s1480; + SWord8 s1481; + SWord32 s1482; + SWord32 s1483; + SWord32 s1484; + SWord8 s1485; + SWord32 s1486; + SWord8 s1487; + SWord32 s1488; + SWord8 s1489; + SWord32 s1490; + SWord32 s1491; + SWord8 s1492; + SWord32 s1493; + SWord32 s1494; + SWord8 s1495; + SWord32 s1496; + SWord32 s1497; + SWord32 s1498; + SWord8 s1499; + SWord32 s1500; + SWord32 s1501; + SWord8 s1502; + SWord32 s1503; + SWord8 s1504; + SWord32 s1505; + SWord32 s1506; + SWord8 s1507; + SWord32 s1508; + SWord32 s1509; + SWord8 s1510; + SWord32 s1511; + SWord32 s1512; + SWord32 s1513; + SWord8 s1514; + SWord32 s1515; + SWord32 s1516; + SWord8 s1517; + SWord32 s1518; + SWord8 s1519; + SWord32 s1520; + SWord32 s1521; + SWord8 s1522; + SWord32 s1523; + SWord32 s1524; + SWord8 s1525; + SWord32 s1526; + SWord32 s1527; + SWord32 s1528; + SWord8 s1529; + SWord32 s1530; + SWord32 s1531; + SWord32 s1532; + SWord8 s1533; + SWord32 s1534; + SWord8 s1535; + SWord32 s1536; + SWord8 s1537; + SWord32 s1538; + SWord32 s1539; + SWord8 s1540; + SWord32 s1541; + SWord32 s1542; + SWord8 s1543; + SWord32 s1544; + SWord32 s1545; + SWord32 s1546; + SWord8 s1547; + SWord32 s1548; + SWord32 s1549; + SWord8 s1550; + SWord32 s1551; + SWord8 s1552; + SWord32 s1553; + SWord32 s1554; + SWord8 s1555; + SWord32 s1556; + SWord32 s1557; + SWord8 s1558; + SWord32 s1559; + SWord32 s1560; + SWord32 s1561; + SWord8 s1562; + SWord32 s1563; + SWord32 s1564; + SWord8 s1565; + SWord32 s1566; + SWord8 s1567; + SWord32 s1568; + SWord32 s1569; + SWord8 s1570; + SWord32 s1571; + SWord32 s1572; + SWord8 s1573; + SWord32 s1574; + SWord32 s1575; + SWord32 s1576; + SWord8 s1577; + SWord32 s1578; + SWord32 s1579; + SWord32 s1580; + SWord8 s1581; + SWord32 s1582; + SWord8 s1583; + SWord32 s1584; + SWord8 s1585; + SWord32 s1586; + SWord32 s1587; + SWord8 s1588; + SWord32 s1589; + SWord32 s1590; + SWord8 s1591; + SWord32 s1592; + SWord32 s1593; + SWord32 s1594; + SWord8 s1595; + SWord32 s1596; + SWord32 s1597; + SWord8 s1598; + SWord32 s1599; + SWord8 s1600; + SWord32 s1601; + SWord32 s1602; + SWord8 s1603; + SWord32 s1604; + SWord32 s1605; + SWord8 s1606; + SWord32 s1607; + SWord32 s1608; + SWord32 s1609; + SWord8 s1610; + SWord32 s1611; + SWord32 s1612; + SWord8 s1613; + SWord32 s1614; + SWord8 s1615; + SWord32 s1616; + SWord32 s1617; + SWord8 s1618; + SWord32 s1619; + SWord32 s1620; + SWord8 s1621; + SWord32 s1622; + SWord32 s1623; + SWord32 s1624; + SWord8 s1625; + SWord32 s1626; + SWord32 s1627; + SWord32 s1628; + SWord8 s1629; + SWord32 s1630; + SWord8 s1631; + SWord32 s1632; + SWord8 s1633; + SWord32 s1634; + SWord32 s1635; + SWord8 s1636; + SWord32 s1637; + SWord32 s1638; + SWord8 s1639; + SWord32 s1640; + SWord32 s1641; + SWord32 s1642; + SWord8 s1643; + SWord32 s1644; + SWord32 s1645; + SWord8 s1646; + SWord32 s1647; + SWord8 s1648; + SWord32 s1649; + SWord32 s1650; + SWord8 s1651; + SWord32 s1652; + SWord32 s1653; + SWord8 s1654; + SWord32 s1655; + SWord32 s1656; + SWord32 s1657; + SWord8 s1658; + SWord32 s1659; + SWord32 s1660; + SWord8 s1661; + SWord32 s1662; + SWord8 s1663; + SWord32 s1664; + SWord32 s1665; + SWord8 s1666; + SWord32 s1667; + SWord32 s1668; + SWord8 s1669; + SWord32 s1670; + SWord32 s1671; + SWord32 s1672; + SWord8 s1673; + SWord32 s1674; + SWord32 s1675; + SWord32 s1676; + SWord8 s1677; + SWord32 s1678; + SWord8 s1679; + SWord32 s1680; + SWord8 s1681; + SWord32 s1682; + SWord32 s1683; + SWord8 s1684; + SWord32 s1685; + SWord32 s1686; + SWord8 s1687; + SWord32 s1688; + SWord32 s1689; + SWord32 s1690; + SWord8 s1691; + SWord32 s1692; + SWord32 s1693; + SWord8 s1694; + SWord32 s1695; + SWord8 s1696; + SWord32 s1697; + SWord32 s1698; + SWord8 s1699; + SWord32 s1700; + SWord32 s1701; + SWord8 s1702; + SWord32 s1703; + SWord32 s1704; + SWord32 s1705; + SWord8 s1706; + SWord32 s1707; + SWord32 s1708; + SWord8 s1709; + SWord32 s1710; + SWord8 s1711; + SWord32 s1712; + SWord32 s1713; + SWord8 s1714; + SWord32 s1715; + SWord32 s1716; + SWord8 s1717; + SWord32 s1718; + SWord32 s1719; + SWord32 s1720; + SWord8 s1721; + SWord32 s1722; + SWord32 s1723; + SWord32 s1724; + SWord8 s1725; + SWord8 s1726; + SWord8 s1727; + SWord32 s1728; + SWord8 s1729; + SWord32 s1730; + SWord32 s1731; + SWord8 s1732; + SWord32 s1733; + SWord32 s1734; + SWord8 s1735; + SWord32 s1736; + SWord32 s1737; + SWord32 s1738; + SWord8 s1739; + SWord8 s1740; + SWord16 s1741; + SWord8 s1742; + SWord32 s1743; + SWord8 s1744; + SWord32 s1745; + SWord32 s1746; + SWord8 s1747; + SWord32 s1748; + SWord32 s1749; + SWord8 s1750; + SWord32 s1751; + SWord32 s1752; + SWord32 s1753; + SWord8 s1754; + SWord8 s1755; + SWord8 s1756; + SWord32 s1757; + SWord8 s1758; + SWord32 s1759; + SWord32 s1760; + SWord8 s1761; + SWord32 s1762; + SWord32 s1763; + SWord8 s1764; + SWord32 s1765; + SWord32 s1766; + SWord32 s1767; + SWord8 s1768; + SWord8 s1769; + SWord16 s1770; + SWord32 s1771; + SWord32 s1772; + SWord8 s1773; + SWord8 s1774; + SWord8 s1775; + SWord8 s1776; + SWord16 s1777; + SWord8 s1778; + SWord8 s1779; + SWord8 s1780; + SWord8 s1781; + SWord16 s1782; + SWord32 s1783; + SWord32 s1784; + SWord8 s1785; + SWord8 s1786; + SWord8 s1787; + SWord8 s1788; + SWord16 s1789; + SWord8 s1790; + SWord8 s1791; + SWord8 s1792; + SWord8 s1793; + SWord16 s1794; + SWord32 s1795; + SWord32 s1796; + SWord8 s1797; + SWord8 s1798; + SWord8 s1799; + SWord8 s1800; + SWord16 s1801; + SWord8 s1802; + SWord8 s1803; + SWord8 s1804; + SWord8 s1805; + SWord16 s1806; + SWord32 s1807; + SWord32 s1808; + 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 + }; + s562 = table1[s561]; + 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 + }; + s820 = table2[s819]; + s821 = s562 ^ s820; + 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 + }; + s1079 = table3[s1078]; + s1080 = s821 ^ s1079; + 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 + }; + s1338 = table4[s1337]; + s1339 = s1080 ^ s1338; + s1340 = s8 ^ s1339; + s1341 = sbv_bv_extract_u32_31_24_u8(s1340); + s1342 = table1[s1341]; + s1344 = table1[s1343]; + s1346 = table2[s1345]; + s1347 = s1344 ^ s1346; + s1349 = table3[s1348]; + s1350 = s1347 ^ s1349; + s1352 = table4[s1351]; + s1353 = s1350 ^ s1352; + s1354 = s11 ^ s1353; + s1355 = sbv_bv_extract_u32_23_16_u8(s1354); + s1356 = table2[s1355]; + s1357 = s1342 ^ s1356; + s1359 = table1[s1358]; + s1361 = table2[s1360]; + s1362 = s1359 ^ s1361; + s1364 = table3[s1363]; + s1365 = s1362 ^ s1364; + s1367 = table4[s1366]; + s1368 = s1365 ^ s1367; + s1369 = s10 ^ s1368; + s1370 = sbv_bv_extract_u32_15_8_u8(s1369); + s1371 = table3[s1370]; + s1372 = s1357 ^ s1371; + s1374 = table1[s1373]; + s1376 = table2[s1375]; + s1377 = s1374 ^ s1376; + s1379 = table3[s1378]; + s1380 = s1377 ^ s1379; + s1382 = table4[s1381]; + s1383 = s1380 ^ s1382; + s1384 = s9 ^ s1383; + s1385 = sbv_bv_extract_u32_7_0_u8(s1384); + s1386 = table4[s1385]; + s1387 = s1372 ^ s1386; + s1388 = s12 ^ s1387; + s1389 = sbv_bv_extract_u32_31_24_u8(s1388); + s1390 = table1[s1389]; + s1391 = sbv_bv_extract_u32_31_24_u8(s1354); + s1392 = table1[s1391]; + s1393 = sbv_bv_extract_u32_23_16_u8(s1369); + s1394 = table2[s1393]; + s1395 = s1392 ^ s1394; + s1396 = sbv_bv_extract_u32_15_8_u8(s1384); + s1397 = table3[s1396]; + s1398 = s1395 ^ s1397; + s1399 = sbv_bv_extract_u32_7_0_u8(s1340); + s1400 = table4[s1399]; + s1401 = s1398 ^ s1400; + s1402 = s15 ^ s1401; + s1403 = sbv_bv_extract_u32_23_16_u8(s1402); + s1404 = table2[s1403]; + s1405 = s1390 ^ s1404; + s1406 = sbv_bv_extract_u32_31_24_u8(s1369); + s1407 = table1[s1406]; + s1408 = sbv_bv_extract_u32_23_16_u8(s1384); + s1409 = table2[s1408]; + s1410 = s1407 ^ s1409; + s1411 = sbv_bv_extract_u32_15_8_u8(s1340); + s1412 = table3[s1411]; + s1413 = s1410 ^ s1412; + s1414 = sbv_bv_extract_u32_7_0_u8(s1354); + s1415 = table4[s1414]; + s1416 = s1413 ^ s1415; + s1417 = s14 ^ s1416; + s1418 = sbv_bv_extract_u32_15_8_u8(s1417); + s1419 = table3[s1418]; + s1420 = s1405 ^ s1419; + s1421 = sbv_bv_extract_u32_31_24_u8(s1384); + s1422 = table1[s1421]; + s1423 = sbv_bv_extract_u32_23_16_u8(s1340); + s1424 = table2[s1423]; + s1425 = s1422 ^ s1424; + s1426 = sbv_bv_extract_u32_15_8_u8(s1354); + s1427 = table3[s1426]; + s1428 = s1425 ^ s1427; + s1429 = sbv_bv_extract_u32_7_0_u8(s1369); + s1430 = table4[s1429]; + s1431 = s1428 ^ s1430; + s1432 = s13 ^ s1431; + s1433 = sbv_bv_extract_u32_7_0_u8(s1432); + s1434 = table4[s1433]; + s1435 = s1420 ^ s1434; + s1436 = s16 ^ s1435; + s1437 = sbv_bv_extract_u32_31_24_u8(s1436); + s1438 = table1[s1437]; + s1439 = sbv_bv_extract_u32_31_24_u8(s1402); + s1440 = table1[s1439]; + s1441 = sbv_bv_extract_u32_23_16_u8(s1417); + s1442 = table2[s1441]; + s1443 = s1440 ^ s1442; + s1444 = sbv_bv_extract_u32_15_8_u8(s1432); + s1445 = table3[s1444]; + s1446 = s1443 ^ s1445; + s1447 = sbv_bv_extract_u32_7_0_u8(s1388); + s1448 = table4[s1447]; + s1449 = s1446 ^ s1448; + s1450 = s19 ^ s1449; + s1451 = sbv_bv_extract_u32_23_16_u8(s1450); + s1452 = table2[s1451]; + s1453 = s1438 ^ s1452; + s1454 = sbv_bv_extract_u32_31_24_u8(s1417); + s1455 = table1[s1454]; + s1456 = sbv_bv_extract_u32_23_16_u8(s1432); + s1457 = table2[s1456]; + s1458 = s1455 ^ s1457; + s1459 = sbv_bv_extract_u32_15_8_u8(s1388); + s1460 = table3[s1459]; + s1461 = s1458 ^ s1460; + s1462 = sbv_bv_extract_u32_7_0_u8(s1402); + s1463 = table4[s1462]; + s1464 = s1461 ^ s1463; + s1465 = s18 ^ s1464; + s1466 = sbv_bv_extract_u32_15_8_u8(s1465); + s1467 = table3[s1466]; + s1468 = s1453 ^ s1467; + s1469 = sbv_bv_extract_u32_31_24_u8(s1432); + s1470 = table1[s1469]; + s1471 = sbv_bv_extract_u32_23_16_u8(s1388); + s1472 = table2[s1471]; + s1473 = s1470 ^ s1472; + s1474 = sbv_bv_extract_u32_15_8_u8(s1402); + s1475 = table3[s1474]; + s1476 = s1473 ^ s1475; + s1477 = sbv_bv_extract_u32_7_0_u8(s1417); + s1478 = table4[s1477]; + s1479 = s1476 ^ s1478; + s1480 = s17 ^ s1479; + s1481 = sbv_bv_extract_u32_7_0_u8(s1480); + s1482 = table4[s1481]; + s1483 = s1468 ^ s1482; + s1484 = s20 ^ s1483; + s1485 = sbv_bv_extract_u32_31_24_u8(s1484); + s1486 = table1[s1485]; + s1487 = sbv_bv_extract_u32_31_24_u8(s1450); + s1488 = table1[s1487]; + s1489 = sbv_bv_extract_u32_23_16_u8(s1465); + s1490 = table2[s1489]; + s1491 = s1488 ^ s1490; + s1492 = sbv_bv_extract_u32_15_8_u8(s1480); + s1493 = table3[s1492]; + s1494 = s1491 ^ s1493; + s1495 = sbv_bv_extract_u32_7_0_u8(s1436); + s1496 = table4[s1495]; + s1497 = s1494 ^ s1496; + s1498 = s23 ^ s1497; + s1499 = sbv_bv_extract_u32_23_16_u8(s1498); + s1500 = table2[s1499]; + s1501 = s1486 ^ s1500; + s1502 = sbv_bv_extract_u32_31_24_u8(s1465); + s1503 = table1[s1502]; + s1504 = sbv_bv_extract_u32_23_16_u8(s1480); + s1505 = table2[s1504]; + s1506 = s1503 ^ s1505; + s1507 = sbv_bv_extract_u32_15_8_u8(s1436); + s1508 = table3[s1507]; + s1509 = s1506 ^ s1508; + s1510 = sbv_bv_extract_u32_7_0_u8(s1450); + s1511 = table4[s1510]; + s1512 = s1509 ^ s1511; + s1513 = s22 ^ s1512; + s1514 = sbv_bv_extract_u32_15_8_u8(s1513); + s1515 = table3[s1514]; + s1516 = s1501 ^ s1515; + s1517 = sbv_bv_extract_u32_31_24_u8(s1480); + s1518 = table1[s1517]; + s1519 = sbv_bv_extract_u32_23_16_u8(s1436); + s1520 = table2[s1519]; + s1521 = s1518 ^ s1520; + s1522 = sbv_bv_extract_u32_15_8_u8(s1450); + s1523 = table3[s1522]; + s1524 = s1521 ^ s1523; + s1525 = sbv_bv_extract_u32_7_0_u8(s1465); + s1526 = table4[s1525]; + s1527 = s1524 ^ s1526; + s1528 = s21 ^ s1527; + s1529 = sbv_bv_extract_u32_7_0_u8(s1528); + s1530 = table4[s1529]; + s1531 = s1516 ^ s1530; + s1532 = s24 ^ s1531; + s1533 = sbv_bv_extract_u32_31_24_u8(s1532); + s1534 = table1[s1533]; + s1535 = sbv_bv_extract_u32_31_24_u8(s1498); + s1536 = table1[s1535]; + s1537 = sbv_bv_extract_u32_23_16_u8(s1513); + s1538 = table2[s1537]; + s1539 = s1536 ^ s1538; + s1540 = sbv_bv_extract_u32_15_8_u8(s1528); + s1541 = table3[s1540]; + s1542 = s1539 ^ s1541; + s1543 = sbv_bv_extract_u32_7_0_u8(s1484); + s1544 = table4[s1543]; + s1545 = s1542 ^ s1544; + s1546 = s27 ^ s1545; + s1547 = sbv_bv_extract_u32_23_16_u8(s1546); + s1548 = table2[s1547]; + s1549 = s1534 ^ s1548; + s1550 = sbv_bv_extract_u32_31_24_u8(s1513); + s1551 = table1[s1550]; + s1552 = sbv_bv_extract_u32_23_16_u8(s1528); + s1553 = table2[s1552]; + s1554 = s1551 ^ s1553; + s1555 = sbv_bv_extract_u32_15_8_u8(s1484); + s1556 = table3[s1555]; + s1557 = s1554 ^ s1556; + s1558 = sbv_bv_extract_u32_7_0_u8(s1498); + s1559 = table4[s1558]; + s1560 = s1557 ^ s1559; + s1561 = s26 ^ s1560; + s1562 = sbv_bv_extract_u32_15_8_u8(s1561); + s1563 = table3[s1562]; + s1564 = s1549 ^ s1563; + s1565 = sbv_bv_extract_u32_31_24_u8(s1528); + s1566 = table1[s1565]; + s1567 = sbv_bv_extract_u32_23_16_u8(s1484); + s1568 = table2[s1567]; + s1569 = s1566 ^ s1568; + s1570 = sbv_bv_extract_u32_15_8_u8(s1498); + s1571 = table3[s1570]; + s1572 = s1569 ^ s1571; + s1573 = sbv_bv_extract_u32_7_0_u8(s1513); + s1574 = table4[s1573]; + s1575 = s1572 ^ s1574; + s1576 = s25 ^ s1575; + s1577 = sbv_bv_extract_u32_7_0_u8(s1576); + s1578 = table4[s1577]; + s1579 = s1564 ^ s1578; + s1580 = s28 ^ s1579; + s1581 = sbv_bv_extract_u32_31_24_u8(s1580); + s1582 = table1[s1581]; + s1583 = sbv_bv_extract_u32_31_24_u8(s1546); + s1584 = table1[s1583]; + s1585 = sbv_bv_extract_u32_23_16_u8(s1561); + s1586 = table2[s1585]; + s1587 = s1584 ^ s1586; + s1588 = sbv_bv_extract_u32_15_8_u8(s1576); + s1589 = table3[s1588]; + s1590 = s1587 ^ s1589; + s1591 = sbv_bv_extract_u32_7_0_u8(s1532); + s1592 = table4[s1591]; + s1593 = s1590 ^ s1592; + s1594 = s31 ^ s1593; + s1595 = sbv_bv_extract_u32_23_16_u8(s1594); + s1596 = table2[s1595]; + s1597 = s1582 ^ s1596; + s1598 = sbv_bv_extract_u32_31_24_u8(s1561); + s1599 = table1[s1598]; + s1600 = sbv_bv_extract_u32_23_16_u8(s1576); + s1601 = table2[s1600]; + s1602 = s1599 ^ s1601; + s1603 = sbv_bv_extract_u32_15_8_u8(s1532); + s1604 = table3[s1603]; + s1605 = s1602 ^ s1604; + s1606 = sbv_bv_extract_u32_7_0_u8(s1546); + s1607 = table4[s1606]; + s1608 = s1605 ^ s1607; + s1609 = s30 ^ s1608; + s1610 = sbv_bv_extract_u32_15_8_u8(s1609); + s1611 = table3[s1610]; + s1612 = s1597 ^ s1611; + s1613 = sbv_bv_extract_u32_31_24_u8(s1576); + s1614 = table1[s1613]; + s1615 = sbv_bv_extract_u32_23_16_u8(s1532); + s1616 = table2[s1615]; + s1617 = s1614 ^ s1616; + s1618 = sbv_bv_extract_u32_15_8_u8(s1546); + s1619 = table3[s1618]; + s1620 = s1617 ^ s1619; + s1621 = sbv_bv_extract_u32_7_0_u8(s1561); + s1622 = table4[s1621]; + s1623 = s1620 ^ s1622; + s1624 = s29 ^ s1623; + s1625 = sbv_bv_extract_u32_7_0_u8(s1624); + s1626 = table4[s1625]; + s1627 = s1612 ^ s1626; + s1628 = s32 ^ s1627; + s1629 = sbv_bv_extract_u32_31_24_u8(s1628); + s1630 = table1[s1629]; + s1631 = sbv_bv_extract_u32_31_24_u8(s1594); + s1632 = table1[s1631]; + s1633 = sbv_bv_extract_u32_23_16_u8(s1609); + s1634 = table2[s1633]; + s1635 = s1632 ^ s1634; + s1636 = sbv_bv_extract_u32_15_8_u8(s1624); + s1637 = table3[s1636]; + s1638 = s1635 ^ s1637; + s1639 = sbv_bv_extract_u32_7_0_u8(s1580); + s1640 = table4[s1639]; + s1641 = s1638 ^ s1640; + s1642 = s35 ^ s1641; + s1643 = sbv_bv_extract_u32_23_16_u8(s1642); + s1644 = table2[s1643]; + s1645 = s1630 ^ s1644; + s1646 = sbv_bv_extract_u32_31_24_u8(s1609); + s1647 = table1[s1646]; + s1648 = sbv_bv_extract_u32_23_16_u8(s1624); + s1649 = table2[s1648]; + s1650 = s1647 ^ s1649; + s1651 = sbv_bv_extract_u32_15_8_u8(s1580); + s1652 = table3[s1651]; + s1653 = s1650 ^ s1652; + s1654 = sbv_bv_extract_u32_7_0_u8(s1594); + s1655 = table4[s1654]; + s1656 = s1653 ^ s1655; + s1657 = s34 ^ s1656; + s1658 = sbv_bv_extract_u32_15_8_u8(s1657); + s1659 = table3[s1658]; + s1660 = s1645 ^ s1659; + s1661 = sbv_bv_extract_u32_31_24_u8(s1624); + s1662 = table1[s1661]; + s1663 = sbv_bv_extract_u32_23_16_u8(s1580); + s1664 = table2[s1663]; + s1665 = s1662 ^ s1664; + s1666 = sbv_bv_extract_u32_15_8_u8(s1594); + s1667 = table3[s1666]; + s1668 = s1665 ^ s1667; + s1669 = sbv_bv_extract_u32_7_0_u8(s1609); + s1670 = table4[s1669]; + s1671 = s1668 ^ s1670; + s1672 = s33 ^ s1671; + s1673 = sbv_bv_extract_u32_7_0_u8(s1672); + s1674 = table4[s1673]; + s1675 = s1660 ^ s1674; + s1676 = s36 ^ s1675; + s1677 = sbv_bv_extract_u32_31_24_u8(s1676); + s1678 = table1[s1677]; + s1679 = sbv_bv_extract_u32_31_24_u8(s1642); + s1680 = table1[s1679]; + s1681 = sbv_bv_extract_u32_23_16_u8(s1657); + s1682 = table2[s1681]; + s1683 = s1680 ^ s1682; + s1684 = sbv_bv_extract_u32_15_8_u8(s1672); + s1685 = table3[s1684]; + s1686 = s1683 ^ s1685; + s1687 = sbv_bv_extract_u32_7_0_u8(s1628); + s1688 = table4[s1687]; + s1689 = s1686 ^ s1688; + s1690 = s39 ^ s1689; + s1691 = sbv_bv_extract_u32_23_16_u8(s1690); + s1692 = table2[s1691]; + s1693 = s1678 ^ s1692; + s1694 = sbv_bv_extract_u32_31_24_u8(s1657); + s1695 = table1[s1694]; + s1696 = sbv_bv_extract_u32_23_16_u8(s1672); + s1697 = table2[s1696]; + s1698 = s1695 ^ s1697; + s1699 = sbv_bv_extract_u32_15_8_u8(s1628); + s1700 = table3[s1699]; + s1701 = s1698 ^ s1700; + s1702 = sbv_bv_extract_u32_7_0_u8(s1642); + s1703 = table4[s1702]; + s1704 = s1701 ^ s1703; + s1705 = s38 ^ s1704; + s1706 = sbv_bv_extract_u32_15_8_u8(s1705); + s1707 = table3[s1706]; + s1708 = s1693 ^ s1707; + s1709 = sbv_bv_extract_u32_31_24_u8(s1672); + s1710 = table1[s1709]; + s1711 = sbv_bv_extract_u32_23_16_u8(s1628); + s1712 = table2[s1711]; + s1713 = s1710 ^ s1712; + s1714 = sbv_bv_extract_u32_15_8_u8(s1642); + s1715 = table3[s1714]; + s1716 = s1713 ^ s1715; + s1717 = sbv_bv_extract_u32_7_0_u8(s1657); + s1718 = table4[s1717]; + s1719 = s1716 ^ s1718; + s1720 = s37 ^ s1719; + s1721 = sbv_bv_extract_u32_7_0_u8(s1720); + s1722 = table4[s1721]; + s1723 = s1708 ^ s1722; + s1724 = s40 ^ s1723; + s1725 = sbv_bv_extract_u32_31_24_u8(s1724); + 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 + }; + s1726 = table0[s1725]; + s1727 = sbv_bv_extract_u32_31_24_u8(s1690); + s1728 = table1[s1727]; + s1729 = sbv_bv_extract_u32_23_16_u8(s1705); + s1730 = table2[s1729]; + s1731 = s1728 ^ s1730; + s1732 = sbv_bv_extract_u32_15_8_u8(s1720); + s1733 = table3[s1732]; + s1734 = s1731 ^ s1733; + s1735 = sbv_bv_extract_u32_7_0_u8(s1676); + s1736 = table4[s1735]; + s1737 = s1734 ^ s1736; + s1738 = s43 ^ s1737; + s1739 = sbv_bv_extract_u32_23_16_u8(s1738); + s1740 = table0[s1739]; + s1741 = sbv_bv_join_u8_u8_u16(s1726, s1740); + s1742 = sbv_bv_extract_u32_31_24_u8(s1705); + s1743 = table1[s1742]; + s1744 = sbv_bv_extract_u32_23_16_u8(s1720); + s1745 = table2[s1744]; + s1746 = s1743 ^ s1745; + s1747 = sbv_bv_extract_u32_15_8_u8(s1676); + s1748 = table3[s1747]; + s1749 = s1746 ^ s1748; + s1750 = sbv_bv_extract_u32_7_0_u8(s1690); + s1751 = table4[s1750]; + s1752 = s1749 ^ s1751; + s1753 = s42 ^ s1752; + s1754 = sbv_bv_extract_u32_15_8_u8(s1753); + s1755 = table0[s1754]; + s1756 = sbv_bv_extract_u32_31_24_u8(s1720); + s1757 = table1[s1756]; + s1758 = sbv_bv_extract_u32_23_16_u8(s1676); + s1759 = table2[s1758]; + s1760 = s1757 ^ s1759; + s1761 = sbv_bv_extract_u32_15_8_u8(s1690); + s1762 = table3[s1761]; + s1763 = s1760 ^ s1762; + s1764 = sbv_bv_extract_u32_7_0_u8(s1705); + s1765 = table4[s1764]; + s1766 = s1763 ^ s1765; + s1767 = s41 ^ s1766; + s1768 = sbv_bv_extract_u32_7_0_u8(s1767); + s1769 = table0[s1768]; + s1770 = sbv_bv_join_u8_u8_u16(s1755, s1769); + s1771 = sbv_bv_join_u16_u16_u32(s1741, s1770); + s1772 = s44 ^ s1771; + s1773 = sbv_bv_extract_u32_31_24_u8(s1767); + s1774 = table0[s1773]; + s1775 = sbv_bv_extract_u32_23_16_u8(s1724); + s1776 = table0[s1775]; + s1777 = sbv_bv_join_u8_u8_u16(s1774, s1776); + s1778 = sbv_bv_extract_u32_15_8_u8(s1738); + s1779 = table0[s1778]; + s1780 = sbv_bv_extract_u32_7_0_u8(s1753); + s1781 = table0[s1780]; + s1782 = sbv_bv_join_u8_u8_u16(s1779, s1781); + s1783 = sbv_bv_join_u16_u16_u32(s1777, s1782); + s1784 = s45 ^ s1783; + s1785 = sbv_bv_extract_u32_31_24_u8(s1753); + s1786 = table0[s1785]; + s1787 = sbv_bv_extract_u32_23_16_u8(s1767); + s1788 = table0[s1787]; + s1789 = sbv_bv_join_u8_u8_u16(s1786, s1788); + s1790 = sbv_bv_extract_u32_15_8_u8(s1724); + s1791 = table0[s1790]; + s1792 = sbv_bv_extract_u32_7_0_u8(s1738); + s1793 = table0[s1792]; + s1794 = sbv_bv_join_u8_u8_u16(s1791, s1793); + s1795 = sbv_bv_join_u16_u16_u32(s1789, s1794); + s1796 = s46 ^ s1795; + s1797 = sbv_bv_extract_u32_31_24_u8(s1738); + s1798 = table0[s1797]; + s1799 = sbv_bv_extract_u32_23_16_u8(s1753); + s1800 = table0[s1799]; + s1801 = sbv_bv_join_u8_u8_u16(s1798, s1800); + s1802 = sbv_bv_extract_u32_15_8_u8(s1767); + s1803 = table0[s1802]; + s1804 = sbv_bv_extract_u32_7_0_u8(s1724); + s1805 = table0[s1804]; + s1806 = sbv_bv_join_u8_u8_u16(s1803, s1805); + s1807 = sbv_bv_join_u16_u16_u32(s1801, s1806); + s1808 = s47 ^ s1807; + + sbv_output_0[0] = s1772; + sbv_output_0[1] = s1784; + sbv_output_0[2] = s1796; + sbv_output_0[3] = s1808; +} +== END: "aes128BlockDecrypt.c" ================== +== BEGIN: "aes128InvKeySchedule.c" ================ +/* File: "aes128InvKeySchedule.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Lib.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotl(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) << amount) | (((uint64_t) (SWord32) a) >> (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotr(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) >> amount) | (((uint64_t) (SWord32) a) << (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128InvKeySchedule(const SWord32 *sbv_input_0, + SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s260 = s2 ^ s3; + const SWord32 s261 = sbv_bv_u32_rotl(s260, 8); + const SWord8 s262 = sbv_bv_extract_u32_31_24_u8(s261); + const SWord8 s265 = sbv_bv_extract_u32_23_16_u8(s261); + const SWord8 s268 = sbv_bv_extract_u32_15_8_u8(s261); + const SWord8 s270 = sbv_bv_extract_u32_7_0_u8(s261); + const SWord32 s275 = s0 ^ s1; + const SWord32 s276 = s1 ^ s2; + const SWord32 s277 = s260 ^ s276; + const SWord32 s278 = sbv_bv_u32_rotl(s277, 8); + const SWord8 s279 = sbv_bv_extract_u32_31_24_u8(s278); + const SWord8 s282 = sbv_bv_extract_u32_23_16_u8(s278); + const SWord8 s285 = sbv_bv_extract_u32_15_8_u8(s278); + const SWord8 s287 = sbv_bv_extract_u32_7_0_u8(s278); + const SWord32 s293 = s275 ^ s276; + const SWord32 s294 = s277 ^ s293; + const SWord32 s295 = sbv_bv_u32_rotl(s294, 8); + const SWord8 s296 = sbv_bv_extract_u32_31_24_u8(s295); + const SWord8 s299 = sbv_bv_extract_u32_23_16_u8(s295); + const SWord8 s302 = sbv_bv_extract_u32_15_8_u8(s295); + const SWord8 s304 = sbv_bv_extract_u32_7_0_u8(s295); + SWord8 s263; + SWord8 s264; + SWord8 s266; + SWord16 s267; + SWord8 s269; + SWord8 s271; + SWord16 s272; + SWord32 s273; + SWord32 s274; + SWord8 s280; + SWord8 s281; + SWord8 s283; + SWord16 s284; + SWord8 s286; + SWord8 s288; + SWord16 s289; + SWord32 s290; + SWord32 s291; + SWord32 s292; + SWord8 s297; + SWord8 s298; + SWord8 s300; + SWord16 s301; + SWord8 s303; + SWord8 s305; + SWord16 s306; + SWord32 s307; + SWord32 s308; + SWord32 s309; + SWord32 s310; + SWord32 s311; + SWord32 s312; + SWord8 s313; + SWord8 s314; + SWord8 s315; + SWord8 s316; + SWord8 s317; + SWord16 s318; + SWord8 s319; + SWord8 s320; + SWord8 s321; + SWord8 s322; + SWord16 s323; + SWord32 s324; + SWord32 s325; + SWord32 s326; + SWord32 s327; + SWord32 s328; + SWord32 s329; + SWord8 s330; + SWord8 s331; + SWord8 s332; + SWord8 s333; + SWord8 s334; + SWord16 s335; + SWord8 s336; + SWord8 s337; + SWord8 s338; + SWord8 s339; + SWord16 s340; + SWord32 s341; + SWord32 s342; + SWord32 s343; + SWord32 s344; + SWord32 s345; + SWord32 s346; + SWord8 s347; + SWord8 s348; + SWord8 s349; + SWord8 s350; + SWord8 s351; + SWord16 s352; + SWord8 s353; + SWord8 s354; + SWord8 s355; + SWord8 s356; + SWord16 s357; + SWord32 s358; + SWord32 s359; + SWord32 s360; + SWord32 s361; + SWord32 s362; + SWord32 s363; + SWord8 s364; + SWord8 s365; + SWord8 s366; + SWord8 s367; + SWord8 s368; + SWord16 s369; + SWord8 s370; + SWord8 s371; + SWord8 s372; + SWord8 s373; + SWord16 s374; + SWord32 s375; + SWord32 s376; + SWord32 s377; + SWord32 s378; + SWord32 s379; + SWord32 s380; + SWord8 s381; + SWord8 s382; + SWord8 s383; + SWord8 s384; + SWord8 s385; + SWord16 s386; + SWord8 s387; + SWord8 s388; + SWord8 s389; + SWord8 s390; + SWord16 s391; + SWord32 s392; + SWord32 s393; + SWord32 s394; + SWord32 s395; + SWord32 s396; + SWord32 s397; + SWord8 s398; + SWord8 s399; + SWord8 s400; + SWord8 s401; + SWord8 s402; + SWord16 s403; + SWord8 s404; + SWord8 s405; + SWord8 s406; + SWord8 s407; + SWord16 s408; + SWord32 s409; + SWord32 s410; + SWord32 s411; + SWord32 s412; + SWord32 s413; + SWord32 s414; + SWord8 s415; + SWord8 s416; + SWord8 s417; + SWord8 s418; + SWord8 s419; + SWord16 s420; + SWord8 s421; + SWord8 s422; + SWord8 s423; + SWord8 s424; + SWord16 s425; + SWord32 s426; + SWord32 s427; + SWord32 s428; + SWord32 s429; + 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 + }; + s263 = table0[s262]; + s264 = 54 ^ s263; + s266 = table0[s265]; + s267 = sbv_bv_join_u8_u8_u16(s264, s266); + s269 = table0[s268]; + s271 = table0[s270]; + s272 = sbv_bv_join_u8_u8_u16(s269, s271); + s273 = sbv_bv_join_u16_u16_u32(s267, s272); + s274 = s0 ^ s273; + s280 = table0[s279]; + s281 = 27 ^ s280; + s283 = table0[s282]; + s284 = sbv_bv_join_u8_u8_u16(s281, s283); + s286 = table0[s285]; + s288 = table0[s287]; + s289 = sbv_bv_join_u8_u8_u16(s286, s288); + s290 = sbv_bv_join_u16_u16_u32(s284, s289); + s291 = s274 ^ s290; + s292 = s274 ^ s275; + s297 = table0[s296]; + s298 = 128 ^ s297; + s300 = table0[s299]; + s301 = sbv_bv_join_u8_u8_u16(s298, s300); + s303 = table0[s302]; + s305 = table0[s304]; + s306 = sbv_bv_join_u8_u8_u16(s303, s305); + s307 = sbv_bv_join_u16_u16_u32(s301, s306); + s308 = s291 ^ s307; + s309 = s291 ^ s292; + s310 = s292 ^ s293; + s311 = s294 ^ s310; + s312 = sbv_bv_u32_rotl(s311, 8); + s313 = sbv_bv_extract_u32_31_24_u8(s312); + s314 = table0[s313]; + s315 = 64 ^ s314; + s316 = sbv_bv_extract_u32_23_16_u8(s312); + s317 = table0[s316]; + s318 = sbv_bv_join_u8_u8_u16(s315, s317); + s319 = sbv_bv_extract_u32_15_8_u8(s312); + s320 = table0[s319]; + s321 = sbv_bv_extract_u32_7_0_u8(s312); + s322 = table0[s321]; + s323 = sbv_bv_join_u8_u8_u16(s320, s322); + s324 = sbv_bv_join_u16_u16_u32(s318, s323); + s325 = s308 ^ s324; + s326 = s308 ^ s309; + s327 = s309 ^ s310; + s328 = s311 ^ s327; + s329 = sbv_bv_u32_rotl(s328, 8); + s330 = sbv_bv_extract_u32_31_24_u8(s329); + s331 = table0[s330]; + s332 = 32 ^ s331; + s333 = sbv_bv_extract_u32_23_16_u8(s329); + s334 = table0[s333]; + s335 = sbv_bv_join_u8_u8_u16(s332, s334); + s336 = sbv_bv_extract_u32_15_8_u8(s329); + s337 = table0[s336]; + s338 = sbv_bv_extract_u32_7_0_u8(s329); + s339 = table0[s338]; + s340 = sbv_bv_join_u8_u8_u16(s337, s339); + s341 = sbv_bv_join_u16_u16_u32(s335, s340); + s342 = s325 ^ s341; + s343 = s325 ^ s326; + s344 = s326 ^ s327; + s345 = s328 ^ s344; + s346 = sbv_bv_u32_rotl(s345, 8); + s347 = sbv_bv_extract_u32_31_24_u8(s346); + s348 = table0[s347]; + s349 = 16 ^ s348; + s350 = sbv_bv_extract_u32_23_16_u8(s346); + s351 = table0[s350]; + s352 = sbv_bv_join_u8_u8_u16(s349, s351); + s353 = sbv_bv_extract_u32_15_8_u8(s346); + s354 = table0[s353]; + s355 = sbv_bv_extract_u32_7_0_u8(s346); + s356 = table0[s355]; + s357 = sbv_bv_join_u8_u8_u16(s354, s356); + s358 = sbv_bv_join_u16_u16_u32(s352, s357); + s359 = s342 ^ s358; + s360 = s342 ^ s343; + s361 = s343 ^ s344; + s362 = s345 ^ s361; + s363 = sbv_bv_u32_rotl(s362, 8); + s364 = sbv_bv_extract_u32_31_24_u8(s363); + s365 = table0[s364]; + s366 = 8 ^ s365; + s367 = sbv_bv_extract_u32_23_16_u8(s363); + s368 = table0[s367]; + s369 = sbv_bv_join_u8_u8_u16(s366, s368); + s370 = sbv_bv_extract_u32_15_8_u8(s363); + s371 = table0[s370]; + s372 = sbv_bv_extract_u32_7_0_u8(s363); + s373 = table0[s372]; + s374 = sbv_bv_join_u8_u8_u16(s371, s373); + s375 = sbv_bv_join_u16_u16_u32(s369, s374); + s376 = s359 ^ s375; + s377 = s359 ^ s360; + s378 = s360 ^ s361; + s379 = s362 ^ s378; + s380 = sbv_bv_u32_rotl(s379, 8); + s381 = sbv_bv_extract_u32_31_24_u8(s380); + s382 = table0[s381]; + s383 = 4 ^ s382; + s384 = sbv_bv_extract_u32_23_16_u8(s380); + s385 = table0[s384]; + s386 = sbv_bv_join_u8_u8_u16(s383, s385); + s387 = sbv_bv_extract_u32_15_8_u8(s380); + s388 = table0[s387]; + s389 = sbv_bv_extract_u32_7_0_u8(s380); + s390 = table0[s389]; + s391 = sbv_bv_join_u8_u8_u16(s388, s390); + s392 = sbv_bv_join_u16_u16_u32(s386, s391); + s393 = s376 ^ s392; + s394 = s376 ^ s377; + s395 = s377 ^ s378; + s396 = s379 ^ s395; + s397 = sbv_bv_u32_rotl(s396, 8); + s398 = sbv_bv_extract_u32_31_24_u8(s397); + s399 = table0[s398]; + s400 = 2 ^ s399; + s401 = sbv_bv_extract_u32_23_16_u8(s397); + s402 = table0[s401]; + s403 = sbv_bv_join_u8_u8_u16(s400, s402); + s404 = sbv_bv_extract_u32_15_8_u8(s397); + s405 = table0[s404]; + s406 = sbv_bv_extract_u32_7_0_u8(s397); + s407 = table0[s406]; + s408 = sbv_bv_join_u8_u8_u16(s405, s407); + s409 = sbv_bv_join_u16_u16_u32(s403, s408); + s410 = s393 ^ s409; + s411 = s393 ^ s394; + s412 = s394 ^ s395; + s413 = s396 ^ s412; + s414 = sbv_bv_u32_rotl(s413, 8); + s415 = sbv_bv_extract_u32_31_24_u8(s414); + s416 = table0[s415]; + s417 = 1 ^ s416; + s418 = sbv_bv_extract_u32_23_16_u8(s414); + s419 = table0[s418]; + s420 = sbv_bv_join_u8_u8_u16(s417, s419); + s421 = sbv_bv_extract_u32_15_8_u8(s414); + s422 = table0[s421]; + s423 = sbv_bv_extract_u32_7_0_u8(s414); + s424 = table0[s423]; + s425 = sbv_bv_join_u8_u8_u16(s422, s424); + s426 = sbv_bv_join_u16_u16_u32(s420, s425); + s427 = s410 ^ s426; + s428 = s410 ^ s411; + s429 = s411 ^ s412; + + sbv_output_0[0] = s0; + sbv_output_0[1] = s1; + sbv_output_0[2] = s2; + sbv_output_0[3] = s3; + sbv_output_0[4] = s274; + sbv_output_0[5] = s275; + sbv_output_0[6] = s276; + sbv_output_0[7] = s260; + sbv_output_0[8] = s291; + sbv_output_0[9] = s292; + sbv_output_0[10] = s293; + sbv_output_0[11] = s277; + sbv_output_0[12] = s308; + sbv_output_0[13] = s309; + sbv_output_0[14] = s310; + sbv_output_0[15] = s294; + sbv_output_0[16] = s325; + sbv_output_0[17] = s326; + sbv_output_0[18] = s327; + sbv_output_0[19] = s311; + sbv_output_0[20] = s342; + sbv_output_0[21] = s343; + sbv_output_0[22] = s344; + sbv_output_0[23] = s328; + sbv_output_0[24] = s359; + sbv_output_0[25] = s360; + sbv_output_0[26] = s361; + sbv_output_0[27] = s345; + sbv_output_0[28] = s376; + sbv_output_0[29] = s377; + sbv_output_0[30] = s378; + sbv_output_0[31] = s362; + sbv_output_0[32] = s393; + sbv_output_0[33] = s394; + sbv_output_0[34] = s395; + sbv_output_0[35] = s379; + sbv_output_0[36] = s410; + sbv_output_0[37] = s411; + sbv_output_0[38] = s412; + sbv_output_0[39] = s396; + sbv_output_0[40] = s427; + sbv_output_0[41] = s428; + sbv_output_0[42] = s429; + sbv_output_0[43] = s413; +} +== END: "aes128InvKeySchedule.c" ================== +== BEGIN: "aes128OTFDecrypt.c" ================ +/* File: "aes128OTFDecrypt.c". Automatically generated by SBV. Do not edit! */ + +#include "aes128Lib.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + + +void aes128OTFDecrypt(const SWord32 *sbv_input_0, + const SWord32 *sbv_input_1, SWord32 *sbv_output_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + const SWord32 s3 = sbv_input_0[3]; + const SWord32 s4 = sbv_input_1[0]; + const SWord32 s5 = sbv_input_1[1]; + const SWord32 s6 = sbv_input_1[2]; + const SWord32 s7 = sbv_input_1[3]; + const SWord32 s8 = sbv_input_1[4]; + const SWord32 s9 = sbv_input_1[5]; + const SWord32 s10 = sbv_input_1[6]; + const SWord32 s11 = sbv_input_1[7]; + const SWord32 s12 = sbv_input_1[8]; + const SWord32 s13 = sbv_input_1[9]; + const SWord32 s14 = sbv_input_1[10]; + const SWord32 s15 = sbv_input_1[11]; + const SWord32 s16 = sbv_input_1[12]; + const SWord32 s17 = sbv_input_1[13]; + const SWord32 s18 = sbv_input_1[14]; + const SWord32 s19 = sbv_input_1[15]; + const SWord32 s20 = sbv_input_1[16]; + const SWord32 s21 = sbv_input_1[17]; + const SWord32 s22 = sbv_input_1[18]; + const SWord32 s23 = sbv_input_1[19]; + const SWord32 s24 = sbv_input_1[20]; + const SWord32 s25 = sbv_input_1[21]; + const SWord32 s26 = sbv_input_1[22]; + const SWord32 s27 = sbv_input_1[23]; + const SWord32 s28 = sbv_input_1[24]; + const SWord32 s29 = sbv_input_1[25]; + const SWord32 s30 = sbv_input_1[26]; + const SWord32 s31 = sbv_input_1[27]; + const SWord32 s32 = sbv_input_1[28]; + const SWord32 s33 = sbv_input_1[29]; + const SWord32 s34 = sbv_input_1[30]; + const SWord32 s35 = sbv_input_1[31]; + const SWord32 s36 = sbv_input_1[32]; + const SWord32 s37 = sbv_input_1[33]; + const SWord32 s38 = sbv_input_1[34]; + const SWord32 s39 = sbv_input_1[35]; + const SWord32 s40 = sbv_input_1[36]; + const SWord32 s41 = sbv_input_1[37]; + const SWord32 s42 = sbv_input_1[38]; + const SWord32 s43 = sbv_input_1[39]; + const SWord32 s44 = sbv_input_1[40]; + const SWord32 s45 = sbv_input_1[41]; + const SWord32 s46 = sbv_input_1[42]; + const SWord32 s47 = sbv_input_1[43]; + const SWord32 s560 = s0 ^ s4; + const SWord8 s561 = sbv_bv_extract_u32_31_24_u8(s560); + const SWord8 s563 = sbv_bv_extract_u32_31_24_u8(s8); + const SWord32 s821 = s3 ^ s7; + const SWord8 s822 = sbv_bv_extract_u32_23_16_u8(s821); + const SWord8 s824 = sbv_bv_extract_u32_23_16_u8(s8); + const SWord32 s1083 = s2 ^ s6; + const SWord8 s1084 = sbv_bv_extract_u32_15_8_u8(s1083); + const SWord8 s1086 = sbv_bv_extract_u32_15_8_u8(s8); + const SWord32 s1345 = s1 ^ s5; + const SWord8 s1346 = sbv_bv_extract_u32_7_0_u8(s1345); + const SWord8 s1348 = sbv_bv_extract_u32_7_0_u8(s8); + const SWord8 s1354 = sbv_bv_extract_u32_31_24_u8(s12); + const SWord8 s1357 = sbv_bv_extract_u32_31_24_u8(s821); + const SWord8 s1359 = sbv_bv_extract_u32_31_24_u8(s11); + const SWord8 s1362 = sbv_bv_extract_u32_23_16_u8(s1083); + const SWord8 s1364 = sbv_bv_extract_u32_23_16_u8(s11); + const SWord8 s1368 = sbv_bv_extract_u32_15_8_u8(s1345); + const SWord8 s1370 = sbv_bv_extract_u32_15_8_u8(s11); + const SWord8 s1374 = sbv_bv_extract_u32_7_0_u8(s560); + const SWord8 s1376 = sbv_bv_extract_u32_7_0_u8(s11); + const SWord8 s1382 = sbv_bv_extract_u32_23_16_u8(s12); + const SWord8 s1386 = sbv_bv_extract_u32_31_24_u8(s1083); + const SWord8 s1388 = sbv_bv_extract_u32_31_24_u8(s10); + const SWord8 s1391 = sbv_bv_extract_u32_23_16_u8(s1345); + const SWord8 s1393 = sbv_bv_extract_u32_23_16_u8(s10); + const SWord8 s1397 = sbv_bv_extract_u32_15_8_u8(s560); + const SWord8 s1399 = sbv_bv_extract_u32_15_8_u8(s10); + const SWord8 s1403 = sbv_bv_extract_u32_7_0_u8(s821); + const SWord8 s1405 = sbv_bv_extract_u32_7_0_u8(s10); + const SWord8 s1411 = sbv_bv_extract_u32_15_8_u8(s12); + const SWord8 s1415 = sbv_bv_extract_u32_31_24_u8(s1345); + const SWord8 s1417 = sbv_bv_extract_u32_31_24_u8(s9); + const SWord8 s1420 = sbv_bv_extract_u32_23_16_u8(s560); + const SWord8 s1422 = sbv_bv_extract_u32_23_16_u8(s9); + const SWord8 s1426 = sbv_bv_extract_u32_15_8_u8(s821); + const SWord8 s1428 = sbv_bv_extract_u32_15_8_u8(s9); + const SWord8 s1432 = sbv_bv_extract_u32_7_0_u8(s1083); + const SWord8 s1434 = sbv_bv_extract_u32_7_0_u8(s9); + const SWord8 s1440 = sbv_bv_extract_u32_7_0_u8(s12); + const SWord8 s1446 = sbv_bv_extract_u32_31_24_u8(s16); + const SWord8 s1451 = sbv_bv_extract_u32_31_24_u8(s15); + const SWord8 s1456 = sbv_bv_extract_u32_23_16_u8(s15); + const SWord8 s1462 = sbv_bv_extract_u32_15_8_u8(s15); + const SWord8 s1468 = sbv_bv_extract_u32_7_0_u8(s15); + const SWord8 s1474 = sbv_bv_extract_u32_23_16_u8(s16); + const SWord8 s1480 = sbv_bv_extract_u32_31_24_u8(s14); + const SWord8 s1485 = sbv_bv_extract_u32_23_16_u8(s14); + const SWord8 s1491 = sbv_bv_extract_u32_15_8_u8(s14); + const SWord8 s1497 = sbv_bv_extract_u32_7_0_u8(s14); + const SWord8 s1503 = sbv_bv_extract_u32_15_8_u8(s16); + const SWord8 s1509 = sbv_bv_extract_u32_31_24_u8(s13); + const SWord8 s1514 = sbv_bv_extract_u32_23_16_u8(s13); + const SWord8 s1520 = sbv_bv_extract_u32_15_8_u8(s13); + const SWord8 s1526 = sbv_bv_extract_u32_7_0_u8(s13); + const SWord8 s1532 = sbv_bv_extract_u32_7_0_u8(s16); + const SWord8 s1538 = sbv_bv_extract_u32_31_24_u8(s20); + const SWord8 s1543 = sbv_bv_extract_u32_31_24_u8(s19); + const SWord8 s1548 = sbv_bv_extract_u32_23_16_u8(s19); + const SWord8 s1554 = sbv_bv_extract_u32_15_8_u8(s19); + const SWord8 s1560 = sbv_bv_extract_u32_7_0_u8(s19); + const SWord8 s1566 = sbv_bv_extract_u32_23_16_u8(s20); + const SWord8 s1572 = sbv_bv_extract_u32_31_24_u8(s18); + const SWord8 s1577 = sbv_bv_extract_u32_23_16_u8(s18); + const SWord8 s1583 = sbv_bv_extract_u32_15_8_u8(s18); + const SWord8 s1589 = sbv_bv_extract_u32_7_0_u8(s18); + const SWord8 s1595 = sbv_bv_extract_u32_15_8_u8(s20); + const SWord8 s1601 = sbv_bv_extract_u32_31_24_u8(s17); + const SWord8 s1606 = sbv_bv_extract_u32_23_16_u8(s17); + const SWord8 s1612 = sbv_bv_extract_u32_15_8_u8(s17); + const SWord8 s1618 = sbv_bv_extract_u32_7_0_u8(s17); + const SWord8 s1624 = sbv_bv_extract_u32_7_0_u8(s20); + const SWord8 s1630 = sbv_bv_extract_u32_31_24_u8(s24); + const SWord8 s1635 = sbv_bv_extract_u32_31_24_u8(s23); + const SWord8 s1640 = sbv_bv_extract_u32_23_16_u8(s23); + const SWord8 s1646 = sbv_bv_extract_u32_15_8_u8(s23); + const SWord8 s1652 = sbv_bv_extract_u32_7_0_u8(s23); + const SWord8 s1658 = sbv_bv_extract_u32_23_16_u8(s24); + const SWord8 s1664 = sbv_bv_extract_u32_31_24_u8(s22); + const SWord8 s1669 = sbv_bv_extract_u32_23_16_u8(s22); + const SWord8 s1675 = sbv_bv_extract_u32_15_8_u8(s22); + const SWord8 s1681 = sbv_bv_extract_u32_7_0_u8(s22); + const SWord8 s1687 = sbv_bv_extract_u32_15_8_u8(s24); + const SWord8 s1693 = sbv_bv_extract_u32_31_24_u8(s21); + const SWord8 s1698 = sbv_bv_extract_u32_23_16_u8(s21); + const SWord8 s1704 = sbv_bv_extract_u32_15_8_u8(s21); + const SWord8 s1710 = sbv_bv_extract_u32_7_0_u8(s21); + const SWord8 s1716 = sbv_bv_extract_u32_7_0_u8(s24); + const SWord8 s1722 = sbv_bv_extract_u32_31_24_u8(s28); + const SWord8 s1727 = sbv_bv_extract_u32_31_24_u8(s27); + const SWord8 s1732 = sbv_bv_extract_u32_23_16_u8(s27); + const SWord8 s1738 = sbv_bv_extract_u32_15_8_u8(s27); + const SWord8 s1744 = sbv_bv_extract_u32_7_0_u8(s27); + const SWord8 s1750 = sbv_bv_extract_u32_23_16_u8(s28); + const SWord8 s1756 = sbv_bv_extract_u32_31_24_u8(s26); + const SWord8 s1761 = sbv_bv_extract_u32_23_16_u8(s26); + const SWord8 s1767 = sbv_bv_extract_u32_15_8_u8(s26); + const SWord8 s1773 = sbv_bv_extract_u32_7_0_u8(s26); + const SWord8 s1779 = sbv_bv_extract_u32_15_8_u8(s28); + const SWord8 s1785 = sbv_bv_extract_u32_31_24_u8(s25); + const SWord8 s1790 = sbv_bv_extract_u32_23_16_u8(s25); + const SWord8 s1796 = sbv_bv_extract_u32_15_8_u8(s25); + const SWord8 s1802 = sbv_bv_extract_u32_7_0_u8(s25); + const SWord8 s1808 = sbv_bv_extract_u32_7_0_u8(s28); + const SWord8 s1814 = sbv_bv_extract_u32_31_24_u8(s32); + const SWord8 s1819 = sbv_bv_extract_u32_31_24_u8(s31); + const SWord8 s1824 = sbv_bv_extract_u32_23_16_u8(s31); + const SWord8 s1830 = sbv_bv_extract_u32_15_8_u8(s31); + const SWord8 s1836 = sbv_bv_extract_u32_7_0_u8(s31); + const SWord8 s1842 = sbv_bv_extract_u32_23_16_u8(s32); + const SWord8 s1848 = sbv_bv_extract_u32_31_24_u8(s30); + const SWord8 s1853 = sbv_bv_extract_u32_23_16_u8(s30); + const SWord8 s1859 = sbv_bv_extract_u32_15_8_u8(s30); + const SWord8 s1865 = sbv_bv_extract_u32_7_0_u8(s30); + const SWord8 s1871 = sbv_bv_extract_u32_15_8_u8(s32); + const SWord8 s1877 = sbv_bv_extract_u32_31_24_u8(s29); + const SWord8 s1882 = sbv_bv_extract_u32_23_16_u8(s29); + const SWord8 s1888 = sbv_bv_extract_u32_15_8_u8(s29); + const SWord8 s1894 = sbv_bv_extract_u32_7_0_u8(s29); + const SWord8 s1900 = sbv_bv_extract_u32_7_0_u8(s32); + const SWord8 s1906 = sbv_bv_extract_u32_31_24_u8(s36); + const SWord8 s1911 = sbv_bv_extract_u32_31_24_u8(s35); + const SWord8 s1916 = sbv_bv_extract_u32_23_16_u8(s35); + const SWord8 s1922 = sbv_bv_extract_u32_15_8_u8(s35); + const SWord8 s1928 = sbv_bv_extract_u32_7_0_u8(s35); + const SWord8 s1934 = sbv_bv_extract_u32_23_16_u8(s36); + const SWord8 s1940 = sbv_bv_extract_u32_31_24_u8(s34); + const SWord8 s1945 = sbv_bv_extract_u32_23_16_u8(s34); + const SWord8 s1951 = sbv_bv_extract_u32_15_8_u8(s34); + const SWord8 s1957 = sbv_bv_extract_u32_7_0_u8(s34); + const SWord8 s1963 = sbv_bv_extract_u32_15_8_u8(s36); + const SWord8 s1969 = sbv_bv_extract_u32_31_24_u8(s33); + const SWord8 s1974 = sbv_bv_extract_u32_23_16_u8(s33); + const SWord8 s1980 = sbv_bv_extract_u32_15_8_u8(s33); + const SWord8 s1986 = sbv_bv_extract_u32_7_0_u8(s33); + const SWord8 s1992 = sbv_bv_extract_u32_7_0_u8(s36); + const SWord8 s1998 = sbv_bv_extract_u32_31_24_u8(s40); + const SWord8 s2003 = sbv_bv_extract_u32_31_24_u8(s39); + const SWord8 s2008 = sbv_bv_extract_u32_23_16_u8(s39); + const SWord8 s2014 = sbv_bv_extract_u32_15_8_u8(s39); + const SWord8 s2020 = sbv_bv_extract_u32_7_0_u8(s39); + const SWord8 s2026 = sbv_bv_extract_u32_23_16_u8(s40); + const SWord8 s2032 = sbv_bv_extract_u32_31_24_u8(s38); + const SWord8 s2037 = sbv_bv_extract_u32_23_16_u8(s38); + const SWord8 s2043 = sbv_bv_extract_u32_15_8_u8(s38); + const SWord8 s2049 = sbv_bv_extract_u32_7_0_u8(s38); + const SWord8 s2055 = sbv_bv_extract_u32_15_8_u8(s40); + const SWord8 s2061 = sbv_bv_extract_u32_31_24_u8(s37); + const SWord8 s2066 = sbv_bv_extract_u32_23_16_u8(s37); + const SWord8 s2072 = sbv_bv_extract_u32_15_8_u8(s37); + const SWord8 s2078 = sbv_bv_extract_u32_7_0_u8(s37); + const SWord8 s2084 = sbv_bv_extract_u32_7_0_u8(s40); + const SWord8 s2092 = sbv_bv_extract_u32_31_24_u8(s43); + const SWord8 s2097 = sbv_bv_extract_u32_23_16_u8(s43); + const SWord8 s2103 = sbv_bv_extract_u32_15_8_u8(s43); + const SWord8 s2109 = sbv_bv_extract_u32_7_0_u8(s43); + const SWord8 s2118 = sbv_bv_extract_u32_31_24_u8(s42); + const SWord8 s2123 = sbv_bv_extract_u32_23_16_u8(s42); + const SWord8 s2129 = sbv_bv_extract_u32_15_8_u8(s42); + const SWord8 s2135 = sbv_bv_extract_u32_7_0_u8(s42); + const SWord8 s2143 = sbv_bv_extract_u32_31_24_u8(s41); + const SWord8 s2148 = sbv_bv_extract_u32_23_16_u8(s41); + const SWord8 s2154 = sbv_bv_extract_u32_15_8_u8(s41); + const SWord8 s2160 = sbv_bv_extract_u32_7_0_u8(s41); + SWord8 s562; + SWord8 s564; + SWord32 s565; + SWord8 s823; + SWord8 s825; + SWord32 s826; + SWord32 s827; + SWord8 s1085; + SWord8 s1087; + SWord32 s1088; + SWord32 s1089; + SWord8 s1347; + SWord8 s1349; + SWord32 s1350; + SWord32 s1351; + SWord8 s1352; + SWord8 s1353; + SWord8 s1355; + SWord32 s1356; + SWord8 s1358; + SWord8 s1360; + SWord32 s1361; + SWord8 s1363; + SWord8 s1365; + SWord32 s1366; + SWord32 s1367; + SWord8 s1369; + SWord8 s1371; + SWord32 s1372; + SWord32 s1373; + SWord8 s1375; + SWord8 s1377; + SWord32 s1378; + SWord32 s1379; + SWord8 s1380; + SWord8 s1381; + SWord8 s1383; + SWord32 s1384; + SWord32 s1385; + SWord8 s1387; + SWord8 s1389; + SWord32 s1390; + SWord8 s1392; + SWord8 s1394; + SWord32 s1395; + SWord32 s1396; + SWord8 s1398; + SWord8 s1400; + SWord32 s1401; + SWord32 s1402; + SWord8 s1404; + SWord8 s1406; + SWord32 s1407; + SWord32 s1408; + SWord8 s1409; + SWord8 s1410; + SWord8 s1412; + SWord32 s1413; + SWord32 s1414; + SWord8 s1416; + SWord8 s1418; + SWord32 s1419; + SWord8 s1421; + SWord8 s1423; + SWord32 s1424; + SWord32 s1425; + SWord8 s1427; + SWord8 s1429; + SWord32 s1430; + SWord32 s1431; + SWord8 s1433; + SWord8 s1435; + SWord32 s1436; + SWord32 s1437; + SWord8 s1438; + SWord8 s1439; + SWord8 s1441; + SWord32 s1442; + SWord32 s1443; + SWord8 s1444; + SWord8 s1445; + SWord8 s1447; + SWord32 s1448; + SWord8 s1449; + SWord8 s1450; + SWord8 s1452; + SWord32 s1453; + SWord8 s1454; + SWord8 s1455; + SWord8 s1457; + SWord32 s1458; + SWord32 s1459; + SWord8 s1460; + SWord8 s1461; + SWord8 s1463; + SWord32 s1464; + SWord32 s1465; + SWord8 s1466; + SWord8 s1467; + SWord8 s1469; + SWord32 s1470; + SWord32 s1471; + SWord8 s1472; + SWord8 s1473; + SWord8 s1475; + SWord32 s1476; + SWord32 s1477; + SWord8 s1478; + SWord8 s1479; + SWord8 s1481; + SWord32 s1482; + SWord8 s1483; + SWord8 s1484; + SWord8 s1486; + SWord32 s1487; + SWord32 s1488; + SWord8 s1489; + SWord8 s1490; + SWord8 s1492; + SWord32 s1493; + SWord32 s1494; + SWord8 s1495; + SWord8 s1496; + SWord8 s1498; + SWord32 s1499; + SWord32 s1500; + SWord8 s1501; + SWord8 s1502; + SWord8 s1504; + SWord32 s1505; + SWord32 s1506; + SWord8 s1507; + SWord8 s1508; + SWord8 s1510; + SWord32 s1511; + SWord8 s1512; + SWord8 s1513; + SWord8 s1515; + SWord32 s1516; + SWord32 s1517; + SWord8 s1518; + SWord8 s1519; + SWord8 s1521; + SWord32 s1522; + SWord32 s1523; + SWord8 s1524; + SWord8 s1525; + SWord8 s1527; + SWord32 s1528; + SWord32 s1529; + SWord8 s1530; + SWord8 s1531; + SWord8 s1533; + SWord32 s1534; + SWord32 s1535; + SWord8 s1536; + SWord8 s1537; + SWord8 s1539; + SWord32 s1540; + SWord8 s1541; + SWord8 s1542; + SWord8 s1544; + SWord32 s1545; + SWord8 s1546; + SWord8 s1547; + SWord8 s1549; + SWord32 s1550; + SWord32 s1551; + SWord8 s1552; + SWord8 s1553; + SWord8 s1555; + SWord32 s1556; + SWord32 s1557; + SWord8 s1558; + SWord8 s1559; + SWord8 s1561; + SWord32 s1562; + SWord32 s1563; + SWord8 s1564; + SWord8 s1565; + SWord8 s1567; + SWord32 s1568; + SWord32 s1569; + SWord8 s1570; + SWord8 s1571; + SWord8 s1573; + SWord32 s1574; + SWord8 s1575; + SWord8 s1576; + SWord8 s1578; + SWord32 s1579; + SWord32 s1580; + SWord8 s1581; + SWord8 s1582; + SWord8 s1584; + SWord32 s1585; + SWord32 s1586; + SWord8 s1587; + SWord8 s1588; + SWord8 s1590; + SWord32 s1591; + SWord32 s1592; + SWord8 s1593; + SWord8 s1594; + SWord8 s1596; + SWord32 s1597; + SWord32 s1598; + SWord8 s1599; + SWord8 s1600; + SWord8 s1602; + SWord32 s1603; + SWord8 s1604; + SWord8 s1605; + SWord8 s1607; + SWord32 s1608; + SWord32 s1609; + SWord8 s1610; + SWord8 s1611; + SWord8 s1613; + SWord32 s1614; + SWord32 s1615; + SWord8 s1616; + SWord8 s1617; + SWord8 s1619; + SWord32 s1620; + SWord32 s1621; + SWord8 s1622; + SWord8 s1623; + SWord8 s1625; + SWord32 s1626; + SWord32 s1627; + SWord8 s1628; + SWord8 s1629; + SWord8 s1631; + SWord32 s1632; + SWord8 s1633; + SWord8 s1634; + SWord8 s1636; + SWord32 s1637; + SWord8 s1638; + SWord8 s1639; + SWord8 s1641; + SWord32 s1642; + SWord32 s1643; + SWord8 s1644; + SWord8 s1645; + SWord8 s1647; + SWord32 s1648; + SWord32 s1649; + SWord8 s1650; + SWord8 s1651; + SWord8 s1653; + SWord32 s1654; + SWord32 s1655; + SWord8 s1656; + SWord8 s1657; + SWord8 s1659; + SWord32 s1660; + SWord32 s1661; + SWord8 s1662; + SWord8 s1663; + SWord8 s1665; + SWord32 s1666; + SWord8 s1667; + SWord8 s1668; + SWord8 s1670; + SWord32 s1671; + SWord32 s1672; + SWord8 s1673; + SWord8 s1674; + SWord8 s1676; + SWord32 s1677; + SWord32 s1678; + SWord8 s1679; + SWord8 s1680; + SWord8 s1682; + SWord32 s1683; + SWord32 s1684; + SWord8 s1685; + SWord8 s1686; + SWord8 s1688; + SWord32 s1689; + SWord32 s1690; + SWord8 s1691; + SWord8 s1692; + SWord8 s1694; + SWord32 s1695; + SWord8 s1696; + SWord8 s1697; + SWord8 s1699; + SWord32 s1700; + SWord32 s1701; + SWord8 s1702; + SWord8 s1703; + SWord8 s1705; + SWord32 s1706; + SWord32 s1707; + SWord8 s1708; + SWord8 s1709; + SWord8 s1711; + SWord32 s1712; + SWord32 s1713; + SWord8 s1714; + SWord8 s1715; + SWord8 s1717; + SWord32 s1718; + SWord32 s1719; + SWord8 s1720; + SWord8 s1721; + SWord8 s1723; + SWord32 s1724; + SWord8 s1725; + SWord8 s1726; + SWord8 s1728; + SWord32 s1729; + SWord8 s1730; + SWord8 s1731; + SWord8 s1733; + SWord32 s1734; + SWord32 s1735; + SWord8 s1736; + SWord8 s1737; + SWord8 s1739; + SWord32 s1740; + SWord32 s1741; + SWord8 s1742; + SWord8 s1743; + SWord8 s1745; + SWord32 s1746; + SWord32 s1747; + SWord8 s1748; + SWord8 s1749; + SWord8 s1751; + SWord32 s1752; + SWord32 s1753; + SWord8 s1754; + SWord8 s1755; + SWord8 s1757; + SWord32 s1758; + SWord8 s1759; + SWord8 s1760; + SWord8 s1762; + SWord32 s1763; + SWord32 s1764; + SWord8 s1765; + SWord8 s1766; + SWord8 s1768; + SWord32 s1769; + SWord32 s1770; + SWord8 s1771; + SWord8 s1772; + SWord8 s1774; + SWord32 s1775; + SWord32 s1776; + SWord8 s1777; + SWord8 s1778; + SWord8 s1780; + SWord32 s1781; + SWord32 s1782; + SWord8 s1783; + SWord8 s1784; + SWord8 s1786; + SWord32 s1787; + SWord8 s1788; + SWord8 s1789; + SWord8 s1791; + SWord32 s1792; + SWord32 s1793; + SWord8 s1794; + SWord8 s1795; + SWord8 s1797; + SWord32 s1798; + SWord32 s1799; + SWord8 s1800; + SWord8 s1801; + SWord8 s1803; + SWord32 s1804; + SWord32 s1805; + SWord8 s1806; + SWord8 s1807; + SWord8 s1809; + SWord32 s1810; + SWord32 s1811; + SWord8 s1812; + SWord8 s1813; + SWord8 s1815; + SWord32 s1816; + SWord8 s1817; + SWord8 s1818; + SWord8 s1820; + SWord32 s1821; + SWord8 s1822; + SWord8 s1823; + SWord8 s1825; + SWord32 s1826; + SWord32 s1827; + SWord8 s1828; + SWord8 s1829; + SWord8 s1831; + SWord32 s1832; + SWord32 s1833; + SWord8 s1834; + SWord8 s1835; + SWord8 s1837; + SWord32 s1838; + SWord32 s1839; + SWord8 s1840; + SWord8 s1841; + SWord8 s1843; + SWord32 s1844; + SWord32 s1845; + SWord8 s1846; + SWord8 s1847; + SWord8 s1849; + SWord32 s1850; + SWord8 s1851; + SWord8 s1852; + SWord8 s1854; + SWord32 s1855; + SWord32 s1856; + SWord8 s1857; + SWord8 s1858; + SWord8 s1860; + SWord32 s1861; + SWord32 s1862; + SWord8 s1863; + SWord8 s1864; + SWord8 s1866; + SWord32 s1867; + SWord32 s1868; + SWord8 s1869; + SWord8 s1870; + SWord8 s1872; + SWord32 s1873; + SWord32 s1874; + SWord8 s1875; + SWord8 s1876; + SWord8 s1878; + SWord32 s1879; + SWord8 s1880; + SWord8 s1881; + SWord8 s1883; + SWord32 s1884; + SWord32 s1885; + SWord8 s1886; + SWord8 s1887; + SWord8 s1889; + SWord32 s1890; + SWord32 s1891; + SWord8 s1892; + SWord8 s1893; + SWord8 s1895; + SWord32 s1896; + SWord32 s1897; + SWord8 s1898; + SWord8 s1899; + SWord8 s1901; + SWord32 s1902; + SWord32 s1903; + SWord8 s1904; + SWord8 s1905; + SWord8 s1907; + SWord32 s1908; + SWord8 s1909; + SWord8 s1910; + SWord8 s1912; + SWord32 s1913; + SWord8 s1914; + SWord8 s1915; + SWord8 s1917; + SWord32 s1918; + SWord32 s1919; + SWord8 s1920; + SWord8 s1921; + SWord8 s1923; + SWord32 s1924; + SWord32 s1925; + SWord8 s1926; + SWord8 s1927; + SWord8 s1929; + SWord32 s1930; + SWord32 s1931; + SWord8 s1932; + SWord8 s1933; + SWord8 s1935; + SWord32 s1936; + SWord32 s1937; + SWord8 s1938; + SWord8 s1939; + SWord8 s1941; + SWord32 s1942; + SWord8 s1943; + SWord8 s1944; + SWord8 s1946; + SWord32 s1947; + SWord32 s1948; + SWord8 s1949; + SWord8 s1950; + SWord8 s1952; + SWord32 s1953; + SWord32 s1954; + SWord8 s1955; + SWord8 s1956; + SWord8 s1958; + SWord32 s1959; + SWord32 s1960; + SWord8 s1961; + SWord8 s1962; + SWord8 s1964; + SWord32 s1965; + SWord32 s1966; + SWord8 s1967; + SWord8 s1968; + SWord8 s1970; + SWord32 s1971; + SWord8 s1972; + SWord8 s1973; + SWord8 s1975; + SWord32 s1976; + SWord32 s1977; + SWord8 s1978; + SWord8 s1979; + SWord8 s1981; + SWord32 s1982; + SWord32 s1983; + SWord8 s1984; + SWord8 s1985; + SWord8 s1987; + SWord32 s1988; + SWord32 s1989; + SWord8 s1990; + SWord8 s1991; + SWord8 s1993; + SWord32 s1994; + SWord32 s1995; + SWord8 s1996; + SWord8 s1997; + SWord8 s1999; + SWord32 s2000; + SWord8 s2001; + SWord8 s2002; + SWord8 s2004; + SWord32 s2005; + SWord8 s2006; + SWord8 s2007; + SWord8 s2009; + SWord32 s2010; + SWord32 s2011; + SWord8 s2012; + SWord8 s2013; + SWord8 s2015; + SWord32 s2016; + SWord32 s2017; + SWord8 s2018; + SWord8 s2019; + SWord8 s2021; + SWord32 s2022; + SWord32 s2023; + SWord8 s2024; + SWord8 s2025; + SWord8 s2027; + SWord32 s2028; + SWord32 s2029; + SWord8 s2030; + SWord8 s2031; + SWord8 s2033; + SWord32 s2034; + SWord8 s2035; + SWord8 s2036; + SWord8 s2038; + SWord32 s2039; + SWord32 s2040; + SWord8 s2041; + SWord8 s2042; + SWord8 s2044; + SWord32 s2045; + SWord32 s2046; + SWord8 s2047; + SWord8 s2048; + SWord8 s2050; + SWord32 s2051; + SWord32 s2052; + SWord8 s2053; + SWord8 s2054; + SWord8 s2056; + SWord32 s2057; + SWord32 s2058; + SWord8 s2059; + SWord8 s2060; + SWord8 s2062; + SWord32 s2063; + SWord8 s2064; + SWord8 s2065; + SWord8 s2067; + SWord32 s2068; + SWord32 s2069; + SWord8 s2070; + SWord8 s2071; + SWord8 s2073; + SWord32 s2074; + SWord32 s2075; + SWord8 s2076; + SWord8 s2077; + SWord8 s2079; + SWord32 s2080; + SWord32 s2081; + SWord8 s2082; + SWord8 s2083; + SWord8 s2085; + SWord32 s2086; + SWord32 s2087; + SWord8 s2088; + SWord8 s2089; + SWord8 s2090; + SWord8 s2091; + SWord8 s2093; + SWord32 s2094; + SWord8 s2095; + SWord8 s2096; + SWord8 s2098; + SWord32 s2099; + SWord32 s2100; + SWord8 s2101; + SWord8 s2102; + SWord8 s2104; + SWord32 s2105; + SWord32 s2106; + SWord8 s2107; + SWord8 s2108; + SWord8 s2110; + SWord32 s2111; + SWord32 s2112; + SWord8 s2113; + SWord8 s2114; + SWord16 s2115; + SWord8 s2116; + SWord8 s2117; + SWord8 s2119; + SWord32 s2120; + SWord8 s2121; + SWord8 s2122; + SWord8 s2124; + SWord32 s2125; + SWord32 s2126; + SWord8 s2127; + SWord8 s2128; + SWord8 s2130; + SWord32 s2131; + SWord32 s2132; + SWord8 s2133; + SWord8 s2134; + SWord8 s2136; + SWord32 s2137; + SWord32 s2138; + SWord8 s2139; + SWord8 s2140; + SWord8 s2141; + SWord8 s2142; + SWord8 s2144; + SWord32 s2145; + SWord8 s2146; + SWord8 s2147; + SWord8 s2149; + SWord32 s2150; + SWord32 s2151; + SWord8 s2152; + SWord8 s2153; + SWord8 s2155; + SWord32 s2156; + SWord32 s2157; + SWord8 s2158; + SWord8 s2159; + SWord8 s2161; + SWord32 s2162; + SWord32 s2163; + SWord8 s2164; + SWord8 s2165; + SWord16 s2166; + SWord32 s2167; + SWord32 s2168; + SWord8 s2169; + SWord8 s2170; + SWord8 s2171; + SWord8 s2172; + SWord16 s2173; + SWord8 s2174; + SWord8 s2175; + SWord8 s2176; + SWord8 s2177; + SWord16 s2178; + SWord32 s2179; + SWord32 s2180; + SWord8 s2181; + SWord8 s2182; + SWord8 s2183; + SWord8 s2184; + SWord16 s2185; + SWord8 s2186; + SWord8 s2187; + SWord8 s2188; + SWord8 s2189; + SWord16 s2190; + SWord32 s2191; + SWord32 s2192; + SWord8 s2193; + SWord8 s2194; + SWord8 s2195; + SWord8 s2196; + SWord16 s2197; + SWord8 s2198; + SWord8 s2199; + SWord8 s2200; + SWord8 s2201; + SWord16 s2202; + SWord32 s2203; + SWord32 s2204; + 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 + }; + s562 = table0[s561]; + s564 = s562 ^ s563; + static const SWord32 table1[] = { + 0x00000000UL, 0x0e090d0bUL, 0x1c121a16UL, 0x121b171dUL, + 0x3824342cUL, 0x362d3927UL, 0x24362e3aUL, 0x2a3f2331UL, + 0x70486858UL, 0x7e416553UL, 0x6c5a724eUL, 0x62537f45UL, + 0x486c5c74UL, 0x4665517fUL, 0x547e4662UL, 0x5a774b69UL, + 0xe090d0b0UL, 0xee99ddbbUL, 0xfc82caa6UL, 0xf28bc7adUL, + 0xd8b4e49cUL, 0xd6bde997UL, 0xc4a6fe8aUL, 0xcaaff381UL, + 0x90d8b8e8UL, 0x9ed1b5e3UL, 0x8ccaa2feUL, 0x82c3aff5UL, + 0xa8fc8cc4UL, 0xa6f581cfUL, 0xb4ee96d2UL, 0xbae79bd9UL, + 0xdb3bbb7bUL, 0xd532b670UL, 0xc729a16dUL, 0xc920ac66UL, + 0xe31f8f57UL, 0xed16825cUL, 0xff0d9541UL, 0xf104984aUL, + 0xab73d323UL, 0xa57ade28UL, 0xb761c935UL, 0xb968c43eUL, + 0x9357e70fUL, 0x9d5eea04UL, 0x8f45fd19UL, 0x814cf012UL, + 0x3bab6bcbUL, 0x35a266c0UL, 0x27b971ddUL, 0x29b07cd6UL, + 0x038f5fe7UL, 0x0d8652ecUL, 0x1f9d45f1UL, 0x119448faUL, + 0x4be30393UL, 0x45ea0e98UL, 0x57f11985UL, 0x59f8148eUL, + 0x73c737bfUL, 0x7dce3ab4UL, 0x6fd52da9UL, 0x61dc20a2UL, + 0xad766df6UL, 0xa37f60fdUL, 0xb16477e0UL, 0xbf6d7aebUL, + 0x955259daUL, 0x9b5b54d1UL, 0x894043ccUL, 0x87494ec7UL, + 0xdd3e05aeUL, 0xd33708a5UL, 0xc12c1fb8UL, 0xcf2512b3UL, + 0xe51a3182UL, 0xeb133c89UL, 0xf9082b94UL, 0xf701269fUL, + 0x4de6bd46UL, 0x43efb04dUL, 0x51f4a750UL, 0x5ffdaa5bUL, + 0x75c2896aUL, 0x7bcb8461UL, 0x69d0937cUL, 0x67d99e77UL, + 0x3daed51eUL, 0x33a7d815UL, 0x21bccf08UL, 0x2fb5c203UL, + 0x058ae132UL, 0x0b83ec39UL, 0x1998fb24UL, 0x1791f62fUL, + 0x764dd68dUL, 0x7844db86UL, 0x6a5fcc9bUL, 0x6456c190UL, + 0x4e69e2a1UL, 0x4060efaaUL, 0x527bf8b7UL, 0x5c72f5bcUL, + 0x0605bed5UL, 0x080cb3deUL, 0x1a17a4c3UL, 0x141ea9c8UL, + 0x3e218af9UL, 0x302887f2UL, 0x223390efUL, 0x2c3a9de4UL, + 0x96dd063dUL, 0x98d40b36UL, 0x8acf1c2bUL, 0x84c61120UL, + 0xaef93211UL, 0xa0f03f1aUL, 0xb2eb2807UL, 0xbce2250cUL, + 0xe6956e65UL, 0xe89c636eUL, 0xfa877473UL, 0xf48e7978UL, + 0xdeb15a49UL, 0xd0b85742UL, 0xc2a3405fUL, 0xccaa4d54UL, + 0x41ecdaf7UL, 0x4fe5d7fcUL, 0x5dfec0e1UL, 0x53f7cdeaUL, + 0x79c8eedbUL, 0x77c1e3d0UL, 0x65daf4cdUL, 0x6bd3f9c6UL, + 0x31a4b2afUL, 0x3fadbfa4UL, 0x2db6a8b9UL, 0x23bfa5b2UL, + 0x09808683UL, 0x07898b88UL, 0x15929c95UL, 0x1b9b919eUL, + 0xa17c0a47UL, 0xaf75074cUL, 0xbd6e1051UL, 0xb3671d5aUL, + 0x99583e6bUL, 0x97513360UL, 0x854a247dUL, 0x8b432976UL, + 0xd134621fUL, 0xdf3d6f14UL, 0xcd267809UL, 0xc32f7502UL, + 0xe9105633UL, 0xe7195b38UL, 0xf5024c25UL, 0xfb0b412eUL, + 0x9ad7618cUL, 0x94de6c87UL, 0x86c57b9aUL, 0x88cc7691UL, + 0xa2f355a0UL, 0xacfa58abUL, 0xbee14fb6UL, 0xb0e842bdUL, + 0xea9f09d4UL, 0xe49604dfUL, 0xf68d13c2UL, 0xf8841ec9UL, + 0xd2bb3df8UL, 0xdcb230f3UL, 0xcea927eeUL, 0xc0a02ae5UL, + 0x7a47b13cUL, 0x744ebc37UL, 0x6655ab2aUL, 0x685ca621UL, + 0x42638510UL, 0x4c6a881bUL, 0x5e719f06UL, 0x5078920dUL, + 0x0a0fd964UL, 0x0406d46fUL, 0x161dc372UL, 0x1814ce79UL, + 0x322bed48UL, 0x3c22e043UL, 0x2e39f75eUL, 0x2030fa55UL, + 0xec9ab701UL, 0xe293ba0aUL, 0xf088ad17UL, 0xfe81a01cUL, + 0xd4be832dUL, 0xdab78e26UL, 0xc8ac993bUL, 0xc6a59430UL, + 0x9cd2df59UL, 0x92dbd252UL, 0x80c0c54fUL, 0x8ec9c844UL, + 0xa4f6eb75UL, 0xaaffe67eUL, 0xb8e4f163UL, 0xb6edfc68UL, + 0x0c0a67b1UL, 0x02036abaUL, 0x10187da7UL, 0x1e1170acUL, + 0x342e539dUL, 0x3a275e96UL, 0x283c498bUL, 0x26354480UL, + 0x7c420fe9UL, 0x724b02e2UL, 0x605015ffUL, 0x6e5918f4UL, + 0x44663bc5UL, 0x4a6f36ceUL, 0x587421d3UL, 0x567d2cd8UL, + 0x37a10c7aUL, 0x39a80171UL, 0x2bb3166cUL, 0x25ba1b67UL, + 0x0f853856UL, 0x018c355dUL, 0x13972240UL, 0x1d9e2f4bUL, + 0x47e96422UL, 0x49e06929UL, 0x5bfb7e34UL, 0x55f2733fUL, + 0x7fcd500eUL, 0x71c45d05UL, 0x63df4a18UL, 0x6dd64713UL, + 0xd731dccaUL, 0xd938d1c1UL, 0xcb23c6dcUL, 0xc52acbd7UL, + 0xef15e8e6UL, 0xe11ce5edUL, 0xf307f2f0UL, 0xfd0efffbUL, + 0xa779b492UL, 0xa970b999UL, 0xbb6bae84UL, 0xb562a38fUL, + 0x9f5d80beUL, 0x91548db5UL, 0x834f9aa8UL, 0x8d4697a3UL + }; + s565 = table1[s564]; + s823 = table0[s822]; + s825 = s823 ^ s824; + static const SWord32 table2[] = { + 0x00000000UL, 0x0b0e090dUL, 0x161c121aUL, 0x1d121b17UL, + 0x2c382434UL, 0x27362d39UL, 0x3a24362eUL, 0x312a3f23UL, + 0x58704868UL, 0x537e4165UL, 0x4e6c5a72UL, 0x4562537fUL, + 0x74486c5cUL, 0x7f466551UL, 0x62547e46UL, 0x695a774bUL, + 0xb0e090d0UL, 0xbbee99ddUL, 0xa6fc82caUL, 0xadf28bc7UL, + 0x9cd8b4e4UL, 0x97d6bde9UL, 0x8ac4a6feUL, 0x81caaff3UL, + 0xe890d8b8UL, 0xe39ed1b5UL, 0xfe8ccaa2UL, 0xf582c3afUL, + 0xc4a8fc8cUL, 0xcfa6f581UL, 0xd2b4ee96UL, 0xd9bae79bUL, + 0x7bdb3bbbUL, 0x70d532b6UL, 0x6dc729a1UL, 0x66c920acUL, + 0x57e31f8fUL, 0x5ced1682UL, 0x41ff0d95UL, 0x4af10498UL, + 0x23ab73d3UL, 0x28a57adeUL, 0x35b761c9UL, 0x3eb968c4UL, + 0x0f9357e7UL, 0x049d5eeaUL, 0x198f45fdUL, 0x12814cf0UL, + 0xcb3bab6bUL, 0xc035a266UL, 0xdd27b971UL, 0xd629b07cUL, + 0xe7038f5fUL, 0xec0d8652UL, 0xf11f9d45UL, 0xfa119448UL, + 0x934be303UL, 0x9845ea0eUL, 0x8557f119UL, 0x8e59f814UL, + 0xbf73c737UL, 0xb47dce3aUL, 0xa96fd52dUL, 0xa261dc20UL, + 0xf6ad766dUL, 0xfda37f60UL, 0xe0b16477UL, 0xebbf6d7aUL, + 0xda955259UL, 0xd19b5b54UL, 0xcc894043UL, 0xc787494eUL, + 0xaedd3e05UL, 0xa5d33708UL, 0xb8c12c1fUL, 0xb3cf2512UL, + 0x82e51a31UL, 0x89eb133cUL, 0x94f9082bUL, 0x9ff70126UL, + 0x464de6bdUL, 0x4d43efb0UL, 0x5051f4a7UL, 0x5b5ffdaaUL, + 0x6a75c289UL, 0x617bcb84UL, 0x7c69d093UL, 0x7767d99eUL, + 0x1e3daed5UL, 0x1533a7d8UL, 0x0821bccfUL, 0x032fb5c2UL, + 0x32058ae1UL, 0x390b83ecUL, 0x241998fbUL, 0x2f1791f6UL, + 0x8d764dd6UL, 0x867844dbUL, 0x9b6a5fccUL, 0x906456c1UL, + 0xa14e69e2UL, 0xaa4060efUL, 0xb7527bf8UL, 0xbc5c72f5UL, + 0xd50605beUL, 0xde080cb3UL, 0xc31a17a4UL, 0xc8141ea9UL, + 0xf93e218aUL, 0xf2302887UL, 0xef223390UL, 0xe42c3a9dUL, + 0x3d96dd06UL, 0x3698d40bUL, 0x2b8acf1cUL, 0x2084c611UL, + 0x11aef932UL, 0x1aa0f03fUL, 0x07b2eb28UL, 0x0cbce225UL, + 0x65e6956eUL, 0x6ee89c63UL, 0x73fa8774UL, 0x78f48e79UL, + 0x49deb15aUL, 0x42d0b857UL, 0x5fc2a340UL, 0x54ccaa4dUL, + 0xf741ecdaUL, 0xfc4fe5d7UL, 0xe15dfec0UL, 0xea53f7cdUL, + 0xdb79c8eeUL, 0xd077c1e3UL, 0xcd65daf4UL, 0xc66bd3f9UL, + 0xaf31a4b2UL, 0xa43fadbfUL, 0xb92db6a8UL, 0xb223bfa5UL, + 0x83098086UL, 0x8807898bUL, 0x9515929cUL, 0x9e1b9b91UL, + 0x47a17c0aUL, 0x4caf7507UL, 0x51bd6e10UL, 0x5ab3671dUL, + 0x6b99583eUL, 0x60975133UL, 0x7d854a24UL, 0x768b4329UL, + 0x1fd13462UL, 0x14df3d6fUL, 0x09cd2678UL, 0x02c32f75UL, + 0x33e91056UL, 0x38e7195bUL, 0x25f5024cUL, 0x2efb0b41UL, + 0x8c9ad761UL, 0x8794de6cUL, 0x9a86c57bUL, 0x9188cc76UL, + 0xa0a2f355UL, 0xabacfa58UL, 0xb6bee14fUL, 0xbdb0e842UL, + 0xd4ea9f09UL, 0xdfe49604UL, 0xc2f68d13UL, 0xc9f8841eUL, + 0xf8d2bb3dUL, 0xf3dcb230UL, 0xeecea927UL, 0xe5c0a02aUL, + 0x3c7a47b1UL, 0x37744ebcUL, 0x2a6655abUL, 0x21685ca6UL, + 0x10426385UL, 0x1b4c6a88UL, 0x065e719fUL, 0x0d507892UL, + 0x640a0fd9UL, 0x6f0406d4UL, 0x72161dc3UL, 0x791814ceUL, + 0x48322bedUL, 0x433c22e0UL, 0x5e2e39f7UL, 0x552030faUL, + 0x01ec9ab7UL, 0x0ae293baUL, 0x17f088adUL, 0x1cfe81a0UL, + 0x2dd4be83UL, 0x26dab78eUL, 0x3bc8ac99UL, 0x30c6a594UL, + 0x599cd2dfUL, 0x5292dbd2UL, 0x4f80c0c5UL, 0x448ec9c8UL, + 0x75a4f6ebUL, 0x7eaaffe6UL, 0x63b8e4f1UL, 0x68b6edfcUL, + 0xb10c0a67UL, 0xba02036aUL, 0xa710187dUL, 0xac1e1170UL, + 0x9d342e53UL, 0x963a275eUL, 0x8b283c49UL, 0x80263544UL, + 0xe97c420fUL, 0xe2724b02UL, 0xff605015UL, 0xf46e5918UL, + 0xc544663bUL, 0xce4a6f36UL, 0xd3587421UL, 0xd8567d2cUL, + 0x7a37a10cUL, 0x7139a801UL, 0x6c2bb316UL, 0x6725ba1bUL, + 0x560f8538UL, 0x5d018c35UL, 0x40139722UL, 0x4b1d9e2fUL, + 0x2247e964UL, 0x2949e069UL, 0x345bfb7eUL, 0x3f55f273UL, + 0x0e7fcd50UL, 0x0571c45dUL, 0x1863df4aUL, 0x136dd647UL, + 0xcad731dcUL, 0xc1d938d1UL, 0xdccb23c6UL, 0xd7c52acbUL, + 0xe6ef15e8UL, 0xede11ce5UL, 0xf0f307f2UL, 0xfbfd0effUL, + 0x92a779b4UL, 0x99a970b9UL, 0x84bb6baeUL, 0x8fb562a3UL, + 0xbe9f5d80UL, 0xb591548dUL, 0xa8834f9aUL, 0xa38d4697UL + }; + s826 = table2[s825]; + s827 = s565 ^ s826; + s1085 = table0[s1084]; + s1087 = s1085 ^ s1086; + static const SWord32 table3[] = { + 0x00000000UL, 0x0d0b0e09UL, 0x1a161c12UL, 0x171d121bUL, + 0x342c3824UL, 0x3927362dUL, 0x2e3a2436UL, 0x23312a3fUL, + 0x68587048UL, 0x65537e41UL, 0x724e6c5aUL, 0x7f456253UL, + 0x5c74486cUL, 0x517f4665UL, 0x4662547eUL, 0x4b695a77UL, + 0xd0b0e090UL, 0xddbbee99UL, 0xcaa6fc82UL, 0xc7adf28bUL, + 0xe49cd8b4UL, 0xe997d6bdUL, 0xfe8ac4a6UL, 0xf381caafUL, + 0xb8e890d8UL, 0xb5e39ed1UL, 0xa2fe8ccaUL, 0xaff582c3UL, + 0x8cc4a8fcUL, 0x81cfa6f5UL, 0x96d2b4eeUL, 0x9bd9bae7UL, + 0xbb7bdb3bUL, 0xb670d532UL, 0xa16dc729UL, 0xac66c920UL, + 0x8f57e31fUL, 0x825ced16UL, 0x9541ff0dUL, 0x984af104UL, + 0xd323ab73UL, 0xde28a57aUL, 0xc935b761UL, 0xc43eb968UL, + 0xe70f9357UL, 0xea049d5eUL, 0xfd198f45UL, 0xf012814cUL, + 0x6bcb3babUL, 0x66c035a2UL, 0x71dd27b9UL, 0x7cd629b0UL, + 0x5fe7038fUL, 0x52ec0d86UL, 0x45f11f9dUL, 0x48fa1194UL, + 0x03934be3UL, 0x0e9845eaUL, 0x198557f1UL, 0x148e59f8UL, + 0x37bf73c7UL, 0x3ab47dceUL, 0x2da96fd5UL, 0x20a261dcUL, + 0x6df6ad76UL, 0x60fda37fUL, 0x77e0b164UL, 0x7aebbf6dUL, + 0x59da9552UL, 0x54d19b5bUL, 0x43cc8940UL, 0x4ec78749UL, + 0x05aedd3eUL, 0x08a5d337UL, 0x1fb8c12cUL, 0x12b3cf25UL, + 0x3182e51aUL, 0x3c89eb13UL, 0x2b94f908UL, 0x269ff701UL, + 0xbd464de6UL, 0xb04d43efUL, 0xa75051f4UL, 0xaa5b5ffdUL, + 0x896a75c2UL, 0x84617bcbUL, 0x937c69d0UL, 0x9e7767d9UL, + 0xd51e3daeUL, 0xd81533a7UL, 0xcf0821bcUL, 0xc2032fb5UL, + 0xe132058aUL, 0xec390b83UL, 0xfb241998UL, 0xf62f1791UL, + 0xd68d764dUL, 0xdb867844UL, 0xcc9b6a5fUL, 0xc1906456UL, + 0xe2a14e69UL, 0xefaa4060UL, 0xf8b7527bUL, 0xf5bc5c72UL, + 0xbed50605UL, 0xb3de080cUL, 0xa4c31a17UL, 0xa9c8141eUL, + 0x8af93e21UL, 0x87f23028UL, 0x90ef2233UL, 0x9de42c3aUL, + 0x063d96ddUL, 0x0b3698d4UL, 0x1c2b8acfUL, 0x112084c6UL, + 0x3211aef9UL, 0x3f1aa0f0UL, 0x2807b2ebUL, 0x250cbce2UL, + 0x6e65e695UL, 0x636ee89cUL, 0x7473fa87UL, 0x7978f48eUL, + 0x5a49deb1UL, 0x5742d0b8UL, 0x405fc2a3UL, 0x4d54ccaaUL, + 0xdaf741ecUL, 0xd7fc4fe5UL, 0xc0e15dfeUL, 0xcdea53f7UL, + 0xeedb79c8UL, 0xe3d077c1UL, 0xf4cd65daUL, 0xf9c66bd3UL, + 0xb2af31a4UL, 0xbfa43fadUL, 0xa8b92db6UL, 0xa5b223bfUL, + 0x86830980UL, 0x8b880789UL, 0x9c951592UL, 0x919e1b9bUL, + 0x0a47a17cUL, 0x074caf75UL, 0x1051bd6eUL, 0x1d5ab367UL, + 0x3e6b9958UL, 0x33609751UL, 0x247d854aUL, 0x29768b43UL, + 0x621fd134UL, 0x6f14df3dUL, 0x7809cd26UL, 0x7502c32fUL, + 0x5633e910UL, 0x5b38e719UL, 0x4c25f502UL, 0x412efb0bUL, + 0x618c9ad7UL, 0x6c8794deUL, 0x7b9a86c5UL, 0x769188ccUL, + 0x55a0a2f3UL, 0x58abacfaUL, 0x4fb6bee1UL, 0x42bdb0e8UL, + 0x09d4ea9fUL, 0x04dfe496UL, 0x13c2f68dUL, 0x1ec9f884UL, + 0x3df8d2bbUL, 0x30f3dcb2UL, 0x27eecea9UL, 0x2ae5c0a0UL, + 0xb13c7a47UL, 0xbc37744eUL, 0xab2a6655UL, 0xa621685cUL, + 0x85104263UL, 0x881b4c6aUL, 0x9f065e71UL, 0x920d5078UL, + 0xd9640a0fUL, 0xd46f0406UL, 0xc372161dUL, 0xce791814UL, + 0xed48322bUL, 0xe0433c22UL, 0xf75e2e39UL, 0xfa552030UL, + 0xb701ec9aUL, 0xba0ae293UL, 0xad17f088UL, 0xa01cfe81UL, + 0x832dd4beUL, 0x8e26dab7UL, 0x993bc8acUL, 0x9430c6a5UL, + 0xdf599cd2UL, 0xd25292dbUL, 0xc54f80c0UL, 0xc8448ec9UL, + 0xeb75a4f6UL, 0xe67eaaffUL, 0xf163b8e4UL, 0xfc68b6edUL, + 0x67b10c0aUL, 0x6aba0203UL, 0x7da71018UL, 0x70ac1e11UL, + 0x539d342eUL, 0x5e963a27UL, 0x498b283cUL, 0x44802635UL, + 0x0fe97c42UL, 0x02e2724bUL, 0x15ff6050UL, 0x18f46e59UL, + 0x3bc54466UL, 0x36ce4a6fUL, 0x21d35874UL, 0x2cd8567dUL, + 0x0c7a37a1UL, 0x017139a8UL, 0x166c2bb3UL, 0x1b6725baUL, + 0x38560f85UL, 0x355d018cUL, 0x22401397UL, 0x2f4b1d9eUL, + 0x642247e9UL, 0x692949e0UL, 0x7e345bfbUL, 0x733f55f2UL, + 0x500e7fcdUL, 0x5d0571c4UL, 0x4a1863dfUL, 0x47136dd6UL, + 0xdccad731UL, 0xd1c1d938UL, 0xc6dccb23UL, 0xcbd7c52aUL, + 0xe8e6ef15UL, 0xe5ede11cUL, 0xf2f0f307UL, 0xfffbfd0eUL, + 0xb492a779UL, 0xb999a970UL, 0xae84bb6bUL, 0xa38fb562UL, + 0x80be9f5dUL, 0x8db59154UL, 0x9aa8834fUL, 0x97a38d46UL + }; + s1088 = table3[s1087]; + s1089 = s827 ^ s1088; + s1347 = table0[s1346]; + s1349 = s1347 ^ s1348; + static const SWord32 table4[] = { + 0x00000000UL, 0x090d0b0eUL, 0x121a161cUL, 0x1b171d12UL, + 0x24342c38UL, 0x2d392736UL, 0x362e3a24UL, 0x3f23312aUL, + 0x48685870UL, 0x4165537eUL, 0x5a724e6cUL, 0x537f4562UL, + 0x6c5c7448UL, 0x65517f46UL, 0x7e466254UL, 0x774b695aUL, + 0x90d0b0e0UL, 0x99ddbbeeUL, 0x82caa6fcUL, 0x8bc7adf2UL, + 0xb4e49cd8UL, 0xbde997d6UL, 0xa6fe8ac4UL, 0xaff381caUL, + 0xd8b8e890UL, 0xd1b5e39eUL, 0xcaa2fe8cUL, 0xc3aff582UL, + 0xfc8cc4a8UL, 0xf581cfa6UL, 0xee96d2b4UL, 0xe79bd9baUL, + 0x3bbb7bdbUL, 0x32b670d5UL, 0x29a16dc7UL, 0x20ac66c9UL, + 0x1f8f57e3UL, 0x16825cedUL, 0x0d9541ffUL, 0x04984af1UL, + 0x73d323abUL, 0x7ade28a5UL, 0x61c935b7UL, 0x68c43eb9UL, + 0x57e70f93UL, 0x5eea049dUL, 0x45fd198fUL, 0x4cf01281UL, + 0xab6bcb3bUL, 0xa266c035UL, 0xb971dd27UL, 0xb07cd629UL, + 0x8f5fe703UL, 0x8652ec0dUL, 0x9d45f11fUL, 0x9448fa11UL, + 0xe303934bUL, 0xea0e9845UL, 0xf1198557UL, 0xf8148e59UL, + 0xc737bf73UL, 0xce3ab47dUL, 0xd52da96fUL, 0xdc20a261UL, + 0x766df6adUL, 0x7f60fda3UL, 0x6477e0b1UL, 0x6d7aebbfUL, + 0x5259da95UL, 0x5b54d19bUL, 0x4043cc89UL, 0x494ec787UL, + 0x3e05aeddUL, 0x3708a5d3UL, 0x2c1fb8c1UL, 0x2512b3cfUL, + 0x1a3182e5UL, 0x133c89ebUL, 0x082b94f9UL, 0x01269ff7UL, + 0xe6bd464dUL, 0xefb04d43UL, 0xf4a75051UL, 0xfdaa5b5fUL, + 0xc2896a75UL, 0xcb84617bUL, 0xd0937c69UL, 0xd99e7767UL, + 0xaed51e3dUL, 0xa7d81533UL, 0xbccf0821UL, 0xb5c2032fUL, + 0x8ae13205UL, 0x83ec390bUL, 0x98fb2419UL, 0x91f62f17UL, + 0x4dd68d76UL, 0x44db8678UL, 0x5fcc9b6aUL, 0x56c19064UL, + 0x69e2a14eUL, 0x60efaa40UL, 0x7bf8b752UL, 0x72f5bc5cUL, + 0x05bed506UL, 0x0cb3de08UL, 0x17a4c31aUL, 0x1ea9c814UL, + 0x218af93eUL, 0x2887f230UL, 0x3390ef22UL, 0x3a9de42cUL, + 0xdd063d96UL, 0xd40b3698UL, 0xcf1c2b8aUL, 0xc6112084UL, + 0xf93211aeUL, 0xf03f1aa0UL, 0xeb2807b2UL, 0xe2250cbcUL, + 0x956e65e6UL, 0x9c636ee8UL, 0x877473faUL, 0x8e7978f4UL, + 0xb15a49deUL, 0xb85742d0UL, 0xa3405fc2UL, 0xaa4d54ccUL, + 0xecdaf741UL, 0xe5d7fc4fUL, 0xfec0e15dUL, 0xf7cdea53UL, + 0xc8eedb79UL, 0xc1e3d077UL, 0xdaf4cd65UL, 0xd3f9c66bUL, + 0xa4b2af31UL, 0xadbfa43fUL, 0xb6a8b92dUL, 0xbfa5b223UL, + 0x80868309UL, 0x898b8807UL, 0x929c9515UL, 0x9b919e1bUL, + 0x7c0a47a1UL, 0x75074cafUL, 0x6e1051bdUL, 0x671d5ab3UL, + 0x583e6b99UL, 0x51336097UL, 0x4a247d85UL, 0x4329768bUL, + 0x34621fd1UL, 0x3d6f14dfUL, 0x267809cdUL, 0x2f7502c3UL, + 0x105633e9UL, 0x195b38e7UL, 0x024c25f5UL, 0x0b412efbUL, + 0xd7618c9aUL, 0xde6c8794UL, 0xc57b9a86UL, 0xcc769188UL, + 0xf355a0a2UL, 0xfa58abacUL, 0xe14fb6beUL, 0xe842bdb0UL, + 0x9f09d4eaUL, 0x9604dfe4UL, 0x8d13c2f6UL, 0x841ec9f8UL, + 0xbb3df8d2UL, 0xb230f3dcUL, 0xa927eeceUL, 0xa02ae5c0UL, + 0x47b13c7aUL, 0x4ebc3774UL, 0x55ab2a66UL, 0x5ca62168UL, + 0x63851042UL, 0x6a881b4cUL, 0x719f065eUL, 0x78920d50UL, + 0x0fd9640aUL, 0x06d46f04UL, 0x1dc37216UL, 0x14ce7918UL, + 0x2bed4832UL, 0x22e0433cUL, 0x39f75e2eUL, 0x30fa5520UL, + 0x9ab701ecUL, 0x93ba0ae2UL, 0x88ad17f0UL, 0x81a01cfeUL, + 0xbe832dd4UL, 0xb78e26daUL, 0xac993bc8UL, 0xa59430c6UL, + 0xd2df599cUL, 0xdbd25292UL, 0xc0c54f80UL, 0xc9c8448eUL, + 0xf6eb75a4UL, 0xffe67eaaUL, 0xe4f163b8UL, 0xedfc68b6UL, + 0x0a67b10cUL, 0x036aba02UL, 0x187da710UL, 0x1170ac1eUL, + 0x2e539d34UL, 0x275e963aUL, 0x3c498b28UL, 0x35448026UL, + 0x420fe97cUL, 0x4b02e272UL, 0x5015ff60UL, 0x5918f46eUL, + 0x663bc544UL, 0x6f36ce4aUL, 0x7421d358UL, 0x7d2cd856UL, + 0xa10c7a37UL, 0xa8017139UL, 0xb3166c2bUL, 0xba1b6725UL, + 0x8538560fUL, 0x8c355d01UL, 0x97224013UL, 0x9e2f4b1dUL, + 0xe9642247UL, 0xe0692949UL, 0xfb7e345bUL, 0xf2733f55UL, + 0xcd500e7fUL, 0xc45d0571UL, 0xdf4a1863UL, 0xd647136dUL, + 0x31dccad7UL, 0x38d1c1d9UL, 0x23c6dccbUL, 0x2acbd7c5UL, + 0x15e8e6efUL, 0x1ce5ede1UL, 0x07f2f0f3UL, 0x0efffbfdUL, + 0x79b492a7UL, 0x70b999a9UL, 0x6bae84bbUL, 0x62a38fb5UL, + 0x5d80be9fUL, 0x548db591UL, 0x4f9aa883UL, 0x4697a38dUL + }; + s1350 = table4[s1349]; + s1351 = s1089 ^ s1350; + s1352 = sbv_bv_extract_u32_31_24_u8(s1351); + s1353 = table0[s1352]; + s1355 = s1353 ^ s1354; + s1356 = table1[s1355]; + s1358 = table0[s1357]; + s1360 = s1358 ^ s1359; + s1361 = table1[s1360]; + s1363 = table0[s1362]; + s1365 = s1363 ^ s1364; + s1366 = table2[s1365]; + s1367 = s1361 ^ s1366; + s1369 = table0[s1368]; + s1371 = s1369 ^ s1370; + s1372 = table3[s1371]; + s1373 = s1367 ^ s1372; + s1375 = table0[s1374]; + s1377 = s1375 ^ s1376; + s1378 = table4[s1377]; + s1379 = s1373 ^ s1378; + s1380 = sbv_bv_extract_u32_23_16_u8(s1379); + s1381 = table0[s1380]; + s1383 = s1381 ^ s1382; + s1384 = table2[s1383]; + s1385 = s1356 ^ s1384; + s1387 = table0[s1386]; + s1389 = s1387 ^ s1388; + s1390 = table1[s1389]; + s1392 = table0[s1391]; + s1394 = s1392 ^ s1393; + s1395 = table2[s1394]; + s1396 = s1390 ^ s1395; + s1398 = table0[s1397]; + s1400 = s1398 ^ s1399; + s1401 = table3[s1400]; + s1402 = s1396 ^ s1401; + s1404 = table0[s1403]; + s1406 = s1404 ^ s1405; + s1407 = table4[s1406]; + s1408 = s1402 ^ s1407; + s1409 = sbv_bv_extract_u32_15_8_u8(s1408); + s1410 = table0[s1409]; + s1412 = s1410 ^ s1411; + s1413 = table3[s1412]; + s1414 = s1385 ^ s1413; + s1416 = table0[s1415]; + s1418 = s1416 ^ s1417; + s1419 = table1[s1418]; + s1421 = table0[s1420]; + s1423 = s1421 ^ s1422; + s1424 = table2[s1423]; + s1425 = s1419 ^ s1424; + s1427 = table0[s1426]; + s1429 = s1427 ^ s1428; + s1430 = table3[s1429]; + s1431 = s1425 ^ s1430; + s1433 = table0[s1432]; + s1435 = s1433 ^ s1434; + s1436 = table4[s1435]; + s1437 = s1431 ^ s1436; + s1438 = sbv_bv_extract_u32_7_0_u8(s1437); + s1439 = table0[s1438]; + s1441 = s1439 ^ s1440; + s1442 = table4[s1441]; + s1443 = s1414 ^ s1442; + s1444 = sbv_bv_extract_u32_31_24_u8(s1443); + s1445 = table0[s1444]; + s1447 = s1445 ^ s1446; + s1448 = table1[s1447]; + s1449 = sbv_bv_extract_u32_31_24_u8(s1379); + s1450 = table0[s1449]; + s1452 = s1450 ^ s1451; + s1453 = table1[s1452]; + s1454 = sbv_bv_extract_u32_23_16_u8(s1408); + s1455 = table0[s1454]; + s1457 = s1455 ^ s1456; + s1458 = table2[s1457]; + s1459 = s1453 ^ s1458; + s1460 = sbv_bv_extract_u32_15_8_u8(s1437); + s1461 = table0[s1460]; + s1463 = s1461 ^ s1462; + s1464 = table3[s1463]; + s1465 = s1459 ^ s1464; + s1466 = sbv_bv_extract_u32_7_0_u8(s1351); + s1467 = table0[s1466]; + s1469 = s1467 ^ s1468; + s1470 = table4[s1469]; + s1471 = s1465 ^ s1470; + s1472 = sbv_bv_extract_u32_23_16_u8(s1471); + s1473 = table0[s1472]; + s1475 = s1473 ^ s1474; + s1476 = table2[s1475]; + s1477 = s1448 ^ s1476; + s1478 = sbv_bv_extract_u32_31_24_u8(s1408); + s1479 = table0[s1478]; + s1481 = s1479 ^ s1480; + s1482 = table1[s1481]; + s1483 = sbv_bv_extract_u32_23_16_u8(s1437); + s1484 = table0[s1483]; + s1486 = s1484 ^ s1485; + s1487 = table2[s1486]; + s1488 = s1482 ^ s1487; + s1489 = sbv_bv_extract_u32_15_8_u8(s1351); + s1490 = table0[s1489]; + s1492 = s1490 ^ s1491; + s1493 = table3[s1492]; + s1494 = s1488 ^ s1493; + s1495 = sbv_bv_extract_u32_7_0_u8(s1379); + s1496 = table0[s1495]; + s1498 = s1496 ^ s1497; + s1499 = table4[s1498]; + s1500 = s1494 ^ s1499; + s1501 = sbv_bv_extract_u32_15_8_u8(s1500); + s1502 = table0[s1501]; + s1504 = s1502 ^ s1503; + s1505 = table3[s1504]; + s1506 = s1477 ^ s1505; + s1507 = sbv_bv_extract_u32_31_24_u8(s1437); + s1508 = table0[s1507]; + s1510 = s1508 ^ s1509; + s1511 = table1[s1510]; + s1512 = sbv_bv_extract_u32_23_16_u8(s1351); + s1513 = table0[s1512]; + s1515 = s1513 ^ s1514; + s1516 = table2[s1515]; + s1517 = s1511 ^ s1516; + s1518 = sbv_bv_extract_u32_15_8_u8(s1379); + s1519 = table0[s1518]; + s1521 = s1519 ^ s1520; + s1522 = table3[s1521]; + s1523 = s1517 ^ s1522; + s1524 = sbv_bv_extract_u32_7_0_u8(s1408); + s1525 = table0[s1524]; + s1527 = s1525 ^ s1526; + s1528 = table4[s1527]; + s1529 = s1523 ^ s1528; + s1530 = sbv_bv_extract_u32_7_0_u8(s1529); + s1531 = table0[s1530]; + s1533 = s1531 ^ s1532; + s1534 = table4[s1533]; + s1535 = s1506 ^ s1534; + s1536 = sbv_bv_extract_u32_31_24_u8(s1535); + s1537 = table0[s1536]; + s1539 = s1537 ^ s1538; + s1540 = table1[s1539]; + s1541 = sbv_bv_extract_u32_31_24_u8(s1471); + s1542 = table0[s1541]; + s1544 = s1542 ^ s1543; + s1545 = table1[s1544]; + s1546 = sbv_bv_extract_u32_23_16_u8(s1500); + s1547 = table0[s1546]; + s1549 = s1547 ^ s1548; + s1550 = table2[s1549]; + s1551 = s1545 ^ s1550; + s1552 = sbv_bv_extract_u32_15_8_u8(s1529); + s1553 = table0[s1552]; + s1555 = s1553 ^ s1554; + s1556 = table3[s1555]; + s1557 = s1551 ^ s1556; + s1558 = sbv_bv_extract_u32_7_0_u8(s1443); + s1559 = table0[s1558]; + s1561 = s1559 ^ s1560; + s1562 = table4[s1561]; + s1563 = s1557 ^ s1562; + s1564 = sbv_bv_extract_u32_23_16_u8(s1563); + s1565 = table0[s1564]; + s1567 = s1565 ^ s1566; + s1568 = table2[s1567]; + s1569 = s1540 ^ s1568; + s1570 = sbv_bv_extract_u32_31_24_u8(s1500); + s1571 = table0[s1570]; + s1573 = s1571 ^ s1572; + s1574 = table1[s1573]; + s1575 = sbv_bv_extract_u32_23_16_u8(s1529); + s1576 = table0[s1575]; + s1578 = s1576 ^ s1577; + s1579 = table2[s1578]; + s1580 = s1574 ^ s1579; + s1581 = sbv_bv_extract_u32_15_8_u8(s1443); + s1582 = table0[s1581]; + s1584 = s1582 ^ s1583; + s1585 = table3[s1584]; + s1586 = s1580 ^ s1585; + s1587 = sbv_bv_extract_u32_7_0_u8(s1471); + s1588 = table0[s1587]; + s1590 = s1588 ^ s1589; + s1591 = table4[s1590]; + s1592 = s1586 ^ s1591; + s1593 = sbv_bv_extract_u32_15_8_u8(s1592); + s1594 = table0[s1593]; + s1596 = s1594 ^ s1595; + s1597 = table3[s1596]; + s1598 = s1569 ^ s1597; + s1599 = sbv_bv_extract_u32_31_24_u8(s1529); + s1600 = table0[s1599]; + s1602 = s1600 ^ s1601; + s1603 = table1[s1602]; + s1604 = sbv_bv_extract_u32_23_16_u8(s1443); + s1605 = table0[s1604]; + s1607 = s1605 ^ s1606; + s1608 = table2[s1607]; + s1609 = s1603 ^ s1608; + s1610 = sbv_bv_extract_u32_15_8_u8(s1471); + s1611 = table0[s1610]; + s1613 = s1611 ^ s1612; + s1614 = table3[s1613]; + s1615 = s1609 ^ s1614; + s1616 = sbv_bv_extract_u32_7_0_u8(s1500); + s1617 = table0[s1616]; + s1619 = s1617 ^ s1618; + s1620 = table4[s1619]; + s1621 = s1615 ^ s1620; + s1622 = sbv_bv_extract_u32_7_0_u8(s1621); + s1623 = table0[s1622]; + s1625 = s1623 ^ s1624; + s1626 = table4[s1625]; + s1627 = s1598 ^ s1626; + s1628 = sbv_bv_extract_u32_31_24_u8(s1627); + s1629 = table0[s1628]; + s1631 = s1629 ^ s1630; + s1632 = table1[s1631]; + s1633 = sbv_bv_extract_u32_31_24_u8(s1563); + s1634 = table0[s1633]; + s1636 = s1634 ^ s1635; + s1637 = table1[s1636]; + s1638 = sbv_bv_extract_u32_23_16_u8(s1592); + s1639 = table0[s1638]; + s1641 = s1639 ^ s1640; + s1642 = table2[s1641]; + s1643 = s1637 ^ s1642; + s1644 = sbv_bv_extract_u32_15_8_u8(s1621); + s1645 = table0[s1644]; + s1647 = s1645 ^ s1646; + s1648 = table3[s1647]; + s1649 = s1643 ^ s1648; + s1650 = sbv_bv_extract_u32_7_0_u8(s1535); + s1651 = table0[s1650]; + s1653 = s1651 ^ s1652; + s1654 = table4[s1653]; + s1655 = s1649 ^ s1654; + s1656 = sbv_bv_extract_u32_23_16_u8(s1655); + s1657 = table0[s1656]; + s1659 = s1657 ^ s1658; + s1660 = table2[s1659]; + s1661 = s1632 ^ s1660; + s1662 = sbv_bv_extract_u32_31_24_u8(s1592); + s1663 = table0[s1662]; + s1665 = s1663 ^ s1664; + s1666 = table1[s1665]; + s1667 = sbv_bv_extract_u32_23_16_u8(s1621); + s1668 = table0[s1667]; + s1670 = s1668 ^ s1669; + s1671 = table2[s1670]; + s1672 = s1666 ^ s1671; + s1673 = sbv_bv_extract_u32_15_8_u8(s1535); + s1674 = table0[s1673]; + s1676 = s1674 ^ s1675; + s1677 = table3[s1676]; + s1678 = s1672 ^ s1677; + s1679 = sbv_bv_extract_u32_7_0_u8(s1563); + s1680 = table0[s1679]; + s1682 = s1680 ^ s1681; + s1683 = table4[s1682]; + s1684 = s1678 ^ s1683; + s1685 = sbv_bv_extract_u32_15_8_u8(s1684); + s1686 = table0[s1685]; + s1688 = s1686 ^ s1687; + s1689 = table3[s1688]; + s1690 = s1661 ^ s1689; + s1691 = sbv_bv_extract_u32_31_24_u8(s1621); + s1692 = table0[s1691]; + s1694 = s1692 ^ s1693; + s1695 = table1[s1694]; + s1696 = sbv_bv_extract_u32_23_16_u8(s1535); + s1697 = table0[s1696]; + s1699 = s1697 ^ s1698; + s1700 = table2[s1699]; + s1701 = s1695 ^ s1700; + s1702 = sbv_bv_extract_u32_15_8_u8(s1563); + s1703 = table0[s1702]; + s1705 = s1703 ^ s1704; + s1706 = table3[s1705]; + s1707 = s1701 ^ s1706; + s1708 = sbv_bv_extract_u32_7_0_u8(s1592); + s1709 = table0[s1708]; + s1711 = s1709 ^ s1710; + s1712 = table4[s1711]; + s1713 = s1707 ^ s1712; + s1714 = sbv_bv_extract_u32_7_0_u8(s1713); + s1715 = table0[s1714]; + s1717 = s1715 ^ s1716; + s1718 = table4[s1717]; + s1719 = s1690 ^ s1718; + s1720 = sbv_bv_extract_u32_31_24_u8(s1719); + s1721 = table0[s1720]; + s1723 = s1721 ^ s1722; + s1724 = table1[s1723]; + s1725 = sbv_bv_extract_u32_31_24_u8(s1655); + s1726 = table0[s1725]; + s1728 = s1726 ^ s1727; + s1729 = table1[s1728]; + s1730 = sbv_bv_extract_u32_23_16_u8(s1684); + s1731 = table0[s1730]; + s1733 = s1731 ^ s1732; + s1734 = table2[s1733]; + s1735 = s1729 ^ s1734; + s1736 = sbv_bv_extract_u32_15_8_u8(s1713); + s1737 = table0[s1736]; + s1739 = s1737 ^ s1738; + s1740 = table3[s1739]; + s1741 = s1735 ^ s1740; + s1742 = sbv_bv_extract_u32_7_0_u8(s1627); + s1743 = table0[s1742]; + s1745 = s1743 ^ s1744; + s1746 = table4[s1745]; + s1747 = s1741 ^ s1746; + s1748 = sbv_bv_extract_u32_23_16_u8(s1747); + s1749 = table0[s1748]; + s1751 = s1749 ^ s1750; + s1752 = table2[s1751]; + s1753 = s1724 ^ s1752; + s1754 = sbv_bv_extract_u32_31_24_u8(s1684); + s1755 = table0[s1754]; + s1757 = s1755 ^ s1756; + s1758 = table1[s1757]; + s1759 = sbv_bv_extract_u32_23_16_u8(s1713); + s1760 = table0[s1759]; + s1762 = s1760 ^ s1761; + s1763 = table2[s1762]; + s1764 = s1758 ^ s1763; + s1765 = sbv_bv_extract_u32_15_8_u8(s1627); + s1766 = table0[s1765]; + s1768 = s1766 ^ s1767; + s1769 = table3[s1768]; + s1770 = s1764 ^ s1769; + s1771 = sbv_bv_extract_u32_7_0_u8(s1655); + s1772 = table0[s1771]; + s1774 = s1772 ^ s1773; + s1775 = table4[s1774]; + s1776 = s1770 ^ s1775; + s1777 = sbv_bv_extract_u32_15_8_u8(s1776); + s1778 = table0[s1777]; + s1780 = s1778 ^ s1779; + s1781 = table3[s1780]; + s1782 = s1753 ^ s1781; + s1783 = sbv_bv_extract_u32_31_24_u8(s1713); + s1784 = table0[s1783]; + s1786 = s1784 ^ s1785; + s1787 = table1[s1786]; + s1788 = sbv_bv_extract_u32_23_16_u8(s1627); + s1789 = table0[s1788]; + s1791 = s1789 ^ s1790; + s1792 = table2[s1791]; + s1793 = s1787 ^ s1792; + s1794 = sbv_bv_extract_u32_15_8_u8(s1655); + s1795 = table0[s1794]; + s1797 = s1795 ^ s1796; + s1798 = table3[s1797]; + s1799 = s1793 ^ s1798; + s1800 = sbv_bv_extract_u32_7_0_u8(s1684); + s1801 = table0[s1800]; + s1803 = s1801 ^ s1802; + s1804 = table4[s1803]; + s1805 = s1799 ^ s1804; + s1806 = sbv_bv_extract_u32_7_0_u8(s1805); + s1807 = table0[s1806]; + s1809 = s1807 ^ s1808; + s1810 = table4[s1809]; + s1811 = s1782 ^ s1810; + s1812 = sbv_bv_extract_u32_31_24_u8(s1811); + s1813 = table0[s1812]; + s1815 = s1813 ^ s1814; + s1816 = table1[s1815]; + s1817 = sbv_bv_extract_u32_31_24_u8(s1747); + s1818 = table0[s1817]; + s1820 = s1818 ^ s1819; + s1821 = table1[s1820]; + s1822 = sbv_bv_extract_u32_23_16_u8(s1776); + s1823 = table0[s1822]; + s1825 = s1823 ^ s1824; + s1826 = table2[s1825]; + s1827 = s1821 ^ s1826; + s1828 = sbv_bv_extract_u32_15_8_u8(s1805); + s1829 = table0[s1828]; + s1831 = s1829 ^ s1830; + s1832 = table3[s1831]; + s1833 = s1827 ^ s1832; + s1834 = sbv_bv_extract_u32_7_0_u8(s1719); + s1835 = table0[s1834]; + s1837 = s1835 ^ s1836; + s1838 = table4[s1837]; + s1839 = s1833 ^ s1838; + s1840 = sbv_bv_extract_u32_23_16_u8(s1839); + s1841 = table0[s1840]; + s1843 = s1841 ^ s1842; + s1844 = table2[s1843]; + s1845 = s1816 ^ s1844; + s1846 = sbv_bv_extract_u32_31_24_u8(s1776); + s1847 = table0[s1846]; + s1849 = s1847 ^ s1848; + s1850 = table1[s1849]; + s1851 = sbv_bv_extract_u32_23_16_u8(s1805); + s1852 = table0[s1851]; + s1854 = s1852 ^ s1853; + s1855 = table2[s1854]; + s1856 = s1850 ^ s1855; + s1857 = sbv_bv_extract_u32_15_8_u8(s1719); + s1858 = table0[s1857]; + s1860 = s1858 ^ s1859; + s1861 = table3[s1860]; + s1862 = s1856 ^ s1861; + s1863 = sbv_bv_extract_u32_7_0_u8(s1747); + s1864 = table0[s1863]; + s1866 = s1864 ^ s1865; + s1867 = table4[s1866]; + s1868 = s1862 ^ s1867; + s1869 = sbv_bv_extract_u32_15_8_u8(s1868); + s1870 = table0[s1869]; + s1872 = s1870 ^ s1871; + s1873 = table3[s1872]; + s1874 = s1845 ^ s1873; + s1875 = sbv_bv_extract_u32_31_24_u8(s1805); + s1876 = table0[s1875]; + s1878 = s1876 ^ s1877; + s1879 = table1[s1878]; + s1880 = sbv_bv_extract_u32_23_16_u8(s1719); + s1881 = table0[s1880]; + s1883 = s1881 ^ s1882; + s1884 = table2[s1883]; + s1885 = s1879 ^ s1884; + s1886 = sbv_bv_extract_u32_15_8_u8(s1747); + s1887 = table0[s1886]; + s1889 = s1887 ^ s1888; + s1890 = table3[s1889]; + s1891 = s1885 ^ s1890; + s1892 = sbv_bv_extract_u32_7_0_u8(s1776); + s1893 = table0[s1892]; + s1895 = s1893 ^ s1894; + s1896 = table4[s1895]; + s1897 = s1891 ^ s1896; + s1898 = sbv_bv_extract_u32_7_0_u8(s1897); + s1899 = table0[s1898]; + s1901 = s1899 ^ s1900; + s1902 = table4[s1901]; + s1903 = s1874 ^ s1902; + s1904 = sbv_bv_extract_u32_31_24_u8(s1903); + s1905 = table0[s1904]; + s1907 = s1905 ^ s1906; + s1908 = table1[s1907]; + s1909 = sbv_bv_extract_u32_31_24_u8(s1839); + s1910 = table0[s1909]; + s1912 = s1910 ^ s1911; + s1913 = table1[s1912]; + s1914 = sbv_bv_extract_u32_23_16_u8(s1868); + s1915 = table0[s1914]; + s1917 = s1915 ^ s1916; + s1918 = table2[s1917]; + s1919 = s1913 ^ s1918; + s1920 = sbv_bv_extract_u32_15_8_u8(s1897); + s1921 = table0[s1920]; + s1923 = s1921 ^ s1922; + s1924 = table3[s1923]; + s1925 = s1919 ^ s1924; + s1926 = sbv_bv_extract_u32_7_0_u8(s1811); + s1927 = table0[s1926]; + s1929 = s1927 ^ s1928; + s1930 = table4[s1929]; + s1931 = s1925 ^ s1930; + s1932 = sbv_bv_extract_u32_23_16_u8(s1931); + s1933 = table0[s1932]; + s1935 = s1933 ^ s1934; + s1936 = table2[s1935]; + s1937 = s1908 ^ s1936; + s1938 = sbv_bv_extract_u32_31_24_u8(s1868); + s1939 = table0[s1938]; + s1941 = s1939 ^ s1940; + s1942 = table1[s1941]; + s1943 = sbv_bv_extract_u32_23_16_u8(s1897); + s1944 = table0[s1943]; + s1946 = s1944 ^ s1945; + s1947 = table2[s1946]; + s1948 = s1942 ^ s1947; + s1949 = sbv_bv_extract_u32_15_8_u8(s1811); + s1950 = table0[s1949]; + s1952 = s1950 ^ s1951; + s1953 = table3[s1952]; + s1954 = s1948 ^ s1953; + s1955 = sbv_bv_extract_u32_7_0_u8(s1839); + s1956 = table0[s1955]; + s1958 = s1956 ^ s1957; + s1959 = table4[s1958]; + s1960 = s1954 ^ s1959; + s1961 = sbv_bv_extract_u32_15_8_u8(s1960); + s1962 = table0[s1961]; + s1964 = s1962 ^ s1963; + s1965 = table3[s1964]; + s1966 = s1937 ^ s1965; + s1967 = sbv_bv_extract_u32_31_24_u8(s1897); + s1968 = table0[s1967]; + s1970 = s1968 ^ s1969; + s1971 = table1[s1970]; + s1972 = sbv_bv_extract_u32_23_16_u8(s1811); + s1973 = table0[s1972]; + s1975 = s1973 ^ s1974; + s1976 = table2[s1975]; + s1977 = s1971 ^ s1976; + s1978 = sbv_bv_extract_u32_15_8_u8(s1839); + s1979 = table0[s1978]; + s1981 = s1979 ^ s1980; + s1982 = table3[s1981]; + s1983 = s1977 ^ s1982; + s1984 = sbv_bv_extract_u32_7_0_u8(s1868); + s1985 = table0[s1984]; + s1987 = s1985 ^ s1986; + s1988 = table4[s1987]; + s1989 = s1983 ^ s1988; + s1990 = sbv_bv_extract_u32_7_0_u8(s1989); + s1991 = table0[s1990]; + s1993 = s1991 ^ s1992; + s1994 = table4[s1993]; + s1995 = s1966 ^ s1994; + s1996 = sbv_bv_extract_u32_31_24_u8(s1995); + s1997 = table0[s1996]; + s1999 = s1997 ^ s1998; + s2000 = table1[s1999]; + s2001 = sbv_bv_extract_u32_31_24_u8(s1931); + s2002 = table0[s2001]; + s2004 = s2002 ^ s2003; + s2005 = table1[s2004]; + s2006 = sbv_bv_extract_u32_23_16_u8(s1960); + s2007 = table0[s2006]; + s2009 = s2007 ^ s2008; + s2010 = table2[s2009]; + s2011 = s2005 ^ s2010; + s2012 = sbv_bv_extract_u32_15_8_u8(s1989); + s2013 = table0[s2012]; + s2015 = s2013 ^ s2014; + s2016 = table3[s2015]; + s2017 = s2011 ^ s2016; + s2018 = sbv_bv_extract_u32_7_0_u8(s1903); + s2019 = table0[s2018]; + s2021 = s2019 ^ s2020; + s2022 = table4[s2021]; + s2023 = s2017 ^ s2022; + s2024 = sbv_bv_extract_u32_23_16_u8(s2023); + s2025 = table0[s2024]; + s2027 = s2025 ^ s2026; + s2028 = table2[s2027]; + s2029 = s2000 ^ s2028; + s2030 = sbv_bv_extract_u32_31_24_u8(s1960); + s2031 = table0[s2030]; + s2033 = s2031 ^ s2032; + s2034 = table1[s2033]; + s2035 = sbv_bv_extract_u32_23_16_u8(s1989); + s2036 = table0[s2035]; + s2038 = s2036 ^ s2037; + s2039 = table2[s2038]; + s2040 = s2034 ^ s2039; + s2041 = sbv_bv_extract_u32_15_8_u8(s1903); + s2042 = table0[s2041]; + s2044 = s2042 ^ s2043; + s2045 = table3[s2044]; + s2046 = s2040 ^ s2045; + s2047 = sbv_bv_extract_u32_7_0_u8(s1931); + s2048 = table0[s2047]; + s2050 = s2048 ^ s2049; + s2051 = table4[s2050]; + s2052 = s2046 ^ s2051; + s2053 = sbv_bv_extract_u32_15_8_u8(s2052); + s2054 = table0[s2053]; + s2056 = s2054 ^ s2055; + s2057 = table3[s2056]; + s2058 = s2029 ^ s2057; + s2059 = sbv_bv_extract_u32_31_24_u8(s1989); + s2060 = table0[s2059]; + s2062 = s2060 ^ s2061; + s2063 = table1[s2062]; + s2064 = sbv_bv_extract_u32_23_16_u8(s1903); + s2065 = table0[s2064]; + s2067 = s2065 ^ s2066; + s2068 = table2[s2067]; + s2069 = s2063 ^ s2068; + s2070 = sbv_bv_extract_u32_15_8_u8(s1931); + s2071 = table0[s2070]; + s2073 = s2071 ^ s2072; + s2074 = table3[s2073]; + s2075 = s2069 ^ s2074; + s2076 = sbv_bv_extract_u32_7_0_u8(s1960); + s2077 = table0[s2076]; + s2079 = s2077 ^ s2078; + s2080 = table4[s2079]; + s2081 = s2075 ^ s2080; + s2082 = sbv_bv_extract_u32_7_0_u8(s2081); + s2083 = table0[s2082]; + s2085 = s2083 ^ s2084; + s2086 = table4[s2085]; + s2087 = s2058 ^ s2086; + s2088 = sbv_bv_extract_u32_31_24_u8(s2087); + s2089 = table0[s2088]; + s2090 = sbv_bv_extract_u32_31_24_u8(s2023); + s2091 = table0[s2090]; + s2093 = s2091 ^ s2092; + s2094 = table1[s2093]; + s2095 = sbv_bv_extract_u32_23_16_u8(s2052); + s2096 = table0[s2095]; + s2098 = s2096 ^ s2097; + s2099 = table2[s2098]; + s2100 = s2094 ^ s2099; + s2101 = sbv_bv_extract_u32_15_8_u8(s2081); + s2102 = table0[s2101]; + s2104 = s2102 ^ s2103; + s2105 = table3[s2104]; + s2106 = s2100 ^ s2105; + s2107 = sbv_bv_extract_u32_7_0_u8(s1995); + s2108 = table0[s2107]; + s2110 = s2108 ^ s2109; + s2111 = table4[s2110]; + s2112 = s2106 ^ s2111; + s2113 = sbv_bv_extract_u32_23_16_u8(s2112); + s2114 = table0[s2113]; + s2115 = sbv_bv_join_u8_u8_u16(s2089, s2114); + s2116 = sbv_bv_extract_u32_31_24_u8(s2052); + s2117 = table0[s2116]; + s2119 = s2117 ^ s2118; + s2120 = table1[s2119]; + s2121 = sbv_bv_extract_u32_23_16_u8(s2081); + s2122 = table0[s2121]; + s2124 = s2122 ^ s2123; + s2125 = table2[s2124]; + s2126 = s2120 ^ s2125; + s2127 = sbv_bv_extract_u32_15_8_u8(s1995); + s2128 = table0[s2127]; + s2130 = s2128 ^ s2129; + s2131 = table3[s2130]; + s2132 = s2126 ^ s2131; + s2133 = sbv_bv_extract_u32_7_0_u8(s2023); + s2134 = table0[s2133]; + s2136 = s2134 ^ s2135; + s2137 = table4[s2136]; + s2138 = s2132 ^ s2137; + s2139 = sbv_bv_extract_u32_15_8_u8(s2138); + s2140 = table0[s2139]; + s2141 = sbv_bv_extract_u32_31_24_u8(s2081); + s2142 = table0[s2141]; + s2144 = s2142 ^ s2143; + s2145 = table1[s2144]; + s2146 = sbv_bv_extract_u32_23_16_u8(s1995); + s2147 = table0[s2146]; + s2149 = s2147 ^ s2148; + s2150 = table2[s2149]; + s2151 = s2145 ^ s2150; + s2152 = sbv_bv_extract_u32_15_8_u8(s2023); + s2153 = table0[s2152]; + s2155 = s2153 ^ s2154; + s2156 = table3[s2155]; + s2157 = s2151 ^ s2156; + s2158 = sbv_bv_extract_u32_7_0_u8(s2052); + s2159 = table0[s2158]; + s2161 = s2159 ^ s2160; + s2162 = table4[s2161]; + s2163 = s2157 ^ s2162; + s2164 = sbv_bv_extract_u32_7_0_u8(s2163); + s2165 = table0[s2164]; + s2166 = sbv_bv_join_u8_u8_u16(s2140, s2165); + s2167 = sbv_bv_join_u16_u16_u32(s2115, s2166); + s2168 = s44 ^ s2167; + s2169 = sbv_bv_extract_u32_31_24_u8(s2163); + s2170 = table0[s2169]; + s2171 = sbv_bv_extract_u32_23_16_u8(s2087); + s2172 = table0[s2171]; + s2173 = sbv_bv_join_u8_u8_u16(s2170, s2172); + s2174 = sbv_bv_extract_u32_15_8_u8(s2112); + s2175 = table0[s2174]; + s2176 = sbv_bv_extract_u32_7_0_u8(s2138); + s2177 = table0[s2176]; + s2178 = sbv_bv_join_u8_u8_u16(s2175, s2177); + s2179 = sbv_bv_join_u16_u16_u32(s2173, s2178); + s2180 = s45 ^ s2179; + s2181 = sbv_bv_extract_u32_31_24_u8(s2138); + s2182 = table0[s2181]; + s2183 = sbv_bv_extract_u32_23_16_u8(s2163); + s2184 = table0[s2183]; + s2185 = sbv_bv_join_u8_u8_u16(s2182, s2184); + s2186 = sbv_bv_extract_u32_15_8_u8(s2087); + s2187 = table0[s2186]; + s2188 = sbv_bv_extract_u32_7_0_u8(s2112); + s2189 = table0[s2188]; + s2190 = sbv_bv_join_u8_u8_u16(s2187, s2189); + s2191 = sbv_bv_join_u16_u16_u32(s2185, s2190); + s2192 = s46 ^ s2191; + s2193 = sbv_bv_extract_u32_31_24_u8(s2112); + s2194 = table0[s2193]; + s2195 = sbv_bv_extract_u32_23_16_u8(s2138); + s2196 = table0[s2195]; + s2197 = sbv_bv_join_u8_u8_u16(s2194, s2196); + s2198 = sbv_bv_extract_u32_15_8_u8(s2163); + s2199 = table0[s2198]; + s2200 = sbv_bv_extract_u32_7_0_u8(s2087); + s2201 = table0[s2200]; + s2202 = sbv_bv_join_u8_u8_u16(s2199, s2201); + s2203 = sbv_bv_join_u16_u16_u32(s2197, s2202); + s2204 = s47 ^ s2203; + + sbv_output_0[0] = s2168; + sbv_output_0[1] = s2180; + sbv_output_0[2] = s2192; + sbv_output_0[3] = s2204; +} +== END: "aes128OTFDecrypt.c" ================== +== BEGIN: "aes128Lib.h" ================ +/* Header file for aes128Lib. Automatically generated by SBV. Do not edit! */ + +#ifndef SBV_GENERATED_aes128Lib_HEADER_INCLUDED +#define SBV_GENERATED_aes128Lib_HEADER_INCLUDED + + +#include +#include +#include +#include +#include +#include +#include + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* Entry point prototypes: */ +void aes128KeySchedule(const SWord32 *key, SWord32 *encKS, + SWord32 *decKS); +void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey, + SWord32 *ct); +void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey, + SWord32 *pt); +void aes128InvKeySchedule(const SWord32 *key, SWord32 *decKS); +void aes128OTFDecrypt(const SWord32 *ct, const SWord32 *xkey, + SWord32 *pt); + +#endif /* SBV_GENERATED_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 +#include "aes128Lib.h" + +void aes128KeySchedule_driver(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array key:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" key[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[44]; + SWord32 sbv_driver_output_1[44]; + + aes128KeySchedule(sbv_driver_input_0, sbv_driver_output_0, + sbv_driver_output_1); + + printf("aes128KeySchedule(key, encKS, decKS) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 44 ; ++sbv_driver_output_0_ctr) + { printf(" encKS[%2d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } + int sbv_driver_output_1_ctr; + for(sbv_driver_output_1_ctr = 0; sbv_driver_output_1_ctr < 44 ; ++sbv_driver_output_1_ctr) + { printf(" decKS[%2d] = ", sbv_driver_output_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_1[sbv_driver_output_1_ctr]); + printf("\n"); + } +} + +void aes128BlockEncrypt_driver(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array pt:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" pt[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord32 sbv_driver_input_1[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 sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 44 ; ++sbv_driver_input_1_ctr) + { printf(" xkey[%2d] = ", sbv_driver_input_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[4]; + + aes128BlockEncrypt(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("aes128BlockEncrypt(pt, xkey, ct) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 4 ; ++sbv_driver_output_0_ctr) + { printf(" ct[%1d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } +} + +void aes128BlockDecrypt_driver(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array ct:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" ct[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord32 sbv_driver_input_1[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 sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 44 ; ++sbv_driver_input_1_ctr) + { printf(" xkey[%2d] = ", sbv_driver_input_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[4]; + + aes128BlockDecrypt(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("aes128BlockDecrypt(ct, xkey, pt) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 4 ; ++sbv_driver_output_0_ctr) + { printf(" pt[%1d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } +} + +void aes128InvKeySchedule_driver(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array key:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" key[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[44]; + + aes128InvKeySchedule(sbv_driver_input_0, sbv_driver_output_0); + + printf("aes128InvKeySchedule(key, decKS) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 44 ; ++sbv_driver_output_0_ctr) + { printf(" decKS[%2d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } +} + +void aes128OTFDecrypt_driver(void) +{ + const SWord32 sbv_driver_input_0[4] = { + 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL + }; + + printf("Contents of input array ct:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 4 ; ++sbv_driver_input_0_ctr) + { printf(" ct[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord32 sbv_driver_input_1[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 sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 44 ; ++sbv_driver_input_1_ctr) + { printf(" xkey[%2d] = ", sbv_driver_input_1_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord32 sbv_driver_output_0[4]; + + aes128OTFDecrypt(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("aes128OTFDecrypt(ct, xkey, pt) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 4 ; ++sbv_driver_output_0_ctr) + { printf(" pt[%1d] = ", sbv_driver_output_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } +} + +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(); + + printf("=======================================\n"); + printf("** Driver run for aes128InvKeySchedule:\n"); + printf("=======================================\n"); + aes128InvKeySchedule_driver(); + + printf("===================================\n"); + printf("** Driver run for aes128OTFDecrypt:\n"); + printf("===================================\n"); + aes128OTFDecrypt_driver(); + + return 0; +} +== END: "aes128Lib_driver.c" ================== +== BEGIN: "Makefile" ================ +# Makefile for aes128Lib. Automatically generated by SBV. Do not edit! + +# include any user-defined .mk file in the current directory. +-include *.mk + +CC?=gcc +CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer +AR?=ar +ARFLAGS?=cr + +all: aes128Lib.a aes128Lib_driver + +aes128Lib.a: aes128KeySchedule.o aes128BlockEncrypt.o aes128BlockDecrypt.o aes128InvKeySchedule.o aes128OTFDecrypt.o + rm -f $@.tmp + ${AR} ${ARFLAGS} $@.tmp $^ + mv -f $@.tmp $@ + +aes128Lib_driver: aes128Lib_driver.c aes128Lib.h aes128Lib.a + ${CC} ${CCFLAGS} $< -o $@ aes128Lib.a ${LDFLAGS} + +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 $@ + +aes128InvKeySchedule.o: aes128InvKeySchedule.c aes128Lib.h + ${CC} ${CCFLAGS} -c $< -o $@ + +aes128OTFDecrypt.o: aes128OTFDecrypt.c aes128Lib.h + ${CC} ${CCFLAGS} -c $< -o $@ + +clean: + rm -f *.o + +veryclean: clean + rm -f aes128Lib.a aes128Lib_driver aes128Lib.a.tmp == END: "Makefile" ================== diff --git a/SBVTestSuite/GoldFiles/cgUninterpret.gold b/SBVTestSuite/GoldFiles/cgUninterpret.gold --- a/SBVTestSuite/GoldFiles/cgUninterpret.gold +++ b/SBVTestSuite/GoldFiles/cgUninterpret.gold @@ -12,11 +12,11 @@ tstShiftLeft.o: tstShiftLeft.c tstShiftLeft.h ${CC} ${CCFLAGS} -c $< -o $@ -tstShiftLeft_driver.o: tstShiftLeft_driver.c +tstShiftLeft_driver.o: tstShiftLeft_driver.c tstShiftLeft.h ${CC} ${CCFLAGS} -c $< -o $@ tstShiftLeft_driver: tstShiftLeft.o tstShiftLeft_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "tstShiftLeft.h" ================ /* Header file for tstShiftLeft. Automatically generated by SBV. Do not edit! */ -#ifndef __tstShiftLeft__HEADER_INCLUDED__ -#define __tstShiftLeft__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_tstShiftLeft_HEADER_INCLUDED +#define SBV_GENERATED_tstShiftLeft_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord32 tstShiftLeft(const SWord32 *vs); -#endif /* __tstShiftLeft__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_tstShiftLeft_HEADER_INCLUDED */ == END: "tstShiftLeft.h" ================== == BEGIN: "tstShiftLeft_driver.c" ================ /* Example driver program for tstShiftLeft. */ @@ -73,19 +81,22 @@ int main(void) { - const SWord32 vs[3] = { + const SWord32 sbv_driver_input_0[3] = { 0x00000001UL, 0x00000002UL, 0x00000003UL }; printf("Contents of input array vs:\n"); - int vs_ctr; - for(vs_ctr = 0; vs_ctr < 3 ; ++vs_ctr) - printf(" vs[%1d] = 0x%08"PRIx32"UL\n", vs_ctr ,vs[vs_ctr]); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 3 ; ++sbv_driver_input_0_ctr) + { printf(" vs[%1d] = ", sbv_driver_input_0_ctr); + printf("0x%08"PRIx32"UL", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } - const SWord32 __result = tstShiftLeft(vs); + const SWord32 sbv_result = tstShiftLeft(sbv_driver_input_0); - printf("tstShiftLeft(vs) = 0x%08"PRIx32"UL\n", __result); + printf("tstShiftLeft(vs) = 0x%08"PRIx32"UL\n", sbv_result); return 0; } @@ -98,16 +109,33 @@ /* User specified custom code for "SBV_SHIFTLEFT" */ #define SBV_SHIFTLEFT(x, y) ((x) << (y)) -SWord32 tstShiftLeft(const SWord32 *vs) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_add(SWord32 a, SWord32 b) { - const SWord32 s0 = vs[0]; - const SWord32 s1 = vs[1]; - const SWord32 s2 = vs[2]; - const SWord32 s3 = /* Uninterpreted function */ SBV_SHIFTLEFT(s0, - s2); - const SWord32 s4 = /* Uninterpreted function */ SBV_SHIFTLEFT(s1, - s2); - const SWord32 s5 = s3 + s4; + const SWord32 bits = (SWord32) ((((uint64_t) (SWord32) a) + ((uint64_t) (SWord32) b)) & UINT64_C(0x00000000ffffffff)); + return (SWord32) bits; +} + + +SWord32 tstShiftLeft(const SWord32 *sbv_input_0) +{ + const SWord32 s0 = sbv_input_0[0]; + const SWord32 s1 = sbv_input_0[1]; + const SWord32 s2 = sbv_input_0[2]; + SWord32 s3; + SWord32 s4; + SWord32 s5; + s3 = /* Uninterpreted function */ SBV_SHIFTLEFT(s0, s2); + s4 = /* Uninterpreted function */ SBV_SHIFTLEFT(s1, s2); + s5 = sbv_bv_u32_add(s3, s4); return s5; } diff --git a/SBVTestSuite/GoldFiles/codeGen1.gold b/SBVTestSuite/GoldFiles/codeGen1.gold --- a/SBVTestSuite/GoldFiles/codeGen1.gold +++ b/SBVTestSuite/GoldFiles/codeGen1.gold @@ -12,11 +12,11 @@ foo.o: foo.c foo.h ${CC} ${CCFLAGS} -c $< -o $@ -foo_driver.o: foo_driver.c +foo_driver.o: foo_driver.c foo.h ${CC} ${CCFLAGS} -c $< -o $@ foo_driver: foo.o foo_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "foo.h" ================ /* Header file for foo. Automatically generated by SBV. Do not edit! */ -#ifndef __foo__HEADER_INCLUDED__ -#define __foo__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_foo_HEADER_INCLUDED +#define SBV_GENERATED_foo_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -63,7 +71,7 @@ SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z, SInt16 *zArr, SInt64 *yArr); -#endif /* __foo__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_foo_HEADER_INCLUDED */ == END: "foo.h" ================== == BEGIN: "foo_driver.c" ================ /* Example driver program for foo. */ @@ -74,7 +82,7 @@ int main(void) { - const SInt64 xArr[45] = { + const SInt64 sbv_driver_input_1[45] = { 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, @@ -93,24 +101,34 @@ }; printf("Contents of input array xArr:\n"); - int xArr_ctr; - for(xArr_ctr = 0; xArr_ctr < 45 ; ++xArr_ctr) - printf(" xArr[%2d] = %"PRId64"LL\n", xArr_ctr ,xArr[xArr_ctr]); + int sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 45 ; ++sbv_driver_input_1_ctr) + { printf(" xArr[%2d] = ", sbv_driver_input_1_ctr); + printf("%"PRId64"LL", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } - SWord16 z; - SInt16 zArr[7]; - SInt64 yArr[45]; + SWord16 sbv_driver_output_0; + SInt16 sbv_driver_output_1[7]; + SInt64 sbv_driver_output_2[45]; - const SInt16 __result = foo(0x0000, xArr, &z, zArr, yArr); + const SInt16 sbv_result = foo(0x0000, sbv_driver_input_1, + &sbv_driver_output_0, sbv_driver_output_1, sbv_driver_output_2); - 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[%1d] = %"PRId16"\n", zArr_ctr ,zArr[zArr_ctr]); - int yArr_ctr; - for(yArr_ctr = 0; yArr_ctr < 45 ; ++yArr_ctr) - printf(" yArr[%2d] = %"PRId64"LL\n", yArr_ctr ,yArr[yArr_ctr]); + printf("foo(0x0000, xArr, &z, zArr, yArr) = %"PRId16"\n", sbv_result); + printf(" z = 0x%04"PRIx16"U\n", sbv_driver_output_0); + int sbv_driver_output_1_ctr; + for(sbv_driver_output_1_ctr = 0; sbv_driver_output_1_ctr < 7 ; ++sbv_driver_output_1_ctr) + { printf(" zArr[%1d] = ", sbv_driver_output_1_ctr); + printf("%"PRId16"", sbv_driver_output_1[sbv_driver_output_1_ctr]); + printf("\n"); + } + int sbv_driver_output_2_ctr; + for(sbv_driver_output_2_ctr = 0; sbv_driver_output_2_ctr < 45 ; ++sbv_driver_output_2_ctr) + { printf(" yArr[%2d] = ", sbv_driver_output_2_ctr); + printf("%"PRId64"LL", sbv_driver_output_2[sbv_driver_output_2_ctr]); + printf("\n"); + } return 0; } @@ -120,111 +138,133 @@ #include "foo.h" -SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z, - SInt16 *zArr, SInt64 *yArr) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SInt16 sbv_bv_s16_add(SInt16 a, SInt16 b) { - 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; + const SWord16 bits = (SWord16) ((((uint64_t) (SWord16) a) + ((uint64_t) (SWord16) b)) & UINT64_C(0x000000000000ffff)); + SInt16 result; memcpy(&result, &bits, sizeof result); return result; +} - *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; +static inline SBV_CGEN_UNUSED SInt16 sbv_bv_s16_mul(SInt16 a, SInt16 b) +{ + const SWord16 bits = (SWord16) ((((uint64_t) (SWord16) a) * ((uint64_t) (SWord16) b)) & UINT64_C(0x000000000000ffff)); + SInt16 result; memcpy(&result, &bits, sizeof result); return result; +} + + +SInt16 foo(const SInt16 sbv_input_0, const SInt64 *sbv_input_1, + SWord16 *sbv_output_0, SInt16 *sbv_output_1, SInt64 *sbv_output_2) +{ + const SInt16 s0 = sbv_input_0; + const SInt64 s1 = sbv_input_1[0]; + const SInt64 s2 = sbv_input_1[1]; + const SInt64 s3 = sbv_input_1[2]; + const SInt64 s4 = sbv_input_1[3]; + const SInt64 s5 = sbv_input_1[4]; + const SInt64 s6 = sbv_input_1[5]; + const SInt64 s7 = sbv_input_1[6]; + const SInt64 s8 = sbv_input_1[7]; + const SInt64 s9 = sbv_input_1[8]; + const SInt64 s10 = sbv_input_1[9]; + const SInt64 s11 = sbv_input_1[10]; + const SInt64 s12 = sbv_input_1[11]; + const SInt64 s13 = sbv_input_1[12]; + const SInt64 s14 = sbv_input_1[13]; + const SInt64 s15 = sbv_input_1[14]; + const SInt64 s16 = sbv_input_1[15]; + const SInt64 s17 = sbv_input_1[16]; + const SInt64 s18 = sbv_input_1[17]; + const SInt64 s19 = sbv_input_1[18]; + const SInt64 s20 = sbv_input_1[19]; + const SInt64 s21 = sbv_input_1[20]; + const SInt64 s22 = sbv_input_1[21]; + const SInt64 s23 = sbv_input_1[22]; + const SInt64 s24 = sbv_input_1[23]; + const SInt64 s25 = sbv_input_1[24]; + const SInt64 s26 = sbv_input_1[25]; + const SInt64 s27 = sbv_input_1[26]; + const SInt64 s28 = sbv_input_1[27]; + const SInt64 s29 = sbv_input_1[28]; + const SInt64 s30 = sbv_input_1[29]; + const SInt64 s31 = sbv_input_1[30]; + const SInt64 s32 = sbv_input_1[31]; + const SInt64 s33 = sbv_input_1[32]; + const SInt64 s34 = sbv_input_1[33]; + const SInt64 s35 = sbv_input_1[34]; + const SInt64 s36 = sbv_input_1[35]; + const SInt64 s37 = sbv_input_1[36]; + const SInt64 s38 = sbv_input_1[37]; + const SInt64 s39 = sbv_input_1[38]; + const SInt64 s40 = sbv_input_1[39]; + const SInt64 s41 = sbv_input_1[40]; + const SInt64 s42 = sbv_input_1[41]; + const SInt64 s43 = sbv_input_1[42]; + const SInt64 s44 = sbv_input_1[43]; + const SInt64 s45 = sbv_input_1[44]; + const SInt16 s48 = sbv_bv_s16_add(s0, 0x0001); + const SInt16 s50 = sbv_bv_s16_mul(s0, 0x0002); + + *sbv_output_0 = 0x0005U; + sbv_output_1[0] = s48; + sbv_output_1[1] = s48; + sbv_output_1[2] = s48; + sbv_output_1[3] = s48; + sbv_output_1[4] = s48; + sbv_output_1[5] = s48; + sbv_output_1[6] = s48; + sbv_output_2[0] = s1; + sbv_output_2[1] = s2; + sbv_output_2[2] = s3; + sbv_output_2[3] = s4; + sbv_output_2[4] = s5; + sbv_output_2[5] = s6; + sbv_output_2[6] = s7; + sbv_output_2[7] = s8; + sbv_output_2[8] = s9; + sbv_output_2[9] = s10; + sbv_output_2[10] = s11; + sbv_output_2[11] = s12; + sbv_output_2[12] = s13; + sbv_output_2[13] = s14; + sbv_output_2[14] = s15; + sbv_output_2[15] = s16; + sbv_output_2[16] = s17; + sbv_output_2[17] = s18; + sbv_output_2[18] = s19; + sbv_output_2[19] = s20; + sbv_output_2[20] = s21; + sbv_output_2[21] = s22; + sbv_output_2[22] = s23; + sbv_output_2[23] = s24; + sbv_output_2[24] = s25; + sbv_output_2[25] = s26; + sbv_output_2[26] = s27; + sbv_output_2[27] = s28; + sbv_output_2[28] = s29; + sbv_output_2[29] = s30; + sbv_output_2[30] = s31; + sbv_output_2[31] = s32; + sbv_output_2[32] = s33; + sbv_output_2[33] = s34; + sbv_output_2[34] = s35; + sbv_output_2[35] = s36; + sbv_output_2[36] = s37; + sbv_output_2[37] = s38; + sbv_output_2[38] = s39; + sbv_output_2[39] = s40; + sbv_output_2[40] = s41; + sbv_output_2[41] = s42; + sbv_output_2[42] = s43; + sbv_output_2[43] = s44; + sbv_output_2[44] = s45; return s50; } == END: "foo.c" ================== diff --git a/SBVTestSuite/GoldFiles/crcUSB5_1.gold b/SBVTestSuite/GoldFiles/crcUSB5_1.gold --- a/SBVTestSuite/GoldFiles/crcUSB5_1.gold +++ b/SBVTestSuite/GoldFiles/crcUSB5_1.gold @@ -12,11 +12,11 @@ crcUSB5.o: crcUSB5.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ -crcUSB5_driver.o: crcUSB5_driver.c +crcUSB5_driver.o: crcUSB5_driver.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver: crcUSB5.o crcUSB5_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "crcUSB5.h" ================ /* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */ -#ifndef __crcUSB5__HEADER_INCLUDED__ -#define __crcUSB5__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_crcUSB5_HEADER_INCLUDED +#define SBV_GENERATED_crcUSB5_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord16 crcUSB5(const SWord16 msg); -#endif /* __crcUSB5__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_crcUSB5_HEADER_INCLUDED */ == END: "crcUSB5.h" ================== == BEGIN: "crcUSB5_driver.c" ================ /* Example driver program for crcUSB5. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord16 __result = crcUSB5(0xfedcU); + const SWord16 sbv_result = crcUSB5(0xfedcU); - printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result); + printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", sbv_result); return 0; } @@ -85,30 +93,128 @@ #include "crcUSB5.h" -SWord16 crcUSB5(const SWord16 msg) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_10_10_u1(SWord16 a) { - const SWord16 s0 = msg; - const SBool s1 = (SBool) ((s0 >> 10) & 1); + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 10)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_9_9_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 9)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_8_8_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_7_7_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 7)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_6_6_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 6)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_5_5_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 5)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_4_4_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 4)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_3_3_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 3)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_2_2_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 2)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_1_1_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 1)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_0_0_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + + +SWord16 crcUSB5(const SWord16 sbv_input_0) +{ + const SWord16 s0 = sbv_input_0; + const SBool s1 = sbv_bv_extract_u16_10_10_u1(s0); const SBool s3 = s1 != false; - const SBool s4 = (SBool) ((s0 >> 9) & 1); + const SBool s4 = sbv_bv_extract_u16_9_9_u1(s0); const SBool s5 = false != s4; - const SBool s6 = (SBool) ((s0 >> 8) & 1); + const SBool s6 = sbv_bv_extract_u16_8_8_u1(s0); const SBool s7 = false != s6; - const SBool s8 = (SBool) ((s0 >> 7) & 1); + const SBool s8 = sbv_bv_extract_u16_7_7_u1(s0); const SBool s9 = false != s8; - const SBool s10 = (SBool) ((s0 >> 6) & 1); + const SBool s10 = sbv_bv_extract_u16_6_6_u1(s0); const SBool s11 = false != s10; - const SBool s12 = (SBool) ((s0 >> 5) & 1); + const SBool s12 = sbv_bv_extract_u16_5_5_u1(s0); const SBool s13 = false != s12; - const SBool s14 = (SBool) ((s0 >> 4) & 1); + const SBool s14 = sbv_bv_extract_u16_4_4_u1(s0); const SBool s15 = false != s14; - const SBool s16 = (SBool) ((s0 >> 3) & 1); + const SBool s16 = sbv_bv_extract_u16_3_3_u1(s0); const SBool s17 = false != s16; - const SBool s18 = (SBool) ((s0 >> 2) & 1); + const SBool s18 = sbv_bv_extract_u16_2_2_u1(s0); const SBool s19 = false != s18; - const SBool s20 = (SBool) ((s0 >> 1) & 1); + const SBool s20 = sbv_bv_extract_u16_1_1_u1(s0); const SBool s21 = false != s20; - const SBool s22 = (SBool) (s0 & 1); + const SBool s22 = sbv_bv_extract_u16_0_0_u1(s0); const SBool s23 = false != s22; const SBool s24 = !s9; const SBool s25 = s3 ? s24 : s9; diff --git a/SBVTestSuite/GoldFiles/crcUSB5_2.gold b/SBVTestSuite/GoldFiles/crcUSB5_2.gold --- a/SBVTestSuite/GoldFiles/crcUSB5_2.gold +++ b/SBVTestSuite/GoldFiles/crcUSB5_2.gold @@ -12,11 +12,11 @@ crcUSB5.o: crcUSB5.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ -crcUSB5_driver.o: crcUSB5_driver.c +crcUSB5_driver.o: crcUSB5_driver.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver: crcUSB5.o crcUSB5_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "crcUSB5.h" ================ /* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */ -#ifndef __crcUSB5__HEADER_INCLUDED__ -#define __crcUSB5__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_crcUSB5_HEADER_INCLUDED +#define SBV_GENERATED_crcUSB5_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord16 crcUSB5(const SWord16 msg); -#endif /* __crcUSB5__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_crcUSB5_HEADER_INCLUDED */ == END: "crcUSB5.h" ================== == BEGIN: "crcUSB5_driver.c" ================ /* Example driver program for crcUSB5. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord16 __result = crcUSB5(0xfedcU); + const SWord16 sbv_result = crcUSB5(0xfedcU); - printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result); + printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", sbv_result); return 0; } @@ -85,55 +93,206 @@ #include "crcUSB5.h" -SWord16 crcUSB5(const SWord16 msg) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_u16_shl(SWord16 a, SWord16 amount) { - const SWord16 s0 = msg; - const SWord16 s2 = s0 << 5; - const SBool s3 = (SBool) ((s2 >> 15) & 1); + const uint64_t n = (uint64_t) (SWord16) amount; + const SWord16 result = n >= 16 ? (SWord16) 0 : (SWord16) ((uint64_t) (SWord16) a << n); + return result; +} + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_u16_lshr(SWord16 a, SWord16 amount) +{ + const uint64_t n = (uint64_t) (SWord16) amount; + return n >= 16 ? (SWord16) 0 : (SWord16) ((uint64_t) (SWord16) a >> n); +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_15_15_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 15)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_14_14_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 14)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_13_13_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 13)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_12_12_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 12)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_11_11_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 11)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_10_10_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 10)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_9_9_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 9)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_8_8_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_7_7_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 7)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_6_6_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 6)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_5_5_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 5)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_4_4_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 4)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_3_3_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 3)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_2_2_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 2)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_1_1_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 1)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u16_0_0_u1(SWord16 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + + +SWord16 crcUSB5(const SWord16 sbv_input_0) +{ + const SWord16 s0 = sbv_input_0; + const SWord16 s2 = sbv_bv_u16_shl(s0, 0x0005U); + const SBool s3 = sbv_bv_extract_u16_15_15_u1(s2); const SBool s5 = s3 != false; - const SBool s6 = (SBool) ((s2 >> 14) & 1); + const SBool s6 = sbv_bv_extract_u16_14_14_u1(s2); const SBool s7 = false != s6; - const SBool s8 = (SBool) ((s2 >> 13) & 1); + const SBool s8 = sbv_bv_extract_u16_13_13_u1(s2); const SBool s9 = false != s8; - const SBool s10 = (SBool) ((s2 >> 12) & 1); + const SBool s10 = sbv_bv_extract_u16_12_12_u1(s2); const SBool s11 = false != s10; const SBool s12 = !s11; const SBool s13 = s5 ? s12 : s11; - const SBool s14 = (SBool) ((s2 >> 11) & 1); + const SBool s14 = sbv_bv_extract_u16_11_11_u1(s2); const SBool s15 = false != s14; const SBool s16 = !s15; const SBool s17 = s7 ? s16 : s15; - const SBool s18 = (SBool) ((s2 >> 10) & 1); + const SBool s18 = sbv_bv_extract_u16_10_10_u1(s2); const SBool s19 = false != s18; const SBool s20 = !s19; const SBool s21 = s5 ? s20 : s19; const SBool s22 = !s21; const SBool s23 = s9 ? s22 : s21; - const SBool s24 = (SBool) ((s2 >> 9) & 1); + const SBool s24 = sbv_bv_extract_u16_9_9_u1(s2); const SBool s25 = false != s24; const SBool s26 = !s25; const SBool s27 = s7 ? s26 : s25; const SBool s28 = !s27; const SBool s29 = s13 ? s28 : s27; - const SBool s30 = (SBool) ((s2 >> 8) & 1); + const SBool s30 = sbv_bv_extract_u16_8_8_u1(s2); const SBool s31 = false != s30; const SBool s32 = !s31; const SBool s33 = s9 ? s32 : s31; const SBool s34 = !s33; const SBool s35 = s17 ? s34 : s33; - const SBool s36 = (SBool) ((s2 >> 7) & 1); + const SBool s36 = sbv_bv_extract_u16_7_7_u1(s2); const SBool s37 = false != s36; const SBool s38 = !s37; const SBool s39 = s13 ? s38 : s37; const SBool s40 = !s39; const SBool s41 = s23 ? s40 : s39; - const SBool s42 = (SBool) ((s2 >> 6) & 1); + const SBool s42 = sbv_bv_extract_u16_6_6_u1(s2); const SBool s43 = false != s42; const SBool s44 = !s43; const SBool s45 = s17 ? s44 : s43; const SBool s46 = !s45; const SBool s47 = s29 ? s46 : s45; - const SBool s48 = (SBool) ((s2 >> 5) & 1); + const SBool s48 = sbv_bv_extract_u16_5_5_u1(s2); const SBool s49 = false != s48; const SBool s50 = !s49; const SBool s51 = s23 ? s50 : s49; @@ -161,29 +320,29 @@ const SBool s73 = s47 ? s72 : s47; const SBool s74 = !s53; const SBool s75 = s53 ? s74 : s53; - const SBool s76 = (SBool) ((s2 >> 4) & 1); + const SBool s76 = sbv_bv_extract_u16_4_4_u1(s2); const SBool s77 = false != s76; const SBool s78 = !s77; const SBool s79 = s29 ? s78 : s77; const SBool s80 = !s79; const SBool s81 = s41 ? s80 : s79; - const SBool s82 = (SBool) ((s2 >> 3) & 1); + const SBool s82 = sbv_bv_extract_u16_3_3_u1(s2); const SBool s83 = false != s82; const SBool s84 = !s83; const SBool s85 = s35 ? s84 : s83; const SBool s86 = !s85; const SBool s87 = s47 ? s86 : s85; - const SBool s88 = (SBool) ((s2 >> 2) & 1); + const SBool s88 = sbv_bv_extract_u16_2_2_u1(s2); const SBool s89 = false != s88; const SBool s90 = !s89; const SBool s91 = s41 ? s90 : s89; const SBool s92 = !s91; const SBool s93 = s53 ? s92 : s91; - const SBool s94 = (SBool) ((s2 >> 1) & 1); + const SBool s94 = sbv_bv_extract_u16_1_1_u1(s2); const SBool s95 = false != s94; const SBool s96 = !s95; const SBool s97 = s47 ? s96 : s95; - const SBool s98 = (SBool) (s2 & 1); + const SBool s98 = sbv_bv_extract_u16_0_0_u1(s2); const SBool s99 = false != s98; const SBool s100 = !s99; const SBool s101 = s53 ? s100 : s99; diff --git a/SBVTestSuite/GoldFiles/doctest_sanity.gold b/SBVTestSuite/GoldFiles/doctest_sanity.gold --- a/SBVTestSuite/GoldFiles/doctest_sanity.gold +++ b/SBVTestSuite/GoldFiles/doctest_sanity.gold @@ -1,3 +1,3 @@ -Total: 1248; Tried: 1248; Skipped: 0; Success: 1248; Errors: 0; Failures 0 -Examples: 1093; Tried: 1093; Skipped: 0; Success: 1093; Errors: 0; Failures 0 +Total: 1268; Tried: 1268; Skipped: 0; Success: 1268; Errors: 0; Failures 0 +Examples: 1113; Tried: 1113; Skipped: 0; Success: 1113; Errors: 0; Failures 0 Setup: 155; Tried: 155; Skipped: 0; Success: 155; Errors: 0; Failures 0 diff --git a/SBVTestSuite/GoldFiles/fib1.gold b/SBVTestSuite/GoldFiles/fib1.gold --- a/SBVTestSuite/GoldFiles/fib1.gold +++ b/SBVTestSuite/GoldFiles/fib1.gold @@ -12,11 +12,11 @@ fib1.o: fib1.c fib1.h ${CC} ${CCFLAGS} -c $< -o $@ -fib1_driver.o: fib1_driver.c +fib1_driver.o: fib1_driver.c fib1.h ${CC} ${CCFLAGS} -c $< -o $@ fib1_driver: fib1.o fib1_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "fib1.h" ================ /* Header file for fib1. Automatically generated by SBV. Do not edit! */ -#ifndef __fib1__HEADER_INCLUDED__ -#define __fib1__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_fib1_HEADER_INCLUDED +#define SBV_GENERATED_fib1_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord64 fib1(const SWord64 n); -#endif /* __fib1__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_fib1_HEADER_INCLUDED */ == END: "fib1.h" ================== == BEGIN: "fib1_driver.c" ================ /* Example driver program for fib1. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord64 __result = fib1(0x000000000000000cULL); + const SWord64 sbv_result = fib1(0x000000000000000cULL); - printf("fib1(0x000000000000000cULL) = 0x%016"PRIx64"ULL\n", __result); + printf("fib1(0x000000000000000cULL) = 0x%016"PRIx64"ULL\n", sbv_result); return 0; } @@ -85,9 +93,9 @@ #include "fib1.h" -SWord64 fib1(const SWord64 n) +SWord64 fib1(const SWord64 sbv_input_0) { - const SWord64 s0 = n; + const SWord64 s0 = sbv_input_0; const SBool s2 = s0 == 0x0000000000000000ULL; const SBool s4 = s0 == 0x0000000000000001ULL; const SBool s6 = s0 == 0x0000000000000002ULL; diff --git a/SBVTestSuite/GoldFiles/fib2.gold b/SBVTestSuite/GoldFiles/fib2.gold --- a/SBVTestSuite/GoldFiles/fib2.gold +++ b/SBVTestSuite/GoldFiles/fib2.gold @@ -12,11 +12,11 @@ fib2.o: fib2.c fib2.h ${CC} ${CCFLAGS} -c $< -o $@ -fib2_driver.o: fib2_driver.c +fib2_driver.o: fib2_driver.c fib2.h ${CC} ${CCFLAGS} -c $< -o $@ fib2_driver: fib2.o fib2_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "fib2.h" ================ /* Header file for fib2. Automatically generated by SBV. Do not edit! */ -#ifndef __fib2__HEADER_INCLUDED__ -#define __fib2__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_fib2_HEADER_INCLUDED +#define SBV_GENERATED_fib2_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord64 fib2(const SWord64 n); -#endif /* __fib2__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_fib2_HEADER_INCLUDED */ == END: "fib2.h" ================== == BEGIN: "fib2_driver.c" ================ /* Example driver program for fib2. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord64 __result = fib2(0x0000000000000014ULL); + const SWord64 sbv_result = fib2(0x0000000000000014ULL); - printf("fib2(0x0000000000000014ULL) = 0x%016"PRIx64"ULL\n", __result); + printf("fib2(0x0000000000000014ULL) = 0x%016"PRIx64"ULL\n", sbv_result); return 0; } @@ -85,9 +93,10 @@ #include "fib2.h" -SWord64 fib2(const SWord64 n) +SWord64 fib2(const SWord64 sbv_input_0) { - const SWord64 s0 = n; + const SWord64 s0 = sbv_input_0; + SWord64 s65; static const SWord64 table0[] = { 0x0000000000000000ULL, 0x0000000000000001ULL, 0x0000000000000001ULL, 0x0000000000000002ULL, @@ -122,7 +131,7 @@ 0x000001686c8312d0ULL, 0x000002472d96a909ULL, 0x000003af9a19bbd9ULL, 0x000005f6c7b064e2ULL, 0x000009a661ca20bbULL }; - const SWord64 s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0]; + s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0]; return s65; } diff --git a/SBVTestSuite/GoldFiles/floats_cgen.gold b/SBVTestSuite/GoldFiles/floats_cgen.gold --- a/SBVTestSuite/GoldFiles/floats_cgen.gold +++ b/SBVTestSuite/GoldFiles/floats_cgen.gold @@ -2,2787 +2,5195 @@ /* File: "toFP_Int8_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" - -SFloat toFP_Int8_ToFloat(const SInt8 a) -{ - const SInt8 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Int8_ToFloat.c" ================== -== BEGIN: "toFP_Int16_ToFloat.c" ================ -/* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Int16_ToFloat(const SInt16 a) -{ - const SInt16 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Int16_ToFloat.c" ================== -== BEGIN: "toFP_Int32_ToFloat.c" ================ -/* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Int32_ToFloat(const SInt32 a) -{ - const SInt32 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Int32_ToFloat.c" ================== -== BEGIN: "toFP_Int64_ToFloat.c" ================ -/* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Int64_ToFloat(const SInt64 a) -{ - const SInt64 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Int64_ToFloat.c" ================== -== BEGIN: "toFP_Word8_ToFloat.c" ================ -/* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Word8_ToFloat(const SWord8 a) -{ - const SWord8 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Word8_ToFloat.c" ================== -== BEGIN: "toFP_Word16_ToFloat.c" ================ -/* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Word16_ToFloat(const SWord16 a) -{ - const SWord16 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Word16_ToFloat.c" ================== -== BEGIN: "toFP_Word32_ToFloat.c" ================ -/* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Word32_ToFloat(const SWord32 a) -{ - const SWord32 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Word32_ToFloat.c" ================== -== BEGIN: "toFP_Word64_ToFloat.c" ================ -/* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Word64_ToFloat(const SWord64 a) -{ - const SWord64 s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Word64_ToFloat.c" ================== -== BEGIN: "toFP_Float_ToFloat.c" ================ -/* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Float_ToFloat(const SFloat a) -{ - const SFloat s0 = a; - return s0; -} -== END: "toFP_Float_ToFloat.c" ================== -== BEGIN: "toFP_Double_ToFloat.c" ================ -/* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Double_ToFloat(const SDouble a) -{ - const SDouble s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Double_ToFloat.c" ================== -== BEGIN: "toFP_Integer_ToFloat.c" ================ -/* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Integer_ToFloat(const SInteger a) -{ - const SInteger s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Integer_ToFloat.c" ================== -== BEGIN: "toFP_Real_ToFloat.c" ================ -/* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat toFP_Real_ToFloat(const SReal a) -{ - const SReal s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "toFP_Real_ToFloat.c" ================== -== BEGIN: "toFP_Int8_ToDouble.c" ================ -/* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Int8_ToDouble(const SInt8 a) -{ - const SInt8 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Int8_ToDouble.c" ================== -== BEGIN: "toFP_Int16_ToDouble.c" ================ -/* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Int16_ToDouble(const SInt16 a) -{ - const SInt16 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Int16_ToDouble.c" ================== -== BEGIN: "toFP_Int32_ToDouble.c" ================ -/* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Int32_ToDouble(const SInt32 a) -{ - const SInt32 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Int32_ToDouble.c" ================== -== BEGIN: "toFP_Int64_ToDouble.c" ================ -/* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Int64_ToDouble(const SInt64 a) -{ - const SInt64 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Int64_ToDouble.c" ================== -== BEGIN: "toFP_Word8_ToDouble.c" ================ -/* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Word8_ToDouble(const SWord8 a) -{ - const SWord8 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Word8_ToDouble.c" ================== -== BEGIN: "toFP_Word16_ToDouble.c" ================ -/* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Word16_ToDouble(const SWord16 a) -{ - const SWord16 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Word16_ToDouble.c" ================== -== BEGIN: "toFP_Word32_ToDouble.c" ================ -/* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Word32_ToDouble(const SWord32 a) -{ - const SWord32 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Word32_ToDouble.c" ================== -== BEGIN: "toFP_Word64_ToDouble.c" ================ -/* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Word64_ToDouble(const SWord64 a) -{ - const SWord64 s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Word64_ToDouble.c" ================== -== BEGIN: "toFP_Float_ToDouble.c" ================ -/* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Float_ToDouble(const SFloat a) -{ - const SFloat s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Float_ToDouble.c" ================== -== BEGIN: "toFP_Double_ToDouble.c" ================ -/* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Double_ToDouble(const SDouble a) -{ - const SDouble s0 = a; - return s0; -} -== END: "toFP_Double_ToDouble.c" ================== -== BEGIN: "toFP_Integer_ToDouble.c" ================ -/* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Integer_ToDouble(const SInteger a) -{ - const SInteger s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Integer_ToDouble.c" ================== -== BEGIN: "toFP_Real_ToDouble.c" ================ -/* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble toFP_Real_ToDouble(const SReal a) -{ - const SReal s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "toFP_Real_ToDouble.c" ================== -== BEGIN: "fromFP_Float_ToInt8.c" ================ -/* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt8 fromFP_Float_ToInt8(const SFloat a) -{ - const SFloat s0 = a; - const SInt8 s2 = (SInt8) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToInt8.c" ================== -== BEGIN: "fromFP_Float_ToInt16.c" ================ -/* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt16 fromFP_Float_ToInt16(const SFloat a) -{ - const SFloat s0 = a; - const SInt16 s2 = (SInt16) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToInt16.c" ================== -== BEGIN: "fromFP_Float_ToInt32.c" ================ -/* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt32 fromFP_Float_ToInt32(const SFloat a) -{ - const SFloat s0 = a; - const SInt32 s2 = (SInt32) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToInt32.c" ================== -== BEGIN: "fromFP_Float_ToInt64.c" ================ -/* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt64 fromFP_Float_ToInt64(const SFloat a) -{ - const SFloat s0 = a; - const SInt64 s2 = (SInt64) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToInt64.c" ================== -== BEGIN: "fromFP_Float_ToWord8.c" ================ -/* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord8 fromFP_Float_ToWord8(const SFloat a) -{ - const SFloat s0 = a; - const SWord8 s2 = (SWord8) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToWord8.c" ================== -== BEGIN: "fromFP_Float_ToWord16.c" ================ -/* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord16 fromFP_Float_ToWord16(const SFloat a) -{ - const SFloat s0 = a; - const SWord16 s2 = (SWord16) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToWord16.c" ================== -== BEGIN: "fromFP_Float_ToWord32.c" ================ -/* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord32 fromFP_Float_ToWord32(const SFloat a) -{ - const SFloat s0 = a; - const SWord32 s2 = (SWord32) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToWord32.c" ================== -== BEGIN: "fromFP_Float_ToWord64.c" ================ -/* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord64 fromFP_Float_ToWord64(const SFloat a) -{ - const SFloat s0 = a; - const SWord64 s2 = (SWord64) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToWord64.c" ================== -== BEGIN: "fromFP_Float_ToFloat.c" ================ -/* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat fromFP_Float_ToFloat(const SFloat a) -{ - const SFloat s0 = a; - return s0; -} -== END: "fromFP_Float_ToFloat.c" ================== -== BEGIN: "fromFP_Float_ToDouble.c" ================ -/* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble fromFP_Float_ToDouble(const SFloat a) -{ - const SFloat s0 = a; - const SDouble s2 = (SDouble) s0; - - return s2; -} -== END: "fromFP_Float_ToDouble.c" ================== -== BEGIN: "fromFP_Float_ToInteger.c" ================ -/* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInteger fromFP_Float_ToInteger(const SFloat a) -{ - const SFloat s0 = a; - const SInteger s2 = (SInteger) rintf(s0); - - return s2; -} -== END: "fromFP_Float_ToInteger.c" ================== -== BEGIN: "fromFP_Float_ToReal.c" ================ -/* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SReal fromFP_Float_ToReal(const SFloat a) -{ - const SFloat s0 = a; - const SReal s2 = (SReal) s0; - - return s2; -} -== END: "fromFP_Float_ToReal.c" ================== -== BEGIN: "fromFP_DoubleTo_Int8.c" ================ -/* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt8 fromFP_DoubleTo_Int8(const SDouble a) -{ - const SDouble s0 = a; - const SInt8 s2 = (SInt8) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Int8.c" ================== -== BEGIN: "fromFP_DoubleTo_Int16.c" ================ -/* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt16 fromFP_DoubleTo_Int16(const SDouble a) -{ - const SDouble s0 = a; - const SInt16 s2 = (SInt16) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Int16.c" ================== -== BEGIN: "fromFP_DoubleTo_Int32.c" ================ -/* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt32 fromFP_DoubleTo_Int32(const SDouble a) -{ - const SDouble s0 = a; - const SInt32 s2 = (SInt32) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Int32.c" ================== -== BEGIN: "fromFP_DoubleTo_Int64.c" ================ -/* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInt64 fromFP_DoubleTo_Int64(const SDouble a) -{ - const SDouble s0 = a; - const SInt64 s2 = (SInt64) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Int64.c" ================== -== BEGIN: "fromFP_DoubleTo_Word8.c" ================ -/* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord8 fromFP_DoubleTo_Word8(const SDouble a) -{ - const SDouble s0 = a; - const SWord8 s2 = (SWord8) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Word8.c" ================== -== BEGIN: "fromFP_DoubleTo_Word16.c" ================ -/* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord16 fromFP_DoubleTo_Word16(const SDouble a) -{ - const SDouble s0 = a; - const SWord16 s2 = (SWord16) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Word16.c" ================== -== BEGIN: "fromFP_DoubleTo_Word32.c" ================ -/* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord32 fromFP_DoubleTo_Word32(const SDouble a) -{ - const SDouble s0 = a; - const SWord32 s2 = (SWord32) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Word32.c" ================== -== BEGIN: "fromFP_DoubleTo_Word64.c" ================ -/* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord64 fromFP_DoubleTo_Word64(const SDouble a) -{ - const SDouble s0 = a; - const SWord64 s2 = (SWord64) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Word64.c" ================== -== BEGIN: "fromFP_DoubleTo_Float.c" ================ -/* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat fromFP_DoubleTo_Float(const SDouble a) -{ - const SDouble s0 = a; - const SFloat s2 = (SFloat) s0; - - return s2; -} -== END: "fromFP_DoubleTo_Float.c" ================== -== BEGIN: "fromFP_DoubleTo_Double.c" ================ -/* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble fromFP_DoubleTo_Double(const SDouble a) -{ - const SDouble s0 = a; - return s0; -} -== END: "fromFP_DoubleTo_Double.c" ================== -== BEGIN: "fromFP_DoubleTo_Integer.c" ================ -/* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SInteger fromFP_DoubleTo_Integer(const SDouble a) -{ - const SDouble s0 = a; - const SInteger s2 = (SInteger) rint(s0); - - return s2; -} -== END: "fromFP_DoubleTo_Integer.c" ================== -== BEGIN: "fromFP_DoubleTo_Real.c" ================ -/* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SReal fromFP_DoubleTo_Real(const SDouble a) -{ - const SDouble s0 = a; - const SReal s2 = (SReal) s0; - - return s2; -} -== END: "fromFP_DoubleTo_Real.c" ================== -== BEGIN: "fromFP_SWord32_SFloat.c" ================ -/* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat fromFP_SWord32_SFloat(const SWord32 a) -{ - const SWord32 s0 = a; - SFloat s1; memcpy(&s1, &s0, sizeof(SFloat)); - - return s1; -} -== END: "fromFP_SWord32_SFloat.c" ================== -== BEGIN: "fromFP_SWord64_SDouble.c" ================ -/* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble fromFP_SWord64_SDouble(const SWord64 a) -{ - const SWord64 s0 = a; - SDouble s1; memcpy(&s1, &s0, sizeof(SDouble)); - - return s1; -} -== END: "fromFP_SWord64_SDouble.c" ================== -== BEGIN: "fromFP_SFloat_SWord32.c" ================ -/* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord32 fromFP_SFloat_SWord32(const SFloat a) -{ - const SFloat s0 = a; - SWord32 s1; memcpy(&s1, &s0, sizeof(SWord32)); - - return s1; -} -== END: "fromFP_SFloat_SWord32.c" ================== -== BEGIN: "fromFP_SDouble_SWord64.c" ================ -/* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SWord64 fromFP_SDouble_SWord64(const SDouble a) -{ - const SDouble s0 = a; - SWord64 s1; memcpy(&s1, &s0, sizeof(SWord64)); - - return s1; -} -== END: "fromFP_SDouble_SWord64.c" ================== -== BEGIN: "f_FP_Abs.c" ================ -/* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Abs(const SFloat a) -{ - const SFloat s0 = a; - const SFloat s1 = fabsf(s0); - - return s1; -} -== END: "f_FP_Abs.c" ================== -== BEGIN: "d_FP_Abs.c" ================ -/* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Abs(const SDouble a) -{ - const SDouble s0 = a; - const SDouble s1 = fabs(s0); - - return s1; -} -== END: "d_FP_Abs.c" ================== -== BEGIN: "f_FP_Neg.c" ================ -/* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Neg(const SFloat a) -{ - const SFloat s0 = a; - const SFloat s1 = (- s0); - - return s1; -} -== END: "f_FP_Neg.c" ================== -== BEGIN: "d_FP_Neg.c" ================ -/* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Neg(const SDouble a) -{ - const SDouble s0 = a; - const SDouble s1 = (- s0); - - return s1; -} -== END: "d_FP_Neg.c" ================== -== BEGIN: "f_FP_Add.c" ================ -/* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Add(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s3 = s0 + s1; - - return s3; -} -== END: "f_FP_Add.c" ================== -== BEGIN: "d_FP_Add.c" ================ -/* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Add(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s3 = s0 + s1; - - return s3; -} -== END: "d_FP_Add.c" ================== -== BEGIN: "f_FP_Sub.c" ================ -/* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Sub(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s3 = s0 - s1; - - return s3; -} -== END: "f_FP_Sub.c" ================== -== BEGIN: "d_FP_Sub.c" ================ -/* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Sub(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s3 = s0 - s1; - - return s3; -} -== END: "d_FP_Sub.c" ================== -== BEGIN: "f_FP_Mul.c" ================ -/* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Mul(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s3 = s0 * s1; - - return s3; -} -== END: "f_FP_Mul.c" ================== -== BEGIN: "d_FP_Mul.c" ================ -/* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Mul(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s3 = s0 * s1; - - return s3; -} -== END: "d_FP_Mul.c" ================== -== BEGIN: "f_FP_Div.c" ================ -/* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Div(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s3 = s0 / s1; - - return s3; -} -== END: "f_FP_Div.c" ================== -== BEGIN: "d_FP_Div.c" ================ -/* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Div(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s3 = s0 / s1; - - return s3; -} -== END: "d_FP_Div.c" ================== -== BEGIN: "f_FP_FMA.c" ================ -/* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s2 = c; - const SFloat s4 = fmaf(s0, s1, s2); - - return s4; -} -== END: "f_FP_FMA.c" ================== -== BEGIN: "d_FP_FMA.c" ================ -/* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_FMA(const SDouble a, const SDouble b, const SDouble c) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s2 = c; - const SDouble s4 = fma(s0, s1, s2); - - return s4; -} -== END: "d_FP_FMA.c" ================== -== BEGIN: "f_FP_Sqrt.c" ================ -/* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Sqrt(const SFloat a) -{ - const SFloat s0 = a; - const SFloat s2 = sqrtf(s0); - - return s2; -} -== END: "f_FP_Sqrt.c" ================== -== BEGIN: "d_FP_Sqrt.c" ================ -/* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Sqrt(const SDouble a) -{ - const SDouble s0 = a; - const SDouble s2 = sqrt(s0); - - return s2; -} -== END: "d_FP_Sqrt.c" ================== -== BEGIN: "f_FP_Rem.c" ================ -/* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Rem(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s2 = fmodf(s0, s1); - - return s2; -} -== END: "f_FP_Rem.c" ================== -== BEGIN: "d_FP_Rem.c" ================ -/* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Rem(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s2 = fmod(s0, s1); - - return s2; -} -== END: "d_FP_Rem.c" ================== -== BEGIN: "f_FP_RoundToIntegral.c" ================ -/* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_RoundToIntegral(const SFloat a) -{ - const SFloat s0 = a; - const SFloat s2 = rintf(s0); - - return s2; -} -== END: "f_FP_RoundToIntegral.c" ================== -== BEGIN: "d_FP_RoundToIntegral.c" ================ -/* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_RoundToIntegral(const SDouble a) -{ - const SDouble s0 = a; - const SDouble s2 = rint(s0); - - return s2; -} -== END: "d_FP_RoundToIntegral.c" ================== -== BEGIN: "f_FP_Min.c" ================ -/* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Min(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0F /* 0.0F */ : fminf(s0, - s1); - - return s2; -} -== END: "f_FP_Min.c" ================== -== BEGIN: "d_FP_Min.c" ================ -/* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Min(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0 /* 0.0 */ : fmin(s0, - s1); - - return s2; -} -== END: "d_FP_Min.c" ================== -== BEGIN: "f_FP_Max.c" ================ -/* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SFloat f_FP_Max(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0F /* 0.0F */ : fmaxf(s0, - s1); - - return s2; -} -== END: "f_FP_Max.c" ================== -== BEGIN: "d_FP_Max.c" ================ -/* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SDouble d_FP_Max(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0 /* 0.0 */ : fmax(s0, - s1); - - return s2; -} -== END: "d_FP_Max.c" ================== -== BEGIN: "f_FP_IsEqualObject.c" ================ -/* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsEqualObject(const SFloat a, const SFloat b) -{ - const SFloat s0 = a; - const SFloat s1 = b; - const SBool s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); - - return s2; -} -== END: "f_FP_IsEqualObject.c" ================== -== BEGIN: "d_FP_IsEqualObject.c" ================ -/* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsEqualObject(const SDouble a, const SDouble b) -{ - const SDouble s0 = a; - const SDouble s1 = b; - const SBool s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); - - return s2; -} -== END: "d_FP_IsEqualObject.c" ================== -== BEGIN: "f_FP_IsNormal.c" ================ -/* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsNormal(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = isnormal(s0); - - return s1; -} -== END: "f_FP_IsNormal.c" ================== -== BEGIN: "d_FP_IsNormal.c" ================ -/* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsNormal(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = isnormal(s0); - - return s1; -} -== END: "d_FP_IsNormal.c" ================== -== BEGIN: "f_FP_IsZero.c" ================ -/* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsZero(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = FP_ZERO == fpclassify(s0); - - return s1; -} -== END: "f_FP_IsZero.c" ================== -== BEGIN: "d_FP_IsZero.c" ================ -/* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsZero(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = FP_ZERO == fpclassify(s0); - - return s1; -} -== END: "d_FP_IsZero.c" ================== -== BEGIN: "f_FP_IsSubnormal.c" ================ -/* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsSubnormal(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = FP_SUBNORMAL == fpclassify(s0); - - return s1; -} -== END: "f_FP_IsSubnormal.c" ================== -== BEGIN: "d_FP_IsSubnormal.c" ================ -/* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsSubnormal(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = FP_SUBNORMAL == fpclassify(s0); - - return s1; -} -== END: "d_FP_IsSubnormal.c" ================== -== BEGIN: "f_FP_IsInfinite.c" ================ -/* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsInfinite(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = isinf(s0); - - return s1; -} -== END: "f_FP_IsInfinite.c" ================== -== BEGIN: "d_FP_IsInfinite.c" ================ -/* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsInfinite(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = isinf(s0); - - return s1; -} -== END: "d_FP_IsInfinite.c" ================== -== BEGIN: "f_FP_IsNaN.c" ================ -/* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsNaN(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = isnan(s0); - - return s1; -} -== END: "f_FP_IsNaN.c" ================== -== BEGIN: "d_FP_IsNaN.c" ================ -/* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsNaN(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = isnan(s0); - - return s1; -} -== END: "d_FP_IsNaN.c" ================== -== BEGIN: "f_FP_IsNegative.c" ================ -/* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsNegative(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = !isnan(s0) && signbit(s0); - - return s1; -} -== END: "f_FP_IsNegative.c" ================== -== BEGIN: "d_FP_IsNegative.c" ================ -/* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsNegative(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = !isnan(s0) && signbit(s0); - - return s1; -} -== END: "d_FP_IsNegative.c" ================== -== BEGIN: "f_FP_IsPositive.c" ================ -/* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool f_FP_IsPositive(const SFloat a) -{ - const SFloat s0 = a; - const SBool s1 = !isnan(s0) && !signbit(s0); - - return s1; -} -== END: "f_FP_IsPositive.c" ================== -== BEGIN: "d_FP_IsPositive.c" ================ -/* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ - -#include "floatCodeGen.h" - -SBool d_FP_IsPositive(const SDouble a) -{ - const SDouble s0 = a; - const SBool s1 = !isnan(s0) && !signbit(s0); - - return s1; -} -== END: "d_FP_IsPositive.c" ================== -== BEGIN: "floatCodeGen.h" ================ -/* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */ - -#ifndef __floatCodeGen__HEADER_INCLUDED__ -#define __floatCodeGen__HEADER_INCLUDED__ - -#include -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* User requested mapping for SInteger. */ -/* NB. Loss of precision: Target type is subject to modular arithmetic. */ -typedef SInt64 SInteger; - -/* User requested mapping for SReal. */ -/* NB. Loss of precision: Target type is subject to rounding. */ -typedef long double SReal; - -/* Entry point prototypes: */ -SFloat toFP_Int8_ToFloat(const SInt8 a); -SFloat toFP_Int16_ToFloat(const SInt16 a); -SFloat toFP_Int32_ToFloat(const SInt32 a); -SFloat toFP_Int64_ToFloat(const SInt64 a); -SFloat toFP_Word8_ToFloat(const SWord8 a); -SFloat toFP_Word16_ToFloat(const SWord16 a); -SFloat toFP_Word32_ToFloat(const SWord32 a); -SFloat toFP_Word64_ToFloat(const SWord64 a); -SFloat toFP_Float_ToFloat(const SFloat a); -SFloat toFP_Double_ToFloat(const SDouble a); -SFloat toFP_Integer_ToFloat(const SInteger a); -SFloat toFP_Real_ToFloat(const SReal a); -SDouble toFP_Int8_ToDouble(const SInt8 a); -SDouble toFP_Int16_ToDouble(const SInt16 a); -SDouble toFP_Int32_ToDouble(const SInt32 a); -SDouble toFP_Int64_ToDouble(const SInt64 a); -SDouble toFP_Word8_ToDouble(const SWord8 a); -SDouble toFP_Word16_ToDouble(const SWord16 a); -SDouble toFP_Word32_ToDouble(const SWord32 a); -SDouble toFP_Word64_ToDouble(const SWord64 a); -SDouble toFP_Float_ToDouble(const SFloat a); -SDouble toFP_Double_ToDouble(const SDouble a); -SDouble toFP_Integer_ToDouble(const SInteger a); -SDouble toFP_Real_ToDouble(const SReal a); -SInt8 fromFP_Float_ToInt8(const SFloat a); -SInt16 fromFP_Float_ToInt16(const SFloat a); -SInt32 fromFP_Float_ToInt32(const SFloat a); -SInt64 fromFP_Float_ToInt64(const SFloat a); -SWord8 fromFP_Float_ToWord8(const SFloat a); -SWord16 fromFP_Float_ToWord16(const SFloat a); -SWord32 fromFP_Float_ToWord32(const SFloat a); -SWord64 fromFP_Float_ToWord64(const SFloat a); -SFloat fromFP_Float_ToFloat(const SFloat a); -SDouble fromFP_Float_ToDouble(const SFloat a); -SInteger fromFP_Float_ToInteger(const SFloat a); -SReal fromFP_Float_ToReal(const SFloat a); -SInt8 fromFP_DoubleTo_Int8(const SDouble a); -SInt16 fromFP_DoubleTo_Int16(const SDouble a); -SInt32 fromFP_DoubleTo_Int32(const SDouble a); -SInt64 fromFP_DoubleTo_Int64(const SDouble a); -SWord8 fromFP_DoubleTo_Word8(const SDouble a); -SWord16 fromFP_DoubleTo_Word16(const SDouble a); -SWord32 fromFP_DoubleTo_Word32(const SDouble a); -SWord64 fromFP_DoubleTo_Word64(const SDouble a); -SFloat fromFP_DoubleTo_Float(const SDouble a); -SDouble fromFP_DoubleTo_Double(const SDouble a); -SInteger fromFP_DoubleTo_Integer(const SDouble a); -SReal fromFP_DoubleTo_Real(const SDouble a); -SFloat fromFP_SWord32_SFloat(const SWord32 a); -SDouble fromFP_SWord64_SDouble(const SWord64 a); -SWord32 fromFP_SFloat_SWord32(const SFloat a); -SWord64 fromFP_SDouble_SWord64(const SDouble a); -SFloat f_FP_Abs(const SFloat a); -SDouble d_FP_Abs(const SDouble a); -SFloat f_FP_Neg(const SFloat a); -SDouble d_FP_Neg(const SDouble a); -SFloat f_FP_Add(const SFloat a, const SFloat b); -SDouble d_FP_Add(const SDouble a, const SDouble b); -SFloat f_FP_Sub(const SFloat a, const SFloat b); -SDouble d_FP_Sub(const SDouble a, const SDouble b); -SFloat f_FP_Mul(const SFloat a, const SFloat b); -SDouble d_FP_Mul(const SDouble a, const SDouble b); -SFloat f_FP_Div(const SFloat a, const SFloat b); -SDouble d_FP_Div(const SDouble a, const SDouble b); -SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c); -SDouble d_FP_FMA(const SDouble a, const SDouble b, - const SDouble c); -SFloat f_FP_Sqrt(const SFloat a); -SDouble d_FP_Sqrt(const SDouble a); -SFloat f_FP_Rem(const SFloat a, const SFloat b); -SDouble d_FP_Rem(const SDouble a, const SDouble b); -SFloat f_FP_RoundToIntegral(const SFloat a); -SDouble d_FP_RoundToIntegral(const SDouble a); -SFloat f_FP_Min(const SFloat a, const SFloat b); -SDouble d_FP_Min(const SDouble a, const SDouble b); -SFloat f_FP_Max(const SFloat a, const SFloat b); -SDouble d_FP_Max(const SDouble a, const SDouble b); -SBool f_FP_IsEqualObject(const SFloat a, const SFloat b); -SBool d_FP_IsEqualObject(const SDouble a, const SDouble b); -SBool f_FP_IsNormal(const SFloat a); -SBool d_FP_IsNormal(const SDouble a); -SBool f_FP_IsZero(const SFloat a); -SBool d_FP_IsZero(const SDouble a); -SBool f_FP_IsSubnormal(const SFloat a); -SBool d_FP_IsSubnormal(const SDouble a); -SBool f_FP_IsInfinite(const SFloat a); -SBool d_FP_IsInfinite(const SDouble a); -SBool f_FP_IsNaN(const SFloat a); -SBool d_FP_IsNaN(const SDouble a); -SBool f_FP_IsNegative(const SFloat a); -SBool d_FP_IsNegative(const SDouble a); -SBool f_FP_IsPositive(const SFloat a); -SBool d_FP_IsPositive(const SDouble a); - -#endif /* __floatCodeGen__HEADER_INCLUDED__ */ -== END: "floatCodeGen.h" ================== -== BEGIN: "floatCodeGen_driver.c" ================ -/* Example driver program for floatCodeGen. */ -/* Automatically generated by SBV. Edit as you see fit! */ - -#include -#include "floatCodeGen.h" - -void toFP_Int8_ToFloat_driver(void) -{ - const SFloat __result = toFP_Int8_ToFloat(42); - - printf("toFP_Int8_ToFloat(42) = %a\n", __result); -} - -void toFP_Int16_ToFloat_driver(void) -{ - const SFloat __result = toFP_Int16_ToFloat(0x002a); - - printf("toFP_Int16_ToFloat(0x002a) = %a\n", __result); -} - -void toFP_Int32_ToFloat_driver(void) -{ - const SFloat __result = toFP_Int32_ToFloat(0x0000002aL); - - printf("toFP_Int32_ToFloat(0x0000002aL) = %a\n", __result); -} - -void toFP_Int64_ToFloat_driver(void) -{ - const SFloat __result = toFP_Int64_ToFloat(0x000000000000002aLL); - - printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %a\n", __result); -} - -void toFP_Word8_ToFloat_driver(void) -{ - const SFloat __result = toFP_Word8_ToFloat(42); - - printf("toFP_Word8_ToFloat(42) = %a\n", __result); -} - -void toFP_Word16_ToFloat_driver(void) -{ - const SFloat __result = toFP_Word16_ToFloat(0x002aU); - - printf("toFP_Word16_ToFloat(0x002aU) = %a\n", __result); -} - -void toFP_Word32_ToFloat_driver(void) -{ - const SFloat __result = toFP_Word32_ToFloat(0x0000002aUL); - - printf("toFP_Word32_ToFloat(0x0000002aUL) = %a\n", __result); -} - -void toFP_Word64_ToFloat_driver(void) -{ - const SFloat __result = toFP_Word64_ToFloat(0x000000000000002aULL); - - printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %a\n", __result); -} - -void toFP_Float_ToFloat_driver(void) -{ - const SFloat __result = toFP_Float_ToFloat(0x1.5p5F /* 42.0F */); - - printf("toFP_Float_ToFloat(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void toFP_Double_ToFloat_driver(void) -{ - const SFloat __result = toFP_Double_ToFloat(0x1.5p5 /* 42.0 */); - - printf("toFP_Double_ToFloat(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void toFP_Integer_ToFloat_driver(void) -{ - const SFloat __result = toFP_Integer_ToFloat(0x000000000000002aLL); - - printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %a\n", __result); -} - -void toFP_Real_ToFloat_driver(void) -{ - const SFloat __result = toFP_Real_ToFloat(42.0L); - - printf("toFP_Real_ToFloat(42.0L) = %a\n", __result); -} - -void toFP_Int8_ToDouble_driver(void) -{ - const SDouble __result = toFP_Int8_ToDouble(42); - - printf("toFP_Int8_ToDouble(42) = %a\n", __result); -} - -void toFP_Int16_ToDouble_driver(void) -{ - const SDouble __result = toFP_Int16_ToDouble(0x002a); - - printf("toFP_Int16_ToDouble(0x002a) = %a\n", __result); -} - -void toFP_Int32_ToDouble_driver(void) -{ - const SDouble __result = toFP_Int32_ToDouble(0x0000002aL); - - printf("toFP_Int32_ToDouble(0x0000002aL) = %a\n", __result); -} - -void toFP_Int64_ToDouble_driver(void) -{ - const SDouble __result = toFP_Int64_ToDouble(0x000000000000002aLL); - - printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %a\n", __result); -} - -void toFP_Word8_ToDouble_driver(void) -{ - const SDouble __result = toFP_Word8_ToDouble(42); - - printf("toFP_Word8_ToDouble(42) = %a\n", __result); -} - -void toFP_Word16_ToDouble_driver(void) -{ - const SDouble __result = toFP_Word16_ToDouble(0x002aU); - - printf("toFP_Word16_ToDouble(0x002aU) = %a\n", __result); -} - -void toFP_Word32_ToDouble_driver(void) -{ - const SDouble __result = toFP_Word32_ToDouble(0x0000002aUL); - - printf("toFP_Word32_ToDouble(0x0000002aUL) = %a\n", __result); -} - -void toFP_Word64_ToDouble_driver(void) -{ - const SDouble __result = toFP_Word64_ToDouble(0x000000000000002aULL); - - printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %a\n", __result); -} - -void toFP_Float_ToDouble_driver(void) -{ - const SDouble __result = toFP_Float_ToDouble(0x1.5p5F /* 42.0F */); - - printf("toFP_Float_ToDouble(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void toFP_Double_ToDouble_driver(void) -{ - const SDouble __result = toFP_Double_ToDouble(0x1.5p5 /* 42.0 */); - - printf("toFP_Double_ToDouble(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void toFP_Integer_ToDouble_driver(void) -{ - const SDouble __result = toFP_Integer_ToDouble(0x000000000000002aLL); - - printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %a\n", __result); -} - -void toFP_Real_ToDouble_driver(void) -{ - const SDouble __result = toFP_Real_ToDouble(42.0L); - - printf("toFP_Real_ToDouble(42.0L) = %a\n", __result); -} - -void fromFP_Float_ToInt8_driver(void) -{ - const SInt8 __result = fromFP_Float_ToInt8(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToInt8(0x1.5p5F /* 42.0F */) = %"PRId8"\n", __result); -} - -void fromFP_Float_ToInt16_driver(void) -{ - const SInt16 __result = fromFP_Float_ToInt16(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToInt16(0x1.5p5F /* 42.0F */) = %"PRId16"\n", __result); -} - -void fromFP_Float_ToInt32_driver(void) -{ - const SInt32 __result = fromFP_Float_ToInt32(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToInt32(0x1.5p5F /* 42.0F */) = %"PRId32"L\n", __result); -} - -void fromFP_Float_ToInt64_driver(void) -{ - const SInt64 __result = fromFP_Float_ToInt64(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToInt64(0x1.5p5F /* 42.0F */) = %"PRId64"LL\n", __result); -} - -void fromFP_Float_ToWord8_driver(void) -{ - const SWord8 __result = fromFP_Float_ToWord8(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToWord8(0x1.5p5F /* 42.0F */) = %"PRIu8"\n", __result); -} - -void fromFP_Float_ToWord16_driver(void) -{ - const SWord16 __result = fromFP_Float_ToWord16(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToWord16(0x1.5p5F /* 42.0F */) = 0x%04"PRIx16"U\n", __result); -} - -void fromFP_Float_ToWord32_driver(void) -{ - const SWord32 __result = fromFP_Float_ToWord32(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToWord32(0x1.5p5F /* 42.0F */) = 0x%08"PRIx32"UL\n", __result); -} - -void fromFP_Float_ToWord64_driver(void) -{ - const SWord64 __result = fromFP_Float_ToWord64(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToWord64(0x1.5p5F /* 42.0F */) = 0x%016"PRIx64"ULL\n", __result); -} - -void fromFP_Float_ToFloat_driver(void) -{ - const SFloat __result = fromFP_Float_ToFloat(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToFloat(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void fromFP_Float_ToDouble_driver(void) -{ - const SDouble __result = fromFP_Float_ToDouble(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToDouble(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void fromFP_Float_ToInteger_driver(void) -{ - const SInteger __result = fromFP_Float_ToInteger(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToInteger(0x1.5p5F /* 42.0F */) = %"PRId64"LL\n", __result); -} - -void fromFP_Float_ToReal_driver(void) -{ - const SReal __result = fromFP_Float_ToReal(0x1.5p5F /* 42.0F */); - - printf("fromFP_Float_ToReal(0x1.5p5F /* 42.0F */) = %Lf\n", __result); -} - -void fromFP_DoubleTo_Int8_driver(void) -{ - const SInt8 __result = fromFP_DoubleTo_Int8(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Int8(0x1.5p5 /* 42.0 */) = %"PRId8"\n", __result); -} - -void fromFP_DoubleTo_Int16_driver(void) -{ - const SInt16 __result = fromFP_DoubleTo_Int16(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Int16(0x1.5p5 /* 42.0 */) = %"PRId16"\n", __result); -} - -void fromFP_DoubleTo_Int32_driver(void) -{ - const SInt32 __result = fromFP_DoubleTo_Int32(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Int32(0x1.5p5 /* 42.0 */) = %"PRId32"L\n", __result); -} - -void fromFP_DoubleTo_Int64_driver(void) -{ - const SInt64 __result = fromFP_DoubleTo_Int64(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Int64(0x1.5p5 /* 42.0 */) = %"PRId64"LL\n", __result); -} - -void fromFP_DoubleTo_Word8_driver(void) -{ - const SWord8 __result = fromFP_DoubleTo_Word8(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Word8(0x1.5p5 /* 42.0 */) = %"PRIu8"\n", __result); -} - -void fromFP_DoubleTo_Word16_driver(void) -{ - const SWord16 __result = fromFP_DoubleTo_Word16(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Word16(0x1.5p5 /* 42.0 */) = 0x%04"PRIx16"U\n", __result); -} - -void fromFP_DoubleTo_Word32_driver(void) -{ - const SWord32 __result = fromFP_DoubleTo_Word32(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Word32(0x1.5p5 /* 42.0 */) = 0x%08"PRIx32"UL\n", __result); -} - -void fromFP_DoubleTo_Word64_driver(void) -{ - const SWord64 __result = fromFP_DoubleTo_Word64(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Word64(0x1.5p5 /* 42.0 */) = 0x%016"PRIx64"ULL\n", __result); -} - -void fromFP_DoubleTo_Float_driver(void) -{ - const SFloat __result = fromFP_DoubleTo_Float(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Float(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void fromFP_DoubleTo_Double_driver(void) -{ - const SDouble __result = fromFP_DoubleTo_Double(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Double(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void fromFP_DoubleTo_Integer_driver(void) -{ - const SInteger __result = fromFP_DoubleTo_Integer(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Integer(0x1.5p5 /* 42.0 */) = %"PRId64"LL\n", __result); -} - -void fromFP_DoubleTo_Real_driver(void) -{ - const SReal __result = fromFP_DoubleTo_Real(0x1.5p5 /* 42.0 */); - - printf("fromFP_DoubleTo_Real(0x1.5p5 /* 42.0 */) = %Lf\n", __result); -} - -void fromFP_SWord32_SFloat_driver(void) -{ - const SFloat __result = fromFP_SWord32_SFloat(0x0000002aUL); - - printf("fromFP_SWord32_SFloat(0x0000002aUL) = %a\n", __result); -} - -void fromFP_SWord64_SDouble_driver(void) -{ - const SDouble __result = fromFP_SWord64_SDouble(0x000000000000002aULL); - - printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %a\n", __result); -} - -void fromFP_SFloat_SWord32_driver(void) -{ - const SWord32 __result = fromFP_SFloat_SWord32(0x1.5p5F /* 42.0F */); - - printf("fromFP_SFloat_SWord32(0x1.5p5F /* 42.0F */) = 0x%08"PRIx32"UL\n", __result); -} - -void fromFP_SDouble_SWord64_driver(void) -{ - const SWord64 __result = fromFP_SDouble_SWord64(0x1.5p5 /* 42.0 */); - - printf("fromFP_SDouble_SWord64(0x1.5p5 /* 42.0 */) = 0x%016"PRIx64"ULL\n", __result); -} - -void f_FP_Abs_driver(void) -{ - const SFloat __result = f_FP_Abs(0x1.5p5F /* 42.0F */); - - printf("f_FP_Abs(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void d_FP_Abs_driver(void) -{ - const SDouble __result = d_FP_Abs(0x1.5p5 /* 42.0 */); - - printf("d_FP_Abs(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void f_FP_Neg_driver(void) -{ - const SFloat __result = f_FP_Neg(0x1.5p5F /* 42.0F */); - - printf("f_FP_Neg(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void d_FP_Neg_driver(void) -{ - const SDouble __result = d_FP_Neg(0x1.5p5 /* 42.0 */); - - printf("d_FP_Neg(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void f_FP_Add_driver(void) -{ - const SFloat __result = f_FP_Add(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Add(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Add_driver(void) -{ - const SDouble __result = d_FP_Add(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Add(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_Sub_driver(void) -{ - const SFloat __result = f_FP_Sub(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Sub(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Sub_driver(void) -{ - const SDouble __result = d_FP_Sub(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Sub(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_Mul_driver(void) -{ - const SFloat __result = f_FP_Mul(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Mul(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Mul_driver(void) -{ - const SDouble __result = d_FP_Mul(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Mul(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_Div_driver(void) -{ - const SFloat __result = f_FP_Div(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Div(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Div_driver(void) -{ - const SDouble __result = d_FP_Div(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Div(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_FMA_driver(void) -{ - const SFloat __result = f_FP_FMA(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */, 0x1.6p5F /* 44.0F */); - - printf("f_FP_FMA(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */, 0x1.6p5F /* 44.0F */) = %a\n", __result); -} - -void d_FP_FMA_driver(void) -{ - const SDouble __result = d_FP_FMA(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */, 0x1.6p5 /* 44.0 */); - - printf("d_FP_FMA(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */, 0x1.6p5 /* 44.0 */) = %a\n", __result); -} - -void f_FP_Sqrt_driver(void) -{ - const SFloat __result = f_FP_Sqrt(0x1.5p5F /* 42.0F */); - - printf("f_FP_Sqrt(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void d_FP_Sqrt_driver(void) -{ - const SDouble __result = d_FP_Sqrt(0x1.5p5 /* 42.0 */); - - printf("d_FP_Sqrt(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void f_FP_Rem_driver(void) -{ - const SFloat __result = f_FP_Rem(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Rem(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Rem_driver(void) -{ - const SDouble __result = d_FP_Rem(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Rem(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_RoundToIntegral_driver(void) -{ - const SFloat __result = f_FP_RoundToIntegral(0x1.5p5F /* 42.0F */); - - printf("f_FP_RoundToIntegral(0x1.5p5F /* 42.0F */) = %a\n", __result); -} - -void d_FP_RoundToIntegral_driver(void) -{ - const SDouble __result = d_FP_RoundToIntegral(0x1.5p5 /* 42.0 */); - - printf("d_FP_RoundToIntegral(0x1.5p5 /* 42.0 */) = %a\n", __result); -} - -void f_FP_Min_driver(void) -{ - const SFloat __result = f_FP_Min(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Min(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Min_driver(void) -{ - const SDouble __result = d_FP_Min(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Min(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_Max_driver(void) -{ - const SFloat __result = f_FP_Max(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_Max(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", __result); -} - -void d_FP_Max_driver(void) -{ - const SDouble __result = d_FP_Max(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_Max(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", __result); -} - -void f_FP_IsEqualObject_driver(void) -{ - const SBool __result = f_FP_IsEqualObject(0x1.5p5F /* 42.0F */, - 0x1.58p5F /* 43.0F */); - - printf("f_FP_IsEqualObject(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %d\n", __result); -} - -void d_FP_IsEqualObject_driver(void) -{ - const SBool __result = d_FP_IsEqualObject(0x1.5p5 /* 42.0 */, - 0x1.58p5 /* 43.0 */); - - printf("d_FP_IsEqualObject(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %d\n", __result); -} - -void f_FP_IsNormal_driver(void) -{ - const SBool __result = f_FP_IsNormal(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsNormal(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsNormal_driver(void) -{ - const SBool __result = d_FP_IsNormal(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsNormal(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsZero_driver(void) -{ - const SBool __result = f_FP_IsZero(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsZero(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsZero_driver(void) -{ - const SBool __result = d_FP_IsZero(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsZero(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsSubnormal_driver(void) -{ - const SBool __result = f_FP_IsSubnormal(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsSubnormal(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsSubnormal_driver(void) -{ - const SBool __result = d_FP_IsSubnormal(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsSubnormal(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsInfinite_driver(void) -{ - const SBool __result = f_FP_IsInfinite(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsInfinite(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsInfinite_driver(void) -{ - const SBool __result = d_FP_IsInfinite(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsInfinite(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsNaN_driver(void) -{ - const SBool __result = f_FP_IsNaN(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsNaN(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsNaN_driver(void) -{ - const SBool __result = d_FP_IsNaN(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsNaN(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsNegative_driver(void) -{ - const SBool __result = f_FP_IsNegative(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsNegative(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsNegative_driver(void) -{ - const SBool __result = d_FP_IsNegative(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsNegative(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -void f_FP_IsPositive_driver(void) -{ - const SBool __result = f_FP_IsPositive(0x1.5p5F /* 42.0F */); - - printf("f_FP_IsPositive(0x1.5p5F /* 42.0F */) = %d\n", __result); -} - -void d_FP_IsPositive_driver(void) -{ - const SBool __result = d_FP_IsPositive(0x1.5p5 /* 42.0 */); - - printf("d_FP_IsPositive(0x1.5p5 /* 42.0 */) = %d\n", __result); -} - -int main(void) -{ - printf("====================================\n"); - printf("** Driver run for toFP_Int8_ToFloat:\n"); - printf("====================================\n"); - toFP_Int8_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Int16_ToFloat:\n"); - printf("=====================================\n"); - toFP_Int16_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Int32_ToFloat:\n"); - printf("=====================================\n"); - toFP_Int32_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Int64_ToFloat:\n"); - printf("=====================================\n"); - toFP_Int64_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Word8_ToFloat:\n"); - printf("=====================================\n"); - toFP_Word8_ToFloat_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Word16_ToFloat:\n"); - printf("======================================\n"); - toFP_Word16_ToFloat_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Word32_ToFloat:\n"); - printf("======================================\n"); - toFP_Word32_ToFloat_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Word64_ToFloat:\n"); - printf("======================================\n"); - toFP_Word64_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Float_ToFloat:\n"); - printf("=====================================\n"); - toFP_Float_ToFloat_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Double_ToFloat:\n"); - printf("======================================\n"); - toFP_Double_ToFloat_driver(); - - printf("=======================================\n"); - printf("** Driver run for toFP_Integer_ToFloat:\n"); - printf("=======================================\n"); - toFP_Integer_ToFloat_driver(); - - printf("====================================\n"); - printf("** Driver run for toFP_Real_ToFloat:\n"); - printf("====================================\n"); - toFP_Real_ToFloat_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Int8_ToDouble:\n"); - printf("=====================================\n"); - toFP_Int8_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Int16_ToDouble:\n"); - printf("======================================\n"); - toFP_Int16_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Int32_ToDouble:\n"); - printf("======================================\n"); - toFP_Int32_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Int64_ToDouble:\n"); - printf("======================================\n"); - toFP_Int64_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Word8_ToDouble:\n"); - printf("======================================\n"); - toFP_Word8_ToDouble_driver(); - - printf("=======================================\n"); - printf("** Driver run for toFP_Word16_ToDouble:\n"); - printf("=======================================\n"); - toFP_Word16_ToDouble_driver(); - - printf("=======================================\n"); - printf("** Driver run for toFP_Word32_ToDouble:\n"); - printf("=======================================\n"); - toFP_Word32_ToDouble_driver(); - - printf("=======================================\n"); - printf("** Driver run for toFP_Word64_ToDouble:\n"); - printf("=======================================\n"); - toFP_Word64_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for toFP_Float_ToDouble:\n"); - printf("======================================\n"); - toFP_Float_ToDouble_driver(); - - printf("=======================================\n"); - printf("** Driver run for toFP_Double_ToDouble:\n"); - printf("=======================================\n"); - toFP_Double_ToDouble_driver(); - - printf("========================================\n"); - printf("** Driver run for toFP_Integer_ToDouble:\n"); - printf("========================================\n"); - toFP_Integer_ToDouble_driver(); - - printf("=====================================\n"); - printf("** Driver run for toFP_Real_ToDouble:\n"); - printf("=====================================\n"); - toFP_Real_ToDouble_driver(); - - printf("======================================\n"); - printf("** Driver run for fromFP_Float_ToInt8:\n"); - printf("======================================\n"); - fromFP_Float_ToInt8_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_Float_ToInt16:\n"); - printf("=======================================\n"); - fromFP_Float_ToInt16_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_Float_ToInt32:\n"); - printf("=======================================\n"); - fromFP_Float_ToInt32_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_Float_ToInt64:\n"); - printf("=======================================\n"); - fromFP_Float_ToInt64_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_Float_ToWord8:\n"); - printf("=======================================\n"); - fromFP_Float_ToWord8_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_Float_ToWord16:\n"); - printf("========================================\n"); - fromFP_Float_ToWord16_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_Float_ToWord32:\n"); - printf("========================================\n"); - fromFP_Float_ToWord32_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_Float_ToWord64:\n"); - printf("========================================\n"); - fromFP_Float_ToWord64_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_Float_ToFloat:\n"); - printf("=======================================\n"); - fromFP_Float_ToFloat_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_Float_ToDouble:\n"); - printf("========================================\n"); - fromFP_Float_ToDouble_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_Float_ToInteger:\n"); - printf("=========================================\n"); - fromFP_Float_ToInteger_driver(); - - printf("======================================\n"); - printf("** Driver run for fromFP_Float_ToReal:\n"); - printf("======================================\n"); - fromFP_Float_ToReal_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_DoubleTo_Int8:\n"); - printf("=======================================\n"); - fromFP_DoubleTo_Int8_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Int16:\n"); - printf("========================================\n"); - fromFP_DoubleTo_Int16_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Int32:\n"); - printf("========================================\n"); - fromFP_DoubleTo_Int32_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Int64:\n"); - printf("========================================\n"); - fromFP_DoubleTo_Int64_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Word8:\n"); - printf("========================================\n"); - fromFP_DoubleTo_Word8_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Word16:\n"); - printf("=========================================\n"); - fromFP_DoubleTo_Word16_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Word32:\n"); - printf("=========================================\n"); - fromFP_DoubleTo_Word32_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Word64:\n"); - printf("=========================================\n"); - fromFP_DoubleTo_Word64_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Float:\n"); - printf("========================================\n"); - fromFP_DoubleTo_Float_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Double:\n"); - printf("=========================================\n"); - fromFP_DoubleTo_Double_driver(); - - printf("==========================================\n"); - printf("** Driver run for fromFP_DoubleTo_Integer:\n"); - printf("==========================================\n"); - fromFP_DoubleTo_Integer_driver(); - - printf("=======================================\n"); - printf("** Driver run for fromFP_DoubleTo_Real:\n"); - printf("=======================================\n"); - fromFP_DoubleTo_Real_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_SWord32_SFloat:\n"); - printf("========================================\n"); - fromFP_SWord32_SFloat_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_SWord64_SDouble:\n"); - printf("=========================================\n"); - fromFP_SWord64_SDouble_driver(); - - printf("========================================\n"); - printf("** Driver run for fromFP_SFloat_SWord32:\n"); - printf("========================================\n"); - fromFP_SFloat_SWord32_driver(); - - printf("=========================================\n"); - printf("** Driver run for fromFP_SDouble_SWord64:\n"); - printf("=========================================\n"); - fromFP_SDouble_SWord64_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Abs:\n"); - printf("===========================\n"); - f_FP_Abs_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Abs:\n"); - printf("===========================\n"); - d_FP_Abs_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Neg:\n"); - printf("===========================\n"); - f_FP_Neg_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Neg:\n"); - printf("===========================\n"); - d_FP_Neg_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Add:\n"); - printf("===========================\n"); - f_FP_Add_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Add:\n"); - printf("===========================\n"); - d_FP_Add_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Sub:\n"); - printf("===========================\n"); - f_FP_Sub_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Sub:\n"); - printf("===========================\n"); - d_FP_Sub_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Mul:\n"); - printf("===========================\n"); - f_FP_Mul_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Mul:\n"); - printf("===========================\n"); - d_FP_Mul_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Div:\n"); - printf("===========================\n"); - f_FP_Div_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Div:\n"); - printf("===========================\n"); - d_FP_Div_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_FMA:\n"); - printf("===========================\n"); - f_FP_FMA_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_FMA:\n"); - printf("===========================\n"); - d_FP_FMA_driver(); - - printf("============================\n"); - printf("** Driver run for f_FP_Sqrt:\n"); - printf("============================\n"); - f_FP_Sqrt_driver(); - - printf("============================\n"); - printf("** Driver run for d_FP_Sqrt:\n"); - printf("============================\n"); - d_FP_Sqrt_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Rem:\n"); - printf("===========================\n"); - f_FP_Rem_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Rem:\n"); - printf("===========================\n"); - d_FP_Rem_driver(); - - printf("=======================================\n"); - printf("** Driver run for f_FP_RoundToIntegral:\n"); - printf("=======================================\n"); - f_FP_RoundToIntegral_driver(); - - printf("=======================================\n"); - printf("** Driver run for d_FP_RoundToIntegral:\n"); - printf("=======================================\n"); - d_FP_RoundToIntegral_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Min:\n"); - printf("===========================\n"); - f_FP_Min_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Min:\n"); - printf("===========================\n"); - d_FP_Min_driver(); - - printf("===========================\n"); - printf("** Driver run for f_FP_Max:\n"); - printf("===========================\n"); - f_FP_Max_driver(); - - printf("===========================\n"); - printf("** Driver run for d_FP_Max:\n"); - printf("===========================\n"); - d_FP_Max_driver(); - - printf("=====================================\n"); - printf("** Driver run for f_FP_IsEqualObject:\n"); - printf("=====================================\n"); - f_FP_IsEqualObject_driver(); - - printf("=====================================\n"); - printf("** Driver run for d_FP_IsEqualObject:\n"); - printf("=====================================\n"); - d_FP_IsEqualObject_driver(); - - printf("================================\n"); - printf("** Driver run for f_FP_IsNormal:\n"); - printf("================================\n"); - f_FP_IsNormal_driver(); - - printf("================================\n"); - printf("** Driver run for d_FP_IsNormal:\n"); - printf("================================\n"); - d_FP_IsNormal_driver(); - - printf("==============================\n"); - printf("** Driver run for f_FP_IsZero:\n"); - printf("==============================\n"); - f_FP_IsZero_driver(); - - printf("==============================\n"); - printf("** Driver run for d_FP_IsZero:\n"); - printf("==============================\n"); - d_FP_IsZero_driver(); - - printf("===================================\n"); - printf("** Driver run for f_FP_IsSubnormal:\n"); - printf("===================================\n"); - f_FP_IsSubnormal_driver(); - - printf("===================================\n"); - printf("** Driver run for d_FP_IsSubnormal:\n"); - printf("===================================\n"); - d_FP_IsSubnormal_driver(); - - printf("==================================\n"); - printf("** Driver run for f_FP_IsInfinite:\n"); - printf("==================================\n"); - f_FP_IsInfinite_driver(); - - printf("==================================\n"); - printf("** Driver run for d_FP_IsInfinite:\n"); - printf("==================================\n"); - d_FP_IsInfinite_driver(); - - printf("=============================\n"); - printf("** Driver run for f_FP_IsNaN:\n"); - printf("=============================\n"); - f_FP_IsNaN_driver(); - - printf("=============================\n"); - printf("** Driver run for d_FP_IsNaN:\n"); - printf("=============================\n"); - d_FP_IsNaN_driver(); - - printf("==================================\n"); - printf("** Driver run for f_FP_IsNegative:\n"); - printf("==================================\n"); - f_FP_IsNegative_driver(); - - printf("==================================\n"); - printf("** Driver run for d_FP_IsNegative:\n"); - printf("==================================\n"); - d_FP_IsNegative_driver(); - - printf("==================================\n"); - printf("** Driver run for f_FP_IsPositive:\n"); - printf("==================================\n"); - f_FP_IsPositive_driver(); - - printf("==================================\n"); - printf("** Driver run for d_FP_IsPositive:\n"); - printf("==================================\n"); - d_FP_IsPositive_driver(); - - return 0; -} -== END: "floatCodeGen_driver.c" ================== -== BEGIN: "Makefile" ================ -# Makefile for floatCodeGen. Automatically generated by SBV. Do not edit! - -# include any user-defined .mk file in the current directory. --include *.mk - -CC?=gcc -CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer -LDFLAGS?=-lm -AR?=ar -ARFLAGS?=cr - -all: floatCodeGen.a floatCodeGen_driver - -floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o - ${AR} ${ARFLAGS} $@ $^ - -floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h - ${CC} ${CCFLAGS} $< -o $@ floatCodeGen.a ${LDFLAGS} - -toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Add.o: f_FP_Add.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Add.o: d_FP_Add.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Div.o: f_FP_Div.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Div.o: d_FP_Div.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Min.o: f_FP_Min.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Min.o: d_FP_Min.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_Max.o: f_FP_Max.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_Max.o: d_FP_Max.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h - ${CC} ${CCFLAGS} -c $< -o $@ - -clean: - rm -f *.o - -veryclean: clean - rm -f floatCodeGen.a floatCodeGen_driver +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat toFP_Int8_ToFloat(const SInt8 sbv_input_0) +{ + const SInt8 s0 = sbv_input_0; + SFloat s2; + s2 = (SFloat) s0; + + return s2; +} +== END: "toFP_Int8_ToFloat.c" ================== +== BEGIN: "toFP_Int16_ToFloat.c" ================ +/* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat toFP_Int16_ToFloat(const SInt16 sbv_input_0) +{ + const SInt16 s0 = sbv_input_0; + SFloat s2; + s2 = (SFloat) s0; + + return s2; +} +== END: "toFP_Int16_ToFloat.c" ================== +== BEGIN: "toFP_Int32_ToFloat.c" ================ +/* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_s32_float(SInt32 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = ((((uint64_t) a) >> (31)) & UINT64_C(1)) != 0; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 32; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0x00000000ffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 32 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Int32_ToFloat(const SInt32 sbv_input_0) +{ + const SInt32 s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_s32_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Int32_ToFloat.c" ================== +== BEGIN: "toFP_Int64_ToFloat.c" ================ +/* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_s64_float(SInt64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = ((((uint64_t) a) >> (63)) & UINT64_C(1)) != 0; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Int64_ToFloat(const SInt64 sbv_input_0) +{ + const SInt64 s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_s64_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Int64_ToFloat.c" ================== +== BEGIN: "toFP_Word8_ToFloat.c" ================ +/* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat toFP_Word8_ToFloat(const SWord8 sbv_input_0) +{ + const SWord8 s0 = sbv_input_0; + SFloat s2; + s2 = (SFloat) s0; + + return s2; +} +== END: "toFP_Word8_ToFloat.c" ================== +== BEGIN: "toFP_Word16_ToFloat.c" ================ +/* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat toFP_Word16_ToFloat(const SWord16 sbv_input_0) +{ + const SWord16 s0 = sbv_input_0; + SFloat s2; + s2 = (SFloat) s0; + + return s2; +} +== END: "toFP_Word16_ToFloat.c" ================== +== BEGIN: "toFP_Word32_ToFloat.c" ================ +/* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_u32_float(SWord32 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = false; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 32; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0x00000000ffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 32 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Word32_ToFloat(const SWord32 sbv_input_0) +{ + const SWord32 s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_u32_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Word32_ToFloat.c" ================== +== BEGIN: "toFP_Word64_ToFloat.c" ================ +/* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_u64_float(SWord64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = false; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Word64_ToFloat(const SWord64 sbv_input_0) +{ + const SWord64 s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_u64_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Word64_ToFloat.c" ================== +== BEGIN: "toFP_Float_ToFloat.c" ================ +/* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat toFP_Float_ToFloat(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + return s0; +} +== END: "toFP_Float_ToFloat.c" ================== +== BEGIN: "toFP_Double_ToFloat.c" ================ +/* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_double_float(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Double_ToFloat(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_double_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Double_ToFloat.c" ================== +== BEGIN: "toFP_Integer_ToFloat.c" ================ +/* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_integer_float(SInt64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = ((((uint64_t) a) >> (63)) & UINT64_C(1)) != 0; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Integer_ToFloat(const SInteger sbv_input_0) +{ + const SInteger s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_integer_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Integer_ToFloat.c" ================== +== BEGIN: "toFP_Real_ToFloat.c" ================ +/* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +#include +#if FLT_RADIX == 2 && LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 && LDBL_MIN_EXP == -1021 +#define SBV_LDBL_EXP_BITS 11 +#elif FLT_RADIX == 2 && (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 +#define SBV_LDBL_EXP_BITS 15 +#else +#error SBV C long-double conversions require binary64, x87 extended, or binary128 long double +#endif +#if BF_EXP_BITS_MAX < SBV_LDBL_EXP_BITS +#error SBV C long-double conversions exceed the LibBF exponent range +#endif + +static SBV_CGEN_UNUSED bf_flags_t sbv_bf_long_double_flags(bf_rnd_t rnd) +{ + return BF_FLAG_SUBNORMAL | bf_set_exp_bits(SBV_LDBL_EXP_BITS) | (bf_flags_t) rnd; +} + +static SBV_CGEN_UNUSED void sbv_bf_set_long_double(bf_t *result, long double value) +{ + int exponent, shift = 0, status = 0; bf_t chunk; + if (isnan(value)) { bf_set_nan(result); return; } + if (isinf(value)) { bf_set_inf(result, signbit(value) != 0); return; } + if (value == 0) { bf_set_zero(result, signbit(value) != 0); return; } + long double fraction = frexpl(fabsl(value), &exponent); + bf_init(result->ctx, &chunk); bf_set_zero(result, 0); + while (fraction != 0) { + fraction = ldexpl(fraction, 32); + const uint32_t bits = (uint32_t) fraction; fraction -= (long double) bits; + status |= bf_mul_2exp(result, 32, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + status |= bf_set_ui(&chunk, bits); + status |= bf_add(result, result, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); shift += 32; + } + status |= bf_mul_2exp(result, exponent - shift, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_delete(&chunk); if (status & BF_ST_MEM_ERROR) abort(); + if (signbit(value)) bf_neg(result); +} + +static SBV_CGEN_UNUSED long double sbv_bf_get_long_double(bf_t *value, bf_rnd_t rnd) +{ + if (bf_round(value, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)) & BF_ST_MEM_ERROR) abort(); + if (bf_is_nan(value)) return nanl(""); + if (!bf_is_finite(value)) return value->sign ? -HUGE_VALL : HUGE_VALL; + if (bf_is_zero(value)) return value->sign ? -0.0L : 0.0L; + long double significand = 0; + const slimb_t base = (slimb_t) value->len * LIMB_BITS; + for (int i = 0; i < LDBL_MANT_DIG; ++i) { + const slimb_t bit = base - 1 - i; + const unsigned digit = bit < 0 ? 0 : (unsigned) ((value->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1); + significand = significand * 2 + digit; + } + const long double result = ldexpl(significand, (int) value->expn - LDBL_MANT_DIG); + return value->sign ? -result : result; +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_real_float(SReal a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); sbv_bf_set_long_double(&x, a); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat toFP_Real_ToFloat(const SReal sbv_input_0) +{ + const SReal s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_real_float(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Real_ToFloat.c" ================== +== BEGIN: "toFP_Int8_ToDouble.c" ================ +/* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Int8_ToDouble(const SInt8 sbv_input_0) +{ + const SInt8 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Int8_ToDouble.c" ================== +== BEGIN: "toFP_Int16_ToDouble.c" ================ +/* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Int16_ToDouble(const SInt16 sbv_input_0) +{ + const SInt16 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Int16_ToDouble.c" ================== +== BEGIN: "toFP_Int32_ToDouble.c" ================ +/* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Int32_ToDouble(const SInt32 sbv_input_0) +{ + const SInt32 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Int32_ToDouble.c" ================== +== BEGIN: "toFP_Int64_ToDouble.c" ================ +/* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SDouble sbv_fp_cast_s64_double(SInt64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = ((((uint64_t) a) >> (63)) & UINT64_C(1)) != 0; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 53, BF_FLAG_SUBNORMAL | bf_set_exp_bits(11) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SDouble) result; +} + + +SDouble toFP_Int64_ToDouble(const SInt64 sbv_input_0) +{ + const SInt64 s0 = sbv_input_0; + SDouble s2; + s2 = sbv_fp_cast_s64_double(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Int64_ToDouble.c" ================== +== BEGIN: "toFP_Word8_ToDouble.c" ================ +/* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Word8_ToDouble(const SWord8 sbv_input_0) +{ + const SWord8 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Word8_ToDouble.c" ================== +== BEGIN: "toFP_Word16_ToDouble.c" ================ +/* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Word16_ToDouble(const SWord16 sbv_input_0) +{ + const SWord16 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Word16_ToDouble.c" ================== +== BEGIN: "toFP_Word32_ToDouble.c" ================ +/* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Word32_ToDouble(const SWord32 sbv_input_0) +{ + const SWord32 s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Word32_ToDouble.c" ================== +== BEGIN: "toFP_Word64_ToDouble.c" ================ +/* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SDouble sbv_fp_cast_u64_double(SWord64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = false; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 53, BF_FLAG_SUBNORMAL | bf_set_exp_bits(11) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SDouble) result; +} + + +SDouble toFP_Word64_ToDouble(const SWord64 sbv_input_0) +{ + const SWord64 s0 = sbv_input_0; + SDouble s2; + s2 = sbv_fp_cast_u64_double(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Word64_ToDouble.c" ================== +== BEGIN: "toFP_Float_ToDouble.c" ================ +/* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Float_ToDouble(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "toFP_Float_ToDouble.c" ================== +== BEGIN: "toFP_Double_ToDouble.c" ================ +/* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble toFP_Double_ToDouble(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + return s0; +} +== END: "toFP_Double_ToDouble.c" ================== +== BEGIN: "toFP_Integer_ToDouble.c" ================ +/* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SDouble sbv_fp_cast_integer_double(SInt64 a, bf_rnd_t rnd) +{ + uint64_t words[1]; uint64_t carry = 1; size_t i; limb_t j; + const bool negative = ((((uint64_t) a) >> (63)) & UINT64_C(1)) != 0; + bf_context_t ctx; bf_t x, chunk; double result; + for (i = 0; i < 1; ++i) { + words[i] = 0; + for (j = 0; j < 64 && i * 64 + j < 64; ++j) + if (((((uint64_t) a) >> ((i * 64 + j))) & UINT64_C(1)) != 0) words[i] |= UINT64_C(1) << j; + } + if (negative) for (i = 0; i < 1; ++i) { + const uint64_t next = ~words[i] + carry; carry = carry && next == 0; words[i] = next; + } + words[0] &= UINT64_C(0xffffffffffffffff); + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_init(&ctx, &chunk); bf_set_ui(&x, 0); + for (i = 1; i-- > 0;) { + bf_mul_2exp(&x, i == 0 ? 64 : 64, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_set_ui(&chunk, words[i]); bf_add(&x, &x, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + } + if (negative) bf_neg(&x); + bf_round(&x, 53, BF_FLAG_SUBNORMAL | bf_set_exp_bits(11) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&chunk); bf_delete(&x); bf_context_end(&ctx); return (SDouble) result; +} + + +SDouble toFP_Integer_ToDouble(const SInteger sbv_input_0) +{ + const SInteger s0 = sbv_input_0; + SDouble s2; + s2 = sbv_fp_cast_integer_double(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Integer_ToDouble.c" ================== +== BEGIN: "toFP_Real_ToDouble.c" ================ +/* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +#include +#if FLT_RADIX == 2 && LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 && LDBL_MIN_EXP == -1021 +#define SBV_LDBL_EXP_BITS 11 +#elif FLT_RADIX == 2 && (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 +#define SBV_LDBL_EXP_BITS 15 +#else +#error SBV C long-double conversions require binary64, x87 extended, or binary128 long double +#endif +#if BF_EXP_BITS_MAX < SBV_LDBL_EXP_BITS +#error SBV C long-double conversions exceed the LibBF exponent range +#endif + +static SBV_CGEN_UNUSED bf_flags_t sbv_bf_long_double_flags(bf_rnd_t rnd) +{ + return BF_FLAG_SUBNORMAL | bf_set_exp_bits(SBV_LDBL_EXP_BITS) | (bf_flags_t) rnd; +} + +static SBV_CGEN_UNUSED void sbv_bf_set_long_double(bf_t *result, long double value) +{ + int exponent, shift = 0, status = 0; bf_t chunk; + if (isnan(value)) { bf_set_nan(result); return; } + if (isinf(value)) { bf_set_inf(result, signbit(value) != 0); return; } + if (value == 0) { bf_set_zero(result, signbit(value) != 0); return; } + long double fraction = frexpl(fabsl(value), &exponent); + bf_init(result->ctx, &chunk); bf_set_zero(result, 0); + while (fraction != 0) { + fraction = ldexpl(fraction, 32); + const uint32_t bits = (uint32_t) fraction; fraction -= (long double) bits; + status |= bf_mul_2exp(result, 32, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + status |= bf_set_ui(&chunk, bits); + status |= bf_add(result, result, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); shift += 32; + } + status |= bf_mul_2exp(result, exponent - shift, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_delete(&chunk); if (status & BF_ST_MEM_ERROR) abort(); + if (signbit(value)) bf_neg(result); +} + +static SBV_CGEN_UNUSED long double sbv_bf_get_long_double(bf_t *value, bf_rnd_t rnd) +{ + if (bf_round(value, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)) & BF_ST_MEM_ERROR) abort(); + if (bf_is_nan(value)) return nanl(""); + if (!bf_is_finite(value)) return value->sign ? -HUGE_VALL : HUGE_VALL; + if (bf_is_zero(value)) return value->sign ? -0.0L : 0.0L; + long double significand = 0; + const slimb_t base = (slimb_t) value->len * LIMB_BITS; + for (int i = 0; i < LDBL_MANT_DIG; ++i) { + const slimb_t bit = base - 1 - i; + const unsigned digit = bit < 0 ? 0 : (unsigned) ((value->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1); + significand = significand * 2 + digit; + } + const long double result = ldexpl(significand, (int) value->expn - LDBL_MANT_DIG); + return value->sign ? -result : result; +} + +static SBV_CGEN_UNUSED inline SDouble sbv_fp_cast_real_double(SReal a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); sbv_bf_set_long_double(&x, a); + bf_round(&x, 53, BF_FLAG_SUBNORMAL | bf_set_exp_bits(11) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SDouble) result; +} + + +SDouble toFP_Real_ToDouble(const SReal sbv_input_0) +{ + const SReal s0 = sbv_input_0; + SDouble s2; + s2 = sbv_fp_cast_real_double(s0, BF_RNDN); + + return s2; +} +== END: "toFP_Real_ToDouble.c" ================== +== BEGIN: "fromFP_Float_ToInt8.c" ================ +/* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt8 sbv_fp_cast_float_s8(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord8 raw = (SWord8) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 8; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord8) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord8) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt8 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt8 fromFP_Float_ToInt8(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SInt8 s2; + s2 = sbv_fp_cast_float_s8(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToInt8.c" ================== +== BEGIN: "fromFP_Float_ToInt16.c" ================ +/* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt16 sbv_fp_cast_float_s16(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord16 raw = (SWord16) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 16; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord16) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord16) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt16 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt16 fromFP_Float_ToInt16(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SInt16 s2; + s2 = sbv_fp_cast_float_s16(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToInt16.c" ================== +== BEGIN: "fromFP_Float_ToInt32.c" ================ +/* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt32 sbv_fp_cast_float_s32(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord32 raw = (SWord32) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 32; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord32) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord32) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt32 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt32 fromFP_Float_ToInt32(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SInt32 s2; + s2 = sbv_fp_cast_float_s32(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToInt32.c" ================== +== BEGIN: "fromFP_Float_ToInt64.c" ================ +/* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt64 sbv_fp_cast_float_s64(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt64 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt64 fromFP_Float_ToInt64(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SInt64 s2; + s2 = sbv_fp_cast_float_s64(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToInt64.c" ================== +== BEGIN: "fromFP_Float_ToWord8.c" ================ +/* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord8 sbv_fp_cast_float_u8(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord8 raw = (SWord8) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 8; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord8) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord8) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord8 fromFP_Float_ToWord8(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SWord8 s2; + s2 = sbv_fp_cast_float_u8(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToWord8.c" ================== +== BEGIN: "fromFP_Float_ToWord16.c" ================ +/* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord16 sbv_fp_cast_float_u16(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord16 raw = (SWord16) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 16; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord16) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord16) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord16 fromFP_Float_ToWord16(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SWord16 s2; + s2 = sbv_fp_cast_float_u16(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToWord16.c" ================== +== BEGIN: "fromFP_Float_ToWord32.c" ================ +/* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord32 sbv_fp_cast_float_u32(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord32 raw = (SWord32) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 32; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord32) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord32) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord32 fromFP_Float_ToWord32(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SWord32 s2; + s2 = sbv_fp_cast_float_u32(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToWord32.c" ================== +== BEGIN: "fromFP_Float_ToWord64.c" ================ +/* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord64 sbv_fp_cast_float_u64(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord64 fromFP_Float_ToWord64(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SWord64 s2; + s2 = sbv_fp_cast_float_u64(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToWord64.c" ================== +== BEGIN: "fromFP_Float_ToFloat.c" ================ +/* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat fromFP_Float_ToFloat(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + return s0; +} +== END: "fromFP_Float_ToFloat.c" ================== +== BEGIN: "fromFP_Float_ToDouble.c" ================ +/* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble fromFP_Float_ToDouble(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SDouble s2; + s2 = (SDouble) s0; + + return s2; +} +== END: "fromFP_Float_ToDouble.c" ================== +== BEGIN: "fromFP_Float_ToInteger.c" ================ +/* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt64 sbv_fp_cast_float_integer(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt64 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInteger fromFP_Float_ToInteger(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SInteger s2; + s2 = sbv_fp_cast_float_integer(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToInteger.c" ================== +== BEGIN: "fromFP_Float_ToReal.c" ================ +/* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +#include +#if FLT_RADIX == 2 && LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 && LDBL_MIN_EXP == -1021 +#define SBV_LDBL_EXP_BITS 11 +#elif FLT_RADIX == 2 && (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 +#define SBV_LDBL_EXP_BITS 15 +#else +#error SBV C long-double conversions require binary64, x87 extended, or binary128 long double +#endif +#if BF_EXP_BITS_MAX < SBV_LDBL_EXP_BITS +#error SBV C long-double conversions exceed the LibBF exponent range +#endif + +static SBV_CGEN_UNUSED bf_flags_t sbv_bf_long_double_flags(bf_rnd_t rnd) +{ + return BF_FLAG_SUBNORMAL | bf_set_exp_bits(SBV_LDBL_EXP_BITS) | (bf_flags_t) rnd; +} + +static SBV_CGEN_UNUSED void sbv_bf_set_long_double(bf_t *result, long double value) +{ + int exponent, shift = 0, status = 0; bf_t chunk; + if (isnan(value)) { bf_set_nan(result); return; } + if (isinf(value)) { bf_set_inf(result, signbit(value) != 0); return; } + if (value == 0) { bf_set_zero(result, signbit(value) != 0); return; } + long double fraction = frexpl(fabsl(value), &exponent); + bf_init(result->ctx, &chunk); bf_set_zero(result, 0); + while (fraction != 0) { + fraction = ldexpl(fraction, 32); + const uint32_t bits = (uint32_t) fraction; fraction -= (long double) bits; + status |= bf_mul_2exp(result, 32, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + status |= bf_set_ui(&chunk, bits); + status |= bf_add(result, result, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); shift += 32; + } + status |= bf_mul_2exp(result, exponent - shift, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_delete(&chunk); if (status & BF_ST_MEM_ERROR) abort(); + if (signbit(value)) bf_neg(result); +} + +static SBV_CGEN_UNUSED long double sbv_bf_get_long_double(bf_t *value, bf_rnd_t rnd) +{ + if (bf_round(value, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)) & BF_ST_MEM_ERROR) abort(); + if (bf_is_nan(value)) return nanl(""); + if (!bf_is_finite(value)) return value->sign ? -HUGE_VALL : HUGE_VALL; + if (bf_is_zero(value)) return value->sign ? -0.0L : 0.0L; + long double significand = 0; + const slimb_t base = (slimb_t) value->len * LIMB_BITS; + for (int i = 0; i < LDBL_MANT_DIG; ++i) { + const slimb_t bit = base - 1 - i; + const unsigned digit = bit < 0 ? 0 : (unsigned) ((value->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1); + significand = significand * 2 + digit; + } + const long double result = ldexpl(significand, (int) value->expn - LDBL_MANT_DIG); + return value->sign ? -result : result; +} + +static SBV_CGEN_UNUSED inline SReal sbv_fp_cast_float_real(SFloat a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; long double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); + bf_round(&x, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)); result = sbv_bf_get_long_double(&x, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SReal) result; +} + + +SReal fromFP_Float_ToReal(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SReal s2; + s2 = sbv_fp_cast_float_real(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_Float_ToReal.c" ================== +== BEGIN: "fromFP_DoubleTo_Int8.c" ================ +/* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt8 sbv_fp_cast_double_s8(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord8 raw = (SWord8) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 8; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord8) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord8) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt8 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt8 fromFP_DoubleTo_Int8(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SInt8 s2; + s2 = sbv_fp_cast_double_s8(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Int8.c" ================== +== BEGIN: "fromFP_DoubleTo_Int16.c" ================ +/* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt16 sbv_fp_cast_double_s16(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord16 raw = (SWord16) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 16; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord16) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord16) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt16 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt16 fromFP_DoubleTo_Int16(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SInt16 s2; + s2 = sbv_fp_cast_double_s16(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Int16.c" ================== +== BEGIN: "fromFP_DoubleTo_Int32.c" ================ +/* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt32 sbv_fp_cast_double_s32(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord32 raw = (SWord32) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 32; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord32) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord32) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt32 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt32 fromFP_DoubleTo_Int32(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SInt32 s2; + s2 = sbv_fp_cast_double_s32(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Int32.c" ================== +== BEGIN: "fromFP_DoubleTo_Int64.c" ================ +/* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt64 sbv_fp_cast_double_s64(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt64 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInt64 fromFP_DoubleTo_Int64(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SInt64 s2; + s2 = sbv_fp_cast_double_s64(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Int64.c" ================== +== BEGIN: "fromFP_DoubleTo_Word8.c" ================ +/* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord8 sbv_fp_cast_double_u8(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord8 raw = (SWord8) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 8; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord8) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord8) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord8 fromFP_DoubleTo_Word8(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SWord8 s2; + s2 = sbv_fp_cast_double_u8(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Word8.c" ================== +== BEGIN: "fromFP_DoubleTo_Word16.c" ================ +/* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord16 sbv_fp_cast_double_u16(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord16 raw = (SWord16) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 16; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord16) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord16) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord16 fromFP_DoubleTo_Word16(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SWord16 s2; + s2 = sbv_fp_cast_double_u16(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Word16.c" ================== +== BEGIN: "fromFP_DoubleTo_Word32.c" ================ +/* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord32 sbv_fp_cast_double_u32(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord32 raw = (SWord32) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 32; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord32) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord32) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord32 fromFP_DoubleTo_Word32(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SWord32 s2; + s2 = sbv_fp_cast_double_u32(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Word32.c" ================== +== BEGIN: "fromFP_DoubleTo_Word64.c" ================ +/* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SWord64 sbv_fp_cast_double_u64(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + return raw; +} + + +SWord64 fromFP_DoubleTo_Word64(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SWord64 s2; + s2 = sbv_fp_cast_double_u64(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Word64.c" ================== +== BEGIN: "fromFP_DoubleTo_Float.c" ================ +/* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SFloat sbv_fp_cast_double_float(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); + bf_round(&x, 24, BF_FLAG_SUBNORMAL | bf_set_exp_bits(8) | (bf_flags_t) rnd); bf_get_float64(&x, &result, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SFloat) result; +} + + +SFloat fromFP_DoubleTo_Float(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SFloat s2; + s2 = sbv_fp_cast_double_float(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Float.c" ================== +== BEGIN: "fromFP_DoubleTo_Double.c" ================ +/* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble fromFP_DoubleTo_Double(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + return s0; +} +== END: "fromFP_DoubleTo_Double.c" ================== +== BEGIN: "fromFP_DoubleTo_Integer.c" ================ +/* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +static SBV_CGEN_UNUSED inline SInt64 sbv_fp_cast_double_integer(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; SWord64 raw = (SWord64) 0; limb_t i; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); bf_rint(&x, rnd); + if (bf_is_finite(&x) && !bf_is_zero(&x)) { + const slimb_t base = (slimb_t) x.len * LIMB_BITS; + for (i = 0; i < 64; ++i) { + const slimb_t bit = (slimb_t) i - x.expn + base; + if (bit >= 0 && bit < base) { raw = (SWord64) ((uint64_t) raw | ((uint64_t) (((x.tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1) != 0) << (i))); } + } + if (x.sign) raw = (SWord64) (~(uint64_t) raw + UINT64_C(1)); + } + bf_delete(&x); bf_context_end(&ctx); + SInt64 result; memcpy(&result, &raw, sizeof result); return result; +} + + +SInteger fromFP_DoubleTo_Integer(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SInteger s2; + s2 = sbv_fp_cast_double_integer(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Integer.c" ================== +== BEGIN: "fromFP_DoubleTo_Real.c" ================ +/* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +/* LibBF-backed arbitrary floating-point runtime. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static SBV_CGEN_UNUSED inline bf_rnd_t sbv_bf_rounding_mode(int mode) +{ + switch (mode) { + case 0: return BF_RNDN; + case 1: return BF_RNDNA; + case 2: return BF_RNDU; + case 3: return BF_RNDD; + case 4: return BF_RNDZ; + default: abort(); + } +} + +static SBV_CGEN_UNUSED void *sbv_bf_realloc(void *opaque, void *ptr, size_t size) +{ + (void) opaque; + return realloc(ptr, size); +} + +#include +#if FLT_RADIX == 2 && LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 && LDBL_MIN_EXP == -1021 +#define SBV_LDBL_EXP_BITS 11 +#elif FLT_RADIX == 2 && (LDBL_MANT_DIG == 64 || LDBL_MANT_DIG == 113) && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 +#define SBV_LDBL_EXP_BITS 15 +#else +#error SBV C long-double conversions require binary64, x87 extended, or binary128 long double +#endif +#if BF_EXP_BITS_MAX < SBV_LDBL_EXP_BITS +#error SBV C long-double conversions exceed the LibBF exponent range +#endif + +static SBV_CGEN_UNUSED bf_flags_t sbv_bf_long_double_flags(bf_rnd_t rnd) +{ + return BF_FLAG_SUBNORMAL | bf_set_exp_bits(SBV_LDBL_EXP_BITS) | (bf_flags_t) rnd; +} + +static SBV_CGEN_UNUSED void sbv_bf_set_long_double(bf_t *result, long double value) +{ + int exponent, shift = 0, status = 0; bf_t chunk; + if (isnan(value)) { bf_set_nan(result); return; } + if (isinf(value)) { bf_set_inf(result, signbit(value) != 0); return; } + if (value == 0) { bf_set_zero(result, signbit(value) != 0); return; } + long double fraction = frexpl(fabsl(value), &exponent); + bf_init(result->ctx, &chunk); bf_set_zero(result, 0); + while (fraction != 0) { + fraction = ldexpl(fraction, 32); + const uint32_t bits = (uint32_t) fraction; fraction -= (long double) bits; + status |= bf_mul_2exp(result, 32, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + status |= bf_set_ui(&chunk, bits); + status |= bf_add(result, result, &chunk, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); shift += 32; + } + status |= bf_mul_2exp(result, exponent - shift, BF_PREC_INF, BF_FLAG_EXT_EXP | BF_RNDZ); + bf_delete(&chunk); if (status & BF_ST_MEM_ERROR) abort(); + if (signbit(value)) bf_neg(result); +} + +static SBV_CGEN_UNUSED long double sbv_bf_get_long_double(bf_t *value, bf_rnd_t rnd) +{ + if (bf_round(value, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)) & BF_ST_MEM_ERROR) abort(); + if (bf_is_nan(value)) return nanl(""); + if (!bf_is_finite(value)) return value->sign ? -HUGE_VALL : HUGE_VALL; + if (bf_is_zero(value)) return value->sign ? -0.0L : 0.0L; + long double significand = 0; + const slimb_t base = (slimb_t) value->len * LIMB_BITS; + for (int i = 0; i < LDBL_MANT_DIG; ++i) { + const slimb_t bit = base - 1 - i; + const unsigned digit = bit < 0 ? 0 : (unsigned) ((value->tab[bit / LIMB_BITS] >> (bit % LIMB_BITS)) & 1); + significand = significand * 2 + digit; + } + const long double result = ldexpl(significand, (int) value->expn - LDBL_MANT_DIG); + return value->sign ? -result : result; +} + +static SBV_CGEN_UNUSED inline SReal sbv_fp_cast_double_real(SDouble a, bf_rnd_t rnd) +{ + bf_context_t ctx; bf_t x; long double result; + bf_context_init(&ctx, sbv_bf_realloc, NULL); bf_init(&ctx, &x); bf_set_float64(&x, (double) a); + bf_round(&x, LDBL_MANT_DIG, sbv_bf_long_double_flags(rnd)); result = sbv_bf_get_long_double(&x, rnd); + bf_delete(&x); bf_context_end(&ctx); return (SReal) result; +} + + +SReal fromFP_DoubleTo_Real(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SReal s2; + s2 = sbv_fp_cast_double_real(s0, BF_RNDN); + + return s2; +} +== END: "fromFP_DoubleTo_Real.c" ================== +== BEGIN: "fromFP_SWord32_SFloat.c" ================ +/* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat fromFP_SWord32_SFloat(const SWord32 sbv_input_0) +{ + const SWord32 s0 = sbv_input_0; + SFloat s1; + memcpy(&s1, &s0, sizeof(SFloat)); + + return s1; +} +== END: "fromFP_SWord32_SFloat.c" ================== +== BEGIN: "fromFP_SWord64_SDouble.c" ================ +/* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble fromFP_SWord64_SDouble(const SWord64 sbv_input_0) +{ + const SWord64 s0 = sbv_input_0; + SDouble s1; + memcpy(&s1, &s0, sizeof(SDouble)); + + return s1; +} +== END: "fromFP_SWord64_SDouble.c" ================== +== BEGIN: "fromFP_SFloat_SWord32.c" ================ +/* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SWord32 fromFP_SFloat_SWord32(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SWord32 s1; + memcpy(&s1, &s0, sizeof(SWord32)); + + return s1; +} +== END: "fromFP_SFloat_SWord32.c" ================== +== BEGIN: "fromFP_SDouble_SWord64.c" ================ +/* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SWord64 fromFP_SDouble_SWord64(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SWord64 s1; + memcpy(&s1, &s0, sizeof(SWord64)); + + return s1; +} +== END: "fromFP_SDouble_SWord64.c" ================== +== BEGIN: "f_FP_Abs.c" ================ +/* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Abs(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SFloat s1; + s1 = fabsf(s0); + + return s1; +} +== END: "f_FP_Abs.c" ================== +== BEGIN: "d_FP_Abs.c" ================ +/* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Abs(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SDouble s1; + s1 = fabs(s0); + + return s1; +} +== END: "d_FP_Abs.c" ================== +== BEGIN: "f_FP_Neg.c" ================ +/* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Neg(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SFloat s1; + s1 = (- s0); + + return s1; +} +== END: "f_FP_Neg.c" ================== +== BEGIN: "d_FP_Neg.c" ================ +/* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Neg(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SDouble s1; + s1 = (- s0); + + return s1; +} +== END: "d_FP_Neg.c" ================== +== BEGIN: "f_FP_Add.c" ================ +/* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Add(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s3; + s3 = s0 + s1; + + return s3; +} +== END: "f_FP_Add.c" ================== +== BEGIN: "d_FP_Add.c" ================ +/* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Add(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s3; + s3 = s0 + s1; + + return s3; +} +== END: "d_FP_Add.c" ================== +== BEGIN: "f_FP_Sub.c" ================ +/* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Sub(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s3; + s3 = s0 - s1; + + return s3; +} +== END: "f_FP_Sub.c" ================== +== BEGIN: "d_FP_Sub.c" ================ +/* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Sub(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s3; + s3 = s0 - s1; + + return s3; +} +== END: "d_FP_Sub.c" ================== +== BEGIN: "f_FP_Mul.c" ================ +/* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Mul(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s3; + s3 = s0 * s1; + + return s3; +} +== END: "f_FP_Mul.c" ================== +== BEGIN: "d_FP_Mul.c" ================ +/* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Mul(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s3; + s3 = s0 * s1; + + return s3; +} +== END: "d_FP_Mul.c" ================== +== BEGIN: "f_FP_Div.c" ================ +/* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Div(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s3; + s3 = s0 / s1; + + return s3; +} +== END: "f_FP_Div.c" ================== +== BEGIN: "d_FP_Div.c" ================ +/* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Div(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s3; + s3 = s0 / s1; + + return s3; +} +== END: "d_FP_Div.c" ================== +== BEGIN: "f_FP_FMA.c" ================ +/* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_FMA(const SFloat sbv_input_0, const SFloat sbv_input_1, + const SFloat sbv_input_2) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + const SFloat s2 = sbv_input_2; + SFloat s4; + s4 = fmaf(s0, s1, s2); + + return s4; +} +== END: "f_FP_FMA.c" ================== +== BEGIN: "d_FP_FMA.c" ================ +/* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_FMA(const SDouble sbv_input_0, + const SDouble sbv_input_1, const SDouble sbv_input_2) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + const SDouble s2 = sbv_input_2; + SDouble s4; + s4 = fma(s0, s1, s2); + + return s4; +} +== END: "d_FP_FMA.c" ================== +== BEGIN: "f_FP_Sqrt.c" ================ +/* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Sqrt(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SFloat s2; + s2 = sqrtf(s0); + + return s2; +} +== END: "f_FP_Sqrt.c" ================== +== BEGIN: "d_FP_Sqrt.c" ================ +/* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Sqrt(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SDouble s2; + s2 = sqrt(s0); + + return s2; +} +== END: "d_FP_Sqrt.c" ================== +== BEGIN: "f_FP_Rem.c" ================ +/* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Rem(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s2; + s2 = remainderf(s0, s1); + + return s2; +} +== END: "f_FP_Rem.c" ================== +== BEGIN: "d_FP_Rem.c" ================ +/* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Rem(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s2; + s2 = remainder(s0, s1); + + return s2; +} +== END: "d_FP_Rem.c" ================== +== BEGIN: "f_FP_RoundToIntegral.c" ================ +/* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_RoundToIntegral(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SFloat s2; + s2 = rintf(s0); + + return s2; +} +== END: "f_FP_RoundToIntegral.c" ================== +== BEGIN: "d_FP_RoundToIntegral.c" ================ +/* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_RoundToIntegral(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SDouble s2; + s2 = rint(s0); + + return s2; +} +== END: "d_FP_RoundToIntegral.c" ================== +== BEGIN: "f_FP_Min.c" ================ +/* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Min(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s2; + s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0F /* 0.0F */ : fminf(s0, + s1); + + return s2; +} +== END: "f_FP_Min.c" ================== +== BEGIN: "d_FP_Min.c" ================ +/* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Min(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s2; + s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0 /* 0.0 */ : fmin(s0, + s1); + + return s2; +} +== END: "d_FP_Min.c" ================== +== BEGIN: "f_FP_Max.c" ================ +/* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SFloat f_FP_Max(const SFloat sbv_input_0, const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SFloat s2; + s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0F /* 0.0F */ : fmaxf(s0, + s1); + + return s2; +} +== END: "f_FP_Max.c" ================== +== BEGIN: "d_FP_Max.c" ================ +/* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SDouble d_FP_Max(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SDouble s2; + s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0x0p+0 /* 0.0 */ : fmax(s0, + s1); + + return s2; +} +== END: "d_FP_Max.c" ================== +== BEGIN: "f_FP_IsEqualObject.c" ================ +/* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsEqualObject(const SFloat sbv_input_0, + const SFloat sbv_input_1) +{ + const SFloat s0 = sbv_input_0; + const SFloat s1 = sbv_input_1; + SBool s2; + s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); + + return s2; +} +== END: "f_FP_IsEqualObject.c" ================== +== BEGIN: "d_FP_IsEqualObject.c" ================ +/* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsEqualObject(const SDouble sbv_input_0, + const SDouble sbv_input_1) +{ + const SDouble s0 = sbv_input_0; + const SDouble s1 = sbv_input_1; + SBool s2; + s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); + + return s2; +} +== END: "d_FP_IsEqualObject.c" ================== +== BEGIN: "f_FP_IsNormal.c" ================ +/* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsNormal(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = isnormal(s0); + + return s1; +} +== END: "f_FP_IsNormal.c" ================== +== BEGIN: "d_FP_IsNormal.c" ================ +/* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsNormal(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = isnormal(s0); + + return s1; +} +== END: "d_FP_IsNormal.c" ================== +== BEGIN: "f_FP_IsZero.c" ================ +/* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsZero(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = FP_ZERO == fpclassify(s0); + + return s1; +} +== END: "f_FP_IsZero.c" ================== +== BEGIN: "d_FP_IsZero.c" ================ +/* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsZero(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = FP_ZERO == fpclassify(s0); + + return s1; +} +== END: "d_FP_IsZero.c" ================== +== BEGIN: "f_FP_IsSubnormal.c" ================ +/* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsSubnormal(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = FP_SUBNORMAL == fpclassify(s0); + + return s1; +} +== END: "f_FP_IsSubnormal.c" ================== +== BEGIN: "d_FP_IsSubnormal.c" ================ +/* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsSubnormal(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = FP_SUBNORMAL == fpclassify(s0); + + return s1; +} +== END: "d_FP_IsSubnormal.c" ================== +== BEGIN: "f_FP_IsInfinite.c" ================ +/* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsInfinite(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = isinf(s0); + + return s1; +} +== END: "f_FP_IsInfinite.c" ================== +== BEGIN: "d_FP_IsInfinite.c" ================ +/* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsInfinite(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = isinf(s0); + + return s1; +} +== END: "d_FP_IsInfinite.c" ================== +== BEGIN: "f_FP_IsNaN.c" ================ +/* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsNaN(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = isnan(s0); + + return s1; +} +== END: "f_FP_IsNaN.c" ================== +== BEGIN: "d_FP_IsNaN.c" ================ +/* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsNaN(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = isnan(s0); + + return s1; +} +== END: "d_FP_IsNaN.c" ================== +== BEGIN: "f_FP_IsNegative.c" ================ +/* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsNegative(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = !isnan(s0) && signbit(s0); + + return s1; +} +== END: "f_FP_IsNegative.c" ================== +== BEGIN: "d_FP_IsNegative.c" ================ +/* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsNegative(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = !isnan(s0) && signbit(s0); + + return s1; +} +== END: "d_FP_IsNegative.c" ================== +== BEGIN: "f_FP_IsPositive.c" ================ +/* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool f_FP_IsPositive(const SFloat sbv_input_0) +{ + const SFloat s0 = sbv_input_0; + SBool s1; + s1 = !isnan(s0) && !signbit(s0); + + return s1; +} +== END: "f_FP_IsPositive.c" ================== +== BEGIN: "d_FP_IsPositive.c" ================ +/* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ + +#include "floatCodeGen.h" +#include + +/* Preserve separate SBV rounding steps; explicit fma calls remain fused. */ +#if defined(__clang__) +#pragma STDC FP_CONTRACT OFF +#endif + + +SBool d_FP_IsPositive(const SDouble sbv_input_0) +{ + const SDouble s0 = sbv_input_0; + SBool s1; + s1 = !isnan(s0) && !signbit(s0); + + return s1; +} +== END: "d_FP_IsPositive.c" ================== +== BEGIN: "floatCodeGen.h" ================ +/* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */ + +#ifndef SBV_GENERATED_floatCodeGen_HEADER_INCLUDED +#define SBV_GENERATED_floatCodeGen_HEADER_INCLUDED + +#if defined(__FAST_MATH__) || (defined(__FINITE_MATH_ONLY__) && __FINITE_MATH_ONLY__ > 0) +#error "SBV-generated C requires IEEE floating-point semantics; disable fast-math and finite-math-only." +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#if FLT_EVAL_METHOD != 0 +#error "SBV-generated C requires FLT_EVAL_METHOD == 0; indeterminate or excess-precision floating evaluation is unsupported." +#endif + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* User requested mapping for SInteger. */ +/* NB. Loss of precision: Target type is subject to modular arithmetic. */ +typedef SInt64 SInteger; + +/* User requested mapping for SReal. */ +/* NB. Loss of precision: Target type is subject to rounding. */ +typedef long double SReal; + +/* IEEE-754 rounding modes. */ +#ifndef SBV_ROUNDING_MODE_DEFINED +#define SBV_ROUNDING_MODE_DEFINED +typedef enum { SBV_RM_RNE = 0, SBV_RM_RNA = 1, SBV_RM_RTP = 2, SBV_RM_RTN = 3, SBV_RM_RTZ = 4 } RoundingMode; +#endif + + +/* Entry point prototypes: */ +SFloat toFP_Int8_ToFloat(const SInt8 a); +SFloat toFP_Int16_ToFloat(const SInt16 a); +SFloat toFP_Int32_ToFloat(const SInt32 a); +SFloat toFP_Int64_ToFloat(const SInt64 a); +SFloat toFP_Word8_ToFloat(const SWord8 a); +SFloat toFP_Word16_ToFloat(const SWord16 a); +SFloat toFP_Word32_ToFloat(const SWord32 a); +SFloat toFP_Word64_ToFloat(const SWord64 a); +SFloat toFP_Float_ToFloat(const SFloat a); +SFloat toFP_Double_ToFloat(const SDouble a); +SFloat toFP_Integer_ToFloat(const SInteger a); +SFloat toFP_Real_ToFloat(const SReal a); +SDouble toFP_Int8_ToDouble(const SInt8 a); +SDouble toFP_Int16_ToDouble(const SInt16 a); +SDouble toFP_Int32_ToDouble(const SInt32 a); +SDouble toFP_Int64_ToDouble(const SInt64 a); +SDouble toFP_Word8_ToDouble(const SWord8 a); +SDouble toFP_Word16_ToDouble(const SWord16 a); +SDouble toFP_Word32_ToDouble(const SWord32 a); +SDouble toFP_Word64_ToDouble(const SWord64 a); +SDouble toFP_Float_ToDouble(const SFloat a); +SDouble toFP_Double_ToDouble(const SDouble a); +SDouble toFP_Integer_ToDouble(const SInteger a); +SDouble toFP_Real_ToDouble(const SReal a); +SInt8 fromFP_Float_ToInt8(const SFloat a); +SInt16 fromFP_Float_ToInt16(const SFloat a); +SInt32 fromFP_Float_ToInt32(const SFloat a); +SInt64 fromFP_Float_ToInt64(const SFloat a); +SWord8 fromFP_Float_ToWord8(const SFloat a); +SWord16 fromFP_Float_ToWord16(const SFloat a); +SWord32 fromFP_Float_ToWord32(const SFloat a); +SWord64 fromFP_Float_ToWord64(const SFloat a); +SFloat fromFP_Float_ToFloat(const SFloat a); +SDouble fromFP_Float_ToDouble(const SFloat a); +SInteger fromFP_Float_ToInteger(const SFloat a); +SReal fromFP_Float_ToReal(const SFloat a); +SInt8 fromFP_DoubleTo_Int8(const SDouble a); +SInt16 fromFP_DoubleTo_Int16(const SDouble a); +SInt32 fromFP_DoubleTo_Int32(const SDouble a); +SInt64 fromFP_DoubleTo_Int64(const SDouble a); +SWord8 fromFP_DoubleTo_Word8(const SDouble a); +SWord16 fromFP_DoubleTo_Word16(const SDouble a); +SWord32 fromFP_DoubleTo_Word32(const SDouble a); +SWord64 fromFP_DoubleTo_Word64(const SDouble a); +SFloat fromFP_DoubleTo_Float(const SDouble a); +SDouble fromFP_DoubleTo_Double(const SDouble a); +SInteger fromFP_DoubleTo_Integer(const SDouble a); +SReal fromFP_DoubleTo_Real(const SDouble a); +SFloat fromFP_SWord32_SFloat(const SWord32 a); +SDouble fromFP_SWord64_SDouble(const SWord64 a); +SWord32 fromFP_SFloat_SWord32(const SFloat a); +SWord64 fromFP_SDouble_SWord64(const SDouble a); +SFloat f_FP_Abs(const SFloat a); +SDouble d_FP_Abs(const SDouble a); +SFloat f_FP_Neg(const SFloat a); +SDouble d_FP_Neg(const SDouble a); +SFloat f_FP_Add(const SFloat a, const SFloat b); +SDouble d_FP_Add(const SDouble a, const SDouble b); +SFloat f_FP_Sub(const SFloat a, const SFloat b); +SDouble d_FP_Sub(const SDouble a, const SDouble b); +SFloat f_FP_Mul(const SFloat a, const SFloat b); +SDouble d_FP_Mul(const SDouble a, const SDouble b); +SFloat f_FP_Div(const SFloat a, const SFloat b); +SDouble d_FP_Div(const SDouble a, const SDouble b); +SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c); +SDouble d_FP_FMA(const SDouble a, const SDouble b, + const SDouble c); +SFloat f_FP_Sqrt(const SFloat a); +SDouble d_FP_Sqrt(const SDouble a); +SFloat f_FP_Rem(const SFloat a, const SFloat b); +SDouble d_FP_Rem(const SDouble a, const SDouble b); +SFloat f_FP_RoundToIntegral(const SFloat a); +SDouble d_FP_RoundToIntegral(const SDouble a); +SFloat f_FP_Min(const SFloat a, const SFloat b); +SDouble d_FP_Min(const SDouble a, const SDouble b); +SFloat f_FP_Max(const SFloat a, const SFloat b); +SDouble d_FP_Max(const SDouble a, const SDouble b); +SBool f_FP_IsEqualObject(const SFloat a, const SFloat b); +SBool d_FP_IsEqualObject(const SDouble a, const SDouble b); +SBool f_FP_IsNormal(const SFloat a); +SBool d_FP_IsNormal(const SDouble a); +SBool f_FP_IsZero(const SFloat a); +SBool d_FP_IsZero(const SDouble a); +SBool f_FP_IsSubnormal(const SFloat a); +SBool d_FP_IsSubnormal(const SDouble a); +SBool f_FP_IsInfinite(const SFloat a); +SBool d_FP_IsInfinite(const SDouble a); +SBool f_FP_IsNaN(const SFloat a); +SBool d_FP_IsNaN(const SDouble a); +SBool f_FP_IsNegative(const SFloat a); +SBool d_FP_IsNegative(const SDouble a); +SBool f_FP_IsPositive(const SFloat a); +SBool d_FP_IsPositive(const SDouble a); + +#endif /* SBV_GENERATED_floatCodeGen_HEADER_INCLUDED */ +== END: "floatCodeGen.h" ================== +== BEGIN: "floatCodeGen_driver.c" ================ +/* Example driver program for floatCodeGen. */ +/* Automatically generated by SBV. Edit as you see fit! */ + +#include +#include "floatCodeGen.h" +#include + +void toFP_Int8_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Int8_ToFloat(42); + + printf("toFP_Int8_ToFloat(42) = %a\n", sbv_result); +} + +void toFP_Int16_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Int16_ToFloat(0x002a); + + printf("toFP_Int16_ToFloat(0x002a) = %a\n", sbv_result); +} + +void toFP_Int32_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Int32_ToFloat(0x0000002aL); + + printf("toFP_Int32_ToFloat(0x0000002aL) = %a\n", sbv_result); +} + +void toFP_Int64_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Int64_ToFloat(0x000000000000002aLL); + + printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %a\n", sbv_result); +} + +void toFP_Word8_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Word8_ToFloat(42); + + printf("toFP_Word8_ToFloat(42) = %a\n", sbv_result); +} + +void toFP_Word16_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Word16_ToFloat(0x002aU); + + printf("toFP_Word16_ToFloat(0x002aU) = %a\n", sbv_result); +} + +void toFP_Word32_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Word32_ToFloat(0x0000002aUL); + + printf("toFP_Word32_ToFloat(0x0000002aUL) = %a\n", sbv_result); +} + +void toFP_Word64_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Word64_ToFloat(0x000000000000002aULL); + + printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %a\n", sbv_result); +} + +void toFP_Float_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Float_ToFloat(0x1.5p5F /* 42.0F */); + + printf("toFP_Float_ToFloat(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void toFP_Double_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Double_ToFloat(0x1.5p5 /* 42.0 */); + + printf("toFP_Double_ToFloat(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void toFP_Integer_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Integer_ToFloat(0x000000000000002aLL); + + printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %a\n", sbv_result); +} + +void toFP_Real_ToFloat_driver(void) +{ + const SFloat sbv_result = toFP_Real_ToFloat(42.0L); + + printf("toFP_Real_ToFloat(42.0L) = %a\n", sbv_result); +} + +void toFP_Int8_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Int8_ToDouble(42); + + printf("toFP_Int8_ToDouble(42) = %a\n", sbv_result); +} + +void toFP_Int16_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Int16_ToDouble(0x002a); + + printf("toFP_Int16_ToDouble(0x002a) = %a\n", sbv_result); +} + +void toFP_Int32_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Int32_ToDouble(0x0000002aL); + + printf("toFP_Int32_ToDouble(0x0000002aL) = %a\n", sbv_result); +} + +void toFP_Int64_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Int64_ToDouble(0x000000000000002aLL); + + printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %a\n", sbv_result); +} + +void toFP_Word8_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Word8_ToDouble(42); + + printf("toFP_Word8_ToDouble(42) = %a\n", sbv_result); +} + +void toFP_Word16_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Word16_ToDouble(0x002aU); + + printf("toFP_Word16_ToDouble(0x002aU) = %a\n", sbv_result); +} + +void toFP_Word32_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Word32_ToDouble(0x0000002aUL); + + printf("toFP_Word32_ToDouble(0x0000002aUL) = %a\n", sbv_result); +} + +void toFP_Word64_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Word64_ToDouble(0x000000000000002aULL); + + printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %a\n", sbv_result); +} + +void toFP_Float_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Float_ToDouble(0x1.5p5F /* 42.0F */); + + printf("toFP_Float_ToDouble(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void toFP_Double_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Double_ToDouble(0x1.5p5 /* 42.0 */); + + printf("toFP_Double_ToDouble(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void toFP_Integer_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Integer_ToDouble(0x000000000000002aLL); + + printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %a\n", sbv_result); +} + +void toFP_Real_ToDouble_driver(void) +{ + const SDouble sbv_result = toFP_Real_ToDouble(42.0L); + + printf("toFP_Real_ToDouble(42.0L) = %a\n", sbv_result); +} + +void fromFP_Float_ToInt8_driver(void) +{ + const SInt8 sbv_result = fromFP_Float_ToInt8(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToInt8(0x1.5p5F /* 42.0F */) = %"PRId8"\n", sbv_result); +} + +void fromFP_Float_ToInt16_driver(void) +{ + const SInt16 sbv_result = fromFP_Float_ToInt16(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToInt16(0x1.5p5F /* 42.0F */) = %"PRId16"\n", sbv_result); +} + +void fromFP_Float_ToInt32_driver(void) +{ + const SInt32 sbv_result = fromFP_Float_ToInt32(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToInt32(0x1.5p5F /* 42.0F */) = %"PRId32"L\n", sbv_result); +} + +void fromFP_Float_ToInt64_driver(void) +{ + const SInt64 sbv_result = fromFP_Float_ToInt64(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToInt64(0x1.5p5F /* 42.0F */) = %"PRId64"LL\n", sbv_result); +} + +void fromFP_Float_ToWord8_driver(void) +{ + const SWord8 sbv_result = fromFP_Float_ToWord8(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToWord8(0x1.5p5F /* 42.0F */) = %"PRIu8"\n", sbv_result); +} + +void fromFP_Float_ToWord16_driver(void) +{ + const SWord16 sbv_result = fromFP_Float_ToWord16(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToWord16(0x1.5p5F /* 42.0F */) = 0x%04"PRIx16"U\n", sbv_result); +} + +void fromFP_Float_ToWord32_driver(void) +{ + const SWord32 sbv_result = fromFP_Float_ToWord32(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToWord32(0x1.5p5F /* 42.0F */) = 0x%08"PRIx32"UL\n", sbv_result); +} + +void fromFP_Float_ToWord64_driver(void) +{ + const SWord64 sbv_result = fromFP_Float_ToWord64(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToWord64(0x1.5p5F /* 42.0F */) = 0x%016"PRIx64"ULL\n", sbv_result); +} + +void fromFP_Float_ToFloat_driver(void) +{ + const SFloat sbv_result = fromFP_Float_ToFloat(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToFloat(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void fromFP_Float_ToDouble_driver(void) +{ + const SDouble sbv_result = fromFP_Float_ToDouble(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToDouble(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void fromFP_Float_ToInteger_driver(void) +{ + const SInteger sbv_result = fromFP_Float_ToInteger(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToInteger(0x1.5p5F /* 42.0F */) = %"PRId64"LL\n", sbv_result); +} + +void fromFP_Float_ToReal_driver(void) +{ + const SReal sbv_result = fromFP_Float_ToReal(0x1.5p5F /* 42.0F */); + + printf("fromFP_Float_ToReal(0x1.5p5F /* 42.0F */) = %Lf\n", sbv_result); +} + +void fromFP_DoubleTo_Int8_driver(void) +{ + const SInt8 sbv_result = fromFP_DoubleTo_Int8(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Int8(0x1.5p5 /* 42.0 */) = %"PRId8"\n", sbv_result); +} + +void fromFP_DoubleTo_Int16_driver(void) +{ + const SInt16 sbv_result = fromFP_DoubleTo_Int16(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Int16(0x1.5p5 /* 42.0 */) = %"PRId16"\n", sbv_result); +} + +void fromFP_DoubleTo_Int32_driver(void) +{ + const SInt32 sbv_result = fromFP_DoubleTo_Int32(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Int32(0x1.5p5 /* 42.0 */) = %"PRId32"L\n", sbv_result); +} + +void fromFP_DoubleTo_Int64_driver(void) +{ + const SInt64 sbv_result = fromFP_DoubleTo_Int64(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Int64(0x1.5p5 /* 42.0 */) = %"PRId64"LL\n", sbv_result); +} + +void fromFP_DoubleTo_Word8_driver(void) +{ + const SWord8 sbv_result = fromFP_DoubleTo_Word8(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Word8(0x1.5p5 /* 42.0 */) = %"PRIu8"\n", sbv_result); +} + +void fromFP_DoubleTo_Word16_driver(void) +{ + const SWord16 sbv_result = fromFP_DoubleTo_Word16(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Word16(0x1.5p5 /* 42.0 */) = 0x%04"PRIx16"U\n", sbv_result); +} + +void fromFP_DoubleTo_Word32_driver(void) +{ + const SWord32 sbv_result = fromFP_DoubleTo_Word32(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Word32(0x1.5p5 /* 42.0 */) = 0x%08"PRIx32"UL\n", sbv_result); +} + +void fromFP_DoubleTo_Word64_driver(void) +{ + const SWord64 sbv_result = fromFP_DoubleTo_Word64(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Word64(0x1.5p5 /* 42.0 */) = 0x%016"PRIx64"ULL\n", sbv_result); +} + +void fromFP_DoubleTo_Float_driver(void) +{ + const SFloat sbv_result = fromFP_DoubleTo_Float(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Float(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void fromFP_DoubleTo_Double_driver(void) +{ + const SDouble sbv_result = fromFP_DoubleTo_Double(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Double(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void fromFP_DoubleTo_Integer_driver(void) +{ + const SInteger sbv_result = fromFP_DoubleTo_Integer(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Integer(0x1.5p5 /* 42.0 */) = %"PRId64"LL\n", sbv_result); +} + +void fromFP_DoubleTo_Real_driver(void) +{ + const SReal sbv_result = fromFP_DoubleTo_Real(0x1.5p5 /* 42.0 */); + + printf("fromFP_DoubleTo_Real(0x1.5p5 /* 42.0 */) = %Lf\n", sbv_result); +} + +void fromFP_SWord32_SFloat_driver(void) +{ + const SFloat sbv_result = fromFP_SWord32_SFloat(0x0000002aUL); + + printf("fromFP_SWord32_SFloat(0x0000002aUL) = %a\n", sbv_result); +} + +void fromFP_SWord64_SDouble_driver(void) +{ + const SDouble sbv_result = fromFP_SWord64_SDouble(0x000000000000002aULL); + + printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %a\n", sbv_result); +} + +void fromFP_SFloat_SWord32_driver(void) +{ + const SWord32 sbv_result = fromFP_SFloat_SWord32(0x1.5p5F /* 42.0F */); + + printf("fromFP_SFloat_SWord32(0x1.5p5F /* 42.0F */) = 0x%08"PRIx32"UL\n", sbv_result); +} + +void fromFP_SDouble_SWord64_driver(void) +{ + const SWord64 sbv_result = fromFP_SDouble_SWord64(0x1.5p5 /* 42.0 */); + + printf("fromFP_SDouble_SWord64(0x1.5p5 /* 42.0 */) = 0x%016"PRIx64"ULL\n", sbv_result); +} + +void f_FP_Abs_driver(void) +{ + const SFloat sbv_result = f_FP_Abs(0x1.5p5F /* 42.0F */); + + printf("f_FP_Abs(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void d_FP_Abs_driver(void) +{ + const SDouble sbv_result = d_FP_Abs(0x1.5p5 /* 42.0 */); + + printf("d_FP_Abs(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void f_FP_Neg_driver(void) +{ + const SFloat sbv_result = f_FP_Neg(0x1.5p5F /* 42.0F */); + + printf("f_FP_Neg(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void d_FP_Neg_driver(void) +{ + const SDouble sbv_result = d_FP_Neg(0x1.5p5 /* 42.0 */); + + printf("d_FP_Neg(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void f_FP_Add_driver(void) +{ + const SFloat sbv_result = f_FP_Add(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Add(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Add_driver(void) +{ + const SDouble sbv_result = d_FP_Add(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Add(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_Sub_driver(void) +{ + const SFloat sbv_result = f_FP_Sub(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Sub(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Sub_driver(void) +{ + const SDouble sbv_result = d_FP_Sub(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Sub(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_Mul_driver(void) +{ + const SFloat sbv_result = f_FP_Mul(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Mul(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Mul_driver(void) +{ + const SDouble sbv_result = d_FP_Mul(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Mul(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_Div_driver(void) +{ + const SFloat sbv_result = f_FP_Div(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Div(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Div_driver(void) +{ + const SDouble sbv_result = d_FP_Div(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Div(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_FMA_driver(void) +{ + const SFloat sbv_result = f_FP_FMA(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */, 0x1.6p5F /* 44.0F */); + + printf("f_FP_FMA(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */, 0x1.6p5F /* 44.0F */) = %a\n", sbv_result); +} + +void d_FP_FMA_driver(void) +{ + const SDouble sbv_result = d_FP_FMA(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */, 0x1.6p5 /* 44.0 */); + + printf("d_FP_FMA(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */, 0x1.6p5 /* 44.0 */) = %a\n", sbv_result); +} + +void f_FP_Sqrt_driver(void) +{ + const SFloat sbv_result = f_FP_Sqrt(0x1.5p5F /* 42.0F */); + + printf("f_FP_Sqrt(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void d_FP_Sqrt_driver(void) +{ + const SDouble sbv_result = d_FP_Sqrt(0x1.5p5 /* 42.0 */); + + printf("d_FP_Sqrt(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void f_FP_Rem_driver(void) +{ + const SFloat sbv_result = f_FP_Rem(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Rem(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Rem_driver(void) +{ + const SDouble sbv_result = d_FP_Rem(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Rem(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_RoundToIntegral_driver(void) +{ + const SFloat sbv_result = f_FP_RoundToIntegral(0x1.5p5F /* 42.0F */); + + printf("f_FP_RoundToIntegral(0x1.5p5F /* 42.0F */) = %a\n", sbv_result); +} + +void d_FP_RoundToIntegral_driver(void) +{ + const SDouble sbv_result = d_FP_RoundToIntegral(0x1.5p5 /* 42.0 */); + + printf("d_FP_RoundToIntegral(0x1.5p5 /* 42.0 */) = %a\n", sbv_result); +} + +void f_FP_Min_driver(void) +{ + const SFloat sbv_result = f_FP_Min(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Min(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Min_driver(void) +{ + const SDouble sbv_result = d_FP_Min(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Min(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_Max_driver(void) +{ + const SFloat sbv_result = f_FP_Max(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_Max(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %a\n", sbv_result); +} + +void d_FP_Max_driver(void) +{ + const SDouble sbv_result = d_FP_Max(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_Max(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %a\n", sbv_result); +} + +void f_FP_IsEqualObject_driver(void) +{ + const SBool sbv_result = f_FP_IsEqualObject(0x1.5p5F /* 42.0F */, + 0x1.58p5F /* 43.0F */); + + printf("f_FP_IsEqualObject(0x1.5p5F /* 42.0F */, 0x1.58p5F /* 43.0F */) = %d\n", sbv_result); +} + +void d_FP_IsEqualObject_driver(void) +{ + const SBool sbv_result = d_FP_IsEqualObject(0x1.5p5 /* 42.0 */, + 0x1.58p5 /* 43.0 */); + + printf("d_FP_IsEqualObject(0x1.5p5 /* 42.0 */, 0x1.58p5 /* 43.0 */) = %d\n", sbv_result); +} + +void f_FP_IsNormal_driver(void) +{ + const SBool sbv_result = f_FP_IsNormal(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsNormal(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsNormal_driver(void) +{ + const SBool sbv_result = d_FP_IsNormal(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsNormal(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsZero_driver(void) +{ + const SBool sbv_result = f_FP_IsZero(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsZero(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsZero_driver(void) +{ + const SBool sbv_result = d_FP_IsZero(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsZero(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsSubnormal_driver(void) +{ + const SBool sbv_result = f_FP_IsSubnormal(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsSubnormal(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsSubnormal_driver(void) +{ + const SBool sbv_result = d_FP_IsSubnormal(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsSubnormal(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsInfinite_driver(void) +{ + const SBool sbv_result = f_FP_IsInfinite(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsInfinite(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsInfinite_driver(void) +{ + const SBool sbv_result = d_FP_IsInfinite(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsInfinite(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsNaN_driver(void) +{ + const SBool sbv_result = f_FP_IsNaN(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsNaN(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsNaN_driver(void) +{ + const SBool sbv_result = d_FP_IsNaN(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsNaN(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsNegative_driver(void) +{ + const SBool sbv_result = f_FP_IsNegative(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsNegative(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsNegative_driver(void) +{ + const SBool sbv_result = d_FP_IsNegative(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsNegative(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +void f_FP_IsPositive_driver(void) +{ + const SBool sbv_result = f_FP_IsPositive(0x1.5p5F /* 42.0F */); + + printf("f_FP_IsPositive(0x1.5p5F /* 42.0F */) = %d\n", sbv_result); +} + +void d_FP_IsPositive_driver(void) +{ + const SBool sbv_result = d_FP_IsPositive(0x1.5p5 /* 42.0 */); + + printf("d_FP_IsPositive(0x1.5p5 /* 42.0 */) = %d\n", sbv_result); +} + +int main(void) +{ + printf("====================================\n"); + printf("** Driver run for toFP_Int8_ToFloat:\n"); + printf("====================================\n"); + toFP_Int8_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Int16_ToFloat:\n"); + printf("=====================================\n"); + toFP_Int16_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Int32_ToFloat:\n"); + printf("=====================================\n"); + toFP_Int32_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Int64_ToFloat:\n"); + printf("=====================================\n"); + toFP_Int64_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Word8_ToFloat:\n"); + printf("=====================================\n"); + toFP_Word8_ToFloat_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Word16_ToFloat:\n"); + printf("======================================\n"); + toFP_Word16_ToFloat_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Word32_ToFloat:\n"); + printf("======================================\n"); + toFP_Word32_ToFloat_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Word64_ToFloat:\n"); + printf("======================================\n"); + toFP_Word64_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Float_ToFloat:\n"); + printf("=====================================\n"); + toFP_Float_ToFloat_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Double_ToFloat:\n"); + printf("======================================\n"); + toFP_Double_ToFloat_driver(); + + printf("=======================================\n"); + printf("** Driver run for toFP_Integer_ToFloat:\n"); + printf("=======================================\n"); + toFP_Integer_ToFloat_driver(); + + printf("====================================\n"); + printf("** Driver run for toFP_Real_ToFloat:\n"); + printf("====================================\n"); + toFP_Real_ToFloat_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Int8_ToDouble:\n"); + printf("=====================================\n"); + toFP_Int8_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Int16_ToDouble:\n"); + printf("======================================\n"); + toFP_Int16_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Int32_ToDouble:\n"); + printf("======================================\n"); + toFP_Int32_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Int64_ToDouble:\n"); + printf("======================================\n"); + toFP_Int64_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Word8_ToDouble:\n"); + printf("======================================\n"); + toFP_Word8_ToDouble_driver(); + + printf("=======================================\n"); + printf("** Driver run for toFP_Word16_ToDouble:\n"); + printf("=======================================\n"); + toFP_Word16_ToDouble_driver(); + + printf("=======================================\n"); + printf("** Driver run for toFP_Word32_ToDouble:\n"); + printf("=======================================\n"); + toFP_Word32_ToDouble_driver(); + + printf("=======================================\n"); + printf("** Driver run for toFP_Word64_ToDouble:\n"); + printf("=======================================\n"); + toFP_Word64_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for toFP_Float_ToDouble:\n"); + printf("======================================\n"); + toFP_Float_ToDouble_driver(); + + printf("=======================================\n"); + printf("** Driver run for toFP_Double_ToDouble:\n"); + printf("=======================================\n"); + toFP_Double_ToDouble_driver(); + + printf("========================================\n"); + printf("** Driver run for toFP_Integer_ToDouble:\n"); + printf("========================================\n"); + toFP_Integer_ToDouble_driver(); + + printf("=====================================\n"); + printf("** Driver run for toFP_Real_ToDouble:\n"); + printf("=====================================\n"); + toFP_Real_ToDouble_driver(); + + printf("======================================\n"); + printf("** Driver run for fromFP_Float_ToInt8:\n"); + printf("======================================\n"); + fromFP_Float_ToInt8_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_Float_ToInt16:\n"); + printf("=======================================\n"); + fromFP_Float_ToInt16_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_Float_ToInt32:\n"); + printf("=======================================\n"); + fromFP_Float_ToInt32_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_Float_ToInt64:\n"); + printf("=======================================\n"); + fromFP_Float_ToInt64_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_Float_ToWord8:\n"); + printf("=======================================\n"); + fromFP_Float_ToWord8_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_Float_ToWord16:\n"); + printf("========================================\n"); + fromFP_Float_ToWord16_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_Float_ToWord32:\n"); + printf("========================================\n"); + fromFP_Float_ToWord32_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_Float_ToWord64:\n"); + printf("========================================\n"); + fromFP_Float_ToWord64_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_Float_ToFloat:\n"); + printf("=======================================\n"); + fromFP_Float_ToFloat_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_Float_ToDouble:\n"); + printf("========================================\n"); + fromFP_Float_ToDouble_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_Float_ToInteger:\n"); + printf("=========================================\n"); + fromFP_Float_ToInteger_driver(); + + printf("======================================\n"); + printf("** Driver run for fromFP_Float_ToReal:\n"); + printf("======================================\n"); + fromFP_Float_ToReal_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_DoubleTo_Int8:\n"); + printf("=======================================\n"); + fromFP_DoubleTo_Int8_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Int16:\n"); + printf("========================================\n"); + fromFP_DoubleTo_Int16_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Int32:\n"); + printf("========================================\n"); + fromFP_DoubleTo_Int32_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Int64:\n"); + printf("========================================\n"); + fromFP_DoubleTo_Int64_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Word8:\n"); + printf("========================================\n"); + fromFP_DoubleTo_Word8_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Word16:\n"); + printf("=========================================\n"); + fromFP_DoubleTo_Word16_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Word32:\n"); + printf("=========================================\n"); + fromFP_DoubleTo_Word32_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Word64:\n"); + printf("=========================================\n"); + fromFP_DoubleTo_Word64_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Float:\n"); + printf("========================================\n"); + fromFP_DoubleTo_Float_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Double:\n"); + printf("=========================================\n"); + fromFP_DoubleTo_Double_driver(); + + printf("==========================================\n"); + printf("** Driver run for fromFP_DoubleTo_Integer:\n"); + printf("==========================================\n"); + fromFP_DoubleTo_Integer_driver(); + + printf("=======================================\n"); + printf("** Driver run for fromFP_DoubleTo_Real:\n"); + printf("=======================================\n"); + fromFP_DoubleTo_Real_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_SWord32_SFloat:\n"); + printf("========================================\n"); + fromFP_SWord32_SFloat_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_SWord64_SDouble:\n"); + printf("=========================================\n"); + fromFP_SWord64_SDouble_driver(); + + printf("========================================\n"); + printf("** Driver run for fromFP_SFloat_SWord32:\n"); + printf("========================================\n"); + fromFP_SFloat_SWord32_driver(); + + printf("=========================================\n"); + printf("** Driver run for fromFP_SDouble_SWord64:\n"); + printf("=========================================\n"); + fromFP_SDouble_SWord64_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Abs:\n"); + printf("===========================\n"); + f_FP_Abs_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Abs:\n"); + printf("===========================\n"); + d_FP_Abs_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Neg:\n"); + printf("===========================\n"); + f_FP_Neg_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Neg:\n"); + printf("===========================\n"); + d_FP_Neg_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Add:\n"); + printf("===========================\n"); + f_FP_Add_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Add:\n"); + printf("===========================\n"); + d_FP_Add_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Sub:\n"); + printf("===========================\n"); + f_FP_Sub_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Sub:\n"); + printf("===========================\n"); + d_FP_Sub_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Mul:\n"); + printf("===========================\n"); + f_FP_Mul_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Mul:\n"); + printf("===========================\n"); + d_FP_Mul_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Div:\n"); + printf("===========================\n"); + f_FP_Div_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Div:\n"); + printf("===========================\n"); + d_FP_Div_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_FMA:\n"); + printf("===========================\n"); + f_FP_FMA_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_FMA:\n"); + printf("===========================\n"); + d_FP_FMA_driver(); + + printf("============================\n"); + printf("** Driver run for f_FP_Sqrt:\n"); + printf("============================\n"); + f_FP_Sqrt_driver(); + + printf("============================\n"); + printf("** Driver run for d_FP_Sqrt:\n"); + printf("============================\n"); + d_FP_Sqrt_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Rem:\n"); + printf("===========================\n"); + f_FP_Rem_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Rem:\n"); + printf("===========================\n"); + d_FP_Rem_driver(); + + printf("=======================================\n"); + printf("** Driver run for f_FP_RoundToIntegral:\n"); + printf("=======================================\n"); + f_FP_RoundToIntegral_driver(); + + printf("=======================================\n"); + printf("** Driver run for d_FP_RoundToIntegral:\n"); + printf("=======================================\n"); + d_FP_RoundToIntegral_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Min:\n"); + printf("===========================\n"); + f_FP_Min_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Min:\n"); + printf("===========================\n"); + d_FP_Min_driver(); + + printf("===========================\n"); + printf("** Driver run for f_FP_Max:\n"); + printf("===========================\n"); + f_FP_Max_driver(); + + printf("===========================\n"); + printf("** Driver run for d_FP_Max:\n"); + printf("===========================\n"); + d_FP_Max_driver(); + + printf("=====================================\n"); + printf("** Driver run for f_FP_IsEqualObject:\n"); + printf("=====================================\n"); + f_FP_IsEqualObject_driver(); + + printf("=====================================\n"); + printf("** Driver run for d_FP_IsEqualObject:\n"); + printf("=====================================\n"); + d_FP_IsEqualObject_driver(); + + printf("================================\n"); + printf("** Driver run for f_FP_IsNormal:\n"); + printf("================================\n"); + f_FP_IsNormal_driver(); + + printf("================================\n"); + printf("** Driver run for d_FP_IsNormal:\n"); + printf("================================\n"); + d_FP_IsNormal_driver(); + + printf("==============================\n"); + printf("** Driver run for f_FP_IsZero:\n"); + printf("==============================\n"); + f_FP_IsZero_driver(); + + printf("==============================\n"); + printf("** Driver run for d_FP_IsZero:\n"); + printf("==============================\n"); + d_FP_IsZero_driver(); + + printf("===================================\n"); + printf("** Driver run for f_FP_IsSubnormal:\n"); + printf("===================================\n"); + f_FP_IsSubnormal_driver(); + + printf("===================================\n"); + printf("** Driver run for d_FP_IsSubnormal:\n"); + printf("===================================\n"); + d_FP_IsSubnormal_driver(); + + printf("==================================\n"); + printf("** Driver run for f_FP_IsInfinite:\n"); + printf("==================================\n"); + f_FP_IsInfinite_driver(); + + printf("==================================\n"); + printf("** Driver run for d_FP_IsInfinite:\n"); + printf("==================================\n"); + d_FP_IsInfinite_driver(); + + printf("=============================\n"); + printf("** Driver run for f_FP_IsNaN:\n"); + printf("=============================\n"); + f_FP_IsNaN_driver(); + + printf("=============================\n"); + printf("** Driver run for d_FP_IsNaN:\n"); + printf("=============================\n"); + d_FP_IsNaN_driver(); + + printf("==================================\n"); + printf("** Driver run for f_FP_IsNegative:\n"); + printf("==================================\n"); + f_FP_IsNegative_driver(); + + printf("==================================\n"); + printf("** Driver run for d_FP_IsNegative:\n"); + printf("==================================\n"); + d_FP_IsNegative_driver(); + + printf("==================================\n"); + printf("** Driver run for f_FP_IsPositive:\n"); + printf("==================================\n"); + f_FP_IsPositive_driver(); + + printf("==================================\n"); + printf("** Driver run for d_FP_IsPositive:\n"); + printf("==================================\n"); + d_FP_IsPositive_driver(); + + return 0; +} +== END: "floatCodeGen_driver.c" ================== +== BEGIN: "Makefile" ================ +# Makefile for floatCodeGen. Automatically generated by SBV. Do not edit! + +# include any user-defined .mk file in the current directory. +-include *.mk + +CC?=gcc +CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer +SBV_LIBS?=-lm -lbf +AR?=ar +ARFLAGS?=cr + +all: floatCodeGen.a floatCodeGen_driver + +floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o + rm -f $@.tmp + ${AR} ${ARFLAGS} $@.tmp $^ + mv -f $@.tmp $@ + +floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h floatCodeGen.a + ${CC} ${CCFLAGS} -ffp-contract=off $< -o $@ floatCodeGen.a ${LDFLAGS} ${SBV_LIBS} + +toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Add.o: f_FP_Add.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Add.o: d_FP_Add.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Div.o: f_FP_Div.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Div.o: d_FP_Div.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Min.o: f_FP_Min.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Min.o: d_FP_Min.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_Max.o: f_FP_Max.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_Max.o: d_FP_Max.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h + ${CC} ${CCFLAGS} -ffp-contract=off -c $< -o $@ + +clean: + rm -f *.o + +veryclean: clean + rm -f floatCodeGen.a floatCodeGen_driver floatCodeGen.a.tmp == END: "Makefile" ================== diff --git a/SBVTestSuite/GoldFiles/gcd.gold b/SBVTestSuite/GoldFiles/gcd.gold --- a/SBVTestSuite/GoldFiles/gcd.gold +++ b/SBVTestSuite/GoldFiles/gcd.gold @@ -12,11 +12,11 @@ sgcd.o: sgcd.c sgcd.h ${CC} ${CCFLAGS} -c $< -o $@ -sgcd_driver.o: sgcd_driver.c +sgcd_driver.o: sgcd_driver.c sgcd.h ${CC} ${CCFLAGS} -c $< -o $@ sgcd_driver: sgcd.o sgcd_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "sgcd.h" ================ /* Header file for sgcd. Automatically generated by SBV. Do not edit! */ -#ifndef __sgcd__HEADER_INCLUDED__ -#define __sgcd__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_sgcd_HEADER_INCLUDED +#define SBV_GENERATED_sgcd_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord8 sgcd(const SWord8 x, const SWord8 y); -#endif /* __sgcd__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_sgcd_HEADER_INCLUDED */ == END: "sgcd.h" ================== == BEGIN: "sgcd_driver.c" ================ /* Example driver program for sgcd. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord8 __result = sgcd(55, 154); + const SWord8 sbv_result = sgcd(55, 154); - printf("sgcd(55, 154) = %"PRIu8"\n", __result); + printf("sgcd(55, 154) = %"PRIu8"\n", sbv_result); return 0; } @@ -85,42 +93,58 @@ #include "sgcd.h" -SWord8 sgcd(const SWord8 x, const SWord8 y) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_rem(SWord8 a, SWord8 b) { - const SWord8 s0 = x; - const SWord8 s1 = y; + if (b == (SWord8) 0) return a; + return (SWord8) (a % b); +} + + +SWord8 sgcd(const SWord8 sbv_input_0, const SWord8 sbv_input_1) +{ + const SWord8 s0 = sbv_input_0; + const SWord8 s1 = sbv_input_1; const SBool s3 = s1 == 0; - const SWord8 s4 = (s1 == 0) ? s0 : (s0 % s1); + const SWord8 s4 = sbv_bv_u8_rem(s0, s1); const SWord8 s5 = s3 ? s0 : s4; const SBool s6 = 0 == s5; - const SWord8 s7 = (s5 == 0) ? s1 : (s1 % s5); + const SWord8 s7 = sbv_bv_u8_rem(s1, s5); const SWord8 s8 = s6 ? s1 : s7; const SBool s9 = 0 == s8; - const SWord8 s10 = (s8 == 0) ? s5 : (s5 % s8); + const SWord8 s10 = sbv_bv_u8_rem(s5, s8); const SWord8 s11 = s9 ? s5 : s10; const SBool s12 = 0 == s11; - const SWord8 s13 = (s11 == 0) ? s8 : (s8 % s11); + const SWord8 s13 = sbv_bv_u8_rem(s8, s11); const SWord8 s14 = s12 ? s8 : s13; const SBool s15 = 0 == s14; - const SWord8 s16 = (s14 == 0) ? s11 : (s11 % s14); + const SWord8 s16 = sbv_bv_u8_rem(s11, s14); const SWord8 s17 = s15 ? s11 : s16; const SBool s18 = 0 == s17; - const SWord8 s19 = (s17 == 0) ? s14 : (s14 % s17); + const SWord8 s19 = sbv_bv_u8_rem(s14, s17); const SWord8 s20 = s18 ? s14 : s19; const SBool s21 = 0 == s20; - const SWord8 s22 = (s20 == 0) ? s17 : (s17 % s20); + const SWord8 s22 = sbv_bv_u8_rem(s17, s20); const SWord8 s23 = s21 ? s17 : s22; const SBool s24 = 0 == s23; - const SWord8 s25 = (s23 == 0) ? s20 : (s20 % s23); + const SWord8 s25 = sbv_bv_u8_rem(s20, s23); const SWord8 s26 = s24 ? s20 : s25; const SBool s27 = 0 == s26; - const SWord8 s28 = (s26 == 0) ? s23 : (s23 % s26); + const SWord8 s28 = sbv_bv_u8_rem(s23, s26); const SWord8 s29 = s27 ? s23 : s28; const SBool s30 = 0 == s29; - const SWord8 s31 = (s29 == 0) ? s26 : (s26 % s29); + const SWord8 s31 = sbv_bv_u8_rem(s26, s29); const SWord8 s32 = s30 ? s26 : s31; const SBool s33 = 0 == s32; - const SWord8 s34 = (s32 == 0) ? s29 : (s29 % s32); + const SWord8 s34 = sbv_bv_u8_rem(s29, s32); const SWord8 s35 = s33 ? s29 : s34; const SBool s36 = 0 == s35; const SWord8 s37 = s36 ? s32 : s35; diff --git a/SBVTestSuite/GoldFiles/legato_c.gold b/SBVTestSuite/GoldFiles/legato_c.gold --- a/SBVTestSuite/GoldFiles/legato_c.gold +++ b/SBVTestSuite/GoldFiles/legato_c.gold @@ -12,6414 +12,6460 @@ 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 -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* Entry point prototype: */ -void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi, - SWord8 *lo); - -#endif /* __legatoMult__HEADER_INCLUDED__ */ -== END: "legatoMult.h" ================== -== BEGIN: "legatoMult_driver.c" ================ -/* Example driver program for legatoMult. */ -/* Automatically generated by SBV. Edit as you see fit! */ - -#include -#include "legatoMult.h" - -int main(void) -{ - SWord8 hi; - SWord8 lo; - - legatoMult(87, 92, &hi, &lo); - - printf("legatoMult(87, 92, &hi, &lo) ->\n"); - printf(" hi = %"PRIu8"\n", hi); - printf(" lo = %"PRIu8"\n", lo); - - return 0; -} -== END: "legatoMult_driver.c" ================== -== BEGIN: "legatoMult.c" ================ -/* File: "legatoMult.c". Automatically generated by SBV. Do not edit! */ - -#include "legatoMult.h" - -void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi, - SWord8 *lo) -{ - const SWord8 s0 = x; - const SWord8 s1 = y; - const SBool s2 = (SBool) (s0 & 1); - const SBool s4 = s2 != false; - const SBool s5 = !s4; - const SWord8 s6 = (s0 >> 1) | (s0 << 7); - const SWord8 s8 = s6 & 127; - const SBool s9 = (SBool) (s8 & 1); - const SBool s10 = false != s9; - const SBool s11 = !s10; - const SWord8 s12 = (s8 >> 1) | (s8 << 7); - const SWord8 s13 = 127 & s12; - const SBool s14 = (SBool) (s13 & 1); - const SBool s15 = false != s14; - const SBool s16 = !s15; - const SWord8 s17 = (s13 >> 1) | (s13 << 7); - const SWord8 s18 = 127 & s17; - const SBool s19 = (SBool) (s18 & 1); - const SBool s20 = false != s19; - const SBool s21 = !s20; - const SWord8 s24 = s4 ? 128 : 0; - const SBool s25 = (SBool) (s24 & 1); - const SBool s26 = false != s25; - const SWord8 s27 = s26 ? 128 : 0; - const SBool s28 = (SBool) (s27 & 1); - const SBool s29 = false != s28; - const SWord8 s30 = (s18 >> 1) | (s18 << 7); - const SWord8 s31 = 128 | s30; - const SWord8 s32 = 127 & s30; - const SWord8 s33 = s29 ? s31 : s32; - const SBool s34 = (SBool) (s33 & 1); - const SBool s35 = false != s34; - const SBool s36 = !s35; - const SWord8 s37 = (s24 >> 1) | (s24 << 7); - const SWord8 s38 = 128 | s37; - const SWord8 s39 = 127 & s37; - const SWord8 s40 = s10 ? s38 : s39; - const SBool s41 = (SBool) (s40 & 1); - const SBool s42 = false != s41; - const SWord8 s43 = (s27 >> 1) | (s27 << 7); - const SWord8 s44 = 128 | s43; - const SWord8 s45 = 127 & s43; - const SWord8 s46 = s42 ? s44 : s45; - const SBool s47 = (SBool) (s46 & 1); - const SBool s48 = false != s47; - const SWord8 s49 = (s33 >> 1) | (s33 << 7); - const SWord8 s50 = 128 | s49; - const SWord8 s51 = 127 & s49; - const SWord8 s52 = s48 ? s50 : s51; - const SBool s53 = (SBool) (s52 & 1); - const SBool s54 = false != s53; - const SBool s55 = !s54; - const SWord8 s56 = (s40 >> 1) | (s40 << 7); - const SWord8 s57 = 128 | s56; - const SWord8 s58 = 127 & s56; - const SWord8 s59 = s15 ? s57 : s58; - const SBool s60 = (SBool) (s59 & 1); - const SBool s61 = false != s60; - const SWord8 s62 = (s46 >> 1) | (s46 << 7); - const SWord8 s63 = 128 | s62; - const SWord8 s64 = 127 & s62; - const SWord8 s65 = s61 ? s63 : s64; - const SBool s66 = (SBool) (s65 & 1); - const SBool s67 = false != s66; - const SWord8 s68 = (s52 >> 1) | (s52 << 7); - const SWord8 s69 = 128 | s68; - const SWord8 s70 = 127 & s68; - const SWord8 s71 = s67 ? s69 : s70; - const SBool s72 = (SBool) (s71 & 1); - const SBool s73 = false != s72; - const SBool s74 = !s73; - const SWord8 s75 = (s59 >> 1) | (s59 << 7); - const SWord8 s76 = 128 | s75; - const SWord8 s77 = 127 & s75; - const SWord8 s78 = s20 ? s76 : s77; - const SBool s79 = (SBool) (s78 & 1); - const SBool s80 = false != s79; - const SWord8 s81 = (s65 >> 1) | (s65 << 7); - const SWord8 s82 = 128 | s81; - const SWord8 s83 = 127 & s81; - const SWord8 s84 = s80 ? s82 : s83; - const SBool s85 = (SBool) (s84 & 1); - const SBool s86 = false != s85; - const SWord8 s87 = (s71 >> 1) | (s71 << 7); - const SWord8 s88 = 128 | s87; - const SWord8 s89 = 127 & s87; - const SWord8 s90 = s86 ? s88 : s89; - const SBool s91 = (SBool) (s90 & 1); - const SBool s92 = false != s91; - const SBool s93 = !s92; - const SWord8 s94 = (s78 >> 1) | (s78 << 7); - const SWord8 s95 = 128 | s94; - const SWord8 s96 = 127 & s94; - const SWord8 s97 = s35 ? s95 : s96; - const SWord8 s98 = (s97 >> 1) | (s97 << 7); - const SWord8 s99 = 128 | s98; - const SWord8 s100 = 127 & s98; - const SWord8 s101 = s54 ? s99 : s100; - const SWord8 s102 = (s101 >> 1) | (s101 << 7); - const SWord8 s103 = 128 | s102; - const SWord8 s104 = 127 & s102; - const SWord8 s105 = s73 ? s103 : s104; - const SWord8 s106 = (s105 >> 1) | (s105 << 7); - const SWord8 s107 = 128 | s106; - const SWord8 s108 = 127 & s106; - const SWord8 s109 = s92 ? s107 : s108; - const SWord8 s110 = s1 + s105; - const SBool s111 = s110 < s1; - const SBool s112 = s110 < s105; - const SBool s113 = s111 || s112; - const SWord8 s114 = (s110 >> 1) | (s110 << 7); - const SWord8 s115 = 128 | s114; - const SWord8 s116 = 127 & s114; - const SWord8 s117 = s113 ? s115 : s116; - const SWord8 s118 = s93 ? s109 : s117; - const SWord8 s119 = s1 + s101; - const SBool s120 = s119 < s1; - const SBool s121 = s119 < s101; - const SBool s122 = s120 || s121; - const SWord8 s123 = (s119 >> 1) | (s119 << 7); - const SWord8 s124 = 128 | s123; - const SWord8 s125 = 127 & s123; - const SWord8 s126 = s122 ? s124 : s125; - const SWord8 s127 = (s126 >> 1) | (s126 << 7); - const SWord8 s128 = 128 | s127; - const SWord8 s129 = 127 & s127; - const SWord8 s130 = s92 ? s128 : s129; - const SWord8 s131 = s1 + s126; - const SBool s132 = s131 < s1; - const SBool s133 = s131 < s126; - const SBool s134 = s132 || s133; - const SWord8 s135 = (s131 >> 1) | (s131 << 7); - const SWord8 s136 = 128 | s135; - const SWord8 s137 = 127 & s135; - const SWord8 s138 = s134 ? s136 : s137; - const SWord8 s139 = s93 ? s130 : s138; - const SWord8 s140 = s74 ? s118 : s139; - const SWord8 s141 = s1 + s97; - const SBool s142 = s141 < s1; - const SBool s143 = s141 < s97; - const SBool s144 = s142 || s143; - const SWord8 s145 = (s141 >> 1) | (s141 << 7); - const SWord8 s146 = 128 | s145; - const SWord8 s147 = 127 & s145; - const SWord8 s148 = s144 ? s146 : s147; - const SWord8 s149 = (s148 >> 1) | (s148 << 7); - const SWord8 s150 = 128 | s149; - const SWord8 s151 = 127 & s149; - const SWord8 s152 = s73 ? s150 : s151; - const SWord8 s153 = (s152 >> 1) | (s152 << 7); - const SWord8 s154 = 128 | s153; - const SWord8 s155 = 127 & s153; - const SWord8 s156 = s92 ? s154 : s155; - const SWord8 s157 = s1 + s152; - const SBool s158 = s157 < s1; - const SBool s159 = s157 < s152; - const SBool s160 = s158 || s159; - const SWord8 s161 = (s157 >> 1) | (s157 << 7); - const SWord8 s162 = 128 | s161; - const SWord8 s163 = 127 & s161; - const SWord8 s164 = s160 ? s162 : s163; - const SWord8 s165 = s93 ? s156 : s164; - const SWord8 s166 = s1 + s148; - const SBool s167 = s166 < s1; - const SBool s168 = s166 < s148; - const SBool s169 = s167 || s168; - const SWord8 s170 = (s166 >> 1) | (s166 << 7); - const SWord8 s171 = 128 | s170; - const SWord8 s172 = 127 & s170; - const SWord8 s173 = s169 ? s171 : s172; - const SWord8 s174 = (s173 >> 1) | (s173 << 7); - const SWord8 s175 = 128 | s174; - const SWord8 s176 = 127 & s174; - const SWord8 s177 = s92 ? s175 : s176; - const SWord8 s178 = s1 + s173; - const SBool s179 = s178 < s1; - const SBool s180 = s178 < s173; - const SBool s181 = s179 || s180; - const SWord8 s182 = (s178 >> 1) | (s178 << 7); - const SWord8 s183 = 128 | s182; - const SWord8 s184 = 127 & s182; - const SWord8 s185 = s181 ? s183 : s184; - const SWord8 s186 = s93 ? s177 : s185; - const SWord8 s187 = s74 ? s165 : s186; - const SWord8 s188 = s55 ? s140 : s187; - const SWord8 s189 = s1 + s78; - const SBool s190 = (SBool) (s189 & 1); - const SBool s191 = false != s190; - const SWord8 s192 = s191 ? s82 : s83; - const SBool s193 = (SBool) (s192 & 1); - const SBool s194 = false != s193; - const SWord8 s195 = s194 ? s88 : s89; - const SBool s196 = (SBool) (s195 & 1); - const SBool s197 = false != s196; - const SBool s198 = !s197; - const SBool s199 = s189 < s1; - const SBool s200 = s189 < s78; - const SBool s201 = s199 || s200; - const SWord8 s202 = (s189 >> 1) | (s189 << 7); - const SWord8 s203 = 128 | s202; - const SWord8 s204 = 127 & s202; - const SWord8 s205 = s201 ? s203 : s204; - const SWord8 s206 = (s205 >> 1) | (s205 << 7); - const SWord8 s207 = 128 | s206; - const SWord8 s208 = 127 & s206; - const SWord8 s209 = s54 ? s207 : s208; - const SWord8 s210 = (s209 >> 1) | (s209 << 7); - const SWord8 s211 = 128 | s210; - const SWord8 s212 = 127 & s210; - const SWord8 s213 = s73 ? s211 : s212; - const SWord8 s214 = (s213 >> 1) | (s213 << 7); - const SWord8 s215 = 128 | s214; - const SWord8 s216 = 127 & s214; - const SWord8 s217 = s197 ? s215 : s216; - const SWord8 s218 = s1 + s213; - const SBool s219 = s218 < s1; - const SBool s220 = s218 < s213; - const SBool s221 = s219 || s220; - const SWord8 s222 = (s218 >> 1) | (s218 << 7); - const SWord8 s223 = 128 | s222; - const SWord8 s224 = 127 & s222; - const SWord8 s225 = s221 ? s223 : s224; - const SWord8 s226 = s198 ? s217 : s225; - const SWord8 s227 = s1 + s209; - const SBool s228 = s227 < s1; - const SBool s229 = s227 < s209; - const SBool s230 = s228 || s229; - const SWord8 s231 = (s227 >> 1) | (s227 << 7); - const SWord8 s232 = 128 | s231; - const SWord8 s233 = 127 & s231; - const SWord8 s234 = s230 ? s232 : s233; - const SWord8 s235 = (s234 >> 1) | (s234 << 7); - const SWord8 s236 = 128 | s235; - const SWord8 s237 = 127 & s235; - const SWord8 s238 = s197 ? s236 : s237; - const SWord8 s239 = s1 + s234; - const SBool s240 = s239 < s1; - const SBool s241 = s239 < s234; - const SBool s242 = s240 || s241; - const SWord8 s243 = (s239 >> 1) | (s239 << 7); - const SWord8 s244 = 128 | s243; - const SWord8 s245 = 127 & s243; - const SWord8 s246 = s242 ? s244 : s245; - const SWord8 s247 = s198 ? s238 : s246; - const SWord8 s248 = s74 ? s226 : s247; - const SWord8 s249 = s1 + s205; - const SBool s250 = s249 < s1; - const SBool s251 = s249 < s205; - const SBool s252 = s250 || s251; - const SWord8 s253 = (s249 >> 1) | (s249 << 7); - const SWord8 s254 = 128 | s253; - const SWord8 s255 = 127 & s253; - const SWord8 s256 = s252 ? s254 : s255; - const SWord8 s257 = (s256 >> 1) | (s256 << 7); - const SWord8 s258 = 128 | s257; - const SWord8 s259 = 127 & s257; - const SWord8 s260 = s73 ? s258 : s259; - const SWord8 s261 = (s260 >> 1) | (s260 << 7); - const SWord8 s262 = 128 | s261; - const SWord8 s263 = 127 & s261; - const SWord8 s264 = s197 ? s262 : s263; - const SWord8 s265 = s1 + s260; - const SBool s266 = s265 < s1; - const SBool s267 = s265 < s260; - const SBool s268 = s266 || s267; - const SWord8 s269 = (s265 >> 1) | (s265 << 7); - const SWord8 s270 = 128 | s269; - const SWord8 s271 = 127 & s269; - const SWord8 s272 = s268 ? s270 : s271; - const SWord8 s273 = s198 ? s264 : s272; - const SWord8 s274 = s1 + s256; - const SBool s275 = s274 < s1; - const SBool s276 = s274 < s256; - const SBool s277 = s275 || s276; - const SWord8 s278 = (s274 >> 1) | (s274 << 7); - const SWord8 s279 = 128 | s278; - const SWord8 s280 = 127 & s278; - const SWord8 s281 = s277 ? s279 : s280; - const SWord8 s282 = (s281 >> 1) | (s281 << 7); - const SWord8 s283 = 128 | s282; - const SWord8 s284 = 127 & s282; - const SWord8 s285 = s197 ? s283 : s284; - const SWord8 s286 = s1 + s281; - const SBool s287 = s286 < s1; - const SBool s288 = s286 < s281; - const SBool s289 = s287 || s288; - const SWord8 s290 = (s286 >> 1) | (s286 << 7); - const SWord8 s291 = 128 | s290; - const SWord8 s292 = 127 & s290; - const SWord8 s293 = s289 ? s291 : s292; - const SWord8 s294 = s198 ? s285 : s293; - const SWord8 s295 = s74 ? s273 : s294; - const SWord8 s296 = s55 ? s248 : s295; - const SWord8 s297 = s36 ? s188 : s296; - const SWord8 s298 = s1 + s59; - const SBool s299 = (SBool) (s298 & 1); - const SBool s300 = false != s299; - const SWord8 s301 = s300 ? s63 : s64; - const SBool s302 = (SBool) (s301 & 1); - const SBool s303 = false != s302; - const SWord8 s304 = s303 ? s69 : s70; - const SBool s305 = (SBool) (s304 & 1); - const SBool s306 = false != s305; - const SBool s307 = !s306; - const SBool s308 = s298 < s1; - const SBool s309 = s298 < s59; - const SBool s310 = s308 || s309; - const SWord8 s311 = (s298 >> 1) | (s298 << 7); - const SWord8 s312 = 128 | s311; - const SWord8 s313 = 127 & s311; - const SWord8 s314 = s310 ? s312 : s313; - const SBool s315 = (SBool) (s314 & 1); - const SBool s316 = false != s315; - const SWord8 s317 = (s301 >> 1) | (s301 << 7); - const SWord8 s318 = 128 | s317; - const SWord8 s319 = 127 & s317; - const SWord8 s320 = s316 ? s318 : s319; - const SBool s321 = (SBool) (s320 & 1); - const SBool s322 = false != s321; - const SWord8 s323 = (s304 >> 1) | (s304 << 7); - const SWord8 s324 = 128 | s323; - const SWord8 s325 = 127 & s323; - const SWord8 s326 = s322 ? s324 : s325; - const SBool s327 = (SBool) (s326 & 1); - const SBool s328 = false != s327; - const SBool s329 = !s328; - const SWord8 s330 = (s314 >> 1) | (s314 << 7); - const SWord8 s331 = 128 | s330; - const SWord8 s332 = 127 & s330; - const SWord8 s333 = s35 ? s331 : s332; - const SWord8 s334 = (s333 >> 1) | (s333 << 7); - const SWord8 s335 = 128 | s334; - const SWord8 s336 = 127 & s334; - const SWord8 s337 = s54 ? s335 : s336; - const SWord8 s338 = (s337 >> 1) | (s337 << 7); - const SWord8 s339 = 128 | s338; - const SWord8 s340 = 127 & s338; - const SWord8 s341 = s306 ? s339 : s340; - const SWord8 s342 = (s341 >> 1) | (s341 << 7); - const SWord8 s343 = 128 | s342; - const SWord8 s344 = 127 & s342; - const SWord8 s345 = s328 ? s343 : s344; - const SWord8 s346 = s1 + s341; - const SBool s347 = s346 < s1; - const SBool s348 = s346 < s341; - const SBool s349 = s347 || s348; - const SWord8 s350 = (s346 >> 1) | (s346 << 7); - const SWord8 s351 = 128 | s350; - const SWord8 s352 = 127 & s350; - const SWord8 s353 = s349 ? s351 : s352; - const SWord8 s354 = s329 ? s345 : s353; - const SWord8 s355 = s1 + s337; - const SBool s356 = s355 < s1; - const SBool s357 = s355 < s337; - const SBool s358 = s356 || s357; - const SWord8 s359 = (s355 >> 1) | (s355 << 7); - const SWord8 s360 = 128 | s359; - const SWord8 s361 = 127 & s359; - const SWord8 s362 = s358 ? s360 : s361; - const SWord8 s363 = (s362 >> 1) | (s362 << 7); - const SWord8 s364 = 128 | s363; - const SWord8 s365 = 127 & s363; - const SWord8 s366 = s328 ? s364 : s365; - const SWord8 s367 = s1 + s362; - const SBool s368 = s367 < s1; - const SBool s369 = s367 < s362; - const SBool s370 = s368 || s369; - const SWord8 s371 = (s367 >> 1) | (s367 << 7); - const SWord8 s372 = 128 | s371; - const SWord8 s373 = 127 & s371; - const SWord8 s374 = s370 ? s372 : s373; - const SWord8 s375 = s329 ? s366 : s374; - const SWord8 s376 = s307 ? s354 : s375; - const SWord8 s377 = s1 + s333; - const SBool s378 = s377 < s1; - const SBool s379 = s377 < s333; - const SBool s380 = s378 || s379; - const SWord8 s381 = (s377 >> 1) | (s377 << 7); - const SWord8 s382 = 128 | s381; - const SWord8 s383 = 127 & s381; - const SWord8 s384 = s380 ? s382 : s383; - const SWord8 s385 = (s384 >> 1) | (s384 << 7); - const SWord8 s386 = 128 | s385; - const SWord8 s387 = 127 & s385; - const SWord8 s388 = s306 ? s386 : s387; - const SWord8 s389 = (s388 >> 1) | (s388 << 7); - const SWord8 s390 = 128 | s389; - const SWord8 s391 = 127 & s389; - const SWord8 s392 = s328 ? s390 : s391; - const SWord8 s393 = s1 + s388; - const SBool s394 = s393 < s1; - const SBool s395 = s393 < s388; - const SBool s396 = s394 || s395; - const SWord8 s397 = (s393 >> 1) | (s393 << 7); - const SWord8 s398 = 128 | s397; - const SWord8 s399 = 127 & s397; - const SWord8 s400 = s396 ? s398 : s399; - const SWord8 s401 = s329 ? s392 : s400; - const SWord8 s402 = s1 + s384; - const SBool s403 = s402 < s1; - const SBool s404 = s402 < s384; - const SBool s405 = s403 || s404; - const SWord8 s406 = (s402 >> 1) | (s402 << 7); - const SWord8 s407 = 128 | s406; - const SWord8 s408 = 127 & s406; - const SWord8 s409 = s405 ? s407 : s408; - const SWord8 s410 = (s409 >> 1) | (s409 << 7); - const SWord8 s411 = 128 | s410; - const SWord8 s412 = 127 & s410; - const SWord8 s413 = s328 ? s411 : s412; - const SWord8 s414 = s1 + s409; - const SBool s415 = s414 < s1; - const SBool s416 = s414 < s409; - const SBool s417 = s415 || s416; - const SWord8 s418 = (s414 >> 1) | (s414 << 7); - const SWord8 s419 = 128 | s418; - const SWord8 s420 = 127 & s418; - const SWord8 s421 = s417 ? s419 : s420; - const SWord8 s422 = s329 ? s413 : s421; - const SWord8 s423 = s307 ? s401 : s422; - const SWord8 s424 = s55 ? s376 : s423; - const SWord8 s425 = s1 + s314; - const SBool s426 = (SBool) (s425 & 1); - const SBool s427 = false != s426; - const SWord8 s428 = s427 ? s318 : s319; - const SBool s429 = (SBool) (s428 & 1); - const SBool s430 = false != s429; - const SWord8 s431 = s430 ? s324 : s325; - const SBool s432 = (SBool) (s431 & 1); - const SBool s433 = false != s432; - const SBool s434 = !s433; - const SBool s435 = s425 < s1; - const SBool s436 = s425 < s314; - const SBool s437 = s435 || s436; - const SWord8 s438 = (s425 >> 1) | (s425 << 7); - const SWord8 s439 = 128 | s438; - const SWord8 s440 = 127 & s438; - const SWord8 s441 = s437 ? s439 : s440; - const SWord8 s442 = (s441 >> 1) | (s441 << 7); - const SWord8 s443 = 128 | s442; - const SWord8 s444 = 127 & s442; - const SWord8 s445 = s54 ? s443 : s444; - const SWord8 s446 = (s445 >> 1) | (s445 << 7); - const SWord8 s447 = 128 | s446; - const SWord8 s448 = 127 & s446; - const SWord8 s449 = s306 ? s447 : s448; - const SWord8 s450 = (s449 >> 1) | (s449 << 7); - const SWord8 s451 = 128 | s450; - const SWord8 s452 = 127 & s450; - const SWord8 s453 = s433 ? s451 : s452; - const SWord8 s454 = s1 + s449; - const SBool s455 = s454 < s1; - const SBool s456 = s454 < s449; - const SBool s457 = s455 || s456; - const SWord8 s458 = (s454 >> 1) | (s454 << 7); - const SWord8 s459 = 128 | s458; - const SWord8 s460 = 127 & s458; - const SWord8 s461 = s457 ? s459 : s460; - const SWord8 s462 = s434 ? s453 : s461; - const SWord8 s463 = s1 + s445; - const SBool s464 = s463 < s1; - const SBool s465 = s463 < s445; - const SBool s466 = s464 || s465; - const SWord8 s467 = (s463 >> 1) | (s463 << 7); - const SWord8 s468 = 128 | s467; - const SWord8 s469 = 127 & s467; - const SWord8 s470 = s466 ? s468 : s469; - const SWord8 s471 = (s470 >> 1) | (s470 << 7); - const SWord8 s472 = 128 | s471; - const SWord8 s473 = 127 & s471; - const SWord8 s474 = s433 ? s472 : s473; - const SWord8 s475 = s1 + s470; - const SBool s476 = s475 < s1; - const SBool s477 = s475 < s470; - const SBool s478 = s476 || s477; - const SWord8 s479 = (s475 >> 1) | (s475 << 7); - const SWord8 s480 = 128 | s479; - const SWord8 s481 = 127 & s479; - const SWord8 s482 = s478 ? s480 : s481; - const SWord8 s483 = s434 ? s474 : s482; - const SWord8 s484 = s307 ? s462 : s483; - const SWord8 s485 = s1 + s441; - const SBool s486 = s485 < s1; - const SBool s487 = s485 < s441; - const SBool s488 = s486 || s487; - const SWord8 s489 = (s485 >> 1) | (s485 << 7); - const SWord8 s490 = 128 | s489; - const SWord8 s491 = 127 & s489; - const SWord8 s492 = s488 ? s490 : s491; - const SWord8 s493 = (s492 >> 1) | (s492 << 7); - const SWord8 s494 = 128 | s493; - const SWord8 s495 = 127 & s493; - const SWord8 s496 = s306 ? s494 : s495; - const SWord8 s497 = (s496 >> 1) | (s496 << 7); - const SWord8 s498 = 128 | s497; - const SWord8 s499 = 127 & s497; - const SWord8 s500 = s433 ? s498 : s499; - const SWord8 s501 = s1 + s496; - const SBool s502 = s501 < s1; - const SBool s503 = s501 < s496; - const SBool s504 = s502 || s503; - const SWord8 s505 = (s501 >> 1) | (s501 << 7); - const SWord8 s506 = 128 | s505; - const SWord8 s507 = 127 & s505; - const SWord8 s508 = s504 ? s506 : s507; - const SWord8 s509 = s434 ? s500 : s508; - const SWord8 s510 = s1 + s492; - const SBool s511 = s510 < s1; - const SBool s512 = s510 < s492; - const SBool s513 = s511 || s512; - const SWord8 s514 = (s510 >> 1) | (s510 << 7); - const SWord8 s515 = 128 | s514; - const SWord8 s516 = 127 & s514; - const SWord8 s517 = s513 ? s515 : s516; - const SWord8 s518 = (s517 >> 1) | (s517 << 7); - const SWord8 s519 = 128 | s518; - const SWord8 s520 = 127 & s518; - const SWord8 s521 = s433 ? s519 : s520; - const SWord8 s522 = s1 + s517; - const SBool s523 = s522 < s1; - const SBool s524 = s522 < s517; - const SBool s525 = s523 || s524; - const SWord8 s526 = (s522 >> 1) | (s522 << 7); - const SWord8 s527 = 128 | s526; - const SWord8 s528 = 127 & s526; - const SWord8 s529 = s525 ? s527 : s528; - const SWord8 s530 = s434 ? s521 : s529; - const SWord8 s531 = s307 ? s509 : s530; - const SWord8 s532 = s55 ? s484 : s531; - const SWord8 s533 = s36 ? s424 : s532; - const SWord8 s534 = s21 ? s297 : s533; - const SWord8 s535 = s1 + s40; - const SBool s536 = (SBool) (s535 & 1); - const SBool s537 = false != s536; - const SWord8 s538 = s537 ? s44 : s45; - const SBool s539 = (SBool) (s538 & 1); - const SBool s540 = false != s539; - const SWord8 s541 = s540 ? s50 : s51; - const SBool s542 = (SBool) (s541 & 1); - const SBool s543 = false != s542; - const SBool s544 = !s543; - const SBool s545 = s535 < s1; - const SBool s546 = s535 < s40; - const SBool s547 = s545 || s546; - const SWord8 s548 = (s535 >> 1) | (s535 << 7); - const SWord8 s549 = 128 | s548; - const SWord8 s550 = 127 & s548; - const SWord8 s551 = s547 ? s549 : s550; - const SBool s552 = (SBool) (s551 & 1); - const SBool s553 = false != s552; - const SWord8 s554 = (s538 >> 1) | (s538 << 7); - const SWord8 s555 = 128 | s554; - const SWord8 s556 = 127 & s554; - const SWord8 s557 = s553 ? s555 : s556; - const SBool s558 = (SBool) (s557 & 1); - const SBool s559 = false != s558; - const SWord8 s560 = (s541 >> 1) | (s541 << 7); - const SWord8 s561 = 128 | s560; - const SWord8 s562 = 127 & s560; - const SWord8 s563 = s559 ? s561 : s562; - const SBool s564 = (SBool) (s563 & 1); - const SBool s565 = false != s564; - const SBool s566 = !s565; - const SWord8 s567 = (s551 >> 1) | (s551 << 7); - const SWord8 s568 = 128 | s567; - const SWord8 s569 = 127 & s567; - const SWord8 s570 = s20 ? s568 : s569; - const SBool s571 = (SBool) (s570 & 1); - const SBool s572 = false != s571; - const SWord8 s573 = (s557 >> 1) | (s557 << 7); - const SWord8 s574 = 128 | s573; - const SWord8 s575 = 127 & s573; - const SWord8 s576 = s572 ? s574 : s575; - const SBool s577 = (SBool) (s576 & 1); - const SBool s578 = false != s577; - const SWord8 s579 = (s563 >> 1) | (s563 << 7); - const SWord8 s580 = 128 | s579; - const SWord8 s581 = 127 & s579; - const SWord8 s582 = s578 ? s580 : s581; - const SBool s583 = (SBool) (s582 & 1); - const SBool s584 = false != s583; - const SBool s585 = !s584; - const SWord8 s586 = (s570 >> 1) | (s570 << 7); - const SWord8 s587 = 128 | s586; - const SWord8 s588 = 127 & s586; - const SWord8 s589 = s35 ? s587 : s588; - const SWord8 s590 = (s589 >> 1) | (s589 << 7); - const SWord8 s591 = 128 | s590; - const SWord8 s592 = 127 & s590; - const SWord8 s593 = s543 ? s591 : s592; - const SWord8 s594 = (s593 >> 1) | (s593 << 7); - const SWord8 s595 = 128 | s594; - const SWord8 s596 = 127 & s594; - const SWord8 s597 = s565 ? s595 : s596; - const SWord8 s598 = (s597 >> 1) | (s597 << 7); - const SWord8 s599 = 128 | s598; - const SWord8 s600 = 127 & s598; - const SWord8 s601 = s584 ? s599 : s600; - const SWord8 s602 = s1 + s597; - const SBool s603 = s602 < s1; - const SBool s604 = s602 < s597; - const SBool s605 = s603 || s604; - const SWord8 s606 = (s602 >> 1) | (s602 << 7); - const SWord8 s607 = 128 | s606; - const SWord8 s608 = 127 & s606; - const SWord8 s609 = s605 ? s607 : s608; - const SWord8 s610 = s585 ? s601 : s609; - const SWord8 s611 = s1 + s593; - const SBool s612 = s611 < s1; - const SBool s613 = s611 < s593; - const SBool s614 = s612 || s613; - const SWord8 s615 = (s611 >> 1) | (s611 << 7); - const SWord8 s616 = 128 | s615; - const SWord8 s617 = 127 & s615; - const SWord8 s618 = s614 ? s616 : s617; - const SWord8 s619 = (s618 >> 1) | (s618 << 7); - const SWord8 s620 = 128 | s619; - const SWord8 s621 = 127 & s619; - const SWord8 s622 = s584 ? s620 : s621; - const SWord8 s623 = s1 + s618; - const SBool s624 = s623 < s1; - const SBool s625 = s623 < s618; - const SBool s626 = s624 || s625; - const SWord8 s627 = (s623 >> 1) | (s623 << 7); - const SWord8 s628 = 128 | s627; - const SWord8 s629 = 127 & s627; - const SWord8 s630 = s626 ? s628 : s629; - const SWord8 s631 = s585 ? s622 : s630; - const SWord8 s632 = s566 ? s610 : s631; - const SWord8 s633 = s1 + s589; - const SBool s634 = s633 < s1; - const SBool s635 = s633 < s589; - const SBool s636 = s634 || s635; - const SWord8 s637 = (s633 >> 1) | (s633 << 7); - const SWord8 s638 = 128 | s637; - const SWord8 s639 = 127 & s637; - const SWord8 s640 = s636 ? s638 : s639; - const SWord8 s641 = (s640 >> 1) | (s640 << 7); - const SWord8 s642 = 128 | s641; - const SWord8 s643 = 127 & s641; - const SWord8 s644 = s565 ? s642 : s643; - const SWord8 s645 = (s644 >> 1) | (s644 << 7); - const SWord8 s646 = 128 | s645; - const SWord8 s647 = 127 & s645; - const SWord8 s648 = s584 ? s646 : s647; - const SWord8 s649 = s1 + s644; - const SBool s650 = s649 < s1; - const SBool s651 = s649 < s644; - const SBool s652 = s650 || s651; - const SWord8 s653 = (s649 >> 1) | (s649 << 7); - const SWord8 s654 = 128 | s653; - const SWord8 s655 = 127 & s653; - const SWord8 s656 = s652 ? s654 : s655; - const SWord8 s657 = s585 ? s648 : s656; - const SWord8 s658 = s1 + s640; - const SBool s659 = s658 < s1; - const SBool s660 = s658 < s640; - const SBool s661 = s659 || s660; - const SWord8 s662 = (s658 >> 1) | (s658 << 7); - const SWord8 s663 = 128 | s662; - const SWord8 s664 = 127 & s662; - const SWord8 s665 = s661 ? s663 : s664; - const SWord8 s666 = (s665 >> 1) | (s665 << 7); - const SWord8 s667 = 128 | s666; - const SWord8 s668 = 127 & s666; - const SWord8 s669 = s584 ? s667 : s668; - const SWord8 s670 = s1 + s665; - const SBool s671 = s670 < s1; - const SBool s672 = s670 < s665; - const SBool s673 = s671 || s672; - const SWord8 s674 = (s670 >> 1) | (s670 << 7); - const SWord8 s675 = 128 | s674; - const SWord8 s676 = 127 & s674; - const SWord8 s677 = s673 ? s675 : s676; - const SWord8 s678 = s585 ? s669 : s677; - const SWord8 s679 = s566 ? s657 : s678; - const SWord8 s680 = s544 ? s632 : s679; - const SWord8 s681 = s1 + s570; - const SBool s682 = (SBool) (s681 & 1); - const SBool s683 = false != s682; - const SWord8 s684 = s683 ? s574 : s575; - const SBool s685 = (SBool) (s684 & 1); - const SBool s686 = false != s685; - const SWord8 s687 = s686 ? s580 : s581; - const SBool s688 = (SBool) (s687 & 1); - const SBool s689 = false != s688; - const SBool s690 = !s689; - const SBool s691 = s681 < s1; - const SBool s692 = s681 < s570; - const SBool s693 = s691 || s692; - const SWord8 s694 = (s681 >> 1) | (s681 << 7); - const SWord8 s695 = 128 | s694; - const SWord8 s696 = 127 & s694; - const SWord8 s697 = s693 ? s695 : s696; - const SWord8 s698 = (s697 >> 1) | (s697 << 7); - const SWord8 s699 = 128 | s698; - const SWord8 s700 = 127 & s698; - const SWord8 s701 = s543 ? s699 : s700; - const SWord8 s702 = (s701 >> 1) | (s701 << 7); - const SWord8 s703 = 128 | s702; - const SWord8 s704 = 127 & s702; - const SWord8 s705 = s565 ? s703 : s704; - const SWord8 s706 = (s705 >> 1) | (s705 << 7); - const SWord8 s707 = 128 | s706; - const SWord8 s708 = 127 & s706; - const SWord8 s709 = s689 ? s707 : s708; - const SWord8 s710 = s1 + s705; - const SBool s711 = s710 < s1; - const SBool s712 = s710 < s705; - const SBool s713 = s711 || s712; - const SWord8 s714 = (s710 >> 1) | (s710 << 7); - const SWord8 s715 = 128 | s714; - const SWord8 s716 = 127 & s714; - const SWord8 s717 = s713 ? s715 : s716; - const SWord8 s718 = s690 ? s709 : s717; - const SWord8 s719 = s1 + s701; - const SBool s720 = s719 < s1; - const SBool s721 = s719 < s701; - const SBool s722 = s720 || s721; - const SWord8 s723 = (s719 >> 1) | (s719 << 7); - const SWord8 s724 = 128 | s723; - const SWord8 s725 = 127 & s723; - const SWord8 s726 = s722 ? s724 : s725; - const SWord8 s727 = (s726 >> 1) | (s726 << 7); - const SWord8 s728 = 128 | s727; - const SWord8 s729 = 127 & s727; - const SWord8 s730 = s689 ? s728 : s729; - const SWord8 s731 = s1 + s726; - const SBool s732 = s731 < s1; - const SBool s733 = s731 < s726; - const SBool s734 = s732 || s733; - const SWord8 s735 = (s731 >> 1) | (s731 << 7); - const SWord8 s736 = 128 | s735; - const SWord8 s737 = 127 & s735; - const SWord8 s738 = s734 ? s736 : s737; - const SWord8 s739 = s690 ? s730 : s738; - const SWord8 s740 = s566 ? s718 : s739; - const SWord8 s741 = s1 + s697; - const SBool s742 = s741 < s1; - const SBool s743 = s741 < s697; - const SBool s744 = s742 || s743; - const SWord8 s745 = (s741 >> 1) | (s741 << 7); - const SWord8 s746 = 128 | s745; - const SWord8 s747 = 127 & s745; - const SWord8 s748 = s744 ? s746 : s747; - const SWord8 s749 = (s748 >> 1) | (s748 << 7); - const SWord8 s750 = 128 | s749; - const SWord8 s751 = 127 & s749; - const SWord8 s752 = s565 ? s750 : s751; - const SWord8 s753 = (s752 >> 1) | (s752 << 7); - const SWord8 s754 = 128 | s753; - const SWord8 s755 = 127 & s753; - const SWord8 s756 = s689 ? s754 : s755; - const SWord8 s757 = s1 + s752; - const SBool s758 = s757 < s1; - const SBool s759 = s757 < s752; - const SBool s760 = s758 || s759; - const SWord8 s761 = (s757 >> 1) | (s757 << 7); - const SWord8 s762 = 128 | s761; - const SWord8 s763 = 127 & s761; - const SWord8 s764 = s760 ? s762 : s763; - const SWord8 s765 = s690 ? s756 : s764; - const SWord8 s766 = s1 + s748; - const SBool s767 = s766 < s1; - const SBool s768 = s766 < s748; - const SBool s769 = s767 || s768; - const SWord8 s770 = (s766 >> 1) | (s766 << 7); - const SWord8 s771 = 128 | s770; - const SWord8 s772 = 127 & s770; - const SWord8 s773 = s769 ? s771 : s772; - const SWord8 s774 = (s773 >> 1) | (s773 << 7); - const SWord8 s775 = 128 | s774; - const SWord8 s776 = 127 & s774; - const SWord8 s777 = s689 ? s775 : s776; - const SWord8 s778 = s1 + s773; - const SBool s779 = s778 < s1; - const SBool s780 = s778 < s773; - const SBool s781 = s779 || s780; - const SWord8 s782 = (s778 >> 1) | (s778 << 7); - const SWord8 s783 = 128 | s782; - const SWord8 s784 = 127 & s782; - const SWord8 s785 = s781 ? s783 : s784; - const SWord8 s786 = s690 ? s777 : s785; - const SWord8 s787 = s566 ? s765 : s786; - const SWord8 s788 = s544 ? s740 : s787; - const SWord8 s789 = s36 ? s680 : s788; - const SWord8 s790 = s1 + s551; - const SBool s791 = (SBool) (s790 & 1); - const SBool s792 = false != s791; - const SWord8 s793 = s792 ? s555 : s556; - const SBool s794 = (SBool) (s793 & 1); - const SBool s795 = false != s794; - const SWord8 s796 = s795 ? s561 : s562; - const SBool s797 = (SBool) (s796 & 1); - const SBool s798 = false != s797; - const SBool s799 = !s798; - const SBool s800 = s790 < s1; - const SBool s801 = s790 < s551; - const SBool s802 = s800 || s801; - const SWord8 s803 = (s790 >> 1) | (s790 << 7); - const SWord8 s804 = 128 | s803; - const SWord8 s805 = 127 & s803; - const SWord8 s806 = s802 ? s804 : s805; - const SBool s807 = (SBool) (s806 & 1); - const SBool s808 = false != s807; - const SWord8 s809 = (s793 >> 1) | (s793 << 7); - const SWord8 s810 = 128 | s809; - const SWord8 s811 = 127 & s809; - const SWord8 s812 = s808 ? s810 : s811; - const SBool s813 = (SBool) (s812 & 1); - const SBool s814 = false != s813; - const SWord8 s815 = (s796 >> 1) | (s796 << 7); - const SWord8 s816 = 128 | s815; - const SWord8 s817 = 127 & s815; - const SWord8 s818 = s814 ? s816 : s817; - const SBool s819 = (SBool) (s818 & 1); - const SBool s820 = false != s819; - const SBool s821 = !s820; - const SWord8 s822 = (s806 >> 1) | (s806 << 7); - const SWord8 s823 = 128 | s822; - const SWord8 s824 = 127 & s822; - const SWord8 s825 = s35 ? s823 : s824; - const SWord8 s826 = (s825 >> 1) | (s825 << 7); - const SWord8 s827 = 128 | s826; - const SWord8 s828 = 127 & s826; - const SWord8 s829 = s543 ? s827 : s828; - const SWord8 s830 = (s829 >> 1) | (s829 << 7); - const SWord8 s831 = 128 | s830; - const SWord8 s832 = 127 & s830; - const SWord8 s833 = s798 ? s831 : s832; - const SWord8 s834 = (s833 >> 1) | (s833 << 7); - const SWord8 s835 = 128 | s834; - const SWord8 s836 = 127 & s834; - const SWord8 s837 = s820 ? s835 : s836; - const SWord8 s838 = s1 + s833; - const SBool s839 = s838 < s1; - const SBool s840 = s838 < s833; - const SBool s841 = s839 || s840; - const SWord8 s842 = (s838 >> 1) | (s838 << 7); - const SWord8 s843 = 128 | s842; - const SWord8 s844 = 127 & s842; - const SWord8 s845 = s841 ? s843 : s844; - const SWord8 s846 = s821 ? s837 : s845; - const SWord8 s847 = s1 + s829; - const SBool s848 = s847 < s1; - const SBool s849 = s847 < s829; - const SBool s850 = s848 || s849; - const SWord8 s851 = (s847 >> 1) | (s847 << 7); - const SWord8 s852 = 128 | s851; - const SWord8 s853 = 127 & s851; - const SWord8 s854 = s850 ? s852 : s853; - const SWord8 s855 = (s854 >> 1) | (s854 << 7); - const SWord8 s856 = 128 | s855; - const SWord8 s857 = 127 & s855; - const SWord8 s858 = s820 ? s856 : s857; - const SWord8 s859 = s1 + s854; - const SBool s860 = s859 < s1; - const SBool s861 = s859 < s854; - const SBool s862 = s860 || s861; - const SWord8 s863 = (s859 >> 1) | (s859 << 7); - const SWord8 s864 = 128 | s863; - const SWord8 s865 = 127 & s863; - const SWord8 s866 = s862 ? s864 : s865; - const SWord8 s867 = s821 ? s858 : s866; - const SWord8 s868 = s799 ? s846 : s867; - const SWord8 s869 = s1 + s825; - const SBool s870 = s869 < s1; - const SBool s871 = s869 < s825; - const SBool s872 = s870 || s871; - const SWord8 s873 = (s869 >> 1) | (s869 << 7); - const SWord8 s874 = 128 | s873; - const SWord8 s875 = 127 & s873; - const SWord8 s876 = s872 ? s874 : s875; - const SWord8 s877 = (s876 >> 1) | (s876 << 7); - const SWord8 s878 = 128 | s877; - const SWord8 s879 = 127 & s877; - const SWord8 s880 = s798 ? s878 : s879; - const SWord8 s881 = (s880 >> 1) | (s880 << 7); - const SWord8 s882 = 128 | s881; - const SWord8 s883 = 127 & s881; - const SWord8 s884 = s820 ? s882 : s883; - const SWord8 s885 = s1 + s880; - const SBool s886 = s885 < s1; - const SBool s887 = s885 < s880; - const SBool s888 = s886 || s887; - const SWord8 s889 = (s885 >> 1) | (s885 << 7); - const SWord8 s890 = 128 | s889; - const SWord8 s891 = 127 & s889; - const SWord8 s892 = s888 ? s890 : s891; - const SWord8 s893 = s821 ? s884 : s892; - const SWord8 s894 = s1 + s876; - const SBool s895 = s894 < s1; - const SBool s896 = s894 < s876; - const SBool s897 = s895 || s896; - const SWord8 s898 = (s894 >> 1) | (s894 << 7); - const SWord8 s899 = 128 | s898; - const SWord8 s900 = 127 & s898; - const SWord8 s901 = s897 ? s899 : s900; - const SWord8 s902 = (s901 >> 1) | (s901 << 7); - const SWord8 s903 = 128 | s902; - const SWord8 s904 = 127 & s902; - const SWord8 s905 = s820 ? s903 : s904; - const SWord8 s906 = s1 + s901; - const SBool s907 = s906 < s1; - const SBool s908 = s906 < s901; - const SBool s909 = s907 || s908; - const SWord8 s910 = (s906 >> 1) | (s906 << 7); - const SWord8 s911 = 128 | s910; - const SWord8 s912 = 127 & s910; - const SWord8 s913 = s909 ? s911 : s912; - const SWord8 s914 = s821 ? s905 : s913; - const SWord8 s915 = s799 ? s893 : s914; - const SWord8 s916 = s544 ? s868 : s915; - const SWord8 s917 = s1 + s806; - const SBool s918 = (SBool) (s917 & 1); - const SBool s919 = false != s918; - const SWord8 s920 = s919 ? s810 : s811; - const SBool s921 = (SBool) (s920 & 1); - const SBool s922 = false != s921; - const SWord8 s923 = s922 ? s816 : s817; - const SBool s924 = (SBool) (s923 & 1); - const SBool s925 = false != s924; - const SBool s926 = !s925; - const SBool s927 = s917 < s1; - const SBool s928 = s917 < s806; - const SBool s929 = s927 || s928; - const SWord8 s930 = (s917 >> 1) | (s917 << 7); - const SWord8 s931 = 128 | s930; - const SWord8 s932 = 127 & s930; - const SWord8 s933 = s929 ? s931 : s932; - const SWord8 s934 = (s933 >> 1) | (s933 << 7); - const SWord8 s935 = 128 | s934; - const SWord8 s936 = 127 & s934; - const SWord8 s937 = s543 ? s935 : s936; - const SWord8 s938 = (s937 >> 1) | (s937 << 7); - const SWord8 s939 = 128 | s938; - const SWord8 s940 = 127 & s938; - const SWord8 s941 = s798 ? s939 : s940; - const SWord8 s942 = (s941 >> 1) | (s941 << 7); - const SWord8 s943 = 128 | s942; - const SWord8 s944 = 127 & s942; - const SWord8 s945 = s925 ? s943 : s944; - const SWord8 s946 = s1 + s941; - const SBool s947 = s946 < s1; - const SBool s948 = s946 < s941; - const SBool s949 = s947 || s948; - const SWord8 s950 = (s946 >> 1) | (s946 << 7); - const SWord8 s951 = 128 | s950; - const SWord8 s952 = 127 & s950; - const SWord8 s953 = s949 ? s951 : s952; - const SWord8 s954 = s926 ? s945 : s953; - const SWord8 s955 = s1 + s937; - const SBool s956 = s955 < s1; - const SBool s957 = s955 < s937; - const SBool s958 = s956 || s957; - const SWord8 s959 = (s955 >> 1) | (s955 << 7); - const SWord8 s960 = 128 | s959; - const SWord8 s961 = 127 & s959; - const SWord8 s962 = s958 ? s960 : s961; - const SWord8 s963 = (s962 >> 1) | (s962 << 7); - const SWord8 s964 = 128 | s963; - const SWord8 s965 = 127 & s963; - const SWord8 s966 = s925 ? s964 : s965; - const SWord8 s967 = s1 + s962; - const SBool s968 = s967 < s1; - const SBool s969 = s967 < s962; - const SBool s970 = s968 || s969; - const SWord8 s971 = (s967 >> 1) | (s967 << 7); - const SWord8 s972 = 128 | s971; - const SWord8 s973 = 127 & s971; - const SWord8 s974 = s970 ? s972 : s973; - const SWord8 s975 = s926 ? s966 : s974; - const SWord8 s976 = s799 ? s954 : s975; - const SWord8 s977 = s1 + s933; - const SBool s978 = s977 < s1; - const SBool s979 = s977 < s933; - const SBool s980 = s978 || s979; - const SWord8 s981 = (s977 >> 1) | (s977 << 7); - const SWord8 s982 = 128 | s981; - const SWord8 s983 = 127 & s981; - const SWord8 s984 = s980 ? s982 : s983; - const SWord8 s985 = (s984 >> 1) | (s984 << 7); - const SWord8 s986 = 128 | s985; - const SWord8 s987 = 127 & s985; - const SWord8 s988 = s798 ? s986 : s987; - const SWord8 s989 = (s988 >> 1) | (s988 << 7); - const SWord8 s990 = 128 | s989; - const SWord8 s991 = 127 & s989; - const SWord8 s992 = s925 ? s990 : s991; - const SWord8 s993 = s1 + s988; - const SBool s994 = s993 < s1; - const SBool s995 = s993 < s988; - const SBool s996 = s994 || s995; - const SWord8 s997 = (s993 >> 1) | (s993 << 7); - const SWord8 s998 = 128 | s997; - const SWord8 s999 = 127 & s997; - const SWord8 s1000 = s996 ? s998 : s999; - const SWord8 s1001 = s926 ? s992 : s1000; - const SWord8 s1002 = s1 + s984; - const SBool s1003 = s1002 < s1; - const SBool s1004 = s1002 < s984; - const SBool s1005 = s1003 || s1004; - const SWord8 s1006 = (s1002 >> 1) | (s1002 << 7); - const SWord8 s1007 = 128 | s1006; - const SWord8 s1008 = 127 & s1006; - const SWord8 s1009 = s1005 ? s1007 : s1008; - const SWord8 s1010 = (s1009 >> 1) | (s1009 << 7); - const SWord8 s1011 = 128 | s1010; - const SWord8 s1012 = 127 & s1010; - const SWord8 s1013 = s925 ? s1011 : s1012; - const SWord8 s1014 = s1 + s1009; - const SBool s1015 = s1014 < s1; - const SBool s1016 = s1014 < s1009; - const SBool s1017 = s1015 || s1016; - const SWord8 s1018 = (s1014 >> 1) | (s1014 << 7); - const SWord8 s1019 = 128 | s1018; - const SWord8 s1020 = 127 & s1018; - const SWord8 s1021 = s1017 ? s1019 : s1020; - const SWord8 s1022 = s926 ? s1013 : s1021; - const SWord8 s1023 = s799 ? s1001 : s1022; - const SWord8 s1024 = s544 ? s976 : s1023; - const SWord8 s1025 = s36 ? s916 : s1024; - const SWord8 s1026 = s21 ? s789 : s1025; - const SWord8 s1027 = s16 ? s534 : s1026; - const SWord8 s1028 = s1 + s24; - const SBool s1029 = (SBool) (s1028 & 1); - const SBool s1030 = false != s1029; - const SWord8 s1031 = s1030 ? 128 : 0; - const SBool s1032 = (SBool) (s1031 & 1); - const SBool s1033 = false != s1032; - const SWord8 s1034 = s1033 ? s31 : s32; - const SBool s1035 = (SBool) (s1034 & 1); - const SBool s1036 = false != s1035; - const SBool s1037 = !s1036; - const SBool s1038 = s1028 < s1; - const SBool s1039 = s1028 < s24; - const SBool s1040 = s1038 || s1039; - const SWord8 s1041 = (s1028 >> 1) | (s1028 << 7); - const SWord8 s1042 = 128 | s1041; - const SWord8 s1043 = 127 & s1041; - const SWord8 s1044 = s1040 ? s1042 : s1043; - const SBool s1045 = (SBool) (s1044 & 1); - const SBool s1046 = false != s1045; - const SWord8 s1047 = (s1031 >> 1) | (s1031 << 7); - const SWord8 s1048 = 128 | s1047; - const SWord8 s1049 = 127 & s1047; - const SWord8 s1050 = s1046 ? s1048 : s1049; - const SBool s1051 = (SBool) (s1050 & 1); - const SBool s1052 = false != s1051; - const SWord8 s1053 = (s1034 >> 1) | (s1034 << 7); - const SWord8 s1054 = 128 | s1053; - const SWord8 s1055 = 127 & s1053; - const SWord8 s1056 = s1052 ? s1054 : s1055; - const SBool s1057 = (SBool) (s1056 & 1); - const SBool s1058 = false != s1057; - const SBool s1059 = !s1058; - const SWord8 s1060 = (s1044 >> 1) | (s1044 << 7); - const SWord8 s1061 = 128 | s1060; - const SWord8 s1062 = 127 & s1060; - const SWord8 s1063 = s15 ? s1061 : s1062; - const SBool s1064 = (SBool) (s1063 & 1); - const SBool s1065 = false != s1064; - const SWord8 s1066 = (s1050 >> 1) | (s1050 << 7); - const SWord8 s1067 = 128 | s1066; - const SWord8 s1068 = 127 & s1066; - const SWord8 s1069 = s1065 ? s1067 : s1068; - const SBool s1070 = (SBool) (s1069 & 1); - const SBool s1071 = false != s1070; - const SWord8 s1072 = (s1056 >> 1) | (s1056 << 7); - const SWord8 s1073 = 128 | s1072; - const SWord8 s1074 = 127 & s1072; - const SWord8 s1075 = s1071 ? s1073 : s1074; - const SBool s1076 = (SBool) (s1075 & 1); - const SBool s1077 = false != s1076; - const SBool s1078 = !s1077; - const SWord8 s1079 = (s1063 >> 1) | (s1063 << 7); - const SWord8 s1080 = 128 | s1079; - const SWord8 s1081 = 127 & s1079; - const SWord8 s1082 = s20 ? s1080 : s1081; - const SBool s1083 = (SBool) (s1082 & 1); - const SBool s1084 = false != s1083; - const SWord8 s1085 = (s1069 >> 1) | (s1069 << 7); - const SWord8 s1086 = 128 | s1085; - const SWord8 s1087 = 127 & s1085; - const SWord8 s1088 = s1084 ? s1086 : s1087; - const SBool s1089 = (SBool) (s1088 & 1); - const SBool s1090 = false != s1089; - const SWord8 s1091 = (s1075 >> 1) | (s1075 << 7); - const SWord8 s1092 = 128 | s1091; - const SWord8 s1093 = 127 & s1091; - const SWord8 s1094 = s1090 ? s1092 : s1093; - const SBool s1095 = (SBool) (s1094 & 1); - const SBool s1096 = false != s1095; - const SBool s1097 = !s1096; - const SWord8 s1098 = (s1082 >> 1) | (s1082 << 7); - const SWord8 s1099 = 128 | s1098; - const SWord8 s1100 = 127 & s1098; - const SWord8 s1101 = s1036 ? s1099 : s1100; - const SWord8 s1102 = (s1101 >> 1) | (s1101 << 7); - const SWord8 s1103 = 128 | s1102; - const SWord8 s1104 = 127 & s1102; - const SWord8 s1105 = s1058 ? s1103 : s1104; - const SWord8 s1106 = (s1105 >> 1) | (s1105 << 7); - const SWord8 s1107 = 128 | s1106; - const SWord8 s1108 = 127 & s1106; - const SWord8 s1109 = s1077 ? s1107 : s1108; - const SWord8 s1110 = (s1109 >> 1) | (s1109 << 7); - const SWord8 s1111 = 128 | s1110; - const SWord8 s1112 = 127 & s1110; - const SWord8 s1113 = s1096 ? s1111 : s1112; - const SWord8 s1114 = s1 + s1109; - const SBool s1115 = s1114 < s1; - const SBool s1116 = s1114 < s1109; - const SBool s1117 = s1115 || s1116; - const SWord8 s1118 = (s1114 >> 1) | (s1114 << 7); - const SWord8 s1119 = 128 | s1118; - const SWord8 s1120 = 127 & s1118; - const SWord8 s1121 = s1117 ? s1119 : s1120; - const SWord8 s1122 = s1097 ? s1113 : s1121; - const SWord8 s1123 = s1 + s1105; - const SBool s1124 = s1123 < s1; - const SBool s1125 = s1123 < s1105; - const SBool s1126 = s1124 || s1125; - const SWord8 s1127 = (s1123 >> 1) | (s1123 << 7); - const SWord8 s1128 = 128 | s1127; - const SWord8 s1129 = 127 & s1127; - const SWord8 s1130 = s1126 ? s1128 : s1129; - const SWord8 s1131 = (s1130 >> 1) | (s1130 << 7); - const SWord8 s1132 = 128 | s1131; - const SWord8 s1133 = 127 & s1131; - const SWord8 s1134 = s1096 ? s1132 : s1133; - const SWord8 s1135 = s1 + s1130; - const SBool s1136 = s1135 < s1; - const SBool s1137 = s1135 < s1130; - const SBool s1138 = s1136 || s1137; - const SWord8 s1139 = (s1135 >> 1) | (s1135 << 7); - const SWord8 s1140 = 128 | s1139; - const SWord8 s1141 = 127 & s1139; - const SWord8 s1142 = s1138 ? s1140 : s1141; - const SWord8 s1143 = s1097 ? s1134 : s1142; - const SWord8 s1144 = s1078 ? s1122 : s1143; - const SWord8 s1145 = s1 + s1101; - const SBool s1146 = s1145 < s1; - const SBool s1147 = s1145 < s1101; - const SBool s1148 = s1146 || s1147; - const SWord8 s1149 = (s1145 >> 1) | (s1145 << 7); - const SWord8 s1150 = 128 | s1149; - const SWord8 s1151 = 127 & s1149; - const SWord8 s1152 = s1148 ? s1150 : s1151; - const SWord8 s1153 = (s1152 >> 1) | (s1152 << 7); - const SWord8 s1154 = 128 | s1153; - const SWord8 s1155 = 127 & s1153; - const SWord8 s1156 = s1077 ? s1154 : s1155; - const SWord8 s1157 = (s1156 >> 1) | (s1156 << 7); - const SWord8 s1158 = 128 | s1157; - const SWord8 s1159 = 127 & s1157; - const SWord8 s1160 = s1096 ? s1158 : s1159; - const SWord8 s1161 = s1 + s1156; - const SBool s1162 = s1161 < s1; - const SBool s1163 = s1161 < s1156; - const SBool s1164 = s1162 || s1163; - const SWord8 s1165 = (s1161 >> 1) | (s1161 << 7); - const SWord8 s1166 = 128 | s1165; - const SWord8 s1167 = 127 & s1165; - const SWord8 s1168 = s1164 ? s1166 : s1167; - const SWord8 s1169 = s1097 ? s1160 : s1168; - const SWord8 s1170 = s1 + s1152; - const SBool s1171 = s1170 < s1; - const SBool s1172 = s1170 < s1152; - const SBool s1173 = s1171 || s1172; - const SWord8 s1174 = (s1170 >> 1) | (s1170 << 7); - const SWord8 s1175 = 128 | s1174; - const SWord8 s1176 = 127 & s1174; - const SWord8 s1177 = s1173 ? s1175 : s1176; - const SWord8 s1178 = (s1177 >> 1) | (s1177 << 7); - const SWord8 s1179 = 128 | s1178; - const SWord8 s1180 = 127 & s1178; - const SWord8 s1181 = s1096 ? s1179 : s1180; - const SWord8 s1182 = s1 + s1177; - const SBool s1183 = s1182 < s1; - const SBool s1184 = s1182 < s1177; - const SBool s1185 = s1183 || s1184; - const SWord8 s1186 = (s1182 >> 1) | (s1182 << 7); - const SWord8 s1187 = 128 | s1186; - const SWord8 s1188 = 127 & s1186; - const SWord8 s1189 = s1185 ? s1187 : s1188; - const SWord8 s1190 = s1097 ? s1181 : s1189; - const SWord8 s1191 = s1078 ? s1169 : s1190; - const SWord8 s1192 = s1059 ? s1144 : s1191; - const SWord8 s1193 = s1 + s1082; - const SBool s1194 = (SBool) (s1193 & 1); - const SBool s1195 = false != s1194; - const SWord8 s1196 = s1195 ? s1086 : s1087; - const SBool s1197 = (SBool) (s1196 & 1); - const SBool s1198 = false != s1197; - const SWord8 s1199 = s1198 ? s1092 : s1093; - const SBool s1200 = (SBool) (s1199 & 1); - const SBool s1201 = false != s1200; - const SBool s1202 = !s1201; - const SBool s1203 = s1193 < s1; - const SBool s1204 = s1193 < s1082; - const SBool s1205 = s1203 || s1204; - const SWord8 s1206 = (s1193 >> 1) | (s1193 << 7); - const SWord8 s1207 = 128 | s1206; - const SWord8 s1208 = 127 & s1206; - const SWord8 s1209 = s1205 ? s1207 : s1208; - const SWord8 s1210 = (s1209 >> 1) | (s1209 << 7); - const SWord8 s1211 = 128 | s1210; - const SWord8 s1212 = 127 & s1210; - const SWord8 s1213 = s1058 ? s1211 : s1212; - const SWord8 s1214 = (s1213 >> 1) | (s1213 << 7); - const SWord8 s1215 = 128 | s1214; - const SWord8 s1216 = 127 & s1214; - const SWord8 s1217 = s1077 ? s1215 : s1216; - const SWord8 s1218 = (s1217 >> 1) | (s1217 << 7); - const SWord8 s1219 = 128 | s1218; - const SWord8 s1220 = 127 & s1218; - const SWord8 s1221 = s1201 ? s1219 : s1220; - const SWord8 s1222 = s1 + s1217; - const SBool s1223 = s1222 < s1; - const SBool s1224 = s1222 < s1217; - const SBool s1225 = s1223 || s1224; - const SWord8 s1226 = (s1222 >> 1) | (s1222 << 7); - const SWord8 s1227 = 128 | s1226; - const SWord8 s1228 = 127 & s1226; - const SWord8 s1229 = s1225 ? s1227 : s1228; - const SWord8 s1230 = s1202 ? s1221 : s1229; - const SWord8 s1231 = s1 + s1213; - const SBool s1232 = s1231 < s1; - const SBool s1233 = s1231 < s1213; - const SBool s1234 = s1232 || s1233; - const SWord8 s1235 = (s1231 >> 1) | (s1231 << 7); - const SWord8 s1236 = 128 | s1235; - const SWord8 s1237 = 127 & s1235; - const SWord8 s1238 = s1234 ? s1236 : s1237; - const SWord8 s1239 = (s1238 >> 1) | (s1238 << 7); - const SWord8 s1240 = 128 | s1239; - const SWord8 s1241 = 127 & s1239; - const SWord8 s1242 = s1201 ? s1240 : s1241; - const SWord8 s1243 = s1 + s1238; - const SBool s1244 = s1243 < s1; - const SBool s1245 = s1243 < s1238; - const SBool s1246 = s1244 || s1245; - const SWord8 s1247 = (s1243 >> 1) | (s1243 << 7); - const SWord8 s1248 = 128 | s1247; - const SWord8 s1249 = 127 & s1247; - const SWord8 s1250 = s1246 ? s1248 : s1249; - const SWord8 s1251 = s1202 ? s1242 : s1250; - const SWord8 s1252 = s1078 ? s1230 : s1251; - const SWord8 s1253 = s1 + s1209; - const SBool s1254 = s1253 < s1; - const SBool s1255 = s1253 < s1209; - const SBool s1256 = s1254 || s1255; - const SWord8 s1257 = (s1253 >> 1) | (s1253 << 7); - const SWord8 s1258 = 128 | s1257; - const SWord8 s1259 = 127 & s1257; - const SWord8 s1260 = s1256 ? s1258 : s1259; - const SWord8 s1261 = (s1260 >> 1) | (s1260 << 7); - const SWord8 s1262 = 128 | s1261; - const SWord8 s1263 = 127 & s1261; - const SWord8 s1264 = s1077 ? s1262 : s1263; - const SWord8 s1265 = (s1264 >> 1) | (s1264 << 7); - const SWord8 s1266 = 128 | s1265; - const SWord8 s1267 = 127 & s1265; - const SWord8 s1268 = s1201 ? s1266 : s1267; - const SWord8 s1269 = s1 + s1264; - const SBool s1270 = s1269 < s1; - const SBool s1271 = s1269 < s1264; - const SBool s1272 = s1270 || s1271; - const SWord8 s1273 = (s1269 >> 1) | (s1269 << 7); - const SWord8 s1274 = 128 | s1273; - const SWord8 s1275 = 127 & s1273; - const SWord8 s1276 = s1272 ? s1274 : s1275; - const SWord8 s1277 = s1202 ? s1268 : s1276; - const SWord8 s1278 = s1 + s1260; - const SBool s1279 = s1278 < s1; - const SBool s1280 = s1278 < s1260; - const SBool s1281 = s1279 || s1280; - const SWord8 s1282 = (s1278 >> 1) | (s1278 << 7); - const SWord8 s1283 = 128 | s1282; - const SWord8 s1284 = 127 & s1282; - const SWord8 s1285 = s1281 ? s1283 : s1284; - const SWord8 s1286 = (s1285 >> 1) | (s1285 << 7); - const SWord8 s1287 = 128 | s1286; - const SWord8 s1288 = 127 & s1286; - const SWord8 s1289 = s1201 ? s1287 : s1288; - const SWord8 s1290 = s1 + s1285; - const SBool s1291 = s1290 < s1; - const SBool s1292 = s1290 < s1285; - const SBool s1293 = s1291 || s1292; - const SWord8 s1294 = (s1290 >> 1) | (s1290 << 7); - const SWord8 s1295 = 128 | s1294; - const SWord8 s1296 = 127 & s1294; - const SWord8 s1297 = s1293 ? s1295 : s1296; - const SWord8 s1298 = s1202 ? s1289 : s1297; - const SWord8 s1299 = s1078 ? s1277 : s1298; - const SWord8 s1300 = s1059 ? s1252 : s1299; - const SWord8 s1301 = s1037 ? s1192 : s1300; - const SWord8 s1302 = s1 + s1063; - const SBool s1303 = (SBool) (s1302 & 1); - const SBool s1304 = false != s1303; - const SWord8 s1305 = s1304 ? s1067 : s1068; - const SBool s1306 = (SBool) (s1305 & 1); - const SBool s1307 = false != s1306; - const SWord8 s1308 = s1307 ? s1073 : s1074; - const SBool s1309 = (SBool) (s1308 & 1); - const SBool s1310 = false != s1309; - const SBool s1311 = !s1310; - const SBool s1312 = s1302 < s1; - const SBool s1313 = s1302 < s1063; - const SBool s1314 = s1312 || s1313; - const SWord8 s1315 = (s1302 >> 1) | (s1302 << 7); - const SWord8 s1316 = 128 | s1315; - const SWord8 s1317 = 127 & s1315; - const SWord8 s1318 = s1314 ? s1316 : s1317; - const SBool s1319 = (SBool) (s1318 & 1); - const SBool s1320 = false != s1319; - const SWord8 s1321 = (s1305 >> 1) | (s1305 << 7); - const SWord8 s1322 = 128 | s1321; - const SWord8 s1323 = 127 & s1321; - const SWord8 s1324 = s1320 ? s1322 : s1323; - const SBool s1325 = (SBool) (s1324 & 1); - const SBool s1326 = false != s1325; - const SWord8 s1327 = (s1308 >> 1) | (s1308 << 7); - const SWord8 s1328 = 128 | s1327; - const SWord8 s1329 = 127 & s1327; - const SWord8 s1330 = s1326 ? s1328 : s1329; - const SBool s1331 = (SBool) (s1330 & 1); - const SBool s1332 = false != s1331; - const SBool s1333 = !s1332; - const SWord8 s1334 = (s1318 >> 1) | (s1318 << 7); - const SWord8 s1335 = 128 | s1334; - const SWord8 s1336 = 127 & s1334; - const SWord8 s1337 = s1036 ? s1335 : s1336; - const SWord8 s1338 = (s1337 >> 1) | (s1337 << 7); - const SWord8 s1339 = 128 | s1338; - const SWord8 s1340 = 127 & s1338; - const SWord8 s1341 = s1058 ? s1339 : s1340; - const SWord8 s1342 = (s1341 >> 1) | (s1341 << 7); - const SWord8 s1343 = 128 | s1342; - const SWord8 s1344 = 127 & s1342; - const SWord8 s1345 = s1310 ? s1343 : s1344; - const SWord8 s1346 = (s1345 >> 1) | (s1345 << 7); - const SWord8 s1347 = 128 | s1346; - const SWord8 s1348 = 127 & s1346; - const SWord8 s1349 = s1332 ? s1347 : s1348; - const SWord8 s1350 = s1 + s1345; - const SBool s1351 = s1350 < s1; - const SBool s1352 = s1350 < s1345; - const SBool s1353 = s1351 || s1352; - const SWord8 s1354 = (s1350 >> 1) | (s1350 << 7); - const SWord8 s1355 = 128 | s1354; - const SWord8 s1356 = 127 & s1354; - const SWord8 s1357 = s1353 ? s1355 : s1356; - const SWord8 s1358 = s1333 ? s1349 : s1357; - const SWord8 s1359 = s1 + s1341; - const SBool s1360 = s1359 < s1; - const SBool s1361 = s1359 < s1341; - const SBool s1362 = s1360 || s1361; - const SWord8 s1363 = (s1359 >> 1) | (s1359 << 7); - const SWord8 s1364 = 128 | s1363; - const SWord8 s1365 = 127 & s1363; - const SWord8 s1366 = s1362 ? s1364 : s1365; - const SWord8 s1367 = (s1366 >> 1) | (s1366 << 7); - const SWord8 s1368 = 128 | s1367; - const SWord8 s1369 = 127 & s1367; - const SWord8 s1370 = s1332 ? s1368 : s1369; - const SWord8 s1371 = s1 + s1366; - const SBool s1372 = s1371 < s1; - const SBool s1373 = s1371 < s1366; - const SBool s1374 = s1372 || s1373; - const SWord8 s1375 = (s1371 >> 1) | (s1371 << 7); - const SWord8 s1376 = 128 | s1375; - const SWord8 s1377 = 127 & s1375; - const SWord8 s1378 = s1374 ? s1376 : s1377; - const SWord8 s1379 = s1333 ? s1370 : s1378; - const SWord8 s1380 = s1311 ? s1358 : s1379; - const SWord8 s1381 = s1 + s1337; - const SBool s1382 = s1381 < s1; - const SBool s1383 = s1381 < s1337; - const SBool s1384 = s1382 || s1383; - const SWord8 s1385 = (s1381 >> 1) | (s1381 << 7); - const SWord8 s1386 = 128 | s1385; - const SWord8 s1387 = 127 & s1385; - const SWord8 s1388 = s1384 ? s1386 : s1387; - const SWord8 s1389 = (s1388 >> 1) | (s1388 << 7); - const SWord8 s1390 = 128 | s1389; - const SWord8 s1391 = 127 & s1389; - const SWord8 s1392 = s1310 ? s1390 : s1391; - const SWord8 s1393 = (s1392 >> 1) | (s1392 << 7); - const SWord8 s1394 = 128 | s1393; - const SWord8 s1395 = 127 & s1393; - const SWord8 s1396 = s1332 ? s1394 : s1395; - const SWord8 s1397 = s1 + s1392; - const SBool s1398 = s1397 < s1; - const SBool s1399 = s1397 < s1392; - const SBool s1400 = s1398 || s1399; - const SWord8 s1401 = (s1397 >> 1) | (s1397 << 7); - const SWord8 s1402 = 128 | s1401; - const SWord8 s1403 = 127 & s1401; - const SWord8 s1404 = s1400 ? s1402 : s1403; - const SWord8 s1405 = s1333 ? s1396 : s1404; - const SWord8 s1406 = s1 + s1388; - const SBool s1407 = s1406 < s1; - const SBool s1408 = s1406 < s1388; - const SBool s1409 = s1407 || s1408; - const SWord8 s1410 = (s1406 >> 1) | (s1406 << 7); - const SWord8 s1411 = 128 | s1410; - const SWord8 s1412 = 127 & s1410; - const SWord8 s1413 = s1409 ? s1411 : s1412; - const SWord8 s1414 = (s1413 >> 1) | (s1413 << 7); - const SWord8 s1415 = 128 | s1414; - const SWord8 s1416 = 127 & s1414; - const SWord8 s1417 = s1332 ? s1415 : s1416; - const SWord8 s1418 = s1 + s1413; - const SBool s1419 = s1418 < s1; - const SBool s1420 = s1418 < s1413; - const SBool s1421 = s1419 || s1420; - const SWord8 s1422 = (s1418 >> 1) | (s1418 << 7); - const SWord8 s1423 = 128 | s1422; - const SWord8 s1424 = 127 & s1422; - const SWord8 s1425 = s1421 ? s1423 : s1424; - const SWord8 s1426 = s1333 ? s1417 : s1425; - const SWord8 s1427 = s1311 ? s1405 : s1426; - const SWord8 s1428 = s1059 ? s1380 : s1427; - const SWord8 s1429 = s1 + s1318; - const SBool s1430 = (SBool) (s1429 & 1); - const SBool s1431 = false != s1430; - const SWord8 s1432 = s1431 ? s1322 : s1323; - const SBool s1433 = (SBool) (s1432 & 1); - const SBool s1434 = false != s1433; - const SWord8 s1435 = s1434 ? s1328 : s1329; - const SBool s1436 = (SBool) (s1435 & 1); - const SBool s1437 = false != s1436; - const SBool s1438 = !s1437; - const SBool s1439 = s1429 < s1; - const SBool s1440 = s1429 < s1318; - const SBool s1441 = s1439 || s1440; - const SWord8 s1442 = (s1429 >> 1) | (s1429 << 7); - const SWord8 s1443 = 128 | s1442; - const SWord8 s1444 = 127 & s1442; - const SWord8 s1445 = s1441 ? s1443 : s1444; - const SWord8 s1446 = (s1445 >> 1) | (s1445 << 7); - const SWord8 s1447 = 128 | s1446; - const SWord8 s1448 = 127 & s1446; - const SWord8 s1449 = s1058 ? s1447 : s1448; - const SWord8 s1450 = (s1449 >> 1) | (s1449 << 7); - const SWord8 s1451 = 128 | s1450; - const SWord8 s1452 = 127 & s1450; - const SWord8 s1453 = s1310 ? s1451 : s1452; - const SWord8 s1454 = (s1453 >> 1) | (s1453 << 7); - const SWord8 s1455 = 128 | s1454; - const SWord8 s1456 = 127 & s1454; - const SWord8 s1457 = s1437 ? s1455 : s1456; - const SWord8 s1458 = s1 + s1453; - const SBool s1459 = s1458 < s1; - const SBool s1460 = s1458 < s1453; - const SBool s1461 = s1459 || s1460; - const SWord8 s1462 = (s1458 >> 1) | (s1458 << 7); - const SWord8 s1463 = 128 | s1462; - const SWord8 s1464 = 127 & s1462; - const SWord8 s1465 = s1461 ? s1463 : s1464; - const SWord8 s1466 = s1438 ? s1457 : s1465; - const SWord8 s1467 = s1 + s1449; - const SBool s1468 = s1467 < s1; - const SBool s1469 = s1467 < s1449; - const SBool s1470 = s1468 || s1469; - const SWord8 s1471 = (s1467 >> 1) | (s1467 << 7); - const SWord8 s1472 = 128 | s1471; - const SWord8 s1473 = 127 & s1471; - const SWord8 s1474 = s1470 ? s1472 : s1473; - const SWord8 s1475 = (s1474 >> 1) | (s1474 << 7); - const SWord8 s1476 = 128 | s1475; - const SWord8 s1477 = 127 & s1475; - const SWord8 s1478 = s1437 ? s1476 : s1477; - const SWord8 s1479 = s1 + s1474; - const SBool s1480 = s1479 < s1; - const SBool s1481 = s1479 < s1474; - const SBool s1482 = s1480 || s1481; - const SWord8 s1483 = (s1479 >> 1) | (s1479 << 7); - const SWord8 s1484 = 128 | s1483; - const SWord8 s1485 = 127 & s1483; - const SWord8 s1486 = s1482 ? s1484 : s1485; - const SWord8 s1487 = s1438 ? s1478 : s1486; - const SWord8 s1488 = s1311 ? s1466 : s1487; - const SWord8 s1489 = s1 + s1445; - const SBool s1490 = s1489 < s1; - const SBool s1491 = s1489 < s1445; - const SBool s1492 = s1490 || s1491; - const SWord8 s1493 = (s1489 >> 1) | (s1489 << 7); - const SWord8 s1494 = 128 | s1493; - const SWord8 s1495 = 127 & s1493; - const SWord8 s1496 = s1492 ? s1494 : s1495; - const SWord8 s1497 = (s1496 >> 1) | (s1496 << 7); - const SWord8 s1498 = 128 | s1497; - const SWord8 s1499 = 127 & s1497; - const SWord8 s1500 = s1310 ? s1498 : s1499; - const SWord8 s1501 = (s1500 >> 1) | (s1500 << 7); - const SWord8 s1502 = 128 | s1501; - const SWord8 s1503 = 127 & s1501; - const SWord8 s1504 = s1437 ? s1502 : s1503; - const SWord8 s1505 = s1 + s1500; - const SBool s1506 = s1505 < s1; - const SBool s1507 = s1505 < s1500; - const SBool s1508 = s1506 || s1507; - const SWord8 s1509 = (s1505 >> 1) | (s1505 << 7); - const SWord8 s1510 = 128 | s1509; - const SWord8 s1511 = 127 & s1509; - const SWord8 s1512 = s1508 ? s1510 : s1511; - const SWord8 s1513 = s1438 ? s1504 : s1512; - const SWord8 s1514 = s1 + s1496; - const SBool s1515 = s1514 < s1; - const SBool s1516 = s1514 < s1496; - const SBool s1517 = s1515 || s1516; - const SWord8 s1518 = (s1514 >> 1) | (s1514 << 7); - const SWord8 s1519 = 128 | s1518; - const SWord8 s1520 = 127 & s1518; - const SWord8 s1521 = s1517 ? s1519 : s1520; - const SWord8 s1522 = (s1521 >> 1) | (s1521 << 7); - const SWord8 s1523 = 128 | s1522; - const SWord8 s1524 = 127 & s1522; - const SWord8 s1525 = s1437 ? s1523 : s1524; - const SWord8 s1526 = s1 + s1521; - const SBool s1527 = s1526 < s1; - const SBool s1528 = s1526 < s1521; - const SBool s1529 = s1527 || s1528; - const SWord8 s1530 = (s1526 >> 1) | (s1526 << 7); - const SWord8 s1531 = 128 | s1530; - const SWord8 s1532 = 127 & s1530; - const SWord8 s1533 = s1529 ? s1531 : s1532; - const SWord8 s1534 = s1438 ? s1525 : s1533; - const SWord8 s1535 = s1311 ? s1513 : s1534; - const SWord8 s1536 = s1059 ? s1488 : s1535; - const SWord8 s1537 = s1037 ? s1428 : s1536; - const SWord8 s1538 = s21 ? s1301 : s1537; - const SWord8 s1539 = s1 + s1044; - const SBool s1540 = (SBool) (s1539 & 1); - const SBool s1541 = false != s1540; - const SWord8 s1542 = s1541 ? s1048 : s1049; - const SBool s1543 = (SBool) (s1542 & 1); - const SBool s1544 = false != s1543; - const SWord8 s1545 = s1544 ? s1054 : s1055; - const SBool s1546 = (SBool) (s1545 & 1); - const SBool s1547 = false != s1546; - const SBool s1548 = !s1547; - const SBool s1549 = s1539 < s1; - const SBool s1550 = s1539 < s1044; - const SBool s1551 = s1549 || s1550; - const SWord8 s1552 = (s1539 >> 1) | (s1539 << 7); - const SWord8 s1553 = 128 | s1552; - const SWord8 s1554 = 127 & s1552; - const SWord8 s1555 = s1551 ? s1553 : s1554; - const SBool s1556 = (SBool) (s1555 & 1); - const SBool s1557 = false != s1556; - const SWord8 s1558 = (s1542 >> 1) | (s1542 << 7); - const SWord8 s1559 = 128 | s1558; - const SWord8 s1560 = 127 & s1558; - const SWord8 s1561 = s1557 ? s1559 : s1560; - const SBool s1562 = (SBool) (s1561 & 1); - const SBool s1563 = false != s1562; - const SWord8 s1564 = (s1545 >> 1) | (s1545 << 7); - const SWord8 s1565 = 128 | s1564; - const SWord8 s1566 = 127 & s1564; - const SWord8 s1567 = s1563 ? s1565 : s1566; - const SBool s1568 = (SBool) (s1567 & 1); - const SBool s1569 = false != s1568; - const SBool s1570 = !s1569; - const SWord8 s1571 = (s1555 >> 1) | (s1555 << 7); - const SWord8 s1572 = 128 | s1571; - const SWord8 s1573 = 127 & s1571; - const SWord8 s1574 = s20 ? s1572 : s1573; - const SBool s1575 = (SBool) (s1574 & 1); - const SBool s1576 = false != s1575; - const SWord8 s1577 = (s1561 >> 1) | (s1561 << 7); - const SWord8 s1578 = 128 | s1577; - const SWord8 s1579 = 127 & s1577; - const SWord8 s1580 = s1576 ? s1578 : s1579; - const SBool s1581 = (SBool) (s1580 & 1); - const SBool s1582 = false != s1581; - const SWord8 s1583 = (s1567 >> 1) | (s1567 << 7); - const SWord8 s1584 = 128 | s1583; - const SWord8 s1585 = 127 & s1583; - const SWord8 s1586 = s1582 ? s1584 : s1585; - const SBool s1587 = (SBool) (s1586 & 1); - const SBool s1588 = false != s1587; - const SBool s1589 = !s1588; - const SWord8 s1590 = (s1574 >> 1) | (s1574 << 7); - const SWord8 s1591 = 128 | s1590; - const SWord8 s1592 = 127 & s1590; - const SWord8 s1593 = s1036 ? s1591 : s1592; - const SWord8 s1594 = (s1593 >> 1) | (s1593 << 7); - const SWord8 s1595 = 128 | s1594; - const SWord8 s1596 = 127 & s1594; - const SWord8 s1597 = s1547 ? s1595 : s1596; - const SWord8 s1598 = (s1597 >> 1) | (s1597 << 7); - const SWord8 s1599 = 128 | s1598; - const SWord8 s1600 = 127 & s1598; - const SWord8 s1601 = s1569 ? s1599 : s1600; - const SWord8 s1602 = (s1601 >> 1) | (s1601 << 7); - const SWord8 s1603 = 128 | s1602; - const SWord8 s1604 = 127 & s1602; - const SWord8 s1605 = s1588 ? s1603 : s1604; - const SWord8 s1606 = s1 + s1601; - const SBool s1607 = s1606 < s1; - const SBool s1608 = s1606 < s1601; - const SBool s1609 = s1607 || s1608; - const SWord8 s1610 = (s1606 >> 1) | (s1606 << 7); - const SWord8 s1611 = 128 | s1610; - const SWord8 s1612 = 127 & s1610; - const SWord8 s1613 = s1609 ? s1611 : s1612; - const SWord8 s1614 = s1589 ? s1605 : s1613; - const SWord8 s1615 = s1 + s1597; - const SBool s1616 = s1615 < s1; - const SBool s1617 = s1615 < s1597; - const SBool s1618 = s1616 || s1617; - const SWord8 s1619 = (s1615 >> 1) | (s1615 << 7); - const SWord8 s1620 = 128 | s1619; - const SWord8 s1621 = 127 & s1619; - const SWord8 s1622 = s1618 ? s1620 : s1621; - const SWord8 s1623 = (s1622 >> 1) | (s1622 << 7); - const SWord8 s1624 = 128 | s1623; - const SWord8 s1625 = 127 & s1623; - const SWord8 s1626 = s1588 ? s1624 : s1625; - const SWord8 s1627 = s1 + s1622; - const SBool s1628 = s1627 < s1; - const SBool s1629 = s1627 < s1622; - const SBool s1630 = s1628 || s1629; - const SWord8 s1631 = (s1627 >> 1) | (s1627 << 7); - const SWord8 s1632 = 128 | s1631; - const SWord8 s1633 = 127 & s1631; - const SWord8 s1634 = s1630 ? s1632 : s1633; - const SWord8 s1635 = s1589 ? s1626 : s1634; - const SWord8 s1636 = s1570 ? s1614 : s1635; - const SWord8 s1637 = s1 + s1593; - const SBool s1638 = s1637 < s1; - const SBool s1639 = s1637 < s1593; - const SBool s1640 = s1638 || s1639; - const SWord8 s1641 = (s1637 >> 1) | (s1637 << 7); - const SWord8 s1642 = 128 | s1641; - const SWord8 s1643 = 127 & s1641; - const SWord8 s1644 = s1640 ? s1642 : s1643; - const SWord8 s1645 = (s1644 >> 1) | (s1644 << 7); - const SWord8 s1646 = 128 | s1645; - const SWord8 s1647 = 127 & s1645; - const SWord8 s1648 = s1569 ? s1646 : s1647; - const SWord8 s1649 = (s1648 >> 1) | (s1648 << 7); - const SWord8 s1650 = 128 | s1649; - const SWord8 s1651 = 127 & s1649; - const SWord8 s1652 = s1588 ? s1650 : s1651; - const SWord8 s1653 = s1 + s1648; - const SBool s1654 = s1653 < s1; - const SBool s1655 = s1653 < s1648; - const SBool s1656 = s1654 || s1655; - const SWord8 s1657 = (s1653 >> 1) | (s1653 << 7); - const SWord8 s1658 = 128 | s1657; - const SWord8 s1659 = 127 & s1657; - const SWord8 s1660 = s1656 ? s1658 : s1659; - const SWord8 s1661 = s1589 ? s1652 : s1660; - const SWord8 s1662 = s1 + s1644; - const SBool s1663 = s1662 < s1; - const SBool s1664 = s1662 < s1644; - const SBool s1665 = s1663 || s1664; - const SWord8 s1666 = (s1662 >> 1) | (s1662 << 7); - const SWord8 s1667 = 128 | s1666; - const SWord8 s1668 = 127 & s1666; - const SWord8 s1669 = s1665 ? s1667 : s1668; - const SWord8 s1670 = (s1669 >> 1) | (s1669 << 7); - const SWord8 s1671 = 128 | s1670; - const SWord8 s1672 = 127 & s1670; - const SWord8 s1673 = s1588 ? s1671 : s1672; - const SWord8 s1674 = s1 + s1669; - const SBool s1675 = s1674 < s1; - const SBool s1676 = s1674 < s1669; - const SBool s1677 = s1675 || s1676; - const SWord8 s1678 = (s1674 >> 1) | (s1674 << 7); - const SWord8 s1679 = 128 | s1678; - const SWord8 s1680 = 127 & s1678; - const SWord8 s1681 = s1677 ? s1679 : s1680; - const SWord8 s1682 = s1589 ? s1673 : s1681; - const SWord8 s1683 = s1570 ? s1661 : s1682; - const SWord8 s1684 = s1548 ? s1636 : s1683; - const SWord8 s1685 = s1 + s1574; - const SBool s1686 = (SBool) (s1685 & 1); - const SBool s1687 = false != s1686; - const SWord8 s1688 = s1687 ? s1578 : s1579; - const SBool s1689 = (SBool) (s1688 & 1); - const SBool s1690 = false != s1689; - const SWord8 s1691 = s1690 ? s1584 : s1585; - const SBool s1692 = (SBool) (s1691 & 1); - const SBool s1693 = false != s1692; - const SBool s1694 = !s1693; - const SBool s1695 = s1685 < s1; - const SBool s1696 = s1685 < s1574; - const SBool s1697 = s1695 || s1696; - const SWord8 s1698 = (s1685 >> 1) | (s1685 << 7); - const SWord8 s1699 = 128 | s1698; - const SWord8 s1700 = 127 & s1698; - const SWord8 s1701 = s1697 ? s1699 : s1700; - const SWord8 s1702 = (s1701 >> 1) | (s1701 << 7); - const SWord8 s1703 = 128 | s1702; - const SWord8 s1704 = 127 & s1702; - const SWord8 s1705 = s1547 ? s1703 : s1704; - const SWord8 s1706 = (s1705 >> 1) | (s1705 << 7); - const SWord8 s1707 = 128 | s1706; - const SWord8 s1708 = 127 & s1706; - const SWord8 s1709 = s1569 ? s1707 : s1708; - const SWord8 s1710 = (s1709 >> 1) | (s1709 << 7); - const SWord8 s1711 = 128 | s1710; - const SWord8 s1712 = 127 & s1710; - const SWord8 s1713 = s1693 ? s1711 : s1712; - const SWord8 s1714 = s1 + s1709; - const SBool s1715 = s1714 < s1; - const SBool s1716 = s1714 < s1709; - const SBool s1717 = s1715 || s1716; - const SWord8 s1718 = (s1714 >> 1) | (s1714 << 7); - const SWord8 s1719 = 128 | s1718; - const SWord8 s1720 = 127 & s1718; - const SWord8 s1721 = s1717 ? s1719 : s1720; - const SWord8 s1722 = s1694 ? s1713 : s1721; - const SWord8 s1723 = s1 + s1705; - const SBool s1724 = s1723 < s1; - const SBool s1725 = s1723 < s1705; - const SBool s1726 = s1724 || s1725; - const SWord8 s1727 = (s1723 >> 1) | (s1723 << 7); - const SWord8 s1728 = 128 | s1727; - const SWord8 s1729 = 127 & s1727; - const SWord8 s1730 = s1726 ? s1728 : s1729; - const SWord8 s1731 = (s1730 >> 1) | (s1730 << 7); - const SWord8 s1732 = 128 | s1731; - const SWord8 s1733 = 127 & s1731; - const SWord8 s1734 = s1693 ? s1732 : s1733; - const SWord8 s1735 = s1 + s1730; - const SBool s1736 = s1735 < s1; - const SBool s1737 = s1735 < s1730; - const SBool s1738 = s1736 || s1737; - const SWord8 s1739 = (s1735 >> 1) | (s1735 << 7); - const SWord8 s1740 = 128 | s1739; - const SWord8 s1741 = 127 & s1739; - const SWord8 s1742 = s1738 ? s1740 : s1741; - const SWord8 s1743 = s1694 ? s1734 : s1742; - const SWord8 s1744 = s1570 ? s1722 : s1743; - const SWord8 s1745 = s1 + s1701; - const SBool s1746 = s1745 < s1; - const SBool s1747 = s1745 < s1701; - const SBool s1748 = s1746 || s1747; - const SWord8 s1749 = (s1745 >> 1) | (s1745 << 7); - const SWord8 s1750 = 128 | s1749; - const SWord8 s1751 = 127 & s1749; - const SWord8 s1752 = s1748 ? s1750 : s1751; - const SWord8 s1753 = (s1752 >> 1) | (s1752 << 7); - const SWord8 s1754 = 128 | s1753; - const SWord8 s1755 = 127 & s1753; - const SWord8 s1756 = s1569 ? s1754 : s1755; - const SWord8 s1757 = (s1756 >> 1) | (s1756 << 7); - const SWord8 s1758 = 128 | s1757; - const SWord8 s1759 = 127 & s1757; - const SWord8 s1760 = s1693 ? s1758 : s1759; - const SWord8 s1761 = s1 + s1756; - const SBool s1762 = s1761 < s1; - const SBool s1763 = s1761 < s1756; - const SBool s1764 = s1762 || s1763; - const SWord8 s1765 = (s1761 >> 1) | (s1761 << 7); - const SWord8 s1766 = 128 | s1765; - const SWord8 s1767 = 127 & s1765; - const SWord8 s1768 = s1764 ? s1766 : s1767; - const SWord8 s1769 = s1694 ? s1760 : s1768; - const SWord8 s1770 = s1 + s1752; - const SBool s1771 = s1770 < s1; - const SBool s1772 = s1770 < s1752; - const SBool s1773 = s1771 || s1772; - const SWord8 s1774 = (s1770 >> 1) | (s1770 << 7); - const SWord8 s1775 = 128 | s1774; - const SWord8 s1776 = 127 & s1774; - const SWord8 s1777 = s1773 ? s1775 : s1776; - const SWord8 s1778 = (s1777 >> 1) | (s1777 << 7); - const SWord8 s1779 = 128 | s1778; - const SWord8 s1780 = 127 & s1778; - const SWord8 s1781 = s1693 ? s1779 : s1780; - const SWord8 s1782 = s1 + s1777; - const SBool s1783 = s1782 < s1; - const SBool s1784 = s1782 < s1777; - const SBool s1785 = s1783 || s1784; - const SWord8 s1786 = (s1782 >> 1) | (s1782 << 7); - const SWord8 s1787 = 128 | s1786; - const SWord8 s1788 = 127 & s1786; - const SWord8 s1789 = s1785 ? s1787 : s1788; - const SWord8 s1790 = s1694 ? s1781 : s1789; - const SWord8 s1791 = s1570 ? s1769 : s1790; - const SWord8 s1792 = s1548 ? s1744 : s1791; - const SWord8 s1793 = s1037 ? s1684 : s1792; - const SWord8 s1794 = s1 + s1555; - const SBool s1795 = (SBool) (s1794 & 1); - const SBool s1796 = false != s1795; - const SWord8 s1797 = s1796 ? s1559 : s1560; - const SBool s1798 = (SBool) (s1797 & 1); - const SBool s1799 = false != s1798; - const SWord8 s1800 = s1799 ? s1565 : s1566; - const SBool s1801 = (SBool) (s1800 & 1); - const SBool s1802 = false != s1801; - const SBool s1803 = !s1802; - const SBool s1804 = s1794 < s1; - const SBool s1805 = s1794 < s1555; - const SBool s1806 = s1804 || s1805; - const SWord8 s1807 = (s1794 >> 1) | (s1794 << 7); - const SWord8 s1808 = 128 | s1807; - const SWord8 s1809 = 127 & s1807; - const SWord8 s1810 = s1806 ? s1808 : s1809; - const SBool s1811 = (SBool) (s1810 & 1); - const SBool s1812 = false != s1811; - const SWord8 s1813 = (s1797 >> 1) | (s1797 << 7); - const SWord8 s1814 = 128 | s1813; - const SWord8 s1815 = 127 & s1813; - const SWord8 s1816 = s1812 ? s1814 : s1815; - const SBool s1817 = (SBool) (s1816 & 1); - const SBool s1818 = false != s1817; - const SWord8 s1819 = (s1800 >> 1) | (s1800 << 7); - const SWord8 s1820 = 128 | s1819; - const SWord8 s1821 = 127 & s1819; - const SWord8 s1822 = s1818 ? s1820 : s1821; - const SBool s1823 = (SBool) (s1822 & 1); - const SBool s1824 = false != s1823; - const SBool s1825 = !s1824; - const SWord8 s1826 = (s1810 >> 1) | (s1810 << 7); - const SWord8 s1827 = 128 | s1826; - const SWord8 s1828 = 127 & s1826; - const SWord8 s1829 = s1036 ? s1827 : s1828; - const SWord8 s1830 = (s1829 >> 1) | (s1829 << 7); - const SWord8 s1831 = 128 | s1830; - const SWord8 s1832 = 127 & s1830; - const SWord8 s1833 = s1547 ? s1831 : s1832; - const SWord8 s1834 = (s1833 >> 1) | (s1833 << 7); - const SWord8 s1835 = 128 | s1834; - const SWord8 s1836 = 127 & s1834; - const SWord8 s1837 = s1802 ? s1835 : s1836; - const SWord8 s1838 = (s1837 >> 1) | (s1837 << 7); - const SWord8 s1839 = 128 | s1838; - const SWord8 s1840 = 127 & s1838; - const SWord8 s1841 = s1824 ? s1839 : s1840; - const SWord8 s1842 = s1 + s1837; - const SBool s1843 = s1842 < s1; - const SBool s1844 = s1842 < s1837; - const SBool s1845 = s1843 || s1844; - const SWord8 s1846 = (s1842 >> 1) | (s1842 << 7); - const SWord8 s1847 = 128 | s1846; - const SWord8 s1848 = 127 & s1846; - const SWord8 s1849 = s1845 ? s1847 : s1848; - const SWord8 s1850 = s1825 ? s1841 : s1849; - const SWord8 s1851 = s1 + s1833; - const SBool s1852 = s1851 < s1; - const SBool s1853 = s1851 < s1833; - const SBool s1854 = s1852 || s1853; - const SWord8 s1855 = (s1851 >> 1) | (s1851 << 7); - const SWord8 s1856 = 128 | s1855; - const SWord8 s1857 = 127 & s1855; - const SWord8 s1858 = s1854 ? s1856 : s1857; - const SWord8 s1859 = (s1858 >> 1) | (s1858 << 7); - const SWord8 s1860 = 128 | s1859; - const SWord8 s1861 = 127 & s1859; - const SWord8 s1862 = s1824 ? s1860 : s1861; - const SWord8 s1863 = s1 + s1858; - const SBool s1864 = s1863 < s1; - const SBool s1865 = s1863 < s1858; - const SBool s1866 = s1864 || s1865; - const SWord8 s1867 = (s1863 >> 1) | (s1863 << 7); - const SWord8 s1868 = 128 | s1867; - const SWord8 s1869 = 127 & s1867; - const SWord8 s1870 = s1866 ? s1868 : s1869; - const SWord8 s1871 = s1825 ? s1862 : s1870; - const SWord8 s1872 = s1803 ? s1850 : s1871; - const SWord8 s1873 = s1 + s1829; - const SBool s1874 = s1873 < s1; - const SBool s1875 = s1873 < s1829; - const SBool s1876 = s1874 || s1875; - const SWord8 s1877 = (s1873 >> 1) | (s1873 << 7); - const SWord8 s1878 = 128 | s1877; - const SWord8 s1879 = 127 & s1877; - const SWord8 s1880 = s1876 ? s1878 : s1879; - const SWord8 s1881 = (s1880 >> 1) | (s1880 << 7); - const SWord8 s1882 = 128 | s1881; - const SWord8 s1883 = 127 & s1881; - const SWord8 s1884 = s1802 ? s1882 : s1883; - const SWord8 s1885 = (s1884 >> 1) | (s1884 << 7); - const SWord8 s1886 = 128 | s1885; - const SWord8 s1887 = 127 & s1885; - const SWord8 s1888 = s1824 ? s1886 : s1887; - const SWord8 s1889 = s1 + s1884; - const SBool s1890 = s1889 < s1; - const SBool s1891 = s1889 < s1884; - const SBool s1892 = s1890 || s1891; - const SWord8 s1893 = (s1889 >> 1) | (s1889 << 7); - const SWord8 s1894 = 128 | s1893; - const SWord8 s1895 = 127 & s1893; - const SWord8 s1896 = s1892 ? s1894 : s1895; - const SWord8 s1897 = s1825 ? s1888 : s1896; - const SWord8 s1898 = s1 + s1880; - const SBool s1899 = s1898 < s1; - const SBool s1900 = s1898 < s1880; - const SBool s1901 = s1899 || s1900; - const SWord8 s1902 = (s1898 >> 1) | (s1898 << 7); - const SWord8 s1903 = 128 | s1902; - const SWord8 s1904 = 127 & s1902; - const SWord8 s1905 = s1901 ? s1903 : s1904; - const SWord8 s1906 = (s1905 >> 1) | (s1905 << 7); - const SWord8 s1907 = 128 | s1906; - const SWord8 s1908 = 127 & s1906; - const SWord8 s1909 = s1824 ? s1907 : s1908; - const SWord8 s1910 = s1 + s1905; - const SBool s1911 = s1910 < s1; - const SBool s1912 = s1910 < s1905; - const SBool s1913 = s1911 || s1912; - const SWord8 s1914 = (s1910 >> 1) | (s1910 << 7); - const SWord8 s1915 = 128 | s1914; - const SWord8 s1916 = 127 & s1914; - const SWord8 s1917 = s1913 ? s1915 : s1916; - const SWord8 s1918 = s1825 ? s1909 : s1917; - const SWord8 s1919 = s1803 ? s1897 : s1918; - const SWord8 s1920 = s1548 ? s1872 : s1919; - const SWord8 s1921 = s1 + s1810; - const SBool s1922 = (SBool) (s1921 & 1); - const SBool s1923 = false != s1922; - const SWord8 s1924 = s1923 ? s1814 : s1815; - const SBool s1925 = (SBool) (s1924 & 1); - const SBool s1926 = false != s1925; - const SWord8 s1927 = s1926 ? s1820 : s1821; - const SBool s1928 = (SBool) (s1927 & 1); - const SBool s1929 = false != s1928; - const SBool s1930 = !s1929; - const SBool s1931 = s1921 < s1; - const SBool s1932 = s1921 < s1810; - const SBool s1933 = s1931 || s1932; - const SWord8 s1934 = (s1921 >> 1) | (s1921 << 7); - const SWord8 s1935 = 128 | s1934; - const SWord8 s1936 = 127 & s1934; - const SWord8 s1937 = s1933 ? s1935 : s1936; - const SWord8 s1938 = (s1937 >> 1) | (s1937 << 7); - const SWord8 s1939 = 128 | s1938; - const SWord8 s1940 = 127 & s1938; - const SWord8 s1941 = s1547 ? s1939 : s1940; - const SWord8 s1942 = (s1941 >> 1) | (s1941 << 7); - const SWord8 s1943 = 128 | s1942; - const SWord8 s1944 = 127 & s1942; - const SWord8 s1945 = s1802 ? s1943 : s1944; - const SWord8 s1946 = (s1945 >> 1) | (s1945 << 7); - const SWord8 s1947 = 128 | s1946; - const SWord8 s1948 = 127 & s1946; - const SWord8 s1949 = s1929 ? s1947 : s1948; - const SWord8 s1950 = s1 + s1945; - const SBool s1951 = s1950 < s1; - const SBool s1952 = s1950 < s1945; - const SBool s1953 = s1951 || s1952; - const SWord8 s1954 = (s1950 >> 1) | (s1950 << 7); - const SWord8 s1955 = 128 | s1954; - const SWord8 s1956 = 127 & s1954; - const SWord8 s1957 = s1953 ? s1955 : s1956; - const SWord8 s1958 = s1930 ? s1949 : s1957; - const SWord8 s1959 = s1 + s1941; - const SBool s1960 = s1959 < s1; - const SBool s1961 = s1959 < s1941; - const SBool s1962 = s1960 || s1961; - const SWord8 s1963 = (s1959 >> 1) | (s1959 << 7); - const SWord8 s1964 = 128 | s1963; - const SWord8 s1965 = 127 & s1963; - const SWord8 s1966 = s1962 ? s1964 : s1965; - const SWord8 s1967 = (s1966 >> 1) | (s1966 << 7); - const SWord8 s1968 = 128 | s1967; - const SWord8 s1969 = 127 & s1967; - const SWord8 s1970 = s1929 ? s1968 : s1969; - const SWord8 s1971 = s1 + s1966; - const SBool s1972 = s1971 < s1; - const SBool s1973 = s1971 < s1966; - const SBool s1974 = s1972 || s1973; - const SWord8 s1975 = (s1971 >> 1) | (s1971 << 7); - const SWord8 s1976 = 128 | s1975; - const SWord8 s1977 = 127 & s1975; - const SWord8 s1978 = s1974 ? s1976 : s1977; - const SWord8 s1979 = s1930 ? s1970 : s1978; - const SWord8 s1980 = s1803 ? s1958 : s1979; - const SWord8 s1981 = s1 + s1937; - const SBool s1982 = s1981 < s1; - const SBool s1983 = s1981 < s1937; - const SBool s1984 = s1982 || s1983; - const SWord8 s1985 = (s1981 >> 1) | (s1981 << 7); - const SWord8 s1986 = 128 | s1985; - const SWord8 s1987 = 127 & s1985; - const SWord8 s1988 = s1984 ? s1986 : s1987; - const SWord8 s1989 = (s1988 >> 1) | (s1988 << 7); - const SWord8 s1990 = 128 | s1989; - const SWord8 s1991 = 127 & s1989; - const SWord8 s1992 = s1802 ? s1990 : s1991; - const SWord8 s1993 = (s1992 >> 1) | (s1992 << 7); - const SWord8 s1994 = 128 | s1993; - const SWord8 s1995 = 127 & s1993; - const SWord8 s1996 = s1929 ? s1994 : s1995; - const SWord8 s1997 = s1 + s1992; - const SBool s1998 = s1997 < s1; - const SBool s1999 = s1997 < s1992; - const SBool s2000 = s1998 || s1999; - const SWord8 s2001 = (s1997 >> 1) | (s1997 << 7); - const SWord8 s2002 = 128 | s2001; - const SWord8 s2003 = 127 & s2001; - const SWord8 s2004 = s2000 ? s2002 : s2003; - const SWord8 s2005 = s1930 ? s1996 : s2004; - const SWord8 s2006 = s1 + s1988; - const SBool s2007 = s2006 < s1; - const SBool s2008 = s2006 < s1988; - const SBool s2009 = s2007 || s2008; - const SWord8 s2010 = (s2006 >> 1) | (s2006 << 7); - const SWord8 s2011 = 128 | s2010; - const SWord8 s2012 = 127 & s2010; - const SWord8 s2013 = s2009 ? s2011 : s2012; - const SWord8 s2014 = (s2013 >> 1) | (s2013 << 7); - const SWord8 s2015 = 128 | s2014; - const SWord8 s2016 = 127 & s2014; - const SWord8 s2017 = s1929 ? s2015 : s2016; - const SWord8 s2018 = s1 + s2013; - const SBool s2019 = s2018 < s1; - const SBool s2020 = s2018 < s2013; - const SBool s2021 = s2019 || s2020; - const SWord8 s2022 = (s2018 >> 1) | (s2018 << 7); - const SWord8 s2023 = 128 | s2022; - const SWord8 s2024 = 127 & s2022; - const SWord8 s2025 = s2021 ? s2023 : s2024; - const SWord8 s2026 = s1930 ? s2017 : s2025; - const SWord8 s2027 = s1803 ? s2005 : s2026; - const SWord8 s2028 = s1548 ? s1980 : s2027; - const SWord8 s2029 = s1037 ? s1920 : s2028; - const SWord8 s2030 = s21 ? s1793 : s2029; - const SWord8 s2031 = s16 ? s1538 : s2030; - const SWord8 s2032 = s11 ? s1027 : s2031; - const SBool s2033 = (SBool) (s1 & 1); - const SBool s2034 = false != s2033; - const SWord8 s2035 = s2034 ? 128 : 0; - const SBool s2036 = (SBool) (s2035 & 1); - const SBool s2037 = false != s2036; - const SWord8 s2038 = s17 | 128; - const SWord8 s2039 = s2037 ? s2038 : s18; - const SBool s2040 = (SBool) (s2039 & 1); - const SBool s2041 = false != s2040; - const SBool s2042 = !s2041; - const SWord8 s2043 = (s1 >> 1) | (s1 << 7); - const SWord8 s2044 = 127 & s2043; - const SBool s2045 = (SBool) (s2044 & 1); - const SBool s2046 = false != s2045; - const SWord8 s2047 = (s2035 >> 1) | (s2035 << 7); - const SWord8 s2048 = 128 | s2047; - const SWord8 s2049 = 127 & s2047; - const SWord8 s2050 = s2046 ? s2048 : s2049; - const SBool s2051 = (SBool) (s2050 & 1); - const SBool s2052 = false != s2051; - const SWord8 s2053 = (s2039 >> 1) | (s2039 << 7); - const SWord8 s2054 = 128 | s2053; - const SWord8 s2055 = 127 & s2053; - const SWord8 s2056 = s2052 ? s2054 : s2055; - const SBool s2057 = (SBool) (s2056 & 1); - const SBool s2058 = false != s2057; - const SBool s2059 = !s2058; - const SWord8 s2060 = (s2044 >> 1) | (s2044 << 7); - const SWord8 s2061 = 128 | s2060; - const SWord8 s2062 = 127 & s2060; - const SWord8 s2063 = s10 ? s2061 : s2062; - const SBool s2064 = (SBool) (s2063 & 1); - const SBool s2065 = false != s2064; - const SWord8 s2066 = (s2050 >> 1) | (s2050 << 7); - const SWord8 s2067 = 128 | s2066; - const SWord8 s2068 = 127 & s2066; - const SWord8 s2069 = s2065 ? s2067 : s2068; - const SBool s2070 = (SBool) (s2069 & 1); - const SBool s2071 = false != s2070; - const SWord8 s2072 = (s2056 >> 1) | (s2056 << 7); - const SWord8 s2073 = 128 | s2072; - const SWord8 s2074 = 127 & s2072; - const SWord8 s2075 = s2071 ? s2073 : s2074; - const SBool s2076 = (SBool) (s2075 & 1); - const SBool s2077 = false != s2076; - const SBool s2078 = !s2077; - const SWord8 s2079 = (s2063 >> 1) | (s2063 << 7); - const SWord8 s2080 = 128 | s2079; - const SWord8 s2081 = 127 & s2079; - const SWord8 s2082 = s15 ? s2080 : s2081; - const SBool s2083 = (SBool) (s2082 & 1); - const SBool s2084 = false != s2083; - const SWord8 s2085 = (s2069 >> 1) | (s2069 << 7); - const SWord8 s2086 = 128 | s2085; - const SWord8 s2087 = 127 & s2085; - const SWord8 s2088 = s2084 ? s2086 : s2087; - const SBool s2089 = (SBool) (s2088 & 1); - const SBool s2090 = false != s2089; - const SWord8 s2091 = (s2075 >> 1) | (s2075 << 7); - const SWord8 s2092 = 128 | s2091; - const SWord8 s2093 = 127 & s2091; - const SWord8 s2094 = s2090 ? s2092 : s2093; - const SBool s2095 = (SBool) (s2094 & 1); - const SBool s2096 = false != s2095; - const SBool s2097 = !s2096; - const SWord8 s2098 = (s2082 >> 1) | (s2082 << 7); - const SWord8 s2099 = 128 | s2098; - const SWord8 s2100 = 127 & s2098; - const SWord8 s2101 = s2041 ? s2099 : s2100; - const SBool s2102 = (SBool) (s2101 & 1); - const SBool s2103 = false != s2102; - const SWord8 s2104 = (s2088 >> 1) | (s2088 << 7); - const SWord8 s2105 = 128 | s2104; - const SWord8 s2106 = 127 & s2104; - const SWord8 s2107 = s2103 ? s2105 : s2106; - const SBool s2108 = (SBool) (s2107 & 1); - const SBool s2109 = false != s2108; - const SWord8 s2110 = (s2094 >> 1) | (s2094 << 7); - const SWord8 s2111 = 128 | s2110; - const SWord8 s2112 = 127 & s2110; - const SWord8 s2113 = s2109 ? s2111 : s2112; - const SBool s2114 = (SBool) (s2113 & 1); - const SBool s2115 = false != s2114; - const SBool s2116 = !s2115; - const SWord8 s2117 = (s2101 >> 1) | (s2101 << 7); - const SWord8 s2118 = 128 | s2117; - const SWord8 s2119 = 127 & s2117; - const SWord8 s2120 = s2058 ? s2118 : s2119; - const SWord8 s2121 = (s2120 >> 1) | (s2120 << 7); - const SWord8 s2122 = 128 | s2121; - const SWord8 s2123 = 127 & s2121; - const SWord8 s2124 = s2077 ? s2122 : s2123; - const SWord8 s2125 = (s2124 >> 1) | (s2124 << 7); - const SWord8 s2126 = 128 | s2125; - const SWord8 s2127 = 127 & s2125; - const SWord8 s2128 = s2096 ? s2126 : s2127; - const SWord8 s2129 = (s2128 >> 1) | (s2128 << 7); - const SWord8 s2130 = 128 | s2129; - const SWord8 s2131 = 127 & s2129; - const SWord8 s2132 = s2115 ? s2130 : s2131; - const SWord8 s2133 = s1 + s2128; - const SBool s2134 = s2133 < s1; - const SBool s2135 = s2133 < s2128; - const SBool s2136 = s2134 || s2135; - const SWord8 s2137 = (s2133 >> 1) | (s2133 << 7); - const SWord8 s2138 = 128 | s2137; - const SWord8 s2139 = 127 & s2137; - const SWord8 s2140 = s2136 ? s2138 : s2139; - const SWord8 s2141 = s2116 ? s2132 : s2140; - const SWord8 s2142 = s1 + s2124; - const SBool s2143 = s2142 < s1; - const SBool s2144 = s2142 < s2124; - const SBool s2145 = s2143 || s2144; - const SWord8 s2146 = (s2142 >> 1) | (s2142 << 7); - const SWord8 s2147 = 128 | s2146; - const SWord8 s2148 = 127 & s2146; - const SWord8 s2149 = s2145 ? s2147 : s2148; - const SWord8 s2150 = (s2149 >> 1) | (s2149 << 7); - const SWord8 s2151 = 128 | s2150; - const SWord8 s2152 = 127 & s2150; - const SWord8 s2153 = s2115 ? s2151 : s2152; - const SWord8 s2154 = s1 + s2149; - const SBool s2155 = s2154 < s1; - const SBool s2156 = s2154 < s2149; - const SBool s2157 = s2155 || s2156; - const SWord8 s2158 = (s2154 >> 1) | (s2154 << 7); - const SWord8 s2159 = 128 | s2158; - const SWord8 s2160 = 127 & s2158; - const SWord8 s2161 = s2157 ? s2159 : s2160; - const SWord8 s2162 = s2116 ? s2153 : s2161; - const SWord8 s2163 = s2097 ? s2141 : s2162; - const SWord8 s2164 = s1 + s2120; - const SBool s2165 = s2164 < s1; - const SBool s2166 = s2164 < s2120; - const SBool s2167 = s2165 || s2166; - const SWord8 s2168 = (s2164 >> 1) | (s2164 << 7); - const SWord8 s2169 = 128 | s2168; - const SWord8 s2170 = 127 & s2168; - const SWord8 s2171 = s2167 ? s2169 : s2170; - const SWord8 s2172 = (s2171 >> 1) | (s2171 << 7); - const SWord8 s2173 = 128 | s2172; - const SWord8 s2174 = 127 & s2172; - const SWord8 s2175 = s2096 ? s2173 : s2174; - const SWord8 s2176 = (s2175 >> 1) | (s2175 << 7); - const SWord8 s2177 = 128 | s2176; - const SWord8 s2178 = 127 & s2176; - const SWord8 s2179 = s2115 ? s2177 : s2178; - const SWord8 s2180 = s1 + s2175; - const SBool s2181 = s2180 < s1; - const SBool s2182 = s2180 < s2175; - const SBool s2183 = s2181 || s2182; - const SWord8 s2184 = (s2180 >> 1) | (s2180 << 7); - const SWord8 s2185 = 128 | s2184; - const SWord8 s2186 = 127 & s2184; - const SWord8 s2187 = s2183 ? s2185 : s2186; - const SWord8 s2188 = s2116 ? s2179 : s2187; - const SWord8 s2189 = s1 + s2171; - const SBool s2190 = s2189 < s1; - const SBool s2191 = s2189 < s2171; - const SBool s2192 = s2190 || s2191; - const SWord8 s2193 = (s2189 >> 1) | (s2189 << 7); - const SWord8 s2194 = 128 | s2193; - const SWord8 s2195 = 127 & s2193; - const SWord8 s2196 = s2192 ? s2194 : s2195; - const SWord8 s2197 = (s2196 >> 1) | (s2196 << 7); - const SWord8 s2198 = 128 | s2197; - const SWord8 s2199 = 127 & s2197; - const SWord8 s2200 = s2115 ? s2198 : s2199; - const SWord8 s2201 = s1 + s2196; - const SBool s2202 = s2201 < s1; - const SBool s2203 = s2201 < s2196; - const SBool s2204 = s2202 || s2203; - const SWord8 s2205 = (s2201 >> 1) | (s2201 << 7); - const SWord8 s2206 = 128 | s2205; - const SWord8 s2207 = 127 & s2205; - const SWord8 s2208 = s2204 ? s2206 : s2207; - const SWord8 s2209 = s2116 ? s2200 : s2208; - const SWord8 s2210 = s2097 ? s2188 : s2209; - const SWord8 s2211 = s2078 ? s2163 : s2210; - const SWord8 s2212 = s1 + s2101; - const SBool s2213 = (SBool) (s2212 & 1); - const SBool s2214 = false != s2213; - const SWord8 s2215 = s2214 ? s2105 : s2106; - const SBool s2216 = (SBool) (s2215 & 1); - const SBool s2217 = false != s2216; - const SWord8 s2218 = s2217 ? s2111 : s2112; - const SBool s2219 = (SBool) (s2218 & 1); - const SBool s2220 = false != s2219; - const SBool s2221 = !s2220; - const SBool s2222 = s2212 < s1; - const SBool s2223 = s2212 < s2101; - const SBool s2224 = s2222 || s2223; - const SWord8 s2225 = (s2212 >> 1) | (s2212 << 7); - const SWord8 s2226 = 128 | s2225; - const SWord8 s2227 = 127 & s2225; - const SWord8 s2228 = s2224 ? s2226 : s2227; - const SWord8 s2229 = (s2228 >> 1) | (s2228 << 7); - const SWord8 s2230 = 128 | s2229; - const SWord8 s2231 = 127 & s2229; - const SWord8 s2232 = s2077 ? s2230 : s2231; - const SWord8 s2233 = (s2232 >> 1) | (s2232 << 7); - const SWord8 s2234 = 128 | s2233; - const SWord8 s2235 = 127 & s2233; - const SWord8 s2236 = s2096 ? s2234 : s2235; - const SWord8 s2237 = (s2236 >> 1) | (s2236 << 7); - const SWord8 s2238 = 128 | s2237; - const SWord8 s2239 = 127 & s2237; - const SWord8 s2240 = s2220 ? s2238 : s2239; - const SWord8 s2241 = s1 + s2236; - const SBool s2242 = s2241 < s1; - const SBool s2243 = s2241 < s2236; - const SBool s2244 = s2242 || s2243; - const SWord8 s2245 = (s2241 >> 1) | (s2241 << 7); - const SWord8 s2246 = 128 | s2245; - const SWord8 s2247 = 127 & s2245; - const SWord8 s2248 = s2244 ? s2246 : s2247; - const SWord8 s2249 = s2221 ? s2240 : s2248; - const SWord8 s2250 = s1 + s2232; - const SBool s2251 = s2250 < s1; - const SBool s2252 = s2250 < s2232; - const SBool s2253 = s2251 || s2252; - const SWord8 s2254 = (s2250 >> 1) | (s2250 << 7); - const SWord8 s2255 = 128 | s2254; - const SWord8 s2256 = 127 & s2254; - const SWord8 s2257 = s2253 ? s2255 : s2256; - const SWord8 s2258 = (s2257 >> 1) | (s2257 << 7); - const SWord8 s2259 = 128 | s2258; - const SWord8 s2260 = 127 & s2258; - const SWord8 s2261 = s2220 ? s2259 : s2260; - const SWord8 s2262 = s1 + s2257; - const SBool s2263 = s2262 < s1; - const SBool s2264 = s2262 < s2257; - const SBool s2265 = s2263 || s2264; - const SWord8 s2266 = (s2262 >> 1) | (s2262 << 7); - const SWord8 s2267 = 128 | s2266; - const SWord8 s2268 = 127 & s2266; - const SWord8 s2269 = s2265 ? s2267 : s2268; - const SWord8 s2270 = s2221 ? s2261 : s2269; - const SWord8 s2271 = s2097 ? s2249 : s2270; - const SWord8 s2272 = s1 + s2228; - const SBool s2273 = s2272 < s1; - const SBool s2274 = s2272 < s2228; - const SBool s2275 = s2273 || s2274; - const SWord8 s2276 = (s2272 >> 1) | (s2272 << 7); - const SWord8 s2277 = 128 | s2276; - const SWord8 s2278 = 127 & s2276; - const SWord8 s2279 = s2275 ? s2277 : s2278; - const SWord8 s2280 = (s2279 >> 1) | (s2279 << 7); - const SWord8 s2281 = 128 | s2280; - const SWord8 s2282 = 127 & s2280; - const SWord8 s2283 = s2096 ? s2281 : s2282; - const SWord8 s2284 = (s2283 >> 1) | (s2283 << 7); - const SWord8 s2285 = 128 | s2284; - const SWord8 s2286 = 127 & s2284; - const SWord8 s2287 = s2220 ? s2285 : s2286; - const SWord8 s2288 = s1 + s2283; - const SBool s2289 = s2288 < s1; - const SBool s2290 = s2288 < s2283; - const SBool s2291 = s2289 || s2290; - const SWord8 s2292 = (s2288 >> 1) | (s2288 << 7); - const SWord8 s2293 = 128 | s2292; - const SWord8 s2294 = 127 & s2292; - const SWord8 s2295 = s2291 ? s2293 : s2294; - const SWord8 s2296 = s2221 ? s2287 : s2295; - const SWord8 s2297 = s1 + s2279; - const SBool s2298 = s2297 < s1; - const SBool s2299 = s2297 < s2279; - const SBool s2300 = s2298 || s2299; - const SWord8 s2301 = (s2297 >> 1) | (s2297 << 7); - const SWord8 s2302 = 128 | s2301; - const SWord8 s2303 = 127 & s2301; - const SWord8 s2304 = s2300 ? s2302 : s2303; - const SWord8 s2305 = (s2304 >> 1) | (s2304 << 7); - const SWord8 s2306 = 128 | s2305; - const SWord8 s2307 = 127 & s2305; - const SWord8 s2308 = s2220 ? s2306 : s2307; - const SWord8 s2309 = s1 + s2304; - const SBool s2310 = s2309 < s1; - const SBool s2311 = s2309 < s2304; - const SBool s2312 = s2310 || s2311; - const SWord8 s2313 = (s2309 >> 1) | (s2309 << 7); - const SWord8 s2314 = 128 | s2313; - const SWord8 s2315 = 127 & s2313; - const SWord8 s2316 = s2312 ? s2314 : s2315; - const SWord8 s2317 = s2221 ? s2308 : s2316; - const SWord8 s2318 = s2097 ? s2296 : s2317; - const SWord8 s2319 = s2078 ? s2271 : s2318; - const SWord8 s2320 = s2059 ? s2211 : s2319; - const SWord8 s2321 = s1 + s2082; - const SBool s2322 = (SBool) (s2321 & 1); - const SBool s2323 = false != s2322; - const SWord8 s2324 = s2323 ? s2086 : s2087; - const SBool s2325 = (SBool) (s2324 & 1); - const SBool s2326 = false != s2325; - const SWord8 s2327 = s2326 ? s2092 : s2093; - const SBool s2328 = (SBool) (s2327 & 1); - const SBool s2329 = false != s2328; - const SBool s2330 = !s2329; - const SBool s2331 = s2321 < s1; - const SBool s2332 = s2321 < s2082; - const SBool s2333 = s2331 || s2332; - const SWord8 s2334 = (s2321 >> 1) | (s2321 << 7); - const SWord8 s2335 = 128 | s2334; - const SWord8 s2336 = 127 & s2334; - const SWord8 s2337 = s2333 ? s2335 : s2336; - const SBool s2338 = (SBool) (s2337 & 1); - const SBool s2339 = false != s2338; - const SWord8 s2340 = (s2324 >> 1) | (s2324 << 7); - const SWord8 s2341 = 128 | s2340; - const SWord8 s2342 = 127 & s2340; - const SWord8 s2343 = s2339 ? s2341 : s2342; - const SBool s2344 = (SBool) (s2343 & 1); - const SBool s2345 = false != s2344; - const SWord8 s2346 = (s2327 >> 1) | (s2327 << 7); - const SWord8 s2347 = 128 | s2346; - const SWord8 s2348 = 127 & s2346; - const SWord8 s2349 = s2345 ? s2347 : s2348; - const SBool s2350 = (SBool) (s2349 & 1); - const SBool s2351 = false != s2350; - const SBool s2352 = !s2351; - const SWord8 s2353 = (s2337 >> 1) | (s2337 << 7); - const SWord8 s2354 = 128 | s2353; - const SWord8 s2355 = 127 & s2353; - const SWord8 s2356 = s2058 ? s2354 : s2355; - const SWord8 s2357 = (s2356 >> 1) | (s2356 << 7); - const SWord8 s2358 = 128 | s2357; - const SWord8 s2359 = 127 & s2357; - const SWord8 s2360 = s2077 ? s2358 : s2359; - const SWord8 s2361 = (s2360 >> 1) | (s2360 << 7); - const SWord8 s2362 = 128 | s2361; - const SWord8 s2363 = 127 & s2361; - const SWord8 s2364 = s2329 ? s2362 : s2363; - const SWord8 s2365 = (s2364 >> 1) | (s2364 << 7); - const SWord8 s2366 = 128 | s2365; - const SWord8 s2367 = 127 & s2365; - const SWord8 s2368 = s2351 ? s2366 : s2367; - const SWord8 s2369 = s1 + s2364; - const SBool s2370 = s2369 < s1; - const SBool s2371 = s2369 < s2364; - const SBool s2372 = s2370 || s2371; - const SWord8 s2373 = (s2369 >> 1) | (s2369 << 7); - const SWord8 s2374 = 128 | s2373; - const SWord8 s2375 = 127 & s2373; - const SWord8 s2376 = s2372 ? s2374 : s2375; - const SWord8 s2377 = s2352 ? s2368 : s2376; - const SWord8 s2378 = s1 + s2360; - const SBool s2379 = s2378 < s1; - const SBool s2380 = s2378 < s2360; - const SBool s2381 = s2379 || s2380; - const SWord8 s2382 = (s2378 >> 1) | (s2378 << 7); - const SWord8 s2383 = 128 | s2382; - const SWord8 s2384 = 127 & s2382; - const SWord8 s2385 = s2381 ? s2383 : s2384; - const SWord8 s2386 = (s2385 >> 1) | (s2385 << 7); - const SWord8 s2387 = 128 | s2386; - const SWord8 s2388 = 127 & s2386; - const SWord8 s2389 = s2351 ? s2387 : s2388; - const SWord8 s2390 = s1 + s2385; - const SBool s2391 = s2390 < s1; - const SBool s2392 = s2390 < s2385; - const SBool s2393 = s2391 || s2392; - const SWord8 s2394 = (s2390 >> 1) | (s2390 << 7); - const SWord8 s2395 = 128 | s2394; - const SWord8 s2396 = 127 & s2394; - const SWord8 s2397 = s2393 ? s2395 : s2396; - const SWord8 s2398 = s2352 ? s2389 : s2397; - const SWord8 s2399 = s2330 ? s2377 : s2398; - const SWord8 s2400 = s1 + s2356; - const SBool s2401 = s2400 < s1; - const SBool s2402 = s2400 < s2356; - const SBool s2403 = s2401 || s2402; - const SWord8 s2404 = (s2400 >> 1) | (s2400 << 7); - const SWord8 s2405 = 128 | s2404; - const SWord8 s2406 = 127 & s2404; - const SWord8 s2407 = s2403 ? s2405 : s2406; - const SWord8 s2408 = (s2407 >> 1) | (s2407 << 7); - const SWord8 s2409 = 128 | s2408; - const SWord8 s2410 = 127 & s2408; - const SWord8 s2411 = s2329 ? s2409 : s2410; - const SWord8 s2412 = (s2411 >> 1) | (s2411 << 7); - const SWord8 s2413 = 128 | s2412; - const SWord8 s2414 = 127 & s2412; - const SWord8 s2415 = s2351 ? s2413 : s2414; - const SWord8 s2416 = s1 + s2411; - const SBool s2417 = s2416 < s1; - const SBool s2418 = s2416 < s2411; - const SBool s2419 = s2417 || s2418; - const SWord8 s2420 = (s2416 >> 1) | (s2416 << 7); - const SWord8 s2421 = 128 | s2420; - const SWord8 s2422 = 127 & s2420; - const SWord8 s2423 = s2419 ? s2421 : s2422; - const SWord8 s2424 = s2352 ? s2415 : s2423; - const SWord8 s2425 = s1 + s2407; - const SBool s2426 = s2425 < s1; - const SBool s2427 = s2425 < s2407; - const SBool s2428 = s2426 || s2427; - const SWord8 s2429 = (s2425 >> 1) | (s2425 << 7); - const SWord8 s2430 = 128 | s2429; - const SWord8 s2431 = 127 & s2429; - const SWord8 s2432 = s2428 ? s2430 : s2431; - const SWord8 s2433 = (s2432 >> 1) | (s2432 << 7); - const SWord8 s2434 = 128 | s2433; - const SWord8 s2435 = 127 & s2433; - const SWord8 s2436 = s2351 ? s2434 : s2435; - const SWord8 s2437 = s1 + s2432; - const SBool s2438 = s2437 < s1; - const SBool s2439 = s2437 < s2432; - const SBool s2440 = s2438 || s2439; - const SWord8 s2441 = (s2437 >> 1) | (s2437 << 7); - const SWord8 s2442 = 128 | s2441; - const SWord8 s2443 = 127 & s2441; - const SWord8 s2444 = s2440 ? s2442 : s2443; - const SWord8 s2445 = s2352 ? s2436 : s2444; - const SWord8 s2446 = s2330 ? s2424 : s2445; - const SWord8 s2447 = s2078 ? s2399 : s2446; - const SWord8 s2448 = s1 + s2337; - const SBool s2449 = (SBool) (s2448 & 1); - const SBool s2450 = false != s2449; - const SWord8 s2451 = s2450 ? s2341 : s2342; - const SBool s2452 = (SBool) (s2451 & 1); - const SBool s2453 = false != s2452; - const SWord8 s2454 = s2453 ? s2347 : s2348; - const SBool s2455 = (SBool) (s2454 & 1); - const SBool s2456 = false != s2455; - const SBool s2457 = !s2456; - const SBool s2458 = s2448 < s1; - const SBool s2459 = s2448 < s2337; - const SBool s2460 = s2458 || s2459; - const SWord8 s2461 = (s2448 >> 1) | (s2448 << 7); - const SWord8 s2462 = 128 | s2461; - const SWord8 s2463 = 127 & s2461; - const SWord8 s2464 = s2460 ? s2462 : s2463; - const SWord8 s2465 = (s2464 >> 1) | (s2464 << 7); - const SWord8 s2466 = 128 | s2465; - const SWord8 s2467 = 127 & s2465; - const SWord8 s2468 = s2077 ? s2466 : s2467; - const SWord8 s2469 = (s2468 >> 1) | (s2468 << 7); - const SWord8 s2470 = 128 | s2469; - const SWord8 s2471 = 127 & s2469; - const SWord8 s2472 = s2329 ? s2470 : s2471; - const SWord8 s2473 = (s2472 >> 1) | (s2472 << 7); - const SWord8 s2474 = 128 | s2473; - const SWord8 s2475 = 127 & s2473; - const SWord8 s2476 = s2456 ? s2474 : s2475; - const SWord8 s2477 = s1 + s2472; - const SBool s2478 = s2477 < s1; - const SBool s2479 = s2477 < s2472; - const SBool s2480 = s2478 || s2479; - const SWord8 s2481 = (s2477 >> 1) | (s2477 << 7); - const SWord8 s2482 = 128 | s2481; - const SWord8 s2483 = 127 & s2481; - const SWord8 s2484 = s2480 ? s2482 : s2483; - const SWord8 s2485 = s2457 ? s2476 : s2484; - const SWord8 s2486 = s1 + s2468; - const SBool s2487 = s2486 < s1; - const SBool s2488 = s2486 < s2468; - const SBool s2489 = s2487 || s2488; - const SWord8 s2490 = (s2486 >> 1) | (s2486 << 7); - const SWord8 s2491 = 128 | s2490; - const SWord8 s2492 = 127 & s2490; - const SWord8 s2493 = s2489 ? s2491 : s2492; - const SWord8 s2494 = (s2493 >> 1) | (s2493 << 7); - const SWord8 s2495 = 128 | s2494; - const SWord8 s2496 = 127 & s2494; - const SWord8 s2497 = s2456 ? s2495 : s2496; - const SWord8 s2498 = s1 + s2493; - const SBool s2499 = s2498 < s1; - const SBool s2500 = s2498 < s2493; - const SBool s2501 = s2499 || s2500; - const SWord8 s2502 = (s2498 >> 1) | (s2498 << 7); - const SWord8 s2503 = 128 | s2502; - const SWord8 s2504 = 127 & s2502; - const SWord8 s2505 = s2501 ? s2503 : s2504; - const SWord8 s2506 = s2457 ? s2497 : s2505; - const SWord8 s2507 = s2330 ? s2485 : s2506; - const SWord8 s2508 = s1 + s2464; - const SBool s2509 = s2508 < s1; - const SBool s2510 = s2508 < s2464; - const SBool s2511 = s2509 || s2510; - const SWord8 s2512 = (s2508 >> 1) | (s2508 << 7); - const SWord8 s2513 = 128 | s2512; - const SWord8 s2514 = 127 & s2512; - const SWord8 s2515 = s2511 ? s2513 : s2514; - const SWord8 s2516 = (s2515 >> 1) | (s2515 << 7); - const SWord8 s2517 = 128 | s2516; - const SWord8 s2518 = 127 & s2516; - const SWord8 s2519 = s2329 ? s2517 : s2518; - const SWord8 s2520 = (s2519 >> 1) | (s2519 << 7); - const SWord8 s2521 = 128 | s2520; - const SWord8 s2522 = 127 & s2520; - const SWord8 s2523 = s2456 ? s2521 : s2522; - const SWord8 s2524 = s1 + s2519; - const SBool s2525 = s2524 < s1; - const SBool s2526 = s2524 < s2519; - const SBool s2527 = s2525 || s2526; - const SWord8 s2528 = (s2524 >> 1) | (s2524 << 7); - const SWord8 s2529 = 128 | s2528; - const SWord8 s2530 = 127 & s2528; - const SWord8 s2531 = s2527 ? s2529 : s2530; - const SWord8 s2532 = s2457 ? s2523 : s2531; - const SWord8 s2533 = s1 + s2515; - const SBool s2534 = s2533 < s1; - const SBool s2535 = s2533 < s2515; - const SBool s2536 = s2534 || s2535; - const SWord8 s2537 = (s2533 >> 1) | (s2533 << 7); - const SWord8 s2538 = 128 | s2537; - const SWord8 s2539 = 127 & s2537; - const SWord8 s2540 = s2536 ? s2538 : s2539; - const SWord8 s2541 = (s2540 >> 1) | (s2540 << 7); - const SWord8 s2542 = 128 | s2541; - const SWord8 s2543 = 127 & s2541; - const SWord8 s2544 = s2456 ? s2542 : s2543; - const SWord8 s2545 = s1 + s2540; - const SBool s2546 = s2545 < s1; - const SBool s2547 = s2545 < s2540; - const SBool s2548 = s2546 || s2547; - const SWord8 s2549 = (s2545 >> 1) | (s2545 << 7); - const SWord8 s2550 = 128 | s2549; - const SWord8 s2551 = 127 & s2549; - const SWord8 s2552 = s2548 ? s2550 : s2551; - const SWord8 s2553 = s2457 ? s2544 : s2552; - const SWord8 s2554 = s2330 ? s2532 : s2553; - const SWord8 s2555 = s2078 ? s2507 : s2554; - const SWord8 s2556 = s2059 ? s2447 : s2555; - const SWord8 s2557 = s2042 ? s2320 : s2556; - const SWord8 s2558 = s1 + s2063; - const SBool s2559 = (SBool) (s2558 & 1); - const SBool s2560 = false != s2559; - const SWord8 s2561 = s2560 ? s2067 : s2068; - const SBool s2562 = (SBool) (s2561 & 1); - const SBool s2563 = false != s2562; - const SWord8 s2564 = s2563 ? s2073 : s2074; - const SBool s2565 = (SBool) (s2564 & 1); - const SBool s2566 = false != s2565; - const SBool s2567 = !s2566; - const SBool s2568 = s2558 < s1; - const SBool s2569 = s2558 < s2063; - const SBool s2570 = s2568 || s2569; - const SWord8 s2571 = (s2558 >> 1) | (s2558 << 7); - const SWord8 s2572 = 128 | s2571; - const SWord8 s2573 = 127 & s2571; - const SWord8 s2574 = s2570 ? s2572 : s2573; - const SBool s2575 = (SBool) (s2574 & 1); - const SBool s2576 = false != s2575; - const SWord8 s2577 = (s2561 >> 1) | (s2561 << 7); - const SWord8 s2578 = 128 | s2577; - const SWord8 s2579 = 127 & s2577; - const SWord8 s2580 = s2576 ? s2578 : s2579; - const SBool s2581 = (SBool) (s2580 & 1); - const SBool s2582 = false != s2581; - const SWord8 s2583 = (s2564 >> 1) | (s2564 << 7); - const SWord8 s2584 = 128 | s2583; - const SWord8 s2585 = 127 & s2583; - const SWord8 s2586 = s2582 ? s2584 : s2585; - const SBool s2587 = (SBool) (s2586 & 1); - const SBool s2588 = false != s2587; - const SBool s2589 = !s2588; - const SWord8 s2590 = (s2574 >> 1) | (s2574 << 7); - const SWord8 s2591 = 128 | s2590; - const SWord8 s2592 = 127 & s2590; - const SWord8 s2593 = s2041 ? s2591 : s2592; - const SBool s2594 = (SBool) (s2593 & 1); - const SBool s2595 = false != s2594; - const SWord8 s2596 = (s2580 >> 1) | (s2580 << 7); - const SWord8 s2597 = 128 | s2596; - const SWord8 s2598 = 127 & s2596; - const SWord8 s2599 = s2595 ? s2597 : s2598; - const SBool s2600 = (SBool) (s2599 & 1); - const SBool s2601 = false != s2600; - const SWord8 s2602 = (s2586 >> 1) | (s2586 << 7); - const SWord8 s2603 = 128 | s2602; - const SWord8 s2604 = 127 & s2602; - const SWord8 s2605 = s2601 ? s2603 : s2604; - const SBool s2606 = (SBool) (s2605 & 1); - const SBool s2607 = false != s2606; - const SBool s2608 = !s2607; - const SWord8 s2609 = (s2593 >> 1) | (s2593 << 7); - const SWord8 s2610 = 128 | s2609; - const SWord8 s2611 = 127 & s2609; - const SWord8 s2612 = s2058 ? s2610 : s2611; - const SWord8 s2613 = (s2612 >> 1) | (s2612 << 7); - const SWord8 s2614 = 128 | s2613; - const SWord8 s2615 = 127 & s2613; - const SWord8 s2616 = s2566 ? s2614 : s2615; - const SWord8 s2617 = (s2616 >> 1) | (s2616 << 7); - const SWord8 s2618 = 128 | s2617; - const SWord8 s2619 = 127 & s2617; - const SWord8 s2620 = s2588 ? s2618 : s2619; - const SWord8 s2621 = (s2620 >> 1) | (s2620 << 7); - const SWord8 s2622 = 128 | s2621; - const SWord8 s2623 = 127 & s2621; - const SWord8 s2624 = s2607 ? s2622 : s2623; - const SWord8 s2625 = s1 + s2620; - const SBool s2626 = s2625 < s1; - const SBool s2627 = s2625 < s2620; - const SBool s2628 = s2626 || s2627; - const SWord8 s2629 = (s2625 >> 1) | (s2625 << 7); - const SWord8 s2630 = 128 | s2629; - const SWord8 s2631 = 127 & s2629; - const SWord8 s2632 = s2628 ? s2630 : s2631; - const SWord8 s2633 = s2608 ? s2624 : s2632; - const SWord8 s2634 = s1 + s2616; - const SBool s2635 = s2634 < s1; - const SBool s2636 = s2634 < s2616; - const SBool s2637 = s2635 || s2636; - const SWord8 s2638 = (s2634 >> 1) | (s2634 << 7); - const SWord8 s2639 = 128 | s2638; - const SWord8 s2640 = 127 & s2638; - const SWord8 s2641 = s2637 ? s2639 : s2640; - const SWord8 s2642 = (s2641 >> 1) | (s2641 << 7); - const SWord8 s2643 = 128 | s2642; - const SWord8 s2644 = 127 & s2642; - const SWord8 s2645 = s2607 ? s2643 : s2644; - const SWord8 s2646 = s1 + s2641; - const SBool s2647 = s2646 < s1; - const SBool s2648 = s2646 < s2641; - const SBool s2649 = s2647 || s2648; - const SWord8 s2650 = (s2646 >> 1) | (s2646 << 7); - const SWord8 s2651 = 128 | s2650; - const SWord8 s2652 = 127 & s2650; - const SWord8 s2653 = s2649 ? s2651 : s2652; - const SWord8 s2654 = s2608 ? s2645 : s2653; - const SWord8 s2655 = s2589 ? s2633 : s2654; - const SWord8 s2656 = s1 + s2612; - const SBool s2657 = s2656 < s1; - const SBool s2658 = s2656 < s2612; - const SBool s2659 = s2657 || s2658; - const SWord8 s2660 = (s2656 >> 1) | (s2656 << 7); - const SWord8 s2661 = 128 | s2660; - const SWord8 s2662 = 127 & s2660; - const SWord8 s2663 = s2659 ? s2661 : s2662; - const SWord8 s2664 = (s2663 >> 1) | (s2663 << 7); - const SWord8 s2665 = 128 | s2664; - const SWord8 s2666 = 127 & s2664; - const SWord8 s2667 = s2588 ? s2665 : s2666; - const SWord8 s2668 = (s2667 >> 1) | (s2667 << 7); - const SWord8 s2669 = 128 | s2668; - const SWord8 s2670 = 127 & s2668; - const SWord8 s2671 = s2607 ? s2669 : s2670; - const SWord8 s2672 = s1 + s2667; - const SBool s2673 = s2672 < s1; - const SBool s2674 = s2672 < s2667; - const SBool s2675 = s2673 || s2674; - const SWord8 s2676 = (s2672 >> 1) | (s2672 << 7); - const SWord8 s2677 = 128 | s2676; - const SWord8 s2678 = 127 & s2676; - const SWord8 s2679 = s2675 ? s2677 : s2678; - const SWord8 s2680 = s2608 ? s2671 : s2679; - const SWord8 s2681 = s1 + s2663; - const SBool s2682 = s2681 < s1; - const SBool s2683 = s2681 < s2663; - const SBool s2684 = s2682 || s2683; - const SWord8 s2685 = (s2681 >> 1) | (s2681 << 7); - const SWord8 s2686 = 128 | s2685; - const SWord8 s2687 = 127 & s2685; - const SWord8 s2688 = s2684 ? s2686 : s2687; - const SWord8 s2689 = (s2688 >> 1) | (s2688 << 7); - const SWord8 s2690 = 128 | s2689; - const SWord8 s2691 = 127 & s2689; - const SWord8 s2692 = s2607 ? s2690 : s2691; - const SWord8 s2693 = s1 + s2688; - const SBool s2694 = s2693 < s1; - const SBool s2695 = s2693 < s2688; - const SBool s2696 = s2694 || s2695; - const SWord8 s2697 = (s2693 >> 1) | (s2693 << 7); - const SWord8 s2698 = 128 | s2697; - const SWord8 s2699 = 127 & s2697; - const SWord8 s2700 = s2696 ? s2698 : s2699; - const SWord8 s2701 = s2608 ? s2692 : s2700; - const SWord8 s2702 = s2589 ? s2680 : s2701; - const SWord8 s2703 = s2567 ? s2655 : s2702; - const SWord8 s2704 = s1 + s2593; - const SBool s2705 = (SBool) (s2704 & 1); - const SBool s2706 = false != s2705; - const SWord8 s2707 = s2706 ? s2597 : s2598; - const SBool s2708 = (SBool) (s2707 & 1); - const SBool s2709 = false != s2708; - const SWord8 s2710 = s2709 ? s2603 : s2604; - const SBool s2711 = (SBool) (s2710 & 1); - const SBool s2712 = false != s2711; - const SBool s2713 = !s2712; - const SBool s2714 = s2704 < s1; - const SBool s2715 = s2704 < s2593; - const SBool s2716 = s2714 || s2715; - const SWord8 s2717 = (s2704 >> 1) | (s2704 << 7); - const SWord8 s2718 = 128 | s2717; - const SWord8 s2719 = 127 & s2717; - const SWord8 s2720 = s2716 ? s2718 : s2719; - const SWord8 s2721 = (s2720 >> 1) | (s2720 << 7); - const SWord8 s2722 = 128 | s2721; - const SWord8 s2723 = 127 & s2721; - const SWord8 s2724 = s2566 ? s2722 : s2723; - const SWord8 s2725 = (s2724 >> 1) | (s2724 << 7); - const SWord8 s2726 = 128 | s2725; - const SWord8 s2727 = 127 & s2725; - const SWord8 s2728 = s2588 ? s2726 : s2727; - const SWord8 s2729 = (s2728 >> 1) | (s2728 << 7); - const SWord8 s2730 = 128 | s2729; - const SWord8 s2731 = 127 & s2729; - const SWord8 s2732 = s2712 ? s2730 : s2731; - const SWord8 s2733 = s1 + s2728; - const SBool s2734 = s2733 < s1; - const SBool s2735 = s2733 < s2728; - const SBool s2736 = s2734 || s2735; - const SWord8 s2737 = (s2733 >> 1) | (s2733 << 7); - const SWord8 s2738 = 128 | s2737; - const SWord8 s2739 = 127 & s2737; - const SWord8 s2740 = s2736 ? s2738 : s2739; - const SWord8 s2741 = s2713 ? s2732 : s2740; - const SWord8 s2742 = s1 + s2724; - const SBool s2743 = s2742 < s1; - const SBool s2744 = s2742 < s2724; - const SBool s2745 = s2743 || s2744; - const SWord8 s2746 = (s2742 >> 1) | (s2742 << 7); - const SWord8 s2747 = 128 | s2746; - const SWord8 s2748 = 127 & s2746; - const SWord8 s2749 = s2745 ? s2747 : s2748; - const SWord8 s2750 = (s2749 >> 1) | (s2749 << 7); - const SWord8 s2751 = 128 | s2750; - const SWord8 s2752 = 127 & s2750; - const SWord8 s2753 = s2712 ? s2751 : s2752; - const SWord8 s2754 = s1 + s2749; - const SBool s2755 = s2754 < s1; - const SBool s2756 = s2754 < s2749; - const SBool s2757 = s2755 || s2756; - const SWord8 s2758 = (s2754 >> 1) | (s2754 << 7); - const SWord8 s2759 = 128 | s2758; - const SWord8 s2760 = 127 & s2758; - const SWord8 s2761 = s2757 ? s2759 : s2760; - const SWord8 s2762 = s2713 ? s2753 : s2761; - const SWord8 s2763 = s2589 ? s2741 : s2762; - const SWord8 s2764 = s1 + s2720; - const SBool s2765 = s2764 < s1; - const SBool s2766 = s2764 < s2720; - const SBool s2767 = s2765 || s2766; - const SWord8 s2768 = (s2764 >> 1) | (s2764 << 7); - const SWord8 s2769 = 128 | s2768; - const SWord8 s2770 = 127 & s2768; - const SWord8 s2771 = s2767 ? s2769 : s2770; - const SWord8 s2772 = (s2771 >> 1) | (s2771 << 7); - const SWord8 s2773 = 128 | s2772; - const SWord8 s2774 = 127 & s2772; - const SWord8 s2775 = s2588 ? s2773 : s2774; - const SWord8 s2776 = (s2775 >> 1) | (s2775 << 7); - const SWord8 s2777 = 128 | s2776; - const SWord8 s2778 = 127 & s2776; - const SWord8 s2779 = s2712 ? s2777 : s2778; - const SWord8 s2780 = s1 + s2775; - const SBool s2781 = s2780 < s1; - const SBool s2782 = s2780 < s2775; - const SBool s2783 = s2781 || s2782; - const SWord8 s2784 = (s2780 >> 1) | (s2780 << 7); - const SWord8 s2785 = 128 | s2784; - const SWord8 s2786 = 127 & s2784; - const SWord8 s2787 = s2783 ? s2785 : s2786; - const SWord8 s2788 = s2713 ? s2779 : s2787; - const SWord8 s2789 = s1 + s2771; - const SBool s2790 = s2789 < s1; - const SBool s2791 = s2789 < s2771; - const SBool s2792 = s2790 || s2791; - const SWord8 s2793 = (s2789 >> 1) | (s2789 << 7); - const SWord8 s2794 = 128 | s2793; - const SWord8 s2795 = 127 & s2793; - const SWord8 s2796 = s2792 ? s2794 : s2795; - const SWord8 s2797 = (s2796 >> 1) | (s2796 << 7); - const SWord8 s2798 = 128 | s2797; - const SWord8 s2799 = 127 & s2797; - const SWord8 s2800 = s2712 ? s2798 : s2799; - const SWord8 s2801 = s1 + s2796; - const SBool s2802 = s2801 < s1; - const SBool s2803 = s2801 < s2796; - const SBool s2804 = s2802 || s2803; - const SWord8 s2805 = (s2801 >> 1) | (s2801 << 7); - const SWord8 s2806 = 128 | s2805; - const SWord8 s2807 = 127 & s2805; - const SWord8 s2808 = s2804 ? s2806 : s2807; - const SWord8 s2809 = s2713 ? s2800 : s2808; - const SWord8 s2810 = s2589 ? s2788 : s2809; - const SWord8 s2811 = s2567 ? s2763 : s2810; - const SWord8 s2812 = s2059 ? s2703 : s2811; - const SWord8 s2813 = s1 + s2574; - const SBool s2814 = (SBool) (s2813 & 1); - const SBool s2815 = false != s2814; - const SWord8 s2816 = s2815 ? s2578 : s2579; - const SBool s2817 = (SBool) (s2816 & 1); - const SBool s2818 = false != s2817; - const SWord8 s2819 = s2818 ? s2584 : s2585; - const SBool s2820 = (SBool) (s2819 & 1); - const SBool s2821 = false != s2820; - const SBool s2822 = !s2821; - const SBool s2823 = s2813 < s1; - const SBool s2824 = s2813 < s2574; - const SBool s2825 = s2823 || s2824; - const SWord8 s2826 = (s2813 >> 1) | (s2813 << 7); - const SWord8 s2827 = 128 | s2826; - const SWord8 s2828 = 127 & s2826; - const SWord8 s2829 = s2825 ? s2827 : s2828; - const SBool s2830 = (SBool) (s2829 & 1); - const SBool s2831 = false != s2830; - const SWord8 s2832 = (s2816 >> 1) | (s2816 << 7); - const SWord8 s2833 = 128 | s2832; - const SWord8 s2834 = 127 & s2832; - const SWord8 s2835 = s2831 ? s2833 : s2834; - const SBool s2836 = (SBool) (s2835 & 1); - const SBool s2837 = false != s2836; - const SWord8 s2838 = (s2819 >> 1) | (s2819 << 7); - const SWord8 s2839 = 128 | s2838; - const SWord8 s2840 = 127 & s2838; - const SWord8 s2841 = s2837 ? s2839 : s2840; - const SBool s2842 = (SBool) (s2841 & 1); - const SBool s2843 = false != s2842; - const SBool s2844 = !s2843; - const SWord8 s2845 = (s2829 >> 1) | (s2829 << 7); - const SWord8 s2846 = 128 | s2845; - const SWord8 s2847 = 127 & s2845; - const SWord8 s2848 = s2058 ? s2846 : s2847; - const SWord8 s2849 = (s2848 >> 1) | (s2848 << 7); - const SWord8 s2850 = 128 | s2849; - const SWord8 s2851 = 127 & s2849; - const SWord8 s2852 = s2566 ? s2850 : s2851; - const SWord8 s2853 = (s2852 >> 1) | (s2852 << 7); - const SWord8 s2854 = 128 | s2853; - const SWord8 s2855 = 127 & s2853; - const SWord8 s2856 = s2821 ? s2854 : s2855; - const SWord8 s2857 = (s2856 >> 1) | (s2856 << 7); - const SWord8 s2858 = 128 | s2857; - const SWord8 s2859 = 127 & s2857; - const SWord8 s2860 = s2843 ? s2858 : s2859; - const SWord8 s2861 = s1 + s2856; - const SBool s2862 = s2861 < s1; - const SBool s2863 = s2861 < s2856; - const SBool s2864 = s2862 || s2863; - const SWord8 s2865 = (s2861 >> 1) | (s2861 << 7); - const SWord8 s2866 = 128 | s2865; - const SWord8 s2867 = 127 & s2865; - const SWord8 s2868 = s2864 ? s2866 : s2867; - const SWord8 s2869 = s2844 ? s2860 : s2868; - const SWord8 s2870 = s1 + s2852; - const SBool s2871 = s2870 < s1; - const SBool s2872 = s2870 < s2852; - const SBool s2873 = s2871 || s2872; - const SWord8 s2874 = (s2870 >> 1) | (s2870 << 7); - const SWord8 s2875 = 128 | s2874; - const SWord8 s2876 = 127 & s2874; - const SWord8 s2877 = s2873 ? s2875 : s2876; - const SWord8 s2878 = (s2877 >> 1) | (s2877 << 7); - const SWord8 s2879 = 128 | s2878; - const SWord8 s2880 = 127 & s2878; - const SWord8 s2881 = s2843 ? s2879 : s2880; - const SWord8 s2882 = s1 + s2877; - const SBool s2883 = s2882 < s1; - const SBool s2884 = s2882 < s2877; - const SBool s2885 = s2883 || s2884; - const SWord8 s2886 = (s2882 >> 1) | (s2882 << 7); - const SWord8 s2887 = 128 | s2886; - const SWord8 s2888 = 127 & s2886; - const SWord8 s2889 = s2885 ? s2887 : s2888; - const SWord8 s2890 = s2844 ? s2881 : s2889; - const SWord8 s2891 = s2822 ? s2869 : s2890; - const SWord8 s2892 = s1 + s2848; - const SBool s2893 = s2892 < s1; - const SBool s2894 = s2892 < s2848; - const SBool s2895 = s2893 || s2894; - const SWord8 s2896 = (s2892 >> 1) | (s2892 << 7); - const SWord8 s2897 = 128 | s2896; - const SWord8 s2898 = 127 & s2896; - const SWord8 s2899 = s2895 ? s2897 : s2898; - const SWord8 s2900 = (s2899 >> 1) | (s2899 << 7); - const SWord8 s2901 = 128 | s2900; - const SWord8 s2902 = 127 & s2900; - const SWord8 s2903 = s2821 ? s2901 : s2902; - const SWord8 s2904 = (s2903 >> 1) | (s2903 << 7); - const SWord8 s2905 = 128 | s2904; - const SWord8 s2906 = 127 & s2904; - const SWord8 s2907 = s2843 ? s2905 : s2906; - const SWord8 s2908 = s1 + s2903; - const SBool s2909 = s2908 < s1; - const SBool s2910 = s2908 < s2903; - const SBool s2911 = s2909 || s2910; - const SWord8 s2912 = (s2908 >> 1) | (s2908 << 7); - const SWord8 s2913 = 128 | s2912; - const SWord8 s2914 = 127 & s2912; - const SWord8 s2915 = s2911 ? s2913 : s2914; - const SWord8 s2916 = s2844 ? s2907 : s2915; - const SWord8 s2917 = s1 + s2899; - const SBool s2918 = s2917 < s1; - const SBool s2919 = s2917 < s2899; - const SBool s2920 = s2918 || s2919; - const SWord8 s2921 = (s2917 >> 1) | (s2917 << 7); - const SWord8 s2922 = 128 | s2921; - const SWord8 s2923 = 127 & s2921; - const SWord8 s2924 = s2920 ? s2922 : s2923; - const SWord8 s2925 = (s2924 >> 1) | (s2924 << 7); - const SWord8 s2926 = 128 | s2925; - const SWord8 s2927 = 127 & s2925; - const SWord8 s2928 = s2843 ? s2926 : s2927; - const SWord8 s2929 = s1 + s2924; - const SBool s2930 = s2929 < s1; - const SBool s2931 = s2929 < s2924; - const SBool s2932 = s2930 || s2931; - const SWord8 s2933 = (s2929 >> 1) | (s2929 << 7); - const SWord8 s2934 = 128 | s2933; - const SWord8 s2935 = 127 & s2933; - const SWord8 s2936 = s2932 ? s2934 : s2935; - const SWord8 s2937 = s2844 ? s2928 : s2936; - const SWord8 s2938 = s2822 ? s2916 : s2937; - const SWord8 s2939 = s2567 ? s2891 : s2938; - const SWord8 s2940 = s1 + s2829; - const SBool s2941 = (SBool) (s2940 & 1); - const SBool s2942 = false != s2941; - const SWord8 s2943 = s2942 ? s2833 : s2834; - const SBool s2944 = (SBool) (s2943 & 1); - const SBool s2945 = false != s2944; - const SWord8 s2946 = s2945 ? s2839 : s2840; - const SBool s2947 = (SBool) (s2946 & 1); - const SBool s2948 = false != s2947; - const SBool s2949 = !s2948; - const SBool s2950 = s2940 < s1; - const SBool s2951 = s2940 < s2829; - const SBool s2952 = s2950 || s2951; - const SWord8 s2953 = (s2940 >> 1) | (s2940 << 7); - const SWord8 s2954 = 128 | s2953; - const SWord8 s2955 = 127 & s2953; - const SWord8 s2956 = s2952 ? s2954 : s2955; - const SWord8 s2957 = (s2956 >> 1) | (s2956 << 7); - const SWord8 s2958 = 128 | s2957; - const SWord8 s2959 = 127 & s2957; - const SWord8 s2960 = s2566 ? s2958 : s2959; - const SWord8 s2961 = (s2960 >> 1) | (s2960 << 7); - const SWord8 s2962 = 128 | s2961; - const SWord8 s2963 = 127 & s2961; - const SWord8 s2964 = s2821 ? s2962 : s2963; - const SWord8 s2965 = (s2964 >> 1) | (s2964 << 7); - const SWord8 s2966 = 128 | s2965; - const SWord8 s2967 = 127 & s2965; - const SWord8 s2968 = s2948 ? s2966 : s2967; - const SWord8 s2969 = s1 + s2964; - const SBool s2970 = s2969 < s1; - const SBool s2971 = s2969 < s2964; - const SBool s2972 = s2970 || s2971; - const SWord8 s2973 = (s2969 >> 1) | (s2969 << 7); - const SWord8 s2974 = 128 | s2973; - const SWord8 s2975 = 127 & s2973; - const SWord8 s2976 = s2972 ? s2974 : s2975; - const SWord8 s2977 = s2949 ? s2968 : s2976; - const SWord8 s2978 = s1 + s2960; - const SBool s2979 = s2978 < s1; - const SBool s2980 = s2978 < s2960; - const SBool s2981 = s2979 || s2980; - const SWord8 s2982 = (s2978 >> 1) | (s2978 << 7); - const SWord8 s2983 = 128 | s2982; - const SWord8 s2984 = 127 & s2982; - const SWord8 s2985 = s2981 ? s2983 : s2984; - const SWord8 s2986 = (s2985 >> 1) | (s2985 << 7); - const SWord8 s2987 = 128 | s2986; - const SWord8 s2988 = 127 & s2986; - const SWord8 s2989 = s2948 ? s2987 : s2988; - const SWord8 s2990 = s1 + s2985; - const SBool s2991 = s2990 < s1; - const SBool s2992 = s2990 < s2985; - const SBool s2993 = s2991 || s2992; - const SWord8 s2994 = (s2990 >> 1) | (s2990 << 7); - const SWord8 s2995 = 128 | s2994; - const SWord8 s2996 = 127 & s2994; - const SWord8 s2997 = s2993 ? s2995 : s2996; - const SWord8 s2998 = s2949 ? s2989 : s2997; - const SWord8 s2999 = s2822 ? s2977 : s2998; - const SWord8 s3000 = s1 + s2956; - const SBool s3001 = s3000 < s1; - const SBool s3002 = s3000 < s2956; - const SBool s3003 = s3001 || s3002; - const SWord8 s3004 = (s3000 >> 1) | (s3000 << 7); - const SWord8 s3005 = 128 | s3004; - const SWord8 s3006 = 127 & s3004; - const SWord8 s3007 = s3003 ? s3005 : s3006; - const SWord8 s3008 = (s3007 >> 1) | (s3007 << 7); - const SWord8 s3009 = 128 | s3008; - const SWord8 s3010 = 127 & s3008; - const SWord8 s3011 = s2821 ? s3009 : s3010; - const SWord8 s3012 = (s3011 >> 1) | (s3011 << 7); - const SWord8 s3013 = 128 | s3012; - const SWord8 s3014 = 127 & s3012; - const SWord8 s3015 = s2948 ? s3013 : s3014; - const SWord8 s3016 = s1 + s3011; - const SBool s3017 = s3016 < s1; - const SBool s3018 = s3016 < s3011; - const SBool s3019 = s3017 || s3018; - const SWord8 s3020 = (s3016 >> 1) | (s3016 << 7); - const SWord8 s3021 = 128 | s3020; - const SWord8 s3022 = 127 & s3020; - const SWord8 s3023 = s3019 ? s3021 : s3022; - const SWord8 s3024 = s2949 ? s3015 : s3023; - const SWord8 s3025 = s1 + s3007; - const SBool s3026 = s3025 < s1; - const SBool s3027 = s3025 < s3007; - const SBool s3028 = s3026 || s3027; - const SWord8 s3029 = (s3025 >> 1) | (s3025 << 7); - const SWord8 s3030 = 128 | s3029; - const SWord8 s3031 = 127 & s3029; - const SWord8 s3032 = s3028 ? s3030 : s3031; - const SWord8 s3033 = (s3032 >> 1) | (s3032 << 7); - const SWord8 s3034 = 128 | s3033; - const SWord8 s3035 = 127 & s3033; - const SWord8 s3036 = s2948 ? s3034 : s3035; - const SWord8 s3037 = s1 + s3032; - const SBool s3038 = s3037 < s1; - const SBool s3039 = s3037 < s3032; - const SBool s3040 = s3038 || s3039; - const SWord8 s3041 = (s3037 >> 1) | (s3037 << 7); - const SWord8 s3042 = 128 | s3041; - const SWord8 s3043 = 127 & s3041; - const SWord8 s3044 = s3040 ? s3042 : s3043; - const SWord8 s3045 = s2949 ? s3036 : s3044; - const SWord8 s3046 = s2822 ? s3024 : s3045; - const SWord8 s3047 = s2567 ? s2999 : s3046; - const SWord8 s3048 = s2059 ? s2939 : s3047; - const SWord8 s3049 = s2042 ? s2812 : s3048; - const SWord8 s3050 = s16 ? s2557 : s3049; - const SWord8 s3051 = s1 + s2044; - const SBool s3052 = (SBool) (s3051 & 1); - const SBool s3053 = false != s3052; - const SWord8 s3054 = s3053 ? s2048 : s2049; - const SBool s3055 = (SBool) (s3054 & 1); - const SBool s3056 = false != s3055; - const SWord8 s3057 = s3056 ? s2054 : s2055; - const SBool s3058 = (SBool) (s3057 & 1); - const SBool s3059 = false != s3058; - const SBool s3060 = !s3059; - const SBool s3061 = s3051 < s1; - const SBool s3062 = s3051 < s2044; - const SBool s3063 = s3061 || s3062; - const SWord8 s3064 = (s3051 >> 1) | (s3051 << 7); - const SWord8 s3065 = 128 | s3064; - const SWord8 s3066 = 127 & s3064; - const SWord8 s3067 = s3063 ? s3065 : s3066; - const SBool s3068 = (SBool) (s3067 & 1); - const SBool s3069 = false != s3068; - const SWord8 s3070 = (s3054 >> 1) | (s3054 << 7); - const SWord8 s3071 = 128 | s3070; - const SWord8 s3072 = 127 & s3070; - const SWord8 s3073 = s3069 ? s3071 : s3072; - const SBool s3074 = (SBool) (s3073 & 1); - const SBool s3075 = false != s3074; - const SWord8 s3076 = (s3057 >> 1) | (s3057 << 7); - const SWord8 s3077 = 128 | s3076; - const SWord8 s3078 = 127 & s3076; - const SWord8 s3079 = s3075 ? s3077 : s3078; - const SBool s3080 = (SBool) (s3079 & 1); - const SBool s3081 = false != s3080; - const SBool s3082 = !s3081; - const SWord8 s3083 = (s3067 >> 1) | (s3067 << 7); - const SWord8 s3084 = 128 | s3083; - const SWord8 s3085 = 127 & s3083; - const SWord8 s3086 = s15 ? s3084 : s3085; - const SBool s3087 = (SBool) (s3086 & 1); - const SBool s3088 = false != s3087; - const SWord8 s3089 = (s3073 >> 1) | (s3073 << 7); - const SWord8 s3090 = 128 | s3089; - const SWord8 s3091 = 127 & s3089; - const SWord8 s3092 = s3088 ? s3090 : s3091; - const SBool s3093 = (SBool) (s3092 & 1); - const SBool s3094 = false != s3093; - const SWord8 s3095 = (s3079 >> 1) | (s3079 << 7); - const SWord8 s3096 = 128 | s3095; - const SWord8 s3097 = 127 & s3095; - const SWord8 s3098 = s3094 ? s3096 : s3097; - const SBool s3099 = (SBool) (s3098 & 1); - const SBool s3100 = false != s3099; - const SBool s3101 = !s3100; - const SWord8 s3102 = (s3086 >> 1) | (s3086 << 7); - const SWord8 s3103 = 128 | s3102; - const SWord8 s3104 = 127 & s3102; - const SWord8 s3105 = s2041 ? s3103 : s3104; - const SBool s3106 = (SBool) (s3105 & 1); - const SBool s3107 = false != s3106; - const SWord8 s3108 = (s3092 >> 1) | (s3092 << 7); - const SWord8 s3109 = 128 | s3108; - const SWord8 s3110 = 127 & s3108; - const SWord8 s3111 = s3107 ? s3109 : s3110; - const SBool s3112 = (SBool) (s3111 & 1); - const SBool s3113 = false != s3112; - const SWord8 s3114 = (s3098 >> 1) | (s3098 << 7); - const SWord8 s3115 = 128 | s3114; - const SWord8 s3116 = 127 & s3114; - const SWord8 s3117 = s3113 ? s3115 : s3116; - const SBool s3118 = (SBool) (s3117 & 1); - const SBool s3119 = false != s3118; - const SBool s3120 = !s3119; - const SWord8 s3121 = (s3105 >> 1) | (s3105 << 7); - const SWord8 s3122 = 128 | s3121; - const SWord8 s3123 = 127 & s3121; - const SWord8 s3124 = s3059 ? s3122 : s3123; - const SWord8 s3125 = (s3124 >> 1) | (s3124 << 7); - const SWord8 s3126 = 128 | s3125; - const SWord8 s3127 = 127 & s3125; - const SWord8 s3128 = s3081 ? s3126 : s3127; - const SWord8 s3129 = (s3128 >> 1) | (s3128 << 7); - const SWord8 s3130 = 128 | s3129; - const SWord8 s3131 = 127 & s3129; - const SWord8 s3132 = s3100 ? s3130 : s3131; - const SWord8 s3133 = (s3132 >> 1) | (s3132 << 7); - const SWord8 s3134 = 128 | s3133; - const SWord8 s3135 = 127 & s3133; - const SWord8 s3136 = s3119 ? s3134 : s3135; - const SWord8 s3137 = s1 + s3132; - const SBool s3138 = s3137 < s1; - const SBool s3139 = s3137 < s3132; - const SBool s3140 = s3138 || s3139; - const SWord8 s3141 = (s3137 >> 1) | (s3137 << 7); - const SWord8 s3142 = 128 | s3141; - const SWord8 s3143 = 127 & s3141; - const SWord8 s3144 = s3140 ? s3142 : s3143; - const SWord8 s3145 = s3120 ? s3136 : s3144; - const SWord8 s3146 = s1 + s3128; - const SBool s3147 = s3146 < s1; - const SBool s3148 = s3146 < s3128; - const SBool s3149 = s3147 || s3148; - const SWord8 s3150 = (s3146 >> 1) | (s3146 << 7); - const SWord8 s3151 = 128 | s3150; - const SWord8 s3152 = 127 & s3150; - const SWord8 s3153 = s3149 ? s3151 : s3152; - const SWord8 s3154 = (s3153 >> 1) | (s3153 << 7); - const SWord8 s3155 = 128 | s3154; - const SWord8 s3156 = 127 & s3154; - const SWord8 s3157 = s3119 ? s3155 : s3156; - const SWord8 s3158 = s1 + s3153; - const SBool s3159 = s3158 < s1; - const SBool s3160 = s3158 < s3153; - const SBool s3161 = s3159 || s3160; - const SWord8 s3162 = (s3158 >> 1) | (s3158 << 7); - const SWord8 s3163 = 128 | s3162; - const SWord8 s3164 = 127 & s3162; - const SWord8 s3165 = s3161 ? s3163 : s3164; - const SWord8 s3166 = s3120 ? s3157 : s3165; - const SWord8 s3167 = s3101 ? s3145 : s3166; - const SWord8 s3168 = s1 + s3124; - const SBool s3169 = s3168 < s1; - const SBool s3170 = s3168 < s3124; - const SBool s3171 = s3169 || s3170; - const SWord8 s3172 = (s3168 >> 1) | (s3168 << 7); - const SWord8 s3173 = 128 | s3172; - const SWord8 s3174 = 127 & s3172; - const SWord8 s3175 = s3171 ? s3173 : s3174; - const SWord8 s3176 = (s3175 >> 1) | (s3175 << 7); - const SWord8 s3177 = 128 | s3176; - const SWord8 s3178 = 127 & s3176; - const SWord8 s3179 = s3100 ? s3177 : s3178; - const SWord8 s3180 = (s3179 >> 1) | (s3179 << 7); - const SWord8 s3181 = 128 | s3180; - const SWord8 s3182 = 127 & s3180; - const SWord8 s3183 = s3119 ? s3181 : s3182; - const SWord8 s3184 = s1 + s3179; - const SBool s3185 = s3184 < s1; - const SBool s3186 = s3184 < s3179; - const SBool s3187 = s3185 || s3186; - const SWord8 s3188 = (s3184 >> 1) | (s3184 << 7); - const SWord8 s3189 = 128 | s3188; - const SWord8 s3190 = 127 & s3188; - const SWord8 s3191 = s3187 ? s3189 : s3190; - const SWord8 s3192 = s3120 ? s3183 : s3191; - const SWord8 s3193 = s1 + s3175; - const SBool s3194 = s3193 < s1; - const SBool s3195 = s3193 < s3175; - const SBool s3196 = s3194 || s3195; - const SWord8 s3197 = (s3193 >> 1) | (s3193 << 7); - const SWord8 s3198 = 128 | s3197; - const SWord8 s3199 = 127 & s3197; - const SWord8 s3200 = s3196 ? s3198 : s3199; - const SWord8 s3201 = (s3200 >> 1) | (s3200 << 7); - const SWord8 s3202 = 128 | s3201; - const SWord8 s3203 = 127 & s3201; - const SWord8 s3204 = s3119 ? s3202 : s3203; - const SWord8 s3205 = s1 + s3200; - const SBool s3206 = s3205 < s1; - const SBool s3207 = s3205 < s3200; - const SBool s3208 = s3206 || s3207; - const SWord8 s3209 = (s3205 >> 1) | (s3205 << 7); - const SWord8 s3210 = 128 | s3209; - const SWord8 s3211 = 127 & s3209; - const SWord8 s3212 = s3208 ? s3210 : s3211; - const SWord8 s3213 = s3120 ? s3204 : s3212; - const SWord8 s3214 = s3101 ? s3192 : s3213; - const SWord8 s3215 = s3082 ? s3167 : s3214; - const SWord8 s3216 = s1 + s3105; - const SBool s3217 = (SBool) (s3216 & 1); - const SBool s3218 = false != s3217; - const SWord8 s3219 = s3218 ? s3109 : s3110; - const SBool s3220 = (SBool) (s3219 & 1); - const SBool s3221 = false != s3220; - const SWord8 s3222 = s3221 ? s3115 : s3116; - const SBool s3223 = (SBool) (s3222 & 1); - const SBool s3224 = false != s3223; - const SBool s3225 = !s3224; - const SBool s3226 = s3216 < s1; - const SBool s3227 = s3216 < s3105; - const SBool s3228 = s3226 || s3227; - const SWord8 s3229 = (s3216 >> 1) | (s3216 << 7); - const SWord8 s3230 = 128 | s3229; - const SWord8 s3231 = 127 & s3229; - const SWord8 s3232 = s3228 ? s3230 : s3231; - const SWord8 s3233 = (s3232 >> 1) | (s3232 << 7); - const SWord8 s3234 = 128 | s3233; - const SWord8 s3235 = 127 & s3233; - const SWord8 s3236 = s3081 ? s3234 : s3235; - const SWord8 s3237 = (s3236 >> 1) | (s3236 << 7); - const SWord8 s3238 = 128 | s3237; - const SWord8 s3239 = 127 & s3237; - const SWord8 s3240 = s3100 ? s3238 : s3239; - const SWord8 s3241 = (s3240 >> 1) | (s3240 << 7); - const SWord8 s3242 = 128 | s3241; - const SWord8 s3243 = 127 & s3241; - const SWord8 s3244 = s3224 ? s3242 : s3243; - const SWord8 s3245 = s1 + s3240; - const SBool s3246 = s3245 < s1; - const SBool s3247 = s3245 < s3240; - const SBool s3248 = s3246 || s3247; - const SWord8 s3249 = (s3245 >> 1) | (s3245 << 7); - const SWord8 s3250 = 128 | s3249; - const SWord8 s3251 = 127 & s3249; - const SWord8 s3252 = s3248 ? s3250 : s3251; - const SWord8 s3253 = s3225 ? s3244 : s3252; - const SWord8 s3254 = s1 + s3236; - const SBool s3255 = s3254 < s1; - const SBool s3256 = s3254 < s3236; - const SBool s3257 = s3255 || s3256; - const SWord8 s3258 = (s3254 >> 1) | (s3254 << 7); - const SWord8 s3259 = 128 | s3258; - const SWord8 s3260 = 127 & s3258; - const SWord8 s3261 = s3257 ? s3259 : s3260; - const SWord8 s3262 = (s3261 >> 1) | (s3261 << 7); - const SWord8 s3263 = 128 | s3262; - const SWord8 s3264 = 127 & s3262; - const SWord8 s3265 = s3224 ? s3263 : s3264; - const SWord8 s3266 = s1 + s3261; - const SBool s3267 = s3266 < s1; - const SBool s3268 = s3266 < s3261; - const SBool s3269 = s3267 || s3268; - const SWord8 s3270 = (s3266 >> 1) | (s3266 << 7); - const SWord8 s3271 = 128 | s3270; - const SWord8 s3272 = 127 & s3270; - const SWord8 s3273 = s3269 ? s3271 : s3272; - const SWord8 s3274 = s3225 ? s3265 : s3273; - const SWord8 s3275 = s3101 ? s3253 : s3274; - const SWord8 s3276 = s1 + s3232; - const SBool s3277 = s3276 < s1; - const SBool s3278 = s3276 < s3232; - const SBool s3279 = s3277 || s3278; - const SWord8 s3280 = (s3276 >> 1) | (s3276 << 7); - const SWord8 s3281 = 128 | s3280; - const SWord8 s3282 = 127 & s3280; - const SWord8 s3283 = s3279 ? s3281 : s3282; - const SWord8 s3284 = (s3283 >> 1) | (s3283 << 7); - const SWord8 s3285 = 128 | s3284; - const SWord8 s3286 = 127 & s3284; - const SWord8 s3287 = s3100 ? s3285 : s3286; - const SWord8 s3288 = (s3287 >> 1) | (s3287 << 7); - const SWord8 s3289 = 128 | s3288; - const SWord8 s3290 = 127 & s3288; - const SWord8 s3291 = s3224 ? s3289 : s3290; - const SWord8 s3292 = s1 + s3287; - const SBool s3293 = s3292 < s1; - const SBool s3294 = s3292 < s3287; - const SBool s3295 = s3293 || s3294; - const SWord8 s3296 = (s3292 >> 1) | (s3292 << 7); - const SWord8 s3297 = 128 | s3296; - const SWord8 s3298 = 127 & s3296; - const SWord8 s3299 = s3295 ? s3297 : s3298; - const SWord8 s3300 = s3225 ? s3291 : s3299; - const SWord8 s3301 = s1 + s3283; - const SBool s3302 = s3301 < s1; - const SBool s3303 = s3301 < s3283; - const SBool s3304 = s3302 || s3303; - const SWord8 s3305 = (s3301 >> 1) | (s3301 << 7); - const SWord8 s3306 = 128 | s3305; - const SWord8 s3307 = 127 & s3305; - const SWord8 s3308 = s3304 ? s3306 : s3307; - const SWord8 s3309 = (s3308 >> 1) | (s3308 << 7); - const SWord8 s3310 = 128 | s3309; - const SWord8 s3311 = 127 & s3309; - const SWord8 s3312 = s3224 ? s3310 : s3311; - const SWord8 s3313 = s1 + s3308; - const SBool s3314 = s3313 < s1; - const SBool s3315 = s3313 < s3308; - const SBool s3316 = s3314 || s3315; - const SWord8 s3317 = (s3313 >> 1) | (s3313 << 7); - const SWord8 s3318 = 128 | s3317; - const SWord8 s3319 = 127 & s3317; - const SWord8 s3320 = s3316 ? s3318 : s3319; - const SWord8 s3321 = s3225 ? s3312 : s3320; - const SWord8 s3322 = s3101 ? s3300 : s3321; - const SWord8 s3323 = s3082 ? s3275 : s3322; - const SWord8 s3324 = s3060 ? s3215 : s3323; - const SWord8 s3325 = s1 + s3086; - const SBool s3326 = (SBool) (s3325 & 1); - const SBool s3327 = false != s3326; - const SWord8 s3328 = s3327 ? s3090 : s3091; - const SBool s3329 = (SBool) (s3328 & 1); - const SBool s3330 = false != s3329; - const SWord8 s3331 = s3330 ? s3096 : s3097; - const SBool s3332 = (SBool) (s3331 & 1); - const SBool s3333 = false != s3332; - const SBool s3334 = !s3333; - const SBool s3335 = s3325 < s1; - const SBool s3336 = s3325 < s3086; - const SBool s3337 = s3335 || s3336; - const SWord8 s3338 = (s3325 >> 1) | (s3325 << 7); - const SWord8 s3339 = 128 | s3338; - const SWord8 s3340 = 127 & s3338; - const SWord8 s3341 = s3337 ? s3339 : s3340; - const SBool s3342 = (SBool) (s3341 & 1); - const SBool s3343 = false != s3342; - const SWord8 s3344 = (s3328 >> 1) | (s3328 << 7); - const SWord8 s3345 = 128 | s3344; - const SWord8 s3346 = 127 & s3344; - const SWord8 s3347 = s3343 ? s3345 : s3346; - const SBool s3348 = (SBool) (s3347 & 1); - const SBool s3349 = false != s3348; - const SWord8 s3350 = (s3331 >> 1) | (s3331 << 7); - const SWord8 s3351 = 128 | s3350; - const SWord8 s3352 = 127 & s3350; - const SWord8 s3353 = s3349 ? s3351 : s3352; - const SBool s3354 = (SBool) (s3353 & 1); - const SBool s3355 = false != s3354; - const SBool s3356 = !s3355; - const SWord8 s3357 = (s3341 >> 1) | (s3341 << 7); - const SWord8 s3358 = 128 | s3357; - const SWord8 s3359 = 127 & s3357; - const SWord8 s3360 = s3059 ? s3358 : s3359; - const SWord8 s3361 = (s3360 >> 1) | (s3360 << 7); - const SWord8 s3362 = 128 | s3361; - const SWord8 s3363 = 127 & s3361; - const SWord8 s3364 = s3081 ? s3362 : s3363; - const SWord8 s3365 = (s3364 >> 1) | (s3364 << 7); - const SWord8 s3366 = 128 | s3365; - const SWord8 s3367 = 127 & s3365; - const SWord8 s3368 = s3333 ? s3366 : s3367; - const SWord8 s3369 = (s3368 >> 1) | (s3368 << 7); - const SWord8 s3370 = 128 | s3369; - const SWord8 s3371 = 127 & s3369; - const SWord8 s3372 = s3355 ? s3370 : s3371; - const SWord8 s3373 = s1 + s3368; - const SBool s3374 = s3373 < s1; - const SBool s3375 = s3373 < s3368; - const SBool s3376 = s3374 || s3375; - const SWord8 s3377 = (s3373 >> 1) | (s3373 << 7); - const SWord8 s3378 = 128 | s3377; - const SWord8 s3379 = 127 & s3377; - const SWord8 s3380 = s3376 ? s3378 : s3379; - const SWord8 s3381 = s3356 ? s3372 : s3380; - const SWord8 s3382 = s1 + s3364; - const SBool s3383 = s3382 < s1; - const SBool s3384 = s3382 < s3364; - const SBool s3385 = s3383 || s3384; - const SWord8 s3386 = (s3382 >> 1) | (s3382 << 7); - const SWord8 s3387 = 128 | s3386; - const SWord8 s3388 = 127 & s3386; - const SWord8 s3389 = s3385 ? s3387 : s3388; - const SWord8 s3390 = (s3389 >> 1) | (s3389 << 7); - const SWord8 s3391 = 128 | s3390; - const SWord8 s3392 = 127 & s3390; - const SWord8 s3393 = s3355 ? s3391 : s3392; - const SWord8 s3394 = s1 + s3389; - const SBool s3395 = s3394 < s1; - const SBool s3396 = s3394 < s3389; - const SBool s3397 = s3395 || s3396; - const SWord8 s3398 = (s3394 >> 1) | (s3394 << 7); - const SWord8 s3399 = 128 | s3398; - const SWord8 s3400 = 127 & s3398; - const SWord8 s3401 = s3397 ? s3399 : s3400; - const SWord8 s3402 = s3356 ? s3393 : s3401; - const SWord8 s3403 = s3334 ? s3381 : s3402; - const SWord8 s3404 = s1 + s3360; - const SBool s3405 = s3404 < s1; - const SBool s3406 = s3404 < s3360; - const SBool s3407 = s3405 || s3406; - const SWord8 s3408 = (s3404 >> 1) | (s3404 << 7); - const SWord8 s3409 = 128 | s3408; - const SWord8 s3410 = 127 & s3408; - const SWord8 s3411 = s3407 ? s3409 : s3410; - const SWord8 s3412 = (s3411 >> 1) | (s3411 << 7); - const SWord8 s3413 = 128 | s3412; - const SWord8 s3414 = 127 & s3412; - const SWord8 s3415 = s3333 ? s3413 : s3414; - const SWord8 s3416 = (s3415 >> 1) | (s3415 << 7); - const SWord8 s3417 = 128 | s3416; - const SWord8 s3418 = 127 & s3416; - const SWord8 s3419 = s3355 ? s3417 : s3418; - const SWord8 s3420 = s1 + s3415; - const SBool s3421 = s3420 < s1; - const SBool s3422 = s3420 < s3415; - const SBool s3423 = s3421 || s3422; - const SWord8 s3424 = (s3420 >> 1) | (s3420 << 7); - const SWord8 s3425 = 128 | s3424; - const SWord8 s3426 = 127 & s3424; - const SWord8 s3427 = s3423 ? s3425 : s3426; - const SWord8 s3428 = s3356 ? s3419 : s3427; - const SWord8 s3429 = s1 + s3411; - const SBool s3430 = s3429 < s1; - const SBool s3431 = s3429 < s3411; - const SBool s3432 = s3430 || s3431; - const SWord8 s3433 = (s3429 >> 1) | (s3429 << 7); - const SWord8 s3434 = 128 | s3433; - const SWord8 s3435 = 127 & s3433; - const SWord8 s3436 = s3432 ? s3434 : s3435; - const SWord8 s3437 = (s3436 >> 1) | (s3436 << 7); - const SWord8 s3438 = 128 | s3437; - const SWord8 s3439 = 127 & s3437; - const SWord8 s3440 = s3355 ? s3438 : s3439; - const SWord8 s3441 = s1 + s3436; - const SBool s3442 = s3441 < s1; - const SBool s3443 = s3441 < s3436; - const SBool s3444 = s3442 || s3443; - const SWord8 s3445 = (s3441 >> 1) | (s3441 << 7); - const SWord8 s3446 = 128 | s3445; - const SWord8 s3447 = 127 & s3445; - const SWord8 s3448 = s3444 ? s3446 : s3447; - const SWord8 s3449 = s3356 ? s3440 : s3448; - const SWord8 s3450 = s3334 ? s3428 : s3449; - const SWord8 s3451 = s3082 ? s3403 : s3450; - const SWord8 s3452 = s1 + s3341; - const SBool s3453 = (SBool) (s3452 & 1); - const SBool s3454 = false != s3453; - const SWord8 s3455 = s3454 ? s3345 : s3346; - const SBool s3456 = (SBool) (s3455 & 1); - const SBool s3457 = false != s3456; - const SWord8 s3458 = s3457 ? s3351 : s3352; - const SBool s3459 = (SBool) (s3458 & 1); - const SBool s3460 = false != s3459; - const SBool s3461 = !s3460; - const SBool s3462 = s3452 < s1; - const SBool s3463 = s3452 < s3341; - const SBool s3464 = s3462 || s3463; - const SWord8 s3465 = (s3452 >> 1) | (s3452 << 7); - const SWord8 s3466 = 128 | s3465; - const SWord8 s3467 = 127 & s3465; - const SWord8 s3468 = s3464 ? s3466 : s3467; - const SWord8 s3469 = (s3468 >> 1) | (s3468 << 7); - const SWord8 s3470 = 128 | s3469; - const SWord8 s3471 = 127 & s3469; - const SWord8 s3472 = s3081 ? s3470 : s3471; - const SWord8 s3473 = (s3472 >> 1) | (s3472 << 7); - const SWord8 s3474 = 128 | s3473; - const SWord8 s3475 = 127 & s3473; - const SWord8 s3476 = s3333 ? s3474 : s3475; - const SWord8 s3477 = (s3476 >> 1) | (s3476 << 7); - const SWord8 s3478 = 128 | s3477; - const SWord8 s3479 = 127 & s3477; - const SWord8 s3480 = s3460 ? s3478 : s3479; - const SWord8 s3481 = s1 + s3476; - const SBool s3482 = s3481 < s1; - const SBool s3483 = s3481 < s3476; - const SBool s3484 = s3482 || s3483; - const SWord8 s3485 = (s3481 >> 1) | (s3481 << 7); - const SWord8 s3486 = 128 | s3485; - const SWord8 s3487 = 127 & s3485; - const SWord8 s3488 = s3484 ? s3486 : s3487; - const SWord8 s3489 = s3461 ? s3480 : s3488; - const SWord8 s3490 = s1 + s3472; - const SBool s3491 = s3490 < s1; - const SBool s3492 = s3490 < s3472; - const SBool s3493 = s3491 || s3492; - const SWord8 s3494 = (s3490 >> 1) | (s3490 << 7); - const SWord8 s3495 = 128 | s3494; - const SWord8 s3496 = 127 & s3494; - const SWord8 s3497 = s3493 ? s3495 : s3496; - const SWord8 s3498 = (s3497 >> 1) | (s3497 << 7); - const SWord8 s3499 = 128 | s3498; - const SWord8 s3500 = 127 & s3498; - const SWord8 s3501 = s3460 ? s3499 : s3500; - const SWord8 s3502 = s1 + s3497; - const SBool s3503 = s3502 < s1; - const SBool s3504 = s3502 < s3497; - const SBool s3505 = s3503 || s3504; - const SWord8 s3506 = (s3502 >> 1) | (s3502 << 7); - const SWord8 s3507 = 128 | s3506; - const SWord8 s3508 = 127 & s3506; - const SWord8 s3509 = s3505 ? s3507 : s3508; - const SWord8 s3510 = s3461 ? s3501 : s3509; - const SWord8 s3511 = s3334 ? s3489 : s3510; - const SWord8 s3512 = s1 + s3468; - const SBool s3513 = s3512 < s1; - const SBool s3514 = s3512 < s3468; - const SBool s3515 = s3513 || s3514; - const SWord8 s3516 = (s3512 >> 1) | (s3512 << 7); - const SWord8 s3517 = 128 | s3516; - const SWord8 s3518 = 127 & s3516; - const SWord8 s3519 = s3515 ? s3517 : s3518; - const SWord8 s3520 = (s3519 >> 1) | (s3519 << 7); - const SWord8 s3521 = 128 | s3520; - const SWord8 s3522 = 127 & s3520; - const SWord8 s3523 = s3333 ? s3521 : s3522; - const SWord8 s3524 = (s3523 >> 1) | (s3523 << 7); - const SWord8 s3525 = 128 | s3524; - const SWord8 s3526 = 127 & s3524; - const SWord8 s3527 = s3460 ? s3525 : s3526; - const SWord8 s3528 = s1 + s3523; - const SBool s3529 = s3528 < s1; - const SBool s3530 = s3528 < s3523; - const SBool s3531 = s3529 || s3530; - const SWord8 s3532 = (s3528 >> 1) | (s3528 << 7); - const SWord8 s3533 = 128 | s3532; - const SWord8 s3534 = 127 & s3532; - const SWord8 s3535 = s3531 ? s3533 : s3534; - const SWord8 s3536 = s3461 ? s3527 : s3535; - const SWord8 s3537 = s1 + s3519; - const SBool s3538 = s3537 < s1; - const SBool s3539 = s3537 < s3519; - const SBool s3540 = s3538 || s3539; - const SWord8 s3541 = (s3537 >> 1) | (s3537 << 7); - const SWord8 s3542 = 128 | s3541; - const SWord8 s3543 = 127 & s3541; - const SWord8 s3544 = s3540 ? s3542 : s3543; - const SWord8 s3545 = (s3544 >> 1) | (s3544 << 7); - const SWord8 s3546 = 128 | s3545; - const SWord8 s3547 = 127 & s3545; - const SWord8 s3548 = s3460 ? s3546 : s3547; - const SWord8 s3549 = s1 + s3544; - const SBool s3550 = s3549 < s1; - const SBool s3551 = s3549 < s3544; - const SBool s3552 = s3550 || s3551; - const SWord8 s3553 = (s3549 >> 1) | (s3549 << 7); - const SWord8 s3554 = 128 | s3553; - const SWord8 s3555 = 127 & s3553; - const SWord8 s3556 = s3552 ? s3554 : s3555; - const SWord8 s3557 = s3461 ? s3548 : s3556; - const SWord8 s3558 = s3334 ? s3536 : s3557; - const SWord8 s3559 = s3082 ? s3511 : s3558; - const SWord8 s3560 = s3060 ? s3451 : s3559; - const SWord8 s3561 = s2042 ? s3324 : s3560; - const SWord8 s3562 = s1 + s3067; - const SBool s3563 = (SBool) (s3562 & 1); - const SBool s3564 = false != s3563; - const SWord8 s3565 = s3564 ? s3071 : s3072; - const SBool s3566 = (SBool) (s3565 & 1); - const SBool s3567 = false != s3566; - const SWord8 s3568 = s3567 ? s3077 : s3078; - const SBool s3569 = (SBool) (s3568 & 1); - const SBool s3570 = false != s3569; - const SBool s3571 = !s3570; - const SBool s3572 = s3562 < s1; - const SBool s3573 = s3562 < s3067; - const SBool s3574 = s3572 || s3573; - const SWord8 s3575 = (s3562 >> 1) | (s3562 << 7); - const SWord8 s3576 = 128 | s3575; - const SWord8 s3577 = 127 & s3575; - const SWord8 s3578 = s3574 ? s3576 : s3577; - const SBool s3579 = (SBool) (s3578 & 1); - const SBool s3580 = false != s3579; - const SWord8 s3581 = (s3565 >> 1) | (s3565 << 7); - const SWord8 s3582 = 128 | s3581; - const SWord8 s3583 = 127 & s3581; - const SWord8 s3584 = s3580 ? s3582 : s3583; - const SBool s3585 = (SBool) (s3584 & 1); - const SBool s3586 = false != s3585; - const SWord8 s3587 = (s3568 >> 1) | (s3568 << 7); - const SWord8 s3588 = 128 | s3587; - const SWord8 s3589 = 127 & s3587; - const SWord8 s3590 = s3586 ? s3588 : s3589; - const SBool s3591 = (SBool) (s3590 & 1); - const SBool s3592 = false != s3591; - const SBool s3593 = !s3592; - const SWord8 s3594 = (s3578 >> 1) | (s3578 << 7); - const SWord8 s3595 = 128 | s3594; - const SWord8 s3596 = 127 & s3594; - const SWord8 s3597 = s2041 ? s3595 : s3596; - const SBool s3598 = (SBool) (s3597 & 1); - const SBool s3599 = false != s3598; - const SWord8 s3600 = (s3584 >> 1) | (s3584 << 7); - const SWord8 s3601 = 128 | s3600; - const SWord8 s3602 = 127 & s3600; - const SWord8 s3603 = s3599 ? s3601 : s3602; - const SBool s3604 = (SBool) (s3603 & 1); - const SBool s3605 = false != s3604; - const SWord8 s3606 = (s3590 >> 1) | (s3590 << 7); - const SWord8 s3607 = 128 | s3606; - const SWord8 s3608 = 127 & s3606; - const SWord8 s3609 = s3605 ? s3607 : s3608; - const SBool s3610 = (SBool) (s3609 & 1); - const SBool s3611 = false != s3610; - const SBool s3612 = !s3611; - const SWord8 s3613 = (s3597 >> 1) | (s3597 << 7); - const SWord8 s3614 = 128 | s3613; - const SWord8 s3615 = 127 & s3613; - const SWord8 s3616 = s3059 ? s3614 : s3615; - const SWord8 s3617 = (s3616 >> 1) | (s3616 << 7); - const SWord8 s3618 = 128 | s3617; - const SWord8 s3619 = 127 & s3617; - const SWord8 s3620 = s3570 ? s3618 : s3619; - const SWord8 s3621 = (s3620 >> 1) | (s3620 << 7); - const SWord8 s3622 = 128 | s3621; - const SWord8 s3623 = 127 & s3621; - const SWord8 s3624 = s3592 ? s3622 : s3623; - const SWord8 s3625 = (s3624 >> 1) | (s3624 << 7); - const SWord8 s3626 = 128 | s3625; - const SWord8 s3627 = 127 & s3625; - const SWord8 s3628 = s3611 ? s3626 : s3627; - const SWord8 s3629 = s1 + s3624; - const SBool s3630 = s3629 < s1; - const SBool s3631 = s3629 < s3624; - const SBool s3632 = s3630 || s3631; - const SWord8 s3633 = (s3629 >> 1) | (s3629 << 7); - const SWord8 s3634 = 128 | s3633; - const SWord8 s3635 = 127 & s3633; - const SWord8 s3636 = s3632 ? s3634 : s3635; - const SWord8 s3637 = s3612 ? s3628 : s3636; - const SWord8 s3638 = s1 + s3620; - const SBool s3639 = s3638 < s1; - const SBool s3640 = s3638 < s3620; - const SBool s3641 = s3639 || s3640; - const SWord8 s3642 = (s3638 >> 1) | (s3638 << 7); - const SWord8 s3643 = 128 | s3642; - const SWord8 s3644 = 127 & s3642; - const SWord8 s3645 = s3641 ? s3643 : s3644; - const SWord8 s3646 = (s3645 >> 1) | (s3645 << 7); - const SWord8 s3647 = 128 | s3646; - const SWord8 s3648 = 127 & s3646; - const SWord8 s3649 = s3611 ? s3647 : s3648; - const SWord8 s3650 = s1 + s3645; - const SBool s3651 = s3650 < s1; - const SBool s3652 = s3650 < s3645; - const SBool s3653 = s3651 || s3652; - const SWord8 s3654 = (s3650 >> 1) | (s3650 << 7); - const SWord8 s3655 = 128 | s3654; - const SWord8 s3656 = 127 & s3654; - const SWord8 s3657 = s3653 ? s3655 : s3656; - const SWord8 s3658 = s3612 ? s3649 : s3657; - const SWord8 s3659 = s3593 ? s3637 : s3658; - const SWord8 s3660 = s1 + s3616; - const SBool s3661 = s3660 < s1; - const SBool s3662 = s3660 < s3616; - const SBool s3663 = s3661 || s3662; - const SWord8 s3664 = (s3660 >> 1) | (s3660 << 7); - const SWord8 s3665 = 128 | s3664; - const SWord8 s3666 = 127 & s3664; - const SWord8 s3667 = s3663 ? s3665 : s3666; - const SWord8 s3668 = (s3667 >> 1) | (s3667 << 7); - const SWord8 s3669 = 128 | s3668; - const SWord8 s3670 = 127 & s3668; - const SWord8 s3671 = s3592 ? s3669 : s3670; - const SWord8 s3672 = (s3671 >> 1) | (s3671 << 7); - const SWord8 s3673 = 128 | s3672; - const SWord8 s3674 = 127 & s3672; - const SWord8 s3675 = s3611 ? s3673 : s3674; - const SWord8 s3676 = s1 + s3671; - const SBool s3677 = s3676 < s1; - const SBool s3678 = s3676 < s3671; - const SBool s3679 = s3677 || s3678; - const SWord8 s3680 = (s3676 >> 1) | (s3676 << 7); - const SWord8 s3681 = 128 | s3680; - const SWord8 s3682 = 127 & s3680; - const SWord8 s3683 = s3679 ? s3681 : s3682; - const SWord8 s3684 = s3612 ? s3675 : s3683; - const SWord8 s3685 = s1 + s3667; - const SBool s3686 = s3685 < s1; - const SBool s3687 = s3685 < s3667; - const SBool s3688 = s3686 || s3687; - const SWord8 s3689 = (s3685 >> 1) | (s3685 << 7); - const SWord8 s3690 = 128 | s3689; - const SWord8 s3691 = 127 & s3689; - const SWord8 s3692 = s3688 ? s3690 : s3691; - const SWord8 s3693 = (s3692 >> 1) | (s3692 << 7); - const SWord8 s3694 = 128 | s3693; - const SWord8 s3695 = 127 & s3693; - const SWord8 s3696 = s3611 ? s3694 : s3695; - const SWord8 s3697 = s1 + s3692; - const SBool s3698 = s3697 < s1; - const SBool s3699 = s3697 < s3692; - const SBool s3700 = s3698 || s3699; - const SWord8 s3701 = (s3697 >> 1) | (s3697 << 7); - const SWord8 s3702 = 128 | s3701; - const SWord8 s3703 = 127 & s3701; - const SWord8 s3704 = s3700 ? s3702 : s3703; - const SWord8 s3705 = s3612 ? s3696 : s3704; - const SWord8 s3706 = s3593 ? s3684 : s3705; - const SWord8 s3707 = s3571 ? s3659 : s3706; - const SWord8 s3708 = s1 + s3597; - const SBool s3709 = (SBool) (s3708 & 1); - const SBool s3710 = false != s3709; - const SWord8 s3711 = s3710 ? s3601 : s3602; - const SBool s3712 = (SBool) (s3711 & 1); - const SBool s3713 = false != s3712; - const SWord8 s3714 = s3713 ? s3607 : s3608; - const SBool s3715 = (SBool) (s3714 & 1); - const SBool s3716 = false != s3715; - const SBool s3717 = !s3716; - const SBool s3718 = s3708 < s1; - const SBool s3719 = s3708 < s3597; - const SBool s3720 = s3718 || s3719; - const SWord8 s3721 = (s3708 >> 1) | (s3708 << 7); - const SWord8 s3722 = 128 | s3721; - const SWord8 s3723 = 127 & s3721; - const SWord8 s3724 = s3720 ? s3722 : s3723; - const SWord8 s3725 = (s3724 >> 1) | (s3724 << 7); - const SWord8 s3726 = 128 | s3725; - const SWord8 s3727 = 127 & s3725; - const SWord8 s3728 = s3570 ? s3726 : s3727; - const SWord8 s3729 = (s3728 >> 1) | (s3728 << 7); - const SWord8 s3730 = 128 | s3729; - const SWord8 s3731 = 127 & s3729; - const SWord8 s3732 = s3592 ? s3730 : s3731; - const SWord8 s3733 = (s3732 >> 1) | (s3732 << 7); - const SWord8 s3734 = 128 | s3733; - const SWord8 s3735 = 127 & s3733; - const SWord8 s3736 = s3716 ? s3734 : s3735; - const SWord8 s3737 = s1 + s3732; - const SBool s3738 = s3737 < s1; - const SBool s3739 = s3737 < s3732; - const SBool s3740 = s3738 || s3739; - const SWord8 s3741 = (s3737 >> 1) | (s3737 << 7); - const SWord8 s3742 = 128 | s3741; - const SWord8 s3743 = 127 & s3741; - const SWord8 s3744 = s3740 ? s3742 : s3743; - const SWord8 s3745 = s3717 ? s3736 : s3744; - const SWord8 s3746 = s1 + s3728; - const SBool s3747 = s3746 < s1; - const SBool s3748 = s3746 < s3728; - const SBool s3749 = s3747 || s3748; - const SWord8 s3750 = (s3746 >> 1) | (s3746 << 7); - const SWord8 s3751 = 128 | s3750; - const SWord8 s3752 = 127 & s3750; - const SWord8 s3753 = s3749 ? s3751 : s3752; - const SWord8 s3754 = (s3753 >> 1) | (s3753 << 7); - const SWord8 s3755 = 128 | s3754; - const SWord8 s3756 = 127 & s3754; - const SWord8 s3757 = s3716 ? s3755 : s3756; - const SWord8 s3758 = s1 + s3753; - const SBool s3759 = s3758 < s1; - const SBool s3760 = s3758 < s3753; - const SBool s3761 = s3759 || s3760; - const SWord8 s3762 = (s3758 >> 1) | (s3758 << 7); - const SWord8 s3763 = 128 | s3762; - const SWord8 s3764 = 127 & s3762; - const SWord8 s3765 = s3761 ? s3763 : s3764; - const SWord8 s3766 = s3717 ? s3757 : s3765; - const SWord8 s3767 = s3593 ? s3745 : s3766; - const SWord8 s3768 = s1 + s3724; - const SBool s3769 = s3768 < s1; - const SBool s3770 = s3768 < s3724; - const SBool s3771 = s3769 || s3770; - const SWord8 s3772 = (s3768 >> 1) | (s3768 << 7); - const SWord8 s3773 = 128 | s3772; - const SWord8 s3774 = 127 & s3772; - const SWord8 s3775 = s3771 ? s3773 : s3774; - const SWord8 s3776 = (s3775 >> 1) | (s3775 << 7); - const SWord8 s3777 = 128 | s3776; - const SWord8 s3778 = 127 & s3776; - const SWord8 s3779 = s3592 ? s3777 : s3778; - const SWord8 s3780 = (s3779 >> 1) | (s3779 << 7); - const SWord8 s3781 = 128 | s3780; - const SWord8 s3782 = 127 & s3780; - const SWord8 s3783 = s3716 ? s3781 : s3782; - const SWord8 s3784 = s1 + s3779; - const SBool s3785 = s3784 < s1; - const SBool s3786 = s3784 < s3779; - const SBool s3787 = s3785 || s3786; - const SWord8 s3788 = (s3784 >> 1) | (s3784 << 7); - const SWord8 s3789 = 128 | s3788; - const SWord8 s3790 = 127 & s3788; - const SWord8 s3791 = s3787 ? s3789 : s3790; - const SWord8 s3792 = s3717 ? s3783 : s3791; - const SWord8 s3793 = s1 + s3775; - const SBool s3794 = s3793 < s1; - const SBool s3795 = s3793 < s3775; - const SBool s3796 = s3794 || s3795; - const SWord8 s3797 = (s3793 >> 1) | (s3793 << 7); - const SWord8 s3798 = 128 | s3797; - const SWord8 s3799 = 127 & s3797; - const SWord8 s3800 = s3796 ? s3798 : s3799; - const SWord8 s3801 = (s3800 >> 1) | (s3800 << 7); - const SWord8 s3802 = 128 | s3801; - const SWord8 s3803 = 127 & s3801; - const SWord8 s3804 = s3716 ? s3802 : s3803; - const SWord8 s3805 = s1 + s3800; - const SBool s3806 = s3805 < s1; - const SBool s3807 = s3805 < s3800; - const SBool s3808 = s3806 || s3807; - const SWord8 s3809 = (s3805 >> 1) | (s3805 << 7); - const SWord8 s3810 = 128 | s3809; - const SWord8 s3811 = 127 & s3809; - const SWord8 s3812 = s3808 ? s3810 : s3811; - const SWord8 s3813 = s3717 ? s3804 : s3812; - const SWord8 s3814 = s3593 ? s3792 : s3813; - const SWord8 s3815 = s3571 ? s3767 : s3814; - const SWord8 s3816 = s3060 ? s3707 : s3815; - const SWord8 s3817 = s1 + s3578; - const SBool s3818 = (SBool) (s3817 & 1); - const SBool s3819 = false != s3818; - const SWord8 s3820 = s3819 ? s3582 : s3583; - const SBool s3821 = (SBool) (s3820 & 1); - const SBool s3822 = false != s3821; - const SWord8 s3823 = s3822 ? s3588 : s3589; - const SBool s3824 = (SBool) (s3823 & 1); - const SBool s3825 = false != s3824; - const SBool s3826 = !s3825; - const SBool s3827 = s3817 < s1; - const SBool s3828 = s3817 < s3578; - const SBool s3829 = s3827 || s3828; - const SWord8 s3830 = (s3817 >> 1) | (s3817 << 7); - const SWord8 s3831 = 128 | s3830; - const SWord8 s3832 = 127 & s3830; - const SWord8 s3833 = s3829 ? s3831 : s3832; - const SBool s3834 = (SBool) (s3833 & 1); - const SBool s3835 = false != s3834; - const SWord8 s3836 = (s3820 >> 1) | (s3820 << 7); - const SWord8 s3837 = 128 | s3836; - const SWord8 s3838 = 127 & s3836; - const SWord8 s3839 = s3835 ? s3837 : s3838; - const SBool s3840 = (SBool) (s3839 & 1); - const SBool s3841 = false != s3840; - const SWord8 s3842 = (s3823 >> 1) | (s3823 << 7); - const SWord8 s3843 = 128 | s3842; - const SWord8 s3844 = 127 & s3842; - const SWord8 s3845 = s3841 ? s3843 : s3844; - const SBool s3846 = (SBool) (s3845 & 1); - const SBool s3847 = false != s3846; - const SBool s3848 = !s3847; - const SWord8 s3849 = (s3833 >> 1) | (s3833 << 7); - const SWord8 s3850 = 128 | s3849; - const SWord8 s3851 = 127 & s3849; - const SWord8 s3852 = s3059 ? s3850 : s3851; - const SWord8 s3853 = (s3852 >> 1) | (s3852 << 7); - const SWord8 s3854 = 128 | s3853; - const SWord8 s3855 = 127 & s3853; - const SWord8 s3856 = s3570 ? s3854 : s3855; - const SWord8 s3857 = (s3856 >> 1) | (s3856 << 7); - const SWord8 s3858 = 128 | s3857; - const SWord8 s3859 = 127 & s3857; - const SWord8 s3860 = s3825 ? s3858 : s3859; - const SWord8 s3861 = (s3860 >> 1) | (s3860 << 7); - const SWord8 s3862 = 128 | s3861; - const SWord8 s3863 = 127 & s3861; - const SWord8 s3864 = s3847 ? s3862 : s3863; - const SWord8 s3865 = s1 + s3860; - const SBool s3866 = s3865 < s1; - const SBool s3867 = s3865 < s3860; - const SBool s3868 = s3866 || s3867; - const SWord8 s3869 = (s3865 >> 1) | (s3865 << 7); - const SWord8 s3870 = 128 | s3869; - const SWord8 s3871 = 127 & s3869; - const SWord8 s3872 = s3868 ? s3870 : s3871; - const SWord8 s3873 = s3848 ? s3864 : s3872; - const SWord8 s3874 = s1 + s3856; - const SBool s3875 = s3874 < s1; - const SBool s3876 = s3874 < s3856; - const SBool s3877 = s3875 || s3876; - const SWord8 s3878 = (s3874 >> 1) | (s3874 << 7); - const SWord8 s3879 = 128 | s3878; - const SWord8 s3880 = 127 & s3878; - const SWord8 s3881 = s3877 ? s3879 : s3880; - const SWord8 s3882 = (s3881 >> 1) | (s3881 << 7); - const SWord8 s3883 = 128 | s3882; - const SWord8 s3884 = 127 & s3882; - const SWord8 s3885 = s3847 ? s3883 : s3884; - const SWord8 s3886 = s1 + s3881; - const SBool s3887 = s3886 < s1; - const SBool s3888 = s3886 < s3881; - const SBool s3889 = s3887 || s3888; - const SWord8 s3890 = (s3886 >> 1) | (s3886 << 7); - const SWord8 s3891 = 128 | s3890; - const SWord8 s3892 = 127 & s3890; - const SWord8 s3893 = s3889 ? s3891 : s3892; - const SWord8 s3894 = s3848 ? s3885 : s3893; - const SWord8 s3895 = s3826 ? s3873 : s3894; - const SWord8 s3896 = s1 + s3852; - const SBool s3897 = s3896 < s1; - const SBool s3898 = s3896 < s3852; - const SBool s3899 = s3897 || s3898; - const SWord8 s3900 = (s3896 >> 1) | (s3896 << 7); - const SWord8 s3901 = 128 | s3900; - const SWord8 s3902 = 127 & s3900; - const SWord8 s3903 = s3899 ? s3901 : s3902; - const SWord8 s3904 = (s3903 >> 1) | (s3903 << 7); - const SWord8 s3905 = 128 | s3904; - const SWord8 s3906 = 127 & s3904; - const SWord8 s3907 = s3825 ? s3905 : s3906; - const SWord8 s3908 = (s3907 >> 1) | (s3907 << 7); - const SWord8 s3909 = 128 | s3908; - const SWord8 s3910 = 127 & s3908; - const SWord8 s3911 = s3847 ? s3909 : s3910; - const SWord8 s3912 = s1 + s3907; - const SBool s3913 = s3912 < s1; - const SBool s3914 = s3912 < s3907; - const SBool s3915 = s3913 || s3914; - const SWord8 s3916 = (s3912 >> 1) | (s3912 << 7); - const SWord8 s3917 = 128 | s3916; - const SWord8 s3918 = 127 & s3916; - const SWord8 s3919 = s3915 ? s3917 : s3918; - const SWord8 s3920 = s3848 ? s3911 : s3919; - const SWord8 s3921 = s1 + s3903; - const SBool s3922 = s3921 < s1; - const SBool s3923 = s3921 < s3903; - const SBool s3924 = s3922 || s3923; - const SWord8 s3925 = (s3921 >> 1) | (s3921 << 7); - const SWord8 s3926 = 128 | s3925; - const SWord8 s3927 = 127 & s3925; - const SWord8 s3928 = s3924 ? s3926 : s3927; - const SWord8 s3929 = (s3928 >> 1) | (s3928 << 7); - const SWord8 s3930 = 128 | s3929; - const SWord8 s3931 = 127 & s3929; - const SWord8 s3932 = s3847 ? s3930 : s3931; - const SWord8 s3933 = s1 + s3928; - const SBool s3934 = s3933 < s1; - const SBool s3935 = s3933 < s3928; - const SBool s3936 = s3934 || s3935; - const SWord8 s3937 = (s3933 >> 1) | (s3933 << 7); - const SWord8 s3938 = 128 | s3937; - const SWord8 s3939 = 127 & s3937; - const SWord8 s3940 = s3936 ? s3938 : s3939; - const SWord8 s3941 = s3848 ? s3932 : s3940; - const SWord8 s3942 = s3826 ? s3920 : s3941; - const SWord8 s3943 = s3571 ? s3895 : s3942; - const SWord8 s3944 = s1 + s3833; - const SBool s3945 = (SBool) (s3944 & 1); - const SBool s3946 = false != s3945; - const SWord8 s3947 = s3946 ? s3837 : s3838; - const SBool s3948 = (SBool) (s3947 & 1); - const SBool s3949 = false != s3948; - const SWord8 s3950 = s3949 ? s3843 : s3844; - const SBool s3951 = (SBool) (s3950 & 1); - const SBool s3952 = false != s3951; - const SBool s3953 = !s3952; - const SBool s3954 = s3944 < s1; - const SBool s3955 = s3944 < s3833; - const SBool s3956 = s3954 || s3955; - const SWord8 s3957 = (s3944 >> 1) | (s3944 << 7); - const SWord8 s3958 = 128 | s3957; - const SWord8 s3959 = 127 & s3957; - const SWord8 s3960 = s3956 ? s3958 : s3959; - const SWord8 s3961 = (s3960 >> 1) | (s3960 << 7); - const SWord8 s3962 = 128 | s3961; - const SWord8 s3963 = 127 & s3961; - const SWord8 s3964 = s3570 ? s3962 : s3963; - const SWord8 s3965 = (s3964 >> 1) | (s3964 << 7); - const SWord8 s3966 = 128 | s3965; - const SWord8 s3967 = 127 & s3965; - const SWord8 s3968 = s3825 ? s3966 : s3967; - const SWord8 s3969 = (s3968 >> 1) | (s3968 << 7); - const SWord8 s3970 = 128 | s3969; - const SWord8 s3971 = 127 & s3969; - const SWord8 s3972 = s3952 ? s3970 : s3971; - const SWord8 s3973 = s1 + s3968; - const SBool s3974 = s3973 < s1; - const SBool s3975 = s3973 < s3968; - const SBool s3976 = s3974 || s3975; - const SWord8 s3977 = (s3973 >> 1) | (s3973 << 7); - const SWord8 s3978 = 128 | s3977; - const SWord8 s3979 = 127 & s3977; - const SWord8 s3980 = s3976 ? s3978 : s3979; - const SWord8 s3981 = s3953 ? s3972 : s3980; - const SWord8 s3982 = s1 + s3964; - const SBool s3983 = s3982 < s1; - const SBool s3984 = s3982 < s3964; - const SBool s3985 = s3983 || s3984; - const SWord8 s3986 = (s3982 >> 1) | (s3982 << 7); - const SWord8 s3987 = 128 | s3986; - const SWord8 s3988 = 127 & s3986; - const SWord8 s3989 = s3985 ? s3987 : s3988; - const SWord8 s3990 = (s3989 >> 1) | (s3989 << 7); - const SWord8 s3991 = 128 | s3990; - const SWord8 s3992 = 127 & s3990; - const SWord8 s3993 = s3952 ? s3991 : s3992; - const SWord8 s3994 = s1 + s3989; - const SBool s3995 = s3994 < s1; - const SBool s3996 = s3994 < s3989; - const SBool s3997 = s3995 || s3996; - const SWord8 s3998 = (s3994 >> 1) | (s3994 << 7); - const SWord8 s3999 = 128 | s3998; - const SWord8 s4000 = 127 & s3998; - const SWord8 s4001 = s3997 ? s3999 : s4000; - const SWord8 s4002 = s3953 ? s3993 : s4001; - const SWord8 s4003 = s3826 ? s3981 : s4002; - const SWord8 s4004 = s1 + s3960; - const SBool s4005 = s4004 < s1; - const SBool s4006 = s4004 < s3960; - const SBool s4007 = s4005 || s4006; - const SWord8 s4008 = (s4004 >> 1) | (s4004 << 7); - const SWord8 s4009 = 128 | s4008; - const SWord8 s4010 = 127 & s4008; - const SWord8 s4011 = s4007 ? s4009 : s4010; - const SWord8 s4012 = (s4011 >> 1) | (s4011 << 7); - const SWord8 s4013 = 128 | s4012; - const SWord8 s4014 = 127 & s4012; - const SWord8 s4015 = s3825 ? s4013 : s4014; - const SWord8 s4016 = (s4015 >> 1) | (s4015 << 7); - const SWord8 s4017 = 128 | s4016; - const SWord8 s4018 = 127 & s4016; - const SWord8 s4019 = s3952 ? s4017 : s4018; - const SWord8 s4020 = s1 + s4015; - const SBool s4021 = s4020 < s1; - const SBool s4022 = s4020 < s4015; - const SBool s4023 = s4021 || s4022; - const SWord8 s4024 = (s4020 >> 1) | (s4020 << 7); - const SWord8 s4025 = 128 | s4024; - const SWord8 s4026 = 127 & s4024; - const SWord8 s4027 = s4023 ? s4025 : s4026; - const SWord8 s4028 = s3953 ? s4019 : s4027; - const SWord8 s4029 = s1 + s4011; - const SBool s4030 = s4029 < s1; - const SBool s4031 = s4029 < s4011; - const SBool s4032 = s4030 || s4031; - const SWord8 s4033 = (s4029 >> 1) | (s4029 << 7); - const SWord8 s4034 = 128 | s4033; - const SWord8 s4035 = 127 & s4033; - const SWord8 s4036 = s4032 ? s4034 : s4035; - const SWord8 s4037 = (s4036 >> 1) | (s4036 << 7); - const SWord8 s4038 = 128 | s4037; - const SWord8 s4039 = 127 & s4037; - const SWord8 s4040 = s3952 ? s4038 : s4039; - const SWord8 s4041 = s1 + s4036; - const SBool s4042 = s4041 < s1; - const SBool s4043 = s4041 < s4036; - const SBool s4044 = s4042 || s4043; - const SWord8 s4045 = (s4041 >> 1) | (s4041 << 7); - const SWord8 s4046 = 128 | s4045; - const SWord8 s4047 = 127 & s4045; - const SWord8 s4048 = s4044 ? s4046 : s4047; - const SWord8 s4049 = s3953 ? s4040 : s4048; - const SWord8 s4050 = s3826 ? s4028 : s4049; - const SWord8 s4051 = s3571 ? s4003 : s4050; - const SWord8 s4052 = s3060 ? s3943 : s4051; - const SWord8 s4053 = s2042 ? s3816 : s4052; - const SWord8 s4054 = s16 ? s3561 : s4053; - const SWord8 s4055 = s11 ? s3050 : s4054; - const SWord8 s4056 = s5 ? s2032 : s4055; - const SBool s4057 = (SBool) (s105 & 1); - const SBool s4058 = false != s4057; - const SBool s4059 = (SBool) (s101 & 1); - const SBool s4060 = false != s4059; - const SBool s4061 = (SBool) (s97 & 1); - const SBool s4062 = false != s4061; - const SWord8 s4063 = (s84 >> 1) | (s84 << 7); - const SWord8 s4064 = 128 | s4063; - const SWord8 s4065 = 127 & s4063; - const SWord8 s4066 = s4062 ? s4064 : s4065; - const SWord8 s4067 = (s4066 >> 1) | (s4066 << 7); - const SWord8 s4068 = 128 | s4067; - const SWord8 s4069 = 127 & s4067; - const SWord8 s4070 = s4060 ? s4068 : s4069; - const SWord8 s4071 = (s4070 >> 1) | (s4070 << 7); - const SWord8 s4072 = 128 | s4071; - const SWord8 s4073 = 127 & s4071; - const SWord8 s4074 = s4058 ? s4072 : s4073; - const SBool s4075 = (SBool) (s110 & 1); - const SBool s4076 = false != s4075; - const SWord8 s4077 = s4076 ? s4072 : s4073; - const SWord8 s4078 = s93 ? s4074 : s4077; - const SBool s4079 = (SBool) (s126 & 1); - const SBool s4080 = false != s4079; - const SBool s4081 = (SBool) (s119 & 1); - const SBool s4082 = false != s4081; - const SWord8 s4083 = s4082 ? s4068 : s4069; - const SWord8 s4084 = (s4083 >> 1) | (s4083 << 7); - const SWord8 s4085 = 128 | s4084; - const SWord8 s4086 = 127 & s4084; - const SWord8 s4087 = s4080 ? s4085 : s4086; - const SBool s4088 = (SBool) (s131 & 1); - const SBool s4089 = false != s4088; - const SWord8 s4090 = s4089 ? s4085 : s4086; - const SWord8 s4091 = s93 ? s4087 : s4090; - const SWord8 s4092 = s74 ? s4078 : s4091; - const SBool s4093 = (SBool) (s152 & 1); - const SBool s4094 = false != s4093; - const SBool s4095 = (SBool) (s148 & 1); - const SBool s4096 = false != s4095; - const SBool s4097 = (SBool) (s141 & 1); - const SBool s4098 = false != s4097; - const SWord8 s4099 = s4098 ? s4064 : s4065; - const SWord8 s4100 = (s4099 >> 1) | (s4099 << 7); - const SWord8 s4101 = 128 | s4100; - const SWord8 s4102 = 127 & s4100; - const SWord8 s4103 = s4096 ? s4101 : s4102; - const SWord8 s4104 = (s4103 >> 1) | (s4103 << 7); - const SWord8 s4105 = 128 | s4104; - const SWord8 s4106 = 127 & s4104; - const SWord8 s4107 = s4094 ? s4105 : s4106; - const SBool s4108 = (SBool) (s157 & 1); - const SBool s4109 = false != s4108; - const SWord8 s4110 = s4109 ? s4105 : s4106; - const SWord8 s4111 = s93 ? s4107 : s4110; - const SBool s4112 = (SBool) (s173 & 1); - const SBool s4113 = false != s4112; - const SBool s4114 = (SBool) (s166 & 1); - const SBool s4115 = false != s4114; - const SWord8 s4116 = s4115 ? s4101 : s4102; - const SWord8 s4117 = (s4116 >> 1) | (s4116 << 7); - const SWord8 s4118 = 128 | s4117; - const SWord8 s4119 = 127 & s4117; - const SWord8 s4120 = s4113 ? s4118 : s4119; - const SBool s4121 = (SBool) (s178 & 1); - const SBool s4122 = false != s4121; - const SWord8 s4123 = s4122 ? s4118 : s4119; - const SWord8 s4124 = s93 ? s4120 : s4123; - const SWord8 s4125 = s74 ? s4111 : s4124; - const SWord8 s4126 = s55 ? s4092 : s4125; - const SBool s4127 = (SBool) (s213 & 1); - const SBool s4128 = false != s4127; - const SBool s4129 = (SBool) (s209 & 1); - const SBool s4130 = false != s4129; - const SBool s4131 = (SBool) (s205 & 1); - const SBool s4132 = false != s4131; - const SWord8 s4133 = (s192 >> 1) | (s192 << 7); - const SWord8 s4134 = 128 | s4133; - const SWord8 s4135 = 127 & s4133; - const SWord8 s4136 = s4132 ? s4134 : s4135; - const SWord8 s4137 = (s4136 >> 1) | (s4136 << 7); - const SWord8 s4138 = 128 | s4137; - const SWord8 s4139 = 127 & s4137; - const SWord8 s4140 = s4130 ? s4138 : s4139; - const SWord8 s4141 = (s4140 >> 1) | (s4140 << 7); - const SWord8 s4142 = 128 | s4141; - const SWord8 s4143 = 127 & s4141; - const SWord8 s4144 = s4128 ? s4142 : s4143; - const SBool s4145 = (SBool) (s218 & 1); - const SBool s4146 = false != s4145; - const SWord8 s4147 = s4146 ? s4142 : s4143; - const SWord8 s4148 = s198 ? s4144 : s4147; - const SBool s4149 = (SBool) (s234 & 1); - const SBool s4150 = false != s4149; - const SBool s4151 = (SBool) (s227 & 1); - const SBool s4152 = false != s4151; - const SWord8 s4153 = s4152 ? s4138 : s4139; - const SWord8 s4154 = (s4153 >> 1) | (s4153 << 7); - const SWord8 s4155 = 128 | s4154; - const SWord8 s4156 = 127 & s4154; - const SWord8 s4157 = s4150 ? s4155 : s4156; - const SBool s4158 = (SBool) (s239 & 1); - const SBool s4159 = false != s4158; - const SWord8 s4160 = s4159 ? s4155 : s4156; - const SWord8 s4161 = s198 ? s4157 : s4160; - const SWord8 s4162 = s74 ? s4148 : s4161; - const SBool s4163 = (SBool) (s260 & 1); - const SBool s4164 = false != s4163; - const SBool s4165 = (SBool) (s256 & 1); - const SBool s4166 = false != s4165; - const SBool s4167 = (SBool) (s249 & 1); - const SBool s4168 = false != s4167; - const SWord8 s4169 = s4168 ? s4134 : s4135; - const SWord8 s4170 = (s4169 >> 1) | (s4169 << 7); - const SWord8 s4171 = 128 | s4170; - const SWord8 s4172 = 127 & s4170; - const SWord8 s4173 = s4166 ? s4171 : s4172; - const SWord8 s4174 = (s4173 >> 1) | (s4173 << 7); - const SWord8 s4175 = 128 | s4174; - const SWord8 s4176 = 127 & s4174; - const SWord8 s4177 = s4164 ? s4175 : s4176; - const SBool s4178 = (SBool) (s265 & 1); - const SBool s4179 = false != s4178; - const SWord8 s4180 = s4179 ? s4175 : s4176; - const SWord8 s4181 = s198 ? s4177 : s4180; - const SBool s4182 = (SBool) (s281 & 1); - const SBool s4183 = false != s4182; - const SBool s4184 = (SBool) (s274 & 1); - const SBool s4185 = false != s4184; - const SWord8 s4186 = s4185 ? s4171 : s4172; - const SWord8 s4187 = (s4186 >> 1) | (s4186 << 7); - const SWord8 s4188 = 128 | s4187; - const SWord8 s4189 = 127 & s4187; - const SWord8 s4190 = s4183 ? s4188 : s4189; - const SBool s4191 = (SBool) (s286 & 1); - const SBool s4192 = false != s4191; - const SWord8 s4193 = s4192 ? s4188 : s4189; - const SWord8 s4194 = s198 ? s4190 : s4193; - const SWord8 s4195 = s74 ? s4181 : s4194; - const SWord8 s4196 = s55 ? s4162 : s4195; - const SWord8 s4197 = s36 ? s4126 : s4196; - const SBool s4198 = (SBool) (s341 & 1); - const SBool s4199 = false != s4198; - const SBool s4200 = (SBool) (s337 & 1); - const SBool s4201 = false != s4200; - const SBool s4202 = (SBool) (s333 & 1); - const SBool s4203 = false != s4202; - const SWord8 s4204 = (s320 >> 1) | (s320 << 7); - const SWord8 s4205 = 128 | s4204; - const SWord8 s4206 = 127 & s4204; - const SWord8 s4207 = s4203 ? s4205 : s4206; - const SWord8 s4208 = (s4207 >> 1) | (s4207 << 7); - const SWord8 s4209 = 128 | s4208; - const SWord8 s4210 = 127 & s4208; - const SWord8 s4211 = s4201 ? s4209 : s4210; - const SWord8 s4212 = (s4211 >> 1) | (s4211 << 7); - const SWord8 s4213 = 128 | s4212; - const SWord8 s4214 = 127 & s4212; - const SWord8 s4215 = s4199 ? s4213 : s4214; - const SBool s4216 = (SBool) (s346 & 1); - const SBool s4217 = false != s4216; - const SWord8 s4218 = s4217 ? s4213 : s4214; - const SWord8 s4219 = s329 ? s4215 : s4218; - const SBool s4220 = (SBool) (s362 & 1); - const SBool s4221 = false != s4220; - const SBool s4222 = (SBool) (s355 & 1); - const SBool s4223 = false != s4222; - const SWord8 s4224 = s4223 ? s4209 : s4210; - const SWord8 s4225 = (s4224 >> 1) | (s4224 << 7); - const SWord8 s4226 = 128 | s4225; - const SWord8 s4227 = 127 & s4225; - const SWord8 s4228 = s4221 ? s4226 : s4227; - const SBool s4229 = (SBool) (s367 & 1); - const SBool s4230 = false != s4229; - const SWord8 s4231 = s4230 ? s4226 : s4227; - const SWord8 s4232 = s329 ? s4228 : s4231; - const SWord8 s4233 = s307 ? s4219 : s4232; - const SBool s4234 = (SBool) (s388 & 1); - const SBool s4235 = false != s4234; - const SBool s4236 = (SBool) (s384 & 1); - const SBool s4237 = false != s4236; - const SBool s4238 = (SBool) (s377 & 1); - const SBool s4239 = false != s4238; - const SWord8 s4240 = s4239 ? s4205 : s4206; - const SWord8 s4241 = (s4240 >> 1) | (s4240 << 7); - const SWord8 s4242 = 128 | s4241; - const SWord8 s4243 = 127 & s4241; - const SWord8 s4244 = s4237 ? s4242 : s4243; - const SWord8 s4245 = (s4244 >> 1) | (s4244 << 7); - const SWord8 s4246 = 128 | s4245; - const SWord8 s4247 = 127 & s4245; - const SWord8 s4248 = s4235 ? s4246 : s4247; - const SBool s4249 = (SBool) (s393 & 1); - const SBool s4250 = false != s4249; - const SWord8 s4251 = s4250 ? s4246 : s4247; - const SWord8 s4252 = s329 ? s4248 : s4251; - const SBool s4253 = (SBool) (s409 & 1); - const SBool s4254 = false != s4253; - const SBool s4255 = (SBool) (s402 & 1); - const SBool s4256 = false != s4255; - const SWord8 s4257 = s4256 ? s4242 : s4243; - const SWord8 s4258 = (s4257 >> 1) | (s4257 << 7); - const SWord8 s4259 = 128 | s4258; - const SWord8 s4260 = 127 & s4258; - const SWord8 s4261 = s4254 ? s4259 : s4260; - const SBool s4262 = (SBool) (s414 & 1); - const SBool s4263 = false != s4262; - const SWord8 s4264 = s4263 ? s4259 : s4260; - const SWord8 s4265 = s329 ? s4261 : s4264; - const SWord8 s4266 = s307 ? s4252 : s4265; - const SWord8 s4267 = s55 ? s4233 : s4266; - const SBool s4268 = (SBool) (s449 & 1); - const SBool s4269 = false != s4268; - const SBool s4270 = (SBool) (s445 & 1); - const SBool s4271 = false != s4270; - const SBool s4272 = (SBool) (s441 & 1); - const SBool s4273 = false != s4272; - const SWord8 s4274 = (s428 >> 1) | (s428 << 7); - const SWord8 s4275 = 128 | s4274; - const SWord8 s4276 = 127 & s4274; - const SWord8 s4277 = s4273 ? s4275 : s4276; - const SWord8 s4278 = (s4277 >> 1) | (s4277 << 7); - const SWord8 s4279 = 128 | s4278; - const SWord8 s4280 = 127 & s4278; - const SWord8 s4281 = s4271 ? s4279 : s4280; - const SWord8 s4282 = (s4281 >> 1) | (s4281 << 7); - const SWord8 s4283 = 128 | s4282; - const SWord8 s4284 = 127 & s4282; - const SWord8 s4285 = s4269 ? s4283 : s4284; - const SBool s4286 = (SBool) (s454 & 1); - const SBool s4287 = false != s4286; - const SWord8 s4288 = s4287 ? s4283 : s4284; - const SWord8 s4289 = s434 ? s4285 : s4288; - const SBool s4290 = (SBool) (s470 & 1); - const SBool s4291 = false != s4290; - const SBool s4292 = (SBool) (s463 & 1); - const SBool s4293 = false != s4292; - const SWord8 s4294 = s4293 ? s4279 : s4280; - const SWord8 s4295 = (s4294 >> 1) | (s4294 << 7); - const SWord8 s4296 = 128 | s4295; - const SWord8 s4297 = 127 & s4295; - const SWord8 s4298 = s4291 ? s4296 : s4297; - const SBool s4299 = (SBool) (s475 & 1); - const SBool s4300 = false != s4299; - const SWord8 s4301 = s4300 ? s4296 : s4297; - const SWord8 s4302 = s434 ? s4298 : s4301; - const SWord8 s4303 = s307 ? s4289 : s4302; - const SBool s4304 = (SBool) (s496 & 1); - const SBool s4305 = false != s4304; - const SBool s4306 = (SBool) (s492 & 1); - const SBool s4307 = false != s4306; - const SBool s4308 = (SBool) (s485 & 1); - const SBool s4309 = false != s4308; - const SWord8 s4310 = s4309 ? s4275 : s4276; - const SWord8 s4311 = (s4310 >> 1) | (s4310 << 7); - const SWord8 s4312 = 128 | s4311; - const SWord8 s4313 = 127 & s4311; - const SWord8 s4314 = s4307 ? s4312 : s4313; - const SWord8 s4315 = (s4314 >> 1) | (s4314 << 7); - const SWord8 s4316 = 128 | s4315; - const SWord8 s4317 = 127 & s4315; - const SWord8 s4318 = s4305 ? s4316 : s4317; - const SBool s4319 = (SBool) (s501 & 1); - const SBool s4320 = false != s4319; - const SWord8 s4321 = s4320 ? s4316 : s4317; - const SWord8 s4322 = s434 ? s4318 : s4321; - const SBool s4323 = (SBool) (s517 & 1); - const SBool s4324 = false != s4323; - const SBool s4325 = (SBool) (s510 & 1); - const SBool s4326 = false != s4325; - const SWord8 s4327 = s4326 ? s4312 : s4313; - const SWord8 s4328 = (s4327 >> 1) | (s4327 << 7); - const SWord8 s4329 = 128 | s4328; - const SWord8 s4330 = 127 & s4328; - const SWord8 s4331 = s4324 ? s4329 : s4330; - const SBool s4332 = (SBool) (s522 & 1); - const SBool s4333 = false != s4332; - const SWord8 s4334 = s4333 ? s4329 : s4330; - const SWord8 s4335 = s434 ? s4331 : s4334; - const SWord8 s4336 = s307 ? s4322 : s4335; - const SWord8 s4337 = s55 ? s4303 : s4336; - const SWord8 s4338 = s36 ? s4267 : s4337; - const SWord8 s4339 = s21 ? s4197 : s4338; - const SBool s4340 = (SBool) (s597 & 1); - const SBool s4341 = false != s4340; - const SBool s4342 = (SBool) (s593 & 1); - const SBool s4343 = false != s4342; - const SBool s4344 = (SBool) (s589 & 1); - const SBool s4345 = false != s4344; - const SWord8 s4346 = (s576 >> 1) | (s576 << 7); - const SWord8 s4347 = 128 | s4346; - const SWord8 s4348 = 127 & s4346; - const SWord8 s4349 = s4345 ? s4347 : s4348; - const SWord8 s4350 = (s4349 >> 1) | (s4349 << 7); - const SWord8 s4351 = 128 | s4350; - const SWord8 s4352 = 127 & s4350; - const SWord8 s4353 = s4343 ? s4351 : s4352; - const SWord8 s4354 = (s4353 >> 1) | (s4353 << 7); - const SWord8 s4355 = 128 | s4354; - const SWord8 s4356 = 127 & s4354; - const SWord8 s4357 = s4341 ? s4355 : s4356; - const SBool s4358 = (SBool) (s602 & 1); - const SBool s4359 = false != s4358; - const SWord8 s4360 = s4359 ? s4355 : s4356; - const SWord8 s4361 = s585 ? s4357 : s4360; - const SBool s4362 = (SBool) (s618 & 1); - const SBool s4363 = false != s4362; - const SBool s4364 = (SBool) (s611 & 1); - const SBool s4365 = false != s4364; - const SWord8 s4366 = s4365 ? s4351 : s4352; - const SWord8 s4367 = (s4366 >> 1) | (s4366 << 7); - const SWord8 s4368 = 128 | s4367; - const SWord8 s4369 = 127 & s4367; - const SWord8 s4370 = s4363 ? s4368 : s4369; - const SBool s4371 = (SBool) (s623 & 1); - const SBool s4372 = false != s4371; - const SWord8 s4373 = s4372 ? s4368 : s4369; - const SWord8 s4374 = s585 ? s4370 : s4373; - const SWord8 s4375 = s566 ? s4361 : s4374; - const SBool s4376 = (SBool) (s644 & 1); - const SBool s4377 = false != s4376; - const SBool s4378 = (SBool) (s640 & 1); - const SBool s4379 = false != s4378; - const SBool s4380 = (SBool) (s633 & 1); - const SBool s4381 = false != s4380; - const SWord8 s4382 = s4381 ? s4347 : s4348; - const SWord8 s4383 = (s4382 >> 1) | (s4382 << 7); - const SWord8 s4384 = 128 | s4383; - const SWord8 s4385 = 127 & s4383; - const SWord8 s4386 = s4379 ? s4384 : s4385; - const SWord8 s4387 = (s4386 >> 1) | (s4386 << 7); - const SWord8 s4388 = 128 | s4387; - const SWord8 s4389 = 127 & s4387; - const SWord8 s4390 = s4377 ? s4388 : s4389; - const SBool s4391 = (SBool) (s649 & 1); - const SBool s4392 = false != s4391; - const SWord8 s4393 = s4392 ? s4388 : s4389; - const SWord8 s4394 = s585 ? s4390 : s4393; - const SBool s4395 = (SBool) (s665 & 1); - const SBool s4396 = false != s4395; - const SBool s4397 = (SBool) (s658 & 1); - const SBool s4398 = false != s4397; - const SWord8 s4399 = s4398 ? s4384 : s4385; - const SWord8 s4400 = (s4399 >> 1) | (s4399 << 7); - const SWord8 s4401 = 128 | s4400; - const SWord8 s4402 = 127 & s4400; - const SWord8 s4403 = s4396 ? s4401 : s4402; - const SBool s4404 = (SBool) (s670 & 1); - const SBool s4405 = false != s4404; - const SWord8 s4406 = s4405 ? s4401 : s4402; - const SWord8 s4407 = s585 ? s4403 : s4406; - const SWord8 s4408 = s566 ? s4394 : s4407; - const SWord8 s4409 = s544 ? s4375 : s4408; - const SBool s4410 = (SBool) (s705 & 1); - const SBool s4411 = false != s4410; - const SBool s4412 = (SBool) (s701 & 1); - const SBool s4413 = false != s4412; - const SBool s4414 = (SBool) (s697 & 1); - const SBool s4415 = false != s4414; - const SWord8 s4416 = (s684 >> 1) | (s684 << 7); - const SWord8 s4417 = 128 | s4416; - const SWord8 s4418 = 127 & s4416; - const SWord8 s4419 = s4415 ? s4417 : s4418; - const SWord8 s4420 = (s4419 >> 1) | (s4419 << 7); - const SWord8 s4421 = 128 | s4420; - const SWord8 s4422 = 127 & s4420; - const SWord8 s4423 = s4413 ? s4421 : s4422; - const SWord8 s4424 = (s4423 >> 1) | (s4423 << 7); - const SWord8 s4425 = 128 | s4424; - const SWord8 s4426 = 127 & s4424; - const SWord8 s4427 = s4411 ? s4425 : s4426; - const SBool s4428 = (SBool) (s710 & 1); - const SBool s4429 = false != s4428; - const SWord8 s4430 = s4429 ? s4425 : s4426; - const SWord8 s4431 = s690 ? s4427 : s4430; - const SBool s4432 = (SBool) (s726 & 1); - const SBool s4433 = false != s4432; - const SBool s4434 = (SBool) (s719 & 1); - const SBool s4435 = false != s4434; - const SWord8 s4436 = s4435 ? s4421 : s4422; - const SWord8 s4437 = (s4436 >> 1) | (s4436 << 7); - const SWord8 s4438 = 128 | s4437; - const SWord8 s4439 = 127 & s4437; - const SWord8 s4440 = s4433 ? s4438 : s4439; - const SBool s4441 = (SBool) (s731 & 1); - const SBool s4442 = false != s4441; - const SWord8 s4443 = s4442 ? s4438 : s4439; - const SWord8 s4444 = s690 ? s4440 : s4443; - const SWord8 s4445 = s566 ? s4431 : s4444; - const SBool s4446 = (SBool) (s752 & 1); - const SBool s4447 = false != s4446; - const SBool s4448 = (SBool) (s748 & 1); - const SBool s4449 = false != s4448; - const SBool s4450 = (SBool) (s741 & 1); - const SBool s4451 = false != s4450; - const SWord8 s4452 = s4451 ? s4417 : s4418; - const SWord8 s4453 = (s4452 >> 1) | (s4452 << 7); - const SWord8 s4454 = 128 | s4453; - const SWord8 s4455 = 127 & s4453; - const SWord8 s4456 = s4449 ? s4454 : s4455; - const SWord8 s4457 = (s4456 >> 1) | (s4456 << 7); - const SWord8 s4458 = 128 | s4457; - const SWord8 s4459 = 127 & s4457; - const SWord8 s4460 = s4447 ? s4458 : s4459; - const SBool s4461 = (SBool) (s757 & 1); - const SBool s4462 = false != s4461; - const SWord8 s4463 = s4462 ? s4458 : s4459; - const SWord8 s4464 = s690 ? s4460 : s4463; - const SBool s4465 = (SBool) (s773 & 1); - const SBool s4466 = false != s4465; - const SBool s4467 = (SBool) (s766 & 1); - const SBool s4468 = false != s4467; - const SWord8 s4469 = s4468 ? s4454 : s4455; - const SWord8 s4470 = (s4469 >> 1) | (s4469 << 7); - const SWord8 s4471 = 128 | s4470; - const SWord8 s4472 = 127 & s4470; - const SWord8 s4473 = s4466 ? s4471 : s4472; - const SBool s4474 = (SBool) (s778 & 1); - const SBool s4475 = false != s4474; - const SWord8 s4476 = s4475 ? s4471 : s4472; - const SWord8 s4477 = s690 ? s4473 : s4476; - const SWord8 s4478 = s566 ? s4464 : s4477; - const SWord8 s4479 = s544 ? s4445 : s4478; - const SWord8 s4480 = s36 ? s4409 : s4479; - const SBool s4481 = (SBool) (s833 & 1); - const SBool s4482 = false != s4481; - const SBool s4483 = (SBool) (s829 & 1); - const SBool s4484 = false != s4483; - const SBool s4485 = (SBool) (s825 & 1); - const SBool s4486 = false != s4485; - const SWord8 s4487 = (s812 >> 1) | (s812 << 7); - const SWord8 s4488 = 128 | s4487; - const SWord8 s4489 = 127 & s4487; - const SWord8 s4490 = s4486 ? s4488 : s4489; - const SWord8 s4491 = (s4490 >> 1) | (s4490 << 7); - const SWord8 s4492 = 128 | s4491; - const SWord8 s4493 = 127 & s4491; - const SWord8 s4494 = s4484 ? s4492 : s4493; - const SWord8 s4495 = (s4494 >> 1) | (s4494 << 7); - const SWord8 s4496 = 128 | s4495; - const SWord8 s4497 = 127 & s4495; - const SWord8 s4498 = s4482 ? s4496 : s4497; - const SBool s4499 = (SBool) (s838 & 1); - const SBool s4500 = false != s4499; - const SWord8 s4501 = s4500 ? s4496 : s4497; - const SWord8 s4502 = s821 ? s4498 : s4501; - const SBool s4503 = (SBool) (s854 & 1); - const SBool s4504 = false != s4503; - const SBool s4505 = (SBool) (s847 & 1); - const SBool s4506 = false != s4505; - const SWord8 s4507 = s4506 ? s4492 : s4493; - const SWord8 s4508 = (s4507 >> 1) | (s4507 << 7); - const SWord8 s4509 = 128 | s4508; - const SWord8 s4510 = 127 & s4508; - const SWord8 s4511 = s4504 ? s4509 : s4510; - const SBool s4512 = (SBool) (s859 & 1); - const SBool s4513 = false != s4512; - const SWord8 s4514 = s4513 ? s4509 : s4510; - const SWord8 s4515 = s821 ? s4511 : s4514; - const SWord8 s4516 = s799 ? s4502 : s4515; - const SBool s4517 = (SBool) (s880 & 1); - const SBool s4518 = false != s4517; - const SBool s4519 = (SBool) (s876 & 1); - const SBool s4520 = false != s4519; - const SBool s4521 = (SBool) (s869 & 1); - const SBool s4522 = false != s4521; - const SWord8 s4523 = s4522 ? s4488 : s4489; - const SWord8 s4524 = (s4523 >> 1) | (s4523 << 7); - const SWord8 s4525 = 128 | s4524; - const SWord8 s4526 = 127 & s4524; - const SWord8 s4527 = s4520 ? s4525 : s4526; - const SWord8 s4528 = (s4527 >> 1) | (s4527 << 7); - const SWord8 s4529 = 128 | s4528; - const SWord8 s4530 = 127 & s4528; - const SWord8 s4531 = s4518 ? s4529 : s4530; - const SBool s4532 = (SBool) (s885 & 1); - const SBool s4533 = false != s4532; - const SWord8 s4534 = s4533 ? s4529 : s4530; - const SWord8 s4535 = s821 ? s4531 : s4534; - const SBool s4536 = (SBool) (s901 & 1); - const SBool s4537 = false != s4536; - const SBool s4538 = (SBool) (s894 & 1); - const SBool s4539 = false != s4538; - const SWord8 s4540 = s4539 ? s4525 : s4526; - const SWord8 s4541 = (s4540 >> 1) | (s4540 << 7); - const SWord8 s4542 = 128 | s4541; - const SWord8 s4543 = 127 & s4541; - const SWord8 s4544 = s4537 ? s4542 : s4543; - const SBool s4545 = (SBool) (s906 & 1); - const SBool s4546 = false != s4545; - const SWord8 s4547 = s4546 ? s4542 : s4543; - const SWord8 s4548 = s821 ? s4544 : s4547; - const SWord8 s4549 = s799 ? s4535 : s4548; - const SWord8 s4550 = s544 ? s4516 : s4549; - const SBool s4551 = (SBool) (s941 & 1); - const SBool s4552 = false != s4551; - const SBool s4553 = (SBool) (s937 & 1); - const SBool s4554 = false != s4553; - const SBool s4555 = (SBool) (s933 & 1); - const SBool s4556 = false != s4555; - const SWord8 s4557 = (s920 >> 1) | (s920 << 7); - const SWord8 s4558 = 128 | s4557; - const SWord8 s4559 = 127 & s4557; - const SWord8 s4560 = s4556 ? s4558 : s4559; - const SWord8 s4561 = (s4560 >> 1) | (s4560 << 7); - const SWord8 s4562 = 128 | s4561; - const SWord8 s4563 = 127 & s4561; - const SWord8 s4564 = s4554 ? s4562 : s4563; - const SWord8 s4565 = (s4564 >> 1) | (s4564 << 7); - const SWord8 s4566 = 128 | s4565; - const SWord8 s4567 = 127 & s4565; - const SWord8 s4568 = s4552 ? s4566 : s4567; - const SBool s4569 = (SBool) (s946 & 1); - const SBool s4570 = false != s4569; - const SWord8 s4571 = s4570 ? s4566 : s4567; - const SWord8 s4572 = s926 ? s4568 : s4571; - const SBool s4573 = (SBool) (s962 & 1); - const SBool s4574 = false != s4573; - const SBool s4575 = (SBool) (s955 & 1); - const SBool s4576 = false != s4575; - const SWord8 s4577 = s4576 ? s4562 : s4563; - const SWord8 s4578 = (s4577 >> 1) | (s4577 << 7); - const SWord8 s4579 = 128 | s4578; - const SWord8 s4580 = 127 & s4578; - const SWord8 s4581 = s4574 ? s4579 : s4580; - const SBool s4582 = (SBool) (s967 & 1); - const SBool s4583 = false != s4582; - const SWord8 s4584 = s4583 ? s4579 : s4580; - const SWord8 s4585 = s926 ? s4581 : s4584; - const SWord8 s4586 = s799 ? s4572 : s4585; - const SBool s4587 = (SBool) (s988 & 1); - const SBool s4588 = false != s4587; - const SBool s4589 = (SBool) (s984 & 1); - const SBool s4590 = false != s4589; - const SBool s4591 = (SBool) (s977 & 1); - const SBool s4592 = false != s4591; - const SWord8 s4593 = s4592 ? s4558 : s4559; - const SWord8 s4594 = (s4593 >> 1) | (s4593 << 7); - const SWord8 s4595 = 128 | s4594; - const SWord8 s4596 = 127 & s4594; - const SWord8 s4597 = s4590 ? s4595 : s4596; - const SWord8 s4598 = (s4597 >> 1) | (s4597 << 7); - const SWord8 s4599 = 128 | s4598; - const SWord8 s4600 = 127 & s4598; - const SWord8 s4601 = s4588 ? s4599 : s4600; - const SBool s4602 = (SBool) (s993 & 1); - const SBool s4603 = false != s4602; - const SWord8 s4604 = s4603 ? s4599 : s4600; - const SWord8 s4605 = s926 ? s4601 : s4604; - const SBool s4606 = (SBool) (s1009 & 1); - const SBool s4607 = false != s4606; - const SBool s4608 = (SBool) (s1002 & 1); - const SBool s4609 = false != s4608; - const SWord8 s4610 = s4609 ? s4595 : s4596; - const SWord8 s4611 = (s4610 >> 1) | (s4610 << 7); - const SWord8 s4612 = 128 | s4611; - const SWord8 s4613 = 127 & s4611; - const SWord8 s4614 = s4607 ? s4612 : s4613; - const SBool s4615 = (SBool) (s1014 & 1); - const SBool s4616 = false != s4615; - const SWord8 s4617 = s4616 ? s4612 : s4613; - const SWord8 s4618 = s926 ? s4614 : s4617; - const SWord8 s4619 = s799 ? s4605 : s4618; - const SWord8 s4620 = s544 ? s4586 : s4619; - const SWord8 s4621 = s36 ? s4550 : s4620; - const SWord8 s4622 = s21 ? s4480 : s4621; - const SWord8 s4623 = s16 ? s4339 : s4622; - const SBool s4624 = (SBool) (s1109 & 1); - const SBool s4625 = false != s4624; - const SBool s4626 = (SBool) (s1105 & 1); - const SBool s4627 = false != s4626; - const SBool s4628 = (SBool) (s1101 & 1); - const SBool s4629 = false != s4628; - const SWord8 s4630 = (s1088 >> 1) | (s1088 << 7); - const SWord8 s4631 = 128 | s4630; - const SWord8 s4632 = 127 & s4630; - const SWord8 s4633 = s4629 ? s4631 : s4632; - const SWord8 s4634 = (s4633 >> 1) | (s4633 << 7); - const SWord8 s4635 = 128 | s4634; - const SWord8 s4636 = 127 & s4634; - const SWord8 s4637 = s4627 ? s4635 : s4636; - const SWord8 s4638 = (s4637 >> 1) | (s4637 << 7); - const SWord8 s4639 = 128 | s4638; - const SWord8 s4640 = 127 & s4638; - const SWord8 s4641 = s4625 ? s4639 : s4640; - const SBool s4642 = (SBool) (s1114 & 1); - const SBool s4643 = false != s4642; - const SWord8 s4644 = s4643 ? s4639 : s4640; - const SWord8 s4645 = s1097 ? s4641 : s4644; - const SBool s4646 = (SBool) (s1130 & 1); - const SBool s4647 = false != s4646; - const SBool s4648 = (SBool) (s1123 & 1); - const SBool s4649 = false != s4648; - const SWord8 s4650 = s4649 ? s4635 : s4636; - const SWord8 s4651 = (s4650 >> 1) | (s4650 << 7); - const SWord8 s4652 = 128 | s4651; - const SWord8 s4653 = 127 & s4651; - const SWord8 s4654 = s4647 ? s4652 : s4653; - const SBool s4655 = (SBool) (s1135 & 1); - const SBool s4656 = false != s4655; - const SWord8 s4657 = s4656 ? s4652 : s4653; - const SWord8 s4658 = s1097 ? s4654 : s4657; - const SWord8 s4659 = s1078 ? s4645 : s4658; - const SBool s4660 = (SBool) (s1156 & 1); - const SBool s4661 = false != s4660; - const SBool s4662 = (SBool) (s1152 & 1); - const SBool s4663 = false != s4662; - const SBool s4664 = (SBool) (s1145 & 1); - const SBool s4665 = false != s4664; - const SWord8 s4666 = s4665 ? s4631 : s4632; - const SWord8 s4667 = (s4666 >> 1) | (s4666 << 7); - const SWord8 s4668 = 128 | s4667; - const SWord8 s4669 = 127 & s4667; - const SWord8 s4670 = s4663 ? s4668 : s4669; - const SWord8 s4671 = (s4670 >> 1) | (s4670 << 7); - const SWord8 s4672 = 128 | s4671; - const SWord8 s4673 = 127 & s4671; - const SWord8 s4674 = s4661 ? s4672 : s4673; - const SBool s4675 = (SBool) (s1161 & 1); - const SBool s4676 = false != s4675; - const SWord8 s4677 = s4676 ? s4672 : s4673; - const SWord8 s4678 = s1097 ? s4674 : s4677; - const SBool s4679 = (SBool) (s1177 & 1); - const SBool s4680 = false != s4679; - const SBool s4681 = (SBool) (s1170 & 1); - const SBool s4682 = false != s4681; - const SWord8 s4683 = s4682 ? s4668 : s4669; - const SWord8 s4684 = (s4683 >> 1) | (s4683 << 7); - const SWord8 s4685 = 128 | s4684; - const SWord8 s4686 = 127 & s4684; - const SWord8 s4687 = s4680 ? s4685 : s4686; - const SBool s4688 = (SBool) (s1182 & 1); - const SBool s4689 = false != s4688; - const SWord8 s4690 = s4689 ? s4685 : s4686; - const SWord8 s4691 = s1097 ? s4687 : s4690; - const SWord8 s4692 = s1078 ? s4678 : s4691; - const SWord8 s4693 = s1059 ? s4659 : s4692; - const SBool s4694 = (SBool) (s1217 & 1); - const SBool s4695 = false != s4694; - const SBool s4696 = (SBool) (s1213 & 1); - const SBool s4697 = false != s4696; - const SBool s4698 = (SBool) (s1209 & 1); - const SBool s4699 = false != s4698; - const SWord8 s4700 = (s1196 >> 1) | (s1196 << 7); - const SWord8 s4701 = 128 | s4700; - const SWord8 s4702 = 127 & s4700; - const SWord8 s4703 = s4699 ? s4701 : s4702; - const SWord8 s4704 = (s4703 >> 1) | (s4703 << 7); - const SWord8 s4705 = 128 | s4704; - const SWord8 s4706 = 127 & s4704; - const SWord8 s4707 = s4697 ? s4705 : s4706; - const SWord8 s4708 = (s4707 >> 1) | (s4707 << 7); - const SWord8 s4709 = 128 | s4708; - const SWord8 s4710 = 127 & s4708; - const SWord8 s4711 = s4695 ? s4709 : s4710; - const SBool s4712 = (SBool) (s1222 & 1); - const SBool s4713 = false != s4712; - const SWord8 s4714 = s4713 ? s4709 : s4710; - const SWord8 s4715 = s1202 ? s4711 : s4714; - const SBool s4716 = (SBool) (s1238 & 1); - const SBool s4717 = false != s4716; - const SBool s4718 = (SBool) (s1231 & 1); - const SBool s4719 = false != s4718; - const SWord8 s4720 = s4719 ? s4705 : s4706; - const SWord8 s4721 = (s4720 >> 1) | (s4720 << 7); - const SWord8 s4722 = 128 | s4721; - const SWord8 s4723 = 127 & s4721; - const SWord8 s4724 = s4717 ? s4722 : s4723; - const SBool s4725 = (SBool) (s1243 & 1); - const SBool s4726 = false != s4725; - const SWord8 s4727 = s4726 ? s4722 : s4723; - const SWord8 s4728 = s1202 ? s4724 : s4727; - const SWord8 s4729 = s1078 ? s4715 : s4728; - const SBool s4730 = (SBool) (s1264 & 1); - const SBool s4731 = false != s4730; - const SBool s4732 = (SBool) (s1260 & 1); - const SBool s4733 = false != s4732; - const SBool s4734 = (SBool) (s1253 & 1); - const SBool s4735 = false != s4734; - const SWord8 s4736 = s4735 ? s4701 : s4702; - const SWord8 s4737 = (s4736 >> 1) | (s4736 << 7); - const SWord8 s4738 = 128 | s4737; - const SWord8 s4739 = 127 & s4737; - const SWord8 s4740 = s4733 ? s4738 : s4739; - const SWord8 s4741 = (s4740 >> 1) | (s4740 << 7); - const SWord8 s4742 = 128 | s4741; - const SWord8 s4743 = 127 & s4741; - const SWord8 s4744 = s4731 ? s4742 : s4743; - const SBool s4745 = (SBool) (s1269 & 1); - const SBool s4746 = false != s4745; - const SWord8 s4747 = s4746 ? s4742 : s4743; - const SWord8 s4748 = s1202 ? s4744 : s4747; - const SBool s4749 = (SBool) (s1285 & 1); - const SBool s4750 = false != s4749; - const SBool s4751 = (SBool) (s1278 & 1); - const SBool s4752 = false != s4751; - const SWord8 s4753 = s4752 ? s4738 : s4739; - const SWord8 s4754 = (s4753 >> 1) | (s4753 << 7); - const SWord8 s4755 = 128 | s4754; - const SWord8 s4756 = 127 & s4754; - const SWord8 s4757 = s4750 ? s4755 : s4756; - const SBool s4758 = (SBool) (s1290 & 1); - const SBool s4759 = false != s4758; - const SWord8 s4760 = s4759 ? s4755 : s4756; - const SWord8 s4761 = s1202 ? s4757 : s4760; - const SWord8 s4762 = s1078 ? s4748 : s4761; - const SWord8 s4763 = s1059 ? s4729 : s4762; - const SWord8 s4764 = s1037 ? s4693 : s4763; - const SBool s4765 = (SBool) (s1345 & 1); - const SBool s4766 = false != s4765; - const SBool s4767 = (SBool) (s1341 & 1); - const SBool s4768 = false != s4767; - const SBool s4769 = (SBool) (s1337 & 1); - const SBool s4770 = false != s4769; - const SWord8 s4771 = (s1324 >> 1) | (s1324 << 7); - const SWord8 s4772 = 128 | s4771; - const SWord8 s4773 = 127 & s4771; - const SWord8 s4774 = s4770 ? s4772 : s4773; - const SWord8 s4775 = (s4774 >> 1) | (s4774 << 7); - const SWord8 s4776 = 128 | s4775; - const SWord8 s4777 = 127 & s4775; - const SWord8 s4778 = s4768 ? s4776 : s4777; - const SWord8 s4779 = (s4778 >> 1) | (s4778 << 7); - const SWord8 s4780 = 128 | s4779; - const SWord8 s4781 = 127 & s4779; - const SWord8 s4782 = s4766 ? s4780 : s4781; - const SBool s4783 = (SBool) (s1350 & 1); - const SBool s4784 = false != s4783; - const SWord8 s4785 = s4784 ? s4780 : s4781; - const SWord8 s4786 = s1333 ? s4782 : s4785; - const SBool s4787 = (SBool) (s1366 & 1); - const SBool s4788 = false != s4787; - const SBool s4789 = (SBool) (s1359 & 1); - const SBool s4790 = false != s4789; - const SWord8 s4791 = s4790 ? s4776 : s4777; - const SWord8 s4792 = (s4791 >> 1) | (s4791 << 7); - const SWord8 s4793 = 128 | s4792; - const SWord8 s4794 = 127 & s4792; - const SWord8 s4795 = s4788 ? s4793 : s4794; - const SBool s4796 = (SBool) (s1371 & 1); - const SBool s4797 = false != s4796; - const SWord8 s4798 = s4797 ? s4793 : s4794; - const SWord8 s4799 = s1333 ? s4795 : s4798; - const SWord8 s4800 = s1311 ? s4786 : s4799; - const SBool s4801 = (SBool) (s1392 & 1); - const SBool s4802 = false != s4801; - const SBool s4803 = (SBool) (s1388 & 1); - const SBool s4804 = false != s4803; - const SBool s4805 = (SBool) (s1381 & 1); - const SBool s4806 = false != s4805; - const SWord8 s4807 = s4806 ? s4772 : s4773; - const SWord8 s4808 = (s4807 >> 1) | (s4807 << 7); - const SWord8 s4809 = 128 | s4808; - const SWord8 s4810 = 127 & s4808; - const SWord8 s4811 = s4804 ? s4809 : s4810; - const SWord8 s4812 = (s4811 >> 1) | (s4811 << 7); - const SWord8 s4813 = 128 | s4812; - const SWord8 s4814 = 127 & s4812; - const SWord8 s4815 = s4802 ? s4813 : s4814; - const SBool s4816 = (SBool) (s1397 & 1); - const SBool s4817 = false != s4816; - const SWord8 s4818 = s4817 ? s4813 : s4814; - const SWord8 s4819 = s1333 ? s4815 : s4818; - const SBool s4820 = (SBool) (s1413 & 1); - const SBool s4821 = false != s4820; - const SBool s4822 = (SBool) (s1406 & 1); - const SBool s4823 = false != s4822; - const SWord8 s4824 = s4823 ? s4809 : s4810; - const SWord8 s4825 = (s4824 >> 1) | (s4824 << 7); - const SWord8 s4826 = 128 | s4825; - const SWord8 s4827 = 127 & s4825; - const SWord8 s4828 = s4821 ? s4826 : s4827; - const SBool s4829 = (SBool) (s1418 & 1); - const SBool s4830 = false != s4829; - const SWord8 s4831 = s4830 ? s4826 : s4827; - const SWord8 s4832 = s1333 ? s4828 : s4831; - const SWord8 s4833 = s1311 ? s4819 : s4832; - const SWord8 s4834 = s1059 ? s4800 : s4833; - const SBool s4835 = (SBool) (s1453 & 1); - const SBool s4836 = false != s4835; - const SBool s4837 = (SBool) (s1449 & 1); - const SBool s4838 = false != s4837; - const SBool s4839 = (SBool) (s1445 & 1); - const SBool s4840 = false != s4839; - const SWord8 s4841 = (s1432 >> 1) | (s1432 << 7); - const SWord8 s4842 = 128 | s4841; - const SWord8 s4843 = 127 & s4841; - const SWord8 s4844 = s4840 ? s4842 : s4843; - const SWord8 s4845 = (s4844 >> 1) | (s4844 << 7); - const SWord8 s4846 = 128 | s4845; - const SWord8 s4847 = 127 & s4845; - const SWord8 s4848 = s4838 ? s4846 : s4847; - const SWord8 s4849 = (s4848 >> 1) | (s4848 << 7); - const SWord8 s4850 = 128 | s4849; - const SWord8 s4851 = 127 & s4849; - const SWord8 s4852 = s4836 ? s4850 : s4851; - const SBool s4853 = (SBool) (s1458 & 1); - const SBool s4854 = false != s4853; - const SWord8 s4855 = s4854 ? s4850 : s4851; - const SWord8 s4856 = s1438 ? s4852 : s4855; - const SBool s4857 = (SBool) (s1474 & 1); - const SBool s4858 = false != s4857; - const SBool s4859 = (SBool) (s1467 & 1); - const SBool s4860 = false != s4859; - const SWord8 s4861 = s4860 ? s4846 : s4847; - const SWord8 s4862 = (s4861 >> 1) | (s4861 << 7); - const SWord8 s4863 = 128 | s4862; - const SWord8 s4864 = 127 & s4862; - const SWord8 s4865 = s4858 ? s4863 : s4864; - const SBool s4866 = (SBool) (s1479 & 1); - const SBool s4867 = false != s4866; - const SWord8 s4868 = s4867 ? s4863 : s4864; - const SWord8 s4869 = s1438 ? s4865 : s4868; - const SWord8 s4870 = s1311 ? s4856 : s4869; - const SBool s4871 = (SBool) (s1500 & 1); - const SBool s4872 = false != s4871; - const SBool s4873 = (SBool) (s1496 & 1); - const SBool s4874 = false != s4873; - const SBool s4875 = (SBool) (s1489 & 1); - const SBool s4876 = false != s4875; - const SWord8 s4877 = s4876 ? s4842 : s4843; - const SWord8 s4878 = (s4877 >> 1) | (s4877 << 7); - const SWord8 s4879 = 128 | s4878; - const SWord8 s4880 = 127 & s4878; - const SWord8 s4881 = s4874 ? s4879 : s4880; - const SWord8 s4882 = (s4881 >> 1) | (s4881 << 7); - const SWord8 s4883 = 128 | s4882; - const SWord8 s4884 = 127 & s4882; - const SWord8 s4885 = s4872 ? s4883 : s4884; - const SBool s4886 = (SBool) (s1505 & 1); - const SBool s4887 = false != s4886; - const SWord8 s4888 = s4887 ? s4883 : s4884; - const SWord8 s4889 = s1438 ? s4885 : s4888; - const SBool s4890 = (SBool) (s1521 & 1); - const SBool s4891 = false != s4890; - const SBool s4892 = (SBool) (s1514 & 1); - const SBool s4893 = false != s4892; - const SWord8 s4894 = s4893 ? s4879 : s4880; - const SWord8 s4895 = (s4894 >> 1) | (s4894 << 7); - const SWord8 s4896 = 128 | s4895; - const SWord8 s4897 = 127 & s4895; - const SWord8 s4898 = s4891 ? s4896 : s4897; - const SBool s4899 = (SBool) (s1526 & 1); - const SBool s4900 = false != s4899; - const SWord8 s4901 = s4900 ? s4896 : s4897; - const SWord8 s4902 = s1438 ? s4898 : s4901; - const SWord8 s4903 = s1311 ? s4889 : s4902; - const SWord8 s4904 = s1059 ? s4870 : s4903; - const SWord8 s4905 = s1037 ? s4834 : s4904; - const SWord8 s4906 = s21 ? s4764 : s4905; - const SBool s4907 = (SBool) (s1601 & 1); - const SBool s4908 = false != s4907; - const SBool s4909 = (SBool) (s1597 & 1); - const SBool s4910 = false != s4909; - const SBool s4911 = (SBool) (s1593 & 1); - const SBool s4912 = false != s4911; - const SWord8 s4913 = (s1580 >> 1) | (s1580 << 7); - const SWord8 s4914 = 128 | s4913; - const SWord8 s4915 = 127 & s4913; - const SWord8 s4916 = s4912 ? s4914 : s4915; - const SWord8 s4917 = (s4916 >> 1) | (s4916 << 7); - const SWord8 s4918 = 128 | s4917; - const SWord8 s4919 = 127 & s4917; - const SWord8 s4920 = s4910 ? s4918 : s4919; - const SWord8 s4921 = (s4920 >> 1) | (s4920 << 7); - const SWord8 s4922 = 128 | s4921; - const SWord8 s4923 = 127 & s4921; - const SWord8 s4924 = s4908 ? s4922 : s4923; - const SBool s4925 = (SBool) (s1606 & 1); - const SBool s4926 = false != s4925; - const SWord8 s4927 = s4926 ? s4922 : s4923; - const SWord8 s4928 = s1589 ? s4924 : s4927; - const SBool s4929 = (SBool) (s1622 & 1); - const SBool s4930 = false != s4929; - const SBool s4931 = (SBool) (s1615 & 1); - const SBool s4932 = false != s4931; - const SWord8 s4933 = s4932 ? s4918 : s4919; - const SWord8 s4934 = (s4933 >> 1) | (s4933 << 7); - const SWord8 s4935 = 128 | s4934; - const SWord8 s4936 = 127 & s4934; - const SWord8 s4937 = s4930 ? s4935 : s4936; - const SBool s4938 = (SBool) (s1627 & 1); - const SBool s4939 = false != s4938; - const SWord8 s4940 = s4939 ? s4935 : s4936; - const SWord8 s4941 = s1589 ? s4937 : s4940; - const SWord8 s4942 = s1570 ? s4928 : s4941; - const SBool s4943 = (SBool) (s1648 & 1); - const SBool s4944 = false != s4943; - const SBool s4945 = (SBool) (s1644 & 1); - const SBool s4946 = false != s4945; - const SBool s4947 = (SBool) (s1637 & 1); - const SBool s4948 = false != s4947; - const SWord8 s4949 = s4948 ? s4914 : s4915; - const SWord8 s4950 = (s4949 >> 1) | (s4949 << 7); - const SWord8 s4951 = 128 | s4950; - const SWord8 s4952 = 127 & s4950; - const SWord8 s4953 = s4946 ? s4951 : s4952; - const SWord8 s4954 = (s4953 >> 1) | (s4953 << 7); - const SWord8 s4955 = 128 | s4954; - const SWord8 s4956 = 127 & s4954; - const SWord8 s4957 = s4944 ? s4955 : s4956; - const SBool s4958 = (SBool) (s1653 & 1); - const SBool s4959 = false != s4958; - const SWord8 s4960 = s4959 ? s4955 : s4956; - const SWord8 s4961 = s1589 ? s4957 : s4960; - const SBool s4962 = (SBool) (s1669 & 1); - const SBool s4963 = false != s4962; - const SBool s4964 = (SBool) (s1662 & 1); - const SBool s4965 = false != s4964; - const SWord8 s4966 = s4965 ? s4951 : s4952; - const SWord8 s4967 = (s4966 >> 1) | (s4966 << 7); - const SWord8 s4968 = 128 | s4967; - const SWord8 s4969 = 127 & s4967; - const SWord8 s4970 = s4963 ? s4968 : s4969; - const SBool s4971 = (SBool) (s1674 & 1); - const SBool s4972 = false != s4971; - const SWord8 s4973 = s4972 ? s4968 : s4969; - const SWord8 s4974 = s1589 ? s4970 : s4973; - const SWord8 s4975 = s1570 ? s4961 : s4974; - const SWord8 s4976 = s1548 ? s4942 : s4975; - const SBool s4977 = (SBool) (s1709 & 1); - const SBool s4978 = false != s4977; - const SBool s4979 = (SBool) (s1705 & 1); - const SBool s4980 = false != s4979; - const SBool s4981 = (SBool) (s1701 & 1); - const SBool s4982 = false != s4981; - const SWord8 s4983 = (s1688 >> 1) | (s1688 << 7); - const SWord8 s4984 = 128 | s4983; - const SWord8 s4985 = 127 & s4983; - const SWord8 s4986 = s4982 ? s4984 : s4985; - const SWord8 s4987 = (s4986 >> 1) | (s4986 << 7); - const SWord8 s4988 = 128 | s4987; - const SWord8 s4989 = 127 & s4987; - const SWord8 s4990 = s4980 ? s4988 : s4989; - const SWord8 s4991 = (s4990 >> 1) | (s4990 << 7); - const SWord8 s4992 = 128 | s4991; - const SWord8 s4993 = 127 & s4991; - const SWord8 s4994 = s4978 ? s4992 : s4993; - const SBool s4995 = (SBool) (s1714 & 1); - const SBool s4996 = false != s4995; - const SWord8 s4997 = s4996 ? s4992 : s4993; - const SWord8 s4998 = s1694 ? s4994 : s4997; - const SBool s4999 = (SBool) (s1730 & 1); - const SBool s5000 = false != s4999; - const SBool s5001 = (SBool) (s1723 & 1); - const SBool s5002 = false != s5001; - const SWord8 s5003 = s5002 ? s4988 : s4989; - const SWord8 s5004 = (s5003 >> 1) | (s5003 << 7); - const SWord8 s5005 = 128 | s5004; - const SWord8 s5006 = 127 & s5004; - const SWord8 s5007 = s5000 ? s5005 : s5006; - const SBool s5008 = (SBool) (s1735 & 1); - const SBool s5009 = false != s5008; - const SWord8 s5010 = s5009 ? s5005 : s5006; - const SWord8 s5011 = s1694 ? s5007 : s5010; - const SWord8 s5012 = s1570 ? s4998 : s5011; - const SBool s5013 = (SBool) (s1756 & 1); - const SBool s5014 = false != s5013; - const SBool s5015 = (SBool) (s1752 & 1); - const SBool s5016 = false != s5015; - const SBool s5017 = (SBool) (s1745 & 1); - const SBool s5018 = false != s5017; - const SWord8 s5019 = s5018 ? s4984 : s4985; - const SWord8 s5020 = (s5019 >> 1) | (s5019 << 7); - const SWord8 s5021 = 128 | s5020; - const SWord8 s5022 = 127 & s5020; - const SWord8 s5023 = s5016 ? s5021 : s5022; - const SWord8 s5024 = (s5023 >> 1) | (s5023 << 7); - const SWord8 s5025 = 128 | s5024; - const SWord8 s5026 = 127 & s5024; - const SWord8 s5027 = s5014 ? s5025 : s5026; - const SBool s5028 = (SBool) (s1761 & 1); - const SBool s5029 = false != s5028; - const SWord8 s5030 = s5029 ? s5025 : s5026; - const SWord8 s5031 = s1694 ? s5027 : s5030; - const SBool s5032 = (SBool) (s1777 & 1); - const SBool s5033 = false != s5032; - const SBool s5034 = (SBool) (s1770 & 1); - const SBool s5035 = false != s5034; - const SWord8 s5036 = s5035 ? s5021 : s5022; - const SWord8 s5037 = (s5036 >> 1) | (s5036 << 7); - const SWord8 s5038 = 128 | s5037; - const SWord8 s5039 = 127 & s5037; - const SWord8 s5040 = s5033 ? s5038 : s5039; - const SBool s5041 = (SBool) (s1782 & 1); - const SBool s5042 = false != s5041; - const SWord8 s5043 = s5042 ? s5038 : s5039; - const SWord8 s5044 = s1694 ? s5040 : s5043; - const SWord8 s5045 = s1570 ? s5031 : s5044; - const SWord8 s5046 = s1548 ? s5012 : s5045; - const SWord8 s5047 = s1037 ? s4976 : s5046; - const SBool s5048 = (SBool) (s1837 & 1); - const SBool s5049 = false != s5048; - const SBool s5050 = (SBool) (s1833 & 1); - const SBool s5051 = false != s5050; - const SBool s5052 = (SBool) (s1829 & 1); - const SBool s5053 = false != s5052; - const SWord8 s5054 = (s1816 >> 1) | (s1816 << 7); - const SWord8 s5055 = 128 | s5054; - const SWord8 s5056 = 127 & s5054; - const SWord8 s5057 = s5053 ? s5055 : s5056; - const SWord8 s5058 = (s5057 >> 1) | (s5057 << 7); - const SWord8 s5059 = 128 | s5058; - const SWord8 s5060 = 127 & s5058; - const SWord8 s5061 = s5051 ? s5059 : s5060; - const SWord8 s5062 = (s5061 >> 1) | (s5061 << 7); - const SWord8 s5063 = 128 | s5062; - const SWord8 s5064 = 127 & s5062; - const SWord8 s5065 = s5049 ? s5063 : s5064; - const SBool s5066 = (SBool) (s1842 & 1); - const SBool s5067 = false != s5066; - const SWord8 s5068 = s5067 ? s5063 : s5064; - const SWord8 s5069 = s1825 ? s5065 : s5068; - const SBool s5070 = (SBool) (s1858 & 1); - const SBool s5071 = false != s5070; - const SBool s5072 = (SBool) (s1851 & 1); - const SBool s5073 = false != s5072; - const SWord8 s5074 = s5073 ? s5059 : s5060; - const SWord8 s5075 = (s5074 >> 1) | (s5074 << 7); - const SWord8 s5076 = 128 | s5075; - const SWord8 s5077 = 127 & s5075; - const SWord8 s5078 = s5071 ? s5076 : s5077; - const SBool s5079 = (SBool) (s1863 & 1); - const SBool s5080 = false != s5079; - const SWord8 s5081 = s5080 ? s5076 : s5077; - const SWord8 s5082 = s1825 ? s5078 : s5081; - const SWord8 s5083 = s1803 ? s5069 : s5082; - const SBool s5084 = (SBool) (s1884 & 1); - const SBool s5085 = false != s5084; - const SBool s5086 = (SBool) (s1880 & 1); - const SBool s5087 = false != s5086; - const SBool s5088 = (SBool) (s1873 & 1); - const SBool s5089 = false != s5088; - const SWord8 s5090 = s5089 ? s5055 : s5056; - const SWord8 s5091 = (s5090 >> 1) | (s5090 << 7); - const SWord8 s5092 = 128 | s5091; - const SWord8 s5093 = 127 & s5091; - const SWord8 s5094 = s5087 ? s5092 : s5093; - const SWord8 s5095 = (s5094 >> 1) | (s5094 << 7); - const SWord8 s5096 = 128 | s5095; - const SWord8 s5097 = 127 & s5095; - const SWord8 s5098 = s5085 ? s5096 : s5097; - const SBool s5099 = (SBool) (s1889 & 1); - const SBool s5100 = false != s5099; - const SWord8 s5101 = s5100 ? s5096 : s5097; - const SWord8 s5102 = s1825 ? s5098 : s5101; - const SBool s5103 = (SBool) (s1905 & 1); - const SBool s5104 = false != s5103; - const SBool s5105 = (SBool) (s1898 & 1); - const SBool s5106 = false != s5105; - const SWord8 s5107 = s5106 ? s5092 : s5093; - const SWord8 s5108 = (s5107 >> 1) | (s5107 << 7); - const SWord8 s5109 = 128 | s5108; - const SWord8 s5110 = 127 & s5108; - const SWord8 s5111 = s5104 ? s5109 : s5110; - const SBool s5112 = (SBool) (s1910 & 1); - const SBool s5113 = false != s5112; - const SWord8 s5114 = s5113 ? s5109 : s5110; - const SWord8 s5115 = s1825 ? s5111 : s5114; - const SWord8 s5116 = s1803 ? s5102 : s5115; - const SWord8 s5117 = s1548 ? s5083 : s5116; - const SBool s5118 = (SBool) (s1945 & 1); - const SBool s5119 = false != s5118; - const SBool s5120 = (SBool) (s1941 & 1); - const SBool s5121 = false != s5120; - const SBool s5122 = (SBool) (s1937 & 1); - const SBool s5123 = false != s5122; - const SWord8 s5124 = (s1924 >> 1) | (s1924 << 7); - const SWord8 s5125 = 128 | s5124; - const SWord8 s5126 = 127 & s5124; - const SWord8 s5127 = s5123 ? s5125 : s5126; - const SWord8 s5128 = (s5127 >> 1) | (s5127 << 7); - const SWord8 s5129 = 128 | s5128; - const SWord8 s5130 = 127 & s5128; - const SWord8 s5131 = s5121 ? s5129 : s5130; - const SWord8 s5132 = (s5131 >> 1) | (s5131 << 7); - const SWord8 s5133 = 128 | s5132; - const SWord8 s5134 = 127 & s5132; - const SWord8 s5135 = s5119 ? s5133 : s5134; - const SBool s5136 = (SBool) (s1950 & 1); - const SBool s5137 = false != s5136; - const SWord8 s5138 = s5137 ? s5133 : s5134; - const SWord8 s5139 = s1930 ? s5135 : s5138; - const SBool s5140 = (SBool) (s1966 & 1); - const SBool s5141 = false != s5140; - const SBool s5142 = (SBool) (s1959 & 1); - const SBool s5143 = false != s5142; - const SWord8 s5144 = s5143 ? s5129 : s5130; - const SWord8 s5145 = (s5144 >> 1) | (s5144 << 7); - const SWord8 s5146 = 128 | s5145; - const SWord8 s5147 = 127 & s5145; - const SWord8 s5148 = s5141 ? s5146 : s5147; - const SBool s5149 = (SBool) (s1971 & 1); - const SBool s5150 = false != s5149; - const SWord8 s5151 = s5150 ? s5146 : s5147; - const SWord8 s5152 = s1930 ? s5148 : s5151; - const SWord8 s5153 = s1803 ? s5139 : s5152; - const SBool s5154 = (SBool) (s1992 & 1); - const SBool s5155 = false != s5154; - const SBool s5156 = (SBool) (s1988 & 1); - const SBool s5157 = false != s5156; - const SBool s5158 = (SBool) (s1981 & 1); - const SBool s5159 = false != s5158; - const SWord8 s5160 = s5159 ? s5125 : s5126; - const SWord8 s5161 = (s5160 >> 1) | (s5160 << 7); - const SWord8 s5162 = 128 | s5161; - const SWord8 s5163 = 127 & s5161; - const SWord8 s5164 = s5157 ? s5162 : s5163; - const SWord8 s5165 = (s5164 >> 1) | (s5164 << 7); - const SWord8 s5166 = 128 | s5165; - const SWord8 s5167 = 127 & s5165; - const SWord8 s5168 = s5155 ? s5166 : s5167; - const SBool s5169 = (SBool) (s1997 & 1); - const SBool s5170 = false != s5169; - const SWord8 s5171 = s5170 ? s5166 : s5167; - const SWord8 s5172 = s1930 ? s5168 : s5171; - const SBool s5173 = (SBool) (s2013 & 1); - const SBool s5174 = false != s5173; - const SBool s5175 = (SBool) (s2006 & 1); - const SBool s5176 = false != s5175; - const SWord8 s5177 = s5176 ? s5162 : s5163; - const SWord8 s5178 = (s5177 >> 1) | (s5177 << 7); - const SWord8 s5179 = 128 | s5178; - const SWord8 s5180 = 127 & s5178; - const SWord8 s5181 = s5174 ? s5179 : s5180; - const SBool s5182 = (SBool) (s2018 & 1); - const SBool s5183 = false != s5182; - const SWord8 s5184 = s5183 ? s5179 : s5180; - const SWord8 s5185 = s1930 ? s5181 : s5184; - const SWord8 s5186 = s1803 ? s5172 : s5185; - const SWord8 s5187 = s1548 ? s5153 : s5186; - const SWord8 s5188 = s1037 ? s5117 : s5187; - const SWord8 s5189 = s21 ? s5047 : s5188; - const SWord8 s5190 = s16 ? s4906 : s5189; - const SWord8 s5191 = s11 ? s4623 : s5190; - const SBool s5192 = (SBool) (s2128 & 1); - const SBool s5193 = false != s5192; - const SBool s5194 = (SBool) (s2124 & 1); - const SBool s5195 = false != s5194; - const SBool s5196 = (SBool) (s2120 & 1); - const SBool s5197 = false != s5196; - const SWord8 s5198 = (s2107 >> 1) | (s2107 << 7); - const SWord8 s5199 = 128 | s5198; - const SWord8 s5200 = 127 & s5198; - const SWord8 s5201 = s5197 ? s5199 : s5200; - const SWord8 s5202 = (s5201 >> 1) | (s5201 << 7); - const SWord8 s5203 = 128 | s5202; - const SWord8 s5204 = 127 & s5202; - const SWord8 s5205 = s5195 ? s5203 : s5204; - const SWord8 s5206 = (s5205 >> 1) | (s5205 << 7); - const SWord8 s5207 = 128 | s5206; - const SWord8 s5208 = 127 & s5206; - const SWord8 s5209 = s5193 ? s5207 : s5208; - const SBool s5210 = (SBool) (s2133 & 1); - const SBool s5211 = false != s5210; - const SWord8 s5212 = s5211 ? s5207 : s5208; - const SWord8 s5213 = s2116 ? s5209 : s5212; - const SBool s5214 = (SBool) (s2149 & 1); - const SBool s5215 = false != s5214; - const SBool s5216 = (SBool) (s2142 & 1); - const SBool s5217 = false != s5216; - const SWord8 s5218 = s5217 ? s5203 : s5204; - const SWord8 s5219 = (s5218 >> 1) | (s5218 << 7); - const SWord8 s5220 = 128 | s5219; - const SWord8 s5221 = 127 & s5219; - const SWord8 s5222 = s5215 ? s5220 : s5221; - const SBool s5223 = (SBool) (s2154 & 1); - const SBool s5224 = false != s5223; - const SWord8 s5225 = s5224 ? s5220 : s5221; - const SWord8 s5226 = s2116 ? s5222 : s5225; - const SWord8 s5227 = s2097 ? s5213 : s5226; - const SBool s5228 = (SBool) (s2175 & 1); - const SBool s5229 = false != s5228; - const SBool s5230 = (SBool) (s2171 & 1); - const SBool s5231 = false != s5230; - const SBool s5232 = (SBool) (s2164 & 1); - const SBool s5233 = false != s5232; - const SWord8 s5234 = s5233 ? s5199 : s5200; - const SWord8 s5235 = (s5234 >> 1) | (s5234 << 7); - const SWord8 s5236 = 128 | s5235; - const SWord8 s5237 = 127 & s5235; - const SWord8 s5238 = s5231 ? s5236 : s5237; - const SWord8 s5239 = (s5238 >> 1) | (s5238 << 7); - const SWord8 s5240 = 128 | s5239; - const SWord8 s5241 = 127 & s5239; - const SWord8 s5242 = s5229 ? s5240 : s5241; - const SBool s5243 = (SBool) (s2180 & 1); - const SBool s5244 = false != s5243; - const SWord8 s5245 = s5244 ? s5240 : s5241; - const SWord8 s5246 = s2116 ? s5242 : s5245; - const SBool s5247 = (SBool) (s2196 & 1); - const SBool s5248 = false != s5247; - const SBool s5249 = (SBool) (s2189 & 1); - const SBool s5250 = false != s5249; - const SWord8 s5251 = s5250 ? s5236 : s5237; - const SWord8 s5252 = (s5251 >> 1) | (s5251 << 7); - const SWord8 s5253 = 128 | s5252; - const SWord8 s5254 = 127 & s5252; - const SWord8 s5255 = s5248 ? s5253 : s5254; - const SBool s5256 = (SBool) (s2201 & 1); - const SBool s5257 = false != s5256; - const SWord8 s5258 = s5257 ? s5253 : s5254; - const SWord8 s5259 = s2116 ? s5255 : s5258; - const SWord8 s5260 = s2097 ? s5246 : s5259; - const SWord8 s5261 = s2078 ? s5227 : s5260; - const SBool s5262 = (SBool) (s2236 & 1); - const SBool s5263 = false != s5262; - const SBool s5264 = (SBool) (s2232 & 1); - const SBool s5265 = false != s5264; - const SBool s5266 = (SBool) (s2228 & 1); - const SBool s5267 = false != s5266; - const SWord8 s5268 = (s2215 >> 1) | (s2215 << 7); - const SWord8 s5269 = 128 | s5268; - const SWord8 s5270 = 127 & s5268; - const SWord8 s5271 = s5267 ? s5269 : s5270; - const SWord8 s5272 = (s5271 >> 1) | (s5271 << 7); - const SWord8 s5273 = 128 | s5272; - const SWord8 s5274 = 127 & s5272; - const SWord8 s5275 = s5265 ? s5273 : s5274; - const SWord8 s5276 = (s5275 >> 1) | (s5275 << 7); - const SWord8 s5277 = 128 | s5276; - const SWord8 s5278 = 127 & s5276; - const SWord8 s5279 = s5263 ? s5277 : s5278; - const SBool s5280 = (SBool) (s2241 & 1); - const SBool s5281 = false != s5280; - const SWord8 s5282 = s5281 ? s5277 : s5278; - const SWord8 s5283 = s2221 ? s5279 : s5282; - const SBool s5284 = (SBool) (s2257 & 1); - const SBool s5285 = false != s5284; - const SBool s5286 = (SBool) (s2250 & 1); - const SBool s5287 = false != s5286; - const SWord8 s5288 = s5287 ? s5273 : s5274; - const SWord8 s5289 = (s5288 >> 1) | (s5288 << 7); - const SWord8 s5290 = 128 | s5289; - const SWord8 s5291 = 127 & s5289; - const SWord8 s5292 = s5285 ? s5290 : s5291; - const SBool s5293 = (SBool) (s2262 & 1); - const SBool s5294 = false != s5293; - const SWord8 s5295 = s5294 ? s5290 : s5291; - const SWord8 s5296 = s2221 ? s5292 : s5295; - const SWord8 s5297 = s2097 ? s5283 : s5296; - const SBool s5298 = (SBool) (s2283 & 1); - const SBool s5299 = false != s5298; - const SBool s5300 = (SBool) (s2279 & 1); - const SBool s5301 = false != s5300; - const SBool s5302 = (SBool) (s2272 & 1); - const SBool s5303 = false != s5302; - const SWord8 s5304 = s5303 ? s5269 : s5270; - const SWord8 s5305 = (s5304 >> 1) | (s5304 << 7); - const SWord8 s5306 = 128 | s5305; - const SWord8 s5307 = 127 & s5305; - const SWord8 s5308 = s5301 ? s5306 : s5307; - const SWord8 s5309 = (s5308 >> 1) | (s5308 << 7); - const SWord8 s5310 = 128 | s5309; - const SWord8 s5311 = 127 & s5309; - const SWord8 s5312 = s5299 ? s5310 : s5311; - const SBool s5313 = (SBool) (s2288 & 1); - const SBool s5314 = false != s5313; - const SWord8 s5315 = s5314 ? s5310 : s5311; - const SWord8 s5316 = s2221 ? s5312 : s5315; - const SBool s5317 = (SBool) (s2304 & 1); - const SBool s5318 = false != s5317; - const SBool s5319 = (SBool) (s2297 & 1); - const SBool s5320 = false != s5319; - const SWord8 s5321 = s5320 ? s5306 : s5307; - const SWord8 s5322 = (s5321 >> 1) | (s5321 << 7); - const SWord8 s5323 = 128 | s5322; - const SWord8 s5324 = 127 & s5322; - const SWord8 s5325 = s5318 ? s5323 : s5324; - const SBool s5326 = (SBool) (s2309 & 1); - const SBool s5327 = false != s5326; - const SWord8 s5328 = s5327 ? s5323 : s5324; - const SWord8 s5329 = s2221 ? s5325 : s5328; - const SWord8 s5330 = s2097 ? s5316 : s5329; - const SWord8 s5331 = s2078 ? s5297 : s5330; - const SWord8 s5332 = s2059 ? s5261 : s5331; - const SBool s5333 = (SBool) (s2364 & 1); - const SBool s5334 = false != s5333; - const SBool s5335 = (SBool) (s2360 & 1); - const SBool s5336 = false != s5335; - const SBool s5337 = (SBool) (s2356 & 1); - const SBool s5338 = false != s5337; - const SWord8 s5339 = (s2343 >> 1) | (s2343 << 7); - const SWord8 s5340 = 128 | s5339; - const SWord8 s5341 = 127 & s5339; - const SWord8 s5342 = s5338 ? s5340 : s5341; - const SWord8 s5343 = (s5342 >> 1) | (s5342 << 7); - const SWord8 s5344 = 128 | s5343; - const SWord8 s5345 = 127 & s5343; - const SWord8 s5346 = s5336 ? s5344 : s5345; - const SWord8 s5347 = (s5346 >> 1) | (s5346 << 7); - const SWord8 s5348 = 128 | s5347; - const SWord8 s5349 = 127 & s5347; - const SWord8 s5350 = s5334 ? s5348 : s5349; - const SBool s5351 = (SBool) (s2369 & 1); - const SBool s5352 = false != s5351; - const SWord8 s5353 = s5352 ? s5348 : s5349; - const SWord8 s5354 = s2352 ? s5350 : s5353; - const SBool s5355 = (SBool) (s2385 & 1); - const SBool s5356 = false != s5355; - const SBool s5357 = (SBool) (s2378 & 1); - const SBool s5358 = false != s5357; - const SWord8 s5359 = s5358 ? s5344 : s5345; - const SWord8 s5360 = (s5359 >> 1) | (s5359 << 7); - const SWord8 s5361 = 128 | s5360; - const SWord8 s5362 = 127 & s5360; - const SWord8 s5363 = s5356 ? s5361 : s5362; - const SBool s5364 = (SBool) (s2390 & 1); - const SBool s5365 = false != s5364; - const SWord8 s5366 = s5365 ? s5361 : s5362; - const SWord8 s5367 = s2352 ? s5363 : s5366; - const SWord8 s5368 = s2330 ? s5354 : s5367; - const SBool s5369 = (SBool) (s2411 & 1); - const SBool s5370 = false != s5369; - const SBool s5371 = (SBool) (s2407 & 1); - const SBool s5372 = false != s5371; - const SBool s5373 = (SBool) (s2400 & 1); - const SBool s5374 = false != s5373; - const SWord8 s5375 = s5374 ? s5340 : s5341; - const SWord8 s5376 = (s5375 >> 1) | (s5375 << 7); - const SWord8 s5377 = 128 | s5376; - const SWord8 s5378 = 127 & s5376; - const SWord8 s5379 = s5372 ? s5377 : s5378; - const SWord8 s5380 = (s5379 >> 1) | (s5379 << 7); - const SWord8 s5381 = 128 | s5380; - const SWord8 s5382 = 127 & s5380; - const SWord8 s5383 = s5370 ? s5381 : s5382; - const SBool s5384 = (SBool) (s2416 & 1); - const SBool s5385 = false != s5384; - const SWord8 s5386 = s5385 ? s5381 : s5382; - const SWord8 s5387 = s2352 ? s5383 : s5386; - const SBool s5388 = (SBool) (s2432 & 1); - const SBool s5389 = false != s5388; - const SBool s5390 = (SBool) (s2425 & 1); - const SBool s5391 = false != s5390; - const SWord8 s5392 = s5391 ? s5377 : s5378; - const SWord8 s5393 = (s5392 >> 1) | (s5392 << 7); - const SWord8 s5394 = 128 | s5393; - const SWord8 s5395 = 127 & s5393; - const SWord8 s5396 = s5389 ? s5394 : s5395; - const SBool s5397 = (SBool) (s2437 & 1); - const SBool s5398 = false != s5397; - const SWord8 s5399 = s5398 ? s5394 : s5395; - const SWord8 s5400 = s2352 ? s5396 : s5399; - const SWord8 s5401 = s2330 ? s5387 : s5400; - const SWord8 s5402 = s2078 ? s5368 : s5401; - const SBool s5403 = (SBool) (s2472 & 1); - const SBool s5404 = false != s5403; - const SBool s5405 = (SBool) (s2468 & 1); - const SBool s5406 = false != s5405; - const SBool s5407 = (SBool) (s2464 & 1); - const SBool s5408 = false != s5407; - const SWord8 s5409 = (s2451 >> 1) | (s2451 << 7); - const SWord8 s5410 = 128 | s5409; - const SWord8 s5411 = 127 & s5409; - const SWord8 s5412 = s5408 ? s5410 : s5411; - const SWord8 s5413 = (s5412 >> 1) | (s5412 << 7); - const SWord8 s5414 = 128 | s5413; - const SWord8 s5415 = 127 & s5413; - const SWord8 s5416 = s5406 ? s5414 : s5415; - const SWord8 s5417 = (s5416 >> 1) | (s5416 << 7); - const SWord8 s5418 = 128 | s5417; - const SWord8 s5419 = 127 & s5417; - const SWord8 s5420 = s5404 ? s5418 : s5419; - const SBool s5421 = (SBool) (s2477 & 1); - const SBool s5422 = false != s5421; - const SWord8 s5423 = s5422 ? s5418 : s5419; - const SWord8 s5424 = s2457 ? s5420 : s5423; - const SBool s5425 = (SBool) (s2493 & 1); - const SBool s5426 = false != s5425; - const SBool s5427 = (SBool) (s2486 & 1); - const SBool s5428 = false != s5427; - const SWord8 s5429 = s5428 ? s5414 : s5415; - const SWord8 s5430 = (s5429 >> 1) | (s5429 << 7); - const SWord8 s5431 = 128 | s5430; - const SWord8 s5432 = 127 & s5430; - const SWord8 s5433 = s5426 ? s5431 : s5432; - const SBool s5434 = (SBool) (s2498 & 1); - const SBool s5435 = false != s5434; - const SWord8 s5436 = s5435 ? s5431 : s5432; - const SWord8 s5437 = s2457 ? s5433 : s5436; - const SWord8 s5438 = s2330 ? s5424 : s5437; - const SBool s5439 = (SBool) (s2519 & 1); - const SBool s5440 = false != s5439; - const SBool s5441 = (SBool) (s2515 & 1); - const SBool s5442 = false != s5441; - const SBool s5443 = (SBool) (s2508 & 1); - const SBool s5444 = false != s5443; - const SWord8 s5445 = s5444 ? s5410 : s5411; - const SWord8 s5446 = (s5445 >> 1) | (s5445 << 7); - const SWord8 s5447 = 128 | s5446; - const SWord8 s5448 = 127 & s5446; - const SWord8 s5449 = s5442 ? s5447 : s5448; - const SWord8 s5450 = (s5449 >> 1) | (s5449 << 7); - const SWord8 s5451 = 128 | s5450; - const SWord8 s5452 = 127 & s5450; - const SWord8 s5453 = s5440 ? s5451 : s5452; - const SBool s5454 = (SBool) (s2524 & 1); - const SBool s5455 = false != s5454; - const SWord8 s5456 = s5455 ? s5451 : s5452; - const SWord8 s5457 = s2457 ? s5453 : s5456; - const SBool s5458 = (SBool) (s2540 & 1); - const SBool s5459 = false != s5458; - const SBool s5460 = (SBool) (s2533 & 1); - const SBool s5461 = false != s5460; - const SWord8 s5462 = s5461 ? s5447 : s5448; - const SWord8 s5463 = (s5462 >> 1) | (s5462 << 7); - const SWord8 s5464 = 128 | s5463; - const SWord8 s5465 = 127 & s5463; - const SWord8 s5466 = s5459 ? s5464 : s5465; - const SBool s5467 = (SBool) (s2545 & 1); - const SBool s5468 = false != s5467; - const SWord8 s5469 = s5468 ? s5464 : s5465; - const SWord8 s5470 = s2457 ? s5466 : s5469; - const SWord8 s5471 = s2330 ? s5457 : s5470; - const SWord8 s5472 = s2078 ? s5438 : s5471; - const SWord8 s5473 = s2059 ? s5402 : s5472; - const SWord8 s5474 = s2042 ? s5332 : s5473; - const SBool s5475 = (SBool) (s2620 & 1); - const SBool s5476 = false != s5475; - const SBool s5477 = (SBool) (s2616 & 1); - const SBool s5478 = false != s5477; - const SBool s5479 = (SBool) (s2612 & 1); - const SBool s5480 = false != s5479; - const SWord8 s5481 = (s2599 >> 1) | (s2599 << 7); - const SWord8 s5482 = 128 | s5481; - const SWord8 s5483 = 127 & s5481; - const SWord8 s5484 = s5480 ? s5482 : s5483; - const SWord8 s5485 = (s5484 >> 1) | (s5484 << 7); - const SWord8 s5486 = 128 | s5485; - const SWord8 s5487 = 127 & s5485; - const SWord8 s5488 = s5478 ? s5486 : s5487; - const SWord8 s5489 = (s5488 >> 1) | (s5488 << 7); - const SWord8 s5490 = 128 | s5489; - const SWord8 s5491 = 127 & s5489; - const SWord8 s5492 = s5476 ? s5490 : s5491; - const SBool s5493 = (SBool) (s2625 & 1); - const SBool s5494 = false != s5493; - const SWord8 s5495 = s5494 ? s5490 : s5491; - const SWord8 s5496 = s2608 ? s5492 : s5495; - const SBool s5497 = (SBool) (s2641 & 1); - const SBool s5498 = false != s5497; - const SBool s5499 = (SBool) (s2634 & 1); - const SBool s5500 = false != s5499; - const SWord8 s5501 = s5500 ? s5486 : s5487; - const SWord8 s5502 = (s5501 >> 1) | (s5501 << 7); - const SWord8 s5503 = 128 | s5502; - const SWord8 s5504 = 127 & s5502; - const SWord8 s5505 = s5498 ? s5503 : s5504; - const SBool s5506 = (SBool) (s2646 & 1); - const SBool s5507 = false != s5506; - const SWord8 s5508 = s5507 ? s5503 : s5504; - const SWord8 s5509 = s2608 ? s5505 : s5508; - const SWord8 s5510 = s2589 ? s5496 : s5509; - const SBool s5511 = (SBool) (s2667 & 1); - const SBool s5512 = false != s5511; - const SBool s5513 = (SBool) (s2663 & 1); - const SBool s5514 = false != s5513; - const SBool s5515 = (SBool) (s2656 & 1); - const SBool s5516 = false != s5515; - const SWord8 s5517 = s5516 ? s5482 : s5483; - const SWord8 s5518 = (s5517 >> 1) | (s5517 << 7); - const SWord8 s5519 = 128 | s5518; - const SWord8 s5520 = 127 & s5518; - const SWord8 s5521 = s5514 ? s5519 : s5520; - const SWord8 s5522 = (s5521 >> 1) | (s5521 << 7); - const SWord8 s5523 = 128 | s5522; - const SWord8 s5524 = 127 & s5522; - const SWord8 s5525 = s5512 ? s5523 : s5524; - const SBool s5526 = (SBool) (s2672 & 1); - const SBool s5527 = false != s5526; - const SWord8 s5528 = s5527 ? s5523 : s5524; - const SWord8 s5529 = s2608 ? s5525 : s5528; - const SBool s5530 = (SBool) (s2688 & 1); - const SBool s5531 = false != s5530; - const SBool s5532 = (SBool) (s2681 & 1); - const SBool s5533 = false != s5532; - const SWord8 s5534 = s5533 ? s5519 : s5520; - const SWord8 s5535 = (s5534 >> 1) | (s5534 << 7); - const SWord8 s5536 = 128 | s5535; - const SWord8 s5537 = 127 & s5535; - const SWord8 s5538 = s5531 ? s5536 : s5537; - const SBool s5539 = (SBool) (s2693 & 1); - const SBool s5540 = false != s5539; - const SWord8 s5541 = s5540 ? s5536 : s5537; - const SWord8 s5542 = s2608 ? s5538 : s5541; - const SWord8 s5543 = s2589 ? s5529 : s5542; - const SWord8 s5544 = s2567 ? s5510 : s5543; - const SBool s5545 = (SBool) (s2728 & 1); - const SBool s5546 = false != s5545; - const SBool s5547 = (SBool) (s2724 & 1); - const SBool s5548 = false != s5547; - const SBool s5549 = (SBool) (s2720 & 1); - const SBool s5550 = false != s5549; - const SWord8 s5551 = (s2707 >> 1) | (s2707 << 7); - const SWord8 s5552 = 128 | s5551; - const SWord8 s5553 = 127 & s5551; - const SWord8 s5554 = s5550 ? s5552 : s5553; - const SWord8 s5555 = (s5554 >> 1) | (s5554 << 7); - const SWord8 s5556 = 128 | s5555; - const SWord8 s5557 = 127 & s5555; - const SWord8 s5558 = s5548 ? s5556 : s5557; - const SWord8 s5559 = (s5558 >> 1) | (s5558 << 7); - const SWord8 s5560 = 128 | s5559; - const SWord8 s5561 = 127 & s5559; - const SWord8 s5562 = s5546 ? s5560 : s5561; - const SBool s5563 = (SBool) (s2733 & 1); - const SBool s5564 = false != s5563; - const SWord8 s5565 = s5564 ? s5560 : s5561; - const SWord8 s5566 = s2713 ? s5562 : s5565; - const SBool s5567 = (SBool) (s2749 & 1); - const SBool s5568 = false != s5567; - const SBool s5569 = (SBool) (s2742 & 1); - const SBool s5570 = false != s5569; - const SWord8 s5571 = s5570 ? s5556 : s5557; - const SWord8 s5572 = (s5571 >> 1) | (s5571 << 7); - const SWord8 s5573 = 128 | s5572; - const SWord8 s5574 = 127 & s5572; - const SWord8 s5575 = s5568 ? s5573 : s5574; - const SBool s5576 = (SBool) (s2754 & 1); - const SBool s5577 = false != s5576; - const SWord8 s5578 = s5577 ? s5573 : s5574; - const SWord8 s5579 = s2713 ? s5575 : s5578; - const SWord8 s5580 = s2589 ? s5566 : s5579; - const SBool s5581 = (SBool) (s2775 & 1); - const SBool s5582 = false != s5581; - const SBool s5583 = (SBool) (s2771 & 1); - const SBool s5584 = false != s5583; - const SBool s5585 = (SBool) (s2764 & 1); - const SBool s5586 = false != s5585; - const SWord8 s5587 = s5586 ? s5552 : s5553; - const SWord8 s5588 = (s5587 >> 1) | (s5587 << 7); - const SWord8 s5589 = 128 | s5588; - const SWord8 s5590 = 127 & s5588; - const SWord8 s5591 = s5584 ? s5589 : s5590; - const SWord8 s5592 = (s5591 >> 1) | (s5591 << 7); - const SWord8 s5593 = 128 | s5592; - const SWord8 s5594 = 127 & s5592; - const SWord8 s5595 = s5582 ? s5593 : s5594; - const SBool s5596 = (SBool) (s2780 & 1); - const SBool s5597 = false != s5596; - const SWord8 s5598 = s5597 ? s5593 : s5594; - const SWord8 s5599 = s2713 ? s5595 : s5598; - const SBool s5600 = (SBool) (s2796 & 1); - const SBool s5601 = false != s5600; - const SBool s5602 = (SBool) (s2789 & 1); - const SBool s5603 = false != s5602; - const SWord8 s5604 = s5603 ? s5589 : s5590; - const SWord8 s5605 = (s5604 >> 1) | (s5604 << 7); - const SWord8 s5606 = 128 | s5605; - const SWord8 s5607 = 127 & s5605; - const SWord8 s5608 = s5601 ? s5606 : s5607; - const SBool s5609 = (SBool) (s2801 & 1); - const SBool s5610 = false != s5609; - const SWord8 s5611 = s5610 ? s5606 : s5607; - const SWord8 s5612 = s2713 ? s5608 : s5611; - const SWord8 s5613 = s2589 ? s5599 : s5612; - const SWord8 s5614 = s2567 ? s5580 : s5613; - const SWord8 s5615 = s2059 ? s5544 : s5614; - const SBool s5616 = (SBool) (s2856 & 1); - const SBool s5617 = false != s5616; - const SBool s5618 = (SBool) (s2852 & 1); - const SBool s5619 = false != s5618; - const SBool s5620 = (SBool) (s2848 & 1); - const SBool s5621 = false != s5620; - const SWord8 s5622 = (s2835 >> 1) | (s2835 << 7); - const SWord8 s5623 = 128 | s5622; - const SWord8 s5624 = 127 & s5622; - const SWord8 s5625 = s5621 ? s5623 : s5624; - const SWord8 s5626 = (s5625 >> 1) | (s5625 << 7); - const SWord8 s5627 = 128 | s5626; - const SWord8 s5628 = 127 & s5626; - const SWord8 s5629 = s5619 ? s5627 : s5628; - const SWord8 s5630 = (s5629 >> 1) | (s5629 << 7); - const SWord8 s5631 = 128 | s5630; - const SWord8 s5632 = 127 & s5630; - const SWord8 s5633 = s5617 ? s5631 : s5632; - const SBool s5634 = (SBool) (s2861 & 1); - const SBool s5635 = false != s5634; - const SWord8 s5636 = s5635 ? s5631 : s5632; - const SWord8 s5637 = s2844 ? s5633 : s5636; - const SBool s5638 = (SBool) (s2877 & 1); - const SBool s5639 = false != s5638; - const SBool s5640 = (SBool) (s2870 & 1); - const SBool s5641 = false != s5640; - const SWord8 s5642 = s5641 ? s5627 : s5628; - const SWord8 s5643 = (s5642 >> 1) | (s5642 << 7); - const SWord8 s5644 = 128 | s5643; - const SWord8 s5645 = 127 & s5643; - const SWord8 s5646 = s5639 ? s5644 : s5645; - const SBool s5647 = (SBool) (s2882 & 1); - const SBool s5648 = false != s5647; - const SWord8 s5649 = s5648 ? s5644 : s5645; - const SWord8 s5650 = s2844 ? s5646 : s5649; - const SWord8 s5651 = s2822 ? s5637 : s5650; - const SBool s5652 = (SBool) (s2903 & 1); - const SBool s5653 = false != s5652; - const SBool s5654 = (SBool) (s2899 & 1); - const SBool s5655 = false != s5654; - const SBool s5656 = (SBool) (s2892 & 1); - const SBool s5657 = false != s5656; - const SWord8 s5658 = s5657 ? s5623 : s5624; - const SWord8 s5659 = (s5658 >> 1) | (s5658 << 7); - const SWord8 s5660 = 128 | s5659; - const SWord8 s5661 = 127 & s5659; - const SWord8 s5662 = s5655 ? s5660 : s5661; - const SWord8 s5663 = (s5662 >> 1) | (s5662 << 7); - const SWord8 s5664 = 128 | s5663; - const SWord8 s5665 = 127 & s5663; - const SWord8 s5666 = s5653 ? s5664 : s5665; - const SBool s5667 = (SBool) (s2908 & 1); - const SBool s5668 = false != s5667; - const SWord8 s5669 = s5668 ? s5664 : s5665; - const SWord8 s5670 = s2844 ? s5666 : s5669; - const SBool s5671 = (SBool) (s2924 & 1); - const SBool s5672 = false != s5671; - const SBool s5673 = (SBool) (s2917 & 1); - const SBool s5674 = false != s5673; - const SWord8 s5675 = s5674 ? s5660 : s5661; - const SWord8 s5676 = (s5675 >> 1) | (s5675 << 7); - const SWord8 s5677 = 128 | s5676; - const SWord8 s5678 = 127 & s5676; - const SWord8 s5679 = s5672 ? s5677 : s5678; - const SBool s5680 = (SBool) (s2929 & 1); - const SBool s5681 = false != s5680; - const SWord8 s5682 = s5681 ? s5677 : s5678; - const SWord8 s5683 = s2844 ? s5679 : s5682; - const SWord8 s5684 = s2822 ? s5670 : s5683; - const SWord8 s5685 = s2567 ? s5651 : s5684; - const SBool s5686 = (SBool) (s2964 & 1); - const SBool s5687 = false != s5686; - const SBool s5688 = (SBool) (s2960 & 1); - const SBool s5689 = false != s5688; - const SBool s5690 = (SBool) (s2956 & 1); - const SBool s5691 = false != s5690; - const SWord8 s5692 = (s2943 >> 1) | (s2943 << 7); - const SWord8 s5693 = 128 | s5692; - const SWord8 s5694 = 127 & s5692; - const SWord8 s5695 = s5691 ? s5693 : s5694; - const SWord8 s5696 = (s5695 >> 1) | (s5695 << 7); - const SWord8 s5697 = 128 | s5696; - const SWord8 s5698 = 127 & s5696; - const SWord8 s5699 = s5689 ? s5697 : s5698; - const SWord8 s5700 = (s5699 >> 1) | (s5699 << 7); - const SWord8 s5701 = 128 | s5700; - const SWord8 s5702 = 127 & s5700; - const SWord8 s5703 = s5687 ? s5701 : s5702; - const SBool s5704 = (SBool) (s2969 & 1); - const SBool s5705 = false != s5704; - const SWord8 s5706 = s5705 ? s5701 : s5702; - const SWord8 s5707 = s2949 ? s5703 : s5706; - const SBool s5708 = (SBool) (s2985 & 1); - const SBool s5709 = false != s5708; - const SBool s5710 = (SBool) (s2978 & 1); - const SBool s5711 = false != s5710; - const SWord8 s5712 = s5711 ? s5697 : s5698; - const SWord8 s5713 = (s5712 >> 1) | (s5712 << 7); - const SWord8 s5714 = 128 | s5713; - const SWord8 s5715 = 127 & s5713; - const SWord8 s5716 = s5709 ? s5714 : s5715; - const SBool s5717 = (SBool) (s2990 & 1); - const SBool s5718 = false != s5717; - const SWord8 s5719 = s5718 ? s5714 : s5715; - const SWord8 s5720 = s2949 ? s5716 : s5719; - const SWord8 s5721 = s2822 ? s5707 : s5720; - const SBool s5722 = (SBool) (s3011 & 1); - const SBool s5723 = false != s5722; - const SBool s5724 = (SBool) (s3007 & 1); - const SBool s5725 = false != s5724; - const SBool s5726 = (SBool) (s3000 & 1); - const SBool s5727 = false != s5726; - const SWord8 s5728 = s5727 ? s5693 : s5694; - const SWord8 s5729 = (s5728 >> 1) | (s5728 << 7); - const SWord8 s5730 = 128 | s5729; - const SWord8 s5731 = 127 & s5729; - const SWord8 s5732 = s5725 ? s5730 : s5731; - const SWord8 s5733 = (s5732 >> 1) | (s5732 << 7); - const SWord8 s5734 = 128 | s5733; - const SWord8 s5735 = 127 & s5733; - const SWord8 s5736 = s5723 ? s5734 : s5735; - const SBool s5737 = (SBool) (s3016 & 1); - const SBool s5738 = false != s5737; - const SWord8 s5739 = s5738 ? s5734 : s5735; - const SWord8 s5740 = s2949 ? s5736 : s5739; - const SBool s5741 = (SBool) (s3032 & 1); - const SBool s5742 = false != s5741; - const SBool s5743 = (SBool) (s3025 & 1); - const SBool s5744 = false != s5743; - const SWord8 s5745 = s5744 ? s5730 : s5731; - const SWord8 s5746 = (s5745 >> 1) | (s5745 << 7); - const SWord8 s5747 = 128 | s5746; - const SWord8 s5748 = 127 & s5746; - const SWord8 s5749 = s5742 ? s5747 : s5748; - const SBool s5750 = (SBool) (s3037 & 1); - const SBool s5751 = false != s5750; - const SWord8 s5752 = s5751 ? s5747 : s5748; - const SWord8 s5753 = s2949 ? s5749 : s5752; - const SWord8 s5754 = s2822 ? s5740 : s5753; - const SWord8 s5755 = s2567 ? s5721 : s5754; - const SWord8 s5756 = s2059 ? s5685 : s5755; - const SWord8 s5757 = s2042 ? s5615 : s5756; - const SWord8 s5758 = s16 ? s5474 : s5757; - const SBool s5759 = (SBool) (s3132 & 1); - const SBool s5760 = false != s5759; - const SBool s5761 = (SBool) (s3128 & 1); - const SBool s5762 = false != s5761; - const SBool s5763 = (SBool) (s3124 & 1); - const SBool s5764 = false != s5763; - const SWord8 s5765 = (s3111 >> 1) | (s3111 << 7); - const SWord8 s5766 = 128 | s5765; - const SWord8 s5767 = 127 & s5765; - const SWord8 s5768 = s5764 ? s5766 : s5767; - const SWord8 s5769 = (s5768 >> 1) | (s5768 << 7); - const SWord8 s5770 = 128 | s5769; - const SWord8 s5771 = 127 & s5769; - const SWord8 s5772 = s5762 ? s5770 : s5771; - const SWord8 s5773 = (s5772 >> 1) | (s5772 << 7); - const SWord8 s5774 = 128 | s5773; - const SWord8 s5775 = 127 & s5773; - const SWord8 s5776 = s5760 ? s5774 : s5775; - const SBool s5777 = (SBool) (s3137 & 1); - const SBool s5778 = false != s5777; - const SWord8 s5779 = s5778 ? s5774 : s5775; - const SWord8 s5780 = s3120 ? s5776 : s5779; - const SBool s5781 = (SBool) (s3153 & 1); - const SBool s5782 = false != s5781; - const SBool s5783 = (SBool) (s3146 & 1); - const SBool s5784 = false != s5783; - const SWord8 s5785 = s5784 ? s5770 : s5771; - const SWord8 s5786 = (s5785 >> 1) | (s5785 << 7); - const SWord8 s5787 = 128 | s5786; - const SWord8 s5788 = 127 & s5786; - const SWord8 s5789 = s5782 ? s5787 : s5788; - const SBool s5790 = (SBool) (s3158 & 1); - const SBool s5791 = false != s5790; - const SWord8 s5792 = s5791 ? s5787 : s5788; - const SWord8 s5793 = s3120 ? s5789 : s5792; - const SWord8 s5794 = s3101 ? s5780 : s5793; - const SBool s5795 = (SBool) (s3179 & 1); - const SBool s5796 = false != s5795; - const SBool s5797 = (SBool) (s3175 & 1); - const SBool s5798 = false != s5797; - const SBool s5799 = (SBool) (s3168 & 1); - const SBool s5800 = false != s5799; - const SWord8 s5801 = s5800 ? s5766 : s5767; - const SWord8 s5802 = (s5801 >> 1) | (s5801 << 7); - const SWord8 s5803 = 128 | s5802; - const SWord8 s5804 = 127 & s5802; - const SWord8 s5805 = s5798 ? s5803 : s5804; - const SWord8 s5806 = (s5805 >> 1) | (s5805 << 7); - const SWord8 s5807 = 128 | s5806; - const SWord8 s5808 = 127 & s5806; - const SWord8 s5809 = s5796 ? s5807 : s5808; - const SBool s5810 = (SBool) (s3184 & 1); - const SBool s5811 = false != s5810; - const SWord8 s5812 = s5811 ? s5807 : s5808; - const SWord8 s5813 = s3120 ? s5809 : s5812; - const SBool s5814 = (SBool) (s3200 & 1); - const SBool s5815 = false != s5814; - const SBool s5816 = (SBool) (s3193 & 1); - const SBool s5817 = false != s5816; - const SWord8 s5818 = s5817 ? s5803 : s5804; - const SWord8 s5819 = (s5818 >> 1) | (s5818 << 7); - const SWord8 s5820 = 128 | s5819; - const SWord8 s5821 = 127 & s5819; - const SWord8 s5822 = s5815 ? s5820 : s5821; - const SBool s5823 = (SBool) (s3205 & 1); - const SBool s5824 = false != s5823; - const SWord8 s5825 = s5824 ? s5820 : s5821; - const SWord8 s5826 = s3120 ? s5822 : s5825; - const SWord8 s5827 = s3101 ? s5813 : s5826; - const SWord8 s5828 = s3082 ? s5794 : s5827; - const SBool s5829 = (SBool) (s3240 & 1); - const SBool s5830 = false != s5829; - const SBool s5831 = (SBool) (s3236 & 1); - const SBool s5832 = false != s5831; - const SBool s5833 = (SBool) (s3232 & 1); - const SBool s5834 = false != s5833; - const SWord8 s5835 = (s3219 >> 1) | (s3219 << 7); - const SWord8 s5836 = 128 | s5835; - const SWord8 s5837 = 127 & s5835; - const SWord8 s5838 = s5834 ? s5836 : s5837; - const SWord8 s5839 = (s5838 >> 1) | (s5838 << 7); - const SWord8 s5840 = 128 | s5839; - const SWord8 s5841 = 127 & s5839; - const SWord8 s5842 = s5832 ? s5840 : s5841; - const SWord8 s5843 = (s5842 >> 1) | (s5842 << 7); - const SWord8 s5844 = 128 | s5843; - const SWord8 s5845 = 127 & s5843; - const SWord8 s5846 = s5830 ? s5844 : s5845; - const SBool s5847 = (SBool) (s3245 & 1); - const SBool s5848 = false != s5847; - const SWord8 s5849 = s5848 ? s5844 : s5845; - const SWord8 s5850 = s3225 ? s5846 : s5849; - const SBool s5851 = (SBool) (s3261 & 1); - const SBool s5852 = false != s5851; - const SBool s5853 = (SBool) (s3254 & 1); - const SBool s5854 = false != s5853; - const SWord8 s5855 = s5854 ? s5840 : s5841; - const SWord8 s5856 = (s5855 >> 1) | (s5855 << 7); - const SWord8 s5857 = 128 | s5856; - const SWord8 s5858 = 127 & s5856; - const SWord8 s5859 = s5852 ? s5857 : s5858; - const SBool s5860 = (SBool) (s3266 & 1); - const SBool s5861 = false != s5860; - const SWord8 s5862 = s5861 ? s5857 : s5858; - const SWord8 s5863 = s3225 ? s5859 : s5862; - const SWord8 s5864 = s3101 ? s5850 : s5863; - const SBool s5865 = (SBool) (s3287 & 1); - const SBool s5866 = false != s5865; - const SBool s5867 = (SBool) (s3283 & 1); - const SBool s5868 = false != s5867; - const SBool s5869 = (SBool) (s3276 & 1); - const SBool s5870 = false != s5869; - const SWord8 s5871 = s5870 ? s5836 : s5837; - const SWord8 s5872 = (s5871 >> 1) | (s5871 << 7); - const SWord8 s5873 = 128 | s5872; - const SWord8 s5874 = 127 & s5872; - const SWord8 s5875 = s5868 ? s5873 : s5874; - const SWord8 s5876 = (s5875 >> 1) | (s5875 << 7); - const SWord8 s5877 = 128 | s5876; - const SWord8 s5878 = 127 & s5876; - const SWord8 s5879 = s5866 ? s5877 : s5878; - const SBool s5880 = (SBool) (s3292 & 1); - const SBool s5881 = false != s5880; - const SWord8 s5882 = s5881 ? s5877 : s5878; - const SWord8 s5883 = s3225 ? s5879 : s5882; - const SBool s5884 = (SBool) (s3308 & 1); - const SBool s5885 = false != s5884; - const SBool s5886 = (SBool) (s3301 & 1); - const SBool s5887 = false != s5886; - const SWord8 s5888 = s5887 ? s5873 : s5874; - const SWord8 s5889 = (s5888 >> 1) | (s5888 << 7); - const SWord8 s5890 = 128 | s5889; - const SWord8 s5891 = 127 & s5889; - const SWord8 s5892 = s5885 ? s5890 : s5891; - const SBool s5893 = (SBool) (s3313 & 1); - const SBool s5894 = false != s5893; - const SWord8 s5895 = s5894 ? s5890 : s5891; - const SWord8 s5896 = s3225 ? s5892 : s5895; - const SWord8 s5897 = s3101 ? s5883 : s5896; - const SWord8 s5898 = s3082 ? s5864 : s5897; - const SWord8 s5899 = s3060 ? s5828 : s5898; - const SBool s5900 = (SBool) (s3368 & 1); - const SBool s5901 = false != s5900; - const SBool s5902 = (SBool) (s3364 & 1); - const SBool s5903 = false != s5902; - const SBool s5904 = (SBool) (s3360 & 1); - const SBool s5905 = false != s5904; - const SWord8 s5906 = (s3347 >> 1) | (s3347 << 7); - const SWord8 s5907 = 128 | s5906; - const SWord8 s5908 = 127 & s5906; - const SWord8 s5909 = s5905 ? s5907 : s5908; - const SWord8 s5910 = (s5909 >> 1) | (s5909 << 7); - const SWord8 s5911 = 128 | s5910; - const SWord8 s5912 = 127 & s5910; - const SWord8 s5913 = s5903 ? s5911 : s5912; - const SWord8 s5914 = (s5913 >> 1) | (s5913 << 7); - const SWord8 s5915 = 128 | s5914; - const SWord8 s5916 = 127 & s5914; - const SWord8 s5917 = s5901 ? s5915 : s5916; - const SBool s5918 = (SBool) (s3373 & 1); - const SBool s5919 = false != s5918; - const SWord8 s5920 = s5919 ? s5915 : s5916; - const SWord8 s5921 = s3356 ? s5917 : s5920; - const SBool s5922 = (SBool) (s3389 & 1); - const SBool s5923 = false != s5922; - const SBool s5924 = (SBool) (s3382 & 1); - const SBool s5925 = false != s5924; - const SWord8 s5926 = s5925 ? s5911 : s5912; - const SWord8 s5927 = (s5926 >> 1) | (s5926 << 7); - const SWord8 s5928 = 128 | s5927; - const SWord8 s5929 = 127 & s5927; - const SWord8 s5930 = s5923 ? s5928 : s5929; - const SBool s5931 = (SBool) (s3394 & 1); - const SBool s5932 = false != s5931; - const SWord8 s5933 = s5932 ? s5928 : s5929; - const SWord8 s5934 = s3356 ? s5930 : s5933; - const SWord8 s5935 = s3334 ? s5921 : s5934; - const SBool s5936 = (SBool) (s3415 & 1); - const SBool s5937 = false != s5936; - const SBool s5938 = (SBool) (s3411 & 1); - const SBool s5939 = false != s5938; - const SBool s5940 = (SBool) (s3404 & 1); - const SBool s5941 = false != s5940; - const SWord8 s5942 = s5941 ? s5907 : s5908; - const SWord8 s5943 = (s5942 >> 1) | (s5942 << 7); - const SWord8 s5944 = 128 | s5943; - const SWord8 s5945 = 127 & s5943; - const SWord8 s5946 = s5939 ? s5944 : s5945; - const SWord8 s5947 = (s5946 >> 1) | (s5946 << 7); - const SWord8 s5948 = 128 | s5947; - const SWord8 s5949 = 127 & s5947; - const SWord8 s5950 = s5937 ? s5948 : s5949; - const SBool s5951 = (SBool) (s3420 & 1); - const SBool s5952 = false != s5951; - const SWord8 s5953 = s5952 ? s5948 : s5949; - const SWord8 s5954 = s3356 ? s5950 : s5953; - const SBool s5955 = (SBool) (s3436 & 1); - const SBool s5956 = false != s5955; - const SBool s5957 = (SBool) (s3429 & 1); - const SBool s5958 = false != s5957; - const SWord8 s5959 = s5958 ? s5944 : s5945; - const SWord8 s5960 = (s5959 >> 1) | (s5959 << 7); - const SWord8 s5961 = 128 | s5960; - const SWord8 s5962 = 127 & s5960; - const SWord8 s5963 = s5956 ? s5961 : s5962; - const SBool s5964 = (SBool) (s3441 & 1); - const SBool s5965 = false != s5964; - const SWord8 s5966 = s5965 ? s5961 : s5962; - const SWord8 s5967 = s3356 ? s5963 : s5966; - const SWord8 s5968 = s3334 ? s5954 : s5967; - const SWord8 s5969 = s3082 ? s5935 : s5968; - const SBool s5970 = (SBool) (s3476 & 1); - const SBool s5971 = false != s5970; - const SBool s5972 = (SBool) (s3472 & 1); - const SBool s5973 = false != s5972; - const SBool s5974 = (SBool) (s3468 & 1); - const SBool s5975 = false != s5974; - const SWord8 s5976 = (s3455 >> 1) | (s3455 << 7); - const SWord8 s5977 = 128 | s5976; - const SWord8 s5978 = 127 & s5976; - const SWord8 s5979 = s5975 ? s5977 : s5978; - const SWord8 s5980 = (s5979 >> 1) | (s5979 << 7); - const SWord8 s5981 = 128 | s5980; - const SWord8 s5982 = 127 & s5980; - const SWord8 s5983 = s5973 ? s5981 : s5982; - const SWord8 s5984 = (s5983 >> 1) | (s5983 << 7); - const SWord8 s5985 = 128 | s5984; - const SWord8 s5986 = 127 & s5984; - const SWord8 s5987 = s5971 ? s5985 : s5986; - const SBool s5988 = (SBool) (s3481 & 1); - const SBool s5989 = false != s5988; - const SWord8 s5990 = s5989 ? s5985 : s5986; - const SWord8 s5991 = s3461 ? s5987 : s5990; - const SBool s5992 = (SBool) (s3497 & 1); - const SBool s5993 = false != s5992; - const SBool s5994 = (SBool) (s3490 & 1); - const SBool s5995 = false != s5994; - const SWord8 s5996 = s5995 ? s5981 : s5982; - const SWord8 s5997 = (s5996 >> 1) | (s5996 << 7); - const SWord8 s5998 = 128 | s5997; - const SWord8 s5999 = 127 & s5997; - const SWord8 s6000 = s5993 ? s5998 : s5999; - const SBool s6001 = (SBool) (s3502 & 1); - const SBool s6002 = false != s6001; - const SWord8 s6003 = s6002 ? s5998 : s5999; - const SWord8 s6004 = s3461 ? s6000 : s6003; - const SWord8 s6005 = s3334 ? s5991 : s6004; - const SBool s6006 = (SBool) (s3523 & 1); - const SBool s6007 = false != s6006; - const SBool s6008 = (SBool) (s3519 & 1); - const SBool s6009 = false != s6008; - const SBool s6010 = (SBool) (s3512 & 1); - const SBool s6011 = false != s6010; - const SWord8 s6012 = s6011 ? s5977 : s5978; - const SWord8 s6013 = (s6012 >> 1) | (s6012 << 7); - const SWord8 s6014 = 128 | s6013; - const SWord8 s6015 = 127 & s6013; - const SWord8 s6016 = s6009 ? s6014 : s6015; - const SWord8 s6017 = (s6016 >> 1) | (s6016 << 7); - const SWord8 s6018 = 128 | s6017; - const SWord8 s6019 = 127 & s6017; - const SWord8 s6020 = s6007 ? s6018 : s6019; - const SBool s6021 = (SBool) (s3528 & 1); - const SBool s6022 = false != s6021; - const SWord8 s6023 = s6022 ? s6018 : s6019; - const SWord8 s6024 = s3461 ? s6020 : s6023; - const SBool s6025 = (SBool) (s3544 & 1); - const SBool s6026 = false != s6025; - const SBool s6027 = (SBool) (s3537 & 1); - const SBool s6028 = false != s6027; - const SWord8 s6029 = s6028 ? s6014 : s6015; - const SWord8 s6030 = (s6029 >> 1) | (s6029 << 7); - const SWord8 s6031 = 128 | s6030; - const SWord8 s6032 = 127 & s6030; - const SWord8 s6033 = s6026 ? s6031 : s6032; - const SBool s6034 = (SBool) (s3549 & 1); - const SBool s6035 = false != s6034; - const SWord8 s6036 = s6035 ? s6031 : s6032; - const SWord8 s6037 = s3461 ? s6033 : s6036; - const SWord8 s6038 = s3334 ? s6024 : s6037; - const SWord8 s6039 = s3082 ? s6005 : s6038; - const SWord8 s6040 = s3060 ? s5969 : s6039; - const SWord8 s6041 = s2042 ? s5899 : s6040; - const SBool s6042 = (SBool) (s3624 & 1); - const SBool s6043 = false != s6042; - const SBool s6044 = (SBool) (s3620 & 1); - const SBool s6045 = false != s6044; - const SBool s6046 = (SBool) (s3616 & 1); - const SBool s6047 = false != s6046; - const SWord8 s6048 = (s3603 >> 1) | (s3603 << 7); - const SWord8 s6049 = 128 | s6048; - const SWord8 s6050 = 127 & s6048; - const SWord8 s6051 = s6047 ? s6049 : s6050; - const SWord8 s6052 = (s6051 >> 1) | (s6051 << 7); - const SWord8 s6053 = 128 | s6052; - const SWord8 s6054 = 127 & s6052; - const SWord8 s6055 = s6045 ? s6053 : s6054; - const SWord8 s6056 = (s6055 >> 1) | (s6055 << 7); - const SWord8 s6057 = 128 | s6056; - const SWord8 s6058 = 127 & s6056; - const SWord8 s6059 = s6043 ? s6057 : s6058; - const SBool s6060 = (SBool) (s3629 & 1); - const SBool s6061 = false != s6060; - const SWord8 s6062 = s6061 ? s6057 : s6058; - const SWord8 s6063 = s3612 ? s6059 : s6062; - const SBool s6064 = (SBool) (s3645 & 1); - const SBool s6065 = false != s6064; - const SBool s6066 = (SBool) (s3638 & 1); - const SBool s6067 = false != s6066; - const SWord8 s6068 = s6067 ? s6053 : s6054; - const SWord8 s6069 = (s6068 >> 1) | (s6068 << 7); - const SWord8 s6070 = 128 | s6069; - const SWord8 s6071 = 127 & s6069; - const SWord8 s6072 = s6065 ? s6070 : s6071; - const SBool s6073 = (SBool) (s3650 & 1); - const SBool s6074 = false != s6073; - const SWord8 s6075 = s6074 ? s6070 : s6071; - const SWord8 s6076 = s3612 ? s6072 : s6075; - const SWord8 s6077 = s3593 ? s6063 : s6076; - const SBool s6078 = (SBool) (s3671 & 1); - const SBool s6079 = false != s6078; - const SBool s6080 = (SBool) (s3667 & 1); - const SBool s6081 = false != s6080; - const SBool s6082 = (SBool) (s3660 & 1); - const SBool s6083 = false != s6082; - const SWord8 s6084 = s6083 ? s6049 : s6050; - const SWord8 s6085 = (s6084 >> 1) | (s6084 << 7); - const SWord8 s6086 = 128 | s6085; - const SWord8 s6087 = 127 & s6085; - const SWord8 s6088 = s6081 ? s6086 : s6087; - const SWord8 s6089 = (s6088 >> 1) | (s6088 << 7); - const SWord8 s6090 = 128 | s6089; - const SWord8 s6091 = 127 & s6089; - const SWord8 s6092 = s6079 ? s6090 : s6091; - const SBool s6093 = (SBool) (s3676 & 1); - const SBool s6094 = false != s6093; - const SWord8 s6095 = s6094 ? s6090 : s6091; - const SWord8 s6096 = s3612 ? s6092 : s6095; - const SBool s6097 = (SBool) (s3692 & 1); - const SBool s6098 = false != s6097; - const SBool s6099 = (SBool) (s3685 & 1); - const SBool s6100 = false != s6099; - const SWord8 s6101 = s6100 ? s6086 : s6087; - const SWord8 s6102 = (s6101 >> 1) | (s6101 << 7); - const SWord8 s6103 = 128 | s6102; - const SWord8 s6104 = 127 & s6102; - const SWord8 s6105 = s6098 ? s6103 : s6104; - const SBool s6106 = (SBool) (s3697 & 1); - const SBool s6107 = false != s6106; - const SWord8 s6108 = s6107 ? s6103 : s6104; - const SWord8 s6109 = s3612 ? s6105 : s6108; - const SWord8 s6110 = s3593 ? s6096 : s6109; - const SWord8 s6111 = s3571 ? s6077 : s6110; - const SBool s6112 = (SBool) (s3732 & 1); - const SBool s6113 = false != s6112; - const SBool s6114 = (SBool) (s3728 & 1); - const SBool s6115 = false != s6114; - const SBool s6116 = (SBool) (s3724 & 1); - const SBool s6117 = false != s6116; - const SWord8 s6118 = (s3711 >> 1) | (s3711 << 7); - const SWord8 s6119 = 128 | s6118; - const SWord8 s6120 = 127 & s6118; - const SWord8 s6121 = s6117 ? s6119 : s6120; - const SWord8 s6122 = (s6121 >> 1) | (s6121 << 7); - const SWord8 s6123 = 128 | s6122; - const SWord8 s6124 = 127 & s6122; - const SWord8 s6125 = s6115 ? s6123 : s6124; - const SWord8 s6126 = (s6125 >> 1) | (s6125 << 7); - const SWord8 s6127 = 128 | s6126; - const SWord8 s6128 = 127 & s6126; - const SWord8 s6129 = s6113 ? s6127 : s6128; - const SBool s6130 = (SBool) (s3737 & 1); - const SBool s6131 = false != s6130; - const SWord8 s6132 = s6131 ? s6127 : s6128; - const SWord8 s6133 = s3717 ? s6129 : s6132; - const SBool s6134 = (SBool) (s3753 & 1); - const SBool s6135 = false != s6134; - const SBool s6136 = (SBool) (s3746 & 1); - const SBool s6137 = false != s6136; - const SWord8 s6138 = s6137 ? s6123 : s6124; - const SWord8 s6139 = (s6138 >> 1) | (s6138 << 7); - const SWord8 s6140 = 128 | s6139; - const SWord8 s6141 = 127 & s6139; - const SWord8 s6142 = s6135 ? s6140 : s6141; - const SBool s6143 = (SBool) (s3758 & 1); - const SBool s6144 = false != s6143; - const SWord8 s6145 = s6144 ? s6140 : s6141; - const SWord8 s6146 = s3717 ? s6142 : s6145; - const SWord8 s6147 = s3593 ? s6133 : s6146; - const SBool s6148 = (SBool) (s3779 & 1); - const SBool s6149 = false != s6148; - const SBool s6150 = (SBool) (s3775 & 1); - const SBool s6151 = false != s6150; - const SBool s6152 = (SBool) (s3768 & 1); - const SBool s6153 = false != s6152; - const SWord8 s6154 = s6153 ? s6119 : s6120; - const SWord8 s6155 = (s6154 >> 1) | (s6154 << 7); - const SWord8 s6156 = 128 | s6155; - const SWord8 s6157 = 127 & s6155; - const SWord8 s6158 = s6151 ? s6156 : s6157; - const SWord8 s6159 = (s6158 >> 1) | (s6158 << 7); - const SWord8 s6160 = 128 | s6159; - const SWord8 s6161 = 127 & s6159; - const SWord8 s6162 = s6149 ? s6160 : s6161; - const SBool s6163 = (SBool) (s3784 & 1); - const SBool s6164 = false != s6163; - const SWord8 s6165 = s6164 ? s6160 : s6161; - const SWord8 s6166 = s3717 ? s6162 : s6165; - const SBool s6167 = (SBool) (s3800 & 1); - const SBool s6168 = false != s6167; - const SBool s6169 = (SBool) (s3793 & 1); - const SBool s6170 = false != s6169; - const SWord8 s6171 = s6170 ? s6156 : s6157; - const SWord8 s6172 = (s6171 >> 1) | (s6171 << 7); - const SWord8 s6173 = 128 | s6172; - const SWord8 s6174 = 127 & s6172; - const SWord8 s6175 = s6168 ? s6173 : s6174; - const SBool s6176 = (SBool) (s3805 & 1); - const SBool s6177 = false != s6176; - const SWord8 s6178 = s6177 ? s6173 : s6174; - const SWord8 s6179 = s3717 ? s6175 : s6178; - const SWord8 s6180 = s3593 ? s6166 : s6179; - const SWord8 s6181 = s3571 ? s6147 : s6180; - const SWord8 s6182 = s3060 ? s6111 : s6181; - const SBool s6183 = (SBool) (s3860 & 1); - const SBool s6184 = false != s6183; - const SBool s6185 = (SBool) (s3856 & 1); - const SBool s6186 = false != s6185; - const SBool s6187 = (SBool) (s3852 & 1); - const SBool s6188 = false != s6187; - const SWord8 s6189 = (s3839 >> 1) | (s3839 << 7); - const SWord8 s6190 = 128 | s6189; - const SWord8 s6191 = 127 & s6189; - const SWord8 s6192 = s6188 ? s6190 : s6191; - const SWord8 s6193 = (s6192 >> 1) | (s6192 << 7); - const SWord8 s6194 = 128 | s6193; - const SWord8 s6195 = 127 & s6193; - const SWord8 s6196 = s6186 ? s6194 : s6195; - const SWord8 s6197 = (s6196 >> 1) | (s6196 << 7); - const SWord8 s6198 = 128 | s6197; - const SWord8 s6199 = 127 & s6197; - const SWord8 s6200 = s6184 ? s6198 : s6199; - const SBool s6201 = (SBool) (s3865 & 1); - const SBool s6202 = false != s6201; - const SWord8 s6203 = s6202 ? s6198 : s6199; - const SWord8 s6204 = s3848 ? s6200 : s6203; - const SBool s6205 = (SBool) (s3881 & 1); - const SBool s6206 = false != s6205; - const SBool s6207 = (SBool) (s3874 & 1); - const SBool s6208 = false != s6207; - const SWord8 s6209 = s6208 ? s6194 : s6195; - const SWord8 s6210 = (s6209 >> 1) | (s6209 << 7); - const SWord8 s6211 = 128 | s6210; - const SWord8 s6212 = 127 & s6210; - const SWord8 s6213 = s6206 ? s6211 : s6212; - const SBool s6214 = (SBool) (s3886 & 1); - const SBool s6215 = false != s6214; - const SWord8 s6216 = s6215 ? s6211 : s6212; - const SWord8 s6217 = s3848 ? s6213 : s6216; - const SWord8 s6218 = s3826 ? s6204 : s6217; - const SBool s6219 = (SBool) (s3907 & 1); - const SBool s6220 = false != s6219; - const SBool s6221 = (SBool) (s3903 & 1); - const SBool s6222 = false != s6221; - const SBool s6223 = (SBool) (s3896 & 1); - const SBool s6224 = false != s6223; - const SWord8 s6225 = s6224 ? s6190 : s6191; - const SWord8 s6226 = (s6225 >> 1) | (s6225 << 7); - const SWord8 s6227 = 128 | s6226; - const SWord8 s6228 = 127 & s6226; - const SWord8 s6229 = s6222 ? s6227 : s6228; - const SWord8 s6230 = (s6229 >> 1) | (s6229 << 7); - const SWord8 s6231 = 128 | s6230; - const SWord8 s6232 = 127 & s6230; - const SWord8 s6233 = s6220 ? s6231 : s6232; - const SBool s6234 = (SBool) (s3912 & 1); - const SBool s6235 = false != s6234; - const SWord8 s6236 = s6235 ? s6231 : s6232; - const SWord8 s6237 = s3848 ? s6233 : s6236; - const SBool s6238 = (SBool) (s3928 & 1); - const SBool s6239 = false != s6238; - const SBool s6240 = (SBool) (s3921 & 1); - const SBool s6241 = false != s6240; - const SWord8 s6242 = s6241 ? s6227 : s6228; - const SWord8 s6243 = (s6242 >> 1) | (s6242 << 7); - const SWord8 s6244 = 128 | s6243; - const SWord8 s6245 = 127 & s6243; - const SWord8 s6246 = s6239 ? s6244 : s6245; - const SBool s6247 = (SBool) (s3933 & 1); - const SBool s6248 = false != s6247; - const SWord8 s6249 = s6248 ? s6244 : s6245; - const SWord8 s6250 = s3848 ? s6246 : s6249; - const SWord8 s6251 = s3826 ? s6237 : s6250; - const SWord8 s6252 = s3571 ? s6218 : s6251; - const SBool s6253 = (SBool) (s3968 & 1); - const SBool s6254 = false != s6253; - const SBool s6255 = (SBool) (s3964 & 1); - const SBool s6256 = false != s6255; - const SBool s6257 = (SBool) (s3960 & 1); - const SBool s6258 = false != s6257; - const SWord8 s6259 = (s3947 >> 1) | (s3947 << 7); - const SWord8 s6260 = 128 | s6259; - const SWord8 s6261 = 127 & s6259; - const SWord8 s6262 = s6258 ? s6260 : s6261; - const SWord8 s6263 = (s6262 >> 1) | (s6262 << 7); - const SWord8 s6264 = 128 | s6263; - const SWord8 s6265 = 127 & s6263; - const SWord8 s6266 = s6256 ? s6264 : s6265; - const SWord8 s6267 = (s6266 >> 1) | (s6266 << 7); - const SWord8 s6268 = 128 | s6267; - const SWord8 s6269 = 127 & s6267; - const SWord8 s6270 = s6254 ? s6268 : s6269; - const SBool s6271 = (SBool) (s3973 & 1); - const SBool s6272 = false != s6271; - const SWord8 s6273 = s6272 ? s6268 : s6269; - const SWord8 s6274 = s3953 ? s6270 : s6273; - const SBool s6275 = (SBool) (s3989 & 1); - const SBool s6276 = false != s6275; - const SBool s6277 = (SBool) (s3982 & 1); - const SBool s6278 = false != s6277; - const SWord8 s6279 = s6278 ? s6264 : s6265; - const SWord8 s6280 = (s6279 >> 1) | (s6279 << 7); - const SWord8 s6281 = 128 | s6280; - const SWord8 s6282 = 127 & s6280; - const SWord8 s6283 = s6276 ? s6281 : s6282; - const SBool s6284 = (SBool) (s3994 & 1); - const SBool s6285 = false != s6284; - const SWord8 s6286 = s6285 ? s6281 : s6282; - const SWord8 s6287 = s3953 ? s6283 : s6286; - const SWord8 s6288 = s3826 ? s6274 : s6287; - const SBool s6289 = (SBool) (s4015 & 1); - const SBool s6290 = false != s6289; - const SBool s6291 = (SBool) (s4011 & 1); - const SBool s6292 = false != s6291; - const SBool s6293 = (SBool) (s4004 & 1); - const SBool s6294 = false != s6293; - const SWord8 s6295 = s6294 ? s6260 : s6261; - const SWord8 s6296 = (s6295 >> 1) | (s6295 << 7); - const SWord8 s6297 = 128 | s6296; - const SWord8 s6298 = 127 & s6296; - const SWord8 s6299 = s6292 ? s6297 : s6298; - const SWord8 s6300 = (s6299 >> 1) | (s6299 << 7); - const SWord8 s6301 = 128 | s6300; - const SWord8 s6302 = 127 & s6300; - const SWord8 s6303 = s6290 ? s6301 : s6302; - const SBool s6304 = (SBool) (s4020 & 1); - const SBool s6305 = false != s6304; - const SWord8 s6306 = s6305 ? s6301 : s6302; - const SWord8 s6307 = s3953 ? s6303 : s6306; - const SBool s6308 = (SBool) (s4036 & 1); - const SBool s6309 = false != s6308; - const SBool s6310 = (SBool) (s4029 & 1); - const SBool s6311 = false != s6310; - const SWord8 s6312 = s6311 ? s6297 : s6298; - const SWord8 s6313 = (s6312 >> 1) | (s6312 << 7); - const SWord8 s6314 = 128 | s6313; - const SWord8 s6315 = 127 & s6313; - const SWord8 s6316 = s6309 ? s6314 : s6315; - const SBool s6317 = (SBool) (s4041 & 1); - const SBool s6318 = false != s6317; - const SWord8 s6319 = s6318 ? s6314 : s6315; - const SWord8 s6320 = s3953 ? s6316 : s6319; - const SWord8 s6321 = s3826 ? s6307 : s6320; - const SWord8 s6322 = s3571 ? s6288 : s6321; - const SWord8 s6323 = s3060 ? s6252 : s6322; - const SWord8 s6324 = s2042 ? s6182 : s6323; - const SWord8 s6325 = s16 ? s6041 : s6324; - const SWord8 s6326 = s11 ? s5758 : s6325; - const SWord8 s6327 = s5 ? s5191 : s6326; - - *hi = s4056; - *lo = s6327; +legatoMult_driver.o: legatoMult_driver.c legatoMult.h + ${CC} ${CCFLAGS} -c $< -o $@ + +legatoMult_driver: legatoMult.o legatoMult_driver.o + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} + +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 SBV_GENERATED_legatoMult_HEADER_INCLUDED +#define SBV_GENERATED_legatoMult_HEADER_INCLUDED + + +#include +#include +#include +#include +#include +#include +#include + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* Entry point prototype: */ +void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi, + SWord8 *lo); + +#endif /* SBV_GENERATED_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 +#include "legatoMult.h" + +int main(void) +{ + SWord8 sbv_driver_output_0; + SWord8 sbv_driver_output_1; + + legatoMult(87, 92, &sbv_driver_output_0, &sbv_driver_output_1); + + printf("legatoMult(87, 92, &hi, &lo) ->\n"); + printf(" hi = %"PRIu8"\n", sbv_driver_output_0); + printf(" lo = %"PRIu8"\n", sbv_driver_output_1); + + return 0; +} +== END: "legatoMult_driver.c" ================== +== BEGIN: "legatoMult.c" ================ +/* File: "legatoMult.c". Automatically generated by SBV. Do not edit! */ + +#include "legatoMult.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SBool sbv_bv_extract_u8_0_0_u1(SWord8 a) +{ + SBool r = (SBool) 0; + uint64_t i; + for (i = 0; i < 1; ++i) { r = (SBool) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_rotl(SWord8 a, uint64_t amount) +{ + amount %= 8; + if (amount == 0) return a; + return (SWord8) ((((uint64_t) (SWord8) a) << amount) | (((uint64_t) (SWord8) a) >> (8 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_rotr(SWord8 a, uint64_t amount) +{ + amount %= 8; + if (amount == 0) return a; + return (SWord8) ((((uint64_t) (SWord8) a) >> amount) | (((uint64_t) (SWord8) a) << (8 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) +{ + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +void legatoMult(const SWord8 sbv_input_0, const SWord8 sbv_input_1, + SWord8 *sbv_output_0, SWord8 *sbv_output_1) +{ + const SWord8 s0 = sbv_input_0; + const SWord8 s1 = sbv_input_1; + const SBool s2 = sbv_bv_extract_u8_0_0_u1(s0); + const SBool s4 = s2 != false; + const SBool s5 = !s4; + const SWord8 s6 = sbv_bv_u8_rotr(s0, 1); + const SWord8 s8 = s6 & 127; + const SBool s9 = sbv_bv_extract_u8_0_0_u1(s8); + const SBool s10 = false != s9; + const SBool s11 = !s10; + const SWord8 s12 = sbv_bv_u8_rotr(s8, 1); + const SWord8 s13 = 127 & s12; + const SBool s14 = sbv_bv_extract_u8_0_0_u1(s13); + const SBool s15 = false != s14; + const SBool s16 = !s15; + const SWord8 s17 = sbv_bv_u8_rotr(s13, 1); + const SWord8 s18 = 127 & s17; + const SBool s19 = sbv_bv_extract_u8_0_0_u1(s18); + const SBool s20 = false != s19; + const SBool s21 = !s20; + const SWord8 s24 = s4 ? 128 : 0; + const SBool s25 = sbv_bv_extract_u8_0_0_u1(s24); + const SBool s26 = false != s25; + const SWord8 s27 = s26 ? 128 : 0; + const SBool s28 = sbv_bv_extract_u8_0_0_u1(s27); + const SBool s29 = false != s28; + const SWord8 s30 = sbv_bv_u8_rotr(s18, 1); + const SWord8 s31 = 128 | s30; + const SWord8 s32 = 127 & s30; + const SWord8 s33 = s29 ? s31 : s32; + const SBool s34 = sbv_bv_extract_u8_0_0_u1(s33); + const SBool s35 = false != s34; + const SBool s36 = !s35; + const SWord8 s37 = sbv_bv_u8_rotr(s24, 1); + const SWord8 s38 = 128 | s37; + const SWord8 s39 = 127 & s37; + const SWord8 s40 = s10 ? s38 : s39; + const SBool s41 = sbv_bv_extract_u8_0_0_u1(s40); + const SBool s42 = false != s41; + const SWord8 s43 = sbv_bv_u8_rotr(s27, 1); + const SWord8 s44 = 128 | s43; + const SWord8 s45 = 127 & s43; + const SWord8 s46 = s42 ? s44 : s45; + const SBool s47 = sbv_bv_extract_u8_0_0_u1(s46); + const SBool s48 = false != s47; + const SWord8 s49 = sbv_bv_u8_rotr(s33, 1); + const SWord8 s50 = 128 | s49; + const SWord8 s51 = 127 & s49; + const SWord8 s52 = s48 ? s50 : s51; + const SBool s53 = sbv_bv_extract_u8_0_0_u1(s52); + const SBool s54 = false != s53; + const SBool s55 = !s54; + const SWord8 s56 = sbv_bv_u8_rotr(s40, 1); + const SWord8 s57 = 128 | s56; + const SWord8 s58 = 127 & s56; + const SWord8 s59 = s15 ? s57 : s58; + const SBool s60 = sbv_bv_extract_u8_0_0_u1(s59); + const SBool s61 = false != s60; + const SWord8 s62 = sbv_bv_u8_rotr(s46, 1); + const SWord8 s63 = 128 | s62; + const SWord8 s64 = 127 & s62; + const SWord8 s65 = s61 ? s63 : s64; + const SBool s66 = sbv_bv_extract_u8_0_0_u1(s65); + const SBool s67 = false != s66; + const SWord8 s68 = sbv_bv_u8_rotr(s52, 1); + const SWord8 s69 = 128 | s68; + const SWord8 s70 = 127 & s68; + const SWord8 s71 = s67 ? s69 : s70; + const SBool s72 = sbv_bv_extract_u8_0_0_u1(s71); + const SBool s73 = false != s72; + const SBool s74 = !s73; + const SWord8 s75 = sbv_bv_u8_rotr(s59, 1); + const SWord8 s76 = 128 | s75; + const SWord8 s77 = 127 & s75; + const SWord8 s78 = s20 ? s76 : s77; + const SBool s79 = sbv_bv_extract_u8_0_0_u1(s78); + const SBool s80 = false != s79; + const SWord8 s81 = sbv_bv_u8_rotr(s65, 1); + const SWord8 s82 = 128 | s81; + const SWord8 s83 = 127 & s81; + const SWord8 s84 = s80 ? s82 : s83; + const SBool s85 = sbv_bv_extract_u8_0_0_u1(s84); + const SBool s86 = false != s85; + const SWord8 s87 = sbv_bv_u8_rotr(s71, 1); + const SWord8 s88 = 128 | s87; + const SWord8 s89 = 127 & s87; + const SWord8 s90 = s86 ? s88 : s89; + const SBool s91 = sbv_bv_extract_u8_0_0_u1(s90); + const SBool s92 = false != s91; + const SBool s93 = !s92; + const SWord8 s94 = sbv_bv_u8_rotr(s78, 1); + const SWord8 s95 = 128 | s94; + const SWord8 s96 = 127 & s94; + const SWord8 s97 = s35 ? s95 : s96; + const SWord8 s98 = sbv_bv_u8_rotr(s97, 1); + const SWord8 s99 = 128 | s98; + const SWord8 s100 = 127 & s98; + const SWord8 s101 = s54 ? s99 : s100; + const SWord8 s102 = sbv_bv_u8_rotr(s101, 1); + const SWord8 s103 = 128 | s102; + const SWord8 s104 = 127 & s102; + const SWord8 s105 = s73 ? s103 : s104; + const SWord8 s106 = sbv_bv_u8_rotr(s105, 1); + const SWord8 s107 = 128 | s106; + const SWord8 s108 = 127 & s106; + const SWord8 s109 = s92 ? s107 : s108; + const SWord8 s110 = sbv_bv_u8_add(s1, s105); + const SBool s111 = s110 < s1; + const SBool s112 = s110 < s105; + const SBool s113 = s111 || s112; + const SWord8 s114 = sbv_bv_u8_rotr(s110, 1); + 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 = sbv_bv_u8_add(s1, s101); + const SBool s120 = s119 < s1; + const SBool s121 = s119 < s101; + const SBool s122 = s120 || s121; + const SWord8 s123 = sbv_bv_u8_rotr(s119, 1); + const SWord8 s124 = 128 | s123; + const SWord8 s125 = 127 & s123; + const SWord8 s126 = s122 ? s124 : s125; + const SWord8 s127 = sbv_bv_u8_rotr(s126, 1); + const SWord8 s128 = 128 | s127; + const SWord8 s129 = 127 & s127; + const SWord8 s130 = s92 ? s128 : s129; + const SWord8 s131 = sbv_bv_u8_add(s1, s126); + const SBool s132 = s131 < s1; + const SBool s133 = s131 < s126; + const SBool s134 = s132 || s133; + const SWord8 s135 = sbv_bv_u8_rotr(s131, 1); + 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 = sbv_bv_u8_add(s1, s97); + const SBool s142 = s141 < s1; + const SBool s143 = s141 < s97; + const SBool s144 = s142 || s143; + const SWord8 s145 = sbv_bv_u8_rotr(s141, 1); + const SWord8 s146 = 128 | s145; + const SWord8 s147 = 127 & s145; + const SWord8 s148 = s144 ? s146 : s147; + const SWord8 s149 = sbv_bv_u8_rotr(s148, 1); + const SWord8 s150 = 128 | s149; + const SWord8 s151 = 127 & s149; + const SWord8 s152 = s73 ? s150 : s151; + const SWord8 s153 = sbv_bv_u8_rotr(s152, 1); + const SWord8 s154 = 128 | s153; + const SWord8 s155 = 127 & s153; + const SWord8 s156 = s92 ? s154 : s155; + const SWord8 s157 = sbv_bv_u8_add(s1, s152); + const SBool s158 = s157 < s1; + const SBool s159 = s157 < s152; + const SBool s160 = s158 || s159; + const SWord8 s161 = sbv_bv_u8_rotr(s157, 1); + 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 = sbv_bv_u8_add(s1, s148); + const SBool s167 = s166 < s1; + const SBool s168 = s166 < s148; + const SBool s169 = s167 || s168; + const SWord8 s170 = sbv_bv_u8_rotr(s166, 1); + const SWord8 s171 = 128 | s170; + const SWord8 s172 = 127 & s170; + const SWord8 s173 = s169 ? s171 : s172; + const SWord8 s174 = sbv_bv_u8_rotr(s173, 1); + const SWord8 s175 = 128 | s174; + const SWord8 s176 = 127 & s174; + const SWord8 s177 = s92 ? s175 : s176; + const SWord8 s178 = sbv_bv_u8_add(s1, s173); + const SBool s179 = s178 < s1; + const SBool s180 = s178 < s173; + const SBool s181 = s179 || s180; + const SWord8 s182 = sbv_bv_u8_rotr(s178, 1); + 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 = sbv_bv_u8_add(s1, s78); + const SBool s190 = sbv_bv_extract_u8_0_0_u1(s189); + const SBool s191 = false != s190; + const SWord8 s192 = s191 ? s82 : s83; + const SBool s193 = sbv_bv_extract_u8_0_0_u1(s192); + const SBool s194 = false != s193; + const SWord8 s195 = s194 ? s88 : s89; + const SBool s196 = sbv_bv_extract_u8_0_0_u1(s195); + const SBool s197 = false != s196; + const SBool s198 = !s197; + const SBool s199 = s189 < s1; + const SBool s200 = s189 < s78; + const SBool s201 = s199 || s200; + const SWord8 s202 = sbv_bv_u8_rotr(s189, 1); + const SWord8 s203 = 128 | s202; + const SWord8 s204 = 127 & s202; + const SWord8 s205 = s201 ? s203 : s204; + const SWord8 s206 = sbv_bv_u8_rotr(s205, 1); + const SWord8 s207 = 128 | s206; + const SWord8 s208 = 127 & s206; + const SWord8 s209 = s54 ? s207 : s208; + const SWord8 s210 = sbv_bv_u8_rotr(s209, 1); + const SWord8 s211 = 128 | s210; + const SWord8 s212 = 127 & s210; + const SWord8 s213 = s73 ? s211 : s212; + const SWord8 s214 = sbv_bv_u8_rotr(s213, 1); + const SWord8 s215 = 128 | s214; + const SWord8 s216 = 127 & s214; + const SWord8 s217 = s197 ? s215 : s216; + const SWord8 s218 = sbv_bv_u8_add(s1, s213); + const SBool s219 = s218 < s1; + const SBool s220 = s218 < s213; + const SBool s221 = s219 || s220; + const SWord8 s222 = sbv_bv_u8_rotr(s218, 1); + 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 = sbv_bv_u8_add(s1, s209); + const SBool s228 = s227 < s1; + const SBool s229 = s227 < s209; + const SBool s230 = s228 || s229; + const SWord8 s231 = sbv_bv_u8_rotr(s227, 1); + const SWord8 s232 = 128 | s231; + const SWord8 s233 = 127 & s231; + const SWord8 s234 = s230 ? s232 : s233; + const SWord8 s235 = sbv_bv_u8_rotr(s234, 1); + const SWord8 s236 = 128 | s235; + const SWord8 s237 = 127 & s235; + const SWord8 s238 = s197 ? s236 : s237; + const SWord8 s239 = sbv_bv_u8_add(s1, s234); + const SBool s240 = s239 < s1; + const SBool s241 = s239 < s234; + const SBool s242 = s240 || s241; + const SWord8 s243 = sbv_bv_u8_rotr(s239, 1); + 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 = sbv_bv_u8_add(s1, s205); + const SBool s250 = s249 < s1; + const SBool s251 = s249 < s205; + const SBool s252 = s250 || s251; + const SWord8 s253 = sbv_bv_u8_rotr(s249, 1); + const SWord8 s254 = 128 | s253; + const SWord8 s255 = 127 & s253; + const SWord8 s256 = s252 ? s254 : s255; + const SWord8 s257 = sbv_bv_u8_rotr(s256, 1); + const SWord8 s258 = 128 | s257; + const SWord8 s259 = 127 & s257; + const SWord8 s260 = s73 ? s258 : s259; + const SWord8 s261 = sbv_bv_u8_rotr(s260, 1); + const SWord8 s262 = 128 | s261; + const SWord8 s263 = 127 & s261; + const SWord8 s264 = s197 ? s262 : s263; + const SWord8 s265 = sbv_bv_u8_add(s1, s260); + const SBool s266 = s265 < s1; + const SBool s267 = s265 < s260; + const SBool s268 = s266 || s267; + const SWord8 s269 = sbv_bv_u8_rotr(s265, 1); + 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 = sbv_bv_u8_add(s1, s256); + const SBool s275 = s274 < s1; + const SBool s276 = s274 < s256; + const SBool s277 = s275 || s276; + const SWord8 s278 = sbv_bv_u8_rotr(s274, 1); + const SWord8 s279 = 128 | s278; + const SWord8 s280 = 127 & s278; + const SWord8 s281 = s277 ? s279 : s280; + const SWord8 s282 = sbv_bv_u8_rotr(s281, 1); + const SWord8 s283 = 128 | s282; + const SWord8 s284 = 127 & s282; + const SWord8 s285 = s197 ? s283 : s284; + const SWord8 s286 = sbv_bv_u8_add(s1, s281); + const SBool s287 = s286 < s1; + const SBool s288 = s286 < s281; + const SBool s289 = s287 || s288; + const SWord8 s290 = sbv_bv_u8_rotr(s286, 1); + 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 = sbv_bv_u8_add(s1, s59); + const SBool s299 = sbv_bv_extract_u8_0_0_u1(s298); + const SBool s300 = false != s299; + const SWord8 s301 = s300 ? s63 : s64; + const SBool s302 = sbv_bv_extract_u8_0_0_u1(s301); + const SBool s303 = false != s302; + const SWord8 s304 = s303 ? s69 : s70; + const SBool s305 = sbv_bv_extract_u8_0_0_u1(s304); + const SBool s306 = false != s305; + const SBool s307 = !s306; + const SBool s308 = s298 < s1; + const SBool s309 = s298 < s59; + const SBool s310 = s308 || s309; + const SWord8 s311 = sbv_bv_u8_rotr(s298, 1); + const SWord8 s312 = 128 | s311; + const SWord8 s313 = 127 & s311; + const SWord8 s314 = s310 ? s312 : s313; + const SBool s315 = sbv_bv_extract_u8_0_0_u1(s314); + const SBool s316 = false != s315; + const SWord8 s317 = sbv_bv_u8_rotr(s301, 1); + const SWord8 s318 = 128 | s317; + const SWord8 s319 = 127 & s317; + const SWord8 s320 = s316 ? s318 : s319; + const SBool s321 = sbv_bv_extract_u8_0_0_u1(s320); + const SBool s322 = false != s321; + const SWord8 s323 = sbv_bv_u8_rotr(s304, 1); + const SWord8 s324 = 128 | s323; + const SWord8 s325 = 127 & s323; + const SWord8 s326 = s322 ? s324 : s325; + const SBool s327 = sbv_bv_extract_u8_0_0_u1(s326); + const SBool s328 = false != s327; + const SBool s329 = !s328; + const SWord8 s330 = sbv_bv_u8_rotr(s314, 1); + const SWord8 s331 = 128 | s330; + const SWord8 s332 = 127 & s330; + const SWord8 s333 = s35 ? s331 : s332; + const SWord8 s334 = sbv_bv_u8_rotr(s333, 1); + const SWord8 s335 = 128 | s334; + const SWord8 s336 = 127 & s334; + const SWord8 s337 = s54 ? s335 : s336; + const SWord8 s338 = sbv_bv_u8_rotr(s337, 1); + const SWord8 s339 = 128 | s338; + const SWord8 s340 = 127 & s338; + const SWord8 s341 = s306 ? s339 : s340; + const SWord8 s342 = sbv_bv_u8_rotr(s341, 1); + const SWord8 s343 = 128 | s342; + const SWord8 s344 = 127 & s342; + const SWord8 s345 = s328 ? s343 : s344; + const SWord8 s346 = sbv_bv_u8_add(s1, s341); + const SBool s347 = s346 < s1; + const SBool s348 = s346 < s341; + const SBool s349 = s347 || s348; + const SWord8 s350 = sbv_bv_u8_rotr(s346, 1); + 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 = sbv_bv_u8_add(s1, s337); + const SBool s356 = s355 < s1; + const SBool s357 = s355 < s337; + const SBool s358 = s356 || s357; + const SWord8 s359 = sbv_bv_u8_rotr(s355, 1); + const SWord8 s360 = 128 | s359; + const SWord8 s361 = 127 & s359; + const SWord8 s362 = s358 ? s360 : s361; + const SWord8 s363 = sbv_bv_u8_rotr(s362, 1); + const SWord8 s364 = 128 | s363; + const SWord8 s365 = 127 & s363; + const SWord8 s366 = s328 ? s364 : s365; + const SWord8 s367 = sbv_bv_u8_add(s1, s362); + const SBool s368 = s367 < s1; + const SBool s369 = s367 < s362; + const SBool s370 = s368 || s369; + const SWord8 s371 = sbv_bv_u8_rotr(s367, 1); + 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 = sbv_bv_u8_add(s1, s333); + const SBool s378 = s377 < s1; + const SBool s379 = s377 < s333; + const SBool s380 = s378 || s379; + const SWord8 s381 = sbv_bv_u8_rotr(s377, 1); + const SWord8 s382 = 128 | s381; + const SWord8 s383 = 127 & s381; + const SWord8 s384 = s380 ? s382 : s383; + const SWord8 s385 = sbv_bv_u8_rotr(s384, 1); + const SWord8 s386 = 128 | s385; + const SWord8 s387 = 127 & s385; + const SWord8 s388 = s306 ? s386 : s387; + const SWord8 s389 = sbv_bv_u8_rotr(s388, 1); + const SWord8 s390 = 128 | s389; + const SWord8 s391 = 127 & s389; + const SWord8 s392 = s328 ? s390 : s391; + const SWord8 s393 = sbv_bv_u8_add(s1, s388); + const SBool s394 = s393 < s1; + const SBool s395 = s393 < s388; + const SBool s396 = s394 || s395; + const SWord8 s397 = sbv_bv_u8_rotr(s393, 1); + 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 = sbv_bv_u8_add(s1, s384); + const SBool s403 = s402 < s1; + const SBool s404 = s402 < s384; + const SBool s405 = s403 || s404; + const SWord8 s406 = sbv_bv_u8_rotr(s402, 1); + const SWord8 s407 = 128 | s406; + const SWord8 s408 = 127 & s406; + const SWord8 s409 = s405 ? s407 : s408; + const SWord8 s410 = sbv_bv_u8_rotr(s409, 1); + const SWord8 s411 = 128 | s410; + const SWord8 s412 = 127 & s410; + const SWord8 s413 = s328 ? s411 : s412; + const SWord8 s414 = sbv_bv_u8_add(s1, s409); + const SBool s415 = s414 < s1; + const SBool s416 = s414 < s409; + const SBool s417 = s415 || s416; + const SWord8 s418 = sbv_bv_u8_rotr(s414, 1); + 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 = sbv_bv_u8_add(s1, s314); + const SBool s426 = sbv_bv_extract_u8_0_0_u1(s425); + const SBool s427 = false != s426; + const SWord8 s428 = s427 ? s318 : s319; + const SBool s429 = sbv_bv_extract_u8_0_0_u1(s428); + const SBool s430 = false != s429; + const SWord8 s431 = s430 ? s324 : s325; + const SBool s432 = sbv_bv_extract_u8_0_0_u1(s431); + const SBool s433 = false != s432; + const SBool s434 = !s433; + const SBool s435 = s425 < s1; + const SBool s436 = s425 < s314; + const SBool s437 = s435 || s436; + const SWord8 s438 = sbv_bv_u8_rotr(s425, 1); + const SWord8 s439 = 128 | s438; + const SWord8 s440 = 127 & s438; + const SWord8 s441 = s437 ? s439 : s440; + const SWord8 s442 = sbv_bv_u8_rotr(s441, 1); + const SWord8 s443 = 128 | s442; + const SWord8 s444 = 127 & s442; + const SWord8 s445 = s54 ? s443 : s444; + const SWord8 s446 = sbv_bv_u8_rotr(s445, 1); + const SWord8 s447 = 128 | s446; + const SWord8 s448 = 127 & s446; + const SWord8 s449 = s306 ? s447 : s448; + const SWord8 s450 = sbv_bv_u8_rotr(s449, 1); + const SWord8 s451 = 128 | s450; + const SWord8 s452 = 127 & s450; + const SWord8 s453 = s433 ? s451 : s452; + const SWord8 s454 = sbv_bv_u8_add(s1, s449); + const SBool s455 = s454 < s1; + const SBool s456 = s454 < s449; + const SBool s457 = s455 || s456; + const SWord8 s458 = sbv_bv_u8_rotr(s454, 1); + 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 = sbv_bv_u8_add(s1, s445); + const SBool s464 = s463 < s1; + const SBool s465 = s463 < s445; + const SBool s466 = s464 || s465; + const SWord8 s467 = sbv_bv_u8_rotr(s463, 1); + const SWord8 s468 = 128 | s467; + const SWord8 s469 = 127 & s467; + const SWord8 s470 = s466 ? s468 : s469; + const SWord8 s471 = sbv_bv_u8_rotr(s470, 1); + const SWord8 s472 = 128 | s471; + const SWord8 s473 = 127 & s471; + const SWord8 s474 = s433 ? s472 : s473; + const SWord8 s475 = sbv_bv_u8_add(s1, s470); + const SBool s476 = s475 < s1; + const SBool s477 = s475 < s470; + const SBool s478 = s476 || s477; + const SWord8 s479 = sbv_bv_u8_rotr(s475, 1); + 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 = sbv_bv_u8_add(s1, s441); + const SBool s486 = s485 < s1; + const SBool s487 = s485 < s441; + const SBool s488 = s486 || s487; + const SWord8 s489 = sbv_bv_u8_rotr(s485, 1); + const SWord8 s490 = 128 | s489; + const SWord8 s491 = 127 & s489; + const SWord8 s492 = s488 ? s490 : s491; + const SWord8 s493 = sbv_bv_u8_rotr(s492, 1); + const SWord8 s494 = 128 | s493; + const SWord8 s495 = 127 & s493; + const SWord8 s496 = s306 ? s494 : s495; + const SWord8 s497 = sbv_bv_u8_rotr(s496, 1); + const SWord8 s498 = 128 | s497; + const SWord8 s499 = 127 & s497; + const SWord8 s500 = s433 ? s498 : s499; + const SWord8 s501 = sbv_bv_u8_add(s1, s496); + const SBool s502 = s501 < s1; + const SBool s503 = s501 < s496; + const SBool s504 = s502 || s503; + const SWord8 s505 = sbv_bv_u8_rotr(s501, 1); + 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 = sbv_bv_u8_add(s1, s492); + const SBool s511 = s510 < s1; + const SBool s512 = s510 < s492; + const SBool s513 = s511 || s512; + const SWord8 s514 = sbv_bv_u8_rotr(s510, 1); + const SWord8 s515 = 128 | s514; + const SWord8 s516 = 127 & s514; + const SWord8 s517 = s513 ? s515 : s516; + const SWord8 s518 = sbv_bv_u8_rotr(s517, 1); + const SWord8 s519 = 128 | s518; + const SWord8 s520 = 127 & s518; + const SWord8 s521 = s433 ? s519 : s520; + const SWord8 s522 = sbv_bv_u8_add(s1, s517); + const SBool s523 = s522 < s1; + const SBool s524 = s522 < s517; + const SBool s525 = s523 || s524; + const SWord8 s526 = sbv_bv_u8_rotr(s522, 1); + const SWord8 s527 = 128 | s526; + const SWord8 s528 = 127 & s526; + const SWord8 s529 = s525 ? s527 : s528; + const SWord8 s530 = s434 ? s521 : s529; + const SWord8 s531 = s307 ? s509 : s530; + const SWord8 s532 = s55 ? s484 : s531; + const SWord8 s533 = s36 ? s424 : s532; + const SWord8 s534 = s21 ? s297 : s533; + const SWord8 s535 = sbv_bv_u8_add(s1, s40); + const SBool s536 = sbv_bv_extract_u8_0_0_u1(s535); + const SBool s537 = false != s536; + const SWord8 s538 = s537 ? s44 : s45; + const SBool s539 = sbv_bv_extract_u8_0_0_u1(s538); + const SBool s540 = false != s539; + const SWord8 s541 = s540 ? s50 : s51; + const SBool s542 = sbv_bv_extract_u8_0_0_u1(s541); + const SBool s543 = false != s542; + const SBool s544 = !s543; + const SBool s545 = s535 < s1; + const SBool s546 = s535 < s40; + const SBool s547 = s545 || s546; + const SWord8 s548 = sbv_bv_u8_rotr(s535, 1); + const SWord8 s549 = 128 | s548; + const SWord8 s550 = 127 & s548; + const SWord8 s551 = s547 ? s549 : s550; + const SBool s552 = sbv_bv_extract_u8_0_0_u1(s551); + const SBool s553 = false != s552; + const SWord8 s554 = sbv_bv_u8_rotr(s538, 1); + const SWord8 s555 = 128 | s554; + const SWord8 s556 = 127 & s554; + const SWord8 s557 = s553 ? s555 : s556; + const SBool s558 = sbv_bv_extract_u8_0_0_u1(s557); + const SBool s559 = false != s558; + const SWord8 s560 = sbv_bv_u8_rotr(s541, 1); + const SWord8 s561 = 128 | s560; + const SWord8 s562 = 127 & s560; + const SWord8 s563 = s559 ? s561 : s562; + const SBool s564 = sbv_bv_extract_u8_0_0_u1(s563); + const SBool s565 = false != s564; + const SBool s566 = !s565; + const SWord8 s567 = sbv_bv_u8_rotr(s551, 1); + const SWord8 s568 = 128 | s567; + const SWord8 s569 = 127 & s567; + const SWord8 s570 = s20 ? s568 : s569; + const SBool s571 = sbv_bv_extract_u8_0_0_u1(s570); + const SBool s572 = false != s571; + const SWord8 s573 = sbv_bv_u8_rotr(s557, 1); + const SWord8 s574 = 128 | s573; + const SWord8 s575 = 127 & s573; + const SWord8 s576 = s572 ? s574 : s575; + const SBool s577 = sbv_bv_extract_u8_0_0_u1(s576); + const SBool s578 = false != s577; + const SWord8 s579 = sbv_bv_u8_rotr(s563, 1); + const SWord8 s580 = 128 | s579; + const SWord8 s581 = 127 & s579; + const SWord8 s582 = s578 ? s580 : s581; + const SBool s583 = sbv_bv_extract_u8_0_0_u1(s582); + const SBool s584 = false != s583; + const SBool s585 = !s584; + const SWord8 s586 = sbv_bv_u8_rotr(s570, 1); + const SWord8 s587 = 128 | s586; + const SWord8 s588 = 127 & s586; + const SWord8 s589 = s35 ? s587 : s588; + const SWord8 s590 = sbv_bv_u8_rotr(s589, 1); + const SWord8 s591 = 128 | s590; + const SWord8 s592 = 127 & s590; + const SWord8 s593 = s543 ? s591 : s592; + const SWord8 s594 = sbv_bv_u8_rotr(s593, 1); + const SWord8 s595 = 128 | s594; + const SWord8 s596 = 127 & s594; + const SWord8 s597 = s565 ? s595 : s596; + const SWord8 s598 = sbv_bv_u8_rotr(s597, 1); + const SWord8 s599 = 128 | s598; + const SWord8 s600 = 127 & s598; + const SWord8 s601 = s584 ? s599 : s600; + const SWord8 s602 = sbv_bv_u8_add(s1, s597); + const SBool s603 = s602 < s1; + const SBool s604 = s602 < s597; + const SBool s605 = s603 || s604; + const SWord8 s606 = sbv_bv_u8_rotr(s602, 1); + 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 = sbv_bv_u8_add(s1, s593); + const SBool s612 = s611 < s1; + const SBool s613 = s611 < s593; + const SBool s614 = s612 || s613; + const SWord8 s615 = sbv_bv_u8_rotr(s611, 1); + const SWord8 s616 = 128 | s615; + const SWord8 s617 = 127 & s615; + const SWord8 s618 = s614 ? s616 : s617; + const SWord8 s619 = sbv_bv_u8_rotr(s618, 1); + const SWord8 s620 = 128 | s619; + const SWord8 s621 = 127 & s619; + const SWord8 s622 = s584 ? s620 : s621; + const SWord8 s623 = sbv_bv_u8_add(s1, s618); + const SBool s624 = s623 < s1; + const SBool s625 = s623 < s618; + const SBool s626 = s624 || s625; + const SWord8 s627 = sbv_bv_u8_rotr(s623, 1); + 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 = sbv_bv_u8_add(s1, s589); + const SBool s634 = s633 < s1; + const SBool s635 = s633 < s589; + const SBool s636 = s634 || s635; + const SWord8 s637 = sbv_bv_u8_rotr(s633, 1); + const SWord8 s638 = 128 | s637; + const SWord8 s639 = 127 & s637; + const SWord8 s640 = s636 ? s638 : s639; + const SWord8 s641 = sbv_bv_u8_rotr(s640, 1); + const SWord8 s642 = 128 | s641; + const SWord8 s643 = 127 & s641; + const SWord8 s644 = s565 ? s642 : s643; + const SWord8 s645 = sbv_bv_u8_rotr(s644, 1); + const SWord8 s646 = 128 | s645; + const SWord8 s647 = 127 & s645; + const SWord8 s648 = s584 ? s646 : s647; + const SWord8 s649 = sbv_bv_u8_add(s1, s644); + const SBool s650 = s649 < s1; + const SBool s651 = s649 < s644; + const SBool s652 = s650 || s651; + const SWord8 s653 = sbv_bv_u8_rotr(s649, 1); + 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 = sbv_bv_u8_add(s1, s640); + const SBool s659 = s658 < s1; + const SBool s660 = s658 < s640; + const SBool s661 = s659 || s660; + const SWord8 s662 = sbv_bv_u8_rotr(s658, 1); + const SWord8 s663 = 128 | s662; + const SWord8 s664 = 127 & s662; + const SWord8 s665 = s661 ? s663 : s664; + const SWord8 s666 = sbv_bv_u8_rotr(s665, 1); + const SWord8 s667 = 128 | s666; + const SWord8 s668 = 127 & s666; + const SWord8 s669 = s584 ? s667 : s668; + const SWord8 s670 = sbv_bv_u8_add(s1, s665); + const SBool s671 = s670 < s1; + const SBool s672 = s670 < s665; + const SBool s673 = s671 || s672; + const SWord8 s674 = sbv_bv_u8_rotr(s670, 1); + 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 = sbv_bv_u8_add(s1, s570); + const SBool s682 = sbv_bv_extract_u8_0_0_u1(s681); + const SBool s683 = false != s682; + const SWord8 s684 = s683 ? s574 : s575; + const SBool s685 = sbv_bv_extract_u8_0_0_u1(s684); + const SBool s686 = false != s685; + const SWord8 s687 = s686 ? s580 : s581; + const SBool s688 = sbv_bv_extract_u8_0_0_u1(s687); + const SBool s689 = false != s688; + const SBool s690 = !s689; + const SBool s691 = s681 < s1; + const SBool s692 = s681 < s570; + const SBool s693 = s691 || s692; + const SWord8 s694 = sbv_bv_u8_rotr(s681, 1); + const SWord8 s695 = 128 | s694; + const SWord8 s696 = 127 & s694; + const SWord8 s697 = s693 ? s695 : s696; + const SWord8 s698 = sbv_bv_u8_rotr(s697, 1); + const SWord8 s699 = 128 | s698; + const SWord8 s700 = 127 & s698; + const SWord8 s701 = s543 ? s699 : s700; + const SWord8 s702 = sbv_bv_u8_rotr(s701, 1); + const SWord8 s703 = 128 | s702; + const SWord8 s704 = 127 & s702; + const SWord8 s705 = s565 ? s703 : s704; + const SWord8 s706 = sbv_bv_u8_rotr(s705, 1); + const SWord8 s707 = 128 | s706; + const SWord8 s708 = 127 & s706; + const SWord8 s709 = s689 ? s707 : s708; + const SWord8 s710 = sbv_bv_u8_add(s1, s705); + const SBool s711 = s710 < s1; + const SBool s712 = s710 < s705; + const SBool s713 = s711 || s712; + const SWord8 s714 = sbv_bv_u8_rotr(s710, 1); + 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 = sbv_bv_u8_add(s1, s701); + const SBool s720 = s719 < s1; + const SBool s721 = s719 < s701; + const SBool s722 = s720 || s721; + const SWord8 s723 = sbv_bv_u8_rotr(s719, 1); + const SWord8 s724 = 128 | s723; + const SWord8 s725 = 127 & s723; + const SWord8 s726 = s722 ? s724 : s725; + const SWord8 s727 = sbv_bv_u8_rotr(s726, 1); + const SWord8 s728 = 128 | s727; + const SWord8 s729 = 127 & s727; + const SWord8 s730 = s689 ? s728 : s729; + const SWord8 s731 = sbv_bv_u8_add(s1, s726); + const SBool s732 = s731 < s1; + const SBool s733 = s731 < s726; + const SBool s734 = s732 || s733; + const SWord8 s735 = sbv_bv_u8_rotr(s731, 1); + 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 = sbv_bv_u8_add(s1, s697); + const SBool s742 = s741 < s1; + const SBool s743 = s741 < s697; + const SBool s744 = s742 || s743; + const SWord8 s745 = sbv_bv_u8_rotr(s741, 1); + const SWord8 s746 = 128 | s745; + const SWord8 s747 = 127 & s745; + const SWord8 s748 = s744 ? s746 : s747; + const SWord8 s749 = sbv_bv_u8_rotr(s748, 1); + const SWord8 s750 = 128 | s749; + const SWord8 s751 = 127 & s749; + const SWord8 s752 = s565 ? s750 : s751; + const SWord8 s753 = sbv_bv_u8_rotr(s752, 1); + const SWord8 s754 = 128 | s753; + const SWord8 s755 = 127 & s753; + const SWord8 s756 = s689 ? s754 : s755; + const SWord8 s757 = sbv_bv_u8_add(s1, s752); + const SBool s758 = s757 < s1; + const SBool s759 = s757 < s752; + const SBool s760 = s758 || s759; + const SWord8 s761 = sbv_bv_u8_rotr(s757, 1); + 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 = sbv_bv_u8_add(s1, s748); + const SBool s767 = s766 < s1; + const SBool s768 = s766 < s748; + const SBool s769 = s767 || s768; + const SWord8 s770 = sbv_bv_u8_rotr(s766, 1); + const SWord8 s771 = 128 | s770; + const SWord8 s772 = 127 & s770; + const SWord8 s773 = s769 ? s771 : s772; + const SWord8 s774 = sbv_bv_u8_rotr(s773, 1); + const SWord8 s775 = 128 | s774; + const SWord8 s776 = 127 & s774; + const SWord8 s777 = s689 ? s775 : s776; + const SWord8 s778 = sbv_bv_u8_add(s1, s773); + const SBool s779 = s778 < s1; + const SBool s780 = s778 < s773; + const SBool s781 = s779 || s780; + const SWord8 s782 = sbv_bv_u8_rotr(s778, 1); + 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 = sbv_bv_u8_add(s1, s551); + const SBool s791 = sbv_bv_extract_u8_0_0_u1(s790); + const SBool s792 = false != s791; + const SWord8 s793 = s792 ? s555 : s556; + const SBool s794 = sbv_bv_extract_u8_0_0_u1(s793); + const SBool s795 = false != s794; + const SWord8 s796 = s795 ? s561 : s562; + const SBool s797 = sbv_bv_extract_u8_0_0_u1(s796); + const SBool s798 = false != s797; + const SBool s799 = !s798; + const SBool s800 = s790 < s1; + const SBool s801 = s790 < s551; + const SBool s802 = s800 || s801; + const SWord8 s803 = sbv_bv_u8_rotr(s790, 1); + const SWord8 s804 = 128 | s803; + const SWord8 s805 = 127 & s803; + const SWord8 s806 = s802 ? s804 : s805; + const SBool s807 = sbv_bv_extract_u8_0_0_u1(s806); + const SBool s808 = false != s807; + const SWord8 s809 = sbv_bv_u8_rotr(s793, 1); + const SWord8 s810 = 128 | s809; + const SWord8 s811 = 127 & s809; + const SWord8 s812 = s808 ? s810 : s811; + const SBool s813 = sbv_bv_extract_u8_0_0_u1(s812); + const SBool s814 = false != s813; + const SWord8 s815 = sbv_bv_u8_rotr(s796, 1); + const SWord8 s816 = 128 | s815; + const SWord8 s817 = 127 & s815; + const SWord8 s818 = s814 ? s816 : s817; + const SBool s819 = sbv_bv_extract_u8_0_0_u1(s818); + const SBool s820 = false != s819; + const SBool s821 = !s820; + const SWord8 s822 = sbv_bv_u8_rotr(s806, 1); + const SWord8 s823 = 128 | s822; + const SWord8 s824 = 127 & s822; + const SWord8 s825 = s35 ? s823 : s824; + const SWord8 s826 = sbv_bv_u8_rotr(s825, 1); + const SWord8 s827 = 128 | s826; + const SWord8 s828 = 127 & s826; + const SWord8 s829 = s543 ? s827 : s828; + const SWord8 s830 = sbv_bv_u8_rotr(s829, 1); + const SWord8 s831 = 128 | s830; + const SWord8 s832 = 127 & s830; + const SWord8 s833 = s798 ? s831 : s832; + const SWord8 s834 = sbv_bv_u8_rotr(s833, 1); + const SWord8 s835 = 128 | s834; + const SWord8 s836 = 127 & s834; + const SWord8 s837 = s820 ? s835 : s836; + const SWord8 s838 = sbv_bv_u8_add(s1, s833); + const SBool s839 = s838 < s1; + const SBool s840 = s838 < s833; + const SBool s841 = s839 || s840; + const SWord8 s842 = sbv_bv_u8_rotr(s838, 1); + 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 = sbv_bv_u8_add(s1, s829); + const SBool s848 = s847 < s1; + const SBool s849 = s847 < s829; + const SBool s850 = s848 || s849; + const SWord8 s851 = sbv_bv_u8_rotr(s847, 1); + const SWord8 s852 = 128 | s851; + const SWord8 s853 = 127 & s851; + const SWord8 s854 = s850 ? s852 : s853; + const SWord8 s855 = sbv_bv_u8_rotr(s854, 1); + const SWord8 s856 = 128 | s855; + const SWord8 s857 = 127 & s855; + const SWord8 s858 = s820 ? s856 : s857; + const SWord8 s859 = sbv_bv_u8_add(s1, s854); + const SBool s860 = s859 < s1; + const SBool s861 = s859 < s854; + const SBool s862 = s860 || s861; + const SWord8 s863 = sbv_bv_u8_rotr(s859, 1); + 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 = sbv_bv_u8_add(s1, s825); + const SBool s870 = s869 < s1; + const SBool s871 = s869 < s825; + const SBool s872 = s870 || s871; + const SWord8 s873 = sbv_bv_u8_rotr(s869, 1); + const SWord8 s874 = 128 | s873; + const SWord8 s875 = 127 & s873; + const SWord8 s876 = s872 ? s874 : s875; + const SWord8 s877 = sbv_bv_u8_rotr(s876, 1); + const SWord8 s878 = 128 | s877; + const SWord8 s879 = 127 & s877; + const SWord8 s880 = s798 ? s878 : s879; + const SWord8 s881 = sbv_bv_u8_rotr(s880, 1); + const SWord8 s882 = 128 | s881; + const SWord8 s883 = 127 & s881; + const SWord8 s884 = s820 ? s882 : s883; + const SWord8 s885 = sbv_bv_u8_add(s1, s880); + const SBool s886 = s885 < s1; + const SBool s887 = s885 < s880; + const SBool s888 = s886 || s887; + const SWord8 s889 = sbv_bv_u8_rotr(s885, 1); + 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 = sbv_bv_u8_add(s1, s876); + const SBool s895 = s894 < s1; + const SBool s896 = s894 < s876; + const SBool s897 = s895 || s896; + const SWord8 s898 = sbv_bv_u8_rotr(s894, 1); + const SWord8 s899 = 128 | s898; + const SWord8 s900 = 127 & s898; + const SWord8 s901 = s897 ? s899 : s900; + const SWord8 s902 = sbv_bv_u8_rotr(s901, 1); + const SWord8 s903 = 128 | s902; + const SWord8 s904 = 127 & s902; + const SWord8 s905 = s820 ? s903 : s904; + const SWord8 s906 = sbv_bv_u8_add(s1, s901); + const SBool s907 = s906 < s1; + const SBool s908 = s906 < s901; + const SBool s909 = s907 || s908; + const SWord8 s910 = sbv_bv_u8_rotr(s906, 1); + 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 = sbv_bv_u8_add(s1, s806); + const SBool s918 = sbv_bv_extract_u8_0_0_u1(s917); + const SBool s919 = false != s918; + const SWord8 s920 = s919 ? s810 : s811; + const SBool s921 = sbv_bv_extract_u8_0_0_u1(s920); + const SBool s922 = false != s921; + const SWord8 s923 = s922 ? s816 : s817; + const SBool s924 = sbv_bv_extract_u8_0_0_u1(s923); + const SBool s925 = false != s924; + const SBool s926 = !s925; + const SBool s927 = s917 < s1; + const SBool s928 = s917 < s806; + const SBool s929 = s927 || s928; + const SWord8 s930 = sbv_bv_u8_rotr(s917, 1); + const SWord8 s931 = 128 | s930; + const SWord8 s932 = 127 & s930; + const SWord8 s933 = s929 ? s931 : s932; + const SWord8 s934 = sbv_bv_u8_rotr(s933, 1); + const SWord8 s935 = 128 | s934; + const SWord8 s936 = 127 & s934; + const SWord8 s937 = s543 ? s935 : s936; + const SWord8 s938 = sbv_bv_u8_rotr(s937, 1); + const SWord8 s939 = 128 | s938; + const SWord8 s940 = 127 & s938; + const SWord8 s941 = s798 ? s939 : s940; + const SWord8 s942 = sbv_bv_u8_rotr(s941, 1); + const SWord8 s943 = 128 | s942; + const SWord8 s944 = 127 & s942; + const SWord8 s945 = s925 ? s943 : s944; + const SWord8 s946 = sbv_bv_u8_add(s1, s941); + const SBool s947 = s946 < s1; + const SBool s948 = s946 < s941; + const SBool s949 = s947 || s948; + const SWord8 s950 = sbv_bv_u8_rotr(s946, 1); + 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 = sbv_bv_u8_add(s1, s937); + const SBool s956 = s955 < s1; + const SBool s957 = s955 < s937; + const SBool s958 = s956 || s957; + const SWord8 s959 = sbv_bv_u8_rotr(s955, 1); + const SWord8 s960 = 128 | s959; + const SWord8 s961 = 127 & s959; + const SWord8 s962 = s958 ? s960 : s961; + const SWord8 s963 = sbv_bv_u8_rotr(s962, 1); + const SWord8 s964 = 128 | s963; + const SWord8 s965 = 127 & s963; + const SWord8 s966 = s925 ? s964 : s965; + const SWord8 s967 = sbv_bv_u8_add(s1, s962); + const SBool s968 = s967 < s1; + const SBool s969 = s967 < s962; + const SBool s970 = s968 || s969; + const SWord8 s971 = sbv_bv_u8_rotr(s967, 1); + 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 = sbv_bv_u8_add(s1, s933); + const SBool s978 = s977 < s1; + const SBool s979 = s977 < s933; + const SBool s980 = s978 || s979; + const SWord8 s981 = sbv_bv_u8_rotr(s977, 1); + const SWord8 s982 = 128 | s981; + const SWord8 s983 = 127 & s981; + const SWord8 s984 = s980 ? s982 : s983; + const SWord8 s985 = sbv_bv_u8_rotr(s984, 1); + const SWord8 s986 = 128 | s985; + const SWord8 s987 = 127 & s985; + const SWord8 s988 = s798 ? s986 : s987; + const SWord8 s989 = sbv_bv_u8_rotr(s988, 1); + const SWord8 s990 = 128 | s989; + const SWord8 s991 = 127 & s989; + const SWord8 s992 = s925 ? s990 : s991; + const SWord8 s993 = sbv_bv_u8_add(s1, s988); + const SBool s994 = s993 < s1; + const SBool s995 = s993 < s988; + const SBool s996 = s994 || s995; + const SWord8 s997 = sbv_bv_u8_rotr(s993, 1); + 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 = sbv_bv_u8_add(s1, s984); + const SBool s1003 = s1002 < s1; + const SBool s1004 = s1002 < s984; + const SBool s1005 = s1003 || s1004; + const SWord8 s1006 = sbv_bv_u8_rotr(s1002, 1); + const SWord8 s1007 = 128 | s1006; + const SWord8 s1008 = 127 & s1006; + const SWord8 s1009 = s1005 ? s1007 : s1008; + const SWord8 s1010 = sbv_bv_u8_rotr(s1009, 1); + const SWord8 s1011 = 128 | s1010; + const SWord8 s1012 = 127 & s1010; + const SWord8 s1013 = s925 ? s1011 : s1012; + const SWord8 s1014 = sbv_bv_u8_add(s1, s1009); + const SBool s1015 = s1014 < s1; + const SBool s1016 = s1014 < s1009; + const SBool s1017 = s1015 || s1016; + const SWord8 s1018 = sbv_bv_u8_rotr(s1014, 1); + const SWord8 s1019 = 128 | s1018; + const SWord8 s1020 = 127 & s1018; + const SWord8 s1021 = s1017 ? s1019 : s1020; + const SWord8 s1022 = s926 ? s1013 : s1021; + const SWord8 s1023 = s799 ? s1001 : s1022; + const SWord8 s1024 = s544 ? s976 : s1023; + const SWord8 s1025 = s36 ? s916 : s1024; + const SWord8 s1026 = s21 ? s789 : s1025; + const SWord8 s1027 = s16 ? s534 : s1026; + const SWord8 s1028 = sbv_bv_u8_add(s1, s24); + const SBool s1029 = sbv_bv_extract_u8_0_0_u1(s1028); + const SBool s1030 = false != s1029; + const SWord8 s1031 = s1030 ? 128 : 0; + const SBool s1032 = sbv_bv_extract_u8_0_0_u1(s1031); + const SBool s1033 = false != s1032; + const SWord8 s1034 = s1033 ? s31 : s32; + const SBool s1035 = sbv_bv_extract_u8_0_0_u1(s1034); + const SBool s1036 = false != s1035; + const SBool s1037 = !s1036; + const SBool s1038 = s1028 < s1; + const SBool s1039 = s1028 < s24; + const SBool s1040 = s1038 || s1039; + const SWord8 s1041 = sbv_bv_u8_rotr(s1028, 1); + const SWord8 s1042 = 128 | s1041; + const SWord8 s1043 = 127 & s1041; + const SWord8 s1044 = s1040 ? s1042 : s1043; + const SBool s1045 = sbv_bv_extract_u8_0_0_u1(s1044); + const SBool s1046 = false != s1045; + const SWord8 s1047 = sbv_bv_u8_rotr(s1031, 1); + const SWord8 s1048 = 128 | s1047; + const SWord8 s1049 = 127 & s1047; + const SWord8 s1050 = s1046 ? s1048 : s1049; + const SBool s1051 = sbv_bv_extract_u8_0_0_u1(s1050); + const SBool s1052 = false != s1051; + const SWord8 s1053 = sbv_bv_u8_rotr(s1034, 1); + const SWord8 s1054 = 128 | s1053; + const SWord8 s1055 = 127 & s1053; + const SWord8 s1056 = s1052 ? s1054 : s1055; + const SBool s1057 = sbv_bv_extract_u8_0_0_u1(s1056); + const SBool s1058 = false != s1057; + const SBool s1059 = !s1058; + const SWord8 s1060 = sbv_bv_u8_rotr(s1044, 1); + const SWord8 s1061 = 128 | s1060; + const SWord8 s1062 = 127 & s1060; + const SWord8 s1063 = s15 ? s1061 : s1062; + const SBool s1064 = sbv_bv_extract_u8_0_0_u1(s1063); + const SBool s1065 = false != s1064; + const SWord8 s1066 = sbv_bv_u8_rotr(s1050, 1); + const SWord8 s1067 = 128 | s1066; + const SWord8 s1068 = 127 & s1066; + const SWord8 s1069 = s1065 ? s1067 : s1068; + const SBool s1070 = sbv_bv_extract_u8_0_0_u1(s1069); + const SBool s1071 = false != s1070; + const SWord8 s1072 = sbv_bv_u8_rotr(s1056, 1); + const SWord8 s1073 = 128 | s1072; + const SWord8 s1074 = 127 & s1072; + const SWord8 s1075 = s1071 ? s1073 : s1074; + const SBool s1076 = sbv_bv_extract_u8_0_0_u1(s1075); + const SBool s1077 = false != s1076; + const SBool s1078 = !s1077; + const SWord8 s1079 = sbv_bv_u8_rotr(s1063, 1); + const SWord8 s1080 = 128 | s1079; + const SWord8 s1081 = 127 & s1079; + const SWord8 s1082 = s20 ? s1080 : s1081; + const SBool s1083 = sbv_bv_extract_u8_0_0_u1(s1082); + const SBool s1084 = false != s1083; + const SWord8 s1085 = sbv_bv_u8_rotr(s1069, 1); + const SWord8 s1086 = 128 | s1085; + const SWord8 s1087 = 127 & s1085; + const SWord8 s1088 = s1084 ? s1086 : s1087; + const SBool s1089 = sbv_bv_extract_u8_0_0_u1(s1088); + const SBool s1090 = false != s1089; + const SWord8 s1091 = sbv_bv_u8_rotr(s1075, 1); + const SWord8 s1092 = 128 | s1091; + const SWord8 s1093 = 127 & s1091; + const SWord8 s1094 = s1090 ? s1092 : s1093; + const SBool s1095 = sbv_bv_extract_u8_0_0_u1(s1094); + const SBool s1096 = false != s1095; + const SBool s1097 = !s1096; + const SWord8 s1098 = sbv_bv_u8_rotr(s1082, 1); + const SWord8 s1099 = 128 | s1098; + const SWord8 s1100 = 127 & s1098; + const SWord8 s1101 = s1036 ? s1099 : s1100; + const SWord8 s1102 = sbv_bv_u8_rotr(s1101, 1); + const SWord8 s1103 = 128 | s1102; + const SWord8 s1104 = 127 & s1102; + const SWord8 s1105 = s1058 ? s1103 : s1104; + const SWord8 s1106 = sbv_bv_u8_rotr(s1105, 1); + const SWord8 s1107 = 128 | s1106; + const SWord8 s1108 = 127 & s1106; + const SWord8 s1109 = s1077 ? s1107 : s1108; + const SWord8 s1110 = sbv_bv_u8_rotr(s1109, 1); + const SWord8 s1111 = 128 | s1110; + const SWord8 s1112 = 127 & s1110; + const SWord8 s1113 = s1096 ? s1111 : s1112; + const SWord8 s1114 = sbv_bv_u8_add(s1, s1109); + const SBool s1115 = s1114 < s1; + const SBool s1116 = s1114 < s1109; + const SBool s1117 = s1115 || s1116; + const SWord8 s1118 = sbv_bv_u8_rotr(s1114, 1); + 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 = sbv_bv_u8_add(s1, s1105); + const SBool s1124 = s1123 < s1; + const SBool s1125 = s1123 < s1105; + const SBool s1126 = s1124 || s1125; + const SWord8 s1127 = sbv_bv_u8_rotr(s1123, 1); + const SWord8 s1128 = 128 | s1127; + const SWord8 s1129 = 127 & s1127; + const SWord8 s1130 = s1126 ? s1128 : s1129; + const SWord8 s1131 = sbv_bv_u8_rotr(s1130, 1); + const SWord8 s1132 = 128 | s1131; + const SWord8 s1133 = 127 & s1131; + const SWord8 s1134 = s1096 ? s1132 : s1133; + const SWord8 s1135 = sbv_bv_u8_add(s1, s1130); + const SBool s1136 = s1135 < s1; + const SBool s1137 = s1135 < s1130; + const SBool s1138 = s1136 || s1137; + const SWord8 s1139 = sbv_bv_u8_rotr(s1135, 1); + 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 = sbv_bv_u8_add(s1, s1101); + const SBool s1146 = s1145 < s1; + const SBool s1147 = s1145 < s1101; + const SBool s1148 = s1146 || s1147; + const SWord8 s1149 = sbv_bv_u8_rotr(s1145, 1); + const SWord8 s1150 = 128 | s1149; + const SWord8 s1151 = 127 & s1149; + const SWord8 s1152 = s1148 ? s1150 : s1151; + const SWord8 s1153 = sbv_bv_u8_rotr(s1152, 1); + const SWord8 s1154 = 128 | s1153; + const SWord8 s1155 = 127 & s1153; + const SWord8 s1156 = s1077 ? s1154 : s1155; + const SWord8 s1157 = sbv_bv_u8_rotr(s1156, 1); + const SWord8 s1158 = 128 | s1157; + const SWord8 s1159 = 127 & s1157; + const SWord8 s1160 = s1096 ? s1158 : s1159; + const SWord8 s1161 = sbv_bv_u8_add(s1, s1156); + const SBool s1162 = s1161 < s1; + const SBool s1163 = s1161 < s1156; + const SBool s1164 = s1162 || s1163; + const SWord8 s1165 = sbv_bv_u8_rotr(s1161, 1); + 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 = sbv_bv_u8_add(s1, s1152); + const SBool s1171 = s1170 < s1; + const SBool s1172 = s1170 < s1152; + const SBool s1173 = s1171 || s1172; + const SWord8 s1174 = sbv_bv_u8_rotr(s1170, 1); + const SWord8 s1175 = 128 | s1174; + const SWord8 s1176 = 127 & s1174; + const SWord8 s1177 = s1173 ? s1175 : s1176; + const SWord8 s1178 = sbv_bv_u8_rotr(s1177, 1); + const SWord8 s1179 = 128 | s1178; + const SWord8 s1180 = 127 & s1178; + const SWord8 s1181 = s1096 ? s1179 : s1180; + const SWord8 s1182 = sbv_bv_u8_add(s1, s1177); + const SBool s1183 = s1182 < s1; + const SBool s1184 = s1182 < s1177; + const SBool s1185 = s1183 || s1184; + const SWord8 s1186 = sbv_bv_u8_rotr(s1182, 1); + 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 = sbv_bv_u8_add(s1, s1082); + const SBool s1194 = sbv_bv_extract_u8_0_0_u1(s1193); + const SBool s1195 = false != s1194; + const SWord8 s1196 = s1195 ? s1086 : s1087; + const SBool s1197 = sbv_bv_extract_u8_0_0_u1(s1196); + const SBool s1198 = false != s1197; + const SWord8 s1199 = s1198 ? s1092 : s1093; + const SBool s1200 = sbv_bv_extract_u8_0_0_u1(s1199); + const SBool s1201 = false != s1200; + const SBool s1202 = !s1201; + const SBool s1203 = s1193 < s1; + const SBool s1204 = s1193 < s1082; + const SBool s1205 = s1203 || s1204; + const SWord8 s1206 = sbv_bv_u8_rotr(s1193, 1); + const SWord8 s1207 = 128 | s1206; + const SWord8 s1208 = 127 & s1206; + const SWord8 s1209 = s1205 ? s1207 : s1208; + const SWord8 s1210 = sbv_bv_u8_rotr(s1209, 1); + const SWord8 s1211 = 128 | s1210; + const SWord8 s1212 = 127 & s1210; + const SWord8 s1213 = s1058 ? s1211 : s1212; + const SWord8 s1214 = sbv_bv_u8_rotr(s1213, 1); + const SWord8 s1215 = 128 | s1214; + const SWord8 s1216 = 127 & s1214; + const SWord8 s1217 = s1077 ? s1215 : s1216; + const SWord8 s1218 = sbv_bv_u8_rotr(s1217, 1); + const SWord8 s1219 = 128 | s1218; + const SWord8 s1220 = 127 & s1218; + const SWord8 s1221 = s1201 ? s1219 : s1220; + const SWord8 s1222 = sbv_bv_u8_add(s1, s1217); + const SBool s1223 = s1222 < s1; + const SBool s1224 = s1222 < s1217; + const SBool s1225 = s1223 || s1224; + const SWord8 s1226 = sbv_bv_u8_rotr(s1222, 1); + 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 = sbv_bv_u8_add(s1, s1213); + const SBool s1232 = s1231 < s1; + const SBool s1233 = s1231 < s1213; + const SBool s1234 = s1232 || s1233; + const SWord8 s1235 = sbv_bv_u8_rotr(s1231, 1); + const SWord8 s1236 = 128 | s1235; + const SWord8 s1237 = 127 & s1235; + const SWord8 s1238 = s1234 ? s1236 : s1237; + const SWord8 s1239 = sbv_bv_u8_rotr(s1238, 1); + const SWord8 s1240 = 128 | s1239; + const SWord8 s1241 = 127 & s1239; + const SWord8 s1242 = s1201 ? s1240 : s1241; + const SWord8 s1243 = sbv_bv_u8_add(s1, s1238); + const SBool s1244 = s1243 < s1; + const SBool s1245 = s1243 < s1238; + const SBool s1246 = s1244 || s1245; + const SWord8 s1247 = sbv_bv_u8_rotr(s1243, 1); + 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 = sbv_bv_u8_add(s1, s1209); + const SBool s1254 = s1253 < s1; + const SBool s1255 = s1253 < s1209; + const SBool s1256 = s1254 || s1255; + const SWord8 s1257 = sbv_bv_u8_rotr(s1253, 1); + const SWord8 s1258 = 128 | s1257; + const SWord8 s1259 = 127 & s1257; + const SWord8 s1260 = s1256 ? s1258 : s1259; + const SWord8 s1261 = sbv_bv_u8_rotr(s1260, 1); + const SWord8 s1262 = 128 | s1261; + const SWord8 s1263 = 127 & s1261; + const SWord8 s1264 = s1077 ? s1262 : s1263; + const SWord8 s1265 = sbv_bv_u8_rotr(s1264, 1); + const SWord8 s1266 = 128 | s1265; + const SWord8 s1267 = 127 & s1265; + const SWord8 s1268 = s1201 ? s1266 : s1267; + const SWord8 s1269 = sbv_bv_u8_add(s1, s1264); + const SBool s1270 = s1269 < s1; + const SBool s1271 = s1269 < s1264; + const SBool s1272 = s1270 || s1271; + const SWord8 s1273 = sbv_bv_u8_rotr(s1269, 1); + 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 = sbv_bv_u8_add(s1, s1260); + const SBool s1279 = s1278 < s1; + const SBool s1280 = s1278 < s1260; + const SBool s1281 = s1279 || s1280; + const SWord8 s1282 = sbv_bv_u8_rotr(s1278, 1); + const SWord8 s1283 = 128 | s1282; + const SWord8 s1284 = 127 & s1282; + const SWord8 s1285 = s1281 ? s1283 : s1284; + const SWord8 s1286 = sbv_bv_u8_rotr(s1285, 1); + const SWord8 s1287 = 128 | s1286; + const SWord8 s1288 = 127 & s1286; + const SWord8 s1289 = s1201 ? s1287 : s1288; + const SWord8 s1290 = sbv_bv_u8_add(s1, s1285); + const SBool s1291 = s1290 < s1; + const SBool s1292 = s1290 < s1285; + const SBool s1293 = s1291 || s1292; + const SWord8 s1294 = sbv_bv_u8_rotr(s1290, 1); + 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 = sbv_bv_u8_add(s1, s1063); + const SBool s1303 = sbv_bv_extract_u8_0_0_u1(s1302); + const SBool s1304 = false != s1303; + const SWord8 s1305 = s1304 ? s1067 : s1068; + const SBool s1306 = sbv_bv_extract_u8_0_0_u1(s1305); + const SBool s1307 = false != s1306; + const SWord8 s1308 = s1307 ? s1073 : s1074; + const SBool s1309 = sbv_bv_extract_u8_0_0_u1(s1308); + const SBool s1310 = false != s1309; + const SBool s1311 = !s1310; + const SBool s1312 = s1302 < s1; + const SBool s1313 = s1302 < s1063; + const SBool s1314 = s1312 || s1313; + const SWord8 s1315 = sbv_bv_u8_rotr(s1302, 1); + const SWord8 s1316 = 128 | s1315; + const SWord8 s1317 = 127 & s1315; + const SWord8 s1318 = s1314 ? s1316 : s1317; + const SBool s1319 = sbv_bv_extract_u8_0_0_u1(s1318); + const SBool s1320 = false != s1319; + const SWord8 s1321 = sbv_bv_u8_rotr(s1305, 1); + const SWord8 s1322 = 128 | s1321; + const SWord8 s1323 = 127 & s1321; + const SWord8 s1324 = s1320 ? s1322 : s1323; + const SBool s1325 = sbv_bv_extract_u8_0_0_u1(s1324); + const SBool s1326 = false != s1325; + const SWord8 s1327 = sbv_bv_u8_rotr(s1308, 1); + const SWord8 s1328 = 128 | s1327; + const SWord8 s1329 = 127 & s1327; + const SWord8 s1330 = s1326 ? s1328 : s1329; + const SBool s1331 = sbv_bv_extract_u8_0_0_u1(s1330); + const SBool s1332 = false != s1331; + const SBool s1333 = !s1332; + const SWord8 s1334 = sbv_bv_u8_rotr(s1318, 1); + const SWord8 s1335 = 128 | s1334; + const SWord8 s1336 = 127 & s1334; + const SWord8 s1337 = s1036 ? s1335 : s1336; + const SWord8 s1338 = sbv_bv_u8_rotr(s1337, 1); + const SWord8 s1339 = 128 | s1338; + const SWord8 s1340 = 127 & s1338; + const SWord8 s1341 = s1058 ? s1339 : s1340; + const SWord8 s1342 = sbv_bv_u8_rotr(s1341, 1); + const SWord8 s1343 = 128 | s1342; + const SWord8 s1344 = 127 & s1342; + const SWord8 s1345 = s1310 ? s1343 : s1344; + const SWord8 s1346 = sbv_bv_u8_rotr(s1345, 1); + const SWord8 s1347 = 128 | s1346; + const SWord8 s1348 = 127 & s1346; + const SWord8 s1349 = s1332 ? s1347 : s1348; + const SWord8 s1350 = sbv_bv_u8_add(s1, s1345); + const SBool s1351 = s1350 < s1; + const SBool s1352 = s1350 < s1345; + const SBool s1353 = s1351 || s1352; + const SWord8 s1354 = sbv_bv_u8_rotr(s1350, 1); + 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 = sbv_bv_u8_add(s1, s1341); + const SBool s1360 = s1359 < s1; + const SBool s1361 = s1359 < s1341; + const SBool s1362 = s1360 || s1361; + const SWord8 s1363 = sbv_bv_u8_rotr(s1359, 1); + const SWord8 s1364 = 128 | s1363; + const SWord8 s1365 = 127 & s1363; + const SWord8 s1366 = s1362 ? s1364 : s1365; + const SWord8 s1367 = sbv_bv_u8_rotr(s1366, 1); + const SWord8 s1368 = 128 | s1367; + const SWord8 s1369 = 127 & s1367; + const SWord8 s1370 = s1332 ? s1368 : s1369; + const SWord8 s1371 = sbv_bv_u8_add(s1, s1366); + const SBool s1372 = s1371 < s1; + const SBool s1373 = s1371 < s1366; + const SBool s1374 = s1372 || s1373; + const SWord8 s1375 = sbv_bv_u8_rotr(s1371, 1); + 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 = sbv_bv_u8_add(s1, s1337); + const SBool s1382 = s1381 < s1; + const SBool s1383 = s1381 < s1337; + const SBool s1384 = s1382 || s1383; + const SWord8 s1385 = sbv_bv_u8_rotr(s1381, 1); + const SWord8 s1386 = 128 | s1385; + const SWord8 s1387 = 127 & s1385; + const SWord8 s1388 = s1384 ? s1386 : s1387; + const SWord8 s1389 = sbv_bv_u8_rotr(s1388, 1); + const SWord8 s1390 = 128 | s1389; + const SWord8 s1391 = 127 & s1389; + const SWord8 s1392 = s1310 ? s1390 : s1391; + const SWord8 s1393 = sbv_bv_u8_rotr(s1392, 1); + const SWord8 s1394 = 128 | s1393; + const SWord8 s1395 = 127 & s1393; + const SWord8 s1396 = s1332 ? s1394 : s1395; + const SWord8 s1397 = sbv_bv_u8_add(s1, s1392); + const SBool s1398 = s1397 < s1; + const SBool s1399 = s1397 < s1392; + const SBool s1400 = s1398 || s1399; + const SWord8 s1401 = sbv_bv_u8_rotr(s1397, 1); + 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 = sbv_bv_u8_add(s1, s1388); + const SBool s1407 = s1406 < s1; + const SBool s1408 = s1406 < s1388; + const SBool s1409 = s1407 || s1408; + const SWord8 s1410 = sbv_bv_u8_rotr(s1406, 1); + const SWord8 s1411 = 128 | s1410; + const SWord8 s1412 = 127 & s1410; + const SWord8 s1413 = s1409 ? s1411 : s1412; + const SWord8 s1414 = sbv_bv_u8_rotr(s1413, 1); + const SWord8 s1415 = 128 | s1414; + const SWord8 s1416 = 127 & s1414; + const SWord8 s1417 = s1332 ? s1415 : s1416; + const SWord8 s1418 = sbv_bv_u8_add(s1, s1413); + const SBool s1419 = s1418 < s1; + const SBool s1420 = s1418 < s1413; + const SBool s1421 = s1419 || s1420; + const SWord8 s1422 = sbv_bv_u8_rotr(s1418, 1); + 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 = sbv_bv_u8_add(s1, s1318); + const SBool s1430 = sbv_bv_extract_u8_0_0_u1(s1429); + const SBool s1431 = false != s1430; + const SWord8 s1432 = s1431 ? s1322 : s1323; + const SBool s1433 = sbv_bv_extract_u8_0_0_u1(s1432); + const SBool s1434 = false != s1433; + const SWord8 s1435 = s1434 ? s1328 : s1329; + const SBool s1436 = sbv_bv_extract_u8_0_0_u1(s1435); + const SBool s1437 = false != s1436; + const SBool s1438 = !s1437; + const SBool s1439 = s1429 < s1; + const SBool s1440 = s1429 < s1318; + const SBool s1441 = s1439 || s1440; + const SWord8 s1442 = sbv_bv_u8_rotr(s1429, 1); + const SWord8 s1443 = 128 | s1442; + const SWord8 s1444 = 127 & s1442; + const SWord8 s1445 = s1441 ? s1443 : s1444; + const SWord8 s1446 = sbv_bv_u8_rotr(s1445, 1); + const SWord8 s1447 = 128 | s1446; + const SWord8 s1448 = 127 & s1446; + const SWord8 s1449 = s1058 ? s1447 : s1448; + const SWord8 s1450 = sbv_bv_u8_rotr(s1449, 1); + const SWord8 s1451 = 128 | s1450; + const SWord8 s1452 = 127 & s1450; + const SWord8 s1453 = s1310 ? s1451 : s1452; + const SWord8 s1454 = sbv_bv_u8_rotr(s1453, 1); + const SWord8 s1455 = 128 | s1454; + const SWord8 s1456 = 127 & s1454; + const SWord8 s1457 = s1437 ? s1455 : s1456; + const SWord8 s1458 = sbv_bv_u8_add(s1, s1453); + const SBool s1459 = s1458 < s1; + const SBool s1460 = s1458 < s1453; + const SBool s1461 = s1459 || s1460; + const SWord8 s1462 = sbv_bv_u8_rotr(s1458, 1); + 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 = sbv_bv_u8_add(s1, s1449); + const SBool s1468 = s1467 < s1; + const SBool s1469 = s1467 < s1449; + const SBool s1470 = s1468 || s1469; + const SWord8 s1471 = sbv_bv_u8_rotr(s1467, 1); + const SWord8 s1472 = 128 | s1471; + const SWord8 s1473 = 127 & s1471; + const SWord8 s1474 = s1470 ? s1472 : s1473; + const SWord8 s1475 = sbv_bv_u8_rotr(s1474, 1); + const SWord8 s1476 = 128 | s1475; + const SWord8 s1477 = 127 & s1475; + const SWord8 s1478 = s1437 ? s1476 : s1477; + const SWord8 s1479 = sbv_bv_u8_add(s1, s1474); + const SBool s1480 = s1479 < s1; + const SBool s1481 = s1479 < s1474; + const SBool s1482 = s1480 || s1481; + const SWord8 s1483 = sbv_bv_u8_rotr(s1479, 1); + 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 = sbv_bv_u8_add(s1, s1445); + const SBool s1490 = s1489 < s1; + const SBool s1491 = s1489 < s1445; + const SBool s1492 = s1490 || s1491; + const SWord8 s1493 = sbv_bv_u8_rotr(s1489, 1); + const SWord8 s1494 = 128 | s1493; + const SWord8 s1495 = 127 & s1493; + const SWord8 s1496 = s1492 ? s1494 : s1495; + const SWord8 s1497 = sbv_bv_u8_rotr(s1496, 1); + const SWord8 s1498 = 128 | s1497; + const SWord8 s1499 = 127 & s1497; + const SWord8 s1500 = s1310 ? s1498 : s1499; + const SWord8 s1501 = sbv_bv_u8_rotr(s1500, 1); + const SWord8 s1502 = 128 | s1501; + const SWord8 s1503 = 127 & s1501; + const SWord8 s1504 = s1437 ? s1502 : s1503; + const SWord8 s1505 = sbv_bv_u8_add(s1, s1500); + const SBool s1506 = s1505 < s1; + const SBool s1507 = s1505 < s1500; + const SBool s1508 = s1506 || s1507; + const SWord8 s1509 = sbv_bv_u8_rotr(s1505, 1); + 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 = sbv_bv_u8_add(s1, s1496); + const SBool s1515 = s1514 < s1; + const SBool s1516 = s1514 < s1496; + const SBool s1517 = s1515 || s1516; + const SWord8 s1518 = sbv_bv_u8_rotr(s1514, 1); + const SWord8 s1519 = 128 | s1518; + const SWord8 s1520 = 127 & s1518; + const SWord8 s1521 = s1517 ? s1519 : s1520; + const SWord8 s1522 = sbv_bv_u8_rotr(s1521, 1); + const SWord8 s1523 = 128 | s1522; + const SWord8 s1524 = 127 & s1522; + const SWord8 s1525 = s1437 ? s1523 : s1524; + const SWord8 s1526 = sbv_bv_u8_add(s1, s1521); + const SBool s1527 = s1526 < s1; + const SBool s1528 = s1526 < s1521; + const SBool s1529 = s1527 || s1528; + const SWord8 s1530 = sbv_bv_u8_rotr(s1526, 1); + const SWord8 s1531 = 128 | s1530; + const SWord8 s1532 = 127 & s1530; + const SWord8 s1533 = s1529 ? s1531 : s1532; + const SWord8 s1534 = s1438 ? s1525 : s1533; + const SWord8 s1535 = s1311 ? s1513 : s1534; + const SWord8 s1536 = s1059 ? s1488 : s1535; + const SWord8 s1537 = s1037 ? s1428 : s1536; + const SWord8 s1538 = s21 ? s1301 : s1537; + const SWord8 s1539 = sbv_bv_u8_add(s1, s1044); + const SBool s1540 = sbv_bv_extract_u8_0_0_u1(s1539); + const SBool s1541 = false != s1540; + const SWord8 s1542 = s1541 ? s1048 : s1049; + const SBool s1543 = sbv_bv_extract_u8_0_0_u1(s1542); + const SBool s1544 = false != s1543; + const SWord8 s1545 = s1544 ? s1054 : s1055; + const SBool s1546 = sbv_bv_extract_u8_0_0_u1(s1545); + const SBool s1547 = false != s1546; + const SBool s1548 = !s1547; + const SBool s1549 = s1539 < s1; + const SBool s1550 = s1539 < s1044; + const SBool s1551 = s1549 || s1550; + const SWord8 s1552 = sbv_bv_u8_rotr(s1539, 1); + const SWord8 s1553 = 128 | s1552; + const SWord8 s1554 = 127 & s1552; + const SWord8 s1555 = s1551 ? s1553 : s1554; + const SBool s1556 = sbv_bv_extract_u8_0_0_u1(s1555); + const SBool s1557 = false != s1556; + const SWord8 s1558 = sbv_bv_u8_rotr(s1542, 1); + const SWord8 s1559 = 128 | s1558; + const SWord8 s1560 = 127 & s1558; + const SWord8 s1561 = s1557 ? s1559 : s1560; + const SBool s1562 = sbv_bv_extract_u8_0_0_u1(s1561); + const SBool s1563 = false != s1562; + const SWord8 s1564 = sbv_bv_u8_rotr(s1545, 1); + const SWord8 s1565 = 128 | s1564; + const SWord8 s1566 = 127 & s1564; + const SWord8 s1567 = s1563 ? s1565 : s1566; + const SBool s1568 = sbv_bv_extract_u8_0_0_u1(s1567); + const SBool s1569 = false != s1568; + const SBool s1570 = !s1569; + const SWord8 s1571 = sbv_bv_u8_rotr(s1555, 1); + const SWord8 s1572 = 128 | s1571; + const SWord8 s1573 = 127 & s1571; + const SWord8 s1574 = s20 ? s1572 : s1573; + const SBool s1575 = sbv_bv_extract_u8_0_0_u1(s1574); + const SBool s1576 = false != s1575; + const SWord8 s1577 = sbv_bv_u8_rotr(s1561, 1); + const SWord8 s1578 = 128 | s1577; + const SWord8 s1579 = 127 & s1577; + const SWord8 s1580 = s1576 ? s1578 : s1579; + const SBool s1581 = sbv_bv_extract_u8_0_0_u1(s1580); + const SBool s1582 = false != s1581; + const SWord8 s1583 = sbv_bv_u8_rotr(s1567, 1); + const SWord8 s1584 = 128 | s1583; + const SWord8 s1585 = 127 & s1583; + const SWord8 s1586 = s1582 ? s1584 : s1585; + const SBool s1587 = sbv_bv_extract_u8_0_0_u1(s1586); + const SBool s1588 = false != s1587; + const SBool s1589 = !s1588; + const SWord8 s1590 = sbv_bv_u8_rotr(s1574, 1); + const SWord8 s1591 = 128 | s1590; + const SWord8 s1592 = 127 & s1590; + const SWord8 s1593 = s1036 ? s1591 : s1592; + const SWord8 s1594 = sbv_bv_u8_rotr(s1593, 1); + const SWord8 s1595 = 128 | s1594; + const SWord8 s1596 = 127 & s1594; + const SWord8 s1597 = s1547 ? s1595 : s1596; + const SWord8 s1598 = sbv_bv_u8_rotr(s1597, 1); + const SWord8 s1599 = 128 | s1598; + const SWord8 s1600 = 127 & s1598; + const SWord8 s1601 = s1569 ? s1599 : s1600; + const SWord8 s1602 = sbv_bv_u8_rotr(s1601, 1); + const SWord8 s1603 = 128 | s1602; + const SWord8 s1604 = 127 & s1602; + const SWord8 s1605 = s1588 ? s1603 : s1604; + const SWord8 s1606 = sbv_bv_u8_add(s1, s1601); + const SBool s1607 = s1606 < s1; + const SBool s1608 = s1606 < s1601; + const SBool s1609 = s1607 || s1608; + const SWord8 s1610 = sbv_bv_u8_rotr(s1606, 1); + 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 = sbv_bv_u8_add(s1, s1597); + const SBool s1616 = s1615 < s1; + const SBool s1617 = s1615 < s1597; + const SBool s1618 = s1616 || s1617; + const SWord8 s1619 = sbv_bv_u8_rotr(s1615, 1); + const SWord8 s1620 = 128 | s1619; + const SWord8 s1621 = 127 & s1619; + const SWord8 s1622 = s1618 ? s1620 : s1621; + const SWord8 s1623 = sbv_bv_u8_rotr(s1622, 1); + const SWord8 s1624 = 128 | s1623; + const SWord8 s1625 = 127 & s1623; + const SWord8 s1626 = s1588 ? s1624 : s1625; + const SWord8 s1627 = sbv_bv_u8_add(s1, s1622); + const SBool s1628 = s1627 < s1; + const SBool s1629 = s1627 < s1622; + const SBool s1630 = s1628 || s1629; + const SWord8 s1631 = sbv_bv_u8_rotr(s1627, 1); + 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 = sbv_bv_u8_add(s1, s1593); + const SBool s1638 = s1637 < s1; + const SBool s1639 = s1637 < s1593; + const SBool s1640 = s1638 || s1639; + const SWord8 s1641 = sbv_bv_u8_rotr(s1637, 1); + const SWord8 s1642 = 128 | s1641; + const SWord8 s1643 = 127 & s1641; + const SWord8 s1644 = s1640 ? s1642 : s1643; + const SWord8 s1645 = sbv_bv_u8_rotr(s1644, 1); + const SWord8 s1646 = 128 | s1645; + const SWord8 s1647 = 127 & s1645; + const SWord8 s1648 = s1569 ? s1646 : s1647; + const SWord8 s1649 = sbv_bv_u8_rotr(s1648, 1); + const SWord8 s1650 = 128 | s1649; + const SWord8 s1651 = 127 & s1649; + const SWord8 s1652 = s1588 ? s1650 : s1651; + const SWord8 s1653 = sbv_bv_u8_add(s1, s1648); + const SBool s1654 = s1653 < s1; + const SBool s1655 = s1653 < s1648; + const SBool s1656 = s1654 || s1655; + const SWord8 s1657 = sbv_bv_u8_rotr(s1653, 1); + 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 = sbv_bv_u8_add(s1, s1644); + const SBool s1663 = s1662 < s1; + const SBool s1664 = s1662 < s1644; + const SBool s1665 = s1663 || s1664; + const SWord8 s1666 = sbv_bv_u8_rotr(s1662, 1); + const SWord8 s1667 = 128 | s1666; + const SWord8 s1668 = 127 & s1666; + const SWord8 s1669 = s1665 ? s1667 : s1668; + const SWord8 s1670 = sbv_bv_u8_rotr(s1669, 1); + const SWord8 s1671 = 128 | s1670; + const SWord8 s1672 = 127 & s1670; + const SWord8 s1673 = s1588 ? s1671 : s1672; + const SWord8 s1674 = sbv_bv_u8_add(s1, s1669); + const SBool s1675 = s1674 < s1; + const SBool s1676 = s1674 < s1669; + const SBool s1677 = s1675 || s1676; + const SWord8 s1678 = sbv_bv_u8_rotr(s1674, 1); + 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 = sbv_bv_u8_add(s1, s1574); + const SBool s1686 = sbv_bv_extract_u8_0_0_u1(s1685); + const SBool s1687 = false != s1686; + const SWord8 s1688 = s1687 ? s1578 : s1579; + const SBool s1689 = sbv_bv_extract_u8_0_0_u1(s1688); + const SBool s1690 = false != s1689; + const SWord8 s1691 = s1690 ? s1584 : s1585; + const SBool s1692 = sbv_bv_extract_u8_0_0_u1(s1691); + const SBool s1693 = false != s1692; + const SBool s1694 = !s1693; + const SBool s1695 = s1685 < s1; + const SBool s1696 = s1685 < s1574; + const SBool s1697 = s1695 || s1696; + const SWord8 s1698 = sbv_bv_u8_rotr(s1685, 1); + const SWord8 s1699 = 128 | s1698; + const SWord8 s1700 = 127 & s1698; + const SWord8 s1701 = s1697 ? s1699 : s1700; + const SWord8 s1702 = sbv_bv_u8_rotr(s1701, 1); + const SWord8 s1703 = 128 | s1702; + const SWord8 s1704 = 127 & s1702; + const SWord8 s1705 = s1547 ? s1703 : s1704; + const SWord8 s1706 = sbv_bv_u8_rotr(s1705, 1); + const SWord8 s1707 = 128 | s1706; + const SWord8 s1708 = 127 & s1706; + const SWord8 s1709 = s1569 ? s1707 : s1708; + const SWord8 s1710 = sbv_bv_u8_rotr(s1709, 1); + const SWord8 s1711 = 128 | s1710; + const SWord8 s1712 = 127 & s1710; + const SWord8 s1713 = s1693 ? s1711 : s1712; + const SWord8 s1714 = sbv_bv_u8_add(s1, s1709); + const SBool s1715 = s1714 < s1; + const SBool s1716 = s1714 < s1709; + const SBool s1717 = s1715 || s1716; + const SWord8 s1718 = sbv_bv_u8_rotr(s1714, 1); + 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 = sbv_bv_u8_add(s1, s1705); + const SBool s1724 = s1723 < s1; + const SBool s1725 = s1723 < s1705; + const SBool s1726 = s1724 || s1725; + const SWord8 s1727 = sbv_bv_u8_rotr(s1723, 1); + const SWord8 s1728 = 128 | s1727; + const SWord8 s1729 = 127 & s1727; + const SWord8 s1730 = s1726 ? s1728 : s1729; + const SWord8 s1731 = sbv_bv_u8_rotr(s1730, 1); + const SWord8 s1732 = 128 | s1731; + const SWord8 s1733 = 127 & s1731; + const SWord8 s1734 = s1693 ? s1732 : s1733; + const SWord8 s1735 = sbv_bv_u8_add(s1, s1730); + const SBool s1736 = s1735 < s1; + const SBool s1737 = s1735 < s1730; + const SBool s1738 = s1736 || s1737; + const SWord8 s1739 = sbv_bv_u8_rotr(s1735, 1); + 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 = sbv_bv_u8_add(s1, s1701); + const SBool s1746 = s1745 < s1; + const SBool s1747 = s1745 < s1701; + const SBool s1748 = s1746 || s1747; + const SWord8 s1749 = sbv_bv_u8_rotr(s1745, 1); + const SWord8 s1750 = 128 | s1749; + const SWord8 s1751 = 127 & s1749; + const SWord8 s1752 = s1748 ? s1750 : s1751; + const SWord8 s1753 = sbv_bv_u8_rotr(s1752, 1); + const SWord8 s1754 = 128 | s1753; + const SWord8 s1755 = 127 & s1753; + const SWord8 s1756 = s1569 ? s1754 : s1755; + const SWord8 s1757 = sbv_bv_u8_rotr(s1756, 1); + const SWord8 s1758 = 128 | s1757; + const SWord8 s1759 = 127 & s1757; + const SWord8 s1760 = s1693 ? s1758 : s1759; + const SWord8 s1761 = sbv_bv_u8_add(s1, s1756); + const SBool s1762 = s1761 < s1; + const SBool s1763 = s1761 < s1756; + const SBool s1764 = s1762 || s1763; + const SWord8 s1765 = sbv_bv_u8_rotr(s1761, 1); + 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 = sbv_bv_u8_add(s1, s1752); + const SBool s1771 = s1770 < s1; + const SBool s1772 = s1770 < s1752; + const SBool s1773 = s1771 || s1772; + const SWord8 s1774 = sbv_bv_u8_rotr(s1770, 1); + const SWord8 s1775 = 128 | s1774; + const SWord8 s1776 = 127 & s1774; + const SWord8 s1777 = s1773 ? s1775 : s1776; + const SWord8 s1778 = sbv_bv_u8_rotr(s1777, 1); + const SWord8 s1779 = 128 | s1778; + const SWord8 s1780 = 127 & s1778; + const SWord8 s1781 = s1693 ? s1779 : s1780; + const SWord8 s1782 = sbv_bv_u8_add(s1, s1777); + const SBool s1783 = s1782 < s1; + const SBool s1784 = s1782 < s1777; + const SBool s1785 = s1783 || s1784; + const SWord8 s1786 = sbv_bv_u8_rotr(s1782, 1); + 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 = sbv_bv_u8_add(s1, s1555); + const SBool s1795 = sbv_bv_extract_u8_0_0_u1(s1794); + const SBool s1796 = false != s1795; + const SWord8 s1797 = s1796 ? s1559 : s1560; + const SBool s1798 = sbv_bv_extract_u8_0_0_u1(s1797); + const SBool s1799 = false != s1798; + const SWord8 s1800 = s1799 ? s1565 : s1566; + const SBool s1801 = sbv_bv_extract_u8_0_0_u1(s1800); + const SBool s1802 = false != s1801; + const SBool s1803 = !s1802; + const SBool s1804 = s1794 < s1; + const SBool s1805 = s1794 < s1555; + const SBool s1806 = s1804 || s1805; + const SWord8 s1807 = sbv_bv_u8_rotr(s1794, 1); + const SWord8 s1808 = 128 | s1807; + const SWord8 s1809 = 127 & s1807; + const SWord8 s1810 = s1806 ? s1808 : s1809; + const SBool s1811 = sbv_bv_extract_u8_0_0_u1(s1810); + const SBool s1812 = false != s1811; + const SWord8 s1813 = sbv_bv_u8_rotr(s1797, 1); + const SWord8 s1814 = 128 | s1813; + const SWord8 s1815 = 127 & s1813; + const SWord8 s1816 = s1812 ? s1814 : s1815; + const SBool s1817 = sbv_bv_extract_u8_0_0_u1(s1816); + const SBool s1818 = false != s1817; + const SWord8 s1819 = sbv_bv_u8_rotr(s1800, 1); + const SWord8 s1820 = 128 | s1819; + const SWord8 s1821 = 127 & s1819; + const SWord8 s1822 = s1818 ? s1820 : s1821; + const SBool s1823 = sbv_bv_extract_u8_0_0_u1(s1822); + const SBool s1824 = false != s1823; + const SBool s1825 = !s1824; + const SWord8 s1826 = sbv_bv_u8_rotr(s1810, 1); + const SWord8 s1827 = 128 | s1826; + const SWord8 s1828 = 127 & s1826; + const SWord8 s1829 = s1036 ? s1827 : s1828; + const SWord8 s1830 = sbv_bv_u8_rotr(s1829, 1); + const SWord8 s1831 = 128 | s1830; + const SWord8 s1832 = 127 & s1830; + const SWord8 s1833 = s1547 ? s1831 : s1832; + const SWord8 s1834 = sbv_bv_u8_rotr(s1833, 1); + const SWord8 s1835 = 128 | s1834; + const SWord8 s1836 = 127 & s1834; + const SWord8 s1837 = s1802 ? s1835 : s1836; + const SWord8 s1838 = sbv_bv_u8_rotr(s1837, 1); + const SWord8 s1839 = 128 | s1838; + const SWord8 s1840 = 127 & s1838; + const SWord8 s1841 = s1824 ? s1839 : s1840; + const SWord8 s1842 = sbv_bv_u8_add(s1, s1837); + const SBool s1843 = s1842 < s1; + const SBool s1844 = s1842 < s1837; + const SBool s1845 = s1843 || s1844; + const SWord8 s1846 = sbv_bv_u8_rotr(s1842, 1); + 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 = sbv_bv_u8_add(s1, s1833); + const SBool s1852 = s1851 < s1; + const SBool s1853 = s1851 < s1833; + const SBool s1854 = s1852 || s1853; + const SWord8 s1855 = sbv_bv_u8_rotr(s1851, 1); + const SWord8 s1856 = 128 | s1855; + const SWord8 s1857 = 127 & s1855; + const SWord8 s1858 = s1854 ? s1856 : s1857; + const SWord8 s1859 = sbv_bv_u8_rotr(s1858, 1); + const SWord8 s1860 = 128 | s1859; + const SWord8 s1861 = 127 & s1859; + const SWord8 s1862 = s1824 ? s1860 : s1861; + const SWord8 s1863 = sbv_bv_u8_add(s1, s1858); + const SBool s1864 = s1863 < s1; + const SBool s1865 = s1863 < s1858; + const SBool s1866 = s1864 || s1865; + const SWord8 s1867 = sbv_bv_u8_rotr(s1863, 1); + 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 = sbv_bv_u8_add(s1, s1829); + const SBool s1874 = s1873 < s1; + const SBool s1875 = s1873 < s1829; + const SBool s1876 = s1874 || s1875; + const SWord8 s1877 = sbv_bv_u8_rotr(s1873, 1); + const SWord8 s1878 = 128 | s1877; + const SWord8 s1879 = 127 & s1877; + const SWord8 s1880 = s1876 ? s1878 : s1879; + const SWord8 s1881 = sbv_bv_u8_rotr(s1880, 1); + const SWord8 s1882 = 128 | s1881; + const SWord8 s1883 = 127 & s1881; + const SWord8 s1884 = s1802 ? s1882 : s1883; + const SWord8 s1885 = sbv_bv_u8_rotr(s1884, 1); + const SWord8 s1886 = 128 | s1885; + const SWord8 s1887 = 127 & s1885; + const SWord8 s1888 = s1824 ? s1886 : s1887; + const SWord8 s1889 = sbv_bv_u8_add(s1, s1884); + const SBool s1890 = s1889 < s1; + const SBool s1891 = s1889 < s1884; + const SBool s1892 = s1890 || s1891; + const SWord8 s1893 = sbv_bv_u8_rotr(s1889, 1); + 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 = sbv_bv_u8_add(s1, s1880); + const SBool s1899 = s1898 < s1; + const SBool s1900 = s1898 < s1880; + const SBool s1901 = s1899 || s1900; + const SWord8 s1902 = sbv_bv_u8_rotr(s1898, 1); + const SWord8 s1903 = 128 | s1902; + const SWord8 s1904 = 127 & s1902; + const SWord8 s1905 = s1901 ? s1903 : s1904; + const SWord8 s1906 = sbv_bv_u8_rotr(s1905, 1); + const SWord8 s1907 = 128 | s1906; + const SWord8 s1908 = 127 & s1906; + const SWord8 s1909 = s1824 ? s1907 : s1908; + const SWord8 s1910 = sbv_bv_u8_add(s1, s1905); + const SBool s1911 = s1910 < s1; + const SBool s1912 = s1910 < s1905; + const SBool s1913 = s1911 || s1912; + const SWord8 s1914 = sbv_bv_u8_rotr(s1910, 1); + 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 = sbv_bv_u8_add(s1, s1810); + const SBool s1922 = sbv_bv_extract_u8_0_0_u1(s1921); + const SBool s1923 = false != s1922; + const SWord8 s1924 = s1923 ? s1814 : s1815; + const SBool s1925 = sbv_bv_extract_u8_0_0_u1(s1924); + const SBool s1926 = false != s1925; + const SWord8 s1927 = s1926 ? s1820 : s1821; + const SBool s1928 = sbv_bv_extract_u8_0_0_u1(s1927); + const SBool s1929 = false != s1928; + const SBool s1930 = !s1929; + const SBool s1931 = s1921 < s1; + const SBool s1932 = s1921 < s1810; + const SBool s1933 = s1931 || s1932; + const SWord8 s1934 = sbv_bv_u8_rotr(s1921, 1); + const SWord8 s1935 = 128 | s1934; + const SWord8 s1936 = 127 & s1934; + const SWord8 s1937 = s1933 ? s1935 : s1936; + const SWord8 s1938 = sbv_bv_u8_rotr(s1937, 1); + const SWord8 s1939 = 128 | s1938; + const SWord8 s1940 = 127 & s1938; + const SWord8 s1941 = s1547 ? s1939 : s1940; + const SWord8 s1942 = sbv_bv_u8_rotr(s1941, 1); + const SWord8 s1943 = 128 | s1942; + const SWord8 s1944 = 127 & s1942; + const SWord8 s1945 = s1802 ? s1943 : s1944; + const SWord8 s1946 = sbv_bv_u8_rotr(s1945, 1); + const SWord8 s1947 = 128 | s1946; + const SWord8 s1948 = 127 & s1946; + const SWord8 s1949 = s1929 ? s1947 : s1948; + const SWord8 s1950 = sbv_bv_u8_add(s1, s1945); + const SBool s1951 = s1950 < s1; + const SBool s1952 = s1950 < s1945; + const SBool s1953 = s1951 || s1952; + const SWord8 s1954 = sbv_bv_u8_rotr(s1950, 1); + 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 = sbv_bv_u8_add(s1, s1941); + const SBool s1960 = s1959 < s1; + const SBool s1961 = s1959 < s1941; + const SBool s1962 = s1960 || s1961; + const SWord8 s1963 = sbv_bv_u8_rotr(s1959, 1); + const SWord8 s1964 = 128 | s1963; + const SWord8 s1965 = 127 & s1963; + const SWord8 s1966 = s1962 ? s1964 : s1965; + const SWord8 s1967 = sbv_bv_u8_rotr(s1966, 1); + const SWord8 s1968 = 128 | s1967; + const SWord8 s1969 = 127 & s1967; + const SWord8 s1970 = s1929 ? s1968 : s1969; + const SWord8 s1971 = sbv_bv_u8_add(s1, s1966); + const SBool s1972 = s1971 < s1; + const SBool s1973 = s1971 < s1966; + const SBool s1974 = s1972 || s1973; + const SWord8 s1975 = sbv_bv_u8_rotr(s1971, 1); + 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 = sbv_bv_u8_add(s1, s1937); + const SBool s1982 = s1981 < s1; + const SBool s1983 = s1981 < s1937; + const SBool s1984 = s1982 || s1983; + const SWord8 s1985 = sbv_bv_u8_rotr(s1981, 1); + const SWord8 s1986 = 128 | s1985; + const SWord8 s1987 = 127 & s1985; + const SWord8 s1988 = s1984 ? s1986 : s1987; + const SWord8 s1989 = sbv_bv_u8_rotr(s1988, 1); + const SWord8 s1990 = 128 | s1989; + const SWord8 s1991 = 127 & s1989; + const SWord8 s1992 = s1802 ? s1990 : s1991; + const SWord8 s1993 = sbv_bv_u8_rotr(s1992, 1); + const SWord8 s1994 = 128 | s1993; + const SWord8 s1995 = 127 & s1993; + const SWord8 s1996 = s1929 ? s1994 : s1995; + const SWord8 s1997 = sbv_bv_u8_add(s1, s1992); + const SBool s1998 = s1997 < s1; + const SBool s1999 = s1997 < s1992; + const SBool s2000 = s1998 || s1999; + const SWord8 s2001 = sbv_bv_u8_rotr(s1997, 1); + 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 = sbv_bv_u8_add(s1, s1988); + const SBool s2007 = s2006 < s1; + const SBool s2008 = s2006 < s1988; + const SBool s2009 = s2007 || s2008; + const SWord8 s2010 = sbv_bv_u8_rotr(s2006, 1); + const SWord8 s2011 = 128 | s2010; + const SWord8 s2012 = 127 & s2010; + const SWord8 s2013 = s2009 ? s2011 : s2012; + const SWord8 s2014 = sbv_bv_u8_rotr(s2013, 1); + const SWord8 s2015 = 128 | s2014; + const SWord8 s2016 = 127 & s2014; + const SWord8 s2017 = s1929 ? s2015 : s2016; + const SWord8 s2018 = sbv_bv_u8_add(s1, s2013); + const SBool s2019 = s2018 < s1; + const SBool s2020 = s2018 < s2013; + const SBool s2021 = s2019 || s2020; + const SWord8 s2022 = sbv_bv_u8_rotr(s2018, 1); + const SWord8 s2023 = 128 | s2022; + const SWord8 s2024 = 127 & s2022; + const SWord8 s2025 = s2021 ? s2023 : s2024; + const SWord8 s2026 = s1930 ? s2017 : s2025; + const SWord8 s2027 = s1803 ? s2005 : s2026; + const SWord8 s2028 = s1548 ? s1980 : s2027; + const SWord8 s2029 = s1037 ? s1920 : s2028; + const SWord8 s2030 = s21 ? s1793 : s2029; + const SWord8 s2031 = s16 ? s1538 : s2030; + const SWord8 s2032 = s11 ? s1027 : s2031; + const SBool s2033 = sbv_bv_extract_u8_0_0_u1(s1); + const SBool s2034 = false != s2033; + const SWord8 s2035 = s2034 ? 128 : 0; + const SBool s2036 = sbv_bv_extract_u8_0_0_u1(s2035); + const SBool s2037 = false != s2036; + const SWord8 s2038 = s17 | 128; + const SWord8 s2039 = s2037 ? s2038 : s18; + const SBool s2040 = sbv_bv_extract_u8_0_0_u1(s2039); + const SBool s2041 = false != s2040; + const SBool s2042 = !s2041; + const SWord8 s2043 = sbv_bv_u8_rotr(s1, 1); + const SWord8 s2044 = 127 & s2043; + const SBool s2045 = sbv_bv_extract_u8_0_0_u1(s2044); + const SBool s2046 = false != s2045; + const SWord8 s2047 = sbv_bv_u8_rotr(s2035, 1); + const SWord8 s2048 = 128 | s2047; + const SWord8 s2049 = 127 & s2047; + const SWord8 s2050 = s2046 ? s2048 : s2049; + const SBool s2051 = sbv_bv_extract_u8_0_0_u1(s2050); + const SBool s2052 = false != s2051; + const SWord8 s2053 = sbv_bv_u8_rotr(s2039, 1); + const SWord8 s2054 = 128 | s2053; + const SWord8 s2055 = 127 & s2053; + const SWord8 s2056 = s2052 ? s2054 : s2055; + const SBool s2057 = sbv_bv_extract_u8_0_0_u1(s2056); + const SBool s2058 = false != s2057; + const SBool s2059 = !s2058; + const SWord8 s2060 = sbv_bv_u8_rotr(s2044, 1); + const SWord8 s2061 = 128 | s2060; + const SWord8 s2062 = 127 & s2060; + const SWord8 s2063 = s10 ? s2061 : s2062; + const SBool s2064 = sbv_bv_extract_u8_0_0_u1(s2063); + const SBool s2065 = false != s2064; + const SWord8 s2066 = sbv_bv_u8_rotr(s2050, 1); + const SWord8 s2067 = 128 | s2066; + const SWord8 s2068 = 127 & s2066; + const SWord8 s2069 = s2065 ? s2067 : s2068; + const SBool s2070 = sbv_bv_extract_u8_0_0_u1(s2069); + const SBool s2071 = false != s2070; + const SWord8 s2072 = sbv_bv_u8_rotr(s2056, 1); + const SWord8 s2073 = 128 | s2072; + const SWord8 s2074 = 127 & s2072; + const SWord8 s2075 = s2071 ? s2073 : s2074; + const SBool s2076 = sbv_bv_extract_u8_0_0_u1(s2075); + const SBool s2077 = false != s2076; + const SBool s2078 = !s2077; + const SWord8 s2079 = sbv_bv_u8_rotr(s2063, 1); + const SWord8 s2080 = 128 | s2079; + const SWord8 s2081 = 127 & s2079; + const SWord8 s2082 = s15 ? s2080 : s2081; + const SBool s2083 = sbv_bv_extract_u8_0_0_u1(s2082); + const SBool s2084 = false != s2083; + const SWord8 s2085 = sbv_bv_u8_rotr(s2069, 1); + const SWord8 s2086 = 128 | s2085; + const SWord8 s2087 = 127 & s2085; + const SWord8 s2088 = s2084 ? s2086 : s2087; + const SBool s2089 = sbv_bv_extract_u8_0_0_u1(s2088); + const SBool s2090 = false != s2089; + const SWord8 s2091 = sbv_bv_u8_rotr(s2075, 1); + const SWord8 s2092 = 128 | s2091; + const SWord8 s2093 = 127 & s2091; + const SWord8 s2094 = s2090 ? s2092 : s2093; + const SBool s2095 = sbv_bv_extract_u8_0_0_u1(s2094); + const SBool s2096 = false != s2095; + const SBool s2097 = !s2096; + const SWord8 s2098 = sbv_bv_u8_rotr(s2082, 1); + const SWord8 s2099 = 128 | s2098; + const SWord8 s2100 = 127 & s2098; + const SWord8 s2101 = s2041 ? s2099 : s2100; + const SBool s2102 = sbv_bv_extract_u8_0_0_u1(s2101); + const SBool s2103 = false != s2102; + const SWord8 s2104 = sbv_bv_u8_rotr(s2088, 1); + const SWord8 s2105 = 128 | s2104; + const SWord8 s2106 = 127 & s2104; + const SWord8 s2107 = s2103 ? s2105 : s2106; + const SBool s2108 = sbv_bv_extract_u8_0_0_u1(s2107); + const SBool s2109 = false != s2108; + const SWord8 s2110 = sbv_bv_u8_rotr(s2094, 1); + const SWord8 s2111 = 128 | s2110; + const SWord8 s2112 = 127 & s2110; + const SWord8 s2113 = s2109 ? s2111 : s2112; + const SBool s2114 = sbv_bv_extract_u8_0_0_u1(s2113); + const SBool s2115 = false != s2114; + const SBool s2116 = !s2115; + const SWord8 s2117 = sbv_bv_u8_rotr(s2101, 1); + const SWord8 s2118 = 128 | s2117; + const SWord8 s2119 = 127 & s2117; + const SWord8 s2120 = s2058 ? s2118 : s2119; + const SWord8 s2121 = sbv_bv_u8_rotr(s2120, 1); + const SWord8 s2122 = 128 | s2121; + const SWord8 s2123 = 127 & s2121; + const SWord8 s2124 = s2077 ? s2122 : s2123; + const SWord8 s2125 = sbv_bv_u8_rotr(s2124, 1); + const SWord8 s2126 = 128 | s2125; + const SWord8 s2127 = 127 & s2125; + const SWord8 s2128 = s2096 ? s2126 : s2127; + const SWord8 s2129 = sbv_bv_u8_rotr(s2128, 1); + const SWord8 s2130 = 128 | s2129; + const SWord8 s2131 = 127 & s2129; + const SWord8 s2132 = s2115 ? s2130 : s2131; + const SWord8 s2133 = sbv_bv_u8_add(s1, s2128); + const SBool s2134 = s2133 < s1; + const SBool s2135 = s2133 < s2128; + const SBool s2136 = s2134 || s2135; + const SWord8 s2137 = sbv_bv_u8_rotr(s2133, 1); + 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 = sbv_bv_u8_add(s1, s2124); + const SBool s2143 = s2142 < s1; + const SBool s2144 = s2142 < s2124; + const SBool s2145 = s2143 || s2144; + const SWord8 s2146 = sbv_bv_u8_rotr(s2142, 1); + const SWord8 s2147 = 128 | s2146; + const SWord8 s2148 = 127 & s2146; + const SWord8 s2149 = s2145 ? s2147 : s2148; + const SWord8 s2150 = sbv_bv_u8_rotr(s2149, 1); + const SWord8 s2151 = 128 | s2150; + const SWord8 s2152 = 127 & s2150; + const SWord8 s2153 = s2115 ? s2151 : s2152; + const SWord8 s2154 = sbv_bv_u8_add(s1, s2149); + const SBool s2155 = s2154 < s1; + const SBool s2156 = s2154 < s2149; + const SBool s2157 = s2155 || s2156; + const SWord8 s2158 = sbv_bv_u8_rotr(s2154, 1); + 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 = sbv_bv_u8_add(s1, s2120); + const SBool s2165 = s2164 < s1; + const SBool s2166 = s2164 < s2120; + const SBool s2167 = s2165 || s2166; + const SWord8 s2168 = sbv_bv_u8_rotr(s2164, 1); + const SWord8 s2169 = 128 | s2168; + const SWord8 s2170 = 127 & s2168; + const SWord8 s2171 = s2167 ? s2169 : s2170; + const SWord8 s2172 = sbv_bv_u8_rotr(s2171, 1); + const SWord8 s2173 = 128 | s2172; + const SWord8 s2174 = 127 & s2172; + const SWord8 s2175 = s2096 ? s2173 : s2174; + const SWord8 s2176 = sbv_bv_u8_rotr(s2175, 1); + const SWord8 s2177 = 128 | s2176; + const SWord8 s2178 = 127 & s2176; + const SWord8 s2179 = s2115 ? s2177 : s2178; + const SWord8 s2180 = sbv_bv_u8_add(s1, s2175); + const SBool s2181 = s2180 < s1; + const SBool s2182 = s2180 < s2175; + const SBool s2183 = s2181 || s2182; + const SWord8 s2184 = sbv_bv_u8_rotr(s2180, 1); + 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 = sbv_bv_u8_add(s1, s2171); + const SBool s2190 = s2189 < s1; + const SBool s2191 = s2189 < s2171; + const SBool s2192 = s2190 || s2191; + const SWord8 s2193 = sbv_bv_u8_rotr(s2189, 1); + const SWord8 s2194 = 128 | s2193; + const SWord8 s2195 = 127 & s2193; + const SWord8 s2196 = s2192 ? s2194 : s2195; + const SWord8 s2197 = sbv_bv_u8_rotr(s2196, 1); + const SWord8 s2198 = 128 | s2197; + const SWord8 s2199 = 127 & s2197; + const SWord8 s2200 = s2115 ? s2198 : s2199; + const SWord8 s2201 = sbv_bv_u8_add(s1, s2196); + const SBool s2202 = s2201 < s1; + const SBool s2203 = s2201 < s2196; + const SBool s2204 = s2202 || s2203; + const SWord8 s2205 = sbv_bv_u8_rotr(s2201, 1); + 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 = sbv_bv_u8_add(s1, s2101); + const SBool s2213 = sbv_bv_extract_u8_0_0_u1(s2212); + const SBool s2214 = false != s2213; + const SWord8 s2215 = s2214 ? s2105 : s2106; + const SBool s2216 = sbv_bv_extract_u8_0_0_u1(s2215); + const SBool s2217 = false != s2216; + const SWord8 s2218 = s2217 ? s2111 : s2112; + const SBool s2219 = sbv_bv_extract_u8_0_0_u1(s2218); + const SBool s2220 = false != s2219; + const SBool s2221 = !s2220; + const SBool s2222 = s2212 < s1; + const SBool s2223 = s2212 < s2101; + const SBool s2224 = s2222 || s2223; + const SWord8 s2225 = sbv_bv_u8_rotr(s2212, 1); + const SWord8 s2226 = 128 | s2225; + const SWord8 s2227 = 127 & s2225; + const SWord8 s2228 = s2224 ? s2226 : s2227; + const SWord8 s2229 = sbv_bv_u8_rotr(s2228, 1); + const SWord8 s2230 = 128 | s2229; + const SWord8 s2231 = 127 & s2229; + const SWord8 s2232 = s2077 ? s2230 : s2231; + const SWord8 s2233 = sbv_bv_u8_rotr(s2232, 1); + const SWord8 s2234 = 128 | s2233; + const SWord8 s2235 = 127 & s2233; + const SWord8 s2236 = s2096 ? s2234 : s2235; + const SWord8 s2237 = sbv_bv_u8_rotr(s2236, 1); + const SWord8 s2238 = 128 | s2237; + const SWord8 s2239 = 127 & s2237; + const SWord8 s2240 = s2220 ? s2238 : s2239; + const SWord8 s2241 = sbv_bv_u8_add(s1, s2236); + const SBool s2242 = s2241 < s1; + const SBool s2243 = s2241 < s2236; + const SBool s2244 = s2242 || s2243; + const SWord8 s2245 = sbv_bv_u8_rotr(s2241, 1); + 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 = sbv_bv_u8_add(s1, s2232); + const SBool s2251 = s2250 < s1; + const SBool s2252 = s2250 < s2232; + const SBool s2253 = s2251 || s2252; + const SWord8 s2254 = sbv_bv_u8_rotr(s2250, 1); + const SWord8 s2255 = 128 | s2254; + const SWord8 s2256 = 127 & s2254; + const SWord8 s2257 = s2253 ? s2255 : s2256; + const SWord8 s2258 = sbv_bv_u8_rotr(s2257, 1); + const SWord8 s2259 = 128 | s2258; + const SWord8 s2260 = 127 & s2258; + const SWord8 s2261 = s2220 ? s2259 : s2260; + const SWord8 s2262 = sbv_bv_u8_add(s1, s2257); + const SBool s2263 = s2262 < s1; + const SBool s2264 = s2262 < s2257; + const SBool s2265 = s2263 || s2264; + const SWord8 s2266 = sbv_bv_u8_rotr(s2262, 1); + 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 = sbv_bv_u8_add(s1, s2228); + const SBool s2273 = s2272 < s1; + const SBool s2274 = s2272 < s2228; + const SBool s2275 = s2273 || s2274; + const SWord8 s2276 = sbv_bv_u8_rotr(s2272, 1); + const SWord8 s2277 = 128 | s2276; + const SWord8 s2278 = 127 & s2276; + const SWord8 s2279 = s2275 ? s2277 : s2278; + const SWord8 s2280 = sbv_bv_u8_rotr(s2279, 1); + const SWord8 s2281 = 128 | s2280; + const SWord8 s2282 = 127 & s2280; + const SWord8 s2283 = s2096 ? s2281 : s2282; + const SWord8 s2284 = sbv_bv_u8_rotr(s2283, 1); + const SWord8 s2285 = 128 | s2284; + const SWord8 s2286 = 127 & s2284; + const SWord8 s2287 = s2220 ? s2285 : s2286; + const SWord8 s2288 = sbv_bv_u8_add(s1, s2283); + const SBool s2289 = s2288 < s1; + const SBool s2290 = s2288 < s2283; + const SBool s2291 = s2289 || s2290; + const SWord8 s2292 = sbv_bv_u8_rotr(s2288, 1); + 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 = sbv_bv_u8_add(s1, s2279); + const SBool s2298 = s2297 < s1; + const SBool s2299 = s2297 < s2279; + const SBool s2300 = s2298 || s2299; + const SWord8 s2301 = sbv_bv_u8_rotr(s2297, 1); + const SWord8 s2302 = 128 | s2301; + const SWord8 s2303 = 127 & s2301; + const SWord8 s2304 = s2300 ? s2302 : s2303; + const SWord8 s2305 = sbv_bv_u8_rotr(s2304, 1); + const SWord8 s2306 = 128 | s2305; + const SWord8 s2307 = 127 & s2305; + const SWord8 s2308 = s2220 ? s2306 : s2307; + const SWord8 s2309 = sbv_bv_u8_add(s1, s2304); + const SBool s2310 = s2309 < s1; + const SBool s2311 = s2309 < s2304; + const SBool s2312 = s2310 || s2311; + const SWord8 s2313 = sbv_bv_u8_rotr(s2309, 1); + 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 = sbv_bv_u8_add(s1, s2082); + const SBool s2322 = sbv_bv_extract_u8_0_0_u1(s2321); + const SBool s2323 = false != s2322; + const SWord8 s2324 = s2323 ? s2086 : s2087; + const SBool s2325 = sbv_bv_extract_u8_0_0_u1(s2324); + const SBool s2326 = false != s2325; + const SWord8 s2327 = s2326 ? s2092 : s2093; + const SBool s2328 = sbv_bv_extract_u8_0_0_u1(s2327); + const SBool s2329 = false != s2328; + const SBool s2330 = !s2329; + const SBool s2331 = s2321 < s1; + const SBool s2332 = s2321 < s2082; + const SBool s2333 = s2331 || s2332; + const SWord8 s2334 = sbv_bv_u8_rotr(s2321, 1); + const SWord8 s2335 = 128 | s2334; + const SWord8 s2336 = 127 & s2334; + const SWord8 s2337 = s2333 ? s2335 : s2336; + const SBool s2338 = sbv_bv_extract_u8_0_0_u1(s2337); + const SBool s2339 = false != s2338; + const SWord8 s2340 = sbv_bv_u8_rotr(s2324, 1); + const SWord8 s2341 = 128 | s2340; + const SWord8 s2342 = 127 & s2340; + const SWord8 s2343 = s2339 ? s2341 : s2342; + const SBool s2344 = sbv_bv_extract_u8_0_0_u1(s2343); + const SBool s2345 = false != s2344; + const SWord8 s2346 = sbv_bv_u8_rotr(s2327, 1); + const SWord8 s2347 = 128 | s2346; + const SWord8 s2348 = 127 & s2346; + const SWord8 s2349 = s2345 ? s2347 : s2348; + const SBool s2350 = sbv_bv_extract_u8_0_0_u1(s2349); + const SBool s2351 = false != s2350; + const SBool s2352 = !s2351; + const SWord8 s2353 = sbv_bv_u8_rotr(s2337, 1); + const SWord8 s2354 = 128 | s2353; + const SWord8 s2355 = 127 & s2353; + const SWord8 s2356 = s2058 ? s2354 : s2355; + const SWord8 s2357 = sbv_bv_u8_rotr(s2356, 1); + const SWord8 s2358 = 128 | s2357; + const SWord8 s2359 = 127 & s2357; + const SWord8 s2360 = s2077 ? s2358 : s2359; + const SWord8 s2361 = sbv_bv_u8_rotr(s2360, 1); + const SWord8 s2362 = 128 | s2361; + const SWord8 s2363 = 127 & s2361; + const SWord8 s2364 = s2329 ? s2362 : s2363; + const SWord8 s2365 = sbv_bv_u8_rotr(s2364, 1); + const SWord8 s2366 = 128 | s2365; + const SWord8 s2367 = 127 & s2365; + const SWord8 s2368 = s2351 ? s2366 : s2367; + const SWord8 s2369 = sbv_bv_u8_add(s1, s2364); + const SBool s2370 = s2369 < s1; + const SBool s2371 = s2369 < s2364; + const SBool s2372 = s2370 || s2371; + const SWord8 s2373 = sbv_bv_u8_rotr(s2369, 1); + 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 = sbv_bv_u8_add(s1, s2360); + const SBool s2379 = s2378 < s1; + const SBool s2380 = s2378 < s2360; + const SBool s2381 = s2379 || s2380; + const SWord8 s2382 = sbv_bv_u8_rotr(s2378, 1); + const SWord8 s2383 = 128 | s2382; + const SWord8 s2384 = 127 & s2382; + const SWord8 s2385 = s2381 ? s2383 : s2384; + const SWord8 s2386 = sbv_bv_u8_rotr(s2385, 1); + const SWord8 s2387 = 128 | s2386; + const SWord8 s2388 = 127 & s2386; + const SWord8 s2389 = s2351 ? s2387 : s2388; + const SWord8 s2390 = sbv_bv_u8_add(s1, s2385); + const SBool s2391 = s2390 < s1; + const SBool s2392 = s2390 < s2385; + const SBool s2393 = s2391 || s2392; + const SWord8 s2394 = sbv_bv_u8_rotr(s2390, 1); + 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 = sbv_bv_u8_add(s1, s2356); + const SBool s2401 = s2400 < s1; + const SBool s2402 = s2400 < s2356; + const SBool s2403 = s2401 || s2402; + const SWord8 s2404 = sbv_bv_u8_rotr(s2400, 1); + const SWord8 s2405 = 128 | s2404; + const SWord8 s2406 = 127 & s2404; + const SWord8 s2407 = s2403 ? s2405 : s2406; + const SWord8 s2408 = sbv_bv_u8_rotr(s2407, 1); + const SWord8 s2409 = 128 | s2408; + const SWord8 s2410 = 127 & s2408; + const SWord8 s2411 = s2329 ? s2409 : s2410; + const SWord8 s2412 = sbv_bv_u8_rotr(s2411, 1); + const SWord8 s2413 = 128 | s2412; + const SWord8 s2414 = 127 & s2412; + const SWord8 s2415 = s2351 ? s2413 : s2414; + const SWord8 s2416 = sbv_bv_u8_add(s1, s2411); + const SBool s2417 = s2416 < s1; + const SBool s2418 = s2416 < s2411; + const SBool s2419 = s2417 || s2418; + const SWord8 s2420 = sbv_bv_u8_rotr(s2416, 1); + 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 = sbv_bv_u8_add(s1, s2407); + const SBool s2426 = s2425 < s1; + const SBool s2427 = s2425 < s2407; + const SBool s2428 = s2426 || s2427; + const SWord8 s2429 = sbv_bv_u8_rotr(s2425, 1); + const SWord8 s2430 = 128 | s2429; + const SWord8 s2431 = 127 & s2429; + const SWord8 s2432 = s2428 ? s2430 : s2431; + const SWord8 s2433 = sbv_bv_u8_rotr(s2432, 1); + const SWord8 s2434 = 128 | s2433; + const SWord8 s2435 = 127 & s2433; + const SWord8 s2436 = s2351 ? s2434 : s2435; + const SWord8 s2437 = sbv_bv_u8_add(s1, s2432); + const SBool s2438 = s2437 < s1; + const SBool s2439 = s2437 < s2432; + const SBool s2440 = s2438 || s2439; + const SWord8 s2441 = sbv_bv_u8_rotr(s2437, 1); + 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 = sbv_bv_u8_add(s1, s2337); + const SBool s2449 = sbv_bv_extract_u8_0_0_u1(s2448); + const SBool s2450 = false != s2449; + const SWord8 s2451 = s2450 ? s2341 : s2342; + const SBool s2452 = sbv_bv_extract_u8_0_0_u1(s2451); + const SBool s2453 = false != s2452; + const SWord8 s2454 = s2453 ? s2347 : s2348; + const SBool s2455 = sbv_bv_extract_u8_0_0_u1(s2454); + const SBool s2456 = false != s2455; + const SBool s2457 = !s2456; + const SBool s2458 = s2448 < s1; + const SBool s2459 = s2448 < s2337; + const SBool s2460 = s2458 || s2459; + const SWord8 s2461 = sbv_bv_u8_rotr(s2448, 1); + const SWord8 s2462 = 128 | s2461; + const SWord8 s2463 = 127 & s2461; + const SWord8 s2464 = s2460 ? s2462 : s2463; + const SWord8 s2465 = sbv_bv_u8_rotr(s2464, 1); + const SWord8 s2466 = 128 | s2465; + const SWord8 s2467 = 127 & s2465; + const SWord8 s2468 = s2077 ? s2466 : s2467; + const SWord8 s2469 = sbv_bv_u8_rotr(s2468, 1); + const SWord8 s2470 = 128 | s2469; + const SWord8 s2471 = 127 & s2469; + const SWord8 s2472 = s2329 ? s2470 : s2471; + const SWord8 s2473 = sbv_bv_u8_rotr(s2472, 1); + const SWord8 s2474 = 128 | s2473; + const SWord8 s2475 = 127 & s2473; + const SWord8 s2476 = s2456 ? s2474 : s2475; + const SWord8 s2477 = sbv_bv_u8_add(s1, s2472); + const SBool s2478 = s2477 < s1; + const SBool s2479 = s2477 < s2472; + const SBool s2480 = s2478 || s2479; + const SWord8 s2481 = sbv_bv_u8_rotr(s2477, 1); + 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 = sbv_bv_u8_add(s1, s2468); + const SBool s2487 = s2486 < s1; + const SBool s2488 = s2486 < s2468; + const SBool s2489 = s2487 || s2488; + const SWord8 s2490 = sbv_bv_u8_rotr(s2486, 1); + const SWord8 s2491 = 128 | s2490; + const SWord8 s2492 = 127 & s2490; + const SWord8 s2493 = s2489 ? s2491 : s2492; + const SWord8 s2494 = sbv_bv_u8_rotr(s2493, 1); + const SWord8 s2495 = 128 | s2494; + const SWord8 s2496 = 127 & s2494; + const SWord8 s2497 = s2456 ? s2495 : s2496; + const SWord8 s2498 = sbv_bv_u8_add(s1, s2493); + const SBool s2499 = s2498 < s1; + const SBool s2500 = s2498 < s2493; + const SBool s2501 = s2499 || s2500; + const SWord8 s2502 = sbv_bv_u8_rotr(s2498, 1); + 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 = sbv_bv_u8_add(s1, s2464); + const SBool s2509 = s2508 < s1; + const SBool s2510 = s2508 < s2464; + const SBool s2511 = s2509 || s2510; + const SWord8 s2512 = sbv_bv_u8_rotr(s2508, 1); + const SWord8 s2513 = 128 | s2512; + const SWord8 s2514 = 127 & s2512; + const SWord8 s2515 = s2511 ? s2513 : s2514; + const SWord8 s2516 = sbv_bv_u8_rotr(s2515, 1); + const SWord8 s2517 = 128 | s2516; + const SWord8 s2518 = 127 & s2516; + const SWord8 s2519 = s2329 ? s2517 : s2518; + const SWord8 s2520 = sbv_bv_u8_rotr(s2519, 1); + const SWord8 s2521 = 128 | s2520; + const SWord8 s2522 = 127 & s2520; + const SWord8 s2523 = s2456 ? s2521 : s2522; + const SWord8 s2524 = sbv_bv_u8_add(s1, s2519); + const SBool s2525 = s2524 < s1; + const SBool s2526 = s2524 < s2519; + const SBool s2527 = s2525 || s2526; + const SWord8 s2528 = sbv_bv_u8_rotr(s2524, 1); + 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 = sbv_bv_u8_add(s1, s2515); + const SBool s2534 = s2533 < s1; + const SBool s2535 = s2533 < s2515; + const SBool s2536 = s2534 || s2535; + const SWord8 s2537 = sbv_bv_u8_rotr(s2533, 1); + const SWord8 s2538 = 128 | s2537; + const SWord8 s2539 = 127 & s2537; + const SWord8 s2540 = s2536 ? s2538 : s2539; + const SWord8 s2541 = sbv_bv_u8_rotr(s2540, 1); + const SWord8 s2542 = 128 | s2541; + const SWord8 s2543 = 127 & s2541; + const SWord8 s2544 = s2456 ? s2542 : s2543; + const SWord8 s2545 = sbv_bv_u8_add(s1, s2540); + const SBool s2546 = s2545 < s1; + const SBool s2547 = s2545 < s2540; + const SBool s2548 = s2546 || s2547; + const SWord8 s2549 = sbv_bv_u8_rotr(s2545, 1); + 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 = sbv_bv_u8_add(s1, s2063); + const SBool s2559 = sbv_bv_extract_u8_0_0_u1(s2558); + const SBool s2560 = false != s2559; + const SWord8 s2561 = s2560 ? s2067 : s2068; + const SBool s2562 = sbv_bv_extract_u8_0_0_u1(s2561); + const SBool s2563 = false != s2562; + const SWord8 s2564 = s2563 ? s2073 : s2074; + const SBool s2565 = sbv_bv_extract_u8_0_0_u1(s2564); + const SBool s2566 = false != s2565; + const SBool s2567 = !s2566; + const SBool s2568 = s2558 < s1; + const SBool s2569 = s2558 < s2063; + const SBool s2570 = s2568 || s2569; + const SWord8 s2571 = sbv_bv_u8_rotr(s2558, 1); + const SWord8 s2572 = 128 | s2571; + const SWord8 s2573 = 127 & s2571; + const SWord8 s2574 = s2570 ? s2572 : s2573; + const SBool s2575 = sbv_bv_extract_u8_0_0_u1(s2574); + const SBool s2576 = false != s2575; + const SWord8 s2577 = sbv_bv_u8_rotr(s2561, 1); + const SWord8 s2578 = 128 | s2577; + const SWord8 s2579 = 127 & s2577; + const SWord8 s2580 = s2576 ? s2578 : s2579; + const SBool s2581 = sbv_bv_extract_u8_0_0_u1(s2580); + const SBool s2582 = false != s2581; + const SWord8 s2583 = sbv_bv_u8_rotr(s2564, 1); + const SWord8 s2584 = 128 | s2583; + const SWord8 s2585 = 127 & s2583; + const SWord8 s2586 = s2582 ? s2584 : s2585; + const SBool s2587 = sbv_bv_extract_u8_0_0_u1(s2586); + const SBool s2588 = false != s2587; + const SBool s2589 = !s2588; + const SWord8 s2590 = sbv_bv_u8_rotr(s2574, 1); + const SWord8 s2591 = 128 | s2590; + const SWord8 s2592 = 127 & s2590; + const SWord8 s2593 = s2041 ? s2591 : s2592; + const SBool s2594 = sbv_bv_extract_u8_0_0_u1(s2593); + const SBool s2595 = false != s2594; + const SWord8 s2596 = sbv_bv_u8_rotr(s2580, 1); + const SWord8 s2597 = 128 | s2596; + const SWord8 s2598 = 127 & s2596; + const SWord8 s2599 = s2595 ? s2597 : s2598; + const SBool s2600 = sbv_bv_extract_u8_0_0_u1(s2599); + const SBool s2601 = false != s2600; + const SWord8 s2602 = sbv_bv_u8_rotr(s2586, 1); + const SWord8 s2603 = 128 | s2602; + const SWord8 s2604 = 127 & s2602; + const SWord8 s2605 = s2601 ? s2603 : s2604; + const SBool s2606 = sbv_bv_extract_u8_0_0_u1(s2605); + const SBool s2607 = false != s2606; + const SBool s2608 = !s2607; + const SWord8 s2609 = sbv_bv_u8_rotr(s2593, 1); + const SWord8 s2610 = 128 | s2609; + const SWord8 s2611 = 127 & s2609; + const SWord8 s2612 = s2058 ? s2610 : s2611; + const SWord8 s2613 = sbv_bv_u8_rotr(s2612, 1); + const SWord8 s2614 = 128 | s2613; + const SWord8 s2615 = 127 & s2613; + const SWord8 s2616 = s2566 ? s2614 : s2615; + const SWord8 s2617 = sbv_bv_u8_rotr(s2616, 1); + const SWord8 s2618 = 128 | s2617; + const SWord8 s2619 = 127 & s2617; + const SWord8 s2620 = s2588 ? s2618 : s2619; + const SWord8 s2621 = sbv_bv_u8_rotr(s2620, 1); + const SWord8 s2622 = 128 | s2621; + const SWord8 s2623 = 127 & s2621; + const SWord8 s2624 = s2607 ? s2622 : s2623; + const SWord8 s2625 = sbv_bv_u8_add(s1, s2620); + const SBool s2626 = s2625 < s1; + const SBool s2627 = s2625 < s2620; + const SBool s2628 = s2626 || s2627; + const SWord8 s2629 = sbv_bv_u8_rotr(s2625, 1); + 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 = sbv_bv_u8_add(s1, s2616); + const SBool s2635 = s2634 < s1; + const SBool s2636 = s2634 < s2616; + const SBool s2637 = s2635 || s2636; + const SWord8 s2638 = sbv_bv_u8_rotr(s2634, 1); + const SWord8 s2639 = 128 | s2638; + const SWord8 s2640 = 127 & s2638; + const SWord8 s2641 = s2637 ? s2639 : s2640; + const SWord8 s2642 = sbv_bv_u8_rotr(s2641, 1); + const SWord8 s2643 = 128 | s2642; + const SWord8 s2644 = 127 & s2642; + const SWord8 s2645 = s2607 ? s2643 : s2644; + const SWord8 s2646 = sbv_bv_u8_add(s1, s2641); + const SBool s2647 = s2646 < s1; + const SBool s2648 = s2646 < s2641; + const SBool s2649 = s2647 || s2648; + const SWord8 s2650 = sbv_bv_u8_rotr(s2646, 1); + 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 = sbv_bv_u8_add(s1, s2612); + const SBool s2657 = s2656 < s1; + const SBool s2658 = s2656 < s2612; + const SBool s2659 = s2657 || s2658; + const SWord8 s2660 = sbv_bv_u8_rotr(s2656, 1); + const SWord8 s2661 = 128 | s2660; + const SWord8 s2662 = 127 & s2660; + const SWord8 s2663 = s2659 ? s2661 : s2662; + const SWord8 s2664 = sbv_bv_u8_rotr(s2663, 1); + const SWord8 s2665 = 128 | s2664; + const SWord8 s2666 = 127 & s2664; + const SWord8 s2667 = s2588 ? s2665 : s2666; + const SWord8 s2668 = sbv_bv_u8_rotr(s2667, 1); + const SWord8 s2669 = 128 | s2668; + const SWord8 s2670 = 127 & s2668; + const SWord8 s2671 = s2607 ? s2669 : s2670; + const SWord8 s2672 = sbv_bv_u8_add(s1, s2667); + const SBool s2673 = s2672 < s1; + const SBool s2674 = s2672 < s2667; + const SBool s2675 = s2673 || s2674; + const SWord8 s2676 = sbv_bv_u8_rotr(s2672, 1); + 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 = sbv_bv_u8_add(s1, s2663); + const SBool s2682 = s2681 < s1; + const SBool s2683 = s2681 < s2663; + const SBool s2684 = s2682 || s2683; + const SWord8 s2685 = sbv_bv_u8_rotr(s2681, 1); + const SWord8 s2686 = 128 | s2685; + const SWord8 s2687 = 127 & s2685; + const SWord8 s2688 = s2684 ? s2686 : s2687; + const SWord8 s2689 = sbv_bv_u8_rotr(s2688, 1); + const SWord8 s2690 = 128 | s2689; + const SWord8 s2691 = 127 & s2689; + const SWord8 s2692 = s2607 ? s2690 : s2691; + const SWord8 s2693 = sbv_bv_u8_add(s1, s2688); + const SBool s2694 = s2693 < s1; + const SBool s2695 = s2693 < s2688; + const SBool s2696 = s2694 || s2695; + const SWord8 s2697 = sbv_bv_u8_rotr(s2693, 1); + 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 = sbv_bv_u8_add(s1, s2593); + const SBool s2705 = sbv_bv_extract_u8_0_0_u1(s2704); + const SBool s2706 = false != s2705; + const SWord8 s2707 = s2706 ? s2597 : s2598; + const SBool s2708 = sbv_bv_extract_u8_0_0_u1(s2707); + const SBool s2709 = false != s2708; + const SWord8 s2710 = s2709 ? s2603 : s2604; + const SBool s2711 = sbv_bv_extract_u8_0_0_u1(s2710); + const SBool s2712 = false != s2711; + const SBool s2713 = !s2712; + const SBool s2714 = s2704 < s1; + const SBool s2715 = s2704 < s2593; + const SBool s2716 = s2714 || s2715; + const SWord8 s2717 = sbv_bv_u8_rotr(s2704, 1); + const SWord8 s2718 = 128 | s2717; + const SWord8 s2719 = 127 & s2717; + const SWord8 s2720 = s2716 ? s2718 : s2719; + const SWord8 s2721 = sbv_bv_u8_rotr(s2720, 1); + const SWord8 s2722 = 128 | s2721; + const SWord8 s2723 = 127 & s2721; + const SWord8 s2724 = s2566 ? s2722 : s2723; + const SWord8 s2725 = sbv_bv_u8_rotr(s2724, 1); + const SWord8 s2726 = 128 | s2725; + const SWord8 s2727 = 127 & s2725; + const SWord8 s2728 = s2588 ? s2726 : s2727; + const SWord8 s2729 = sbv_bv_u8_rotr(s2728, 1); + const SWord8 s2730 = 128 | s2729; + const SWord8 s2731 = 127 & s2729; + const SWord8 s2732 = s2712 ? s2730 : s2731; + const SWord8 s2733 = sbv_bv_u8_add(s1, s2728); + const SBool s2734 = s2733 < s1; + const SBool s2735 = s2733 < s2728; + const SBool s2736 = s2734 || s2735; + const SWord8 s2737 = sbv_bv_u8_rotr(s2733, 1); + 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 = sbv_bv_u8_add(s1, s2724); + const SBool s2743 = s2742 < s1; + const SBool s2744 = s2742 < s2724; + const SBool s2745 = s2743 || s2744; + const SWord8 s2746 = sbv_bv_u8_rotr(s2742, 1); + const SWord8 s2747 = 128 | s2746; + const SWord8 s2748 = 127 & s2746; + const SWord8 s2749 = s2745 ? s2747 : s2748; + const SWord8 s2750 = sbv_bv_u8_rotr(s2749, 1); + const SWord8 s2751 = 128 | s2750; + const SWord8 s2752 = 127 & s2750; + const SWord8 s2753 = s2712 ? s2751 : s2752; + const SWord8 s2754 = sbv_bv_u8_add(s1, s2749); + const SBool s2755 = s2754 < s1; + const SBool s2756 = s2754 < s2749; + const SBool s2757 = s2755 || s2756; + const SWord8 s2758 = sbv_bv_u8_rotr(s2754, 1); + 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 = sbv_bv_u8_add(s1, s2720); + const SBool s2765 = s2764 < s1; + const SBool s2766 = s2764 < s2720; + const SBool s2767 = s2765 || s2766; + const SWord8 s2768 = sbv_bv_u8_rotr(s2764, 1); + const SWord8 s2769 = 128 | s2768; + const SWord8 s2770 = 127 & s2768; + const SWord8 s2771 = s2767 ? s2769 : s2770; + const SWord8 s2772 = sbv_bv_u8_rotr(s2771, 1); + const SWord8 s2773 = 128 | s2772; + const SWord8 s2774 = 127 & s2772; + const SWord8 s2775 = s2588 ? s2773 : s2774; + const SWord8 s2776 = sbv_bv_u8_rotr(s2775, 1); + const SWord8 s2777 = 128 | s2776; + const SWord8 s2778 = 127 & s2776; + const SWord8 s2779 = s2712 ? s2777 : s2778; + const SWord8 s2780 = sbv_bv_u8_add(s1, s2775); + const SBool s2781 = s2780 < s1; + const SBool s2782 = s2780 < s2775; + const SBool s2783 = s2781 || s2782; + const SWord8 s2784 = sbv_bv_u8_rotr(s2780, 1); + 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 = sbv_bv_u8_add(s1, s2771); + const SBool s2790 = s2789 < s1; + const SBool s2791 = s2789 < s2771; + const SBool s2792 = s2790 || s2791; + const SWord8 s2793 = sbv_bv_u8_rotr(s2789, 1); + const SWord8 s2794 = 128 | s2793; + const SWord8 s2795 = 127 & s2793; + const SWord8 s2796 = s2792 ? s2794 : s2795; + const SWord8 s2797 = sbv_bv_u8_rotr(s2796, 1); + const SWord8 s2798 = 128 | s2797; + const SWord8 s2799 = 127 & s2797; + const SWord8 s2800 = s2712 ? s2798 : s2799; + const SWord8 s2801 = sbv_bv_u8_add(s1, s2796); + const SBool s2802 = s2801 < s1; + const SBool s2803 = s2801 < s2796; + const SBool s2804 = s2802 || s2803; + const SWord8 s2805 = sbv_bv_u8_rotr(s2801, 1); + 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 = sbv_bv_u8_add(s1, s2574); + const SBool s2814 = sbv_bv_extract_u8_0_0_u1(s2813); + const SBool s2815 = false != s2814; + const SWord8 s2816 = s2815 ? s2578 : s2579; + const SBool s2817 = sbv_bv_extract_u8_0_0_u1(s2816); + const SBool s2818 = false != s2817; + const SWord8 s2819 = s2818 ? s2584 : s2585; + const SBool s2820 = sbv_bv_extract_u8_0_0_u1(s2819); + const SBool s2821 = false != s2820; + const SBool s2822 = !s2821; + const SBool s2823 = s2813 < s1; + const SBool s2824 = s2813 < s2574; + const SBool s2825 = s2823 || s2824; + const SWord8 s2826 = sbv_bv_u8_rotr(s2813, 1); + const SWord8 s2827 = 128 | s2826; + const SWord8 s2828 = 127 & s2826; + const SWord8 s2829 = s2825 ? s2827 : s2828; + const SBool s2830 = sbv_bv_extract_u8_0_0_u1(s2829); + const SBool s2831 = false != s2830; + const SWord8 s2832 = sbv_bv_u8_rotr(s2816, 1); + const SWord8 s2833 = 128 | s2832; + const SWord8 s2834 = 127 & s2832; + const SWord8 s2835 = s2831 ? s2833 : s2834; + const SBool s2836 = sbv_bv_extract_u8_0_0_u1(s2835); + const SBool s2837 = false != s2836; + const SWord8 s2838 = sbv_bv_u8_rotr(s2819, 1); + const SWord8 s2839 = 128 | s2838; + const SWord8 s2840 = 127 & s2838; + const SWord8 s2841 = s2837 ? s2839 : s2840; + const SBool s2842 = sbv_bv_extract_u8_0_0_u1(s2841); + const SBool s2843 = false != s2842; + const SBool s2844 = !s2843; + const SWord8 s2845 = sbv_bv_u8_rotr(s2829, 1); + const SWord8 s2846 = 128 | s2845; + const SWord8 s2847 = 127 & s2845; + const SWord8 s2848 = s2058 ? s2846 : s2847; + const SWord8 s2849 = sbv_bv_u8_rotr(s2848, 1); + const SWord8 s2850 = 128 | s2849; + const SWord8 s2851 = 127 & s2849; + const SWord8 s2852 = s2566 ? s2850 : s2851; + const SWord8 s2853 = sbv_bv_u8_rotr(s2852, 1); + const SWord8 s2854 = 128 | s2853; + const SWord8 s2855 = 127 & s2853; + const SWord8 s2856 = s2821 ? s2854 : s2855; + const SWord8 s2857 = sbv_bv_u8_rotr(s2856, 1); + const SWord8 s2858 = 128 | s2857; + const SWord8 s2859 = 127 & s2857; + const SWord8 s2860 = s2843 ? s2858 : s2859; + const SWord8 s2861 = sbv_bv_u8_add(s1, s2856); + const SBool s2862 = s2861 < s1; + const SBool s2863 = s2861 < s2856; + const SBool s2864 = s2862 || s2863; + const SWord8 s2865 = sbv_bv_u8_rotr(s2861, 1); + 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 = sbv_bv_u8_add(s1, s2852); + const SBool s2871 = s2870 < s1; + const SBool s2872 = s2870 < s2852; + const SBool s2873 = s2871 || s2872; + const SWord8 s2874 = sbv_bv_u8_rotr(s2870, 1); + const SWord8 s2875 = 128 | s2874; + const SWord8 s2876 = 127 & s2874; + const SWord8 s2877 = s2873 ? s2875 : s2876; + const SWord8 s2878 = sbv_bv_u8_rotr(s2877, 1); + const SWord8 s2879 = 128 | s2878; + const SWord8 s2880 = 127 & s2878; + const SWord8 s2881 = s2843 ? s2879 : s2880; + const SWord8 s2882 = sbv_bv_u8_add(s1, s2877); + const SBool s2883 = s2882 < s1; + const SBool s2884 = s2882 < s2877; + const SBool s2885 = s2883 || s2884; + const SWord8 s2886 = sbv_bv_u8_rotr(s2882, 1); + 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 = sbv_bv_u8_add(s1, s2848); + const SBool s2893 = s2892 < s1; + const SBool s2894 = s2892 < s2848; + const SBool s2895 = s2893 || s2894; + const SWord8 s2896 = sbv_bv_u8_rotr(s2892, 1); + const SWord8 s2897 = 128 | s2896; + const SWord8 s2898 = 127 & s2896; + const SWord8 s2899 = s2895 ? s2897 : s2898; + const SWord8 s2900 = sbv_bv_u8_rotr(s2899, 1); + const SWord8 s2901 = 128 | s2900; + const SWord8 s2902 = 127 & s2900; + const SWord8 s2903 = s2821 ? s2901 : s2902; + const SWord8 s2904 = sbv_bv_u8_rotr(s2903, 1); + const SWord8 s2905 = 128 | s2904; + const SWord8 s2906 = 127 & s2904; + const SWord8 s2907 = s2843 ? s2905 : s2906; + const SWord8 s2908 = sbv_bv_u8_add(s1, s2903); + const SBool s2909 = s2908 < s1; + const SBool s2910 = s2908 < s2903; + const SBool s2911 = s2909 || s2910; + const SWord8 s2912 = sbv_bv_u8_rotr(s2908, 1); + 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 = sbv_bv_u8_add(s1, s2899); + const SBool s2918 = s2917 < s1; + const SBool s2919 = s2917 < s2899; + const SBool s2920 = s2918 || s2919; + const SWord8 s2921 = sbv_bv_u8_rotr(s2917, 1); + const SWord8 s2922 = 128 | s2921; + const SWord8 s2923 = 127 & s2921; + const SWord8 s2924 = s2920 ? s2922 : s2923; + const SWord8 s2925 = sbv_bv_u8_rotr(s2924, 1); + const SWord8 s2926 = 128 | s2925; + const SWord8 s2927 = 127 & s2925; + const SWord8 s2928 = s2843 ? s2926 : s2927; + const SWord8 s2929 = sbv_bv_u8_add(s1, s2924); + const SBool s2930 = s2929 < s1; + const SBool s2931 = s2929 < s2924; + const SBool s2932 = s2930 || s2931; + const SWord8 s2933 = sbv_bv_u8_rotr(s2929, 1); + 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 = sbv_bv_u8_add(s1, s2829); + const SBool s2941 = sbv_bv_extract_u8_0_0_u1(s2940); + const SBool s2942 = false != s2941; + const SWord8 s2943 = s2942 ? s2833 : s2834; + const SBool s2944 = sbv_bv_extract_u8_0_0_u1(s2943); + const SBool s2945 = false != s2944; + const SWord8 s2946 = s2945 ? s2839 : s2840; + const SBool s2947 = sbv_bv_extract_u8_0_0_u1(s2946); + const SBool s2948 = false != s2947; + const SBool s2949 = !s2948; + const SBool s2950 = s2940 < s1; + const SBool s2951 = s2940 < s2829; + const SBool s2952 = s2950 || s2951; + const SWord8 s2953 = sbv_bv_u8_rotr(s2940, 1); + const SWord8 s2954 = 128 | s2953; + const SWord8 s2955 = 127 & s2953; + const SWord8 s2956 = s2952 ? s2954 : s2955; + const SWord8 s2957 = sbv_bv_u8_rotr(s2956, 1); + const SWord8 s2958 = 128 | s2957; + const SWord8 s2959 = 127 & s2957; + const SWord8 s2960 = s2566 ? s2958 : s2959; + const SWord8 s2961 = sbv_bv_u8_rotr(s2960, 1); + const SWord8 s2962 = 128 | s2961; + const SWord8 s2963 = 127 & s2961; + const SWord8 s2964 = s2821 ? s2962 : s2963; + const SWord8 s2965 = sbv_bv_u8_rotr(s2964, 1); + const SWord8 s2966 = 128 | s2965; + const SWord8 s2967 = 127 & s2965; + const SWord8 s2968 = s2948 ? s2966 : s2967; + const SWord8 s2969 = sbv_bv_u8_add(s1, s2964); + const SBool s2970 = s2969 < s1; + const SBool s2971 = s2969 < s2964; + const SBool s2972 = s2970 || s2971; + const SWord8 s2973 = sbv_bv_u8_rotr(s2969, 1); + 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 = sbv_bv_u8_add(s1, s2960); + const SBool s2979 = s2978 < s1; + const SBool s2980 = s2978 < s2960; + const SBool s2981 = s2979 || s2980; + const SWord8 s2982 = sbv_bv_u8_rotr(s2978, 1); + const SWord8 s2983 = 128 | s2982; + const SWord8 s2984 = 127 & s2982; + const SWord8 s2985 = s2981 ? s2983 : s2984; + const SWord8 s2986 = sbv_bv_u8_rotr(s2985, 1); + const SWord8 s2987 = 128 | s2986; + const SWord8 s2988 = 127 & s2986; + const SWord8 s2989 = s2948 ? s2987 : s2988; + const SWord8 s2990 = sbv_bv_u8_add(s1, s2985); + const SBool s2991 = s2990 < s1; + const SBool s2992 = s2990 < s2985; + const SBool s2993 = s2991 || s2992; + const SWord8 s2994 = sbv_bv_u8_rotr(s2990, 1); + 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 = sbv_bv_u8_add(s1, s2956); + const SBool s3001 = s3000 < s1; + const SBool s3002 = s3000 < s2956; + const SBool s3003 = s3001 || s3002; + const SWord8 s3004 = sbv_bv_u8_rotr(s3000, 1); + const SWord8 s3005 = 128 | s3004; + const SWord8 s3006 = 127 & s3004; + const SWord8 s3007 = s3003 ? s3005 : s3006; + const SWord8 s3008 = sbv_bv_u8_rotr(s3007, 1); + const SWord8 s3009 = 128 | s3008; + const SWord8 s3010 = 127 & s3008; + const SWord8 s3011 = s2821 ? s3009 : s3010; + const SWord8 s3012 = sbv_bv_u8_rotr(s3011, 1); + const SWord8 s3013 = 128 | s3012; + const SWord8 s3014 = 127 & s3012; + const SWord8 s3015 = s2948 ? s3013 : s3014; + const SWord8 s3016 = sbv_bv_u8_add(s1, s3011); + const SBool s3017 = s3016 < s1; + const SBool s3018 = s3016 < s3011; + const SBool s3019 = s3017 || s3018; + const SWord8 s3020 = sbv_bv_u8_rotr(s3016, 1); + 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 = sbv_bv_u8_add(s1, s3007); + const SBool s3026 = s3025 < s1; + const SBool s3027 = s3025 < s3007; + const SBool s3028 = s3026 || s3027; + const SWord8 s3029 = sbv_bv_u8_rotr(s3025, 1); + const SWord8 s3030 = 128 | s3029; + const SWord8 s3031 = 127 & s3029; + const SWord8 s3032 = s3028 ? s3030 : s3031; + const SWord8 s3033 = sbv_bv_u8_rotr(s3032, 1); + const SWord8 s3034 = 128 | s3033; + const SWord8 s3035 = 127 & s3033; + const SWord8 s3036 = s2948 ? s3034 : s3035; + const SWord8 s3037 = sbv_bv_u8_add(s1, s3032); + const SBool s3038 = s3037 < s1; + const SBool s3039 = s3037 < s3032; + const SBool s3040 = s3038 || s3039; + const SWord8 s3041 = sbv_bv_u8_rotr(s3037, 1); + const SWord8 s3042 = 128 | s3041; + const SWord8 s3043 = 127 & s3041; + const SWord8 s3044 = s3040 ? s3042 : s3043; + const SWord8 s3045 = s2949 ? s3036 : s3044; + const SWord8 s3046 = s2822 ? s3024 : s3045; + const SWord8 s3047 = s2567 ? s2999 : s3046; + const SWord8 s3048 = s2059 ? s2939 : s3047; + const SWord8 s3049 = s2042 ? s2812 : s3048; + const SWord8 s3050 = s16 ? s2557 : s3049; + const SWord8 s3051 = sbv_bv_u8_add(s1, s2044); + const SBool s3052 = sbv_bv_extract_u8_0_0_u1(s3051); + const SBool s3053 = false != s3052; + const SWord8 s3054 = s3053 ? s2048 : s2049; + const SBool s3055 = sbv_bv_extract_u8_0_0_u1(s3054); + const SBool s3056 = false != s3055; + const SWord8 s3057 = s3056 ? s2054 : s2055; + const SBool s3058 = sbv_bv_extract_u8_0_0_u1(s3057); + const SBool s3059 = false != s3058; + const SBool s3060 = !s3059; + const SBool s3061 = s3051 < s1; + const SBool s3062 = s3051 < s2044; + const SBool s3063 = s3061 || s3062; + const SWord8 s3064 = sbv_bv_u8_rotr(s3051, 1); + const SWord8 s3065 = 128 | s3064; + const SWord8 s3066 = 127 & s3064; + const SWord8 s3067 = s3063 ? s3065 : s3066; + const SBool s3068 = sbv_bv_extract_u8_0_0_u1(s3067); + const SBool s3069 = false != s3068; + const SWord8 s3070 = sbv_bv_u8_rotr(s3054, 1); + const SWord8 s3071 = 128 | s3070; + const SWord8 s3072 = 127 & s3070; + const SWord8 s3073 = s3069 ? s3071 : s3072; + const SBool s3074 = sbv_bv_extract_u8_0_0_u1(s3073); + const SBool s3075 = false != s3074; + const SWord8 s3076 = sbv_bv_u8_rotr(s3057, 1); + const SWord8 s3077 = 128 | s3076; + const SWord8 s3078 = 127 & s3076; + const SWord8 s3079 = s3075 ? s3077 : s3078; + const SBool s3080 = sbv_bv_extract_u8_0_0_u1(s3079); + const SBool s3081 = false != s3080; + const SBool s3082 = !s3081; + const SWord8 s3083 = sbv_bv_u8_rotr(s3067, 1); + const SWord8 s3084 = 128 | s3083; + const SWord8 s3085 = 127 & s3083; + const SWord8 s3086 = s15 ? s3084 : s3085; + const SBool s3087 = sbv_bv_extract_u8_0_0_u1(s3086); + const SBool s3088 = false != s3087; + const SWord8 s3089 = sbv_bv_u8_rotr(s3073, 1); + const SWord8 s3090 = 128 | s3089; + const SWord8 s3091 = 127 & s3089; + const SWord8 s3092 = s3088 ? s3090 : s3091; + const SBool s3093 = sbv_bv_extract_u8_0_0_u1(s3092); + const SBool s3094 = false != s3093; + const SWord8 s3095 = sbv_bv_u8_rotr(s3079, 1); + const SWord8 s3096 = 128 | s3095; + const SWord8 s3097 = 127 & s3095; + const SWord8 s3098 = s3094 ? s3096 : s3097; + const SBool s3099 = sbv_bv_extract_u8_0_0_u1(s3098); + const SBool s3100 = false != s3099; + const SBool s3101 = !s3100; + const SWord8 s3102 = sbv_bv_u8_rotr(s3086, 1); + const SWord8 s3103 = 128 | s3102; + const SWord8 s3104 = 127 & s3102; + const SWord8 s3105 = s2041 ? s3103 : s3104; + const SBool s3106 = sbv_bv_extract_u8_0_0_u1(s3105); + const SBool s3107 = false != s3106; + const SWord8 s3108 = sbv_bv_u8_rotr(s3092, 1); + const SWord8 s3109 = 128 | s3108; + const SWord8 s3110 = 127 & s3108; + const SWord8 s3111 = s3107 ? s3109 : s3110; + const SBool s3112 = sbv_bv_extract_u8_0_0_u1(s3111); + const SBool s3113 = false != s3112; + const SWord8 s3114 = sbv_bv_u8_rotr(s3098, 1); + const SWord8 s3115 = 128 | s3114; + const SWord8 s3116 = 127 & s3114; + const SWord8 s3117 = s3113 ? s3115 : s3116; + const SBool s3118 = sbv_bv_extract_u8_0_0_u1(s3117); + const SBool s3119 = false != s3118; + const SBool s3120 = !s3119; + const SWord8 s3121 = sbv_bv_u8_rotr(s3105, 1); + const SWord8 s3122 = 128 | s3121; + const SWord8 s3123 = 127 & s3121; + const SWord8 s3124 = s3059 ? s3122 : s3123; + const SWord8 s3125 = sbv_bv_u8_rotr(s3124, 1); + const SWord8 s3126 = 128 | s3125; + const SWord8 s3127 = 127 & s3125; + const SWord8 s3128 = s3081 ? s3126 : s3127; + const SWord8 s3129 = sbv_bv_u8_rotr(s3128, 1); + const SWord8 s3130 = 128 | s3129; + const SWord8 s3131 = 127 & s3129; + const SWord8 s3132 = s3100 ? s3130 : s3131; + const SWord8 s3133 = sbv_bv_u8_rotr(s3132, 1); + const SWord8 s3134 = 128 | s3133; + const SWord8 s3135 = 127 & s3133; + const SWord8 s3136 = s3119 ? s3134 : s3135; + const SWord8 s3137 = sbv_bv_u8_add(s1, s3132); + const SBool s3138 = s3137 < s1; + const SBool s3139 = s3137 < s3132; + const SBool s3140 = s3138 || s3139; + const SWord8 s3141 = sbv_bv_u8_rotr(s3137, 1); + 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 = sbv_bv_u8_add(s1, s3128); + const SBool s3147 = s3146 < s1; + const SBool s3148 = s3146 < s3128; + const SBool s3149 = s3147 || s3148; + const SWord8 s3150 = sbv_bv_u8_rotr(s3146, 1); + const SWord8 s3151 = 128 | s3150; + const SWord8 s3152 = 127 & s3150; + const SWord8 s3153 = s3149 ? s3151 : s3152; + const SWord8 s3154 = sbv_bv_u8_rotr(s3153, 1); + const SWord8 s3155 = 128 | s3154; + const SWord8 s3156 = 127 & s3154; + const SWord8 s3157 = s3119 ? s3155 : s3156; + const SWord8 s3158 = sbv_bv_u8_add(s1, s3153); + const SBool s3159 = s3158 < s1; + const SBool s3160 = s3158 < s3153; + const SBool s3161 = s3159 || s3160; + const SWord8 s3162 = sbv_bv_u8_rotr(s3158, 1); + 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 = sbv_bv_u8_add(s1, s3124); + const SBool s3169 = s3168 < s1; + const SBool s3170 = s3168 < s3124; + const SBool s3171 = s3169 || s3170; + const SWord8 s3172 = sbv_bv_u8_rotr(s3168, 1); + const SWord8 s3173 = 128 | s3172; + const SWord8 s3174 = 127 & s3172; + const SWord8 s3175 = s3171 ? s3173 : s3174; + const SWord8 s3176 = sbv_bv_u8_rotr(s3175, 1); + const SWord8 s3177 = 128 | s3176; + const SWord8 s3178 = 127 & s3176; + const SWord8 s3179 = s3100 ? s3177 : s3178; + const SWord8 s3180 = sbv_bv_u8_rotr(s3179, 1); + const SWord8 s3181 = 128 | s3180; + const SWord8 s3182 = 127 & s3180; + const SWord8 s3183 = s3119 ? s3181 : s3182; + const SWord8 s3184 = sbv_bv_u8_add(s1, s3179); + const SBool s3185 = s3184 < s1; + const SBool s3186 = s3184 < s3179; + const SBool s3187 = s3185 || s3186; + const SWord8 s3188 = sbv_bv_u8_rotr(s3184, 1); + 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 = sbv_bv_u8_add(s1, s3175); + const SBool s3194 = s3193 < s1; + const SBool s3195 = s3193 < s3175; + const SBool s3196 = s3194 || s3195; + const SWord8 s3197 = sbv_bv_u8_rotr(s3193, 1); + const SWord8 s3198 = 128 | s3197; + const SWord8 s3199 = 127 & s3197; + const SWord8 s3200 = s3196 ? s3198 : s3199; + const SWord8 s3201 = sbv_bv_u8_rotr(s3200, 1); + const SWord8 s3202 = 128 | s3201; + const SWord8 s3203 = 127 & s3201; + const SWord8 s3204 = s3119 ? s3202 : s3203; + const SWord8 s3205 = sbv_bv_u8_add(s1, s3200); + const SBool s3206 = s3205 < s1; + const SBool s3207 = s3205 < s3200; + const SBool s3208 = s3206 || s3207; + const SWord8 s3209 = sbv_bv_u8_rotr(s3205, 1); + 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 = sbv_bv_u8_add(s1, s3105); + const SBool s3217 = sbv_bv_extract_u8_0_0_u1(s3216); + const SBool s3218 = false != s3217; + const SWord8 s3219 = s3218 ? s3109 : s3110; + const SBool s3220 = sbv_bv_extract_u8_0_0_u1(s3219); + const SBool s3221 = false != s3220; + const SWord8 s3222 = s3221 ? s3115 : s3116; + const SBool s3223 = sbv_bv_extract_u8_0_0_u1(s3222); + const SBool s3224 = false != s3223; + const SBool s3225 = !s3224; + const SBool s3226 = s3216 < s1; + const SBool s3227 = s3216 < s3105; + const SBool s3228 = s3226 || s3227; + const SWord8 s3229 = sbv_bv_u8_rotr(s3216, 1); + const SWord8 s3230 = 128 | s3229; + const SWord8 s3231 = 127 & s3229; + const SWord8 s3232 = s3228 ? s3230 : s3231; + const SWord8 s3233 = sbv_bv_u8_rotr(s3232, 1); + const SWord8 s3234 = 128 | s3233; + const SWord8 s3235 = 127 & s3233; + const SWord8 s3236 = s3081 ? s3234 : s3235; + const SWord8 s3237 = sbv_bv_u8_rotr(s3236, 1); + const SWord8 s3238 = 128 | s3237; + const SWord8 s3239 = 127 & s3237; + const SWord8 s3240 = s3100 ? s3238 : s3239; + const SWord8 s3241 = sbv_bv_u8_rotr(s3240, 1); + const SWord8 s3242 = 128 | s3241; + const SWord8 s3243 = 127 & s3241; + const SWord8 s3244 = s3224 ? s3242 : s3243; + const SWord8 s3245 = sbv_bv_u8_add(s1, s3240); + const SBool s3246 = s3245 < s1; + const SBool s3247 = s3245 < s3240; + const SBool s3248 = s3246 || s3247; + const SWord8 s3249 = sbv_bv_u8_rotr(s3245, 1); + 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 = sbv_bv_u8_add(s1, s3236); + const SBool s3255 = s3254 < s1; + const SBool s3256 = s3254 < s3236; + const SBool s3257 = s3255 || s3256; + const SWord8 s3258 = sbv_bv_u8_rotr(s3254, 1); + const SWord8 s3259 = 128 | s3258; + const SWord8 s3260 = 127 & s3258; + const SWord8 s3261 = s3257 ? s3259 : s3260; + const SWord8 s3262 = sbv_bv_u8_rotr(s3261, 1); + const SWord8 s3263 = 128 | s3262; + const SWord8 s3264 = 127 & s3262; + const SWord8 s3265 = s3224 ? s3263 : s3264; + const SWord8 s3266 = sbv_bv_u8_add(s1, s3261); + const SBool s3267 = s3266 < s1; + const SBool s3268 = s3266 < s3261; + const SBool s3269 = s3267 || s3268; + const SWord8 s3270 = sbv_bv_u8_rotr(s3266, 1); + 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 = sbv_bv_u8_add(s1, s3232); + const SBool s3277 = s3276 < s1; + const SBool s3278 = s3276 < s3232; + const SBool s3279 = s3277 || s3278; + const SWord8 s3280 = sbv_bv_u8_rotr(s3276, 1); + const SWord8 s3281 = 128 | s3280; + const SWord8 s3282 = 127 & s3280; + const SWord8 s3283 = s3279 ? s3281 : s3282; + const SWord8 s3284 = sbv_bv_u8_rotr(s3283, 1); + const SWord8 s3285 = 128 | s3284; + const SWord8 s3286 = 127 & s3284; + const SWord8 s3287 = s3100 ? s3285 : s3286; + const SWord8 s3288 = sbv_bv_u8_rotr(s3287, 1); + const SWord8 s3289 = 128 | s3288; + const SWord8 s3290 = 127 & s3288; + const SWord8 s3291 = s3224 ? s3289 : s3290; + const SWord8 s3292 = sbv_bv_u8_add(s1, s3287); + const SBool s3293 = s3292 < s1; + const SBool s3294 = s3292 < s3287; + const SBool s3295 = s3293 || s3294; + const SWord8 s3296 = sbv_bv_u8_rotr(s3292, 1); + 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 = sbv_bv_u8_add(s1, s3283); + const SBool s3302 = s3301 < s1; + const SBool s3303 = s3301 < s3283; + const SBool s3304 = s3302 || s3303; + const SWord8 s3305 = sbv_bv_u8_rotr(s3301, 1); + const SWord8 s3306 = 128 | s3305; + const SWord8 s3307 = 127 & s3305; + const SWord8 s3308 = s3304 ? s3306 : s3307; + const SWord8 s3309 = sbv_bv_u8_rotr(s3308, 1); + const SWord8 s3310 = 128 | s3309; + const SWord8 s3311 = 127 & s3309; + const SWord8 s3312 = s3224 ? s3310 : s3311; + const SWord8 s3313 = sbv_bv_u8_add(s1, s3308); + const SBool s3314 = s3313 < s1; + const SBool s3315 = s3313 < s3308; + const SBool s3316 = s3314 || s3315; + const SWord8 s3317 = sbv_bv_u8_rotr(s3313, 1); + 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 = sbv_bv_u8_add(s1, s3086); + const SBool s3326 = sbv_bv_extract_u8_0_0_u1(s3325); + const SBool s3327 = false != s3326; + const SWord8 s3328 = s3327 ? s3090 : s3091; + const SBool s3329 = sbv_bv_extract_u8_0_0_u1(s3328); + const SBool s3330 = false != s3329; + const SWord8 s3331 = s3330 ? s3096 : s3097; + const SBool s3332 = sbv_bv_extract_u8_0_0_u1(s3331); + const SBool s3333 = false != s3332; + const SBool s3334 = !s3333; + const SBool s3335 = s3325 < s1; + const SBool s3336 = s3325 < s3086; + const SBool s3337 = s3335 || s3336; + const SWord8 s3338 = sbv_bv_u8_rotr(s3325, 1); + const SWord8 s3339 = 128 | s3338; + const SWord8 s3340 = 127 & s3338; + const SWord8 s3341 = s3337 ? s3339 : s3340; + const SBool s3342 = sbv_bv_extract_u8_0_0_u1(s3341); + const SBool s3343 = false != s3342; + const SWord8 s3344 = sbv_bv_u8_rotr(s3328, 1); + const SWord8 s3345 = 128 | s3344; + const SWord8 s3346 = 127 & s3344; + const SWord8 s3347 = s3343 ? s3345 : s3346; + const SBool s3348 = sbv_bv_extract_u8_0_0_u1(s3347); + const SBool s3349 = false != s3348; + const SWord8 s3350 = sbv_bv_u8_rotr(s3331, 1); + const SWord8 s3351 = 128 | s3350; + const SWord8 s3352 = 127 & s3350; + const SWord8 s3353 = s3349 ? s3351 : s3352; + const SBool s3354 = sbv_bv_extract_u8_0_0_u1(s3353); + const SBool s3355 = false != s3354; + const SBool s3356 = !s3355; + const SWord8 s3357 = sbv_bv_u8_rotr(s3341, 1); + const SWord8 s3358 = 128 | s3357; + const SWord8 s3359 = 127 & s3357; + const SWord8 s3360 = s3059 ? s3358 : s3359; + const SWord8 s3361 = sbv_bv_u8_rotr(s3360, 1); + const SWord8 s3362 = 128 | s3361; + const SWord8 s3363 = 127 & s3361; + const SWord8 s3364 = s3081 ? s3362 : s3363; + const SWord8 s3365 = sbv_bv_u8_rotr(s3364, 1); + const SWord8 s3366 = 128 | s3365; + const SWord8 s3367 = 127 & s3365; + const SWord8 s3368 = s3333 ? s3366 : s3367; + const SWord8 s3369 = sbv_bv_u8_rotr(s3368, 1); + const SWord8 s3370 = 128 | s3369; + const SWord8 s3371 = 127 & s3369; + const SWord8 s3372 = s3355 ? s3370 : s3371; + const SWord8 s3373 = sbv_bv_u8_add(s1, s3368); + const SBool s3374 = s3373 < s1; + const SBool s3375 = s3373 < s3368; + const SBool s3376 = s3374 || s3375; + const SWord8 s3377 = sbv_bv_u8_rotr(s3373, 1); + 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 = sbv_bv_u8_add(s1, s3364); + const SBool s3383 = s3382 < s1; + const SBool s3384 = s3382 < s3364; + const SBool s3385 = s3383 || s3384; + const SWord8 s3386 = sbv_bv_u8_rotr(s3382, 1); + const SWord8 s3387 = 128 | s3386; + const SWord8 s3388 = 127 & s3386; + const SWord8 s3389 = s3385 ? s3387 : s3388; + const SWord8 s3390 = sbv_bv_u8_rotr(s3389, 1); + const SWord8 s3391 = 128 | s3390; + const SWord8 s3392 = 127 & s3390; + const SWord8 s3393 = s3355 ? s3391 : s3392; + const SWord8 s3394 = sbv_bv_u8_add(s1, s3389); + const SBool s3395 = s3394 < s1; + const SBool s3396 = s3394 < s3389; + const SBool s3397 = s3395 || s3396; + const SWord8 s3398 = sbv_bv_u8_rotr(s3394, 1); + 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 = sbv_bv_u8_add(s1, s3360); + const SBool s3405 = s3404 < s1; + const SBool s3406 = s3404 < s3360; + const SBool s3407 = s3405 || s3406; + const SWord8 s3408 = sbv_bv_u8_rotr(s3404, 1); + const SWord8 s3409 = 128 | s3408; + const SWord8 s3410 = 127 & s3408; + const SWord8 s3411 = s3407 ? s3409 : s3410; + const SWord8 s3412 = sbv_bv_u8_rotr(s3411, 1); + const SWord8 s3413 = 128 | s3412; + const SWord8 s3414 = 127 & s3412; + const SWord8 s3415 = s3333 ? s3413 : s3414; + const SWord8 s3416 = sbv_bv_u8_rotr(s3415, 1); + const SWord8 s3417 = 128 | s3416; + const SWord8 s3418 = 127 & s3416; + const SWord8 s3419 = s3355 ? s3417 : s3418; + const SWord8 s3420 = sbv_bv_u8_add(s1, s3415); + const SBool s3421 = s3420 < s1; + const SBool s3422 = s3420 < s3415; + const SBool s3423 = s3421 || s3422; + const SWord8 s3424 = sbv_bv_u8_rotr(s3420, 1); + 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 = sbv_bv_u8_add(s1, s3411); + const SBool s3430 = s3429 < s1; + const SBool s3431 = s3429 < s3411; + const SBool s3432 = s3430 || s3431; + const SWord8 s3433 = sbv_bv_u8_rotr(s3429, 1); + const SWord8 s3434 = 128 | s3433; + const SWord8 s3435 = 127 & s3433; + const SWord8 s3436 = s3432 ? s3434 : s3435; + const SWord8 s3437 = sbv_bv_u8_rotr(s3436, 1); + const SWord8 s3438 = 128 | s3437; + const SWord8 s3439 = 127 & s3437; + const SWord8 s3440 = s3355 ? s3438 : s3439; + const SWord8 s3441 = sbv_bv_u8_add(s1, s3436); + const SBool s3442 = s3441 < s1; + const SBool s3443 = s3441 < s3436; + const SBool s3444 = s3442 || s3443; + const SWord8 s3445 = sbv_bv_u8_rotr(s3441, 1); + 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 = sbv_bv_u8_add(s1, s3341); + const SBool s3453 = sbv_bv_extract_u8_0_0_u1(s3452); + const SBool s3454 = false != s3453; + const SWord8 s3455 = s3454 ? s3345 : s3346; + const SBool s3456 = sbv_bv_extract_u8_0_0_u1(s3455); + const SBool s3457 = false != s3456; + const SWord8 s3458 = s3457 ? s3351 : s3352; + const SBool s3459 = sbv_bv_extract_u8_0_0_u1(s3458); + const SBool s3460 = false != s3459; + const SBool s3461 = !s3460; + const SBool s3462 = s3452 < s1; + const SBool s3463 = s3452 < s3341; + const SBool s3464 = s3462 || s3463; + const SWord8 s3465 = sbv_bv_u8_rotr(s3452, 1); + const SWord8 s3466 = 128 | s3465; + const SWord8 s3467 = 127 & s3465; + const SWord8 s3468 = s3464 ? s3466 : s3467; + const SWord8 s3469 = sbv_bv_u8_rotr(s3468, 1); + const SWord8 s3470 = 128 | s3469; + const SWord8 s3471 = 127 & s3469; + const SWord8 s3472 = s3081 ? s3470 : s3471; + const SWord8 s3473 = sbv_bv_u8_rotr(s3472, 1); + const SWord8 s3474 = 128 | s3473; + const SWord8 s3475 = 127 & s3473; + const SWord8 s3476 = s3333 ? s3474 : s3475; + const SWord8 s3477 = sbv_bv_u8_rotr(s3476, 1); + const SWord8 s3478 = 128 | s3477; + const SWord8 s3479 = 127 & s3477; + const SWord8 s3480 = s3460 ? s3478 : s3479; + const SWord8 s3481 = sbv_bv_u8_add(s1, s3476); + const SBool s3482 = s3481 < s1; + const SBool s3483 = s3481 < s3476; + const SBool s3484 = s3482 || s3483; + const SWord8 s3485 = sbv_bv_u8_rotr(s3481, 1); + 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 = sbv_bv_u8_add(s1, s3472); + const SBool s3491 = s3490 < s1; + const SBool s3492 = s3490 < s3472; + const SBool s3493 = s3491 || s3492; + const SWord8 s3494 = sbv_bv_u8_rotr(s3490, 1); + const SWord8 s3495 = 128 | s3494; + const SWord8 s3496 = 127 & s3494; + const SWord8 s3497 = s3493 ? s3495 : s3496; + const SWord8 s3498 = sbv_bv_u8_rotr(s3497, 1); + const SWord8 s3499 = 128 | s3498; + const SWord8 s3500 = 127 & s3498; + const SWord8 s3501 = s3460 ? s3499 : s3500; + const SWord8 s3502 = sbv_bv_u8_add(s1, s3497); + const SBool s3503 = s3502 < s1; + const SBool s3504 = s3502 < s3497; + const SBool s3505 = s3503 || s3504; + const SWord8 s3506 = sbv_bv_u8_rotr(s3502, 1); + 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 = sbv_bv_u8_add(s1, s3468); + const SBool s3513 = s3512 < s1; + const SBool s3514 = s3512 < s3468; + const SBool s3515 = s3513 || s3514; + const SWord8 s3516 = sbv_bv_u8_rotr(s3512, 1); + const SWord8 s3517 = 128 | s3516; + const SWord8 s3518 = 127 & s3516; + const SWord8 s3519 = s3515 ? s3517 : s3518; + const SWord8 s3520 = sbv_bv_u8_rotr(s3519, 1); + const SWord8 s3521 = 128 | s3520; + const SWord8 s3522 = 127 & s3520; + const SWord8 s3523 = s3333 ? s3521 : s3522; + const SWord8 s3524 = sbv_bv_u8_rotr(s3523, 1); + const SWord8 s3525 = 128 | s3524; + const SWord8 s3526 = 127 & s3524; + const SWord8 s3527 = s3460 ? s3525 : s3526; + const SWord8 s3528 = sbv_bv_u8_add(s1, s3523); + const SBool s3529 = s3528 < s1; + const SBool s3530 = s3528 < s3523; + const SBool s3531 = s3529 || s3530; + const SWord8 s3532 = sbv_bv_u8_rotr(s3528, 1); + 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 = sbv_bv_u8_add(s1, s3519); + const SBool s3538 = s3537 < s1; + const SBool s3539 = s3537 < s3519; + const SBool s3540 = s3538 || s3539; + const SWord8 s3541 = sbv_bv_u8_rotr(s3537, 1); + const SWord8 s3542 = 128 | s3541; + const SWord8 s3543 = 127 & s3541; + const SWord8 s3544 = s3540 ? s3542 : s3543; + const SWord8 s3545 = sbv_bv_u8_rotr(s3544, 1); + const SWord8 s3546 = 128 | s3545; + const SWord8 s3547 = 127 & s3545; + const SWord8 s3548 = s3460 ? s3546 : s3547; + const SWord8 s3549 = sbv_bv_u8_add(s1, s3544); + const SBool s3550 = s3549 < s1; + const SBool s3551 = s3549 < s3544; + const SBool s3552 = s3550 || s3551; + const SWord8 s3553 = sbv_bv_u8_rotr(s3549, 1); + 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 = sbv_bv_u8_add(s1, s3067); + const SBool s3563 = sbv_bv_extract_u8_0_0_u1(s3562); + const SBool s3564 = false != s3563; + const SWord8 s3565 = s3564 ? s3071 : s3072; + const SBool s3566 = sbv_bv_extract_u8_0_0_u1(s3565); + const SBool s3567 = false != s3566; + const SWord8 s3568 = s3567 ? s3077 : s3078; + const SBool s3569 = sbv_bv_extract_u8_0_0_u1(s3568); + const SBool s3570 = false != s3569; + const SBool s3571 = !s3570; + const SBool s3572 = s3562 < s1; + const SBool s3573 = s3562 < s3067; + const SBool s3574 = s3572 || s3573; + const SWord8 s3575 = sbv_bv_u8_rotr(s3562, 1); + const SWord8 s3576 = 128 | s3575; + const SWord8 s3577 = 127 & s3575; + const SWord8 s3578 = s3574 ? s3576 : s3577; + const SBool s3579 = sbv_bv_extract_u8_0_0_u1(s3578); + const SBool s3580 = false != s3579; + const SWord8 s3581 = sbv_bv_u8_rotr(s3565, 1); + const SWord8 s3582 = 128 | s3581; + const SWord8 s3583 = 127 & s3581; + const SWord8 s3584 = s3580 ? s3582 : s3583; + const SBool s3585 = sbv_bv_extract_u8_0_0_u1(s3584); + const SBool s3586 = false != s3585; + const SWord8 s3587 = sbv_bv_u8_rotr(s3568, 1); + const SWord8 s3588 = 128 | s3587; + const SWord8 s3589 = 127 & s3587; + const SWord8 s3590 = s3586 ? s3588 : s3589; + const SBool s3591 = sbv_bv_extract_u8_0_0_u1(s3590); + const SBool s3592 = false != s3591; + const SBool s3593 = !s3592; + const SWord8 s3594 = sbv_bv_u8_rotr(s3578, 1); + const SWord8 s3595 = 128 | s3594; + const SWord8 s3596 = 127 & s3594; + const SWord8 s3597 = s2041 ? s3595 : s3596; + const SBool s3598 = sbv_bv_extract_u8_0_0_u1(s3597); + const SBool s3599 = false != s3598; + const SWord8 s3600 = sbv_bv_u8_rotr(s3584, 1); + const SWord8 s3601 = 128 | s3600; + const SWord8 s3602 = 127 & s3600; + const SWord8 s3603 = s3599 ? s3601 : s3602; + const SBool s3604 = sbv_bv_extract_u8_0_0_u1(s3603); + const SBool s3605 = false != s3604; + const SWord8 s3606 = sbv_bv_u8_rotr(s3590, 1); + const SWord8 s3607 = 128 | s3606; + const SWord8 s3608 = 127 & s3606; + const SWord8 s3609 = s3605 ? s3607 : s3608; + const SBool s3610 = sbv_bv_extract_u8_0_0_u1(s3609); + const SBool s3611 = false != s3610; + const SBool s3612 = !s3611; + const SWord8 s3613 = sbv_bv_u8_rotr(s3597, 1); + const SWord8 s3614 = 128 | s3613; + const SWord8 s3615 = 127 & s3613; + const SWord8 s3616 = s3059 ? s3614 : s3615; + const SWord8 s3617 = sbv_bv_u8_rotr(s3616, 1); + const SWord8 s3618 = 128 | s3617; + const SWord8 s3619 = 127 & s3617; + const SWord8 s3620 = s3570 ? s3618 : s3619; + const SWord8 s3621 = sbv_bv_u8_rotr(s3620, 1); + const SWord8 s3622 = 128 | s3621; + const SWord8 s3623 = 127 & s3621; + const SWord8 s3624 = s3592 ? s3622 : s3623; + const SWord8 s3625 = sbv_bv_u8_rotr(s3624, 1); + const SWord8 s3626 = 128 | s3625; + const SWord8 s3627 = 127 & s3625; + const SWord8 s3628 = s3611 ? s3626 : s3627; + const SWord8 s3629 = sbv_bv_u8_add(s1, s3624); + const SBool s3630 = s3629 < s1; + const SBool s3631 = s3629 < s3624; + const SBool s3632 = s3630 || s3631; + const SWord8 s3633 = sbv_bv_u8_rotr(s3629, 1); + 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 = sbv_bv_u8_add(s1, s3620); + const SBool s3639 = s3638 < s1; + const SBool s3640 = s3638 < s3620; + const SBool s3641 = s3639 || s3640; + const SWord8 s3642 = sbv_bv_u8_rotr(s3638, 1); + const SWord8 s3643 = 128 | s3642; + const SWord8 s3644 = 127 & s3642; + const SWord8 s3645 = s3641 ? s3643 : s3644; + const SWord8 s3646 = sbv_bv_u8_rotr(s3645, 1); + const SWord8 s3647 = 128 | s3646; + const SWord8 s3648 = 127 & s3646; + const SWord8 s3649 = s3611 ? s3647 : s3648; + const SWord8 s3650 = sbv_bv_u8_add(s1, s3645); + const SBool s3651 = s3650 < s1; + const SBool s3652 = s3650 < s3645; + const SBool s3653 = s3651 || s3652; + const SWord8 s3654 = sbv_bv_u8_rotr(s3650, 1); + 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 = sbv_bv_u8_add(s1, s3616); + const SBool s3661 = s3660 < s1; + const SBool s3662 = s3660 < s3616; + const SBool s3663 = s3661 || s3662; + const SWord8 s3664 = sbv_bv_u8_rotr(s3660, 1); + const SWord8 s3665 = 128 | s3664; + const SWord8 s3666 = 127 & s3664; + const SWord8 s3667 = s3663 ? s3665 : s3666; + const SWord8 s3668 = sbv_bv_u8_rotr(s3667, 1); + const SWord8 s3669 = 128 | s3668; + const SWord8 s3670 = 127 & s3668; + const SWord8 s3671 = s3592 ? s3669 : s3670; + const SWord8 s3672 = sbv_bv_u8_rotr(s3671, 1); + const SWord8 s3673 = 128 | s3672; + const SWord8 s3674 = 127 & s3672; + const SWord8 s3675 = s3611 ? s3673 : s3674; + const SWord8 s3676 = sbv_bv_u8_add(s1, s3671); + const SBool s3677 = s3676 < s1; + const SBool s3678 = s3676 < s3671; + const SBool s3679 = s3677 || s3678; + const SWord8 s3680 = sbv_bv_u8_rotr(s3676, 1); + 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 = sbv_bv_u8_add(s1, s3667); + const SBool s3686 = s3685 < s1; + const SBool s3687 = s3685 < s3667; + const SBool s3688 = s3686 || s3687; + const SWord8 s3689 = sbv_bv_u8_rotr(s3685, 1); + const SWord8 s3690 = 128 | s3689; + const SWord8 s3691 = 127 & s3689; + const SWord8 s3692 = s3688 ? s3690 : s3691; + const SWord8 s3693 = sbv_bv_u8_rotr(s3692, 1); + const SWord8 s3694 = 128 | s3693; + const SWord8 s3695 = 127 & s3693; + const SWord8 s3696 = s3611 ? s3694 : s3695; + const SWord8 s3697 = sbv_bv_u8_add(s1, s3692); + const SBool s3698 = s3697 < s1; + const SBool s3699 = s3697 < s3692; + const SBool s3700 = s3698 || s3699; + const SWord8 s3701 = sbv_bv_u8_rotr(s3697, 1); + 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 = sbv_bv_u8_add(s1, s3597); + const SBool s3709 = sbv_bv_extract_u8_0_0_u1(s3708); + const SBool s3710 = false != s3709; + const SWord8 s3711 = s3710 ? s3601 : s3602; + const SBool s3712 = sbv_bv_extract_u8_0_0_u1(s3711); + const SBool s3713 = false != s3712; + const SWord8 s3714 = s3713 ? s3607 : s3608; + const SBool s3715 = sbv_bv_extract_u8_0_0_u1(s3714); + const SBool s3716 = false != s3715; + const SBool s3717 = !s3716; + const SBool s3718 = s3708 < s1; + const SBool s3719 = s3708 < s3597; + const SBool s3720 = s3718 || s3719; + const SWord8 s3721 = sbv_bv_u8_rotr(s3708, 1); + const SWord8 s3722 = 128 | s3721; + const SWord8 s3723 = 127 & s3721; + const SWord8 s3724 = s3720 ? s3722 : s3723; + const SWord8 s3725 = sbv_bv_u8_rotr(s3724, 1); + const SWord8 s3726 = 128 | s3725; + const SWord8 s3727 = 127 & s3725; + const SWord8 s3728 = s3570 ? s3726 : s3727; + const SWord8 s3729 = sbv_bv_u8_rotr(s3728, 1); + const SWord8 s3730 = 128 | s3729; + const SWord8 s3731 = 127 & s3729; + const SWord8 s3732 = s3592 ? s3730 : s3731; + const SWord8 s3733 = sbv_bv_u8_rotr(s3732, 1); + const SWord8 s3734 = 128 | s3733; + const SWord8 s3735 = 127 & s3733; + const SWord8 s3736 = s3716 ? s3734 : s3735; + const SWord8 s3737 = sbv_bv_u8_add(s1, s3732); + const SBool s3738 = s3737 < s1; + const SBool s3739 = s3737 < s3732; + const SBool s3740 = s3738 || s3739; + const SWord8 s3741 = sbv_bv_u8_rotr(s3737, 1); + 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 = sbv_bv_u8_add(s1, s3728); + const SBool s3747 = s3746 < s1; + const SBool s3748 = s3746 < s3728; + const SBool s3749 = s3747 || s3748; + const SWord8 s3750 = sbv_bv_u8_rotr(s3746, 1); + const SWord8 s3751 = 128 | s3750; + const SWord8 s3752 = 127 & s3750; + const SWord8 s3753 = s3749 ? s3751 : s3752; + const SWord8 s3754 = sbv_bv_u8_rotr(s3753, 1); + const SWord8 s3755 = 128 | s3754; + const SWord8 s3756 = 127 & s3754; + const SWord8 s3757 = s3716 ? s3755 : s3756; + const SWord8 s3758 = sbv_bv_u8_add(s1, s3753); + const SBool s3759 = s3758 < s1; + const SBool s3760 = s3758 < s3753; + const SBool s3761 = s3759 || s3760; + const SWord8 s3762 = sbv_bv_u8_rotr(s3758, 1); + 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 = sbv_bv_u8_add(s1, s3724); + const SBool s3769 = s3768 < s1; + const SBool s3770 = s3768 < s3724; + const SBool s3771 = s3769 || s3770; + const SWord8 s3772 = sbv_bv_u8_rotr(s3768, 1); + const SWord8 s3773 = 128 | s3772; + const SWord8 s3774 = 127 & s3772; + const SWord8 s3775 = s3771 ? s3773 : s3774; + const SWord8 s3776 = sbv_bv_u8_rotr(s3775, 1); + const SWord8 s3777 = 128 | s3776; + const SWord8 s3778 = 127 & s3776; + const SWord8 s3779 = s3592 ? s3777 : s3778; + const SWord8 s3780 = sbv_bv_u8_rotr(s3779, 1); + const SWord8 s3781 = 128 | s3780; + const SWord8 s3782 = 127 & s3780; + const SWord8 s3783 = s3716 ? s3781 : s3782; + const SWord8 s3784 = sbv_bv_u8_add(s1, s3779); + const SBool s3785 = s3784 < s1; + const SBool s3786 = s3784 < s3779; + const SBool s3787 = s3785 || s3786; + const SWord8 s3788 = sbv_bv_u8_rotr(s3784, 1); + 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 = sbv_bv_u8_add(s1, s3775); + const SBool s3794 = s3793 < s1; + const SBool s3795 = s3793 < s3775; + const SBool s3796 = s3794 || s3795; + const SWord8 s3797 = sbv_bv_u8_rotr(s3793, 1); + const SWord8 s3798 = 128 | s3797; + const SWord8 s3799 = 127 & s3797; + const SWord8 s3800 = s3796 ? s3798 : s3799; + const SWord8 s3801 = sbv_bv_u8_rotr(s3800, 1); + const SWord8 s3802 = 128 | s3801; + const SWord8 s3803 = 127 & s3801; + const SWord8 s3804 = s3716 ? s3802 : s3803; + const SWord8 s3805 = sbv_bv_u8_add(s1, s3800); + const SBool s3806 = s3805 < s1; + const SBool s3807 = s3805 < s3800; + const SBool s3808 = s3806 || s3807; + const SWord8 s3809 = sbv_bv_u8_rotr(s3805, 1); + 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 = sbv_bv_u8_add(s1, s3578); + const SBool s3818 = sbv_bv_extract_u8_0_0_u1(s3817); + const SBool s3819 = false != s3818; + const SWord8 s3820 = s3819 ? s3582 : s3583; + const SBool s3821 = sbv_bv_extract_u8_0_0_u1(s3820); + const SBool s3822 = false != s3821; + const SWord8 s3823 = s3822 ? s3588 : s3589; + const SBool s3824 = sbv_bv_extract_u8_0_0_u1(s3823); + const SBool s3825 = false != s3824; + const SBool s3826 = !s3825; + const SBool s3827 = s3817 < s1; + const SBool s3828 = s3817 < s3578; + const SBool s3829 = s3827 || s3828; + const SWord8 s3830 = sbv_bv_u8_rotr(s3817, 1); + const SWord8 s3831 = 128 | s3830; + const SWord8 s3832 = 127 & s3830; + const SWord8 s3833 = s3829 ? s3831 : s3832; + const SBool s3834 = sbv_bv_extract_u8_0_0_u1(s3833); + const SBool s3835 = false != s3834; + const SWord8 s3836 = sbv_bv_u8_rotr(s3820, 1); + const SWord8 s3837 = 128 | s3836; + const SWord8 s3838 = 127 & s3836; + const SWord8 s3839 = s3835 ? s3837 : s3838; + const SBool s3840 = sbv_bv_extract_u8_0_0_u1(s3839); + const SBool s3841 = false != s3840; + const SWord8 s3842 = sbv_bv_u8_rotr(s3823, 1); + const SWord8 s3843 = 128 | s3842; + const SWord8 s3844 = 127 & s3842; + const SWord8 s3845 = s3841 ? s3843 : s3844; + const SBool s3846 = sbv_bv_extract_u8_0_0_u1(s3845); + const SBool s3847 = false != s3846; + const SBool s3848 = !s3847; + const SWord8 s3849 = sbv_bv_u8_rotr(s3833, 1); + const SWord8 s3850 = 128 | s3849; + const SWord8 s3851 = 127 & s3849; + const SWord8 s3852 = s3059 ? s3850 : s3851; + const SWord8 s3853 = sbv_bv_u8_rotr(s3852, 1); + const SWord8 s3854 = 128 | s3853; + const SWord8 s3855 = 127 & s3853; + const SWord8 s3856 = s3570 ? s3854 : s3855; + const SWord8 s3857 = sbv_bv_u8_rotr(s3856, 1); + const SWord8 s3858 = 128 | s3857; + const SWord8 s3859 = 127 & s3857; + const SWord8 s3860 = s3825 ? s3858 : s3859; + const SWord8 s3861 = sbv_bv_u8_rotr(s3860, 1); + const SWord8 s3862 = 128 | s3861; + const SWord8 s3863 = 127 & s3861; + const SWord8 s3864 = s3847 ? s3862 : s3863; + const SWord8 s3865 = sbv_bv_u8_add(s1, s3860); + const SBool s3866 = s3865 < s1; + const SBool s3867 = s3865 < s3860; + const SBool s3868 = s3866 || s3867; + const SWord8 s3869 = sbv_bv_u8_rotr(s3865, 1); + 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 = sbv_bv_u8_add(s1, s3856); + const SBool s3875 = s3874 < s1; + const SBool s3876 = s3874 < s3856; + const SBool s3877 = s3875 || s3876; + const SWord8 s3878 = sbv_bv_u8_rotr(s3874, 1); + const SWord8 s3879 = 128 | s3878; + const SWord8 s3880 = 127 & s3878; + const SWord8 s3881 = s3877 ? s3879 : s3880; + const SWord8 s3882 = sbv_bv_u8_rotr(s3881, 1); + const SWord8 s3883 = 128 | s3882; + const SWord8 s3884 = 127 & s3882; + const SWord8 s3885 = s3847 ? s3883 : s3884; + const SWord8 s3886 = sbv_bv_u8_add(s1, s3881); + const SBool s3887 = s3886 < s1; + const SBool s3888 = s3886 < s3881; + const SBool s3889 = s3887 || s3888; + const SWord8 s3890 = sbv_bv_u8_rotr(s3886, 1); + 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 = sbv_bv_u8_add(s1, s3852); + const SBool s3897 = s3896 < s1; + const SBool s3898 = s3896 < s3852; + const SBool s3899 = s3897 || s3898; + const SWord8 s3900 = sbv_bv_u8_rotr(s3896, 1); + const SWord8 s3901 = 128 | s3900; + const SWord8 s3902 = 127 & s3900; + const SWord8 s3903 = s3899 ? s3901 : s3902; + const SWord8 s3904 = sbv_bv_u8_rotr(s3903, 1); + const SWord8 s3905 = 128 | s3904; + const SWord8 s3906 = 127 & s3904; + const SWord8 s3907 = s3825 ? s3905 : s3906; + const SWord8 s3908 = sbv_bv_u8_rotr(s3907, 1); + const SWord8 s3909 = 128 | s3908; + const SWord8 s3910 = 127 & s3908; + const SWord8 s3911 = s3847 ? s3909 : s3910; + const SWord8 s3912 = sbv_bv_u8_add(s1, s3907); + const SBool s3913 = s3912 < s1; + const SBool s3914 = s3912 < s3907; + const SBool s3915 = s3913 || s3914; + const SWord8 s3916 = sbv_bv_u8_rotr(s3912, 1); + 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 = sbv_bv_u8_add(s1, s3903); + const SBool s3922 = s3921 < s1; + const SBool s3923 = s3921 < s3903; + const SBool s3924 = s3922 || s3923; + const SWord8 s3925 = sbv_bv_u8_rotr(s3921, 1); + const SWord8 s3926 = 128 | s3925; + const SWord8 s3927 = 127 & s3925; + const SWord8 s3928 = s3924 ? s3926 : s3927; + const SWord8 s3929 = sbv_bv_u8_rotr(s3928, 1); + const SWord8 s3930 = 128 | s3929; + const SWord8 s3931 = 127 & s3929; + const SWord8 s3932 = s3847 ? s3930 : s3931; + const SWord8 s3933 = sbv_bv_u8_add(s1, s3928); + const SBool s3934 = s3933 < s1; + const SBool s3935 = s3933 < s3928; + const SBool s3936 = s3934 || s3935; + const SWord8 s3937 = sbv_bv_u8_rotr(s3933, 1); + 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 = sbv_bv_u8_add(s1, s3833); + const SBool s3945 = sbv_bv_extract_u8_0_0_u1(s3944); + const SBool s3946 = false != s3945; + const SWord8 s3947 = s3946 ? s3837 : s3838; + const SBool s3948 = sbv_bv_extract_u8_0_0_u1(s3947); + const SBool s3949 = false != s3948; + const SWord8 s3950 = s3949 ? s3843 : s3844; + const SBool s3951 = sbv_bv_extract_u8_0_0_u1(s3950); + const SBool s3952 = false != s3951; + const SBool s3953 = !s3952; + const SBool s3954 = s3944 < s1; + const SBool s3955 = s3944 < s3833; + const SBool s3956 = s3954 || s3955; + const SWord8 s3957 = sbv_bv_u8_rotr(s3944, 1); + const SWord8 s3958 = 128 | s3957; + const SWord8 s3959 = 127 & s3957; + const SWord8 s3960 = s3956 ? s3958 : s3959; + const SWord8 s3961 = sbv_bv_u8_rotr(s3960, 1); + const SWord8 s3962 = 128 | s3961; + const SWord8 s3963 = 127 & s3961; + const SWord8 s3964 = s3570 ? s3962 : s3963; + const SWord8 s3965 = sbv_bv_u8_rotr(s3964, 1); + const SWord8 s3966 = 128 | s3965; + const SWord8 s3967 = 127 & s3965; + const SWord8 s3968 = s3825 ? s3966 : s3967; + const SWord8 s3969 = sbv_bv_u8_rotr(s3968, 1); + const SWord8 s3970 = 128 | s3969; + const SWord8 s3971 = 127 & s3969; + const SWord8 s3972 = s3952 ? s3970 : s3971; + const SWord8 s3973 = sbv_bv_u8_add(s1, s3968); + const SBool s3974 = s3973 < s1; + const SBool s3975 = s3973 < s3968; + const SBool s3976 = s3974 || s3975; + const SWord8 s3977 = sbv_bv_u8_rotr(s3973, 1); + 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 = sbv_bv_u8_add(s1, s3964); + const SBool s3983 = s3982 < s1; + const SBool s3984 = s3982 < s3964; + const SBool s3985 = s3983 || s3984; + const SWord8 s3986 = sbv_bv_u8_rotr(s3982, 1); + const SWord8 s3987 = 128 | s3986; + const SWord8 s3988 = 127 & s3986; + const SWord8 s3989 = s3985 ? s3987 : s3988; + const SWord8 s3990 = sbv_bv_u8_rotr(s3989, 1); + const SWord8 s3991 = 128 | s3990; + const SWord8 s3992 = 127 & s3990; + const SWord8 s3993 = s3952 ? s3991 : s3992; + const SWord8 s3994 = sbv_bv_u8_add(s1, s3989); + const SBool s3995 = s3994 < s1; + const SBool s3996 = s3994 < s3989; + const SBool s3997 = s3995 || s3996; + const SWord8 s3998 = sbv_bv_u8_rotr(s3994, 1); + 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 = sbv_bv_u8_add(s1, s3960); + const SBool s4005 = s4004 < s1; + const SBool s4006 = s4004 < s3960; + const SBool s4007 = s4005 || s4006; + const SWord8 s4008 = sbv_bv_u8_rotr(s4004, 1); + const SWord8 s4009 = 128 | s4008; + const SWord8 s4010 = 127 & s4008; + const SWord8 s4011 = s4007 ? s4009 : s4010; + const SWord8 s4012 = sbv_bv_u8_rotr(s4011, 1); + const SWord8 s4013 = 128 | s4012; + const SWord8 s4014 = 127 & s4012; + const SWord8 s4015 = s3825 ? s4013 : s4014; + const SWord8 s4016 = sbv_bv_u8_rotr(s4015, 1); + const SWord8 s4017 = 128 | s4016; + const SWord8 s4018 = 127 & s4016; + const SWord8 s4019 = s3952 ? s4017 : s4018; + const SWord8 s4020 = sbv_bv_u8_add(s1, s4015); + const SBool s4021 = s4020 < s1; + const SBool s4022 = s4020 < s4015; + const SBool s4023 = s4021 || s4022; + const SWord8 s4024 = sbv_bv_u8_rotr(s4020, 1); + 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 = sbv_bv_u8_add(s1, s4011); + const SBool s4030 = s4029 < s1; + const SBool s4031 = s4029 < s4011; + const SBool s4032 = s4030 || s4031; + const SWord8 s4033 = sbv_bv_u8_rotr(s4029, 1); + const SWord8 s4034 = 128 | s4033; + const SWord8 s4035 = 127 & s4033; + const SWord8 s4036 = s4032 ? s4034 : s4035; + const SWord8 s4037 = sbv_bv_u8_rotr(s4036, 1); + const SWord8 s4038 = 128 | s4037; + const SWord8 s4039 = 127 & s4037; + const SWord8 s4040 = s3952 ? s4038 : s4039; + const SWord8 s4041 = sbv_bv_u8_add(s1, s4036); + const SBool s4042 = s4041 < s1; + const SBool s4043 = s4041 < s4036; + const SBool s4044 = s4042 || s4043; + const SWord8 s4045 = sbv_bv_u8_rotr(s4041, 1); + const SWord8 s4046 = 128 | s4045; + const SWord8 s4047 = 127 & s4045; + const SWord8 s4048 = s4044 ? s4046 : s4047; + const SWord8 s4049 = s3953 ? s4040 : s4048; + const SWord8 s4050 = s3826 ? s4028 : s4049; + const SWord8 s4051 = s3571 ? s4003 : s4050; + const SWord8 s4052 = s3060 ? s3943 : s4051; + const SWord8 s4053 = s2042 ? s3816 : s4052; + const SWord8 s4054 = s16 ? s3561 : s4053; + const SWord8 s4055 = s11 ? s3050 : s4054; + const SWord8 s4056 = s5 ? s2032 : s4055; + const SBool s4057 = sbv_bv_extract_u8_0_0_u1(s105); + const SBool s4058 = false != s4057; + const SBool s4059 = sbv_bv_extract_u8_0_0_u1(s101); + const SBool s4060 = false != s4059; + const SBool s4061 = sbv_bv_extract_u8_0_0_u1(s97); + const SBool s4062 = false != s4061; + const SWord8 s4063 = sbv_bv_u8_rotr(s84, 1); + const SWord8 s4064 = 128 | s4063; + const SWord8 s4065 = 127 & s4063; + const SWord8 s4066 = s4062 ? s4064 : s4065; + const SWord8 s4067 = sbv_bv_u8_rotr(s4066, 1); + const SWord8 s4068 = 128 | s4067; + const SWord8 s4069 = 127 & s4067; + const SWord8 s4070 = s4060 ? s4068 : s4069; + const SWord8 s4071 = sbv_bv_u8_rotr(s4070, 1); + const SWord8 s4072 = 128 | s4071; + const SWord8 s4073 = 127 & s4071; + const SWord8 s4074 = s4058 ? s4072 : s4073; + const SBool s4075 = sbv_bv_extract_u8_0_0_u1(s110); + const SBool s4076 = false != s4075; + const SWord8 s4077 = s4076 ? s4072 : s4073; + const SWord8 s4078 = s93 ? s4074 : s4077; + const SBool s4079 = sbv_bv_extract_u8_0_0_u1(s126); + const SBool s4080 = false != s4079; + const SBool s4081 = sbv_bv_extract_u8_0_0_u1(s119); + const SBool s4082 = false != s4081; + const SWord8 s4083 = s4082 ? s4068 : s4069; + const SWord8 s4084 = sbv_bv_u8_rotr(s4083, 1); + const SWord8 s4085 = 128 | s4084; + const SWord8 s4086 = 127 & s4084; + const SWord8 s4087 = s4080 ? s4085 : s4086; + const SBool s4088 = sbv_bv_extract_u8_0_0_u1(s131); + const SBool s4089 = false != s4088; + const SWord8 s4090 = s4089 ? s4085 : s4086; + const SWord8 s4091 = s93 ? s4087 : s4090; + const SWord8 s4092 = s74 ? s4078 : s4091; + const SBool s4093 = sbv_bv_extract_u8_0_0_u1(s152); + const SBool s4094 = false != s4093; + const SBool s4095 = sbv_bv_extract_u8_0_0_u1(s148); + const SBool s4096 = false != s4095; + const SBool s4097 = sbv_bv_extract_u8_0_0_u1(s141); + const SBool s4098 = false != s4097; + const SWord8 s4099 = s4098 ? s4064 : s4065; + const SWord8 s4100 = sbv_bv_u8_rotr(s4099, 1); + const SWord8 s4101 = 128 | s4100; + const SWord8 s4102 = 127 & s4100; + const SWord8 s4103 = s4096 ? s4101 : s4102; + const SWord8 s4104 = sbv_bv_u8_rotr(s4103, 1); + const SWord8 s4105 = 128 | s4104; + const SWord8 s4106 = 127 & s4104; + const SWord8 s4107 = s4094 ? s4105 : s4106; + const SBool s4108 = sbv_bv_extract_u8_0_0_u1(s157); + const SBool s4109 = false != s4108; + const SWord8 s4110 = s4109 ? s4105 : s4106; + const SWord8 s4111 = s93 ? s4107 : s4110; + const SBool s4112 = sbv_bv_extract_u8_0_0_u1(s173); + const SBool s4113 = false != s4112; + const SBool s4114 = sbv_bv_extract_u8_0_0_u1(s166); + const SBool s4115 = false != s4114; + const SWord8 s4116 = s4115 ? s4101 : s4102; + const SWord8 s4117 = sbv_bv_u8_rotr(s4116, 1); + const SWord8 s4118 = 128 | s4117; + const SWord8 s4119 = 127 & s4117; + const SWord8 s4120 = s4113 ? s4118 : s4119; + const SBool s4121 = sbv_bv_extract_u8_0_0_u1(s178); + const SBool s4122 = false != s4121; + const SWord8 s4123 = s4122 ? s4118 : s4119; + const SWord8 s4124 = s93 ? s4120 : s4123; + const SWord8 s4125 = s74 ? s4111 : s4124; + const SWord8 s4126 = s55 ? s4092 : s4125; + const SBool s4127 = sbv_bv_extract_u8_0_0_u1(s213); + const SBool s4128 = false != s4127; + const SBool s4129 = sbv_bv_extract_u8_0_0_u1(s209); + const SBool s4130 = false != s4129; + const SBool s4131 = sbv_bv_extract_u8_0_0_u1(s205); + const SBool s4132 = false != s4131; + const SWord8 s4133 = sbv_bv_u8_rotr(s192, 1); + const SWord8 s4134 = 128 | s4133; + const SWord8 s4135 = 127 & s4133; + const SWord8 s4136 = s4132 ? s4134 : s4135; + const SWord8 s4137 = sbv_bv_u8_rotr(s4136, 1); + const SWord8 s4138 = 128 | s4137; + const SWord8 s4139 = 127 & s4137; + const SWord8 s4140 = s4130 ? s4138 : s4139; + const SWord8 s4141 = sbv_bv_u8_rotr(s4140, 1); + const SWord8 s4142 = 128 | s4141; + const SWord8 s4143 = 127 & s4141; + const SWord8 s4144 = s4128 ? s4142 : s4143; + const SBool s4145 = sbv_bv_extract_u8_0_0_u1(s218); + const SBool s4146 = false != s4145; + const SWord8 s4147 = s4146 ? s4142 : s4143; + const SWord8 s4148 = s198 ? s4144 : s4147; + const SBool s4149 = sbv_bv_extract_u8_0_0_u1(s234); + const SBool s4150 = false != s4149; + const SBool s4151 = sbv_bv_extract_u8_0_0_u1(s227); + const SBool s4152 = false != s4151; + const SWord8 s4153 = s4152 ? s4138 : s4139; + const SWord8 s4154 = sbv_bv_u8_rotr(s4153, 1); + const SWord8 s4155 = 128 | s4154; + const SWord8 s4156 = 127 & s4154; + const SWord8 s4157 = s4150 ? s4155 : s4156; + const SBool s4158 = sbv_bv_extract_u8_0_0_u1(s239); + const SBool s4159 = false != s4158; + const SWord8 s4160 = s4159 ? s4155 : s4156; + const SWord8 s4161 = s198 ? s4157 : s4160; + const SWord8 s4162 = s74 ? s4148 : s4161; + const SBool s4163 = sbv_bv_extract_u8_0_0_u1(s260); + const SBool s4164 = false != s4163; + const SBool s4165 = sbv_bv_extract_u8_0_0_u1(s256); + const SBool s4166 = false != s4165; + const SBool s4167 = sbv_bv_extract_u8_0_0_u1(s249); + const SBool s4168 = false != s4167; + const SWord8 s4169 = s4168 ? s4134 : s4135; + const SWord8 s4170 = sbv_bv_u8_rotr(s4169, 1); + const SWord8 s4171 = 128 | s4170; + const SWord8 s4172 = 127 & s4170; + const SWord8 s4173 = s4166 ? s4171 : s4172; + const SWord8 s4174 = sbv_bv_u8_rotr(s4173, 1); + const SWord8 s4175 = 128 | s4174; + const SWord8 s4176 = 127 & s4174; + const SWord8 s4177 = s4164 ? s4175 : s4176; + const SBool s4178 = sbv_bv_extract_u8_0_0_u1(s265); + const SBool s4179 = false != s4178; + const SWord8 s4180 = s4179 ? s4175 : s4176; + const SWord8 s4181 = s198 ? s4177 : s4180; + const SBool s4182 = sbv_bv_extract_u8_0_0_u1(s281); + const SBool s4183 = false != s4182; + const SBool s4184 = sbv_bv_extract_u8_0_0_u1(s274); + const SBool s4185 = false != s4184; + const SWord8 s4186 = s4185 ? s4171 : s4172; + const SWord8 s4187 = sbv_bv_u8_rotr(s4186, 1); + const SWord8 s4188 = 128 | s4187; + const SWord8 s4189 = 127 & s4187; + const SWord8 s4190 = s4183 ? s4188 : s4189; + const SBool s4191 = sbv_bv_extract_u8_0_0_u1(s286); + const SBool s4192 = false != s4191; + const SWord8 s4193 = s4192 ? s4188 : s4189; + const SWord8 s4194 = s198 ? s4190 : s4193; + const SWord8 s4195 = s74 ? s4181 : s4194; + const SWord8 s4196 = s55 ? s4162 : s4195; + const SWord8 s4197 = s36 ? s4126 : s4196; + const SBool s4198 = sbv_bv_extract_u8_0_0_u1(s341); + const SBool s4199 = false != s4198; + const SBool s4200 = sbv_bv_extract_u8_0_0_u1(s337); + const SBool s4201 = false != s4200; + const SBool s4202 = sbv_bv_extract_u8_0_0_u1(s333); + const SBool s4203 = false != s4202; + const SWord8 s4204 = sbv_bv_u8_rotr(s320, 1); + const SWord8 s4205 = 128 | s4204; + const SWord8 s4206 = 127 & s4204; + const SWord8 s4207 = s4203 ? s4205 : s4206; + const SWord8 s4208 = sbv_bv_u8_rotr(s4207, 1); + const SWord8 s4209 = 128 | s4208; + const SWord8 s4210 = 127 & s4208; + const SWord8 s4211 = s4201 ? s4209 : s4210; + const SWord8 s4212 = sbv_bv_u8_rotr(s4211, 1); + const SWord8 s4213 = 128 | s4212; + const SWord8 s4214 = 127 & s4212; + const SWord8 s4215 = s4199 ? s4213 : s4214; + const SBool s4216 = sbv_bv_extract_u8_0_0_u1(s346); + const SBool s4217 = false != s4216; + const SWord8 s4218 = s4217 ? s4213 : s4214; + const SWord8 s4219 = s329 ? s4215 : s4218; + const SBool s4220 = sbv_bv_extract_u8_0_0_u1(s362); + const SBool s4221 = false != s4220; + const SBool s4222 = sbv_bv_extract_u8_0_0_u1(s355); + const SBool s4223 = false != s4222; + const SWord8 s4224 = s4223 ? s4209 : s4210; + const SWord8 s4225 = sbv_bv_u8_rotr(s4224, 1); + const SWord8 s4226 = 128 | s4225; + const SWord8 s4227 = 127 & s4225; + const SWord8 s4228 = s4221 ? s4226 : s4227; + const SBool s4229 = sbv_bv_extract_u8_0_0_u1(s367); + const SBool s4230 = false != s4229; + const SWord8 s4231 = s4230 ? s4226 : s4227; + const SWord8 s4232 = s329 ? s4228 : s4231; + const SWord8 s4233 = s307 ? s4219 : s4232; + const SBool s4234 = sbv_bv_extract_u8_0_0_u1(s388); + const SBool s4235 = false != s4234; + const SBool s4236 = sbv_bv_extract_u8_0_0_u1(s384); + const SBool s4237 = false != s4236; + const SBool s4238 = sbv_bv_extract_u8_0_0_u1(s377); + const SBool s4239 = false != s4238; + const SWord8 s4240 = s4239 ? s4205 : s4206; + const SWord8 s4241 = sbv_bv_u8_rotr(s4240, 1); + const SWord8 s4242 = 128 | s4241; + const SWord8 s4243 = 127 & s4241; + const SWord8 s4244 = s4237 ? s4242 : s4243; + const SWord8 s4245 = sbv_bv_u8_rotr(s4244, 1); + const SWord8 s4246 = 128 | s4245; + const SWord8 s4247 = 127 & s4245; + const SWord8 s4248 = s4235 ? s4246 : s4247; + const SBool s4249 = sbv_bv_extract_u8_0_0_u1(s393); + const SBool s4250 = false != s4249; + const SWord8 s4251 = s4250 ? s4246 : s4247; + const SWord8 s4252 = s329 ? s4248 : s4251; + const SBool s4253 = sbv_bv_extract_u8_0_0_u1(s409); + const SBool s4254 = false != s4253; + const SBool s4255 = sbv_bv_extract_u8_0_0_u1(s402); + const SBool s4256 = false != s4255; + const SWord8 s4257 = s4256 ? s4242 : s4243; + const SWord8 s4258 = sbv_bv_u8_rotr(s4257, 1); + const SWord8 s4259 = 128 | s4258; + const SWord8 s4260 = 127 & s4258; + const SWord8 s4261 = s4254 ? s4259 : s4260; + const SBool s4262 = sbv_bv_extract_u8_0_0_u1(s414); + const SBool s4263 = false != s4262; + const SWord8 s4264 = s4263 ? s4259 : s4260; + const SWord8 s4265 = s329 ? s4261 : s4264; + const SWord8 s4266 = s307 ? s4252 : s4265; + const SWord8 s4267 = s55 ? s4233 : s4266; + const SBool s4268 = sbv_bv_extract_u8_0_0_u1(s449); + const SBool s4269 = false != s4268; + const SBool s4270 = sbv_bv_extract_u8_0_0_u1(s445); + const SBool s4271 = false != s4270; + const SBool s4272 = sbv_bv_extract_u8_0_0_u1(s441); + const SBool s4273 = false != s4272; + const SWord8 s4274 = sbv_bv_u8_rotr(s428, 1); + const SWord8 s4275 = 128 | s4274; + const SWord8 s4276 = 127 & s4274; + const SWord8 s4277 = s4273 ? s4275 : s4276; + const SWord8 s4278 = sbv_bv_u8_rotr(s4277, 1); + const SWord8 s4279 = 128 | s4278; + const SWord8 s4280 = 127 & s4278; + const SWord8 s4281 = s4271 ? s4279 : s4280; + const SWord8 s4282 = sbv_bv_u8_rotr(s4281, 1); + const SWord8 s4283 = 128 | s4282; + const SWord8 s4284 = 127 & s4282; + const SWord8 s4285 = s4269 ? s4283 : s4284; + const SBool s4286 = sbv_bv_extract_u8_0_0_u1(s454); + const SBool s4287 = false != s4286; + const SWord8 s4288 = s4287 ? s4283 : s4284; + const SWord8 s4289 = s434 ? s4285 : s4288; + const SBool s4290 = sbv_bv_extract_u8_0_0_u1(s470); + const SBool s4291 = false != s4290; + const SBool s4292 = sbv_bv_extract_u8_0_0_u1(s463); + const SBool s4293 = false != s4292; + const SWord8 s4294 = s4293 ? s4279 : s4280; + const SWord8 s4295 = sbv_bv_u8_rotr(s4294, 1); + const SWord8 s4296 = 128 | s4295; + const SWord8 s4297 = 127 & s4295; + const SWord8 s4298 = s4291 ? s4296 : s4297; + const SBool s4299 = sbv_bv_extract_u8_0_0_u1(s475); + const SBool s4300 = false != s4299; + const SWord8 s4301 = s4300 ? s4296 : s4297; + const SWord8 s4302 = s434 ? s4298 : s4301; + const SWord8 s4303 = s307 ? s4289 : s4302; + const SBool s4304 = sbv_bv_extract_u8_0_0_u1(s496); + const SBool s4305 = false != s4304; + const SBool s4306 = sbv_bv_extract_u8_0_0_u1(s492); + const SBool s4307 = false != s4306; + const SBool s4308 = sbv_bv_extract_u8_0_0_u1(s485); + const SBool s4309 = false != s4308; + const SWord8 s4310 = s4309 ? s4275 : s4276; + const SWord8 s4311 = sbv_bv_u8_rotr(s4310, 1); + const SWord8 s4312 = 128 | s4311; + const SWord8 s4313 = 127 & s4311; + const SWord8 s4314 = s4307 ? s4312 : s4313; + const SWord8 s4315 = sbv_bv_u8_rotr(s4314, 1); + const SWord8 s4316 = 128 | s4315; + const SWord8 s4317 = 127 & s4315; + const SWord8 s4318 = s4305 ? s4316 : s4317; + const SBool s4319 = sbv_bv_extract_u8_0_0_u1(s501); + const SBool s4320 = false != s4319; + const SWord8 s4321 = s4320 ? s4316 : s4317; + const SWord8 s4322 = s434 ? s4318 : s4321; + const SBool s4323 = sbv_bv_extract_u8_0_0_u1(s517); + const SBool s4324 = false != s4323; + const SBool s4325 = sbv_bv_extract_u8_0_0_u1(s510); + const SBool s4326 = false != s4325; + const SWord8 s4327 = s4326 ? s4312 : s4313; + const SWord8 s4328 = sbv_bv_u8_rotr(s4327, 1); + const SWord8 s4329 = 128 | s4328; + const SWord8 s4330 = 127 & s4328; + const SWord8 s4331 = s4324 ? s4329 : s4330; + const SBool s4332 = sbv_bv_extract_u8_0_0_u1(s522); + const SBool s4333 = false != s4332; + const SWord8 s4334 = s4333 ? s4329 : s4330; + const SWord8 s4335 = s434 ? s4331 : s4334; + const SWord8 s4336 = s307 ? s4322 : s4335; + const SWord8 s4337 = s55 ? s4303 : s4336; + const SWord8 s4338 = s36 ? s4267 : s4337; + const SWord8 s4339 = s21 ? s4197 : s4338; + const SBool s4340 = sbv_bv_extract_u8_0_0_u1(s597); + const SBool s4341 = false != s4340; + const SBool s4342 = sbv_bv_extract_u8_0_0_u1(s593); + const SBool s4343 = false != s4342; + const SBool s4344 = sbv_bv_extract_u8_0_0_u1(s589); + const SBool s4345 = false != s4344; + const SWord8 s4346 = sbv_bv_u8_rotr(s576, 1); + const SWord8 s4347 = 128 | s4346; + const SWord8 s4348 = 127 & s4346; + const SWord8 s4349 = s4345 ? s4347 : s4348; + const SWord8 s4350 = sbv_bv_u8_rotr(s4349, 1); + const SWord8 s4351 = 128 | s4350; + const SWord8 s4352 = 127 & s4350; + const SWord8 s4353 = s4343 ? s4351 : s4352; + const SWord8 s4354 = sbv_bv_u8_rotr(s4353, 1); + const SWord8 s4355 = 128 | s4354; + const SWord8 s4356 = 127 & s4354; + const SWord8 s4357 = s4341 ? s4355 : s4356; + const SBool s4358 = sbv_bv_extract_u8_0_0_u1(s602); + const SBool s4359 = false != s4358; + const SWord8 s4360 = s4359 ? s4355 : s4356; + const SWord8 s4361 = s585 ? s4357 : s4360; + const SBool s4362 = sbv_bv_extract_u8_0_0_u1(s618); + const SBool s4363 = false != s4362; + const SBool s4364 = sbv_bv_extract_u8_0_0_u1(s611); + const SBool s4365 = false != s4364; + const SWord8 s4366 = s4365 ? s4351 : s4352; + const SWord8 s4367 = sbv_bv_u8_rotr(s4366, 1); + const SWord8 s4368 = 128 | s4367; + const SWord8 s4369 = 127 & s4367; + const SWord8 s4370 = s4363 ? s4368 : s4369; + const SBool s4371 = sbv_bv_extract_u8_0_0_u1(s623); + const SBool s4372 = false != s4371; + const SWord8 s4373 = s4372 ? s4368 : s4369; + const SWord8 s4374 = s585 ? s4370 : s4373; + const SWord8 s4375 = s566 ? s4361 : s4374; + const SBool s4376 = sbv_bv_extract_u8_0_0_u1(s644); + const SBool s4377 = false != s4376; + const SBool s4378 = sbv_bv_extract_u8_0_0_u1(s640); + const SBool s4379 = false != s4378; + const SBool s4380 = sbv_bv_extract_u8_0_0_u1(s633); + const SBool s4381 = false != s4380; + const SWord8 s4382 = s4381 ? s4347 : s4348; + const SWord8 s4383 = sbv_bv_u8_rotr(s4382, 1); + const SWord8 s4384 = 128 | s4383; + const SWord8 s4385 = 127 & s4383; + const SWord8 s4386 = s4379 ? s4384 : s4385; + const SWord8 s4387 = sbv_bv_u8_rotr(s4386, 1); + const SWord8 s4388 = 128 | s4387; + const SWord8 s4389 = 127 & s4387; + const SWord8 s4390 = s4377 ? s4388 : s4389; + const SBool s4391 = sbv_bv_extract_u8_0_0_u1(s649); + const SBool s4392 = false != s4391; + const SWord8 s4393 = s4392 ? s4388 : s4389; + const SWord8 s4394 = s585 ? s4390 : s4393; + const SBool s4395 = sbv_bv_extract_u8_0_0_u1(s665); + const SBool s4396 = false != s4395; + const SBool s4397 = sbv_bv_extract_u8_0_0_u1(s658); + const SBool s4398 = false != s4397; + const SWord8 s4399 = s4398 ? s4384 : s4385; + const SWord8 s4400 = sbv_bv_u8_rotr(s4399, 1); + const SWord8 s4401 = 128 | s4400; + const SWord8 s4402 = 127 & s4400; + const SWord8 s4403 = s4396 ? s4401 : s4402; + const SBool s4404 = sbv_bv_extract_u8_0_0_u1(s670); + const SBool s4405 = false != s4404; + const SWord8 s4406 = s4405 ? s4401 : s4402; + const SWord8 s4407 = s585 ? s4403 : s4406; + const SWord8 s4408 = s566 ? s4394 : s4407; + const SWord8 s4409 = s544 ? s4375 : s4408; + const SBool s4410 = sbv_bv_extract_u8_0_0_u1(s705); + const SBool s4411 = false != s4410; + const SBool s4412 = sbv_bv_extract_u8_0_0_u1(s701); + const SBool s4413 = false != s4412; + const SBool s4414 = sbv_bv_extract_u8_0_0_u1(s697); + const SBool s4415 = false != s4414; + const SWord8 s4416 = sbv_bv_u8_rotr(s684, 1); + const SWord8 s4417 = 128 | s4416; + const SWord8 s4418 = 127 & s4416; + const SWord8 s4419 = s4415 ? s4417 : s4418; + const SWord8 s4420 = sbv_bv_u8_rotr(s4419, 1); + const SWord8 s4421 = 128 | s4420; + const SWord8 s4422 = 127 & s4420; + const SWord8 s4423 = s4413 ? s4421 : s4422; + const SWord8 s4424 = sbv_bv_u8_rotr(s4423, 1); + const SWord8 s4425 = 128 | s4424; + const SWord8 s4426 = 127 & s4424; + const SWord8 s4427 = s4411 ? s4425 : s4426; + const SBool s4428 = sbv_bv_extract_u8_0_0_u1(s710); + const SBool s4429 = false != s4428; + const SWord8 s4430 = s4429 ? s4425 : s4426; + const SWord8 s4431 = s690 ? s4427 : s4430; + const SBool s4432 = sbv_bv_extract_u8_0_0_u1(s726); + const SBool s4433 = false != s4432; + const SBool s4434 = sbv_bv_extract_u8_0_0_u1(s719); + const SBool s4435 = false != s4434; + const SWord8 s4436 = s4435 ? s4421 : s4422; + const SWord8 s4437 = sbv_bv_u8_rotr(s4436, 1); + const SWord8 s4438 = 128 | s4437; + const SWord8 s4439 = 127 & s4437; + const SWord8 s4440 = s4433 ? s4438 : s4439; + const SBool s4441 = sbv_bv_extract_u8_0_0_u1(s731); + const SBool s4442 = false != s4441; + const SWord8 s4443 = s4442 ? s4438 : s4439; + const SWord8 s4444 = s690 ? s4440 : s4443; + const SWord8 s4445 = s566 ? s4431 : s4444; + const SBool s4446 = sbv_bv_extract_u8_0_0_u1(s752); + const SBool s4447 = false != s4446; + const SBool s4448 = sbv_bv_extract_u8_0_0_u1(s748); + const SBool s4449 = false != s4448; + const SBool s4450 = sbv_bv_extract_u8_0_0_u1(s741); + const SBool s4451 = false != s4450; + const SWord8 s4452 = s4451 ? s4417 : s4418; + const SWord8 s4453 = sbv_bv_u8_rotr(s4452, 1); + const SWord8 s4454 = 128 | s4453; + const SWord8 s4455 = 127 & s4453; + const SWord8 s4456 = s4449 ? s4454 : s4455; + const SWord8 s4457 = sbv_bv_u8_rotr(s4456, 1); + const SWord8 s4458 = 128 | s4457; + const SWord8 s4459 = 127 & s4457; + const SWord8 s4460 = s4447 ? s4458 : s4459; + const SBool s4461 = sbv_bv_extract_u8_0_0_u1(s757); + const SBool s4462 = false != s4461; + const SWord8 s4463 = s4462 ? s4458 : s4459; + const SWord8 s4464 = s690 ? s4460 : s4463; + const SBool s4465 = sbv_bv_extract_u8_0_0_u1(s773); + const SBool s4466 = false != s4465; + const SBool s4467 = sbv_bv_extract_u8_0_0_u1(s766); + const SBool s4468 = false != s4467; + const SWord8 s4469 = s4468 ? s4454 : s4455; + const SWord8 s4470 = sbv_bv_u8_rotr(s4469, 1); + const SWord8 s4471 = 128 | s4470; + const SWord8 s4472 = 127 & s4470; + const SWord8 s4473 = s4466 ? s4471 : s4472; + const SBool s4474 = sbv_bv_extract_u8_0_0_u1(s778); + const SBool s4475 = false != s4474; + const SWord8 s4476 = s4475 ? s4471 : s4472; + const SWord8 s4477 = s690 ? s4473 : s4476; + const SWord8 s4478 = s566 ? s4464 : s4477; + const SWord8 s4479 = s544 ? s4445 : s4478; + const SWord8 s4480 = s36 ? s4409 : s4479; + const SBool s4481 = sbv_bv_extract_u8_0_0_u1(s833); + const SBool s4482 = false != s4481; + const SBool s4483 = sbv_bv_extract_u8_0_0_u1(s829); + const SBool s4484 = false != s4483; + const SBool s4485 = sbv_bv_extract_u8_0_0_u1(s825); + const SBool s4486 = false != s4485; + const SWord8 s4487 = sbv_bv_u8_rotr(s812, 1); + const SWord8 s4488 = 128 | s4487; + const SWord8 s4489 = 127 & s4487; + const SWord8 s4490 = s4486 ? s4488 : s4489; + const SWord8 s4491 = sbv_bv_u8_rotr(s4490, 1); + const SWord8 s4492 = 128 | s4491; + const SWord8 s4493 = 127 & s4491; + const SWord8 s4494 = s4484 ? s4492 : s4493; + const SWord8 s4495 = sbv_bv_u8_rotr(s4494, 1); + const SWord8 s4496 = 128 | s4495; + const SWord8 s4497 = 127 & s4495; + const SWord8 s4498 = s4482 ? s4496 : s4497; + const SBool s4499 = sbv_bv_extract_u8_0_0_u1(s838); + const SBool s4500 = false != s4499; + const SWord8 s4501 = s4500 ? s4496 : s4497; + const SWord8 s4502 = s821 ? s4498 : s4501; + const SBool s4503 = sbv_bv_extract_u8_0_0_u1(s854); + const SBool s4504 = false != s4503; + const SBool s4505 = sbv_bv_extract_u8_0_0_u1(s847); + const SBool s4506 = false != s4505; + const SWord8 s4507 = s4506 ? s4492 : s4493; + const SWord8 s4508 = sbv_bv_u8_rotr(s4507, 1); + const SWord8 s4509 = 128 | s4508; + const SWord8 s4510 = 127 & s4508; + const SWord8 s4511 = s4504 ? s4509 : s4510; + const SBool s4512 = sbv_bv_extract_u8_0_0_u1(s859); + const SBool s4513 = false != s4512; + const SWord8 s4514 = s4513 ? s4509 : s4510; + const SWord8 s4515 = s821 ? s4511 : s4514; + const SWord8 s4516 = s799 ? s4502 : s4515; + const SBool s4517 = sbv_bv_extract_u8_0_0_u1(s880); + const SBool s4518 = false != s4517; + const SBool s4519 = sbv_bv_extract_u8_0_0_u1(s876); + const SBool s4520 = false != s4519; + const SBool s4521 = sbv_bv_extract_u8_0_0_u1(s869); + const SBool s4522 = false != s4521; + const SWord8 s4523 = s4522 ? s4488 : s4489; + const SWord8 s4524 = sbv_bv_u8_rotr(s4523, 1); + const SWord8 s4525 = 128 | s4524; + const SWord8 s4526 = 127 & s4524; + const SWord8 s4527 = s4520 ? s4525 : s4526; + const SWord8 s4528 = sbv_bv_u8_rotr(s4527, 1); + const SWord8 s4529 = 128 | s4528; + const SWord8 s4530 = 127 & s4528; + const SWord8 s4531 = s4518 ? s4529 : s4530; + const SBool s4532 = sbv_bv_extract_u8_0_0_u1(s885); + const SBool s4533 = false != s4532; + const SWord8 s4534 = s4533 ? s4529 : s4530; + const SWord8 s4535 = s821 ? s4531 : s4534; + const SBool s4536 = sbv_bv_extract_u8_0_0_u1(s901); + const SBool s4537 = false != s4536; + const SBool s4538 = sbv_bv_extract_u8_0_0_u1(s894); + const SBool s4539 = false != s4538; + const SWord8 s4540 = s4539 ? s4525 : s4526; + const SWord8 s4541 = sbv_bv_u8_rotr(s4540, 1); + const SWord8 s4542 = 128 | s4541; + const SWord8 s4543 = 127 & s4541; + const SWord8 s4544 = s4537 ? s4542 : s4543; + const SBool s4545 = sbv_bv_extract_u8_0_0_u1(s906); + const SBool s4546 = false != s4545; + const SWord8 s4547 = s4546 ? s4542 : s4543; + const SWord8 s4548 = s821 ? s4544 : s4547; + const SWord8 s4549 = s799 ? s4535 : s4548; + const SWord8 s4550 = s544 ? s4516 : s4549; + const SBool s4551 = sbv_bv_extract_u8_0_0_u1(s941); + const SBool s4552 = false != s4551; + const SBool s4553 = sbv_bv_extract_u8_0_0_u1(s937); + const SBool s4554 = false != s4553; + const SBool s4555 = sbv_bv_extract_u8_0_0_u1(s933); + const SBool s4556 = false != s4555; + const SWord8 s4557 = sbv_bv_u8_rotr(s920, 1); + const SWord8 s4558 = 128 | s4557; + const SWord8 s4559 = 127 & s4557; + const SWord8 s4560 = s4556 ? s4558 : s4559; + const SWord8 s4561 = sbv_bv_u8_rotr(s4560, 1); + const SWord8 s4562 = 128 | s4561; + const SWord8 s4563 = 127 & s4561; + const SWord8 s4564 = s4554 ? s4562 : s4563; + const SWord8 s4565 = sbv_bv_u8_rotr(s4564, 1); + const SWord8 s4566 = 128 | s4565; + const SWord8 s4567 = 127 & s4565; + const SWord8 s4568 = s4552 ? s4566 : s4567; + const SBool s4569 = sbv_bv_extract_u8_0_0_u1(s946); + const SBool s4570 = false != s4569; + const SWord8 s4571 = s4570 ? s4566 : s4567; + const SWord8 s4572 = s926 ? s4568 : s4571; + const SBool s4573 = sbv_bv_extract_u8_0_0_u1(s962); + const SBool s4574 = false != s4573; + const SBool s4575 = sbv_bv_extract_u8_0_0_u1(s955); + const SBool s4576 = false != s4575; + const SWord8 s4577 = s4576 ? s4562 : s4563; + const SWord8 s4578 = sbv_bv_u8_rotr(s4577, 1); + const SWord8 s4579 = 128 | s4578; + const SWord8 s4580 = 127 & s4578; + const SWord8 s4581 = s4574 ? s4579 : s4580; + const SBool s4582 = sbv_bv_extract_u8_0_0_u1(s967); + const SBool s4583 = false != s4582; + const SWord8 s4584 = s4583 ? s4579 : s4580; + const SWord8 s4585 = s926 ? s4581 : s4584; + const SWord8 s4586 = s799 ? s4572 : s4585; + const SBool s4587 = sbv_bv_extract_u8_0_0_u1(s988); + const SBool s4588 = false != s4587; + const SBool s4589 = sbv_bv_extract_u8_0_0_u1(s984); + const SBool s4590 = false != s4589; + const SBool s4591 = sbv_bv_extract_u8_0_0_u1(s977); + const SBool s4592 = false != s4591; + const SWord8 s4593 = s4592 ? s4558 : s4559; + const SWord8 s4594 = sbv_bv_u8_rotr(s4593, 1); + const SWord8 s4595 = 128 | s4594; + const SWord8 s4596 = 127 & s4594; + const SWord8 s4597 = s4590 ? s4595 : s4596; + const SWord8 s4598 = sbv_bv_u8_rotr(s4597, 1); + const SWord8 s4599 = 128 | s4598; + const SWord8 s4600 = 127 & s4598; + const SWord8 s4601 = s4588 ? s4599 : s4600; + const SBool s4602 = sbv_bv_extract_u8_0_0_u1(s993); + const SBool s4603 = false != s4602; + const SWord8 s4604 = s4603 ? s4599 : s4600; + const SWord8 s4605 = s926 ? s4601 : s4604; + const SBool s4606 = sbv_bv_extract_u8_0_0_u1(s1009); + const SBool s4607 = false != s4606; + const SBool s4608 = sbv_bv_extract_u8_0_0_u1(s1002); + const SBool s4609 = false != s4608; + const SWord8 s4610 = s4609 ? s4595 : s4596; + const SWord8 s4611 = sbv_bv_u8_rotr(s4610, 1); + const SWord8 s4612 = 128 | s4611; + const SWord8 s4613 = 127 & s4611; + const SWord8 s4614 = s4607 ? s4612 : s4613; + const SBool s4615 = sbv_bv_extract_u8_0_0_u1(s1014); + const SBool s4616 = false != s4615; + const SWord8 s4617 = s4616 ? s4612 : s4613; + const SWord8 s4618 = s926 ? s4614 : s4617; + const SWord8 s4619 = s799 ? s4605 : s4618; + const SWord8 s4620 = s544 ? s4586 : s4619; + const SWord8 s4621 = s36 ? s4550 : s4620; + const SWord8 s4622 = s21 ? s4480 : s4621; + const SWord8 s4623 = s16 ? s4339 : s4622; + const SBool s4624 = sbv_bv_extract_u8_0_0_u1(s1109); + const SBool s4625 = false != s4624; + const SBool s4626 = sbv_bv_extract_u8_0_0_u1(s1105); + const SBool s4627 = false != s4626; + const SBool s4628 = sbv_bv_extract_u8_0_0_u1(s1101); + const SBool s4629 = false != s4628; + const SWord8 s4630 = sbv_bv_u8_rotr(s1088, 1); + const SWord8 s4631 = 128 | s4630; + const SWord8 s4632 = 127 & s4630; + const SWord8 s4633 = s4629 ? s4631 : s4632; + const SWord8 s4634 = sbv_bv_u8_rotr(s4633, 1); + const SWord8 s4635 = 128 | s4634; + const SWord8 s4636 = 127 & s4634; + const SWord8 s4637 = s4627 ? s4635 : s4636; + const SWord8 s4638 = sbv_bv_u8_rotr(s4637, 1); + const SWord8 s4639 = 128 | s4638; + const SWord8 s4640 = 127 & s4638; + const SWord8 s4641 = s4625 ? s4639 : s4640; + const SBool s4642 = sbv_bv_extract_u8_0_0_u1(s1114); + const SBool s4643 = false != s4642; + const SWord8 s4644 = s4643 ? s4639 : s4640; + const SWord8 s4645 = s1097 ? s4641 : s4644; + const SBool s4646 = sbv_bv_extract_u8_0_0_u1(s1130); + const SBool s4647 = false != s4646; + const SBool s4648 = sbv_bv_extract_u8_0_0_u1(s1123); + const SBool s4649 = false != s4648; + const SWord8 s4650 = s4649 ? s4635 : s4636; + const SWord8 s4651 = sbv_bv_u8_rotr(s4650, 1); + const SWord8 s4652 = 128 | s4651; + const SWord8 s4653 = 127 & s4651; + const SWord8 s4654 = s4647 ? s4652 : s4653; + const SBool s4655 = sbv_bv_extract_u8_0_0_u1(s1135); + const SBool s4656 = false != s4655; + const SWord8 s4657 = s4656 ? s4652 : s4653; + const SWord8 s4658 = s1097 ? s4654 : s4657; + const SWord8 s4659 = s1078 ? s4645 : s4658; + const SBool s4660 = sbv_bv_extract_u8_0_0_u1(s1156); + const SBool s4661 = false != s4660; + const SBool s4662 = sbv_bv_extract_u8_0_0_u1(s1152); + const SBool s4663 = false != s4662; + const SBool s4664 = sbv_bv_extract_u8_0_0_u1(s1145); + const SBool s4665 = false != s4664; + const SWord8 s4666 = s4665 ? s4631 : s4632; + const SWord8 s4667 = sbv_bv_u8_rotr(s4666, 1); + const SWord8 s4668 = 128 | s4667; + const SWord8 s4669 = 127 & s4667; + const SWord8 s4670 = s4663 ? s4668 : s4669; + const SWord8 s4671 = sbv_bv_u8_rotr(s4670, 1); + const SWord8 s4672 = 128 | s4671; + const SWord8 s4673 = 127 & s4671; + const SWord8 s4674 = s4661 ? s4672 : s4673; + const SBool s4675 = sbv_bv_extract_u8_0_0_u1(s1161); + const SBool s4676 = false != s4675; + const SWord8 s4677 = s4676 ? s4672 : s4673; + const SWord8 s4678 = s1097 ? s4674 : s4677; + const SBool s4679 = sbv_bv_extract_u8_0_0_u1(s1177); + const SBool s4680 = false != s4679; + const SBool s4681 = sbv_bv_extract_u8_0_0_u1(s1170); + const SBool s4682 = false != s4681; + const SWord8 s4683 = s4682 ? s4668 : s4669; + const SWord8 s4684 = sbv_bv_u8_rotr(s4683, 1); + const SWord8 s4685 = 128 | s4684; + const SWord8 s4686 = 127 & s4684; + const SWord8 s4687 = s4680 ? s4685 : s4686; + const SBool s4688 = sbv_bv_extract_u8_0_0_u1(s1182); + const SBool s4689 = false != s4688; + const SWord8 s4690 = s4689 ? s4685 : s4686; + const SWord8 s4691 = s1097 ? s4687 : s4690; + const SWord8 s4692 = s1078 ? s4678 : s4691; + const SWord8 s4693 = s1059 ? s4659 : s4692; + const SBool s4694 = sbv_bv_extract_u8_0_0_u1(s1217); + const SBool s4695 = false != s4694; + const SBool s4696 = sbv_bv_extract_u8_0_0_u1(s1213); + const SBool s4697 = false != s4696; + const SBool s4698 = sbv_bv_extract_u8_0_0_u1(s1209); + const SBool s4699 = false != s4698; + const SWord8 s4700 = sbv_bv_u8_rotr(s1196, 1); + const SWord8 s4701 = 128 | s4700; + const SWord8 s4702 = 127 & s4700; + const SWord8 s4703 = s4699 ? s4701 : s4702; + const SWord8 s4704 = sbv_bv_u8_rotr(s4703, 1); + const SWord8 s4705 = 128 | s4704; + const SWord8 s4706 = 127 & s4704; + const SWord8 s4707 = s4697 ? s4705 : s4706; + const SWord8 s4708 = sbv_bv_u8_rotr(s4707, 1); + const SWord8 s4709 = 128 | s4708; + const SWord8 s4710 = 127 & s4708; + const SWord8 s4711 = s4695 ? s4709 : s4710; + const SBool s4712 = sbv_bv_extract_u8_0_0_u1(s1222); + const SBool s4713 = false != s4712; + const SWord8 s4714 = s4713 ? s4709 : s4710; + const SWord8 s4715 = s1202 ? s4711 : s4714; + const SBool s4716 = sbv_bv_extract_u8_0_0_u1(s1238); + const SBool s4717 = false != s4716; + const SBool s4718 = sbv_bv_extract_u8_0_0_u1(s1231); + const SBool s4719 = false != s4718; + const SWord8 s4720 = s4719 ? s4705 : s4706; + const SWord8 s4721 = sbv_bv_u8_rotr(s4720, 1); + const SWord8 s4722 = 128 | s4721; + const SWord8 s4723 = 127 & s4721; + const SWord8 s4724 = s4717 ? s4722 : s4723; + const SBool s4725 = sbv_bv_extract_u8_0_0_u1(s1243); + const SBool s4726 = false != s4725; + const SWord8 s4727 = s4726 ? s4722 : s4723; + const SWord8 s4728 = s1202 ? s4724 : s4727; + const SWord8 s4729 = s1078 ? s4715 : s4728; + const SBool s4730 = sbv_bv_extract_u8_0_0_u1(s1264); + const SBool s4731 = false != s4730; + const SBool s4732 = sbv_bv_extract_u8_0_0_u1(s1260); + const SBool s4733 = false != s4732; + const SBool s4734 = sbv_bv_extract_u8_0_0_u1(s1253); + const SBool s4735 = false != s4734; + const SWord8 s4736 = s4735 ? s4701 : s4702; + const SWord8 s4737 = sbv_bv_u8_rotr(s4736, 1); + const SWord8 s4738 = 128 | s4737; + const SWord8 s4739 = 127 & s4737; + const SWord8 s4740 = s4733 ? s4738 : s4739; + const SWord8 s4741 = sbv_bv_u8_rotr(s4740, 1); + const SWord8 s4742 = 128 | s4741; + const SWord8 s4743 = 127 & s4741; + const SWord8 s4744 = s4731 ? s4742 : s4743; + const SBool s4745 = sbv_bv_extract_u8_0_0_u1(s1269); + const SBool s4746 = false != s4745; + const SWord8 s4747 = s4746 ? s4742 : s4743; + const SWord8 s4748 = s1202 ? s4744 : s4747; + const SBool s4749 = sbv_bv_extract_u8_0_0_u1(s1285); + const SBool s4750 = false != s4749; + const SBool s4751 = sbv_bv_extract_u8_0_0_u1(s1278); + const SBool s4752 = false != s4751; + const SWord8 s4753 = s4752 ? s4738 : s4739; + const SWord8 s4754 = sbv_bv_u8_rotr(s4753, 1); + const SWord8 s4755 = 128 | s4754; + const SWord8 s4756 = 127 & s4754; + const SWord8 s4757 = s4750 ? s4755 : s4756; + const SBool s4758 = sbv_bv_extract_u8_0_0_u1(s1290); + const SBool s4759 = false != s4758; + const SWord8 s4760 = s4759 ? s4755 : s4756; + const SWord8 s4761 = s1202 ? s4757 : s4760; + const SWord8 s4762 = s1078 ? s4748 : s4761; + const SWord8 s4763 = s1059 ? s4729 : s4762; + const SWord8 s4764 = s1037 ? s4693 : s4763; + const SBool s4765 = sbv_bv_extract_u8_0_0_u1(s1345); + const SBool s4766 = false != s4765; + const SBool s4767 = sbv_bv_extract_u8_0_0_u1(s1341); + const SBool s4768 = false != s4767; + const SBool s4769 = sbv_bv_extract_u8_0_0_u1(s1337); + const SBool s4770 = false != s4769; + const SWord8 s4771 = sbv_bv_u8_rotr(s1324, 1); + const SWord8 s4772 = 128 | s4771; + const SWord8 s4773 = 127 & s4771; + const SWord8 s4774 = s4770 ? s4772 : s4773; + const SWord8 s4775 = sbv_bv_u8_rotr(s4774, 1); + const SWord8 s4776 = 128 | s4775; + const SWord8 s4777 = 127 & s4775; + const SWord8 s4778 = s4768 ? s4776 : s4777; + const SWord8 s4779 = sbv_bv_u8_rotr(s4778, 1); + const SWord8 s4780 = 128 | s4779; + const SWord8 s4781 = 127 & s4779; + const SWord8 s4782 = s4766 ? s4780 : s4781; + const SBool s4783 = sbv_bv_extract_u8_0_0_u1(s1350); + const SBool s4784 = false != s4783; + const SWord8 s4785 = s4784 ? s4780 : s4781; + const SWord8 s4786 = s1333 ? s4782 : s4785; + const SBool s4787 = sbv_bv_extract_u8_0_0_u1(s1366); + const SBool s4788 = false != s4787; + const SBool s4789 = sbv_bv_extract_u8_0_0_u1(s1359); + const SBool s4790 = false != s4789; + const SWord8 s4791 = s4790 ? s4776 : s4777; + const SWord8 s4792 = sbv_bv_u8_rotr(s4791, 1); + const SWord8 s4793 = 128 | s4792; + const SWord8 s4794 = 127 & s4792; + const SWord8 s4795 = s4788 ? s4793 : s4794; + const SBool s4796 = sbv_bv_extract_u8_0_0_u1(s1371); + const SBool s4797 = false != s4796; + const SWord8 s4798 = s4797 ? s4793 : s4794; + const SWord8 s4799 = s1333 ? s4795 : s4798; + const SWord8 s4800 = s1311 ? s4786 : s4799; + const SBool s4801 = sbv_bv_extract_u8_0_0_u1(s1392); + const SBool s4802 = false != s4801; + const SBool s4803 = sbv_bv_extract_u8_0_0_u1(s1388); + const SBool s4804 = false != s4803; + const SBool s4805 = sbv_bv_extract_u8_0_0_u1(s1381); + const SBool s4806 = false != s4805; + const SWord8 s4807 = s4806 ? s4772 : s4773; + const SWord8 s4808 = sbv_bv_u8_rotr(s4807, 1); + const SWord8 s4809 = 128 | s4808; + const SWord8 s4810 = 127 & s4808; + const SWord8 s4811 = s4804 ? s4809 : s4810; + const SWord8 s4812 = sbv_bv_u8_rotr(s4811, 1); + const SWord8 s4813 = 128 | s4812; + const SWord8 s4814 = 127 & s4812; + const SWord8 s4815 = s4802 ? s4813 : s4814; + const SBool s4816 = sbv_bv_extract_u8_0_0_u1(s1397); + const SBool s4817 = false != s4816; + const SWord8 s4818 = s4817 ? s4813 : s4814; + const SWord8 s4819 = s1333 ? s4815 : s4818; + const SBool s4820 = sbv_bv_extract_u8_0_0_u1(s1413); + const SBool s4821 = false != s4820; + const SBool s4822 = sbv_bv_extract_u8_0_0_u1(s1406); + const SBool s4823 = false != s4822; + const SWord8 s4824 = s4823 ? s4809 : s4810; + const SWord8 s4825 = sbv_bv_u8_rotr(s4824, 1); + const SWord8 s4826 = 128 | s4825; + const SWord8 s4827 = 127 & s4825; + const SWord8 s4828 = s4821 ? s4826 : s4827; + const SBool s4829 = sbv_bv_extract_u8_0_0_u1(s1418); + const SBool s4830 = false != s4829; + const SWord8 s4831 = s4830 ? s4826 : s4827; + const SWord8 s4832 = s1333 ? s4828 : s4831; + const SWord8 s4833 = s1311 ? s4819 : s4832; + const SWord8 s4834 = s1059 ? s4800 : s4833; + const SBool s4835 = sbv_bv_extract_u8_0_0_u1(s1453); + const SBool s4836 = false != s4835; + const SBool s4837 = sbv_bv_extract_u8_0_0_u1(s1449); + const SBool s4838 = false != s4837; + const SBool s4839 = sbv_bv_extract_u8_0_0_u1(s1445); + const SBool s4840 = false != s4839; + const SWord8 s4841 = sbv_bv_u8_rotr(s1432, 1); + const SWord8 s4842 = 128 | s4841; + const SWord8 s4843 = 127 & s4841; + const SWord8 s4844 = s4840 ? s4842 : s4843; + const SWord8 s4845 = sbv_bv_u8_rotr(s4844, 1); + const SWord8 s4846 = 128 | s4845; + const SWord8 s4847 = 127 & s4845; + const SWord8 s4848 = s4838 ? s4846 : s4847; + const SWord8 s4849 = sbv_bv_u8_rotr(s4848, 1); + const SWord8 s4850 = 128 | s4849; + const SWord8 s4851 = 127 & s4849; + const SWord8 s4852 = s4836 ? s4850 : s4851; + const SBool s4853 = sbv_bv_extract_u8_0_0_u1(s1458); + const SBool s4854 = false != s4853; + const SWord8 s4855 = s4854 ? s4850 : s4851; + const SWord8 s4856 = s1438 ? s4852 : s4855; + const SBool s4857 = sbv_bv_extract_u8_0_0_u1(s1474); + const SBool s4858 = false != s4857; + const SBool s4859 = sbv_bv_extract_u8_0_0_u1(s1467); + const SBool s4860 = false != s4859; + const SWord8 s4861 = s4860 ? s4846 : s4847; + const SWord8 s4862 = sbv_bv_u8_rotr(s4861, 1); + const SWord8 s4863 = 128 | s4862; + const SWord8 s4864 = 127 & s4862; + const SWord8 s4865 = s4858 ? s4863 : s4864; + const SBool s4866 = sbv_bv_extract_u8_0_0_u1(s1479); + const SBool s4867 = false != s4866; + const SWord8 s4868 = s4867 ? s4863 : s4864; + const SWord8 s4869 = s1438 ? s4865 : s4868; + const SWord8 s4870 = s1311 ? s4856 : s4869; + const SBool s4871 = sbv_bv_extract_u8_0_0_u1(s1500); + const SBool s4872 = false != s4871; + const SBool s4873 = sbv_bv_extract_u8_0_0_u1(s1496); + const SBool s4874 = false != s4873; + const SBool s4875 = sbv_bv_extract_u8_0_0_u1(s1489); + const SBool s4876 = false != s4875; + const SWord8 s4877 = s4876 ? s4842 : s4843; + const SWord8 s4878 = sbv_bv_u8_rotr(s4877, 1); + const SWord8 s4879 = 128 | s4878; + const SWord8 s4880 = 127 & s4878; + const SWord8 s4881 = s4874 ? s4879 : s4880; + const SWord8 s4882 = sbv_bv_u8_rotr(s4881, 1); + const SWord8 s4883 = 128 | s4882; + const SWord8 s4884 = 127 & s4882; + const SWord8 s4885 = s4872 ? s4883 : s4884; + const SBool s4886 = sbv_bv_extract_u8_0_0_u1(s1505); + const SBool s4887 = false != s4886; + const SWord8 s4888 = s4887 ? s4883 : s4884; + const SWord8 s4889 = s1438 ? s4885 : s4888; + const SBool s4890 = sbv_bv_extract_u8_0_0_u1(s1521); + const SBool s4891 = false != s4890; + const SBool s4892 = sbv_bv_extract_u8_0_0_u1(s1514); + const SBool s4893 = false != s4892; + const SWord8 s4894 = s4893 ? s4879 : s4880; + const SWord8 s4895 = sbv_bv_u8_rotr(s4894, 1); + const SWord8 s4896 = 128 | s4895; + const SWord8 s4897 = 127 & s4895; + const SWord8 s4898 = s4891 ? s4896 : s4897; + const SBool s4899 = sbv_bv_extract_u8_0_0_u1(s1526); + const SBool s4900 = false != s4899; + const SWord8 s4901 = s4900 ? s4896 : s4897; + const SWord8 s4902 = s1438 ? s4898 : s4901; + const SWord8 s4903 = s1311 ? s4889 : s4902; + const SWord8 s4904 = s1059 ? s4870 : s4903; + const SWord8 s4905 = s1037 ? s4834 : s4904; + const SWord8 s4906 = s21 ? s4764 : s4905; + const SBool s4907 = sbv_bv_extract_u8_0_0_u1(s1601); + const SBool s4908 = false != s4907; + const SBool s4909 = sbv_bv_extract_u8_0_0_u1(s1597); + const SBool s4910 = false != s4909; + const SBool s4911 = sbv_bv_extract_u8_0_0_u1(s1593); + const SBool s4912 = false != s4911; + const SWord8 s4913 = sbv_bv_u8_rotr(s1580, 1); + const SWord8 s4914 = 128 | s4913; + const SWord8 s4915 = 127 & s4913; + const SWord8 s4916 = s4912 ? s4914 : s4915; + const SWord8 s4917 = sbv_bv_u8_rotr(s4916, 1); + const SWord8 s4918 = 128 | s4917; + const SWord8 s4919 = 127 & s4917; + const SWord8 s4920 = s4910 ? s4918 : s4919; + const SWord8 s4921 = sbv_bv_u8_rotr(s4920, 1); + const SWord8 s4922 = 128 | s4921; + const SWord8 s4923 = 127 & s4921; + const SWord8 s4924 = s4908 ? s4922 : s4923; + const SBool s4925 = sbv_bv_extract_u8_0_0_u1(s1606); + const SBool s4926 = false != s4925; + const SWord8 s4927 = s4926 ? s4922 : s4923; + const SWord8 s4928 = s1589 ? s4924 : s4927; + const SBool s4929 = sbv_bv_extract_u8_0_0_u1(s1622); + const SBool s4930 = false != s4929; + const SBool s4931 = sbv_bv_extract_u8_0_0_u1(s1615); + const SBool s4932 = false != s4931; + const SWord8 s4933 = s4932 ? s4918 : s4919; + const SWord8 s4934 = sbv_bv_u8_rotr(s4933, 1); + const SWord8 s4935 = 128 | s4934; + const SWord8 s4936 = 127 & s4934; + const SWord8 s4937 = s4930 ? s4935 : s4936; + const SBool s4938 = sbv_bv_extract_u8_0_0_u1(s1627); + const SBool s4939 = false != s4938; + const SWord8 s4940 = s4939 ? s4935 : s4936; + const SWord8 s4941 = s1589 ? s4937 : s4940; + const SWord8 s4942 = s1570 ? s4928 : s4941; + const SBool s4943 = sbv_bv_extract_u8_0_0_u1(s1648); + const SBool s4944 = false != s4943; + const SBool s4945 = sbv_bv_extract_u8_0_0_u1(s1644); + const SBool s4946 = false != s4945; + const SBool s4947 = sbv_bv_extract_u8_0_0_u1(s1637); + const SBool s4948 = false != s4947; + const SWord8 s4949 = s4948 ? s4914 : s4915; + const SWord8 s4950 = sbv_bv_u8_rotr(s4949, 1); + const SWord8 s4951 = 128 | s4950; + const SWord8 s4952 = 127 & s4950; + const SWord8 s4953 = s4946 ? s4951 : s4952; + const SWord8 s4954 = sbv_bv_u8_rotr(s4953, 1); + const SWord8 s4955 = 128 | s4954; + const SWord8 s4956 = 127 & s4954; + const SWord8 s4957 = s4944 ? s4955 : s4956; + const SBool s4958 = sbv_bv_extract_u8_0_0_u1(s1653); + const SBool s4959 = false != s4958; + const SWord8 s4960 = s4959 ? s4955 : s4956; + const SWord8 s4961 = s1589 ? s4957 : s4960; + const SBool s4962 = sbv_bv_extract_u8_0_0_u1(s1669); + const SBool s4963 = false != s4962; + const SBool s4964 = sbv_bv_extract_u8_0_0_u1(s1662); + const SBool s4965 = false != s4964; + const SWord8 s4966 = s4965 ? s4951 : s4952; + const SWord8 s4967 = sbv_bv_u8_rotr(s4966, 1); + const SWord8 s4968 = 128 | s4967; + const SWord8 s4969 = 127 & s4967; + const SWord8 s4970 = s4963 ? s4968 : s4969; + const SBool s4971 = sbv_bv_extract_u8_0_0_u1(s1674); + const SBool s4972 = false != s4971; + const SWord8 s4973 = s4972 ? s4968 : s4969; + const SWord8 s4974 = s1589 ? s4970 : s4973; + const SWord8 s4975 = s1570 ? s4961 : s4974; + const SWord8 s4976 = s1548 ? s4942 : s4975; + const SBool s4977 = sbv_bv_extract_u8_0_0_u1(s1709); + const SBool s4978 = false != s4977; + const SBool s4979 = sbv_bv_extract_u8_0_0_u1(s1705); + const SBool s4980 = false != s4979; + const SBool s4981 = sbv_bv_extract_u8_0_0_u1(s1701); + const SBool s4982 = false != s4981; + const SWord8 s4983 = sbv_bv_u8_rotr(s1688, 1); + const SWord8 s4984 = 128 | s4983; + const SWord8 s4985 = 127 & s4983; + const SWord8 s4986 = s4982 ? s4984 : s4985; + const SWord8 s4987 = sbv_bv_u8_rotr(s4986, 1); + const SWord8 s4988 = 128 | s4987; + const SWord8 s4989 = 127 & s4987; + const SWord8 s4990 = s4980 ? s4988 : s4989; + const SWord8 s4991 = sbv_bv_u8_rotr(s4990, 1); + const SWord8 s4992 = 128 | s4991; + const SWord8 s4993 = 127 & s4991; + const SWord8 s4994 = s4978 ? s4992 : s4993; + const SBool s4995 = sbv_bv_extract_u8_0_0_u1(s1714); + const SBool s4996 = false != s4995; + const SWord8 s4997 = s4996 ? s4992 : s4993; + const SWord8 s4998 = s1694 ? s4994 : s4997; + const SBool s4999 = sbv_bv_extract_u8_0_0_u1(s1730); + const SBool s5000 = false != s4999; + const SBool s5001 = sbv_bv_extract_u8_0_0_u1(s1723); + const SBool s5002 = false != s5001; + const SWord8 s5003 = s5002 ? s4988 : s4989; + const SWord8 s5004 = sbv_bv_u8_rotr(s5003, 1); + const SWord8 s5005 = 128 | s5004; + const SWord8 s5006 = 127 & s5004; + const SWord8 s5007 = s5000 ? s5005 : s5006; + const SBool s5008 = sbv_bv_extract_u8_0_0_u1(s1735); + const SBool s5009 = false != s5008; + const SWord8 s5010 = s5009 ? s5005 : s5006; + const SWord8 s5011 = s1694 ? s5007 : s5010; + const SWord8 s5012 = s1570 ? s4998 : s5011; + const SBool s5013 = sbv_bv_extract_u8_0_0_u1(s1756); + const SBool s5014 = false != s5013; + const SBool s5015 = sbv_bv_extract_u8_0_0_u1(s1752); + const SBool s5016 = false != s5015; + const SBool s5017 = sbv_bv_extract_u8_0_0_u1(s1745); + const SBool s5018 = false != s5017; + const SWord8 s5019 = s5018 ? s4984 : s4985; + const SWord8 s5020 = sbv_bv_u8_rotr(s5019, 1); + const SWord8 s5021 = 128 | s5020; + const SWord8 s5022 = 127 & s5020; + const SWord8 s5023 = s5016 ? s5021 : s5022; + const SWord8 s5024 = sbv_bv_u8_rotr(s5023, 1); + const SWord8 s5025 = 128 | s5024; + const SWord8 s5026 = 127 & s5024; + const SWord8 s5027 = s5014 ? s5025 : s5026; + const SBool s5028 = sbv_bv_extract_u8_0_0_u1(s1761); + const SBool s5029 = false != s5028; + const SWord8 s5030 = s5029 ? s5025 : s5026; + const SWord8 s5031 = s1694 ? s5027 : s5030; + const SBool s5032 = sbv_bv_extract_u8_0_0_u1(s1777); + const SBool s5033 = false != s5032; + const SBool s5034 = sbv_bv_extract_u8_0_0_u1(s1770); + const SBool s5035 = false != s5034; + const SWord8 s5036 = s5035 ? s5021 : s5022; + const SWord8 s5037 = sbv_bv_u8_rotr(s5036, 1); + const SWord8 s5038 = 128 | s5037; + const SWord8 s5039 = 127 & s5037; + const SWord8 s5040 = s5033 ? s5038 : s5039; + const SBool s5041 = sbv_bv_extract_u8_0_0_u1(s1782); + const SBool s5042 = false != s5041; + const SWord8 s5043 = s5042 ? s5038 : s5039; + const SWord8 s5044 = s1694 ? s5040 : s5043; + const SWord8 s5045 = s1570 ? s5031 : s5044; + const SWord8 s5046 = s1548 ? s5012 : s5045; + const SWord8 s5047 = s1037 ? s4976 : s5046; + const SBool s5048 = sbv_bv_extract_u8_0_0_u1(s1837); + const SBool s5049 = false != s5048; + const SBool s5050 = sbv_bv_extract_u8_0_0_u1(s1833); + const SBool s5051 = false != s5050; + const SBool s5052 = sbv_bv_extract_u8_0_0_u1(s1829); + const SBool s5053 = false != s5052; + const SWord8 s5054 = sbv_bv_u8_rotr(s1816, 1); + const SWord8 s5055 = 128 | s5054; + const SWord8 s5056 = 127 & s5054; + const SWord8 s5057 = s5053 ? s5055 : s5056; + const SWord8 s5058 = sbv_bv_u8_rotr(s5057, 1); + const SWord8 s5059 = 128 | s5058; + const SWord8 s5060 = 127 & s5058; + const SWord8 s5061 = s5051 ? s5059 : s5060; + const SWord8 s5062 = sbv_bv_u8_rotr(s5061, 1); + const SWord8 s5063 = 128 | s5062; + const SWord8 s5064 = 127 & s5062; + const SWord8 s5065 = s5049 ? s5063 : s5064; + const SBool s5066 = sbv_bv_extract_u8_0_0_u1(s1842); + const SBool s5067 = false != s5066; + const SWord8 s5068 = s5067 ? s5063 : s5064; + const SWord8 s5069 = s1825 ? s5065 : s5068; + const SBool s5070 = sbv_bv_extract_u8_0_0_u1(s1858); + const SBool s5071 = false != s5070; + const SBool s5072 = sbv_bv_extract_u8_0_0_u1(s1851); + const SBool s5073 = false != s5072; + const SWord8 s5074 = s5073 ? s5059 : s5060; + const SWord8 s5075 = sbv_bv_u8_rotr(s5074, 1); + const SWord8 s5076 = 128 | s5075; + const SWord8 s5077 = 127 & s5075; + const SWord8 s5078 = s5071 ? s5076 : s5077; + const SBool s5079 = sbv_bv_extract_u8_0_0_u1(s1863); + const SBool s5080 = false != s5079; + const SWord8 s5081 = s5080 ? s5076 : s5077; + const SWord8 s5082 = s1825 ? s5078 : s5081; + const SWord8 s5083 = s1803 ? s5069 : s5082; + const SBool s5084 = sbv_bv_extract_u8_0_0_u1(s1884); + const SBool s5085 = false != s5084; + const SBool s5086 = sbv_bv_extract_u8_0_0_u1(s1880); + const SBool s5087 = false != s5086; + const SBool s5088 = sbv_bv_extract_u8_0_0_u1(s1873); + const SBool s5089 = false != s5088; + const SWord8 s5090 = s5089 ? s5055 : s5056; + const SWord8 s5091 = sbv_bv_u8_rotr(s5090, 1); + const SWord8 s5092 = 128 | s5091; + const SWord8 s5093 = 127 & s5091; + const SWord8 s5094 = s5087 ? s5092 : s5093; + const SWord8 s5095 = sbv_bv_u8_rotr(s5094, 1); + const SWord8 s5096 = 128 | s5095; + const SWord8 s5097 = 127 & s5095; + const SWord8 s5098 = s5085 ? s5096 : s5097; + const SBool s5099 = sbv_bv_extract_u8_0_0_u1(s1889); + const SBool s5100 = false != s5099; + const SWord8 s5101 = s5100 ? s5096 : s5097; + const SWord8 s5102 = s1825 ? s5098 : s5101; + const SBool s5103 = sbv_bv_extract_u8_0_0_u1(s1905); + const SBool s5104 = false != s5103; + const SBool s5105 = sbv_bv_extract_u8_0_0_u1(s1898); + const SBool s5106 = false != s5105; + const SWord8 s5107 = s5106 ? s5092 : s5093; + const SWord8 s5108 = sbv_bv_u8_rotr(s5107, 1); + const SWord8 s5109 = 128 | s5108; + const SWord8 s5110 = 127 & s5108; + const SWord8 s5111 = s5104 ? s5109 : s5110; + const SBool s5112 = sbv_bv_extract_u8_0_0_u1(s1910); + const SBool s5113 = false != s5112; + const SWord8 s5114 = s5113 ? s5109 : s5110; + const SWord8 s5115 = s1825 ? s5111 : s5114; + const SWord8 s5116 = s1803 ? s5102 : s5115; + const SWord8 s5117 = s1548 ? s5083 : s5116; + const SBool s5118 = sbv_bv_extract_u8_0_0_u1(s1945); + const SBool s5119 = false != s5118; + const SBool s5120 = sbv_bv_extract_u8_0_0_u1(s1941); + const SBool s5121 = false != s5120; + const SBool s5122 = sbv_bv_extract_u8_0_0_u1(s1937); + const SBool s5123 = false != s5122; + const SWord8 s5124 = sbv_bv_u8_rotr(s1924, 1); + const SWord8 s5125 = 128 | s5124; + const SWord8 s5126 = 127 & s5124; + const SWord8 s5127 = s5123 ? s5125 : s5126; + const SWord8 s5128 = sbv_bv_u8_rotr(s5127, 1); + const SWord8 s5129 = 128 | s5128; + const SWord8 s5130 = 127 & s5128; + const SWord8 s5131 = s5121 ? s5129 : s5130; + const SWord8 s5132 = sbv_bv_u8_rotr(s5131, 1); + const SWord8 s5133 = 128 | s5132; + const SWord8 s5134 = 127 & s5132; + const SWord8 s5135 = s5119 ? s5133 : s5134; + const SBool s5136 = sbv_bv_extract_u8_0_0_u1(s1950); + const SBool s5137 = false != s5136; + const SWord8 s5138 = s5137 ? s5133 : s5134; + const SWord8 s5139 = s1930 ? s5135 : s5138; + const SBool s5140 = sbv_bv_extract_u8_0_0_u1(s1966); + const SBool s5141 = false != s5140; + const SBool s5142 = sbv_bv_extract_u8_0_0_u1(s1959); + const SBool s5143 = false != s5142; + const SWord8 s5144 = s5143 ? s5129 : s5130; + const SWord8 s5145 = sbv_bv_u8_rotr(s5144, 1); + const SWord8 s5146 = 128 | s5145; + const SWord8 s5147 = 127 & s5145; + const SWord8 s5148 = s5141 ? s5146 : s5147; + const SBool s5149 = sbv_bv_extract_u8_0_0_u1(s1971); + const SBool s5150 = false != s5149; + const SWord8 s5151 = s5150 ? s5146 : s5147; + const SWord8 s5152 = s1930 ? s5148 : s5151; + const SWord8 s5153 = s1803 ? s5139 : s5152; + const SBool s5154 = sbv_bv_extract_u8_0_0_u1(s1992); + const SBool s5155 = false != s5154; + const SBool s5156 = sbv_bv_extract_u8_0_0_u1(s1988); + const SBool s5157 = false != s5156; + const SBool s5158 = sbv_bv_extract_u8_0_0_u1(s1981); + const SBool s5159 = false != s5158; + const SWord8 s5160 = s5159 ? s5125 : s5126; + const SWord8 s5161 = sbv_bv_u8_rotr(s5160, 1); + const SWord8 s5162 = 128 | s5161; + const SWord8 s5163 = 127 & s5161; + const SWord8 s5164 = s5157 ? s5162 : s5163; + const SWord8 s5165 = sbv_bv_u8_rotr(s5164, 1); + const SWord8 s5166 = 128 | s5165; + const SWord8 s5167 = 127 & s5165; + const SWord8 s5168 = s5155 ? s5166 : s5167; + const SBool s5169 = sbv_bv_extract_u8_0_0_u1(s1997); + const SBool s5170 = false != s5169; + const SWord8 s5171 = s5170 ? s5166 : s5167; + const SWord8 s5172 = s1930 ? s5168 : s5171; + const SBool s5173 = sbv_bv_extract_u8_0_0_u1(s2013); + const SBool s5174 = false != s5173; + const SBool s5175 = sbv_bv_extract_u8_0_0_u1(s2006); + const SBool s5176 = false != s5175; + const SWord8 s5177 = s5176 ? s5162 : s5163; + const SWord8 s5178 = sbv_bv_u8_rotr(s5177, 1); + const SWord8 s5179 = 128 | s5178; + const SWord8 s5180 = 127 & s5178; + const SWord8 s5181 = s5174 ? s5179 : s5180; + const SBool s5182 = sbv_bv_extract_u8_0_0_u1(s2018); + const SBool s5183 = false != s5182; + const SWord8 s5184 = s5183 ? s5179 : s5180; + const SWord8 s5185 = s1930 ? s5181 : s5184; + const SWord8 s5186 = s1803 ? s5172 : s5185; + const SWord8 s5187 = s1548 ? s5153 : s5186; + const SWord8 s5188 = s1037 ? s5117 : s5187; + const SWord8 s5189 = s21 ? s5047 : s5188; + const SWord8 s5190 = s16 ? s4906 : s5189; + const SWord8 s5191 = s11 ? s4623 : s5190; + const SBool s5192 = sbv_bv_extract_u8_0_0_u1(s2128); + const SBool s5193 = false != s5192; + const SBool s5194 = sbv_bv_extract_u8_0_0_u1(s2124); + const SBool s5195 = false != s5194; + const SBool s5196 = sbv_bv_extract_u8_0_0_u1(s2120); + const SBool s5197 = false != s5196; + const SWord8 s5198 = sbv_bv_u8_rotr(s2107, 1); + const SWord8 s5199 = 128 | s5198; + const SWord8 s5200 = 127 & s5198; + const SWord8 s5201 = s5197 ? s5199 : s5200; + const SWord8 s5202 = sbv_bv_u8_rotr(s5201, 1); + const SWord8 s5203 = 128 | s5202; + const SWord8 s5204 = 127 & s5202; + const SWord8 s5205 = s5195 ? s5203 : s5204; + const SWord8 s5206 = sbv_bv_u8_rotr(s5205, 1); + const SWord8 s5207 = 128 | s5206; + const SWord8 s5208 = 127 & s5206; + const SWord8 s5209 = s5193 ? s5207 : s5208; + const SBool s5210 = sbv_bv_extract_u8_0_0_u1(s2133); + const SBool s5211 = false != s5210; + const SWord8 s5212 = s5211 ? s5207 : s5208; + const SWord8 s5213 = s2116 ? s5209 : s5212; + const SBool s5214 = sbv_bv_extract_u8_0_0_u1(s2149); + const SBool s5215 = false != s5214; + const SBool s5216 = sbv_bv_extract_u8_0_0_u1(s2142); + const SBool s5217 = false != s5216; + const SWord8 s5218 = s5217 ? s5203 : s5204; + const SWord8 s5219 = sbv_bv_u8_rotr(s5218, 1); + const SWord8 s5220 = 128 | s5219; + const SWord8 s5221 = 127 & s5219; + const SWord8 s5222 = s5215 ? s5220 : s5221; + const SBool s5223 = sbv_bv_extract_u8_0_0_u1(s2154); + const SBool s5224 = false != s5223; + const SWord8 s5225 = s5224 ? s5220 : s5221; + const SWord8 s5226 = s2116 ? s5222 : s5225; + const SWord8 s5227 = s2097 ? s5213 : s5226; + const SBool s5228 = sbv_bv_extract_u8_0_0_u1(s2175); + const SBool s5229 = false != s5228; + const SBool s5230 = sbv_bv_extract_u8_0_0_u1(s2171); + const SBool s5231 = false != s5230; + const SBool s5232 = sbv_bv_extract_u8_0_0_u1(s2164); + const SBool s5233 = false != s5232; + const SWord8 s5234 = s5233 ? s5199 : s5200; + const SWord8 s5235 = sbv_bv_u8_rotr(s5234, 1); + const SWord8 s5236 = 128 | s5235; + const SWord8 s5237 = 127 & s5235; + const SWord8 s5238 = s5231 ? s5236 : s5237; + const SWord8 s5239 = sbv_bv_u8_rotr(s5238, 1); + const SWord8 s5240 = 128 | s5239; + const SWord8 s5241 = 127 & s5239; + const SWord8 s5242 = s5229 ? s5240 : s5241; + const SBool s5243 = sbv_bv_extract_u8_0_0_u1(s2180); + const SBool s5244 = false != s5243; + const SWord8 s5245 = s5244 ? s5240 : s5241; + const SWord8 s5246 = s2116 ? s5242 : s5245; + const SBool s5247 = sbv_bv_extract_u8_0_0_u1(s2196); + const SBool s5248 = false != s5247; + const SBool s5249 = sbv_bv_extract_u8_0_0_u1(s2189); + const SBool s5250 = false != s5249; + const SWord8 s5251 = s5250 ? s5236 : s5237; + const SWord8 s5252 = sbv_bv_u8_rotr(s5251, 1); + const SWord8 s5253 = 128 | s5252; + const SWord8 s5254 = 127 & s5252; + const SWord8 s5255 = s5248 ? s5253 : s5254; + const SBool s5256 = sbv_bv_extract_u8_0_0_u1(s2201); + const SBool s5257 = false != s5256; + const SWord8 s5258 = s5257 ? s5253 : s5254; + const SWord8 s5259 = s2116 ? s5255 : s5258; + const SWord8 s5260 = s2097 ? s5246 : s5259; + const SWord8 s5261 = s2078 ? s5227 : s5260; + const SBool s5262 = sbv_bv_extract_u8_0_0_u1(s2236); + const SBool s5263 = false != s5262; + const SBool s5264 = sbv_bv_extract_u8_0_0_u1(s2232); + const SBool s5265 = false != s5264; + const SBool s5266 = sbv_bv_extract_u8_0_0_u1(s2228); + const SBool s5267 = false != s5266; + const SWord8 s5268 = sbv_bv_u8_rotr(s2215, 1); + const SWord8 s5269 = 128 | s5268; + const SWord8 s5270 = 127 & s5268; + const SWord8 s5271 = s5267 ? s5269 : s5270; + const SWord8 s5272 = sbv_bv_u8_rotr(s5271, 1); + const SWord8 s5273 = 128 | s5272; + const SWord8 s5274 = 127 & s5272; + const SWord8 s5275 = s5265 ? s5273 : s5274; + const SWord8 s5276 = sbv_bv_u8_rotr(s5275, 1); + const SWord8 s5277 = 128 | s5276; + const SWord8 s5278 = 127 & s5276; + const SWord8 s5279 = s5263 ? s5277 : s5278; + const SBool s5280 = sbv_bv_extract_u8_0_0_u1(s2241); + const SBool s5281 = false != s5280; + const SWord8 s5282 = s5281 ? s5277 : s5278; + const SWord8 s5283 = s2221 ? s5279 : s5282; + const SBool s5284 = sbv_bv_extract_u8_0_0_u1(s2257); + const SBool s5285 = false != s5284; + const SBool s5286 = sbv_bv_extract_u8_0_0_u1(s2250); + const SBool s5287 = false != s5286; + const SWord8 s5288 = s5287 ? s5273 : s5274; + const SWord8 s5289 = sbv_bv_u8_rotr(s5288, 1); + const SWord8 s5290 = 128 | s5289; + const SWord8 s5291 = 127 & s5289; + const SWord8 s5292 = s5285 ? s5290 : s5291; + const SBool s5293 = sbv_bv_extract_u8_0_0_u1(s2262); + const SBool s5294 = false != s5293; + const SWord8 s5295 = s5294 ? s5290 : s5291; + const SWord8 s5296 = s2221 ? s5292 : s5295; + const SWord8 s5297 = s2097 ? s5283 : s5296; + const SBool s5298 = sbv_bv_extract_u8_0_0_u1(s2283); + const SBool s5299 = false != s5298; + const SBool s5300 = sbv_bv_extract_u8_0_0_u1(s2279); + const SBool s5301 = false != s5300; + const SBool s5302 = sbv_bv_extract_u8_0_0_u1(s2272); + const SBool s5303 = false != s5302; + const SWord8 s5304 = s5303 ? s5269 : s5270; + const SWord8 s5305 = sbv_bv_u8_rotr(s5304, 1); + const SWord8 s5306 = 128 | s5305; + const SWord8 s5307 = 127 & s5305; + const SWord8 s5308 = s5301 ? s5306 : s5307; + const SWord8 s5309 = sbv_bv_u8_rotr(s5308, 1); + const SWord8 s5310 = 128 | s5309; + const SWord8 s5311 = 127 & s5309; + const SWord8 s5312 = s5299 ? s5310 : s5311; + const SBool s5313 = sbv_bv_extract_u8_0_0_u1(s2288); + const SBool s5314 = false != s5313; + const SWord8 s5315 = s5314 ? s5310 : s5311; + const SWord8 s5316 = s2221 ? s5312 : s5315; + const SBool s5317 = sbv_bv_extract_u8_0_0_u1(s2304); + const SBool s5318 = false != s5317; + const SBool s5319 = sbv_bv_extract_u8_0_0_u1(s2297); + const SBool s5320 = false != s5319; + const SWord8 s5321 = s5320 ? s5306 : s5307; + const SWord8 s5322 = sbv_bv_u8_rotr(s5321, 1); + const SWord8 s5323 = 128 | s5322; + const SWord8 s5324 = 127 & s5322; + const SWord8 s5325 = s5318 ? s5323 : s5324; + const SBool s5326 = sbv_bv_extract_u8_0_0_u1(s2309); + const SBool s5327 = false != s5326; + const SWord8 s5328 = s5327 ? s5323 : s5324; + const SWord8 s5329 = s2221 ? s5325 : s5328; + const SWord8 s5330 = s2097 ? s5316 : s5329; + const SWord8 s5331 = s2078 ? s5297 : s5330; + const SWord8 s5332 = s2059 ? s5261 : s5331; + const SBool s5333 = sbv_bv_extract_u8_0_0_u1(s2364); + const SBool s5334 = false != s5333; + const SBool s5335 = sbv_bv_extract_u8_0_0_u1(s2360); + const SBool s5336 = false != s5335; + const SBool s5337 = sbv_bv_extract_u8_0_0_u1(s2356); + const SBool s5338 = false != s5337; + const SWord8 s5339 = sbv_bv_u8_rotr(s2343, 1); + const SWord8 s5340 = 128 | s5339; + const SWord8 s5341 = 127 & s5339; + const SWord8 s5342 = s5338 ? s5340 : s5341; + const SWord8 s5343 = sbv_bv_u8_rotr(s5342, 1); + const SWord8 s5344 = 128 | s5343; + const SWord8 s5345 = 127 & s5343; + const SWord8 s5346 = s5336 ? s5344 : s5345; + const SWord8 s5347 = sbv_bv_u8_rotr(s5346, 1); + const SWord8 s5348 = 128 | s5347; + const SWord8 s5349 = 127 & s5347; + const SWord8 s5350 = s5334 ? s5348 : s5349; + const SBool s5351 = sbv_bv_extract_u8_0_0_u1(s2369); + const SBool s5352 = false != s5351; + const SWord8 s5353 = s5352 ? s5348 : s5349; + const SWord8 s5354 = s2352 ? s5350 : s5353; + const SBool s5355 = sbv_bv_extract_u8_0_0_u1(s2385); + const SBool s5356 = false != s5355; + const SBool s5357 = sbv_bv_extract_u8_0_0_u1(s2378); + const SBool s5358 = false != s5357; + const SWord8 s5359 = s5358 ? s5344 : s5345; + const SWord8 s5360 = sbv_bv_u8_rotr(s5359, 1); + const SWord8 s5361 = 128 | s5360; + const SWord8 s5362 = 127 & s5360; + const SWord8 s5363 = s5356 ? s5361 : s5362; + const SBool s5364 = sbv_bv_extract_u8_0_0_u1(s2390); + const SBool s5365 = false != s5364; + const SWord8 s5366 = s5365 ? s5361 : s5362; + const SWord8 s5367 = s2352 ? s5363 : s5366; + const SWord8 s5368 = s2330 ? s5354 : s5367; + const SBool s5369 = sbv_bv_extract_u8_0_0_u1(s2411); + const SBool s5370 = false != s5369; + const SBool s5371 = sbv_bv_extract_u8_0_0_u1(s2407); + const SBool s5372 = false != s5371; + const SBool s5373 = sbv_bv_extract_u8_0_0_u1(s2400); + const SBool s5374 = false != s5373; + const SWord8 s5375 = s5374 ? s5340 : s5341; + const SWord8 s5376 = sbv_bv_u8_rotr(s5375, 1); + const SWord8 s5377 = 128 | s5376; + const SWord8 s5378 = 127 & s5376; + const SWord8 s5379 = s5372 ? s5377 : s5378; + const SWord8 s5380 = sbv_bv_u8_rotr(s5379, 1); + const SWord8 s5381 = 128 | s5380; + const SWord8 s5382 = 127 & s5380; + const SWord8 s5383 = s5370 ? s5381 : s5382; + const SBool s5384 = sbv_bv_extract_u8_0_0_u1(s2416); + const SBool s5385 = false != s5384; + const SWord8 s5386 = s5385 ? s5381 : s5382; + const SWord8 s5387 = s2352 ? s5383 : s5386; + const SBool s5388 = sbv_bv_extract_u8_0_0_u1(s2432); + const SBool s5389 = false != s5388; + const SBool s5390 = sbv_bv_extract_u8_0_0_u1(s2425); + const SBool s5391 = false != s5390; + const SWord8 s5392 = s5391 ? s5377 : s5378; + const SWord8 s5393 = sbv_bv_u8_rotr(s5392, 1); + const SWord8 s5394 = 128 | s5393; + const SWord8 s5395 = 127 & s5393; + const SWord8 s5396 = s5389 ? s5394 : s5395; + const SBool s5397 = sbv_bv_extract_u8_0_0_u1(s2437); + const SBool s5398 = false != s5397; + const SWord8 s5399 = s5398 ? s5394 : s5395; + const SWord8 s5400 = s2352 ? s5396 : s5399; + const SWord8 s5401 = s2330 ? s5387 : s5400; + const SWord8 s5402 = s2078 ? s5368 : s5401; + const SBool s5403 = sbv_bv_extract_u8_0_0_u1(s2472); + const SBool s5404 = false != s5403; + const SBool s5405 = sbv_bv_extract_u8_0_0_u1(s2468); + const SBool s5406 = false != s5405; + const SBool s5407 = sbv_bv_extract_u8_0_0_u1(s2464); + const SBool s5408 = false != s5407; + const SWord8 s5409 = sbv_bv_u8_rotr(s2451, 1); + const SWord8 s5410 = 128 | s5409; + const SWord8 s5411 = 127 & s5409; + const SWord8 s5412 = s5408 ? s5410 : s5411; + const SWord8 s5413 = sbv_bv_u8_rotr(s5412, 1); + const SWord8 s5414 = 128 | s5413; + const SWord8 s5415 = 127 & s5413; + const SWord8 s5416 = s5406 ? s5414 : s5415; + const SWord8 s5417 = sbv_bv_u8_rotr(s5416, 1); + const SWord8 s5418 = 128 | s5417; + const SWord8 s5419 = 127 & s5417; + const SWord8 s5420 = s5404 ? s5418 : s5419; + const SBool s5421 = sbv_bv_extract_u8_0_0_u1(s2477); + const SBool s5422 = false != s5421; + const SWord8 s5423 = s5422 ? s5418 : s5419; + const SWord8 s5424 = s2457 ? s5420 : s5423; + const SBool s5425 = sbv_bv_extract_u8_0_0_u1(s2493); + const SBool s5426 = false != s5425; + const SBool s5427 = sbv_bv_extract_u8_0_0_u1(s2486); + const SBool s5428 = false != s5427; + const SWord8 s5429 = s5428 ? s5414 : s5415; + const SWord8 s5430 = sbv_bv_u8_rotr(s5429, 1); + const SWord8 s5431 = 128 | s5430; + const SWord8 s5432 = 127 & s5430; + const SWord8 s5433 = s5426 ? s5431 : s5432; + const SBool s5434 = sbv_bv_extract_u8_0_0_u1(s2498); + const SBool s5435 = false != s5434; + const SWord8 s5436 = s5435 ? s5431 : s5432; + const SWord8 s5437 = s2457 ? s5433 : s5436; + const SWord8 s5438 = s2330 ? s5424 : s5437; + const SBool s5439 = sbv_bv_extract_u8_0_0_u1(s2519); + const SBool s5440 = false != s5439; + const SBool s5441 = sbv_bv_extract_u8_0_0_u1(s2515); + const SBool s5442 = false != s5441; + const SBool s5443 = sbv_bv_extract_u8_0_0_u1(s2508); + const SBool s5444 = false != s5443; + const SWord8 s5445 = s5444 ? s5410 : s5411; + const SWord8 s5446 = sbv_bv_u8_rotr(s5445, 1); + const SWord8 s5447 = 128 | s5446; + const SWord8 s5448 = 127 & s5446; + const SWord8 s5449 = s5442 ? s5447 : s5448; + const SWord8 s5450 = sbv_bv_u8_rotr(s5449, 1); + const SWord8 s5451 = 128 | s5450; + const SWord8 s5452 = 127 & s5450; + const SWord8 s5453 = s5440 ? s5451 : s5452; + const SBool s5454 = sbv_bv_extract_u8_0_0_u1(s2524); + const SBool s5455 = false != s5454; + const SWord8 s5456 = s5455 ? s5451 : s5452; + const SWord8 s5457 = s2457 ? s5453 : s5456; + const SBool s5458 = sbv_bv_extract_u8_0_0_u1(s2540); + const SBool s5459 = false != s5458; + const SBool s5460 = sbv_bv_extract_u8_0_0_u1(s2533); + const SBool s5461 = false != s5460; + const SWord8 s5462 = s5461 ? s5447 : s5448; + const SWord8 s5463 = sbv_bv_u8_rotr(s5462, 1); + const SWord8 s5464 = 128 | s5463; + const SWord8 s5465 = 127 & s5463; + const SWord8 s5466 = s5459 ? s5464 : s5465; + const SBool s5467 = sbv_bv_extract_u8_0_0_u1(s2545); + const SBool s5468 = false != s5467; + const SWord8 s5469 = s5468 ? s5464 : s5465; + const SWord8 s5470 = s2457 ? s5466 : s5469; + const SWord8 s5471 = s2330 ? s5457 : s5470; + const SWord8 s5472 = s2078 ? s5438 : s5471; + const SWord8 s5473 = s2059 ? s5402 : s5472; + const SWord8 s5474 = s2042 ? s5332 : s5473; + const SBool s5475 = sbv_bv_extract_u8_0_0_u1(s2620); + const SBool s5476 = false != s5475; + const SBool s5477 = sbv_bv_extract_u8_0_0_u1(s2616); + const SBool s5478 = false != s5477; + const SBool s5479 = sbv_bv_extract_u8_0_0_u1(s2612); + const SBool s5480 = false != s5479; + const SWord8 s5481 = sbv_bv_u8_rotr(s2599, 1); + const SWord8 s5482 = 128 | s5481; + const SWord8 s5483 = 127 & s5481; + const SWord8 s5484 = s5480 ? s5482 : s5483; + const SWord8 s5485 = sbv_bv_u8_rotr(s5484, 1); + const SWord8 s5486 = 128 | s5485; + const SWord8 s5487 = 127 & s5485; + const SWord8 s5488 = s5478 ? s5486 : s5487; + const SWord8 s5489 = sbv_bv_u8_rotr(s5488, 1); + const SWord8 s5490 = 128 | s5489; + const SWord8 s5491 = 127 & s5489; + const SWord8 s5492 = s5476 ? s5490 : s5491; + const SBool s5493 = sbv_bv_extract_u8_0_0_u1(s2625); + const SBool s5494 = false != s5493; + const SWord8 s5495 = s5494 ? s5490 : s5491; + const SWord8 s5496 = s2608 ? s5492 : s5495; + const SBool s5497 = sbv_bv_extract_u8_0_0_u1(s2641); + const SBool s5498 = false != s5497; + const SBool s5499 = sbv_bv_extract_u8_0_0_u1(s2634); + const SBool s5500 = false != s5499; + const SWord8 s5501 = s5500 ? s5486 : s5487; + const SWord8 s5502 = sbv_bv_u8_rotr(s5501, 1); + const SWord8 s5503 = 128 | s5502; + const SWord8 s5504 = 127 & s5502; + const SWord8 s5505 = s5498 ? s5503 : s5504; + const SBool s5506 = sbv_bv_extract_u8_0_0_u1(s2646); + const SBool s5507 = false != s5506; + const SWord8 s5508 = s5507 ? s5503 : s5504; + const SWord8 s5509 = s2608 ? s5505 : s5508; + const SWord8 s5510 = s2589 ? s5496 : s5509; + const SBool s5511 = sbv_bv_extract_u8_0_0_u1(s2667); + const SBool s5512 = false != s5511; + const SBool s5513 = sbv_bv_extract_u8_0_0_u1(s2663); + const SBool s5514 = false != s5513; + const SBool s5515 = sbv_bv_extract_u8_0_0_u1(s2656); + const SBool s5516 = false != s5515; + const SWord8 s5517 = s5516 ? s5482 : s5483; + const SWord8 s5518 = sbv_bv_u8_rotr(s5517, 1); + const SWord8 s5519 = 128 | s5518; + const SWord8 s5520 = 127 & s5518; + const SWord8 s5521 = s5514 ? s5519 : s5520; + const SWord8 s5522 = sbv_bv_u8_rotr(s5521, 1); + const SWord8 s5523 = 128 | s5522; + const SWord8 s5524 = 127 & s5522; + const SWord8 s5525 = s5512 ? s5523 : s5524; + const SBool s5526 = sbv_bv_extract_u8_0_0_u1(s2672); + const SBool s5527 = false != s5526; + const SWord8 s5528 = s5527 ? s5523 : s5524; + const SWord8 s5529 = s2608 ? s5525 : s5528; + const SBool s5530 = sbv_bv_extract_u8_0_0_u1(s2688); + const SBool s5531 = false != s5530; + const SBool s5532 = sbv_bv_extract_u8_0_0_u1(s2681); + const SBool s5533 = false != s5532; + const SWord8 s5534 = s5533 ? s5519 : s5520; + const SWord8 s5535 = sbv_bv_u8_rotr(s5534, 1); + const SWord8 s5536 = 128 | s5535; + const SWord8 s5537 = 127 & s5535; + const SWord8 s5538 = s5531 ? s5536 : s5537; + const SBool s5539 = sbv_bv_extract_u8_0_0_u1(s2693); + const SBool s5540 = false != s5539; + const SWord8 s5541 = s5540 ? s5536 : s5537; + const SWord8 s5542 = s2608 ? s5538 : s5541; + const SWord8 s5543 = s2589 ? s5529 : s5542; + const SWord8 s5544 = s2567 ? s5510 : s5543; + const SBool s5545 = sbv_bv_extract_u8_0_0_u1(s2728); + const SBool s5546 = false != s5545; + const SBool s5547 = sbv_bv_extract_u8_0_0_u1(s2724); + const SBool s5548 = false != s5547; + const SBool s5549 = sbv_bv_extract_u8_0_0_u1(s2720); + const SBool s5550 = false != s5549; + const SWord8 s5551 = sbv_bv_u8_rotr(s2707, 1); + const SWord8 s5552 = 128 | s5551; + const SWord8 s5553 = 127 & s5551; + const SWord8 s5554 = s5550 ? s5552 : s5553; + const SWord8 s5555 = sbv_bv_u8_rotr(s5554, 1); + const SWord8 s5556 = 128 | s5555; + const SWord8 s5557 = 127 & s5555; + const SWord8 s5558 = s5548 ? s5556 : s5557; + const SWord8 s5559 = sbv_bv_u8_rotr(s5558, 1); + const SWord8 s5560 = 128 | s5559; + const SWord8 s5561 = 127 & s5559; + const SWord8 s5562 = s5546 ? s5560 : s5561; + const SBool s5563 = sbv_bv_extract_u8_0_0_u1(s2733); + const SBool s5564 = false != s5563; + const SWord8 s5565 = s5564 ? s5560 : s5561; + const SWord8 s5566 = s2713 ? s5562 : s5565; + const SBool s5567 = sbv_bv_extract_u8_0_0_u1(s2749); + const SBool s5568 = false != s5567; + const SBool s5569 = sbv_bv_extract_u8_0_0_u1(s2742); + const SBool s5570 = false != s5569; + const SWord8 s5571 = s5570 ? s5556 : s5557; + const SWord8 s5572 = sbv_bv_u8_rotr(s5571, 1); + const SWord8 s5573 = 128 | s5572; + const SWord8 s5574 = 127 & s5572; + const SWord8 s5575 = s5568 ? s5573 : s5574; + const SBool s5576 = sbv_bv_extract_u8_0_0_u1(s2754); + const SBool s5577 = false != s5576; + const SWord8 s5578 = s5577 ? s5573 : s5574; + const SWord8 s5579 = s2713 ? s5575 : s5578; + const SWord8 s5580 = s2589 ? s5566 : s5579; + const SBool s5581 = sbv_bv_extract_u8_0_0_u1(s2775); + const SBool s5582 = false != s5581; + const SBool s5583 = sbv_bv_extract_u8_0_0_u1(s2771); + const SBool s5584 = false != s5583; + const SBool s5585 = sbv_bv_extract_u8_0_0_u1(s2764); + const SBool s5586 = false != s5585; + const SWord8 s5587 = s5586 ? s5552 : s5553; + const SWord8 s5588 = sbv_bv_u8_rotr(s5587, 1); + const SWord8 s5589 = 128 | s5588; + const SWord8 s5590 = 127 & s5588; + const SWord8 s5591 = s5584 ? s5589 : s5590; + const SWord8 s5592 = sbv_bv_u8_rotr(s5591, 1); + const SWord8 s5593 = 128 | s5592; + const SWord8 s5594 = 127 & s5592; + const SWord8 s5595 = s5582 ? s5593 : s5594; + const SBool s5596 = sbv_bv_extract_u8_0_0_u1(s2780); + const SBool s5597 = false != s5596; + const SWord8 s5598 = s5597 ? s5593 : s5594; + const SWord8 s5599 = s2713 ? s5595 : s5598; + const SBool s5600 = sbv_bv_extract_u8_0_0_u1(s2796); + const SBool s5601 = false != s5600; + const SBool s5602 = sbv_bv_extract_u8_0_0_u1(s2789); + const SBool s5603 = false != s5602; + const SWord8 s5604 = s5603 ? s5589 : s5590; + const SWord8 s5605 = sbv_bv_u8_rotr(s5604, 1); + const SWord8 s5606 = 128 | s5605; + const SWord8 s5607 = 127 & s5605; + const SWord8 s5608 = s5601 ? s5606 : s5607; + const SBool s5609 = sbv_bv_extract_u8_0_0_u1(s2801); + const SBool s5610 = false != s5609; + const SWord8 s5611 = s5610 ? s5606 : s5607; + const SWord8 s5612 = s2713 ? s5608 : s5611; + const SWord8 s5613 = s2589 ? s5599 : s5612; + const SWord8 s5614 = s2567 ? s5580 : s5613; + const SWord8 s5615 = s2059 ? s5544 : s5614; + const SBool s5616 = sbv_bv_extract_u8_0_0_u1(s2856); + const SBool s5617 = false != s5616; + const SBool s5618 = sbv_bv_extract_u8_0_0_u1(s2852); + const SBool s5619 = false != s5618; + const SBool s5620 = sbv_bv_extract_u8_0_0_u1(s2848); + const SBool s5621 = false != s5620; + const SWord8 s5622 = sbv_bv_u8_rotr(s2835, 1); + const SWord8 s5623 = 128 | s5622; + const SWord8 s5624 = 127 & s5622; + const SWord8 s5625 = s5621 ? s5623 : s5624; + const SWord8 s5626 = sbv_bv_u8_rotr(s5625, 1); + const SWord8 s5627 = 128 | s5626; + const SWord8 s5628 = 127 & s5626; + const SWord8 s5629 = s5619 ? s5627 : s5628; + const SWord8 s5630 = sbv_bv_u8_rotr(s5629, 1); + const SWord8 s5631 = 128 | s5630; + const SWord8 s5632 = 127 & s5630; + const SWord8 s5633 = s5617 ? s5631 : s5632; + const SBool s5634 = sbv_bv_extract_u8_0_0_u1(s2861); + const SBool s5635 = false != s5634; + const SWord8 s5636 = s5635 ? s5631 : s5632; + const SWord8 s5637 = s2844 ? s5633 : s5636; + const SBool s5638 = sbv_bv_extract_u8_0_0_u1(s2877); + const SBool s5639 = false != s5638; + const SBool s5640 = sbv_bv_extract_u8_0_0_u1(s2870); + const SBool s5641 = false != s5640; + const SWord8 s5642 = s5641 ? s5627 : s5628; + const SWord8 s5643 = sbv_bv_u8_rotr(s5642, 1); + const SWord8 s5644 = 128 | s5643; + const SWord8 s5645 = 127 & s5643; + const SWord8 s5646 = s5639 ? s5644 : s5645; + const SBool s5647 = sbv_bv_extract_u8_0_0_u1(s2882); + const SBool s5648 = false != s5647; + const SWord8 s5649 = s5648 ? s5644 : s5645; + const SWord8 s5650 = s2844 ? s5646 : s5649; + const SWord8 s5651 = s2822 ? s5637 : s5650; + const SBool s5652 = sbv_bv_extract_u8_0_0_u1(s2903); + const SBool s5653 = false != s5652; + const SBool s5654 = sbv_bv_extract_u8_0_0_u1(s2899); + const SBool s5655 = false != s5654; + const SBool s5656 = sbv_bv_extract_u8_0_0_u1(s2892); + const SBool s5657 = false != s5656; + const SWord8 s5658 = s5657 ? s5623 : s5624; + const SWord8 s5659 = sbv_bv_u8_rotr(s5658, 1); + const SWord8 s5660 = 128 | s5659; + const SWord8 s5661 = 127 & s5659; + const SWord8 s5662 = s5655 ? s5660 : s5661; + const SWord8 s5663 = sbv_bv_u8_rotr(s5662, 1); + const SWord8 s5664 = 128 | s5663; + const SWord8 s5665 = 127 & s5663; + const SWord8 s5666 = s5653 ? s5664 : s5665; + const SBool s5667 = sbv_bv_extract_u8_0_0_u1(s2908); + const SBool s5668 = false != s5667; + const SWord8 s5669 = s5668 ? s5664 : s5665; + const SWord8 s5670 = s2844 ? s5666 : s5669; + const SBool s5671 = sbv_bv_extract_u8_0_0_u1(s2924); + const SBool s5672 = false != s5671; + const SBool s5673 = sbv_bv_extract_u8_0_0_u1(s2917); + const SBool s5674 = false != s5673; + const SWord8 s5675 = s5674 ? s5660 : s5661; + const SWord8 s5676 = sbv_bv_u8_rotr(s5675, 1); + const SWord8 s5677 = 128 | s5676; + const SWord8 s5678 = 127 & s5676; + const SWord8 s5679 = s5672 ? s5677 : s5678; + const SBool s5680 = sbv_bv_extract_u8_0_0_u1(s2929); + const SBool s5681 = false != s5680; + const SWord8 s5682 = s5681 ? s5677 : s5678; + const SWord8 s5683 = s2844 ? s5679 : s5682; + const SWord8 s5684 = s2822 ? s5670 : s5683; + const SWord8 s5685 = s2567 ? s5651 : s5684; + const SBool s5686 = sbv_bv_extract_u8_0_0_u1(s2964); + const SBool s5687 = false != s5686; + const SBool s5688 = sbv_bv_extract_u8_0_0_u1(s2960); + const SBool s5689 = false != s5688; + const SBool s5690 = sbv_bv_extract_u8_0_0_u1(s2956); + const SBool s5691 = false != s5690; + const SWord8 s5692 = sbv_bv_u8_rotr(s2943, 1); + const SWord8 s5693 = 128 | s5692; + const SWord8 s5694 = 127 & s5692; + const SWord8 s5695 = s5691 ? s5693 : s5694; + const SWord8 s5696 = sbv_bv_u8_rotr(s5695, 1); + const SWord8 s5697 = 128 | s5696; + const SWord8 s5698 = 127 & s5696; + const SWord8 s5699 = s5689 ? s5697 : s5698; + const SWord8 s5700 = sbv_bv_u8_rotr(s5699, 1); + const SWord8 s5701 = 128 | s5700; + const SWord8 s5702 = 127 & s5700; + const SWord8 s5703 = s5687 ? s5701 : s5702; + const SBool s5704 = sbv_bv_extract_u8_0_0_u1(s2969); + const SBool s5705 = false != s5704; + const SWord8 s5706 = s5705 ? s5701 : s5702; + const SWord8 s5707 = s2949 ? s5703 : s5706; + const SBool s5708 = sbv_bv_extract_u8_0_0_u1(s2985); + const SBool s5709 = false != s5708; + const SBool s5710 = sbv_bv_extract_u8_0_0_u1(s2978); + const SBool s5711 = false != s5710; + const SWord8 s5712 = s5711 ? s5697 : s5698; + const SWord8 s5713 = sbv_bv_u8_rotr(s5712, 1); + const SWord8 s5714 = 128 | s5713; + const SWord8 s5715 = 127 & s5713; + const SWord8 s5716 = s5709 ? s5714 : s5715; + const SBool s5717 = sbv_bv_extract_u8_0_0_u1(s2990); + const SBool s5718 = false != s5717; + const SWord8 s5719 = s5718 ? s5714 : s5715; + const SWord8 s5720 = s2949 ? s5716 : s5719; + const SWord8 s5721 = s2822 ? s5707 : s5720; + const SBool s5722 = sbv_bv_extract_u8_0_0_u1(s3011); + const SBool s5723 = false != s5722; + const SBool s5724 = sbv_bv_extract_u8_0_0_u1(s3007); + const SBool s5725 = false != s5724; + const SBool s5726 = sbv_bv_extract_u8_0_0_u1(s3000); + const SBool s5727 = false != s5726; + const SWord8 s5728 = s5727 ? s5693 : s5694; + const SWord8 s5729 = sbv_bv_u8_rotr(s5728, 1); + const SWord8 s5730 = 128 | s5729; + const SWord8 s5731 = 127 & s5729; + const SWord8 s5732 = s5725 ? s5730 : s5731; + const SWord8 s5733 = sbv_bv_u8_rotr(s5732, 1); + const SWord8 s5734 = 128 | s5733; + const SWord8 s5735 = 127 & s5733; + const SWord8 s5736 = s5723 ? s5734 : s5735; + const SBool s5737 = sbv_bv_extract_u8_0_0_u1(s3016); + const SBool s5738 = false != s5737; + const SWord8 s5739 = s5738 ? s5734 : s5735; + const SWord8 s5740 = s2949 ? s5736 : s5739; + const SBool s5741 = sbv_bv_extract_u8_0_0_u1(s3032); + const SBool s5742 = false != s5741; + const SBool s5743 = sbv_bv_extract_u8_0_0_u1(s3025); + const SBool s5744 = false != s5743; + const SWord8 s5745 = s5744 ? s5730 : s5731; + const SWord8 s5746 = sbv_bv_u8_rotr(s5745, 1); + const SWord8 s5747 = 128 | s5746; + const SWord8 s5748 = 127 & s5746; + const SWord8 s5749 = s5742 ? s5747 : s5748; + const SBool s5750 = sbv_bv_extract_u8_0_0_u1(s3037); + const SBool s5751 = false != s5750; + const SWord8 s5752 = s5751 ? s5747 : s5748; + const SWord8 s5753 = s2949 ? s5749 : s5752; + const SWord8 s5754 = s2822 ? s5740 : s5753; + const SWord8 s5755 = s2567 ? s5721 : s5754; + const SWord8 s5756 = s2059 ? s5685 : s5755; + const SWord8 s5757 = s2042 ? s5615 : s5756; + const SWord8 s5758 = s16 ? s5474 : s5757; + const SBool s5759 = sbv_bv_extract_u8_0_0_u1(s3132); + const SBool s5760 = false != s5759; + const SBool s5761 = sbv_bv_extract_u8_0_0_u1(s3128); + const SBool s5762 = false != s5761; + const SBool s5763 = sbv_bv_extract_u8_0_0_u1(s3124); + const SBool s5764 = false != s5763; + const SWord8 s5765 = sbv_bv_u8_rotr(s3111, 1); + const SWord8 s5766 = 128 | s5765; + const SWord8 s5767 = 127 & s5765; + const SWord8 s5768 = s5764 ? s5766 : s5767; + const SWord8 s5769 = sbv_bv_u8_rotr(s5768, 1); + const SWord8 s5770 = 128 | s5769; + const SWord8 s5771 = 127 & s5769; + const SWord8 s5772 = s5762 ? s5770 : s5771; + const SWord8 s5773 = sbv_bv_u8_rotr(s5772, 1); + const SWord8 s5774 = 128 | s5773; + const SWord8 s5775 = 127 & s5773; + const SWord8 s5776 = s5760 ? s5774 : s5775; + const SBool s5777 = sbv_bv_extract_u8_0_0_u1(s3137); + const SBool s5778 = false != s5777; + const SWord8 s5779 = s5778 ? s5774 : s5775; + const SWord8 s5780 = s3120 ? s5776 : s5779; + const SBool s5781 = sbv_bv_extract_u8_0_0_u1(s3153); + const SBool s5782 = false != s5781; + const SBool s5783 = sbv_bv_extract_u8_0_0_u1(s3146); + const SBool s5784 = false != s5783; + const SWord8 s5785 = s5784 ? s5770 : s5771; + const SWord8 s5786 = sbv_bv_u8_rotr(s5785, 1); + const SWord8 s5787 = 128 | s5786; + const SWord8 s5788 = 127 & s5786; + const SWord8 s5789 = s5782 ? s5787 : s5788; + const SBool s5790 = sbv_bv_extract_u8_0_0_u1(s3158); + const SBool s5791 = false != s5790; + const SWord8 s5792 = s5791 ? s5787 : s5788; + const SWord8 s5793 = s3120 ? s5789 : s5792; + const SWord8 s5794 = s3101 ? s5780 : s5793; + const SBool s5795 = sbv_bv_extract_u8_0_0_u1(s3179); + const SBool s5796 = false != s5795; + const SBool s5797 = sbv_bv_extract_u8_0_0_u1(s3175); + const SBool s5798 = false != s5797; + const SBool s5799 = sbv_bv_extract_u8_0_0_u1(s3168); + const SBool s5800 = false != s5799; + const SWord8 s5801 = s5800 ? s5766 : s5767; + const SWord8 s5802 = sbv_bv_u8_rotr(s5801, 1); + const SWord8 s5803 = 128 | s5802; + const SWord8 s5804 = 127 & s5802; + const SWord8 s5805 = s5798 ? s5803 : s5804; + const SWord8 s5806 = sbv_bv_u8_rotr(s5805, 1); + const SWord8 s5807 = 128 | s5806; + const SWord8 s5808 = 127 & s5806; + const SWord8 s5809 = s5796 ? s5807 : s5808; + const SBool s5810 = sbv_bv_extract_u8_0_0_u1(s3184); + const SBool s5811 = false != s5810; + const SWord8 s5812 = s5811 ? s5807 : s5808; + const SWord8 s5813 = s3120 ? s5809 : s5812; + const SBool s5814 = sbv_bv_extract_u8_0_0_u1(s3200); + const SBool s5815 = false != s5814; + const SBool s5816 = sbv_bv_extract_u8_0_0_u1(s3193); + const SBool s5817 = false != s5816; + const SWord8 s5818 = s5817 ? s5803 : s5804; + const SWord8 s5819 = sbv_bv_u8_rotr(s5818, 1); + const SWord8 s5820 = 128 | s5819; + const SWord8 s5821 = 127 & s5819; + const SWord8 s5822 = s5815 ? s5820 : s5821; + const SBool s5823 = sbv_bv_extract_u8_0_0_u1(s3205); + const SBool s5824 = false != s5823; + const SWord8 s5825 = s5824 ? s5820 : s5821; + const SWord8 s5826 = s3120 ? s5822 : s5825; + const SWord8 s5827 = s3101 ? s5813 : s5826; + const SWord8 s5828 = s3082 ? s5794 : s5827; + const SBool s5829 = sbv_bv_extract_u8_0_0_u1(s3240); + const SBool s5830 = false != s5829; + const SBool s5831 = sbv_bv_extract_u8_0_0_u1(s3236); + const SBool s5832 = false != s5831; + const SBool s5833 = sbv_bv_extract_u8_0_0_u1(s3232); + const SBool s5834 = false != s5833; + const SWord8 s5835 = sbv_bv_u8_rotr(s3219, 1); + const SWord8 s5836 = 128 | s5835; + const SWord8 s5837 = 127 & s5835; + const SWord8 s5838 = s5834 ? s5836 : s5837; + const SWord8 s5839 = sbv_bv_u8_rotr(s5838, 1); + const SWord8 s5840 = 128 | s5839; + const SWord8 s5841 = 127 & s5839; + const SWord8 s5842 = s5832 ? s5840 : s5841; + const SWord8 s5843 = sbv_bv_u8_rotr(s5842, 1); + const SWord8 s5844 = 128 | s5843; + const SWord8 s5845 = 127 & s5843; + const SWord8 s5846 = s5830 ? s5844 : s5845; + const SBool s5847 = sbv_bv_extract_u8_0_0_u1(s3245); + const SBool s5848 = false != s5847; + const SWord8 s5849 = s5848 ? s5844 : s5845; + const SWord8 s5850 = s3225 ? s5846 : s5849; + const SBool s5851 = sbv_bv_extract_u8_0_0_u1(s3261); + const SBool s5852 = false != s5851; + const SBool s5853 = sbv_bv_extract_u8_0_0_u1(s3254); + const SBool s5854 = false != s5853; + const SWord8 s5855 = s5854 ? s5840 : s5841; + const SWord8 s5856 = sbv_bv_u8_rotr(s5855, 1); + const SWord8 s5857 = 128 | s5856; + const SWord8 s5858 = 127 & s5856; + const SWord8 s5859 = s5852 ? s5857 : s5858; + const SBool s5860 = sbv_bv_extract_u8_0_0_u1(s3266); + const SBool s5861 = false != s5860; + const SWord8 s5862 = s5861 ? s5857 : s5858; + const SWord8 s5863 = s3225 ? s5859 : s5862; + const SWord8 s5864 = s3101 ? s5850 : s5863; + const SBool s5865 = sbv_bv_extract_u8_0_0_u1(s3287); + const SBool s5866 = false != s5865; + const SBool s5867 = sbv_bv_extract_u8_0_0_u1(s3283); + const SBool s5868 = false != s5867; + const SBool s5869 = sbv_bv_extract_u8_0_0_u1(s3276); + const SBool s5870 = false != s5869; + const SWord8 s5871 = s5870 ? s5836 : s5837; + const SWord8 s5872 = sbv_bv_u8_rotr(s5871, 1); + const SWord8 s5873 = 128 | s5872; + const SWord8 s5874 = 127 & s5872; + const SWord8 s5875 = s5868 ? s5873 : s5874; + const SWord8 s5876 = sbv_bv_u8_rotr(s5875, 1); + const SWord8 s5877 = 128 | s5876; + const SWord8 s5878 = 127 & s5876; + const SWord8 s5879 = s5866 ? s5877 : s5878; + const SBool s5880 = sbv_bv_extract_u8_0_0_u1(s3292); + const SBool s5881 = false != s5880; + const SWord8 s5882 = s5881 ? s5877 : s5878; + const SWord8 s5883 = s3225 ? s5879 : s5882; + const SBool s5884 = sbv_bv_extract_u8_0_0_u1(s3308); + const SBool s5885 = false != s5884; + const SBool s5886 = sbv_bv_extract_u8_0_0_u1(s3301); + const SBool s5887 = false != s5886; + const SWord8 s5888 = s5887 ? s5873 : s5874; + const SWord8 s5889 = sbv_bv_u8_rotr(s5888, 1); + const SWord8 s5890 = 128 | s5889; + const SWord8 s5891 = 127 & s5889; + const SWord8 s5892 = s5885 ? s5890 : s5891; + const SBool s5893 = sbv_bv_extract_u8_0_0_u1(s3313); + const SBool s5894 = false != s5893; + const SWord8 s5895 = s5894 ? s5890 : s5891; + const SWord8 s5896 = s3225 ? s5892 : s5895; + const SWord8 s5897 = s3101 ? s5883 : s5896; + const SWord8 s5898 = s3082 ? s5864 : s5897; + const SWord8 s5899 = s3060 ? s5828 : s5898; + const SBool s5900 = sbv_bv_extract_u8_0_0_u1(s3368); + const SBool s5901 = false != s5900; + const SBool s5902 = sbv_bv_extract_u8_0_0_u1(s3364); + const SBool s5903 = false != s5902; + const SBool s5904 = sbv_bv_extract_u8_0_0_u1(s3360); + const SBool s5905 = false != s5904; + const SWord8 s5906 = sbv_bv_u8_rotr(s3347, 1); + const SWord8 s5907 = 128 | s5906; + const SWord8 s5908 = 127 & s5906; + const SWord8 s5909 = s5905 ? s5907 : s5908; + const SWord8 s5910 = sbv_bv_u8_rotr(s5909, 1); + const SWord8 s5911 = 128 | s5910; + const SWord8 s5912 = 127 & s5910; + const SWord8 s5913 = s5903 ? s5911 : s5912; + const SWord8 s5914 = sbv_bv_u8_rotr(s5913, 1); + const SWord8 s5915 = 128 | s5914; + const SWord8 s5916 = 127 & s5914; + const SWord8 s5917 = s5901 ? s5915 : s5916; + const SBool s5918 = sbv_bv_extract_u8_0_0_u1(s3373); + const SBool s5919 = false != s5918; + const SWord8 s5920 = s5919 ? s5915 : s5916; + const SWord8 s5921 = s3356 ? s5917 : s5920; + const SBool s5922 = sbv_bv_extract_u8_0_0_u1(s3389); + const SBool s5923 = false != s5922; + const SBool s5924 = sbv_bv_extract_u8_0_0_u1(s3382); + const SBool s5925 = false != s5924; + const SWord8 s5926 = s5925 ? s5911 : s5912; + const SWord8 s5927 = sbv_bv_u8_rotr(s5926, 1); + const SWord8 s5928 = 128 | s5927; + const SWord8 s5929 = 127 & s5927; + const SWord8 s5930 = s5923 ? s5928 : s5929; + const SBool s5931 = sbv_bv_extract_u8_0_0_u1(s3394); + const SBool s5932 = false != s5931; + const SWord8 s5933 = s5932 ? s5928 : s5929; + const SWord8 s5934 = s3356 ? s5930 : s5933; + const SWord8 s5935 = s3334 ? s5921 : s5934; + const SBool s5936 = sbv_bv_extract_u8_0_0_u1(s3415); + const SBool s5937 = false != s5936; + const SBool s5938 = sbv_bv_extract_u8_0_0_u1(s3411); + const SBool s5939 = false != s5938; + const SBool s5940 = sbv_bv_extract_u8_0_0_u1(s3404); + const SBool s5941 = false != s5940; + const SWord8 s5942 = s5941 ? s5907 : s5908; + const SWord8 s5943 = sbv_bv_u8_rotr(s5942, 1); + const SWord8 s5944 = 128 | s5943; + const SWord8 s5945 = 127 & s5943; + const SWord8 s5946 = s5939 ? s5944 : s5945; + const SWord8 s5947 = sbv_bv_u8_rotr(s5946, 1); + const SWord8 s5948 = 128 | s5947; + const SWord8 s5949 = 127 & s5947; + const SWord8 s5950 = s5937 ? s5948 : s5949; + const SBool s5951 = sbv_bv_extract_u8_0_0_u1(s3420); + const SBool s5952 = false != s5951; + const SWord8 s5953 = s5952 ? s5948 : s5949; + const SWord8 s5954 = s3356 ? s5950 : s5953; + const SBool s5955 = sbv_bv_extract_u8_0_0_u1(s3436); + const SBool s5956 = false != s5955; + const SBool s5957 = sbv_bv_extract_u8_0_0_u1(s3429); + const SBool s5958 = false != s5957; + const SWord8 s5959 = s5958 ? s5944 : s5945; + const SWord8 s5960 = sbv_bv_u8_rotr(s5959, 1); + const SWord8 s5961 = 128 | s5960; + const SWord8 s5962 = 127 & s5960; + const SWord8 s5963 = s5956 ? s5961 : s5962; + const SBool s5964 = sbv_bv_extract_u8_0_0_u1(s3441); + const SBool s5965 = false != s5964; + const SWord8 s5966 = s5965 ? s5961 : s5962; + const SWord8 s5967 = s3356 ? s5963 : s5966; + const SWord8 s5968 = s3334 ? s5954 : s5967; + const SWord8 s5969 = s3082 ? s5935 : s5968; + const SBool s5970 = sbv_bv_extract_u8_0_0_u1(s3476); + const SBool s5971 = false != s5970; + const SBool s5972 = sbv_bv_extract_u8_0_0_u1(s3472); + const SBool s5973 = false != s5972; + const SBool s5974 = sbv_bv_extract_u8_0_0_u1(s3468); + const SBool s5975 = false != s5974; + const SWord8 s5976 = sbv_bv_u8_rotr(s3455, 1); + const SWord8 s5977 = 128 | s5976; + const SWord8 s5978 = 127 & s5976; + const SWord8 s5979 = s5975 ? s5977 : s5978; + const SWord8 s5980 = sbv_bv_u8_rotr(s5979, 1); + const SWord8 s5981 = 128 | s5980; + const SWord8 s5982 = 127 & s5980; + const SWord8 s5983 = s5973 ? s5981 : s5982; + const SWord8 s5984 = sbv_bv_u8_rotr(s5983, 1); + const SWord8 s5985 = 128 | s5984; + const SWord8 s5986 = 127 & s5984; + const SWord8 s5987 = s5971 ? s5985 : s5986; + const SBool s5988 = sbv_bv_extract_u8_0_0_u1(s3481); + const SBool s5989 = false != s5988; + const SWord8 s5990 = s5989 ? s5985 : s5986; + const SWord8 s5991 = s3461 ? s5987 : s5990; + const SBool s5992 = sbv_bv_extract_u8_0_0_u1(s3497); + const SBool s5993 = false != s5992; + const SBool s5994 = sbv_bv_extract_u8_0_0_u1(s3490); + const SBool s5995 = false != s5994; + const SWord8 s5996 = s5995 ? s5981 : s5982; + const SWord8 s5997 = sbv_bv_u8_rotr(s5996, 1); + const SWord8 s5998 = 128 | s5997; + const SWord8 s5999 = 127 & s5997; + const SWord8 s6000 = s5993 ? s5998 : s5999; + const SBool s6001 = sbv_bv_extract_u8_0_0_u1(s3502); + const SBool s6002 = false != s6001; + const SWord8 s6003 = s6002 ? s5998 : s5999; + const SWord8 s6004 = s3461 ? s6000 : s6003; + const SWord8 s6005 = s3334 ? s5991 : s6004; + const SBool s6006 = sbv_bv_extract_u8_0_0_u1(s3523); + const SBool s6007 = false != s6006; + const SBool s6008 = sbv_bv_extract_u8_0_0_u1(s3519); + const SBool s6009 = false != s6008; + const SBool s6010 = sbv_bv_extract_u8_0_0_u1(s3512); + const SBool s6011 = false != s6010; + const SWord8 s6012 = s6011 ? s5977 : s5978; + const SWord8 s6013 = sbv_bv_u8_rotr(s6012, 1); + const SWord8 s6014 = 128 | s6013; + const SWord8 s6015 = 127 & s6013; + const SWord8 s6016 = s6009 ? s6014 : s6015; + const SWord8 s6017 = sbv_bv_u8_rotr(s6016, 1); + const SWord8 s6018 = 128 | s6017; + const SWord8 s6019 = 127 & s6017; + const SWord8 s6020 = s6007 ? s6018 : s6019; + const SBool s6021 = sbv_bv_extract_u8_0_0_u1(s3528); + const SBool s6022 = false != s6021; + const SWord8 s6023 = s6022 ? s6018 : s6019; + const SWord8 s6024 = s3461 ? s6020 : s6023; + const SBool s6025 = sbv_bv_extract_u8_0_0_u1(s3544); + const SBool s6026 = false != s6025; + const SBool s6027 = sbv_bv_extract_u8_0_0_u1(s3537); + const SBool s6028 = false != s6027; + const SWord8 s6029 = s6028 ? s6014 : s6015; + const SWord8 s6030 = sbv_bv_u8_rotr(s6029, 1); + const SWord8 s6031 = 128 | s6030; + const SWord8 s6032 = 127 & s6030; + const SWord8 s6033 = s6026 ? s6031 : s6032; + const SBool s6034 = sbv_bv_extract_u8_0_0_u1(s3549); + const SBool s6035 = false != s6034; + const SWord8 s6036 = s6035 ? s6031 : s6032; + const SWord8 s6037 = s3461 ? s6033 : s6036; + const SWord8 s6038 = s3334 ? s6024 : s6037; + const SWord8 s6039 = s3082 ? s6005 : s6038; + const SWord8 s6040 = s3060 ? s5969 : s6039; + const SWord8 s6041 = s2042 ? s5899 : s6040; + const SBool s6042 = sbv_bv_extract_u8_0_0_u1(s3624); + const SBool s6043 = false != s6042; + const SBool s6044 = sbv_bv_extract_u8_0_0_u1(s3620); + const SBool s6045 = false != s6044; + const SBool s6046 = sbv_bv_extract_u8_0_0_u1(s3616); + const SBool s6047 = false != s6046; + const SWord8 s6048 = sbv_bv_u8_rotr(s3603, 1); + const SWord8 s6049 = 128 | s6048; + const SWord8 s6050 = 127 & s6048; + const SWord8 s6051 = s6047 ? s6049 : s6050; + const SWord8 s6052 = sbv_bv_u8_rotr(s6051, 1); + const SWord8 s6053 = 128 | s6052; + const SWord8 s6054 = 127 & s6052; + const SWord8 s6055 = s6045 ? s6053 : s6054; + const SWord8 s6056 = sbv_bv_u8_rotr(s6055, 1); + const SWord8 s6057 = 128 | s6056; + const SWord8 s6058 = 127 & s6056; + const SWord8 s6059 = s6043 ? s6057 : s6058; + const SBool s6060 = sbv_bv_extract_u8_0_0_u1(s3629); + const SBool s6061 = false != s6060; + const SWord8 s6062 = s6061 ? s6057 : s6058; + const SWord8 s6063 = s3612 ? s6059 : s6062; + const SBool s6064 = sbv_bv_extract_u8_0_0_u1(s3645); + const SBool s6065 = false != s6064; + const SBool s6066 = sbv_bv_extract_u8_0_0_u1(s3638); + const SBool s6067 = false != s6066; + const SWord8 s6068 = s6067 ? s6053 : s6054; + const SWord8 s6069 = sbv_bv_u8_rotr(s6068, 1); + const SWord8 s6070 = 128 | s6069; + const SWord8 s6071 = 127 & s6069; + const SWord8 s6072 = s6065 ? s6070 : s6071; + const SBool s6073 = sbv_bv_extract_u8_0_0_u1(s3650); + const SBool s6074 = false != s6073; + const SWord8 s6075 = s6074 ? s6070 : s6071; + const SWord8 s6076 = s3612 ? s6072 : s6075; + const SWord8 s6077 = s3593 ? s6063 : s6076; + const SBool s6078 = sbv_bv_extract_u8_0_0_u1(s3671); + const SBool s6079 = false != s6078; + const SBool s6080 = sbv_bv_extract_u8_0_0_u1(s3667); + const SBool s6081 = false != s6080; + const SBool s6082 = sbv_bv_extract_u8_0_0_u1(s3660); + const SBool s6083 = false != s6082; + const SWord8 s6084 = s6083 ? s6049 : s6050; + const SWord8 s6085 = sbv_bv_u8_rotr(s6084, 1); + const SWord8 s6086 = 128 | s6085; + const SWord8 s6087 = 127 & s6085; + const SWord8 s6088 = s6081 ? s6086 : s6087; + const SWord8 s6089 = sbv_bv_u8_rotr(s6088, 1); + const SWord8 s6090 = 128 | s6089; + const SWord8 s6091 = 127 & s6089; + const SWord8 s6092 = s6079 ? s6090 : s6091; + const SBool s6093 = sbv_bv_extract_u8_0_0_u1(s3676); + const SBool s6094 = false != s6093; + const SWord8 s6095 = s6094 ? s6090 : s6091; + const SWord8 s6096 = s3612 ? s6092 : s6095; + const SBool s6097 = sbv_bv_extract_u8_0_0_u1(s3692); + const SBool s6098 = false != s6097; + const SBool s6099 = sbv_bv_extract_u8_0_0_u1(s3685); + const SBool s6100 = false != s6099; + const SWord8 s6101 = s6100 ? s6086 : s6087; + const SWord8 s6102 = sbv_bv_u8_rotr(s6101, 1); + const SWord8 s6103 = 128 | s6102; + const SWord8 s6104 = 127 & s6102; + const SWord8 s6105 = s6098 ? s6103 : s6104; + const SBool s6106 = sbv_bv_extract_u8_0_0_u1(s3697); + const SBool s6107 = false != s6106; + const SWord8 s6108 = s6107 ? s6103 : s6104; + const SWord8 s6109 = s3612 ? s6105 : s6108; + const SWord8 s6110 = s3593 ? s6096 : s6109; + const SWord8 s6111 = s3571 ? s6077 : s6110; + const SBool s6112 = sbv_bv_extract_u8_0_0_u1(s3732); + const SBool s6113 = false != s6112; + const SBool s6114 = sbv_bv_extract_u8_0_0_u1(s3728); + const SBool s6115 = false != s6114; + const SBool s6116 = sbv_bv_extract_u8_0_0_u1(s3724); + const SBool s6117 = false != s6116; + const SWord8 s6118 = sbv_bv_u8_rotr(s3711, 1); + const SWord8 s6119 = 128 | s6118; + const SWord8 s6120 = 127 & s6118; + const SWord8 s6121 = s6117 ? s6119 : s6120; + const SWord8 s6122 = sbv_bv_u8_rotr(s6121, 1); + const SWord8 s6123 = 128 | s6122; + const SWord8 s6124 = 127 & s6122; + const SWord8 s6125 = s6115 ? s6123 : s6124; + const SWord8 s6126 = sbv_bv_u8_rotr(s6125, 1); + const SWord8 s6127 = 128 | s6126; + const SWord8 s6128 = 127 & s6126; + const SWord8 s6129 = s6113 ? s6127 : s6128; + const SBool s6130 = sbv_bv_extract_u8_0_0_u1(s3737); + const SBool s6131 = false != s6130; + const SWord8 s6132 = s6131 ? s6127 : s6128; + const SWord8 s6133 = s3717 ? s6129 : s6132; + const SBool s6134 = sbv_bv_extract_u8_0_0_u1(s3753); + const SBool s6135 = false != s6134; + const SBool s6136 = sbv_bv_extract_u8_0_0_u1(s3746); + const SBool s6137 = false != s6136; + const SWord8 s6138 = s6137 ? s6123 : s6124; + const SWord8 s6139 = sbv_bv_u8_rotr(s6138, 1); + const SWord8 s6140 = 128 | s6139; + const SWord8 s6141 = 127 & s6139; + const SWord8 s6142 = s6135 ? s6140 : s6141; + const SBool s6143 = sbv_bv_extract_u8_0_0_u1(s3758); + const SBool s6144 = false != s6143; + const SWord8 s6145 = s6144 ? s6140 : s6141; + const SWord8 s6146 = s3717 ? s6142 : s6145; + const SWord8 s6147 = s3593 ? s6133 : s6146; + const SBool s6148 = sbv_bv_extract_u8_0_0_u1(s3779); + const SBool s6149 = false != s6148; + const SBool s6150 = sbv_bv_extract_u8_0_0_u1(s3775); + const SBool s6151 = false != s6150; + const SBool s6152 = sbv_bv_extract_u8_0_0_u1(s3768); + const SBool s6153 = false != s6152; + const SWord8 s6154 = s6153 ? s6119 : s6120; + const SWord8 s6155 = sbv_bv_u8_rotr(s6154, 1); + const SWord8 s6156 = 128 | s6155; + const SWord8 s6157 = 127 & s6155; + const SWord8 s6158 = s6151 ? s6156 : s6157; + const SWord8 s6159 = sbv_bv_u8_rotr(s6158, 1); + const SWord8 s6160 = 128 | s6159; + const SWord8 s6161 = 127 & s6159; + const SWord8 s6162 = s6149 ? s6160 : s6161; + const SBool s6163 = sbv_bv_extract_u8_0_0_u1(s3784); + const SBool s6164 = false != s6163; + const SWord8 s6165 = s6164 ? s6160 : s6161; + const SWord8 s6166 = s3717 ? s6162 : s6165; + const SBool s6167 = sbv_bv_extract_u8_0_0_u1(s3800); + const SBool s6168 = false != s6167; + const SBool s6169 = sbv_bv_extract_u8_0_0_u1(s3793); + const SBool s6170 = false != s6169; + const SWord8 s6171 = s6170 ? s6156 : s6157; + const SWord8 s6172 = sbv_bv_u8_rotr(s6171, 1); + const SWord8 s6173 = 128 | s6172; + const SWord8 s6174 = 127 & s6172; + const SWord8 s6175 = s6168 ? s6173 : s6174; + const SBool s6176 = sbv_bv_extract_u8_0_0_u1(s3805); + const SBool s6177 = false != s6176; + const SWord8 s6178 = s6177 ? s6173 : s6174; + const SWord8 s6179 = s3717 ? s6175 : s6178; + const SWord8 s6180 = s3593 ? s6166 : s6179; + const SWord8 s6181 = s3571 ? s6147 : s6180; + const SWord8 s6182 = s3060 ? s6111 : s6181; + const SBool s6183 = sbv_bv_extract_u8_0_0_u1(s3860); + const SBool s6184 = false != s6183; + const SBool s6185 = sbv_bv_extract_u8_0_0_u1(s3856); + const SBool s6186 = false != s6185; + const SBool s6187 = sbv_bv_extract_u8_0_0_u1(s3852); + const SBool s6188 = false != s6187; + const SWord8 s6189 = sbv_bv_u8_rotr(s3839, 1); + const SWord8 s6190 = 128 | s6189; + const SWord8 s6191 = 127 & s6189; + const SWord8 s6192 = s6188 ? s6190 : s6191; + const SWord8 s6193 = sbv_bv_u8_rotr(s6192, 1); + const SWord8 s6194 = 128 | s6193; + const SWord8 s6195 = 127 & s6193; + const SWord8 s6196 = s6186 ? s6194 : s6195; + const SWord8 s6197 = sbv_bv_u8_rotr(s6196, 1); + const SWord8 s6198 = 128 | s6197; + const SWord8 s6199 = 127 & s6197; + const SWord8 s6200 = s6184 ? s6198 : s6199; + const SBool s6201 = sbv_bv_extract_u8_0_0_u1(s3865); + const SBool s6202 = false != s6201; + const SWord8 s6203 = s6202 ? s6198 : s6199; + const SWord8 s6204 = s3848 ? s6200 : s6203; + const SBool s6205 = sbv_bv_extract_u8_0_0_u1(s3881); + const SBool s6206 = false != s6205; + const SBool s6207 = sbv_bv_extract_u8_0_0_u1(s3874); + const SBool s6208 = false != s6207; + const SWord8 s6209 = s6208 ? s6194 : s6195; + const SWord8 s6210 = sbv_bv_u8_rotr(s6209, 1); + const SWord8 s6211 = 128 | s6210; + const SWord8 s6212 = 127 & s6210; + const SWord8 s6213 = s6206 ? s6211 : s6212; + const SBool s6214 = sbv_bv_extract_u8_0_0_u1(s3886); + const SBool s6215 = false != s6214; + const SWord8 s6216 = s6215 ? s6211 : s6212; + const SWord8 s6217 = s3848 ? s6213 : s6216; + const SWord8 s6218 = s3826 ? s6204 : s6217; + const SBool s6219 = sbv_bv_extract_u8_0_0_u1(s3907); + const SBool s6220 = false != s6219; + const SBool s6221 = sbv_bv_extract_u8_0_0_u1(s3903); + const SBool s6222 = false != s6221; + const SBool s6223 = sbv_bv_extract_u8_0_0_u1(s3896); + const SBool s6224 = false != s6223; + const SWord8 s6225 = s6224 ? s6190 : s6191; + const SWord8 s6226 = sbv_bv_u8_rotr(s6225, 1); + const SWord8 s6227 = 128 | s6226; + const SWord8 s6228 = 127 & s6226; + const SWord8 s6229 = s6222 ? s6227 : s6228; + const SWord8 s6230 = sbv_bv_u8_rotr(s6229, 1); + const SWord8 s6231 = 128 | s6230; + const SWord8 s6232 = 127 & s6230; + const SWord8 s6233 = s6220 ? s6231 : s6232; + const SBool s6234 = sbv_bv_extract_u8_0_0_u1(s3912); + const SBool s6235 = false != s6234; + const SWord8 s6236 = s6235 ? s6231 : s6232; + const SWord8 s6237 = s3848 ? s6233 : s6236; + const SBool s6238 = sbv_bv_extract_u8_0_0_u1(s3928); + const SBool s6239 = false != s6238; + const SBool s6240 = sbv_bv_extract_u8_0_0_u1(s3921); + const SBool s6241 = false != s6240; + const SWord8 s6242 = s6241 ? s6227 : s6228; + const SWord8 s6243 = sbv_bv_u8_rotr(s6242, 1); + const SWord8 s6244 = 128 | s6243; + const SWord8 s6245 = 127 & s6243; + const SWord8 s6246 = s6239 ? s6244 : s6245; + const SBool s6247 = sbv_bv_extract_u8_0_0_u1(s3933); + const SBool s6248 = false != s6247; + const SWord8 s6249 = s6248 ? s6244 : s6245; + const SWord8 s6250 = s3848 ? s6246 : s6249; + const SWord8 s6251 = s3826 ? s6237 : s6250; + const SWord8 s6252 = s3571 ? s6218 : s6251; + const SBool s6253 = sbv_bv_extract_u8_0_0_u1(s3968); + const SBool s6254 = false != s6253; + const SBool s6255 = sbv_bv_extract_u8_0_0_u1(s3964); + const SBool s6256 = false != s6255; + const SBool s6257 = sbv_bv_extract_u8_0_0_u1(s3960); + const SBool s6258 = false != s6257; + const SWord8 s6259 = sbv_bv_u8_rotr(s3947, 1); + const SWord8 s6260 = 128 | s6259; + const SWord8 s6261 = 127 & s6259; + const SWord8 s6262 = s6258 ? s6260 : s6261; + const SWord8 s6263 = sbv_bv_u8_rotr(s6262, 1); + const SWord8 s6264 = 128 | s6263; + const SWord8 s6265 = 127 & s6263; + const SWord8 s6266 = s6256 ? s6264 : s6265; + const SWord8 s6267 = sbv_bv_u8_rotr(s6266, 1); + const SWord8 s6268 = 128 | s6267; + const SWord8 s6269 = 127 & s6267; + const SWord8 s6270 = s6254 ? s6268 : s6269; + const SBool s6271 = sbv_bv_extract_u8_0_0_u1(s3973); + const SBool s6272 = false != s6271; + const SWord8 s6273 = s6272 ? s6268 : s6269; + const SWord8 s6274 = s3953 ? s6270 : s6273; + const SBool s6275 = sbv_bv_extract_u8_0_0_u1(s3989); + const SBool s6276 = false != s6275; + const SBool s6277 = sbv_bv_extract_u8_0_0_u1(s3982); + const SBool s6278 = false != s6277; + const SWord8 s6279 = s6278 ? s6264 : s6265; + const SWord8 s6280 = sbv_bv_u8_rotr(s6279, 1); + const SWord8 s6281 = 128 | s6280; + const SWord8 s6282 = 127 & s6280; + const SWord8 s6283 = s6276 ? s6281 : s6282; + const SBool s6284 = sbv_bv_extract_u8_0_0_u1(s3994); + const SBool s6285 = false != s6284; + const SWord8 s6286 = s6285 ? s6281 : s6282; + const SWord8 s6287 = s3953 ? s6283 : s6286; + const SWord8 s6288 = s3826 ? s6274 : s6287; + const SBool s6289 = sbv_bv_extract_u8_0_0_u1(s4015); + const SBool s6290 = false != s6289; + const SBool s6291 = sbv_bv_extract_u8_0_0_u1(s4011); + const SBool s6292 = false != s6291; + const SBool s6293 = sbv_bv_extract_u8_0_0_u1(s4004); + const SBool s6294 = false != s6293; + const SWord8 s6295 = s6294 ? s6260 : s6261; + const SWord8 s6296 = sbv_bv_u8_rotr(s6295, 1); + const SWord8 s6297 = 128 | s6296; + const SWord8 s6298 = 127 & s6296; + const SWord8 s6299 = s6292 ? s6297 : s6298; + const SWord8 s6300 = sbv_bv_u8_rotr(s6299, 1); + const SWord8 s6301 = 128 | s6300; + const SWord8 s6302 = 127 & s6300; + const SWord8 s6303 = s6290 ? s6301 : s6302; + const SBool s6304 = sbv_bv_extract_u8_0_0_u1(s4020); + const SBool s6305 = false != s6304; + const SWord8 s6306 = s6305 ? s6301 : s6302; + const SWord8 s6307 = s3953 ? s6303 : s6306; + const SBool s6308 = sbv_bv_extract_u8_0_0_u1(s4036); + const SBool s6309 = false != s6308; + const SBool s6310 = sbv_bv_extract_u8_0_0_u1(s4029); + const SBool s6311 = false != s6310; + const SWord8 s6312 = s6311 ? s6297 : s6298; + const SWord8 s6313 = sbv_bv_u8_rotr(s6312, 1); + const SWord8 s6314 = 128 | s6313; + const SWord8 s6315 = 127 & s6313; + const SWord8 s6316 = s6309 ? s6314 : s6315; + const SBool s6317 = sbv_bv_extract_u8_0_0_u1(s4041); + const SBool s6318 = false != s6317; + const SWord8 s6319 = s6318 ? s6314 : s6315; + const SWord8 s6320 = s3953 ? s6316 : s6319; + const SWord8 s6321 = s3826 ? s6307 : s6320; + const SWord8 s6322 = s3571 ? s6288 : s6321; + const SWord8 s6323 = s3060 ? s6252 : s6322; + const SWord8 s6324 = s2042 ? s6182 : s6323; + const SWord8 s6325 = s16 ? s6041 : s6324; + const SWord8 s6326 = s11 ? s5758 : s6325; + const SWord8 s6327 = s5 ? s5191 : s6326; + + *sbv_output_0 = s4056; + *sbv_output_1 = s6327; } == END: "legatoMult.c" ================== diff --git a/SBVTestSuite/GoldFiles/merge.gold b/SBVTestSuite/GoldFiles/merge.gold --- a/SBVTestSuite/GoldFiles/merge.gold +++ b/SBVTestSuite/GoldFiles/merge.gold @@ -12,11 +12,11 @@ merge.o: merge.c merge.h ${CC} ${CCFLAGS} -c $< -o $@ -merge_driver.o: merge_driver.c +merge_driver.o: merge_driver.c merge.h ${CC} ${CCFLAGS} -c $< -o $@ merge_driver: merge.o merge_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "merge.h" ================ /* Header file for merge. Automatically generated by SBV. Do not edit! */ -#ifndef __merge__HEADER_INCLUDED__ -#define __merge__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_merge_HEADER_INCLUDED +#define SBV_GENERATED_merge_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ void merge(const SWord8 *xs, SWord8 *ys); -#endif /* __merge__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_merge_HEADER_INCLUDED */ == END: "merge.h" ================== == BEGIN: "merge_driver.c" ================ /* Example driver program for merge. */ @@ -73,23 +81,29 @@ int main(void) { - const SWord8 xs[5] = { + const SWord8 sbv_driver_input_0[5] = { 10, 6, 4, 82, 71 }; printf("Contents of input array xs:\n"); - int xs_ctr; - for(xs_ctr = 0; xs_ctr < 5 ; ++xs_ctr) - printf(" xs[%1d] = %"PRIu8"\n", xs_ctr ,xs[xs_ctr]); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 5 ; ++sbv_driver_input_0_ctr) + { printf(" xs[%1d] = ", sbv_driver_input_0_ctr); + printf("%"PRIu8"", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } - SWord8 ys[5]; + SWord8 sbv_driver_output_0[5]; - merge(xs, ys); + merge(sbv_driver_input_0, sbv_driver_output_0); printf("merge(xs, ys) ->\n"); - int ys_ctr; - for(ys_ctr = 0; ys_ctr < 5 ; ++ys_ctr) - printf(" ys[%1d] = %"PRIu8"\n", ys_ctr ,ys[ys_ctr]); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 5 ; ++sbv_driver_output_0_ctr) + { printf(" ys[%1d] = ", sbv_driver_output_0_ctr); + printf("%"PRIu8"", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } return 0; } @@ -99,13 +113,13 @@ #include "merge.h" -void merge(const SWord8 *xs, SWord8 *ys) +void merge(const SWord8 *sbv_input_0, SWord8 *sbv_output_0) { - const SWord8 s0 = xs[0]; - const SWord8 s1 = xs[1]; - const SWord8 s2 = xs[2]; - const SWord8 s3 = xs[3]; - const SWord8 s4 = xs[4]; + const SWord8 s0 = sbv_input_0[0]; + const SWord8 s1 = sbv_input_0[1]; + const SWord8 s2 = sbv_input_0[2]; + const SWord8 s3 = sbv_input_0[3]; + const SWord8 s4 = sbv_input_0[4]; const SBool s5 = s0 < s1; const SWord8 s6 = s5 ? s0 : s1; const SBool s7 = s3 < s4; @@ -147,10 +161,10 @@ const SWord8 s43 = s20 ? s40 : s42; const SWord8 s44 = s11 ? s41 : s43; - ys[0] = s12; - ys[1] = s22; - ys[2] = s31; - ys[3] = s38; - ys[4] = s44; + sbv_output_0[0] = s12; + sbv_output_0[1] = s22; + sbv_output_0[2] = s31; + sbv_output_0[3] = s38; + sbv_output_0[4] = s44; } == END: "merge.c" ================== diff --git a/SBVTestSuite/GoldFiles/popCount1.gold b/SBVTestSuite/GoldFiles/popCount1.gold --- a/SBVTestSuite/GoldFiles/popCount1.gold +++ b/SBVTestSuite/GoldFiles/popCount1.gold @@ -12,11 +12,11 @@ popCount.o: popCount.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ -popCount_driver.o: popCount_driver.c +popCount_driver.o: popCount_driver.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver: popCount.o popCount_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "popCount.h" ================ /* Header file for popCount. Automatically generated by SBV. Do not edit! */ -#ifndef __popCount__HEADER_INCLUDED__ -#define __popCount__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_popCount_HEADER_INCLUDED +#define SBV_GENERATED_popCount_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord8 popCount(const SWord64 x); -#endif /* __popCount__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_popCount_HEADER_INCLUDED */ == END: "popCount.h" ================== == BEGIN: "popCount_driver.c" ================ /* Example driver program for popCount. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord8 __result = popCount(0x0123456789abcdefULL); + const SWord8 sbv_result = popCount(0x0123456789abcdefULL); - printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result); + printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", sbv_result); return 0; } @@ -85,9 +93,68 @@ #include "popCount.h" -SWord8 popCount(const SWord64 x) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_shl(SWord64 a, SWord64 amount) { - const SWord64 s0 = x; + const uint64_t n = (uint64_t) (SWord64) amount; + const SWord64 result = n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a << n); + return result; +} + +static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_lshr(SWord64 a, SWord64 amount) +{ + const uint64_t n = (uint64_t) (SWord64) amount; + return n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a >> n); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) +{ + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +SWord8 popCount(const SWord64 sbv_input_0) +{ + const SWord64 s0 = sbv_input_0; + const SWord64 s11 = s0 & 0x00000000000000ffULL; + const SWord64 s14 = sbv_bv_u64_lshr(s0, 0x0000000000000008ULL); + const SWord64 s15 = 0x00000000000000ffULL & s14; + const SWord64 s18 = sbv_bv_u64_lshr(s14, 0x0000000000000008ULL); + const SWord64 s19 = 0x00000000000000ffULL & s18; + const SWord64 s22 = sbv_bv_u64_lshr(s18, 0x0000000000000008ULL); + const SWord64 s23 = 0x00000000000000ffULL & s22; + const SWord64 s26 = sbv_bv_u64_lshr(s22, 0x0000000000000008ULL); + const SWord64 s27 = 0x00000000000000ffULL & s26; + const SWord64 s30 = sbv_bv_u64_lshr(s26, 0x0000000000000008ULL); + const SWord64 s31 = 0x00000000000000ffULL & s30; + const SWord64 s34 = sbv_bv_u64_lshr(s30, 0x0000000000000008ULL); + const SWord64 s35 = 0x00000000000000ffULL & s34; + const SWord64 s38 = sbv_bv_u64_lshr(s34, 0x0000000000000008ULL); + const SWord64 s39 = 0x00000000000000ffULL & s38; + SWord8 s12; + SWord8 s16; + SWord8 s17; + SWord8 s20; + SWord8 s21; + SWord8 s24; + SWord8 s25; + SWord8 s28; + SWord8 s29; + SWord8 s32; + SWord8 s33; + SWord8 s36; + SWord8 s37; + SWord8 s40; + SWord8 s41; 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, @@ -102,36 +169,21 @@ 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 s14 = s0 >> 8; - const SWord64 s15 = 0x00000000000000ffULL & s14; - const SWord8 s16 = table0[s15]; - const SWord8 s17 = s12 + s16; - const SWord64 s18 = s14 >> 8; - const SWord64 s19 = 0x00000000000000ffULL & s18; - const SWord8 s20 = table0[s19]; - const SWord8 s21 = s17 + s20; - const SWord64 s22 = s18 >> 8; - const SWord64 s23 = 0x00000000000000ffULL & s22; - const SWord8 s24 = table0[s23]; - const SWord8 s25 = s21 + s24; - const SWord64 s26 = s22 >> 8; - const SWord64 s27 = 0x00000000000000ffULL & s26; - const SWord8 s28 = table0[s27]; - const SWord8 s29 = s25 + s28; - const SWord64 s30 = s26 >> 8; - const SWord64 s31 = 0x00000000000000ffULL & s30; - const SWord8 s32 = table0[s31]; - const SWord8 s33 = s29 + s32; - const SWord64 s34 = s30 >> 8; - const SWord64 s35 = 0x00000000000000ffULL & s34; - const SWord8 s36 = table0[s35]; - const SWord8 s37 = s33 + s36; - const SWord64 s38 = s34 >> 8; - const SWord64 s39 = 0x00000000000000ffULL & s38; - const SWord8 s40 = table0[s39]; - const SWord8 s41 = s37 + s40; + s12 = table0[s11]; + s16 = table0[s15]; + s17 = sbv_bv_u8_add(s12, s16); + s20 = table0[s19]; + s21 = sbv_bv_u8_add(s17, s20); + s24 = table0[s23]; + s25 = sbv_bv_u8_add(s21, s24); + s28 = table0[s27]; + s29 = sbv_bv_u8_add(s25, s28); + s32 = table0[s31]; + s33 = sbv_bv_u8_add(s29, s32); + s36 = table0[s35]; + s37 = sbv_bv_u8_add(s33, s36); + s40 = table0[s39]; + s41 = sbv_bv_u8_add(s37, s40); return s41; } diff --git a/SBVTestSuite/GoldFiles/popCount2.gold b/SBVTestSuite/GoldFiles/popCount2.gold --- a/SBVTestSuite/GoldFiles/popCount2.gold +++ b/SBVTestSuite/GoldFiles/popCount2.gold @@ -12,11 +12,11 @@ popCount.o: popCount.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ -popCount_driver.o: popCount_driver.c +popCount_driver.o: popCount_driver.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver: popCount.o popCount_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "popCount.h" ================ /* Header file for popCount. Automatically generated by SBV. Do not edit! */ -#ifndef __popCount__HEADER_INCLUDED__ -#define __popCount__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_popCount_HEADER_INCLUDED +#define SBV_GENERATED_popCount_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord8 popCount(const SWord64 x); -#endif /* __popCount__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_popCount_HEADER_INCLUDED */ == END: "popCount.h" ================== == BEGIN: "popCount_driver.c" ================ /* Example driver program for popCount. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord8 __result = popCount(0x0123456789abcdefULL); + const SWord8 sbv_result = popCount(0x0123456789abcdefULL); - printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result); + printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", sbv_result); return 0; } @@ -85,9 +93,68 @@ #include "popCount.h" -SWord8 popCount(const SWord64 x) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_shl(SWord64 a, SWord64 amount) { - const SWord64 s0 = x; + const uint64_t n = (uint64_t) (SWord64) amount; + const SWord64 result = n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a << n); + return result; +} + +static inline SBV_CGEN_UNUSED SWord64 sbv_bv_u64_lshr(SWord64 a, SWord64 amount) +{ + const uint64_t n = (uint64_t) (SWord64) amount; + return n >= 64 ? (SWord64) 0 : (SWord64) ((uint64_t) (SWord64) a >> n); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) +{ + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +SWord8 popCount(const SWord64 sbv_input_0) +{ + const SWord64 s0 = sbv_input_0; + const SWord64 s11 = s0 & 0x00000000000000ffULL; + const SWord64 s14 = sbv_bv_u64_lshr(s0, 0x0000000000000008ULL); + const SWord64 s15 = 0x00000000000000ffULL & s14; + const SWord64 s18 = sbv_bv_u64_lshr(s14, 0x0000000000000008ULL); + const SWord64 s19 = 0x00000000000000ffULL & s18; + const SWord64 s22 = sbv_bv_u64_lshr(s18, 0x0000000000000008ULL); + const SWord64 s23 = 0x00000000000000ffULL & s22; + const SWord64 s26 = sbv_bv_u64_lshr(s22, 0x0000000000000008ULL); + const SWord64 s27 = 0x00000000000000ffULL & s26; + const SWord64 s30 = sbv_bv_u64_lshr(s26, 0x0000000000000008ULL); + const SWord64 s31 = 0x00000000000000ffULL & s30; + const SWord64 s34 = sbv_bv_u64_lshr(s30, 0x0000000000000008ULL); + const SWord64 s35 = 0x00000000000000ffULL & s34; + const SWord64 s38 = sbv_bv_u64_lshr(s34, 0x0000000000000008ULL); + const SWord64 s39 = 0x00000000000000ffULL & s38; + SWord8 s12; + SWord8 s16; + SWord8 s17; + SWord8 s20; + SWord8 s21; + SWord8 s24; + SWord8 s25; + SWord8 s28; + SWord8 s29; + SWord8 s32; + SWord8 s33; + SWord8 s36; + SWord8 s37; + SWord8 s40; + SWord8 s41; 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, @@ -102,36 +169,21 @@ 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 s14 = s0 >> 8; - const SWord64 s15 = 0x00000000000000ffULL & s14; - const SWord8 s16 = s15 >= 256 ? 0 : table0[s15]; - const SWord8 s17 = s12 + s16; - const SWord64 s18 = s14 >> 8; - const SWord64 s19 = 0x00000000000000ffULL & s18; - const SWord8 s20 = s19 >= 256 ? 0 : table0[s19]; - const SWord8 s21 = s17 + s20; - const SWord64 s22 = s18 >> 8; - const SWord64 s23 = 0x00000000000000ffULL & s22; - const SWord8 s24 = s23 >= 256 ? 0 : table0[s23]; - const SWord8 s25 = s21 + s24; - const SWord64 s26 = s22 >> 8; - const SWord64 s27 = 0x00000000000000ffULL & s26; - const SWord8 s28 = s27 >= 256 ? 0 : table0[s27]; - const SWord8 s29 = s25 + s28; - const SWord64 s30 = s26 >> 8; - const SWord64 s31 = 0x00000000000000ffULL & s30; - const SWord8 s32 = s31 >= 256 ? 0 : table0[s31]; - const SWord8 s33 = s29 + s32; - const SWord64 s34 = s30 >> 8; - const SWord64 s35 = 0x00000000000000ffULL & s34; - const SWord8 s36 = s35 >= 256 ? 0 : table0[s35]; - const SWord8 s37 = s33 + s36; - const SWord64 s38 = s34 >> 8; - const SWord64 s39 = 0x00000000000000ffULL & s38; - const SWord8 s40 = s39 >= 256 ? 0 : table0[s39]; - const SWord8 s41 = s37 + s40; + s12 = s11 >= 256 ? 0 : table0[s11]; + s16 = s15 >= 256 ? 0 : table0[s15]; + s17 = sbv_bv_u8_add(s12, s16); + s20 = s19 >= 256 ? 0 : table0[s19]; + s21 = sbv_bv_u8_add(s17, s20); + s24 = s23 >= 256 ? 0 : table0[s23]; + s25 = sbv_bv_u8_add(s21, s24); + s28 = s27 >= 256 ? 0 : table0[s27]; + s29 = sbv_bv_u8_add(s25, s28); + s32 = s31 >= 256 ? 0 : table0[s31]; + s33 = sbv_bv_u8_add(s29, s32); + s36 = s35 >= 256 ? 0 : table0[s35]; + s37 = sbv_bv_u8_add(s33, s36); + s40 = s39 >= 256 ? 0 : table0[s39]; + s41 = sbv_bv_u8_add(s37, s40); return s41; } diff --git a/SBVTestSuite/GoldFiles/queryTables.gold b/SBVTestSuite/GoldFiles/queryTables.gold --- a/SBVTestSuite/GoldFiles/queryTables.gold +++ b/SBVTestSuite/GoldFiles/queryTables.gold @@ -33,14 +33,14 @@ [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) +[GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) + ((mkSBVTuple2 (proj_1_SBVTuple2 T1) + (proj_2_SBVTuple2 T2)))))) [GOOD] ; User defined ADT: Maybe [GOOD] (declare-datatype Maybe (par (a) ( (Nothing) (Just (getJust_1 a)) ))) -[GOOD] (declare-datatypes ((SBVTuple2 2)) ((par (T1 T2) - ((mkSBVTuple2 (proj_1_SBVTuple2 T1) - (proj_2_SBVTuple2 T2)))))) [GOOD] (define-fun s13 () (_ BitVec 16) #x000a) [GOOD] (define-fun s15 () (_ BitVec 16) (bvneg #x0001)) [GOOD] (define-fun s17 () (_ BitVec 16) #x0007) diff --git a/SBVTestSuite/GoldFiles/query_uisatex1.gold b/SBVTestSuite/GoldFiles/query_uisatex1.gold --- a/SBVTestSuite/GoldFiles/query_uisatex1.gold +++ b/SBVTestSuite/GoldFiles/query_uisatex1.gold @@ -19,34 +19,32 @@ [GOOD] (define-fun s9 () Int (- 3)) [GOOD] (define-fun s11 () Int 9) [GOOD] (define-fun s14 () Int 1) -[GOOD] (define-fun s21 () Int 5) -[GOOD] (define-fun s23 () Int 7) -[GOOD] (define-fun s25 () Int 6) -[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00010011001100110011010)) -[GOOD] (define-fun s32 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00110011001100110011010)) -[GOOD] (define-fun s33 () Int 121) -[GOOD] (define-fun s38 () Int 8) -[GOOD] (define-fun s40 () (_ FloatingPoint 8 24) (_ +oo 8 24)) -[GOOD] (define-fun s42 () String (_ char #x63)) -[GOOD] (define-fun s43 () String "hey") -[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b00111000000000000000000)) -[GOOD] (define-fun s47 () String "tey") -[GOOD] (define-fun s49 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b01110000000000000000000)) -[GOOD] (define-fun s51 () String (_ char #x72)) -[GOOD] (define-fun s52 () String "foo") -[GOOD] (define-fun s54 () (_ FloatingPoint 8 24) (fp #b0 #b10000000 #b11000000000000000000000)) -[GOOD] (define-fun s56 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) -[GOOD] (define-fun s57 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000000 #b10000000000000000000000)))) -[GOOD] (define-fun s60 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) -[GOOD] (define-fun s61 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000010 #b00100000000000000000000)))) -[GOOD] (define-fun s63 () Int 21) -[GOOD] (define-fun s65 () (Seq Int) (seq.unit 5)) -[GOOD] (define-fun s66 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (_ +zero 8 24)))) -[GOOD] (define-fun s68 () Int 210) +[GOOD] (define-fun s18 () Int 5) +[GOOD] (define-fun s20 () Int 7) +[GOOD] (define-fun s22 () Int 6) +[GOOD] (define-fun s26 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00010011001100110011010)) +[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00110011001100110011010)) +[GOOD] (define-fun s30 () Int 121) +[GOOD] (define-fun s35 () Int 8) +[GOOD] (define-fun s37 () (_ FloatingPoint 8 24) (_ +oo 8 24)) +[GOOD] (define-fun s39 () String (_ char #x63)) +[GOOD] (define-fun s40 () String "hey") +[GOOD] (define-fun s42 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b00111000000000000000000)) +[GOOD] (define-fun s44 () String "tey") +[GOOD] (define-fun s46 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b01110000000000000000000)) +[GOOD] (define-fun s48 () String (_ char #x72)) +[GOOD] (define-fun s49 () String "foo") +[GOOD] (define-fun s51 () (_ FloatingPoint 8 24) (fp #b0 #b10000000 #b11000000000000000000000)) +[GOOD] (define-fun s53 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) +[GOOD] (define-fun s54 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000000 #b10000000000000000000000)))) +[GOOD] (define-fun s57 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) +[GOOD] (define-fun s58 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000010 #b00100000000000000000000)))) +[GOOD] (define-fun s60 () Int 21) +[GOOD] (define-fun s62 () (Seq Int) (seq.unit 5)) +[GOOD] (define-fun s63 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (_ +zero 8 24)))) +[GOOD] (define-fun s65 () Int 210) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () Int) -[GOOD] (declare-fun s17 () Bool) ; tracks user variable "__internal_sbv_s17" -[GOOD] (declare-fun s18 () Int) ; tracks user variable "__internal_sbv_s18" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -66,59 +64,54 @@ [GOOD] (define-fun s13 () Int (q1 s0)) [GOOD] (define-fun s15 () Int (+ s0 s14)) [GOOD] (define-fun s16 () Bool (= s13 s15)) -[GOOD] (define-fun s19 () Int (q2 s17 s18)) -[GOOD] (define-fun s20 () Int (q2 true s5)) -[GOOD] (define-fun s22 () Bool (= s20 s21)) -[GOOD] (define-fun s24 () Int (q2 false s23)) -[GOOD] (define-fun s26 () Bool (= s24 s25)) -[GOOD] (define-fun s27 () Int (q2 false s3)) -[GOOD] (define-fun s28 () Bool (= s5 s27)) -[GOOD] (define-fun s30 () (_ FloatingPoint 8 24) (q3 s29 true s3)) -[GOOD] (define-fun s31 () Bool (fp.eq s29 s30)) -[GOOD] (define-fun s34 () (_ FloatingPoint 8 24) (q3 s32 true s33)) -[GOOD] (define-fun s35 () Bool (fp.isZero s34)) -[GOOD] (define-fun s36 () Bool (fp.isNegative s34)) -[GOOD] (define-fun s37 () Bool (and s35 s36)) -[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (q3 s32 false s38)) -[GOOD] (define-fun s41 () Bool (fp.eq s39 s40)) -[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) (q4 s42 s43)) -[GOOD] (define-fun s46 () Bool (fp.eq s44 s45)) -[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) (q4 s42 s47)) -[GOOD] (define-fun s50 () Bool (fp.eq s48 s49)) -[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) (q4 s51 s52)) -[GOOD] (define-fun s55 () Bool (fp.eq s53 s54)) -[GOOD] (define-fun s58 () Int (q5 s56 s57)) -[GOOD] (define-fun s59 () Bool (= s23 s58)) -[GOOD] (define-fun s62 () Int (q5 s60 s61)) -[GOOD] (define-fun s64 () Bool (= s62 s63)) -[GOOD] (define-fun s67 () Int (q5 s65 s66)) -[GOOD] (define-fun s69 () Bool (= s67 s68)) +[GOOD] (define-fun s17 () Int (q2 true s5)) +[GOOD] (define-fun s19 () Bool (= s17 s18)) +[GOOD] (define-fun s21 () Int (q2 false s20)) +[GOOD] (define-fun s23 () Bool (= s21 s22)) +[GOOD] (define-fun s24 () Int (q2 false s3)) +[GOOD] (define-fun s25 () Bool (= s5 s24)) +[GOOD] (define-fun s27 () (_ FloatingPoint 8 24) (q3 s26 true s3)) +[GOOD] (define-fun s28 () Bool (fp.eq s26 s27)) +[GOOD] (define-fun s31 () (_ FloatingPoint 8 24) (q3 s29 true s30)) +[GOOD] (define-fun s32 () Bool (fp.isZero s31)) +[GOOD] (define-fun s33 () Bool (fp.isNegative s31)) +[GOOD] (define-fun s34 () Bool (and s32 s33)) +[GOOD] (define-fun s36 () (_ FloatingPoint 8 24) (q3 s29 false s35)) +[GOOD] (define-fun s38 () Bool (fp.eq s36 s37)) +[GOOD] (define-fun s41 () (_ FloatingPoint 8 24) (q4 s39 s40)) +[GOOD] (define-fun s43 () Bool (fp.eq s41 s42)) +[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) (q4 s39 s44)) +[GOOD] (define-fun s47 () Bool (fp.eq s45 s46)) +[GOOD] (define-fun s50 () (_ FloatingPoint 8 24) (q4 s48 s49)) +[GOOD] (define-fun s52 () Bool (fp.eq s50 s51)) +[GOOD] (define-fun s55 () Int (q5 s53 s54)) +[GOOD] (define-fun s56 () Bool (= s20 s55)) +[GOOD] (define-fun s59 () Int (q5 s57 s58)) +[GOOD] (define-fun s61 () Bool (= s59 s60)) +[GOOD] (define-fun s64 () Int (q5 s62 s63)) +[GOOD] (define-fun s66 () Bool (= s64 s65)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s8) [GOOD] (assert s12) [GOOD] (assert s16) -[GOOD] (assert s22) -[GOOD] (assert s26) +[GOOD] (assert s19) +[GOOD] (assert s23) +[GOOD] (assert s25) [GOOD] (assert s28) -[GOOD] (assert s31) -[GOOD] (assert s37) -[GOOD] (assert s41) -[GOOD] (assert s46) -[GOOD] (assert s50) -[GOOD] (assert s55) -[GOOD] (assert s59) -[GOOD] (assert s64) -[GOOD] (assert s69) +[GOOD] (assert s34) +[GOOD] (assert s38) +[GOOD] (assert s43) +[GOOD] (assert s47) +[GOOD] (assert s52) +[GOOD] (assert s56) +[GOOD] (assert s61) +[GOOD] (assert s66) [SEND] (check-sat) [RECV] sat [SEND] (get-value (s0)) [RECV] ((s0 0)) -[SEND] (get-value (s17)) -[RECV] ((s17 false)) -[SEND] (get-value (s18)) -[RECV] ((s18 0)) [GOOD] (set-option :pp.max_depth 4294967295) [GOOD] (set-option :pp.min_alias_size 4294967295) [GOOD] (set-option :model.inline_def true ) diff --git a/SBVTestSuite/GoldFiles/query_uisatex2.gold b/SBVTestSuite/GoldFiles/query_uisatex2.gold --- a/SBVTestSuite/GoldFiles/query_uisatex2.gold +++ b/SBVTestSuite/GoldFiles/query_uisatex2.gold @@ -19,35 +19,33 @@ [GOOD] (define-fun s9 () Int (- 3)) [GOOD] (define-fun s11 () Int 9) [GOOD] (define-fun s14 () Int 1) -[GOOD] (define-fun s21 () Int 5) -[GOOD] (define-fun s23 () Int 7) -[GOOD] (define-fun s25 () Int 6) -[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00010011001100110011010)) -[GOOD] (define-fun s32 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00110011001100110011010)) -[GOOD] (define-fun s33 () Int 121) -[GOOD] (define-fun s38 () Int 8) -[GOOD] (define-fun s40 () (_ FloatingPoint 8 24) (_ +oo 8 24)) -[GOOD] (define-fun s42 () String (_ char #x63)) -[GOOD] (define-fun s43 () String "hey") -[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b00111000000000000000000)) -[GOOD] (define-fun s47 () String "tey") -[GOOD] (define-fun s49 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b01110000000000000000000)) -[GOOD] (define-fun s51 () String (_ char #x72)) -[GOOD] (define-fun s52 () String "foo") -[GOOD] (define-fun s54 () (_ FloatingPoint 8 24) (fp #b0 #b10000000 #b11000000000000000000000)) -[GOOD] (define-fun s56 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) -[GOOD] (define-fun s57 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000000 #b10000000000000000000000)))) -[GOOD] (define-fun s60 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) -[GOOD] (define-fun s61 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000010 #b00100000000000000000000)))) -[GOOD] (define-fun s63 () Int 21) -[GOOD] (define-fun s65 () (Seq Int) (seq.unit 5)) -[GOOD] (define-fun s66 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (_ +zero 8 24)))) -[GOOD] (define-fun s68 () Int 210) +[GOOD] (define-fun s18 () Int 5) +[GOOD] (define-fun s20 () Int 7) +[GOOD] (define-fun s22 () Int 6) +[GOOD] (define-fun s26 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00010011001100110011010)) +[GOOD] (define-fun s29 () (_ FloatingPoint 8 24) (fp #b0 #b10000010 #b00110011001100110011010)) +[GOOD] (define-fun s30 () Int 121) +[GOOD] (define-fun s35 () Int 8) +[GOOD] (define-fun s37 () (_ FloatingPoint 8 24) (_ +oo 8 24)) +[GOOD] (define-fun s39 () String (_ char #x63)) +[GOOD] (define-fun s40 () String "hey") +[GOOD] (define-fun s42 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b00111000000000000000000)) +[GOOD] (define-fun s44 () String "tey") +[GOOD] (define-fun s46 () (_ FloatingPoint 8 24) (fp #b0 #b10000101 #b01110000000000000000000)) +[GOOD] (define-fun s48 () String (_ char #x72)) +[GOOD] (define-fun s49 () String "foo") +[GOOD] (define-fun s51 () (_ FloatingPoint 8 24) (fp #b0 #b10000000 #b11000000000000000000000)) +[GOOD] (define-fun s53 () (Seq Int) (seq.++ (seq.unit 1) (seq.unit 2) (seq.unit 3))) +[GOOD] (define-fun s54 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000000 #b10000000000000000000000)))) +[GOOD] (define-fun s57 () (Seq Int) (seq.++ (seq.unit 9) (seq.unit 5))) +[GOOD] (define-fun s58 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (fp #b0 #b10000010 #b00100000000000000000000)))) +[GOOD] (define-fun s60 () Int 21) +[GOOD] (define-fun s62 () (Seq Int) (seq.unit 5)) +[GOOD] (define-fun s63 () (Seq (_ FloatingPoint 8 24)) (seq.++ (seq.unit (fp #b0 #b10000010 #b00000110011001100110011)) (seq.unit (_ +zero 8 24)))) +[GOOD] (define-fun s65 () Int 210) [GOOD] ; --- top level inputs --- [GOOD] (declare-fun s0 () Int) -[GOOD] (declare-fun s17 () Bool) ; tracks user variable "__internal_sbv_s17" -[GOOD] (declare-fun s18 () Int) ; tracks user variable "__internal_sbv_s18" -[GOOD] (declare-fun s70 () Int) ; tracks user variable "__internal_sbv_s70" +[GOOD] (declare-fun s67 () Int) ; tracks user variable "__internal_sbv_s67" [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -68,52 +66,51 @@ [GOOD] (define-fun s13 () Int (q1 s0)) [GOOD] (define-fun s15 () Int (+ s0 s14)) [GOOD] (define-fun s16 () Bool (= s13 s15)) -[GOOD] (define-fun s19 () Int (q2 s17 s18)) -[GOOD] (define-fun s20 () Int (q2 true s5)) -[GOOD] (define-fun s22 () Bool (= s20 s21)) -[GOOD] (define-fun s24 () Int (q2 false s23)) -[GOOD] (define-fun s26 () Bool (= s24 s25)) -[GOOD] (define-fun s27 () Int (q2 false s3)) -[GOOD] (define-fun s28 () Bool (= s5 s27)) -[GOOD] (define-fun s30 () (_ FloatingPoint 8 24) (q3 s29 true s3)) -[GOOD] (define-fun s31 () Bool (fp.eq s29 s30)) -[GOOD] (define-fun s34 () (_ FloatingPoint 8 24) (q3 s32 true s33)) -[GOOD] (define-fun s35 () Bool (fp.isZero s34)) -[GOOD] (define-fun s36 () Bool (fp.isNegative s34)) -[GOOD] (define-fun s37 () Bool (and s35 s36)) -[GOOD] (define-fun s39 () (_ FloatingPoint 8 24) (q3 s32 false s38)) -[GOOD] (define-fun s41 () Bool (fp.eq s39 s40)) -[GOOD] (define-fun s44 () (_ FloatingPoint 8 24) (q4 s42 s43)) -[GOOD] (define-fun s46 () Bool (fp.eq s44 s45)) -[GOOD] (define-fun s48 () (_ FloatingPoint 8 24) (q4 s42 s47)) -[GOOD] (define-fun s50 () Bool (fp.eq s48 s49)) -[GOOD] (define-fun s53 () (_ FloatingPoint 8 24) (q4 s51 s52)) -[GOOD] (define-fun s55 () Bool (fp.eq s53 s54)) -[GOOD] (define-fun s58 () Int (q5 s56 s57)) -[GOOD] (define-fun s59 () Bool (= s23 s58)) -[GOOD] (define-fun s62 () Int (q5 s60 s61)) -[GOOD] (define-fun s64 () Bool (= s62 s63)) -[GOOD] (define-fun s67 () Int (q5 s65 s66)) -[GOOD] (define-fun s69 () Bool (= s67 s68)) -[GOOD] (define-fun s71 () Bool (q6 s70)) +[GOOD] (define-fun s17 () Int (q2 true s5)) +[GOOD] (define-fun s19 () Bool (= s17 s18)) +[GOOD] (define-fun s21 () Int (q2 false s20)) +[GOOD] (define-fun s23 () Bool (= s21 s22)) +[GOOD] (define-fun s24 () Int (q2 false s3)) +[GOOD] (define-fun s25 () Bool (= s5 s24)) +[GOOD] (define-fun s27 () (_ FloatingPoint 8 24) (q3 s26 true s3)) +[GOOD] (define-fun s28 () Bool (fp.eq s26 s27)) +[GOOD] (define-fun s31 () (_ FloatingPoint 8 24) (q3 s29 true s30)) +[GOOD] (define-fun s32 () Bool (fp.isZero s31)) +[GOOD] (define-fun s33 () Bool (fp.isNegative s31)) +[GOOD] (define-fun s34 () Bool (and s32 s33)) +[GOOD] (define-fun s36 () (_ FloatingPoint 8 24) (q3 s29 false s35)) +[GOOD] (define-fun s38 () Bool (fp.eq s36 s37)) +[GOOD] (define-fun s41 () (_ FloatingPoint 8 24) (q4 s39 s40)) +[GOOD] (define-fun s43 () Bool (fp.eq s41 s42)) +[GOOD] (define-fun s45 () (_ FloatingPoint 8 24) (q4 s39 s44)) +[GOOD] (define-fun s47 () Bool (fp.eq s45 s46)) +[GOOD] (define-fun s50 () (_ FloatingPoint 8 24) (q4 s48 s49)) +[GOOD] (define-fun s52 () Bool (fp.eq s50 s51)) +[GOOD] (define-fun s55 () Int (q5 s53 s54)) +[GOOD] (define-fun s56 () Bool (= s20 s55)) +[GOOD] (define-fun s59 () Int (q5 s57 s58)) +[GOOD] (define-fun s61 () Bool (= s59 s60)) +[GOOD] (define-fun s64 () Int (q5 s62 s63)) +[GOOD] (define-fun s66 () Bool (= s64 s65)) +[GOOD] (define-fun s68 () Bool (q6 s67)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s4) [GOOD] (assert s8) [GOOD] (assert s12) [GOOD] (assert s16) -[GOOD] (assert s22) -[GOOD] (assert s26) +[GOOD] (assert s19) +[GOOD] (assert s23) +[GOOD] (assert s25) [GOOD] (assert s28) -[GOOD] (assert s31) -[GOOD] (assert s37) -[GOOD] (assert s41) -[GOOD] (assert s46) -[GOOD] (assert s50) -[GOOD] (assert s55) -[GOOD] (assert s59) -[GOOD] (assert s64) -[GOOD] (assert s69) +[GOOD] (assert s34) +[GOOD] (assert s38) +[GOOD] (assert s43) +[GOOD] (assert s47) +[GOOD] (assert s52) +[GOOD] (assert s56) +[GOOD] (assert s61) +[GOOD] (assert s66) [SEND] (check-sat) [RECV] sat [SEND] (get-value (q1)) diff --git a/SBVTestSuite/GoldFiles/selChecked.gold b/SBVTestSuite/GoldFiles/selChecked.gold --- a/SBVTestSuite/GoldFiles/selChecked.gold +++ b/SBVTestSuite/GoldFiles/selChecked.gold @@ -12,11 +12,11 @@ selChecked.o: selChecked.c selChecked.h ${CC} ${CCFLAGS} -c $< -o $@ -selChecked_driver.o: selChecked_driver.c +selChecked_driver.o: selChecked_driver.c selChecked.h ${CC} ${CCFLAGS} -c $< -o $@ selChecked_driver: selChecked.o selChecked_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "selChecked.h" ================ /* Header file for selChecked. Automatically generated by SBV. Do not edit! */ -#ifndef __selChecked__HEADER_INCLUDED__ -#define __selChecked__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_selChecked_HEADER_INCLUDED +#define SBV_GENERATED_selChecked_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord8 selChecked(const SWord8 x); -#endif /* __selChecked__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_selChecked_HEADER_INCLUDED */ == END: "selChecked.h" ================== == BEGIN: "selChecked_driver.c" ================ /* Example driver program for selChecked. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord8 __result = selChecked(65); + const SWord8 sbv_result = selChecked(65); - printf("selChecked(65) = %"PRIu8"\n", __result); + printf("selChecked(65) = %"PRIu8"\n", sbv_result); return 0; } @@ -85,14 +93,31 @@ #include "selChecked.h" -SWord8 selChecked(const SWord8 x) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) { - const SWord8 s0 = x; - const SWord8 s3 = s0 + 2; + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +SWord8 selChecked(const SWord8 sbv_input_0) +{ + const SWord8 s0 = sbv_input_0; + const SWord8 s3 = sbv_bv_u8_add(s0, 2); + SWord8 s5; const SWord8 table0[] = { 1, s3 }; - const SWord8 s5 = s0 >= 2 ? 3 : table0[s0]; + s5 = s0 >= 2 ? 3 : table0[s0]; return s5; } diff --git a/SBVTestSuite/GoldFiles/selUnchecked.gold b/SBVTestSuite/GoldFiles/selUnchecked.gold --- a/SBVTestSuite/GoldFiles/selUnchecked.gold +++ b/SBVTestSuite/GoldFiles/selUnchecked.gold @@ -12,11 +12,11 @@ selUnChecked.o: selUnChecked.c selUnChecked.h ${CC} ${CCFLAGS} -c $< -o $@ -selUnChecked_driver.o: selUnChecked_driver.c +selUnChecked_driver.o: selUnChecked_driver.c selUnChecked.h ${CC} ${CCFLAGS} -c $< -o $@ selUnChecked_driver: selUnChecked.o selUnChecked_driver.o - ${CC} ${CCFLAGS} $^ -o $@ + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} clean: rm -f *.o @@ -27,9 +27,10 @@ == BEGIN: "selUnChecked.h" ================ /* Header file for selUnChecked. Automatically generated by SBV. Do not edit! */ -#ifndef __selUnChecked__HEADER_INCLUDED__ -#define __selUnChecked__HEADER_INCLUDED__ +#ifndef SBV_GENERATED_selUnChecked_HEADER_INCLUDED +#define SBV_GENERATED_selUnChecked_HEADER_INCLUDED + #include #include #include @@ -38,6 +39,13 @@ #include #include +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + /* The boolean type */ typedef bool SBool; @@ -62,7 +70,7 @@ /* Entry point prototype: */ SWord8 selUnChecked(const SWord8 x); -#endif /* __selUnChecked__HEADER_INCLUDED__ */ +#endif /* SBV_GENERATED_selUnChecked_HEADER_INCLUDED */ == END: "selUnChecked.h" ================== == BEGIN: "selUnChecked_driver.c" ================ /* Example driver program for selUnChecked. */ @@ -73,9 +81,9 @@ int main(void) { - const SWord8 __result = selUnChecked(65); + const SWord8 sbv_result = selUnChecked(65); - printf("selUnChecked(65) = %"PRIu8"\n", __result); + printf("selUnChecked(65) = %"PRIu8"\n", sbv_result); return 0; } @@ -85,14 +93,31 @@ #include "selUnChecked.h" -SWord8 selUnChecked(const SWord8 x) +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_u8_add(SWord8 a, SWord8 b) { - const SWord8 s0 = x; - const SWord8 s3 = s0 + 2; + const SWord8 bits = (SWord8) ((((uint64_t) (SWord8) a) + ((uint64_t) (SWord8) b)) & UINT64_C(0x00000000000000ff)); + return (SWord8) bits; +} + + +SWord8 selUnChecked(const SWord8 sbv_input_0) +{ + const SWord8 s0 = sbv_input_0; + const SWord8 s3 = sbv_bv_u8_add(s0, 2); + SWord8 s5; const SWord8 table0[] = { 1, s3 }; - const SWord8 s5 = table0[s0]; + s5 = table0[s0]; return s5; } diff --git a/SBVTestSuite/GoldFiles/sha256HashBlock.gold b/SBVTestSuite/GoldFiles/sha256HashBlock.gold --- a/SBVTestSuite/GoldFiles/sha256HashBlock.gold +++ b/SBVTestSuite/GoldFiles/sha256HashBlock.gold @@ -12,2578 +12,2687 @@ sha256HashBlock.o: sha256HashBlock.c sha256HashBlock.h ${CC} ${CCFLAGS} -c $< -o $@ -sha256HashBlock_driver.o: sha256HashBlock_driver.c - ${CC} ${CCFLAGS} -c $< -o $@ - -sha256HashBlock_driver: sha256HashBlock.o sha256HashBlock_driver.o - ${CC} ${CCFLAGS} $^ -o $@ - -clean: - rm -f *.o - -veryclean: clean - rm -f sha256HashBlock_driver -== END: "Makefile" ================== -== BEGIN: "sha256HashBlock.h" ================ -/* Header file for sha256HashBlock. Automatically generated by SBV. Do not edit! */ - -#ifndef __sha256HashBlock__HEADER_INCLUDED__ -#define __sha256HashBlock__HEADER_INCLUDED__ - -#include -#include -#include -#include -#include -#include -#include - -/* The boolean type */ -typedef bool SBool; - -/* The float type */ -typedef float SFloat; - -/* The double type */ -typedef double SDouble; - -/* Unsigned bit-vectors */ -typedef uint8_t SWord8; -typedef uint16_t SWord16; -typedef uint32_t SWord32; -typedef uint64_t SWord64; - -/* Signed bit-vectors */ -typedef int8_t SInt8; -typedef int16_t SInt16; -typedef int32_t SInt32; -typedef int64_t SInt64; - -/* Entry point prototype: */ -void sha256HashBlock(const SWord8 *hIn, const SWord8 *block, - SWord8 *hash); - -#endif /* __sha256HashBlock__HEADER_INCLUDED__ */ -== END: "sha256HashBlock.h" ================== -== BEGIN: "sha256HashBlock_driver.c" ================ -/* Example driver program for sha256HashBlock. */ -/* Automatically generated by SBV. Edit as you see fit! */ - -#include -#include "sha256HashBlock.h" - -int main(void) -{ - const SWord8 hIn[32] = { - 0x6a, 0x09, 0xe6, 0x67, 0xbb, 0x67, 0xae, 0x85, 0x3c, 0x6e, 0xf3, - 0x72, 0xa5, 0x4f, 0xf5, 0x3a, 0x51, 0x0e, 0x52, 0x7f, 0x9b, 0x05, - 0x68, 0x8c, 0x1f, 0x83, 0xd9, 0xab, 0x5b, 0xe0, 0xcd, 0x19 - }; - - printf("Contents of input array hIn:\n"); - int hIn_ctr; - for(hIn_ctr = 0; hIn_ctr < 32 ; ++hIn_ctr) - printf(" hIn[%2d] = 0x%02"PRIx8"\n", hIn_ctr ,hIn[hIn_ctr]); - - const SWord8 block[64] = { - 0x53, 0x42, 0x56, 0x20, 0x67, 0x6f, 0x65, 0x73, 0x20, 0x53, 0x48, - 0x41, 0x32, 0x35, 0x36, 0x21, 0x21, 0x80, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 - }; - - printf("Contents of input array block:\n"); - int block_ctr; - for(block_ctr = 0; block_ctr < 64 ; ++block_ctr) - printf(" block[%2d] = 0x%02"PRIx8"\n", block_ctr ,block[block_ctr]); - - SWord8 hash[32]; - - sha256HashBlock(hIn, block, hash); - - printf("sha256HashBlock(hIn, block, hash) ->\n"); - int hash_ctr; - for(hash_ctr = 0; hash_ctr < 32 ; ++hash_ctr) - printf(" hash[%2d] = 0x%02"PRIx8"\n", hash_ctr ,hash[hash_ctr]); - - return 0; -} -== END: "sha256HashBlock_driver.c" ================== -== BEGIN: "sha256HashBlock.c" ================ -/* File: "sha256HashBlock.c". Automatically generated by SBV. Do not edit! */ - -#include "sha256HashBlock.h" - -void sha256HashBlock(const SWord8 *hIn, const SWord8 *block, - SWord8 *hash) -{ - const SWord8 s0 = hIn[0]; - const SWord8 s1 = hIn[1]; - const SWord8 s2 = hIn[2]; - const SWord8 s3 = hIn[3]; - const SWord8 s4 = hIn[4]; - const SWord8 s5 = hIn[5]; - const SWord8 s6 = hIn[6]; - const SWord8 s7 = hIn[7]; - const SWord8 s8 = hIn[8]; - const SWord8 s9 = hIn[9]; - const SWord8 s10 = hIn[10]; - const SWord8 s11 = hIn[11]; - const SWord8 s12 = hIn[12]; - const SWord8 s13 = hIn[13]; - const SWord8 s14 = hIn[14]; - const SWord8 s15 = hIn[15]; - const SWord8 s16 = hIn[16]; - const SWord8 s17 = hIn[17]; - const SWord8 s18 = hIn[18]; - const SWord8 s19 = hIn[19]; - const SWord8 s20 = hIn[20]; - const SWord8 s21 = hIn[21]; - const SWord8 s22 = hIn[22]; - const SWord8 s23 = hIn[23]; - const SWord8 s24 = hIn[24]; - const SWord8 s25 = hIn[25]; - const SWord8 s26 = hIn[26]; - const SWord8 s27 = hIn[27]; - const SWord8 s28 = hIn[28]; - const SWord8 s29 = hIn[29]; - const SWord8 s30 = hIn[30]; - const SWord8 s31 = hIn[31]; - const SWord8 s32 = block[0]; - const SWord8 s33 = block[1]; - const SWord8 s34 = block[2]; - const SWord8 s35 = block[3]; - const SWord8 s36 = block[4]; - const SWord8 s37 = block[5]; - const SWord8 s38 = block[6]; - const SWord8 s39 = block[7]; - const SWord8 s40 = block[8]; - const SWord8 s41 = block[9]; - const SWord8 s42 = block[10]; - const SWord8 s43 = block[11]; - const SWord8 s44 = block[12]; - const SWord8 s45 = block[13]; - const SWord8 s46 = block[14]; - const SWord8 s47 = block[15]; - const SWord8 s48 = block[16]; - const SWord8 s49 = block[17]; - const SWord8 s50 = block[18]; - const SWord8 s51 = block[19]; - const SWord8 s52 = block[20]; - const SWord8 s53 = block[21]; - const SWord8 s54 = block[22]; - const SWord8 s55 = block[23]; - const SWord8 s56 = block[24]; - const SWord8 s57 = block[25]; - const SWord8 s58 = block[26]; - const SWord8 s59 = block[27]; - const SWord8 s60 = block[28]; - const SWord8 s61 = block[29]; - const SWord8 s62 = block[30]; - const SWord8 s63 = block[31]; - const SWord8 s64 = block[32]; - const SWord8 s65 = block[33]; - const SWord8 s66 = block[34]; - const SWord8 s67 = block[35]; - const SWord8 s68 = block[36]; - const SWord8 s69 = block[37]; - const SWord8 s70 = block[38]; - const SWord8 s71 = block[39]; - const SWord8 s72 = block[40]; - const SWord8 s73 = block[41]; - const SWord8 s74 = block[42]; - const SWord8 s75 = block[43]; - const SWord8 s76 = block[44]; - const SWord8 s77 = block[45]; - const SWord8 s78 = block[46]; - const SWord8 s79 = block[47]; - const SWord8 s80 = block[48]; - const SWord8 s81 = block[49]; - const SWord8 s82 = block[50]; - const SWord8 s83 = block[51]; - const SWord8 s84 = block[52]; - const SWord8 s85 = block[53]; - const SWord8 s86 = block[54]; - const SWord8 s87 = block[55]; - const SWord8 s88 = block[56]; - const SWord8 s89 = block[57]; - const SWord8 s90 = block[58]; - const SWord8 s91 = block[59]; - const SWord8 s92 = block[60]; - const SWord8 s93 = block[61]; - const SWord8 s94 = block[62]; - const SWord8 s95 = block[63]; - const SWord16 s96 = (((SWord16) s0) << 8) | ((SWord16) s1); - const SWord16 s97 = (((SWord16) s2) << 8) | ((SWord16) s3); - const SWord32 s98 = (((SWord32) s96) << 16) | ((SWord32) s97); - const SWord16 s99 = (((SWord16) s16) << 8) | ((SWord16) s17); - const SWord16 s100 = (((SWord16) s18) << 8) | ((SWord16) s19); - const SWord32 s101 = (((SWord32) s99) << 16) | ((SWord32) s100); - const SWord16 s102 = (((SWord16) s4) << 8) | ((SWord16) s5); - const SWord16 s103 = (((SWord16) s6) << 8) | ((SWord16) s7); - const SWord32 s104 = (((SWord32) s102) << 16) | ((SWord32) s103); - const SWord16 s105 = (((SWord16) s20) << 8) | ((SWord16) s21); - const SWord16 s106 = (((SWord16) s22) << 8) | ((SWord16) s23); - const SWord32 s107 = (((SWord32) s105) << 16) | ((SWord32) s106); - const SWord16 s108 = (((SWord16) s8) << 8) | ((SWord16) s9); - const SWord16 s109 = (((SWord16) s10) << 8) | ((SWord16) s11); - const SWord32 s110 = (((SWord32) s108) << 16) | ((SWord32) s109); - const SWord16 s111 = (((SWord16) s24) << 8) | ((SWord16) s25); - const SWord16 s112 = (((SWord16) s26) << 8) | ((SWord16) s27); - const SWord32 s113 = (((SWord32) s111) << 16) | ((SWord32) s112); - const SWord16 s114 = (((SWord16) s12) << 8) | ((SWord16) s13); - const SWord16 s115 = (((SWord16) s14) << 8) | ((SWord16) s15); - const SWord32 s116 = (((SWord32) s114) << 16) | ((SWord32) s115); - const SWord16 s117 = (((SWord16) s28) << 8) | ((SWord16) s29); - const SWord16 s118 = (((SWord16) s30) << 8) | ((SWord16) s31); - const SWord32 s119 = (((SWord32) s117) << 16) | ((SWord32) s118); - const SWord32 s120 = (s101 >> 6) | (s101 << 26); - const SWord32 s121 = (s101 >> 11) | (s101 << 21); - const SWord32 s122 = s120 ^ s121; - const SWord32 s123 = (s101 >> 25) | (s101 << 7); - const SWord32 s124 = s122 ^ s123; - const SWord32 s125 = s119 + s124; - const SWord32 s126 = s101 & s107; - const SWord32 s127 = ~s101; - const SWord32 s128 = s113 & s127; - const SWord32 s129 = s126 ^ s128; - const SWord32 s130 = s125 + s129; - const SWord32 s132 = s130 + 0x428a2f98UL; - const SWord16 s133 = (((SWord16) s32) << 8) | ((SWord16) s33); - const SWord16 s134 = (((SWord16) s34) << 8) | ((SWord16) s35); - const SWord32 s135 = (((SWord32) s133) << 16) | ((SWord32) s134); - const SWord32 s136 = s132 + s135; - const SWord32 s137 = s116 + s136; - const SWord32 s138 = (s137 >> 6) | (s137 << 26); - const SWord32 s139 = (s137 >> 11) | (s137 << 21); - const SWord32 s140 = s138 ^ s139; - const SWord32 s141 = (s137 >> 25) | (s137 << 7); - const SWord32 s142 = s140 ^ s141; - const SWord32 s143 = s113 + s142; - const SWord32 s144 = s101 & s137; - const SWord32 s145 = ~s137; - const SWord32 s146 = s107 & s145; - const SWord32 s147 = s144 ^ s146; - const SWord32 s148 = s143 + s147; - const SWord32 s150 = s148 + 0x71374491UL; - const SWord16 s151 = (((SWord16) s36) << 8) | ((SWord16) s37); - const SWord16 s152 = (((SWord16) s38) << 8) | ((SWord16) s39); - const SWord32 s153 = (((SWord32) s151) << 16) | ((SWord32) s152); - const SWord32 s154 = s150 + s153; - const SWord32 s155 = s110 + s154; - const SWord32 s156 = (s155 >> 6) | (s155 << 26); - const SWord32 s157 = (s155 >> 11) | (s155 << 21); - const SWord32 s158 = s156 ^ s157; - const SWord32 s159 = (s155 >> 25) | (s155 << 7); - const SWord32 s160 = s158 ^ s159; - const SWord32 s161 = s107 + s160; - const SWord32 s162 = s137 & s155; - const SWord32 s163 = ~s155; - const SWord32 s164 = s101 & s163; - const SWord32 s165 = s162 ^ s164; - const SWord32 s166 = s161 + s165; - const SWord32 s168 = s166 + 0xb5c0fbcfUL; - const SWord16 s169 = (((SWord16) s40) << 8) | ((SWord16) s41); - const SWord16 s170 = (((SWord16) s42) << 8) | ((SWord16) s43); - const SWord32 s171 = (((SWord32) s169) << 16) | ((SWord32) s170); - const SWord32 s172 = s168 + s171; - const SWord32 s173 = s104 + s172; - const SWord32 s174 = (s173 >> 6) | (s173 << 26); - const SWord32 s175 = (s173 >> 11) | (s173 << 21); - const SWord32 s176 = s174 ^ s175; - const SWord32 s177 = (s173 >> 25) | (s173 << 7); - const SWord32 s178 = s176 ^ s177; - const SWord32 s179 = s101 + s178; - const SWord32 s180 = s155 & s173; - const SWord32 s181 = ~s173; - const SWord32 s182 = s137 & s181; - const SWord32 s183 = s180 ^ s182; - const SWord32 s184 = s179 + s183; - const SWord32 s186 = s184 + 0xe9b5dba5UL; - const SWord16 s187 = (((SWord16) s44) << 8) | ((SWord16) s45); - const SWord16 s188 = (((SWord16) s46) << 8) | ((SWord16) s47); - const SWord32 s189 = (((SWord32) s187) << 16) | ((SWord32) s188); - const SWord32 s190 = s186 + s189; - const SWord32 s191 = s98 + s190; - const SWord32 s192 = (s98 >> 2) | (s98 << 30); - const SWord32 s193 = (s98 >> 13) | (s98 << 19); - const SWord32 s194 = s192 ^ s193; - const SWord32 s195 = (s98 >> 22) | (s98 << 10); - const SWord32 s196 = s194 ^ s195; - const SWord32 s197 = s98 & s104; - const SWord32 s198 = s98 & s110; - const SWord32 s199 = s197 ^ s198; - const SWord32 s200 = s104 & s110; - const SWord32 s201 = s199 ^ s200; - const SWord32 s202 = s196 + s201; - const SWord32 s203 = s136 + s202; - const SWord32 s204 = (s203 >> 2) | (s203 << 30); - const SWord32 s205 = (s203 >> 13) | (s203 << 19); - const SWord32 s206 = s204 ^ s205; - const SWord32 s207 = (s203 >> 22) | (s203 << 10); - const SWord32 s208 = s206 ^ s207; - const SWord32 s209 = s98 & s203; - const SWord32 s210 = s104 & s203; - const SWord32 s211 = s209 ^ s210; - const SWord32 s212 = s197 ^ s211; - const SWord32 s213 = s208 + s212; - const SWord32 s214 = s154 + s213; - const SWord32 s215 = (s214 >> 2) | (s214 << 30); - const SWord32 s216 = (s214 >> 13) | (s214 << 19); - const SWord32 s217 = s215 ^ s216; - const SWord32 s218 = (s214 >> 22) | (s214 << 10); - const SWord32 s219 = s217 ^ s218; - const SWord32 s220 = s203 & s214; - const SWord32 s221 = s98 & s214; - const SWord32 s222 = s220 ^ s221; - const SWord32 s223 = s209 ^ s222; - const SWord32 s224 = s219 + s223; - const SWord32 s225 = s172 + s224; - const SWord32 s226 = (s191 >> 6) | (s191 << 26); - const SWord32 s227 = (s191 >> 11) | (s191 << 21); - const SWord32 s228 = s226 ^ s227; - const SWord32 s229 = (s191 >> 25) | (s191 << 7); - const SWord32 s230 = s228 ^ s229; - const SWord32 s231 = s137 + s230; - const SWord32 s232 = s173 & s191; - const SWord32 s233 = ~s191; - const SWord32 s234 = s155 & s233; - const SWord32 s235 = s232 ^ s234; - const SWord32 s236 = s231 + s235; - const SWord32 s238 = s236 + 0x3956c25bUL; - const SWord16 s239 = (((SWord16) s48) << 8) | ((SWord16) s49); - const SWord16 s240 = (((SWord16) s50) << 8) | ((SWord16) s51); - const SWord32 s241 = (((SWord32) s239) << 16) | ((SWord32) s240); - const SWord32 s242 = s238 + s241; - const SWord32 s243 = s203 + s242; - const SWord32 s244 = (s243 >> 6) | (s243 << 26); - const SWord32 s245 = (s243 >> 11) | (s243 << 21); - const SWord32 s246 = s244 ^ s245; - const SWord32 s247 = (s243 >> 25) | (s243 << 7); - const SWord32 s248 = s246 ^ s247; - const SWord32 s249 = s155 + s248; - const SWord32 s250 = s191 & s243; - const SWord32 s251 = ~s243; - const SWord32 s252 = s173 & s251; - const SWord32 s253 = s250 ^ s252; - const SWord32 s254 = s249 + s253; - const SWord32 s256 = s254 + 0x59f111f1UL; - const SWord16 s257 = (((SWord16) s52) << 8) | ((SWord16) s53); - const SWord16 s258 = (((SWord16) s54) << 8) | ((SWord16) s55); - const SWord32 s259 = (((SWord32) s257) << 16) | ((SWord32) s258); - const SWord32 s260 = s256 + s259; - const SWord32 s261 = s214 + s260; - const SWord32 s262 = (s261 >> 6) | (s261 << 26); - const SWord32 s263 = (s261 >> 11) | (s261 << 21); - const SWord32 s264 = s262 ^ s263; - const SWord32 s265 = (s261 >> 25) | (s261 << 7); - const SWord32 s266 = s264 ^ s265; - const SWord32 s267 = s173 + s266; - const SWord32 s268 = s243 & s261; - const SWord32 s269 = ~s261; - const SWord32 s270 = s191 & s269; - const SWord32 s271 = s268 ^ s270; - const SWord32 s272 = s267 + s271; - const SWord32 s274 = s272 + 0x923f82a4UL; - const SWord16 s275 = (((SWord16) s56) << 8) | ((SWord16) s57); - const SWord16 s276 = (((SWord16) s58) << 8) | ((SWord16) s59); - const SWord32 s277 = (((SWord32) s275) << 16) | ((SWord32) s276); - const SWord32 s278 = s274 + s277; - const SWord32 s279 = s225 + s278; - const SWord32 s280 = (s279 >> 6) | (s279 << 26); - const SWord32 s281 = (s279 >> 11) | (s279 << 21); - const SWord32 s282 = s280 ^ s281; - const SWord32 s283 = (s279 >> 25) | (s279 << 7); - const SWord32 s284 = s282 ^ s283; - const SWord32 s285 = s191 + s284; - const SWord32 s286 = s261 & s279; - const SWord32 s287 = ~s279; - const SWord32 s288 = s243 & s287; - const SWord32 s289 = s286 ^ s288; - const SWord32 s290 = s285 + s289; - const SWord32 s292 = s290 + 0xab1c5ed5UL; - const SWord16 s293 = (((SWord16) s60) << 8) | ((SWord16) s61); - const SWord16 s294 = (((SWord16) s62) << 8) | ((SWord16) s63); - const SWord32 s295 = (((SWord32) s293) << 16) | ((SWord32) s294); - const SWord32 s296 = s292 + s295; - const SWord32 s297 = (s225 >> 2) | (s225 << 30); - const SWord32 s298 = (s225 >> 13) | (s225 << 19); - const SWord32 s299 = s297 ^ s298; - const SWord32 s300 = (s225 >> 22) | (s225 << 10); - const SWord32 s301 = s299 ^ s300; - const SWord32 s302 = s214 & s225; - const SWord32 s303 = s203 & s225; - const SWord32 s304 = s302 ^ s303; - const SWord32 s305 = s220 ^ s304; - const SWord32 s306 = s301 + s305; - const SWord32 s307 = s190 + s306; - const SWord32 s308 = (s307 >> 2) | (s307 << 30); - const SWord32 s309 = (s307 >> 13) | (s307 << 19); - const SWord32 s310 = s308 ^ s309; - const SWord32 s311 = (s307 >> 22) | (s307 << 10); - const SWord32 s312 = s310 ^ s311; - const SWord32 s313 = s225 & s307; - const SWord32 s314 = s214 & s307; - const SWord32 s315 = s313 ^ s314; - const SWord32 s316 = s302 ^ s315; - const SWord32 s317 = s312 + s316; - const SWord32 s318 = s242 + s317; - const SWord32 s319 = (s318 >> 2) | (s318 << 30); - const SWord32 s320 = (s318 >> 13) | (s318 << 19); - const SWord32 s321 = s319 ^ s320; - const SWord32 s322 = (s318 >> 22) | (s318 << 10); - const SWord32 s323 = s321 ^ s322; - const SWord32 s324 = s307 & s318; - const SWord32 s325 = s225 & s318; - const SWord32 s326 = s324 ^ s325; - const SWord32 s327 = s313 ^ s326; - const SWord32 s328 = s323 + s327; - const SWord32 s329 = s260 + s328; - const SWord32 s330 = (s329 >> 2) | (s329 << 30); - const SWord32 s331 = (s329 >> 13) | (s329 << 19); - const SWord32 s332 = s330 ^ s331; - const SWord32 s333 = (s329 >> 22) | (s329 << 10); - const SWord32 s334 = s332 ^ s333; - const SWord32 s335 = s318 & s329; - const SWord32 s336 = s307 & s329; - const SWord32 s337 = s335 ^ s336; - const SWord32 s338 = s324 ^ s337; - const SWord32 s339 = s334 + s338; - const SWord32 s340 = s278 + s339; - const SWord32 s341 = (s340 >> 2) | (s340 << 30); - const SWord32 s342 = (s340 >> 13) | (s340 << 19); - const SWord32 s343 = s341 ^ s342; - const SWord32 s344 = (s340 >> 22) | (s340 << 10); - const SWord32 s345 = s343 ^ s344; - const SWord32 s346 = s329 & s340; - const SWord32 s347 = s318 & s340; - const SWord32 s348 = s346 ^ s347; - const SWord32 s349 = s335 ^ s348; - const SWord32 s350 = s345 + s349; - const SWord32 s351 = s296 + s350; - const SWord32 s352 = s296 + s307; - const SWord32 s353 = (s352 >> 6) | (s352 << 26); - const SWord32 s354 = (s352 >> 11) | (s352 << 21); - const SWord32 s355 = s353 ^ s354; - const SWord32 s356 = (s352 >> 25) | (s352 << 7); - const SWord32 s357 = s355 ^ s356; - const SWord32 s358 = s243 + s357; - const SWord32 s359 = s279 & s352; - const SWord32 s360 = ~s352; - const SWord32 s361 = s261 & s360; - const SWord32 s362 = s359 ^ s361; - const SWord32 s363 = s358 + s362; - const SWord32 s365 = s363 + 0xd807aa98UL; - const SWord16 s366 = (((SWord16) s64) << 8) | ((SWord16) s65); - const SWord16 s367 = (((SWord16) s66) << 8) | ((SWord16) s67); - const SWord32 s368 = (((SWord32) s366) << 16) | ((SWord32) s367); - const SWord32 s369 = s365 + s368; - const SWord32 s370 = s318 + s369; - const SWord32 s371 = (s370 >> 6) | (s370 << 26); - const SWord32 s372 = (s370 >> 11) | (s370 << 21); - const SWord32 s373 = s371 ^ s372; - const SWord32 s374 = (s370 >> 25) | (s370 << 7); - const SWord32 s375 = s373 ^ s374; - const SWord32 s376 = s261 + s375; - const SWord32 s377 = s352 & s370; - const SWord32 s378 = ~s370; - const SWord32 s379 = s279 & s378; - const SWord32 s380 = s377 ^ s379; - const SWord32 s381 = s376 + s380; - const SWord32 s383 = s381 + 0x12835b01UL; - const SWord16 s384 = (((SWord16) s68) << 8) | ((SWord16) s69); - const SWord16 s385 = (((SWord16) s70) << 8) | ((SWord16) s71); - const SWord32 s386 = (((SWord32) s384) << 16) | ((SWord32) s385); - const SWord32 s387 = s383 + s386; - const SWord32 s388 = s329 + s387; - const SWord32 s389 = (s388 >> 6) | (s388 << 26); - const SWord32 s390 = (s388 >> 11) | (s388 << 21); - const SWord32 s391 = s389 ^ s390; - const SWord32 s392 = (s388 >> 25) | (s388 << 7); - const SWord32 s393 = s391 ^ s392; - const SWord32 s394 = s279 + s393; - const SWord32 s395 = s370 & s388; - const SWord32 s396 = ~s388; - const SWord32 s397 = s352 & s396; - const SWord32 s398 = s395 ^ s397; - const SWord32 s399 = s394 + s398; - const SWord32 s401 = s399 + 0x243185beUL; - const SWord16 s402 = (((SWord16) s72) << 8) | ((SWord16) s73); - const SWord16 s403 = (((SWord16) s74) << 8) | ((SWord16) s75); - const SWord32 s404 = (((SWord32) s402) << 16) | ((SWord32) s403); - const SWord32 s405 = s401 + s404; - const SWord32 s406 = s340 + s405; - const SWord32 s407 = (s406 >> 6) | (s406 << 26); - const SWord32 s408 = (s406 >> 11) | (s406 << 21); - const SWord32 s409 = s407 ^ s408; - const SWord32 s410 = (s406 >> 25) | (s406 << 7); - const SWord32 s411 = s409 ^ s410; - const SWord32 s412 = s352 + s411; - const SWord32 s413 = s388 & s406; - const SWord32 s414 = ~s406; - const SWord32 s415 = s370 & s414; - const SWord32 s416 = s413 ^ s415; - const SWord32 s417 = s412 + s416; - const SWord32 s419 = s417 + 0x550c7dc3UL; - const SWord16 s420 = (((SWord16) s76) << 8) | ((SWord16) s77); - const SWord16 s421 = (((SWord16) s78) << 8) | ((SWord16) s79); - const SWord32 s422 = (((SWord32) s420) << 16) | ((SWord32) s421); - const SWord32 s423 = s419 + s422; - const SWord32 s424 = s351 + s423; - const SWord32 s425 = (s351 >> 2) | (s351 << 30); - const SWord32 s426 = (s351 >> 13) | (s351 << 19); - const SWord32 s427 = s425 ^ s426; - const SWord32 s428 = (s351 >> 22) | (s351 << 10); - const SWord32 s429 = s427 ^ s428; - const SWord32 s430 = s340 & s351; - const SWord32 s431 = s329 & s351; - const SWord32 s432 = s430 ^ s431; - const SWord32 s433 = s346 ^ s432; - const SWord32 s434 = s429 + s433; - const SWord32 s435 = s369 + s434; - const SWord32 s436 = (s435 >> 2) | (s435 << 30); - const SWord32 s437 = (s435 >> 13) | (s435 << 19); - const SWord32 s438 = s436 ^ s437; - const SWord32 s439 = (s435 >> 22) | (s435 << 10); - const SWord32 s440 = s438 ^ s439; - const SWord32 s441 = s351 & s435; - const SWord32 s442 = s340 & s435; - const SWord32 s443 = s441 ^ s442; - const SWord32 s444 = s430 ^ s443; - const SWord32 s445 = s440 + s444; - const SWord32 s446 = s387 + s445; - const SWord32 s447 = (s446 >> 2) | (s446 << 30); - const SWord32 s448 = (s446 >> 13) | (s446 << 19); - const SWord32 s449 = s447 ^ s448; - const SWord32 s450 = (s446 >> 22) | (s446 << 10); - const SWord32 s451 = s449 ^ s450; - const SWord32 s452 = s435 & s446; - const SWord32 s453 = s351 & s446; - const SWord32 s454 = s452 ^ s453; - const SWord32 s455 = s441 ^ s454; - const SWord32 s456 = s451 + s455; - const SWord32 s457 = s405 + s456; - const SWord32 s458 = (s424 >> 6) | (s424 << 26); - const SWord32 s459 = (s424 >> 11) | (s424 << 21); - const SWord32 s460 = s458 ^ s459; - const SWord32 s461 = (s424 >> 25) | (s424 << 7); - const SWord32 s462 = s460 ^ s461; - const SWord32 s463 = s370 + s462; - const SWord32 s464 = s406 & s424; - const SWord32 s465 = ~s424; - const SWord32 s466 = s388 & s465; - const SWord32 s467 = s464 ^ s466; - const SWord32 s468 = s463 + s467; - const SWord32 s470 = s468 + 0x72be5d74UL; - const SWord16 s471 = (((SWord16) s80) << 8) | ((SWord16) s81); - const SWord16 s472 = (((SWord16) s82) << 8) | ((SWord16) s83); - const SWord32 s473 = (((SWord32) s471) << 16) | ((SWord32) s472); - const SWord32 s474 = s470 + s473; - const SWord32 s475 = s435 + s474; - const SWord32 s476 = (s475 >> 6) | (s475 << 26); - const SWord32 s477 = (s475 >> 11) | (s475 << 21); - const SWord32 s478 = s476 ^ s477; - const SWord32 s479 = (s475 >> 25) | (s475 << 7); - const SWord32 s480 = s478 ^ s479; - const SWord32 s481 = s388 + s480; - const SWord32 s482 = s424 & s475; - const SWord32 s483 = ~s475; - const SWord32 s484 = s406 & s483; - const SWord32 s485 = s482 ^ s484; - const SWord32 s486 = s481 + s485; - const SWord32 s488 = s486 + 0x80deb1feUL; - const SWord16 s489 = (((SWord16) s84) << 8) | ((SWord16) s85); - const SWord16 s490 = (((SWord16) s86) << 8) | ((SWord16) s87); - const SWord32 s491 = (((SWord32) s489) << 16) | ((SWord32) s490); - const SWord32 s492 = s488 + s491; - const SWord32 s493 = s446 + s492; - const SWord32 s494 = (s493 >> 6) | (s493 << 26); - const SWord32 s495 = (s493 >> 11) | (s493 << 21); - const SWord32 s496 = s494 ^ s495; - const SWord32 s497 = (s493 >> 25) | (s493 << 7); - const SWord32 s498 = s496 ^ s497; - const SWord32 s499 = s406 + s498; - const SWord32 s500 = s475 & s493; - const SWord32 s501 = ~s493; - const SWord32 s502 = s424 & s501; - const SWord32 s503 = s500 ^ s502; - const SWord32 s504 = s499 + s503; - const SWord32 s506 = s504 + 0x9bdc06a7UL; - const SWord16 s507 = (((SWord16) s88) << 8) | ((SWord16) s89); - const SWord16 s508 = (((SWord16) s90) << 8) | ((SWord16) s91); - const SWord32 s509 = (((SWord32) s507) << 16) | ((SWord32) s508); - const SWord32 s510 = s506 + s509; - const SWord32 s511 = s457 + s510; - const SWord32 s512 = (s511 >> 6) | (s511 << 26); - const SWord32 s513 = (s511 >> 11) | (s511 << 21); - const SWord32 s514 = s512 ^ s513; - const SWord32 s515 = (s511 >> 25) | (s511 << 7); - const SWord32 s516 = s514 ^ s515; - const SWord32 s517 = s424 + s516; - const SWord32 s518 = s493 & s511; - const SWord32 s519 = ~s511; - const SWord32 s520 = s475 & s519; - const SWord32 s521 = s518 ^ s520; - const SWord32 s522 = s517 + s521; - const SWord32 s524 = s522 + 0xc19bf174UL; - const SWord16 s525 = (((SWord16) s92) << 8) | ((SWord16) s93); - const SWord16 s526 = (((SWord16) s94) << 8) | ((SWord16) s95); - const SWord32 s527 = (((SWord32) s525) << 16) | ((SWord32) s526); - const SWord32 s528 = s524 + s527; - const SWord32 s529 = (s457 >> 2) | (s457 << 30); - const SWord32 s530 = (s457 >> 13) | (s457 << 19); - const SWord32 s531 = s529 ^ s530; - const SWord32 s532 = (s457 >> 22) | (s457 << 10); - const SWord32 s533 = s531 ^ s532; - const SWord32 s534 = s446 & s457; - const SWord32 s535 = s435 & s457; - const SWord32 s536 = s534 ^ s535; - const SWord32 s537 = s452 ^ s536; - const SWord32 s538 = s533 + s537; - const SWord32 s539 = s423 + s538; - const SWord32 s540 = (s539 >> 2) | (s539 << 30); - const SWord32 s541 = (s539 >> 13) | (s539 << 19); - const SWord32 s542 = s540 ^ s541; - const SWord32 s543 = (s539 >> 22) | (s539 << 10); - const SWord32 s544 = s542 ^ s543; - const SWord32 s545 = s457 & s539; - const SWord32 s546 = s446 & s539; - const SWord32 s547 = s545 ^ s546; - const SWord32 s548 = s534 ^ s547; - const SWord32 s549 = s544 + s548; - const SWord32 s550 = s474 + s549; - const SWord32 s551 = (s550 >> 2) | (s550 << 30); - const SWord32 s552 = (s550 >> 13) | (s550 << 19); - const SWord32 s553 = s551 ^ s552; - const SWord32 s554 = (s550 >> 22) | (s550 << 10); - const SWord32 s555 = s553 ^ s554; - const SWord32 s556 = s539 & s550; - const SWord32 s557 = s457 & s550; - const SWord32 s558 = s556 ^ s557; - const SWord32 s559 = s545 ^ s558; - const SWord32 s560 = s555 + s559; - const SWord32 s561 = s492 + s560; - const SWord32 s562 = (s561 >> 2) | (s561 << 30); - const SWord32 s563 = (s561 >> 13) | (s561 << 19); - const SWord32 s564 = s562 ^ s563; - const SWord32 s565 = (s561 >> 22) | (s561 << 10); - const SWord32 s566 = s564 ^ s565; - const SWord32 s567 = s550 & s561; - const SWord32 s568 = s539 & s561; - const SWord32 s569 = s567 ^ s568; - const SWord32 s570 = s556 ^ s569; - const SWord32 s571 = s566 + s570; - const SWord32 s572 = s510 + s571; - const SWord32 s573 = (s572 >> 2) | (s572 << 30); - const SWord32 s574 = (s572 >> 13) | (s572 << 19); - const SWord32 s575 = s573 ^ s574; - const SWord32 s576 = (s572 >> 22) | (s572 << 10); - const SWord32 s577 = s575 ^ s576; - const SWord32 s578 = s561 & s572; - const SWord32 s579 = s550 & s572; - const SWord32 s580 = s578 ^ s579; - const SWord32 s581 = s567 ^ s580; - const SWord32 s582 = s577 + s581; - const SWord32 s583 = s528 + s582; - const SWord32 s584 = s528 + s539; - const SWord32 s585 = (s584 >> 6) | (s584 << 26); - const SWord32 s586 = (s584 >> 11) | (s584 << 21); - const SWord32 s587 = s585 ^ s586; - const SWord32 s588 = (s584 >> 25) | (s584 << 7); - const SWord32 s589 = s587 ^ s588; - const SWord32 s590 = s475 + s589; - const SWord32 s591 = s511 & s584; - const SWord32 s592 = ~s584; - const SWord32 s593 = s493 & s592; - const SWord32 s594 = s591 ^ s593; - const SWord32 s595 = s590 + s594; - const SWord32 s597 = s595 + 0xe49b69c1UL; - const SWord32 s598 = (s509 >> 17) | (s509 << 15); - const SWord32 s599 = (s509 >> 19) | (s509 << 13); - const SWord32 s600 = s598 ^ s599; - const SWord32 s602 = s509 >> 10; - const SWord32 s603 = s600 ^ s602; - const SWord32 s604 = s386 + s603; - const SWord32 s605 = (s153 >> 7) | (s153 << 25); - const SWord32 s606 = (s153 >> 18) | (s153 << 14); - const SWord32 s607 = s605 ^ s606; - const SWord32 s609 = s153 >> 3; - const SWord32 s610 = s607 ^ s609; - const SWord32 s611 = s604 + s610; - const SWord32 s612 = s135 + s611; - const SWord32 s613 = s597 + s612; - const SWord32 s614 = s550 + s613; - const SWord32 s615 = (s614 >> 6) | (s614 << 26); - const SWord32 s616 = (s614 >> 11) | (s614 << 21); - const SWord32 s617 = s615 ^ s616; - const SWord32 s618 = (s614 >> 25) | (s614 << 7); - const SWord32 s619 = s617 ^ s618; - const SWord32 s620 = s493 + s619; - const SWord32 s621 = s584 & s614; - const SWord32 s622 = ~s614; - const SWord32 s623 = s511 & s622; - const SWord32 s624 = s621 ^ s623; - const SWord32 s625 = s620 + s624; - const SWord32 s627 = s625 + 0xefbe4786UL; - const SWord32 s628 = (s527 >> 17) | (s527 << 15); - const SWord32 s629 = (s527 >> 19) | (s527 << 13); - const SWord32 s630 = s628 ^ s629; - const SWord32 s631 = s527 >> 10; - const SWord32 s632 = s630 ^ s631; - const SWord32 s633 = s404 + s632; - const SWord32 s634 = (s171 >> 7) | (s171 << 25); - const SWord32 s635 = (s171 >> 18) | (s171 << 14); - const SWord32 s636 = s634 ^ s635; - const SWord32 s637 = s171 >> 3; - const SWord32 s638 = s636 ^ s637; - const SWord32 s639 = s633 + s638; - const SWord32 s640 = s153 + s639; - const SWord32 s641 = s627 + s640; - const SWord32 s642 = s561 + s641; - const SWord32 s643 = (s642 >> 6) | (s642 << 26); - const SWord32 s644 = (s642 >> 11) | (s642 << 21); - const SWord32 s645 = s643 ^ s644; - const SWord32 s646 = (s642 >> 25) | (s642 << 7); - const SWord32 s647 = s645 ^ s646; - const SWord32 s648 = s511 + s647; - const SWord32 s649 = s614 & s642; - const SWord32 s650 = ~s642; - const SWord32 s651 = s584 & s650; - const SWord32 s652 = s649 ^ s651; - const SWord32 s653 = s648 + s652; - const SWord32 s655 = s653 + 0x0fc19dc6UL; - const SWord32 s656 = (s612 >> 17) | (s612 << 15); - const SWord32 s657 = (s612 >> 19) | (s612 << 13); - const SWord32 s658 = s656 ^ s657; - const SWord32 s659 = s612 >> 10; - const SWord32 s660 = s658 ^ s659; - const SWord32 s661 = s422 + s660; - const SWord32 s662 = (s189 >> 7) | (s189 << 25); - const SWord32 s663 = (s189 >> 18) | (s189 << 14); - const SWord32 s664 = s662 ^ s663; - const SWord32 s665 = s189 >> 3; - const SWord32 s666 = s664 ^ s665; - const SWord32 s667 = s661 + s666; - const SWord32 s668 = s171 + s667; - const SWord32 s669 = s655 + s668; - const SWord32 s670 = s572 + s669; - const SWord32 s671 = (s670 >> 6) | (s670 << 26); - const SWord32 s672 = (s670 >> 11) | (s670 << 21); - const SWord32 s673 = s671 ^ s672; - const SWord32 s674 = (s670 >> 25) | (s670 << 7); - const SWord32 s675 = s673 ^ s674; - const SWord32 s676 = s584 + s675; - const SWord32 s677 = s642 & s670; - const SWord32 s678 = ~s670; - const SWord32 s679 = s614 & s678; - const SWord32 s680 = s677 ^ s679; - const SWord32 s681 = s676 + s680; - const SWord32 s683 = s681 + 0x240ca1ccUL; - const SWord32 s684 = (s640 >> 17) | (s640 << 15); - const SWord32 s685 = (s640 >> 19) | (s640 << 13); - const SWord32 s686 = s684 ^ s685; - const SWord32 s687 = s640 >> 10; - const SWord32 s688 = s686 ^ s687; - const SWord32 s689 = s473 + s688; - const SWord32 s690 = (s241 >> 7) | (s241 << 25); - const SWord32 s691 = (s241 >> 18) | (s241 << 14); - const SWord32 s692 = s690 ^ s691; - const SWord32 s693 = s241 >> 3; - const SWord32 s694 = s692 ^ s693; - const SWord32 s695 = s689 + s694; - const SWord32 s696 = s189 + s695; - const SWord32 s697 = s683 + s696; - const SWord32 s698 = s583 + s697; - const SWord32 s699 = (s583 >> 2) | (s583 << 30); - const SWord32 s700 = (s583 >> 13) | (s583 << 19); - const SWord32 s701 = s699 ^ s700; - const SWord32 s702 = (s583 >> 22) | (s583 << 10); - const SWord32 s703 = s701 ^ s702; - const SWord32 s704 = s572 & s583; - const SWord32 s705 = s561 & s583; - const SWord32 s706 = s704 ^ s705; - const SWord32 s707 = s578 ^ s706; - const SWord32 s708 = s703 + s707; - const SWord32 s709 = s613 + s708; - const SWord32 s710 = (s709 >> 2) | (s709 << 30); - const SWord32 s711 = (s709 >> 13) | (s709 << 19); - const SWord32 s712 = s710 ^ s711; - const SWord32 s713 = (s709 >> 22) | (s709 << 10); - const SWord32 s714 = s712 ^ s713; - const SWord32 s715 = s583 & s709; - const SWord32 s716 = s572 & s709; - const SWord32 s717 = s715 ^ s716; - const SWord32 s718 = s704 ^ s717; - const SWord32 s719 = s714 + s718; - const SWord32 s720 = s641 + s719; - const SWord32 s721 = (s720 >> 2) | (s720 << 30); - const SWord32 s722 = (s720 >> 13) | (s720 << 19); - const SWord32 s723 = s721 ^ s722; - const SWord32 s724 = (s720 >> 22) | (s720 << 10); - const SWord32 s725 = s723 ^ s724; - const SWord32 s726 = s709 & s720; - const SWord32 s727 = s583 & s720; - const SWord32 s728 = s726 ^ s727; - const SWord32 s729 = s715 ^ s728; - const SWord32 s730 = s725 + s729; - const SWord32 s731 = s669 + s730; - const SWord32 s732 = (s698 >> 6) | (s698 << 26); - const SWord32 s733 = (s698 >> 11) | (s698 << 21); - const SWord32 s734 = s732 ^ s733; - const SWord32 s735 = (s698 >> 25) | (s698 << 7); - const SWord32 s736 = s734 ^ s735; - const SWord32 s737 = s614 + s736; - const SWord32 s738 = s670 & s698; - const SWord32 s739 = ~s698; - const SWord32 s740 = s642 & s739; - const SWord32 s741 = s738 ^ s740; - const SWord32 s742 = s737 + s741; - const SWord32 s744 = s742 + 0x2de92c6fUL; - const SWord32 s745 = (s668 >> 17) | (s668 << 15); - const SWord32 s746 = (s668 >> 19) | (s668 << 13); - const SWord32 s747 = s745 ^ s746; - const SWord32 s748 = s668 >> 10; - const SWord32 s749 = s747 ^ s748; - const SWord32 s750 = s491 + s749; - const SWord32 s751 = (s259 >> 7) | (s259 << 25); - const SWord32 s752 = (s259 >> 18) | (s259 << 14); - const SWord32 s753 = s751 ^ s752; - const SWord32 s754 = s259 >> 3; - const SWord32 s755 = s753 ^ s754; - const SWord32 s756 = s750 + s755; - const SWord32 s757 = s241 + s756; - const SWord32 s758 = s744 + s757; - const SWord32 s759 = s709 + s758; - const SWord32 s760 = (s759 >> 6) | (s759 << 26); - const SWord32 s761 = (s759 >> 11) | (s759 << 21); - const SWord32 s762 = s760 ^ s761; - const SWord32 s763 = (s759 >> 25) | (s759 << 7); - const SWord32 s764 = s762 ^ s763; - const SWord32 s765 = s642 + s764; - const SWord32 s766 = s698 & s759; - const SWord32 s767 = ~s759; - const SWord32 s768 = s670 & s767; - const SWord32 s769 = s766 ^ s768; - const SWord32 s770 = s765 + s769; - const SWord32 s772 = s770 + 0x4a7484aaUL; - const SWord32 s773 = (s696 >> 17) | (s696 << 15); - const SWord32 s774 = (s696 >> 19) | (s696 << 13); - const SWord32 s775 = s773 ^ s774; - const SWord32 s776 = s696 >> 10; - const SWord32 s777 = s775 ^ s776; - const SWord32 s778 = s509 + s777; - const SWord32 s779 = (s277 >> 7) | (s277 << 25); - const SWord32 s780 = (s277 >> 18) | (s277 << 14); - const SWord32 s781 = s779 ^ s780; - const SWord32 s782 = s277 >> 3; - const SWord32 s783 = s781 ^ s782; - const SWord32 s784 = s778 + s783; - const SWord32 s785 = s259 + s784; - const SWord32 s786 = s772 + s785; - const SWord32 s787 = s720 + s786; - const SWord32 s788 = (s787 >> 6) | (s787 << 26); - const SWord32 s789 = (s787 >> 11) | (s787 << 21); - const SWord32 s790 = s788 ^ s789; - const SWord32 s791 = (s787 >> 25) | (s787 << 7); - const SWord32 s792 = s790 ^ s791; - const SWord32 s793 = s670 + s792; - const SWord32 s794 = s759 & s787; - const SWord32 s795 = ~s787; - const SWord32 s796 = s698 & s795; - const SWord32 s797 = s794 ^ s796; - const SWord32 s798 = s793 + s797; - const SWord32 s800 = s798 + 0x5cb0a9dcUL; - const SWord32 s801 = (s757 >> 17) | (s757 << 15); - const SWord32 s802 = (s757 >> 19) | (s757 << 13); - const SWord32 s803 = s801 ^ s802; - const SWord32 s804 = s757 >> 10; - const SWord32 s805 = s803 ^ s804; - const SWord32 s806 = s527 + s805; - const SWord32 s807 = (s295 >> 7) | (s295 << 25); - const SWord32 s808 = (s295 >> 18) | (s295 << 14); - const SWord32 s809 = s807 ^ s808; - const SWord32 s810 = s295 >> 3; - const SWord32 s811 = s809 ^ s810; - const SWord32 s812 = s806 + s811; - const SWord32 s813 = s277 + s812; - const SWord32 s814 = s800 + s813; - const SWord32 s815 = s731 + s814; - const SWord32 s816 = (s815 >> 6) | (s815 << 26); - const SWord32 s817 = (s815 >> 11) | (s815 << 21); - const SWord32 s818 = s816 ^ s817; - const SWord32 s819 = (s815 >> 25) | (s815 << 7); - const SWord32 s820 = s818 ^ s819; - const SWord32 s821 = s698 + s820; - const SWord32 s822 = s787 & s815; - const SWord32 s823 = ~s815; - const SWord32 s824 = s759 & s823; - const SWord32 s825 = s822 ^ s824; - const SWord32 s826 = s821 + s825; - const SWord32 s828 = s826 + 0x76f988daUL; - const SWord32 s829 = (s785 >> 17) | (s785 << 15); - const SWord32 s830 = (s785 >> 19) | (s785 << 13); - const SWord32 s831 = s829 ^ s830; - const SWord32 s832 = s785 >> 10; - const SWord32 s833 = s831 ^ s832; - const SWord32 s834 = s612 + s833; - const SWord32 s835 = (s368 >> 7) | (s368 << 25); - const SWord32 s836 = (s368 >> 18) | (s368 << 14); - const SWord32 s837 = s835 ^ s836; - const SWord32 s838 = s368 >> 3; - const SWord32 s839 = s837 ^ s838; - const SWord32 s840 = s834 + s839; - const SWord32 s841 = s295 + s840; - const SWord32 s842 = s828 + s841; - const SWord32 s843 = (s731 >> 2) | (s731 << 30); - const SWord32 s844 = (s731 >> 13) | (s731 << 19); - const SWord32 s845 = s843 ^ s844; - const SWord32 s846 = (s731 >> 22) | (s731 << 10); - const SWord32 s847 = s845 ^ s846; - const SWord32 s848 = s720 & s731; - const SWord32 s849 = s709 & s731; - const SWord32 s850 = s848 ^ s849; - const SWord32 s851 = s726 ^ s850; - const SWord32 s852 = s847 + s851; - const SWord32 s853 = s697 + s852; - const SWord32 s854 = (s853 >> 2) | (s853 << 30); - const SWord32 s855 = (s853 >> 13) | (s853 << 19); - const SWord32 s856 = s854 ^ s855; - const SWord32 s857 = (s853 >> 22) | (s853 << 10); - const SWord32 s858 = s856 ^ s857; - const SWord32 s859 = s731 & s853; - const SWord32 s860 = s720 & s853; - const SWord32 s861 = s859 ^ s860; - const SWord32 s862 = s848 ^ s861; - const SWord32 s863 = s858 + s862; - const SWord32 s864 = s758 + s863; - const SWord32 s865 = (s864 >> 2) | (s864 << 30); - const SWord32 s866 = (s864 >> 13) | (s864 << 19); - const SWord32 s867 = s865 ^ s866; - const SWord32 s868 = (s864 >> 22) | (s864 << 10); - const SWord32 s869 = s867 ^ s868; - const SWord32 s870 = s853 & s864; - const SWord32 s871 = s731 & s864; - const SWord32 s872 = s870 ^ s871; - const SWord32 s873 = s859 ^ s872; - const SWord32 s874 = s869 + s873; - const SWord32 s875 = s786 + s874; - const SWord32 s876 = (s875 >> 2) | (s875 << 30); - const SWord32 s877 = (s875 >> 13) | (s875 << 19); - const SWord32 s878 = s876 ^ s877; - const SWord32 s879 = (s875 >> 22) | (s875 << 10); - const SWord32 s880 = s878 ^ s879; - const SWord32 s881 = s864 & s875; - const SWord32 s882 = s853 & s875; - const SWord32 s883 = s881 ^ s882; - const SWord32 s884 = s870 ^ s883; - const SWord32 s885 = s880 + s884; - const SWord32 s886 = s814 + s885; - const SWord32 s887 = (s886 >> 2) | (s886 << 30); - const SWord32 s888 = (s886 >> 13) | (s886 << 19); - const SWord32 s889 = s887 ^ s888; - const SWord32 s890 = (s886 >> 22) | (s886 << 10); - const SWord32 s891 = s889 ^ s890; - const SWord32 s892 = s875 & s886; - const SWord32 s893 = s864 & s886; - const SWord32 s894 = s892 ^ s893; - const SWord32 s895 = s881 ^ s894; - const SWord32 s896 = s891 + s895; - const SWord32 s897 = s842 + s896; - const SWord32 s898 = s842 + s853; - const SWord32 s899 = (s898 >> 6) | (s898 << 26); - const SWord32 s900 = (s898 >> 11) | (s898 << 21); - const SWord32 s901 = s899 ^ s900; - const SWord32 s902 = (s898 >> 25) | (s898 << 7); - const SWord32 s903 = s901 ^ s902; - const SWord32 s904 = s759 + s903; - const SWord32 s905 = s815 & s898; - const SWord32 s906 = ~s898; - const SWord32 s907 = s787 & s906; - const SWord32 s908 = s905 ^ s907; - const SWord32 s909 = s904 + s908; - const SWord32 s911 = s909 + 0x983e5152UL; - const SWord32 s912 = (s813 >> 17) | (s813 << 15); - const SWord32 s913 = (s813 >> 19) | (s813 << 13); - const SWord32 s914 = s912 ^ s913; - const SWord32 s915 = s813 >> 10; - const SWord32 s916 = s914 ^ s915; - const SWord32 s917 = s640 + s916; - const SWord32 s918 = (s386 >> 7) | (s386 << 25); - const SWord32 s919 = (s386 >> 18) | (s386 << 14); - const SWord32 s920 = s918 ^ s919; - const SWord32 s921 = s386 >> 3; - const SWord32 s922 = s920 ^ s921; - const SWord32 s923 = s917 + s922; - const SWord32 s924 = s368 + s923; - const SWord32 s925 = s911 + s924; - const SWord32 s926 = s864 + s925; - const SWord32 s927 = (s926 >> 6) | (s926 << 26); - const SWord32 s928 = (s926 >> 11) | (s926 << 21); - const SWord32 s929 = s927 ^ s928; - const SWord32 s930 = (s926 >> 25) | (s926 << 7); - const SWord32 s931 = s929 ^ s930; - const SWord32 s932 = s787 + s931; - const SWord32 s933 = s898 & s926; - const SWord32 s934 = ~s926; - const SWord32 s935 = s815 & s934; - const SWord32 s936 = s933 ^ s935; - const SWord32 s937 = s932 + s936; - const SWord32 s939 = s937 + 0xa831c66dUL; - const SWord32 s940 = (s841 >> 17) | (s841 << 15); - const SWord32 s941 = (s841 >> 19) | (s841 << 13); - const SWord32 s942 = s940 ^ s941; - const SWord32 s943 = s841 >> 10; - const SWord32 s944 = s942 ^ s943; - const SWord32 s945 = s668 + s944; - const SWord32 s946 = (s404 >> 7) | (s404 << 25); - const SWord32 s947 = (s404 >> 18) | (s404 << 14); - const SWord32 s948 = s946 ^ s947; - const SWord32 s949 = s404 >> 3; - const SWord32 s950 = s948 ^ s949; - const SWord32 s951 = s945 + s950; - const SWord32 s952 = s386 + s951; - const SWord32 s953 = s939 + s952; - const SWord32 s954 = s875 + s953; - const SWord32 s955 = (s954 >> 6) | (s954 << 26); - const SWord32 s956 = (s954 >> 11) | (s954 << 21); - const SWord32 s957 = s955 ^ s956; - const SWord32 s958 = (s954 >> 25) | (s954 << 7); - const SWord32 s959 = s957 ^ s958; - const SWord32 s960 = s815 + s959; - const SWord32 s961 = s926 & s954; - const SWord32 s962 = ~s954; - const SWord32 s963 = s898 & s962; - const SWord32 s964 = s961 ^ s963; - const SWord32 s965 = s960 + s964; - const SWord32 s967 = s965 + 0xb00327c8UL; - const SWord32 s968 = (s924 >> 17) | (s924 << 15); - const SWord32 s969 = (s924 >> 19) | (s924 << 13); - const SWord32 s970 = s968 ^ s969; - const SWord32 s971 = s924 >> 10; - const SWord32 s972 = s970 ^ s971; - const SWord32 s973 = s696 + s972; - const SWord32 s974 = (s422 >> 7) | (s422 << 25); - const SWord32 s975 = (s422 >> 18) | (s422 << 14); - const SWord32 s976 = s974 ^ s975; - const SWord32 s977 = s422 >> 3; - const SWord32 s978 = s976 ^ s977; - const SWord32 s979 = s973 + s978; - const SWord32 s980 = s404 + s979; - const SWord32 s981 = s967 + s980; - const SWord32 s982 = s886 + s981; - const SWord32 s983 = (s982 >> 6) | (s982 << 26); - const SWord32 s984 = (s982 >> 11) | (s982 << 21); - const SWord32 s985 = s983 ^ s984; - const SWord32 s986 = (s982 >> 25) | (s982 << 7); - const SWord32 s987 = s985 ^ s986; - const SWord32 s988 = s898 + s987; - const SWord32 s989 = s954 & s982; - const SWord32 s990 = ~s982; - const SWord32 s991 = s926 & s990; - const SWord32 s992 = s989 ^ s991; - const SWord32 s993 = s988 + s992; - const SWord32 s995 = s993 + 0xbf597fc7UL; - const SWord32 s996 = (s952 >> 17) | (s952 << 15); - const SWord32 s997 = (s952 >> 19) | (s952 << 13); - const SWord32 s998 = s996 ^ s997; - const SWord32 s999 = s952 >> 10; - const SWord32 s1000 = s998 ^ s999; - const SWord32 s1001 = s757 + s1000; - const SWord32 s1002 = (s473 >> 7) | (s473 << 25); - const SWord32 s1003 = (s473 >> 18) | (s473 << 14); - const SWord32 s1004 = s1002 ^ s1003; - const SWord32 s1005 = s473 >> 3; - const SWord32 s1006 = s1004 ^ s1005; - const SWord32 s1007 = s1001 + s1006; - const SWord32 s1008 = s422 + s1007; - const SWord32 s1009 = s995 + s1008; - const SWord32 s1010 = s897 + s1009; - const SWord32 s1011 = (s897 >> 2) | (s897 << 30); - const SWord32 s1012 = (s897 >> 13) | (s897 << 19); - const SWord32 s1013 = s1011 ^ s1012; - const SWord32 s1014 = (s897 >> 22) | (s897 << 10); - const SWord32 s1015 = s1013 ^ s1014; - const SWord32 s1016 = s886 & s897; - const SWord32 s1017 = s875 & s897; - const SWord32 s1018 = s1016 ^ s1017; - const SWord32 s1019 = s892 ^ s1018; - const SWord32 s1020 = s1015 + s1019; - const SWord32 s1021 = s925 + s1020; - const SWord32 s1022 = (s1021 >> 2) | (s1021 << 30); - const SWord32 s1023 = (s1021 >> 13) | (s1021 << 19); - const SWord32 s1024 = s1022 ^ s1023; - const SWord32 s1025 = (s1021 >> 22) | (s1021 << 10); - const SWord32 s1026 = s1024 ^ s1025; - const SWord32 s1027 = s897 & s1021; - const SWord32 s1028 = s886 & s1021; - const SWord32 s1029 = s1027 ^ s1028; - const SWord32 s1030 = s1016 ^ s1029; - const SWord32 s1031 = s1026 + s1030; - const SWord32 s1032 = s953 + s1031; - const SWord32 s1033 = (s1032 >> 2) | (s1032 << 30); - const SWord32 s1034 = (s1032 >> 13) | (s1032 << 19); - const SWord32 s1035 = s1033 ^ s1034; - const SWord32 s1036 = (s1032 >> 22) | (s1032 << 10); - const SWord32 s1037 = s1035 ^ s1036; - const SWord32 s1038 = s1021 & s1032; - const SWord32 s1039 = s897 & s1032; - const SWord32 s1040 = s1038 ^ s1039; - const SWord32 s1041 = s1027 ^ s1040; - const SWord32 s1042 = s1037 + s1041; - const SWord32 s1043 = s981 + s1042; - const SWord32 s1044 = (s1010 >> 6) | (s1010 << 26); - const SWord32 s1045 = (s1010 >> 11) | (s1010 << 21); - const SWord32 s1046 = s1044 ^ s1045; - const SWord32 s1047 = (s1010 >> 25) | (s1010 << 7); - const SWord32 s1048 = s1046 ^ s1047; - const SWord32 s1049 = s926 + s1048; - const SWord32 s1050 = s982 & s1010; - const SWord32 s1051 = ~s1010; - const SWord32 s1052 = s954 & s1051; - const SWord32 s1053 = s1050 ^ s1052; - const SWord32 s1054 = s1049 + s1053; - const SWord32 s1056 = s1054 + 0xc6e00bf3UL; - const SWord32 s1057 = (s980 >> 17) | (s980 << 15); - const SWord32 s1058 = (s980 >> 19) | (s980 << 13); - const SWord32 s1059 = s1057 ^ s1058; - const SWord32 s1060 = s980 >> 10; - const SWord32 s1061 = s1059 ^ s1060; - const SWord32 s1062 = s785 + s1061; - const SWord32 s1063 = (s491 >> 7) | (s491 << 25); - const SWord32 s1064 = (s491 >> 18) | (s491 << 14); - const SWord32 s1065 = s1063 ^ s1064; - const SWord32 s1066 = s491 >> 3; - const SWord32 s1067 = s1065 ^ s1066; - const SWord32 s1068 = s1062 + s1067; - const SWord32 s1069 = s473 + s1068; - const SWord32 s1070 = s1056 + s1069; - const SWord32 s1071 = s1021 + s1070; - const SWord32 s1072 = (s1071 >> 6) | (s1071 << 26); - const SWord32 s1073 = (s1071 >> 11) | (s1071 << 21); - const SWord32 s1074 = s1072 ^ s1073; - const SWord32 s1075 = (s1071 >> 25) | (s1071 << 7); - const SWord32 s1076 = s1074 ^ s1075; - const SWord32 s1077 = s954 + s1076; - const SWord32 s1078 = s1010 & s1071; - const SWord32 s1079 = ~s1071; - const SWord32 s1080 = s982 & s1079; - const SWord32 s1081 = s1078 ^ s1080; - const SWord32 s1082 = s1077 + s1081; - const SWord32 s1084 = s1082 + 0xd5a79147UL; - const SWord32 s1085 = (s1008 >> 17) | (s1008 << 15); - const SWord32 s1086 = (s1008 >> 19) | (s1008 << 13); - const SWord32 s1087 = s1085 ^ s1086; - const SWord32 s1088 = s1008 >> 10; - const SWord32 s1089 = s1087 ^ s1088; - const SWord32 s1090 = s813 + s1089; - const SWord32 s1091 = (s509 >> 7) | (s509 << 25); - const SWord32 s1092 = (s509 >> 18) | (s509 << 14); - const SWord32 s1093 = s1091 ^ s1092; - const SWord32 s1094 = s509 >> 3; - const SWord32 s1095 = s1093 ^ s1094; - const SWord32 s1096 = s1090 + s1095; - const SWord32 s1097 = s491 + s1096; - const SWord32 s1098 = s1084 + s1097; - const SWord32 s1099 = s1032 + s1098; - const SWord32 s1100 = (s1099 >> 6) | (s1099 << 26); - const SWord32 s1101 = (s1099 >> 11) | (s1099 << 21); - const SWord32 s1102 = s1100 ^ s1101; - const SWord32 s1103 = (s1099 >> 25) | (s1099 << 7); - const SWord32 s1104 = s1102 ^ s1103; - const SWord32 s1105 = s982 + s1104; - const SWord32 s1106 = s1071 & s1099; - const SWord32 s1107 = ~s1099; - const SWord32 s1108 = s1010 & s1107; - const SWord32 s1109 = s1106 ^ s1108; - const SWord32 s1110 = s1105 + s1109; - const SWord32 s1112 = s1110 + 0x06ca6351UL; - const SWord32 s1113 = (s1069 >> 17) | (s1069 << 15); - const SWord32 s1114 = (s1069 >> 19) | (s1069 << 13); - const SWord32 s1115 = s1113 ^ s1114; - const SWord32 s1116 = s1069 >> 10; - const SWord32 s1117 = s1115 ^ s1116; - const SWord32 s1118 = s841 + s1117; - const SWord32 s1119 = (s527 >> 7) | (s527 << 25); - const SWord32 s1120 = (s527 >> 18) | (s527 << 14); - const SWord32 s1121 = s1119 ^ s1120; - const SWord32 s1122 = s527 >> 3; - const SWord32 s1123 = s1121 ^ s1122; - const SWord32 s1124 = s1118 + s1123; - const SWord32 s1125 = s509 + s1124; - const SWord32 s1126 = s1112 + s1125; - const SWord32 s1127 = s1043 + s1126; - const SWord32 s1128 = (s1127 >> 6) | (s1127 << 26); - const SWord32 s1129 = (s1127 >> 11) | (s1127 << 21); - const SWord32 s1130 = s1128 ^ s1129; - const SWord32 s1131 = (s1127 >> 25) | (s1127 << 7); - const SWord32 s1132 = s1130 ^ s1131; - const SWord32 s1133 = s1010 + s1132; - const SWord32 s1134 = s1099 & s1127; - const SWord32 s1135 = ~s1127; - const SWord32 s1136 = s1071 & s1135; - const SWord32 s1137 = s1134 ^ s1136; - const SWord32 s1138 = s1133 + s1137; - const SWord32 s1140 = s1138 + 0x14292967UL; - const SWord32 s1141 = (s1097 >> 17) | (s1097 << 15); - const SWord32 s1142 = (s1097 >> 19) | (s1097 << 13); - const SWord32 s1143 = s1141 ^ s1142; - const SWord32 s1144 = s1097 >> 10; - const SWord32 s1145 = s1143 ^ s1144; - const SWord32 s1146 = s924 + s1145; - const SWord32 s1147 = (s612 >> 7) | (s612 << 25); - const SWord32 s1148 = (s612 >> 18) | (s612 << 14); - const SWord32 s1149 = s1147 ^ s1148; - const SWord32 s1150 = s612 >> 3; - const SWord32 s1151 = s1149 ^ s1150; - const SWord32 s1152 = s1146 + s1151; - const SWord32 s1153 = s527 + s1152; - const SWord32 s1154 = s1140 + s1153; - const SWord32 s1155 = (s1043 >> 2) | (s1043 << 30); - const SWord32 s1156 = (s1043 >> 13) | (s1043 << 19); - const SWord32 s1157 = s1155 ^ s1156; - const SWord32 s1158 = (s1043 >> 22) | (s1043 << 10); - const SWord32 s1159 = s1157 ^ s1158; - const SWord32 s1160 = s1032 & s1043; - const SWord32 s1161 = s1021 & s1043; - const SWord32 s1162 = s1160 ^ s1161; - const SWord32 s1163 = s1038 ^ s1162; - const SWord32 s1164 = s1159 + s1163; - const SWord32 s1165 = s1009 + s1164; - const SWord32 s1166 = (s1165 >> 2) | (s1165 << 30); - const SWord32 s1167 = (s1165 >> 13) | (s1165 << 19); - const SWord32 s1168 = s1166 ^ s1167; - const SWord32 s1169 = (s1165 >> 22) | (s1165 << 10); - const SWord32 s1170 = s1168 ^ s1169; - const SWord32 s1171 = s1043 & s1165; - const SWord32 s1172 = s1032 & s1165; - const SWord32 s1173 = s1171 ^ s1172; - const SWord32 s1174 = s1160 ^ s1173; - const SWord32 s1175 = s1170 + s1174; - const SWord32 s1176 = s1070 + s1175; - const SWord32 s1177 = (s1176 >> 2) | (s1176 << 30); - const SWord32 s1178 = (s1176 >> 13) | (s1176 << 19); - const SWord32 s1179 = s1177 ^ s1178; - const SWord32 s1180 = (s1176 >> 22) | (s1176 << 10); - const SWord32 s1181 = s1179 ^ s1180; - const SWord32 s1182 = s1165 & s1176; - const SWord32 s1183 = s1043 & s1176; - const SWord32 s1184 = s1182 ^ s1183; - const SWord32 s1185 = s1171 ^ s1184; - const SWord32 s1186 = s1181 + s1185; - const SWord32 s1187 = s1098 + s1186; - const SWord32 s1188 = (s1187 >> 2) | (s1187 << 30); - const SWord32 s1189 = (s1187 >> 13) | (s1187 << 19); - const SWord32 s1190 = s1188 ^ s1189; - const SWord32 s1191 = (s1187 >> 22) | (s1187 << 10); - const SWord32 s1192 = s1190 ^ s1191; - const SWord32 s1193 = s1176 & s1187; - const SWord32 s1194 = s1165 & s1187; - const SWord32 s1195 = s1193 ^ s1194; - const SWord32 s1196 = s1182 ^ s1195; - const SWord32 s1197 = s1192 + s1196; - const SWord32 s1198 = s1126 + s1197; - const SWord32 s1199 = (s1198 >> 2) | (s1198 << 30); - const SWord32 s1200 = (s1198 >> 13) | (s1198 << 19); - const SWord32 s1201 = s1199 ^ s1200; - const SWord32 s1202 = (s1198 >> 22) | (s1198 << 10); - const SWord32 s1203 = s1201 ^ s1202; - const SWord32 s1204 = s1187 & s1198; - const SWord32 s1205 = s1176 & s1198; - const SWord32 s1206 = s1204 ^ s1205; - const SWord32 s1207 = s1193 ^ s1206; - const SWord32 s1208 = s1203 + s1207; - const SWord32 s1209 = s1154 + s1208; - const SWord32 s1210 = s1154 + s1165; - const SWord32 s1211 = (s1210 >> 6) | (s1210 << 26); - const SWord32 s1212 = (s1210 >> 11) | (s1210 << 21); - const SWord32 s1213 = s1211 ^ s1212; - const SWord32 s1214 = (s1210 >> 25) | (s1210 << 7); - const SWord32 s1215 = s1213 ^ s1214; - const SWord32 s1216 = s1071 + s1215; - const SWord32 s1217 = s1127 & s1210; - const SWord32 s1218 = ~s1210; - const SWord32 s1219 = s1099 & s1218; - const SWord32 s1220 = s1217 ^ s1219; - const SWord32 s1221 = s1216 + s1220; - const SWord32 s1223 = s1221 + 0x27b70a85UL; - const SWord32 s1224 = (s1125 >> 17) | (s1125 << 15); - const SWord32 s1225 = (s1125 >> 19) | (s1125 << 13); - const SWord32 s1226 = s1224 ^ s1225; - const SWord32 s1227 = s1125 >> 10; - const SWord32 s1228 = s1226 ^ s1227; - const SWord32 s1229 = s952 + s1228; - const SWord32 s1230 = (s640 >> 7) | (s640 << 25); - const SWord32 s1231 = (s640 >> 18) | (s640 << 14); - const SWord32 s1232 = s1230 ^ s1231; - const SWord32 s1233 = s640 >> 3; - const SWord32 s1234 = s1232 ^ s1233; - const SWord32 s1235 = s1229 + s1234; - const SWord32 s1236 = s612 + s1235; - const SWord32 s1237 = s1223 + s1236; - const SWord32 s1238 = s1176 + s1237; - const SWord32 s1239 = (s1238 >> 6) | (s1238 << 26); - const SWord32 s1240 = (s1238 >> 11) | (s1238 << 21); - const SWord32 s1241 = s1239 ^ s1240; - const SWord32 s1242 = (s1238 >> 25) | (s1238 << 7); - const SWord32 s1243 = s1241 ^ s1242; - const SWord32 s1244 = s1099 + s1243; - const SWord32 s1245 = s1210 & s1238; - const SWord32 s1246 = ~s1238; - const SWord32 s1247 = s1127 & s1246; - const SWord32 s1248 = s1245 ^ s1247; - const SWord32 s1249 = s1244 + s1248; - const SWord32 s1251 = s1249 + 0x2e1b2138UL; - const SWord32 s1252 = (s1153 >> 17) | (s1153 << 15); - const SWord32 s1253 = (s1153 >> 19) | (s1153 << 13); - const SWord32 s1254 = s1252 ^ s1253; - const SWord32 s1255 = s1153 >> 10; - const SWord32 s1256 = s1254 ^ s1255; - const SWord32 s1257 = s980 + s1256; - const SWord32 s1258 = (s668 >> 7) | (s668 << 25); - const SWord32 s1259 = (s668 >> 18) | (s668 << 14); - const SWord32 s1260 = s1258 ^ s1259; - const SWord32 s1261 = s668 >> 3; - const SWord32 s1262 = s1260 ^ s1261; - const SWord32 s1263 = s1257 + s1262; - const SWord32 s1264 = s640 + s1263; - const SWord32 s1265 = s1251 + s1264; - const SWord32 s1266 = s1187 + s1265; - const SWord32 s1267 = (s1266 >> 6) | (s1266 << 26); - const SWord32 s1268 = (s1266 >> 11) | (s1266 << 21); - const SWord32 s1269 = s1267 ^ s1268; - const SWord32 s1270 = (s1266 >> 25) | (s1266 << 7); - const SWord32 s1271 = s1269 ^ s1270; - const SWord32 s1272 = s1127 + s1271; - const SWord32 s1273 = s1238 & s1266; - const SWord32 s1274 = ~s1266; - const SWord32 s1275 = s1210 & s1274; - const SWord32 s1276 = s1273 ^ s1275; - const SWord32 s1277 = s1272 + s1276; - const SWord32 s1279 = s1277 + 0x4d2c6dfcUL; - const SWord32 s1280 = (s1236 >> 17) | (s1236 << 15); - const SWord32 s1281 = (s1236 >> 19) | (s1236 << 13); - const SWord32 s1282 = s1280 ^ s1281; - const SWord32 s1283 = s1236 >> 10; - const SWord32 s1284 = s1282 ^ s1283; - const SWord32 s1285 = s1008 + s1284; - const SWord32 s1286 = (s696 >> 7) | (s696 << 25); - const SWord32 s1287 = (s696 >> 18) | (s696 << 14); - const SWord32 s1288 = s1286 ^ s1287; - const SWord32 s1289 = s696 >> 3; - const SWord32 s1290 = s1288 ^ s1289; - const SWord32 s1291 = s1285 + s1290; - const SWord32 s1292 = s668 + s1291; - const SWord32 s1293 = s1279 + s1292; - const SWord32 s1294 = s1198 + s1293; - const SWord32 s1295 = (s1294 >> 6) | (s1294 << 26); - const SWord32 s1296 = (s1294 >> 11) | (s1294 << 21); - const SWord32 s1297 = s1295 ^ s1296; - const SWord32 s1298 = (s1294 >> 25) | (s1294 << 7); - const SWord32 s1299 = s1297 ^ s1298; - const SWord32 s1300 = s1210 + s1299; - const SWord32 s1301 = s1266 & s1294; - const SWord32 s1302 = ~s1294; - const SWord32 s1303 = s1238 & s1302; - const SWord32 s1304 = s1301 ^ s1303; - const SWord32 s1305 = s1300 + s1304; - const SWord32 s1307 = s1305 + 0x53380d13UL; - const SWord32 s1308 = (s1264 >> 17) | (s1264 << 15); - const SWord32 s1309 = (s1264 >> 19) | (s1264 << 13); - const SWord32 s1310 = s1308 ^ s1309; - const SWord32 s1311 = s1264 >> 10; - const SWord32 s1312 = s1310 ^ s1311; - const SWord32 s1313 = s1069 + s1312; - const SWord32 s1314 = (s757 >> 7) | (s757 << 25); - const SWord32 s1315 = (s757 >> 18) | (s757 << 14); - const SWord32 s1316 = s1314 ^ s1315; - const SWord32 s1317 = s757 >> 3; - const SWord32 s1318 = s1316 ^ s1317; - const SWord32 s1319 = s1313 + s1318; - const SWord32 s1320 = s696 + s1319; - const SWord32 s1321 = s1307 + s1320; - const SWord32 s1322 = s1209 + s1321; - const SWord32 s1323 = (s1209 >> 2) | (s1209 << 30); - const SWord32 s1324 = (s1209 >> 13) | (s1209 << 19); - const SWord32 s1325 = s1323 ^ s1324; - const SWord32 s1326 = (s1209 >> 22) | (s1209 << 10); - const SWord32 s1327 = s1325 ^ s1326; - const SWord32 s1328 = s1198 & s1209; - const SWord32 s1329 = s1187 & s1209; - const SWord32 s1330 = s1328 ^ s1329; - const SWord32 s1331 = s1204 ^ s1330; - const SWord32 s1332 = s1327 + s1331; - const SWord32 s1333 = s1237 + s1332; - const SWord32 s1334 = (s1333 >> 2) | (s1333 << 30); - const SWord32 s1335 = (s1333 >> 13) | (s1333 << 19); - const SWord32 s1336 = s1334 ^ s1335; - const SWord32 s1337 = (s1333 >> 22) | (s1333 << 10); - const SWord32 s1338 = s1336 ^ s1337; - const SWord32 s1339 = s1209 & s1333; - const SWord32 s1340 = s1198 & s1333; - const SWord32 s1341 = s1339 ^ s1340; - const SWord32 s1342 = s1328 ^ s1341; - const SWord32 s1343 = s1338 + s1342; - const SWord32 s1344 = s1265 + s1343; - const SWord32 s1345 = (s1344 >> 2) | (s1344 << 30); - const SWord32 s1346 = (s1344 >> 13) | (s1344 << 19); - const SWord32 s1347 = s1345 ^ s1346; - const SWord32 s1348 = (s1344 >> 22) | (s1344 << 10); - const SWord32 s1349 = s1347 ^ s1348; - const SWord32 s1350 = s1333 & s1344; - const SWord32 s1351 = s1209 & s1344; - const SWord32 s1352 = s1350 ^ s1351; - const SWord32 s1353 = s1339 ^ s1352; - const SWord32 s1354 = s1349 + s1353; - const SWord32 s1355 = s1293 + s1354; - const SWord32 s1356 = (s1322 >> 6) | (s1322 << 26); - const SWord32 s1357 = (s1322 >> 11) | (s1322 << 21); - const SWord32 s1358 = s1356 ^ s1357; - const SWord32 s1359 = (s1322 >> 25) | (s1322 << 7); - const SWord32 s1360 = s1358 ^ s1359; - const SWord32 s1361 = s1238 + s1360; - const SWord32 s1362 = s1294 & s1322; - const SWord32 s1363 = ~s1322; - const SWord32 s1364 = s1266 & s1363; - const SWord32 s1365 = s1362 ^ s1364; - const SWord32 s1366 = s1361 + s1365; - const SWord32 s1368 = s1366 + 0x650a7354UL; - const SWord32 s1369 = (s1292 >> 17) | (s1292 << 15); - const SWord32 s1370 = (s1292 >> 19) | (s1292 << 13); - const SWord32 s1371 = s1369 ^ s1370; - const SWord32 s1372 = s1292 >> 10; - const SWord32 s1373 = s1371 ^ s1372; - const SWord32 s1374 = s1097 + s1373; - const SWord32 s1375 = (s785 >> 7) | (s785 << 25); - const SWord32 s1376 = (s785 >> 18) | (s785 << 14); - const SWord32 s1377 = s1375 ^ s1376; - const SWord32 s1378 = s785 >> 3; - const SWord32 s1379 = s1377 ^ s1378; - const SWord32 s1380 = s1374 + s1379; - const SWord32 s1381 = s757 + s1380; - const SWord32 s1382 = s1368 + s1381; - const SWord32 s1383 = s1333 + s1382; - const SWord32 s1384 = (s1383 >> 6) | (s1383 << 26); - const SWord32 s1385 = (s1383 >> 11) | (s1383 << 21); - const SWord32 s1386 = s1384 ^ s1385; - const SWord32 s1387 = (s1383 >> 25) | (s1383 << 7); - const SWord32 s1388 = s1386 ^ s1387; - const SWord32 s1389 = s1266 + s1388; - const SWord32 s1390 = s1322 & s1383; - const SWord32 s1391 = ~s1383; - const SWord32 s1392 = s1294 & s1391; - const SWord32 s1393 = s1390 ^ s1392; - const SWord32 s1394 = s1389 + s1393; - const SWord32 s1396 = s1394 + 0x766a0abbUL; - const SWord32 s1397 = (s1320 >> 17) | (s1320 << 15); - const SWord32 s1398 = (s1320 >> 19) | (s1320 << 13); - const SWord32 s1399 = s1397 ^ s1398; - const SWord32 s1400 = s1320 >> 10; - const SWord32 s1401 = s1399 ^ s1400; - const SWord32 s1402 = s1125 + s1401; - const SWord32 s1403 = (s813 >> 7) | (s813 << 25); - const SWord32 s1404 = (s813 >> 18) | (s813 << 14); - const SWord32 s1405 = s1403 ^ s1404; - const SWord32 s1406 = s813 >> 3; - const SWord32 s1407 = s1405 ^ s1406; - const SWord32 s1408 = s1402 + s1407; - const SWord32 s1409 = s785 + s1408; - const SWord32 s1410 = s1396 + s1409; - const SWord32 s1411 = s1344 + s1410; - const SWord32 s1412 = (s1411 >> 6) | (s1411 << 26); - const SWord32 s1413 = (s1411 >> 11) | (s1411 << 21); - const SWord32 s1414 = s1412 ^ s1413; - const SWord32 s1415 = (s1411 >> 25) | (s1411 << 7); - const SWord32 s1416 = s1414 ^ s1415; - const SWord32 s1417 = s1294 + s1416; - const SWord32 s1418 = s1383 & s1411; - const SWord32 s1419 = ~s1411; - const SWord32 s1420 = s1322 & s1419; - const SWord32 s1421 = s1418 ^ s1420; - const SWord32 s1422 = s1417 + s1421; - const SWord32 s1424 = s1422 + 0x81c2c92eUL; - const SWord32 s1425 = (s1381 >> 17) | (s1381 << 15); - const SWord32 s1426 = (s1381 >> 19) | (s1381 << 13); - const SWord32 s1427 = s1425 ^ s1426; - const SWord32 s1428 = s1381 >> 10; - const SWord32 s1429 = s1427 ^ s1428; - const SWord32 s1430 = s1153 + s1429; - const SWord32 s1431 = (s841 >> 7) | (s841 << 25); - const SWord32 s1432 = (s841 >> 18) | (s841 << 14); - const SWord32 s1433 = s1431 ^ s1432; - const SWord32 s1434 = s841 >> 3; - const SWord32 s1435 = s1433 ^ s1434; - const SWord32 s1436 = s1430 + s1435; - const SWord32 s1437 = s813 + s1436; - const SWord32 s1438 = s1424 + s1437; - const SWord32 s1439 = s1355 + s1438; - const SWord32 s1440 = (s1439 >> 6) | (s1439 << 26); - const SWord32 s1441 = (s1439 >> 11) | (s1439 << 21); - const SWord32 s1442 = s1440 ^ s1441; - const SWord32 s1443 = (s1439 >> 25) | (s1439 << 7); - const SWord32 s1444 = s1442 ^ s1443; - const SWord32 s1445 = s1322 + s1444; - const SWord32 s1446 = s1411 & s1439; - const SWord32 s1447 = ~s1439; - const SWord32 s1448 = s1383 & s1447; - const SWord32 s1449 = s1446 ^ s1448; - const SWord32 s1450 = s1445 + s1449; - const SWord32 s1452 = s1450 + 0x92722c85UL; - const SWord32 s1453 = (s1409 >> 17) | (s1409 << 15); - const SWord32 s1454 = (s1409 >> 19) | (s1409 << 13); - const SWord32 s1455 = s1453 ^ s1454; - const SWord32 s1456 = s1409 >> 10; - const SWord32 s1457 = s1455 ^ s1456; - const SWord32 s1458 = s1236 + s1457; - const SWord32 s1459 = (s924 >> 7) | (s924 << 25); - const SWord32 s1460 = (s924 >> 18) | (s924 << 14); - const SWord32 s1461 = s1459 ^ s1460; - const SWord32 s1462 = s924 >> 3; - const SWord32 s1463 = s1461 ^ s1462; - const SWord32 s1464 = s1458 + s1463; - const SWord32 s1465 = s841 + s1464; - const SWord32 s1466 = s1452 + s1465; - const SWord32 s1467 = (s1355 >> 2) | (s1355 << 30); - const SWord32 s1468 = (s1355 >> 13) | (s1355 << 19); - const SWord32 s1469 = s1467 ^ s1468; - const SWord32 s1470 = (s1355 >> 22) | (s1355 << 10); - const SWord32 s1471 = s1469 ^ s1470; - const SWord32 s1472 = s1344 & s1355; - const SWord32 s1473 = s1333 & s1355; - const SWord32 s1474 = s1472 ^ s1473; - const SWord32 s1475 = s1350 ^ s1474; - const SWord32 s1476 = s1471 + s1475; - const SWord32 s1477 = s1321 + s1476; - const SWord32 s1478 = (s1477 >> 2) | (s1477 << 30); - const SWord32 s1479 = (s1477 >> 13) | (s1477 << 19); - const SWord32 s1480 = s1478 ^ s1479; - const SWord32 s1481 = (s1477 >> 22) | (s1477 << 10); - const SWord32 s1482 = s1480 ^ s1481; - const SWord32 s1483 = s1355 & s1477; - const SWord32 s1484 = s1344 & s1477; - const SWord32 s1485 = s1483 ^ s1484; - const SWord32 s1486 = s1472 ^ s1485; - const SWord32 s1487 = s1482 + s1486; - const SWord32 s1488 = s1382 + s1487; - const SWord32 s1489 = (s1488 >> 2) | (s1488 << 30); - const SWord32 s1490 = (s1488 >> 13) | (s1488 << 19); - const SWord32 s1491 = s1489 ^ s1490; - const SWord32 s1492 = (s1488 >> 22) | (s1488 << 10); - const SWord32 s1493 = s1491 ^ s1492; - const SWord32 s1494 = s1477 & s1488; - const SWord32 s1495 = s1355 & s1488; - const SWord32 s1496 = s1494 ^ s1495; - const SWord32 s1497 = s1483 ^ s1496; - const SWord32 s1498 = s1493 + s1497; - const SWord32 s1499 = s1410 + s1498; - const SWord32 s1500 = (s1499 >> 2) | (s1499 << 30); - const SWord32 s1501 = (s1499 >> 13) | (s1499 << 19); - const SWord32 s1502 = s1500 ^ s1501; - const SWord32 s1503 = (s1499 >> 22) | (s1499 << 10); - const SWord32 s1504 = s1502 ^ s1503; - const SWord32 s1505 = s1488 & s1499; - const SWord32 s1506 = s1477 & s1499; - const SWord32 s1507 = s1505 ^ s1506; - const SWord32 s1508 = s1494 ^ s1507; - const SWord32 s1509 = s1504 + s1508; - const SWord32 s1510 = s1438 + s1509; - const SWord32 s1511 = (s1510 >> 2) | (s1510 << 30); - const SWord32 s1512 = (s1510 >> 13) | (s1510 << 19); - const SWord32 s1513 = s1511 ^ s1512; - const SWord32 s1514 = (s1510 >> 22) | (s1510 << 10); - const SWord32 s1515 = s1513 ^ s1514; - const SWord32 s1516 = s1499 & s1510; - const SWord32 s1517 = s1488 & s1510; - const SWord32 s1518 = s1516 ^ s1517; - const SWord32 s1519 = s1505 ^ s1518; - const SWord32 s1520 = s1515 + s1519; - const SWord32 s1521 = s1466 + s1520; - const SWord32 s1522 = s1466 + s1477; - const SWord32 s1523 = (s1522 >> 6) | (s1522 << 26); - const SWord32 s1524 = (s1522 >> 11) | (s1522 << 21); - const SWord32 s1525 = s1523 ^ s1524; - const SWord32 s1526 = (s1522 >> 25) | (s1522 << 7); - const SWord32 s1527 = s1525 ^ s1526; - const SWord32 s1528 = s1383 + s1527; - const SWord32 s1529 = s1439 & s1522; - const SWord32 s1530 = ~s1522; - const SWord32 s1531 = s1411 & s1530; - const SWord32 s1532 = s1529 ^ s1531; - const SWord32 s1533 = s1528 + s1532; - const SWord32 s1535 = s1533 + 0xa2bfe8a1UL; - const SWord32 s1536 = (s1437 >> 17) | (s1437 << 15); - const SWord32 s1537 = (s1437 >> 19) | (s1437 << 13); - const SWord32 s1538 = s1536 ^ s1537; - const SWord32 s1539 = s1437 >> 10; - const SWord32 s1540 = s1538 ^ s1539; - const SWord32 s1541 = s1264 + s1540; - const SWord32 s1542 = (s952 >> 7) | (s952 << 25); - const SWord32 s1543 = (s952 >> 18) | (s952 << 14); - const SWord32 s1544 = s1542 ^ s1543; - const SWord32 s1545 = s952 >> 3; - const SWord32 s1546 = s1544 ^ s1545; - const SWord32 s1547 = s1541 + s1546; - const SWord32 s1548 = s924 + s1547; - const SWord32 s1549 = s1535 + s1548; - const SWord32 s1550 = s1488 + s1549; - const SWord32 s1551 = (s1550 >> 6) | (s1550 << 26); - const SWord32 s1552 = (s1550 >> 11) | (s1550 << 21); - const SWord32 s1553 = s1551 ^ s1552; - const SWord32 s1554 = (s1550 >> 25) | (s1550 << 7); - const SWord32 s1555 = s1553 ^ s1554; - const SWord32 s1556 = s1411 + s1555; - const SWord32 s1557 = s1522 & s1550; - const SWord32 s1558 = ~s1550; - const SWord32 s1559 = s1439 & s1558; - const SWord32 s1560 = s1557 ^ s1559; - const SWord32 s1561 = s1556 + s1560; - const SWord32 s1563 = s1561 + 0xa81a664bUL; - const SWord32 s1564 = (s1465 >> 17) | (s1465 << 15); - const SWord32 s1565 = (s1465 >> 19) | (s1465 << 13); - const SWord32 s1566 = s1564 ^ s1565; - const SWord32 s1567 = s1465 >> 10; - const SWord32 s1568 = s1566 ^ s1567; - const SWord32 s1569 = s1292 + s1568; - const SWord32 s1570 = (s980 >> 7) | (s980 << 25); - const SWord32 s1571 = (s980 >> 18) | (s980 << 14); - const SWord32 s1572 = s1570 ^ s1571; - const SWord32 s1573 = s980 >> 3; - const SWord32 s1574 = s1572 ^ s1573; - const SWord32 s1575 = s1569 + s1574; - const SWord32 s1576 = s952 + s1575; - const SWord32 s1577 = s1563 + s1576; - const SWord32 s1578 = s1499 + s1577; - const SWord32 s1579 = (s1578 >> 6) | (s1578 << 26); - const SWord32 s1580 = (s1578 >> 11) | (s1578 << 21); - const SWord32 s1581 = s1579 ^ s1580; - const SWord32 s1582 = (s1578 >> 25) | (s1578 << 7); - const SWord32 s1583 = s1581 ^ s1582; - const SWord32 s1584 = s1439 + s1583; - const SWord32 s1585 = s1550 & s1578; - const SWord32 s1586 = ~s1578; - const SWord32 s1587 = s1522 & s1586; - const SWord32 s1588 = s1585 ^ s1587; - const SWord32 s1589 = s1584 + s1588; - const SWord32 s1591 = s1589 + 0xc24b8b70UL; - const SWord32 s1592 = (s1548 >> 17) | (s1548 << 15); - const SWord32 s1593 = (s1548 >> 19) | (s1548 << 13); - const SWord32 s1594 = s1592 ^ s1593; - const SWord32 s1595 = s1548 >> 10; - const SWord32 s1596 = s1594 ^ s1595; - const SWord32 s1597 = s1320 + s1596; - const SWord32 s1598 = (s1008 >> 7) | (s1008 << 25); - const SWord32 s1599 = (s1008 >> 18) | (s1008 << 14); - const SWord32 s1600 = s1598 ^ s1599; - const SWord32 s1601 = s1008 >> 3; - const SWord32 s1602 = s1600 ^ s1601; - const SWord32 s1603 = s1597 + s1602; - const SWord32 s1604 = s980 + s1603; - const SWord32 s1605 = s1591 + s1604; - const SWord32 s1606 = s1510 + s1605; - const SWord32 s1607 = (s1606 >> 6) | (s1606 << 26); - const SWord32 s1608 = (s1606 >> 11) | (s1606 << 21); - const SWord32 s1609 = s1607 ^ s1608; - const SWord32 s1610 = (s1606 >> 25) | (s1606 << 7); - const SWord32 s1611 = s1609 ^ s1610; - const SWord32 s1612 = s1522 + s1611; - const SWord32 s1613 = s1578 & s1606; - const SWord32 s1614 = ~s1606; - const SWord32 s1615 = s1550 & s1614; - const SWord32 s1616 = s1613 ^ s1615; - const SWord32 s1617 = s1612 + s1616; - const SWord32 s1619 = s1617 + 0xc76c51a3UL; - const SWord32 s1620 = (s1576 >> 17) | (s1576 << 15); - const SWord32 s1621 = (s1576 >> 19) | (s1576 << 13); - const SWord32 s1622 = s1620 ^ s1621; - const SWord32 s1623 = s1576 >> 10; - const SWord32 s1624 = s1622 ^ s1623; - const SWord32 s1625 = s1381 + s1624; - const SWord32 s1626 = (s1069 >> 7) | (s1069 << 25); - const SWord32 s1627 = (s1069 >> 18) | (s1069 << 14); - const SWord32 s1628 = s1626 ^ s1627; - const SWord32 s1629 = s1069 >> 3; - const SWord32 s1630 = s1628 ^ s1629; - const SWord32 s1631 = s1625 + s1630; - const SWord32 s1632 = s1008 + s1631; - const SWord32 s1633 = s1619 + s1632; - const SWord32 s1634 = s1521 + s1633; - const SWord32 s1635 = (s1521 >> 2) | (s1521 << 30); - const SWord32 s1636 = (s1521 >> 13) | (s1521 << 19); - const SWord32 s1637 = s1635 ^ s1636; - const SWord32 s1638 = (s1521 >> 22) | (s1521 << 10); - const SWord32 s1639 = s1637 ^ s1638; - const SWord32 s1640 = s1510 & s1521; - const SWord32 s1641 = s1499 & s1521; - const SWord32 s1642 = s1640 ^ s1641; - const SWord32 s1643 = s1516 ^ s1642; - const SWord32 s1644 = s1639 + s1643; - const SWord32 s1645 = s1549 + s1644; - const SWord32 s1646 = (s1645 >> 2) | (s1645 << 30); - const SWord32 s1647 = (s1645 >> 13) | (s1645 << 19); - const SWord32 s1648 = s1646 ^ s1647; - const SWord32 s1649 = (s1645 >> 22) | (s1645 << 10); - const SWord32 s1650 = s1648 ^ s1649; - const SWord32 s1651 = s1521 & s1645; - const SWord32 s1652 = s1510 & s1645; - const SWord32 s1653 = s1651 ^ s1652; - const SWord32 s1654 = s1640 ^ s1653; - const SWord32 s1655 = s1650 + s1654; - const SWord32 s1656 = s1577 + s1655; - const SWord32 s1657 = (s1656 >> 2) | (s1656 << 30); - const SWord32 s1658 = (s1656 >> 13) | (s1656 << 19); - const SWord32 s1659 = s1657 ^ s1658; - const SWord32 s1660 = (s1656 >> 22) | (s1656 << 10); - const SWord32 s1661 = s1659 ^ s1660; - const SWord32 s1662 = s1645 & s1656; - const SWord32 s1663 = s1521 & s1656; - const SWord32 s1664 = s1662 ^ s1663; - const SWord32 s1665 = s1651 ^ s1664; - const SWord32 s1666 = s1661 + s1665; - const SWord32 s1667 = s1605 + s1666; - const SWord32 s1668 = (s1634 >> 6) | (s1634 << 26); - const SWord32 s1669 = (s1634 >> 11) | (s1634 << 21); - const SWord32 s1670 = s1668 ^ s1669; - const SWord32 s1671 = (s1634 >> 25) | (s1634 << 7); - const SWord32 s1672 = s1670 ^ s1671; - const SWord32 s1673 = s1550 + s1672; - const SWord32 s1674 = s1606 & s1634; - const SWord32 s1675 = ~s1634; - const SWord32 s1676 = s1578 & s1675; - const SWord32 s1677 = s1674 ^ s1676; - const SWord32 s1678 = s1673 + s1677; - const SWord32 s1680 = s1678 + 0xd192e819UL; - const SWord32 s1681 = (s1604 >> 17) | (s1604 << 15); - const SWord32 s1682 = (s1604 >> 19) | (s1604 << 13); - const SWord32 s1683 = s1681 ^ s1682; - const SWord32 s1684 = s1604 >> 10; - const SWord32 s1685 = s1683 ^ s1684; - const SWord32 s1686 = s1409 + s1685; - const SWord32 s1687 = (s1097 >> 7) | (s1097 << 25); - const SWord32 s1688 = (s1097 >> 18) | (s1097 << 14); - const SWord32 s1689 = s1687 ^ s1688; - const SWord32 s1690 = s1097 >> 3; - const SWord32 s1691 = s1689 ^ s1690; - const SWord32 s1692 = s1686 + s1691; - const SWord32 s1693 = s1069 + s1692; - const SWord32 s1694 = s1680 + s1693; - const SWord32 s1695 = s1645 + s1694; - const SWord32 s1696 = (s1695 >> 6) | (s1695 << 26); - const SWord32 s1697 = (s1695 >> 11) | (s1695 << 21); - const SWord32 s1698 = s1696 ^ s1697; - const SWord32 s1699 = (s1695 >> 25) | (s1695 << 7); - const SWord32 s1700 = s1698 ^ s1699; - const SWord32 s1701 = s1578 + s1700; - const SWord32 s1702 = s1634 & s1695; - const SWord32 s1703 = ~s1695; - const SWord32 s1704 = s1606 & s1703; - const SWord32 s1705 = s1702 ^ s1704; - const SWord32 s1706 = s1701 + s1705; - const SWord32 s1708 = s1706 + 0xd6990624UL; - const SWord32 s1709 = (s1632 >> 17) | (s1632 << 15); - const SWord32 s1710 = (s1632 >> 19) | (s1632 << 13); - const SWord32 s1711 = s1709 ^ s1710; - const SWord32 s1712 = s1632 >> 10; - const SWord32 s1713 = s1711 ^ s1712; - const SWord32 s1714 = s1437 + s1713; - const SWord32 s1715 = (s1125 >> 7) | (s1125 << 25); - const SWord32 s1716 = (s1125 >> 18) | (s1125 << 14); - const SWord32 s1717 = s1715 ^ s1716; - const SWord32 s1718 = s1125 >> 3; - const SWord32 s1719 = s1717 ^ s1718; - const SWord32 s1720 = s1714 + s1719; - const SWord32 s1721 = s1097 + s1720; - const SWord32 s1722 = s1708 + s1721; - const SWord32 s1723 = s1656 + s1722; - const SWord32 s1724 = (s1723 >> 6) | (s1723 << 26); - const SWord32 s1725 = (s1723 >> 11) | (s1723 << 21); - const SWord32 s1726 = s1724 ^ s1725; - const SWord32 s1727 = (s1723 >> 25) | (s1723 << 7); - const SWord32 s1728 = s1726 ^ s1727; - const SWord32 s1729 = s1606 + s1728; - const SWord32 s1730 = s1695 & s1723; - const SWord32 s1731 = ~s1723; - const SWord32 s1732 = s1634 & s1731; - const SWord32 s1733 = s1730 ^ s1732; - const SWord32 s1734 = s1729 + s1733; - const SWord32 s1736 = s1734 + 0xf40e3585UL; - const SWord32 s1737 = (s1693 >> 17) | (s1693 << 15); - const SWord32 s1738 = (s1693 >> 19) | (s1693 << 13); - const SWord32 s1739 = s1737 ^ s1738; - const SWord32 s1740 = s1693 >> 10; - const SWord32 s1741 = s1739 ^ s1740; - const SWord32 s1742 = s1465 + s1741; - const SWord32 s1743 = (s1153 >> 7) | (s1153 << 25); - const SWord32 s1744 = (s1153 >> 18) | (s1153 << 14); - const SWord32 s1745 = s1743 ^ s1744; - const SWord32 s1746 = s1153 >> 3; - const SWord32 s1747 = s1745 ^ s1746; - const SWord32 s1748 = s1742 + s1747; - const SWord32 s1749 = s1125 + s1748; - const SWord32 s1750 = s1736 + s1749; - const SWord32 s1751 = s1667 + s1750; - const SWord32 s1752 = (s1751 >> 6) | (s1751 << 26); - const SWord32 s1753 = (s1751 >> 11) | (s1751 << 21); - const SWord32 s1754 = s1752 ^ s1753; - const SWord32 s1755 = (s1751 >> 25) | (s1751 << 7); - const SWord32 s1756 = s1754 ^ s1755; - const SWord32 s1757 = s1634 + s1756; - const SWord32 s1758 = s1723 & s1751; - const SWord32 s1759 = ~s1751; - const SWord32 s1760 = s1695 & s1759; - const SWord32 s1761 = s1758 ^ s1760; - const SWord32 s1762 = s1757 + s1761; - const SWord32 s1764 = s1762 + 0x106aa070UL; - const SWord32 s1765 = (s1721 >> 17) | (s1721 << 15); - const SWord32 s1766 = (s1721 >> 19) | (s1721 << 13); - const SWord32 s1767 = s1765 ^ s1766; - const SWord32 s1768 = s1721 >> 10; - const SWord32 s1769 = s1767 ^ s1768; - const SWord32 s1770 = s1548 + s1769; - const SWord32 s1771 = (s1236 >> 7) | (s1236 << 25); - const SWord32 s1772 = (s1236 >> 18) | (s1236 << 14); - const SWord32 s1773 = s1771 ^ s1772; - const SWord32 s1774 = s1236 >> 3; - const SWord32 s1775 = s1773 ^ s1774; - const SWord32 s1776 = s1770 + s1775; - const SWord32 s1777 = s1153 + s1776; - const SWord32 s1778 = s1764 + s1777; - const SWord32 s1779 = (s1667 >> 2) | (s1667 << 30); - const SWord32 s1780 = (s1667 >> 13) | (s1667 << 19); - const SWord32 s1781 = s1779 ^ s1780; - const SWord32 s1782 = (s1667 >> 22) | (s1667 << 10); - const SWord32 s1783 = s1781 ^ s1782; - const SWord32 s1784 = s1656 & s1667; - const SWord32 s1785 = s1645 & s1667; - const SWord32 s1786 = s1784 ^ s1785; - const SWord32 s1787 = s1662 ^ s1786; - const SWord32 s1788 = s1783 + s1787; - const SWord32 s1789 = s1633 + s1788; - const SWord32 s1790 = (s1789 >> 2) | (s1789 << 30); - const SWord32 s1791 = (s1789 >> 13) | (s1789 << 19); - const SWord32 s1792 = s1790 ^ s1791; - const SWord32 s1793 = (s1789 >> 22) | (s1789 << 10); - const SWord32 s1794 = s1792 ^ s1793; - const SWord32 s1795 = s1667 & s1789; - const SWord32 s1796 = s1656 & s1789; - const SWord32 s1797 = s1795 ^ s1796; - const SWord32 s1798 = s1784 ^ s1797; - const SWord32 s1799 = s1794 + s1798; - const SWord32 s1800 = s1694 + s1799; - const SWord32 s1801 = (s1800 >> 2) | (s1800 << 30); - const SWord32 s1802 = (s1800 >> 13) | (s1800 << 19); - const SWord32 s1803 = s1801 ^ s1802; - const SWord32 s1804 = (s1800 >> 22) | (s1800 << 10); - const SWord32 s1805 = s1803 ^ s1804; - const SWord32 s1806 = s1789 & s1800; - const SWord32 s1807 = s1667 & s1800; - const SWord32 s1808 = s1806 ^ s1807; - const SWord32 s1809 = s1795 ^ s1808; - const SWord32 s1810 = s1805 + s1809; - const SWord32 s1811 = s1722 + s1810; - const SWord32 s1812 = (s1811 >> 2) | (s1811 << 30); - const SWord32 s1813 = (s1811 >> 13) | (s1811 << 19); - const SWord32 s1814 = s1812 ^ s1813; - const SWord32 s1815 = (s1811 >> 22) | (s1811 << 10); - const SWord32 s1816 = s1814 ^ s1815; - const SWord32 s1817 = s1800 & s1811; - const SWord32 s1818 = s1789 & s1811; - const SWord32 s1819 = s1817 ^ s1818; - const SWord32 s1820 = s1806 ^ s1819; - const SWord32 s1821 = s1816 + s1820; - const SWord32 s1822 = s1750 + s1821; - const SWord32 s1823 = (s1822 >> 2) | (s1822 << 30); - const SWord32 s1824 = (s1822 >> 13) | (s1822 << 19); - const SWord32 s1825 = s1823 ^ s1824; - const SWord32 s1826 = (s1822 >> 22) | (s1822 << 10); - const SWord32 s1827 = s1825 ^ s1826; - const SWord32 s1828 = s1811 & s1822; - const SWord32 s1829 = s1800 & s1822; - const SWord32 s1830 = s1828 ^ s1829; - const SWord32 s1831 = s1817 ^ s1830; - const SWord32 s1832 = s1827 + s1831; - const SWord32 s1833 = s1778 + s1832; - const SWord32 s1834 = s1778 + s1789; - const SWord32 s1835 = (s1834 >> 6) | (s1834 << 26); - const SWord32 s1836 = (s1834 >> 11) | (s1834 << 21); - const SWord32 s1837 = s1835 ^ s1836; - const SWord32 s1838 = (s1834 >> 25) | (s1834 << 7); - const SWord32 s1839 = s1837 ^ s1838; - const SWord32 s1840 = s1695 + s1839; - const SWord32 s1841 = s1751 & s1834; - const SWord32 s1842 = ~s1834; - const SWord32 s1843 = s1723 & s1842; - const SWord32 s1844 = s1841 ^ s1843; - const SWord32 s1845 = s1840 + s1844; - const SWord32 s1847 = s1845 + 0x19a4c116UL; - const SWord32 s1848 = (s1749 >> 17) | (s1749 << 15); - const SWord32 s1849 = (s1749 >> 19) | (s1749 << 13); - const SWord32 s1850 = s1848 ^ s1849; - const SWord32 s1851 = s1749 >> 10; - const SWord32 s1852 = s1850 ^ s1851; - const SWord32 s1853 = s1576 + s1852; - const SWord32 s1854 = (s1264 >> 7) | (s1264 << 25); - const SWord32 s1855 = (s1264 >> 18) | (s1264 << 14); - const SWord32 s1856 = s1854 ^ s1855; - const SWord32 s1857 = s1264 >> 3; - const SWord32 s1858 = s1856 ^ s1857; - const SWord32 s1859 = s1853 + s1858; - const SWord32 s1860 = s1236 + s1859; - const SWord32 s1861 = s1847 + s1860; - const SWord32 s1862 = s1800 + s1861; - const SWord32 s1863 = (s1862 >> 6) | (s1862 << 26); - const SWord32 s1864 = (s1862 >> 11) | (s1862 << 21); - const SWord32 s1865 = s1863 ^ s1864; - const SWord32 s1866 = (s1862 >> 25) | (s1862 << 7); - const SWord32 s1867 = s1865 ^ s1866; - const SWord32 s1868 = s1723 + s1867; - const SWord32 s1869 = s1834 & s1862; - const SWord32 s1870 = ~s1862; - const SWord32 s1871 = s1751 & s1870; - const SWord32 s1872 = s1869 ^ s1871; - const SWord32 s1873 = s1868 + s1872; - const SWord32 s1875 = s1873 + 0x1e376c08UL; - const SWord32 s1876 = (s1777 >> 17) | (s1777 << 15); - const SWord32 s1877 = (s1777 >> 19) | (s1777 << 13); - const SWord32 s1878 = s1876 ^ s1877; - const SWord32 s1879 = s1777 >> 10; - const SWord32 s1880 = s1878 ^ s1879; - const SWord32 s1881 = s1604 + s1880; - const SWord32 s1882 = (s1292 >> 7) | (s1292 << 25); - const SWord32 s1883 = (s1292 >> 18) | (s1292 << 14); - const SWord32 s1884 = s1882 ^ s1883; - const SWord32 s1885 = s1292 >> 3; - const SWord32 s1886 = s1884 ^ s1885; - const SWord32 s1887 = s1881 + s1886; - const SWord32 s1888 = s1264 + s1887; - const SWord32 s1889 = s1875 + s1888; - const SWord32 s1890 = s1811 + s1889; - const SWord32 s1891 = (s1890 >> 6) | (s1890 << 26); - const SWord32 s1892 = (s1890 >> 11) | (s1890 << 21); - const SWord32 s1893 = s1891 ^ s1892; - const SWord32 s1894 = (s1890 >> 25) | (s1890 << 7); - const SWord32 s1895 = s1893 ^ s1894; - const SWord32 s1896 = s1751 + s1895; - const SWord32 s1897 = s1862 & s1890; - const SWord32 s1898 = ~s1890; - const SWord32 s1899 = s1834 & s1898; - const SWord32 s1900 = s1897 ^ s1899; - const SWord32 s1901 = s1896 + s1900; - const SWord32 s1903 = s1901 + 0x2748774cUL; - const SWord32 s1904 = (s1860 >> 17) | (s1860 << 15); - const SWord32 s1905 = (s1860 >> 19) | (s1860 << 13); - const SWord32 s1906 = s1904 ^ s1905; - const SWord32 s1907 = s1860 >> 10; - const SWord32 s1908 = s1906 ^ s1907; - const SWord32 s1909 = s1632 + s1908; - const SWord32 s1910 = (s1320 >> 7) | (s1320 << 25); - const SWord32 s1911 = (s1320 >> 18) | (s1320 << 14); - const SWord32 s1912 = s1910 ^ s1911; - const SWord32 s1913 = s1320 >> 3; - const SWord32 s1914 = s1912 ^ s1913; - const SWord32 s1915 = s1909 + s1914; - const SWord32 s1916 = s1292 + s1915; - const SWord32 s1917 = s1903 + s1916; - const SWord32 s1918 = s1822 + s1917; - const SWord32 s1919 = (s1918 >> 6) | (s1918 << 26); - const SWord32 s1920 = (s1918 >> 11) | (s1918 << 21); - const SWord32 s1921 = s1919 ^ s1920; - const SWord32 s1922 = (s1918 >> 25) | (s1918 << 7); - const SWord32 s1923 = s1921 ^ s1922; - const SWord32 s1924 = s1834 + s1923; - const SWord32 s1925 = s1890 & s1918; - const SWord32 s1926 = ~s1918; - const SWord32 s1927 = s1862 & s1926; - const SWord32 s1928 = s1925 ^ s1927; - const SWord32 s1929 = s1924 + s1928; - const SWord32 s1931 = s1929 + 0x34b0bcb5UL; - const SWord32 s1932 = (s1888 >> 17) | (s1888 << 15); - const SWord32 s1933 = (s1888 >> 19) | (s1888 << 13); - const SWord32 s1934 = s1932 ^ s1933; - const SWord32 s1935 = s1888 >> 10; - const SWord32 s1936 = s1934 ^ s1935; - const SWord32 s1937 = s1693 + s1936; - const SWord32 s1938 = (s1381 >> 7) | (s1381 << 25); - const SWord32 s1939 = (s1381 >> 18) | (s1381 << 14); - const SWord32 s1940 = s1938 ^ s1939; - const SWord32 s1941 = s1381 >> 3; - const SWord32 s1942 = s1940 ^ s1941; - const SWord32 s1943 = s1937 + s1942; - const SWord32 s1944 = s1320 + s1943; - const SWord32 s1945 = s1931 + s1944; - const SWord32 s1946 = s1833 + s1945; - const SWord32 s1947 = (s1833 >> 2) | (s1833 << 30); - const SWord32 s1948 = (s1833 >> 13) | (s1833 << 19); - const SWord32 s1949 = s1947 ^ s1948; - const SWord32 s1950 = (s1833 >> 22) | (s1833 << 10); - const SWord32 s1951 = s1949 ^ s1950; - const SWord32 s1952 = s1822 & s1833; - const SWord32 s1953 = s1811 & s1833; - const SWord32 s1954 = s1952 ^ s1953; - const SWord32 s1955 = s1828 ^ s1954; - const SWord32 s1956 = s1951 + s1955; - const SWord32 s1957 = s1861 + s1956; - const SWord32 s1958 = (s1957 >> 2) | (s1957 << 30); - const SWord32 s1959 = (s1957 >> 13) | (s1957 << 19); - const SWord32 s1960 = s1958 ^ s1959; - const SWord32 s1961 = (s1957 >> 22) | (s1957 << 10); - const SWord32 s1962 = s1960 ^ s1961; - const SWord32 s1963 = s1833 & s1957; - const SWord32 s1964 = s1822 & s1957; - const SWord32 s1965 = s1963 ^ s1964; - const SWord32 s1966 = s1952 ^ s1965; - const SWord32 s1967 = s1962 + s1966; - const SWord32 s1968 = s1889 + s1967; - const SWord32 s1969 = (s1968 >> 2) | (s1968 << 30); - const SWord32 s1970 = (s1968 >> 13) | (s1968 << 19); - const SWord32 s1971 = s1969 ^ s1970; - const SWord32 s1972 = (s1968 >> 22) | (s1968 << 10); - const SWord32 s1973 = s1971 ^ s1972; - const SWord32 s1974 = s1957 & s1968; - const SWord32 s1975 = s1833 & s1968; - const SWord32 s1976 = s1974 ^ s1975; - const SWord32 s1977 = s1963 ^ s1976; - const SWord32 s1978 = s1973 + s1977; - const SWord32 s1979 = s1917 + s1978; - const SWord32 s1980 = (s1946 >> 6) | (s1946 << 26); - const SWord32 s1981 = (s1946 >> 11) | (s1946 << 21); - const SWord32 s1982 = s1980 ^ s1981; - const SWord32 s1983 = (s1946 >> 25) | (s1946 << 7); - const SWord32 s1984 = s1982 ^ s1983; - const SWord32 s1985 = s1862 + s1984; - const SWord32 s1986 = s1918 & s1946; - const SWord32 s1987 = ~s1946; - const SWord32 s1988 = s1890 & s1987; - const SWord32 s1989 = s1986 ^ s1988; - const SWord32 s1990 = s1985 + s1989; - const SWord32 s1992 = s1990 + 0x391c0cb3UL; - const SWord32 s1993 = (s1916 >> 17) | (s1916 << 15); - const SWord32 s1994 = (s1916 >> 19) | (s1916 << 13); - const SWord32 s1995 = s1993 ^ s1994; - const SWord32 s1996 = s1916 >> 10; - const SWord32 s1997 = s1995 ^ s1996; - const SWord32 s1998 = s1721 + s1997; - const SWord32 s1999 = (s1409 >> 7) | (s1409 << 25); - const SWord32 s2000 = (s1409 >> 18) | (s1409 << 14); - const SWord32 s2001 = s1999 ^ s2000; - const SWord32 s2002 = s1409 >> 3; - const SWord32 s2003 = s2001 ^ s2002; - const SWord32 s2004 = s1998 + s2003; - const SWord32 s2005 = s1381 + s2004; - const SWord32 s2006 = s1992 + s2005; - const SWord32 s2007 = s1957 + s2006; - const SWord32 s2008 = (s2007 >> 6) | (s2007 << 26); - const SWord32 s2009 = (s2007 >> 11) | (s2007 << 21); - const SWord32 s2010 = s2008 ^ s2009; - const SWord32 s2011 = (s2007 >> 25) | (s2007 << 7); - const SWord32 s2012 = s2010 ^ s2011; - const SWord32 s2013 = s1890 + s2012; - const SWord32 s2014 = s1946 & s2007; - const SWord32 s2015 = ~s2007; - const SWord32 s2016 = s1918 & s2015; - const SWord32 s2017 = s2014 ^ s2016; - const SWord32 s2018 = s2013 + s2017; - const SWord32 s2020 = s2018 + 0x4ed8aa4aUL; - const SWord32 s2021 = (s1944 >> 17) | (s1944 << 15); - const SWord32 s2022 = (s1944 >> 19) | (s1944 << 13); - const SWord32 s2023 = s2021 ^ s2022; - const SWord32 s2024 = s1944 >> 10; - const SWord32 s2025 = s2023 ^ s2024; - const SWord32 s2026 = s1749 + s2025; - const SWord32 s2027 = (s1437 >> 7) | (s1437 << 25); - const SWord32 s2028 = (s1437 >> 18) | (s1437 << 14); - const SWord32 s2029 = s2027 ^ s2028; - const SWord32 s2030 = s1437 >> 3; - const SWord32 s2031 = s2029 ^ s2030; - const SWord32 s2032 = s2026 + s2031; - const SWord32 s2033 = s1409 + s2032; - const SWord32 s2034 = s2020 + s2033; - const SWord32 s2035 = s1968 + s2034; - const SWord32 s2036 = (s2035 >> 6) | (s2035 << 26); - const SWord32 s2037 = (s2035 >> 11) | (s2035 << 21); - const SWord32 s2038 = s2036 ^ s2037; - const SWord32 s2039 = (s2035 >> 25) | (s2035 << 7); - const SWord32 s2040 = s2038 ^ s2039; - const SWord32 s2041 = s1918 + s2040; - const SWord32 s2042 = s2007 & s2035; - const SWord32 s2043 = ~s2035; - const SWord32 s2044 = s1946 & s2043; - const SWord32 s2045 = s2042 ^ s2044; - const SWord32 s2046 = s2041 + s2045; - const SWord32 s2048 = s2046 + 0x5b9cca4fUL; - const SWord32 s2049 = (s2005 >> 17) | (s2005 << 15); - const SWord32 s2050 = (s2005 >> 19) | (s2005 << 13); - const SWord32 s2051 = s2049 ^ s2050; - const SWord32 s2052 = s2005 >> 10; - const SWord32 s2053 = s2051 ^ s2052; - const SWord32 s2054 = s1777 + s2053; - const SWord32 s2055 = (s1465 >> 7) | (s1465 << 25); - const SWord32 s2056 = (s1465 >> 18) | (s1465 << 14); - const SWord32 s2057 = s2055 ^ s2056; - const SWord32 s2058 = s1465 >> 3; - const SWord32 s2059 = s2057 ^ s2058; - const SWord32 s2060 = s2054 + s2059; - const SWord32 s2061 = s1437 + s2060; - const SWord32 s2062 = s2048 + s2061; - const SWord32 s2063 = s1979 + s2062; - const SWord32 s2064 = (s2063 >> 6) | (s2063 << 26); - const SWord32 s2065 = (s2063 >> 11) | (s2063 << 21); - const SWord32 s2066 = s2064 ^ s2065; - const SWord32 s2067 = (s2063 >> 25) | (s2063 << 7); - const SWord32 s2068 = s2066 ^ s2067; - const SWord32 s2069 = s1946 + s2068; - const SWord32 s2070 = s2035 & s2063; - const SWord32 s2071 = ~s2063; - const SWord32 s2072 = s2007 & s2071; - const SWord32 s2073 = s2070 ^ s2072; - const SWord32 s2074 = s2069 + s2073; - const SWord32 s2076 = s2074 + 0x682e6ff3UL; - const SWord32 s2077 = (s2033 >> 17) | (s2033 << 15); - const SWord32 s2078 = (s2033 >> 19) | (s2033 << 13); - const SWord32 s2079 = s2077 ^ s2078; - const SWord32 s2080 = s2033 >> 10; - const SWord32 s2081 = s2079 ^ s2080; - const SWord32 s2082 = s1860 + s2081; - const SWord32 s2083 = (s1548 >> 7) | (s1548 << 25); - const SWord32 s2084 = (s1548 >> 18) | (s1548 << 14); - const SWord32 s2085 = s2083 ^ s2084; - const SWord32 s2086 = s1548 >> 3; - const SWord32 s2087 = s2085 ^ s2086; - const SWord32 s2088 = s2082 + s2087; - const SWord32 s2089 = s1465 + s2088; - const SWord32 s2090 = s2076 + s2089; - const SWord32 s2091 = (s1979 >> 2) | (s1979 << 30); - const SWord32 s2092 = (s1979 >> 13) | (s1979 << 19); - const SWord32 s2093 = s2091 ^ s2092; - const SWord32 s2094 = (s1979 >> 22) | (s1979 << 10); - const SWord32 s2095 = s2093 ^ s2094; - const SWord32 s2096 = s1968 & s1979; - const SWord32 s2097 = s1957 & s1979; - const SWord32 s2098 = s2096 ^ s2097; - const SWord32 s2099 = s1974 ^ s2098; - const SWord32 s2100 = s2095 + s2099; - const SWord32 s2101 = s1945 + s2100; - const SWord32 s2102 = (s2101 >> 2) | (s2101 << 30); - const SWord32 s2103 = (s2101 >> 13) | (s2101 << 19); - const SWord32 s2104 = s2102 ^ s2103; - const SWord32 s2105 = (s2101 >> 22) | (s2101 << 10); - const SWord32 s2106 = s2104 ^ s2105; - const SWord32 s2107 = s1979 & s2101; - const SWord32 s2108 = s1968 & s2101; - const SWord32 s2109 = s2107 ^ s2108; - const SWord32 s2110 = s2096 ^ s2109; - const SWord32 s2111 = s2106 + s2110; - const SWord32 s2112 = s2006 + s2111; - const SWord32 s2113 = (s2112 >> 2) | (s2112 << 30); - const SWord32 s2114 = (s2112 >> 13) | (s2112 << 19); - const SWord32 s2115 = s2113 ^ s2114; - const SWord32 s2116 = (s2112 >> 22) | (s2112 << 10); - const SWord32 s2117 = s2115 ^ s2116; - const SWord32 s2118 = s2101 & s2112; - const SWord32 s2119 = s1979 & s2112; - const SWord32 s2120 = s2118 ^ s2119; - const SWord32 s2121 = s2107 ^ s2120; - const SWord32 s2122 = s2117 + s2121; - const SWord32 s2123 = s2034 + s2122; - const SWord32 s2124 = (s2123 >> 2) | (s2123 << 30); - const SWord32 s2125 = (s2123 >> 13) | (s2123 << 19); - const SWord32 s2126 = s2124 ^ s2125; - const SWord32 s2127 = (s2123 >> 22) | (s2123 << 10); - const SWord32 s2128 = s2126 ^ s2127; - const SWord32 s2129 = s2112 & s2123; - const SWord32 s2130 = s2101 & s2123; - const SWord32 s2131 = s2129 ^ s2130; - const SWord32 s2132 = s2118 ^ s2131; - const SWord32 s2133 = s2128 + s2132; - const SWord32 s2134 = s2062 + s2133; - const SWord32 s2135 = (s2134 >> 2) | (s2134 << 30); - const SWord32 s2136 = (s2134 >> 13) | (s2134 << 19); - const SWord32 s2137 = s2135 ^ s2136; - const SWord32 s2138 = (s2134 >> 22) | (s2134 << 10); - const SWord32 s2139 = s2137 ^ s2138; - const SWord32 s2140 = s2123 & s2134; - const SWord32 s2141 = s2112 & s2134; - const SWord32 s2142 = s2140 ^ s2141; - const SWord32 s2143 = s2129 ^ s2142; - const SWord32 s2144 = s2139 + s2143; - const SWord32 s2145 = s2090 + s2144; - const SWord32 s2146 = s2090 + s2101; - const SWord32 s2147 = (s2146 >> 6) | (s2146 << 26); - const SWord32 s2148 = (s2146 >> 11) | (s2146 << 21); - const SWord32 s2149 = s2147 ^ s2148; - const SWord32 s2150 = (s2146 >> 25) | (s2146 << 7); - const SWord32 s2151 = s2149 ^ s2150; - const SWord32 s2152 = s2007 + s2151; - const SWord32 s2153 = s2063 & s2146; - const SWord32 s2154 = ~s2146; - const SWord32 s2155 = s2035 & s2154; - const SWord32 s2156 = s2153 ^ s2155; - const SWord32 s2157 = s2152 + s2156; - const SWord32 s2159 = s2157 + 0x748f82eeUL; - const SWord32 s2160 = (s2061 >> 17) | (s2061 << 15); - const SWord32 s2161 = (s2061 >> 19) | (s2061 << 13); - const SWord32 s2162 = s2160 ^ s2161; - const SWord32 s2163 = s2061 >> 10; - const SWord32 s2164 = s2162 ^ s2163; - const SWord32 s2165 = s1888 + s2164; - const SWord32 s2166 = (s1576 >> 7) | (s1576 << 25); - const SWord32 s2167 = (s1576 >> 18) | (s1576 << 14); - const SWord32 s2168 = s2166 ^ s2167; - const SWord32 s2169 = s1576 >> 3; - const SWord32 s2170 = s2168 ^ s2169; - const SWord32 s2171 = s2165 + s2170; - const SWord32 s2172 = s1548 + s2171; - const SWord32 s2173 = s2159 + s2172; - const SWord32 s2174 = s2112 + s2173; - const SWord32 s2175 = (s2174 >> 6) | (s2174 << 26); - const SWord32 s2176 = (s2174 >> 11) | (s2174 << 21); - const SWord32 s2177 = s2175 ^ s2176; - const SWord32 s2178 = (s2174 >> 25) | (s2174 << 7); - const SWord32 s2179 = s2177 ^ s2178; - const SWord32 s2180 = s2035 + s2179; - const SWord32 s2181 = s2146 & s2174; - const SWord32 s2182 = ~s2174; - const SWord32 s2183 = s2063 & s2182; - const SWord32 s2184 = s2181 ^ s2183; - const SWord32 s2185 = s2180 + s2184; - const SWord32 s2187 = s2185 + 0x78a5636fUL; - const SWord32 s2188 = (s2089 >> 17) | (s2089 << 15); - const SWord32 s2189 = (s2089 >> 19) | (s2089 << 13); - const SWord32 s2190 = s2188 ^ s2189; - const SWord32 s2191 = s2089 >> 10; - const SWord32 s2192 = s2190 ^ s2191; - const SWord32 s2193 = s1916 + s2192; - const SWord32 s2194 = (s1604 >> 7) | (s1604 << 25); - const SWord32 s2195 = (s1604 >> 18) | (s1604 << 14); - const SWord32 s2196 = s2194 ^ s2195; - const SWord32 s2197 = s1604 >> 3; - const SWord32 s2198 = s2196 ^ s2197; - const SWord32 s2199 = s2193 + s2198; - const SWord32 s2200 = s1576 + s2199; - const SWord32 s2201 = s2187 + s2200; - const SWord32 s2202 = s2123 + s2201; - const SWord32 s2203 = (s2202 >> 6) | (s2202 << 26); - const SWord32 s2204 = (s2202 >> 11) | (s2202 << 21); - const SWord32 s2205 = s2203 ^ s2204; - const SWord32 s2206 = (s2202 >> 25) | (s2202 << 7); - const SWord32 s2207 = s2205 ^ s2206; - const SWord32 s2208 = s2063 + s2207; - const SWord32 s2209 = s2174 & s2202; - const SWord32 s2210 = ~s2202; - const SWord32 s2211 = s2146 & s2210; - const SWord32 s2212 = s2209 ^ s2211; - const SWord32 s2213 = s2208 + s2212; - const SWord32 s2215 = s2213 + 0x84c87814UL; - const SWord32 s2216 = (s2172 >> 17) | (s2172 << 15); - const SWord32 s2217 = (s2172 >> 19) | (s2172 << 13); - const SWord32 s2218 = s2216 ^ s2217; - const SWord32 s2219 = s2172 >> 10; - const SWord32 s2220 = s2218 ^ s2219; - const SWord32 s2221 = s1944 + s2220; - const SWord32 s2222 = (s1632 >> 7) | (s1632 << 25); - const SWord32 s2223 = (s1632 >> 18) | (s1632 << 14); - const SWord32 s2224 = s2222 ^ s2223; - const SWord32 s2225 = s1632 >> 3; - const SWord32 s2226 = s2224 ^ s2225; - const SWord32 s2227 = s2221 + s2226; - const SWord32 s2228 = s1604 + s2227; - const SWord32 s2229 = s2215 + s2228; - const SWord32 s2230 = s2134 + s2229; - const SWord32 s2231 = (s2230 >> 6) | (s2230 << 26); - const SWord32 s2232 = (s2230 >> 11) | (s2230 << 21); - const SWord32 s2233 = s2231 ^ s2232; - const SWord32 s2234 = (s2230 >> 25) | (s2230 << 7); - const SWord32 s2235 = s2233 ^ s2234; - const SWord32 s2236 = s2146 + s2235; - const SWord32 s2237 = s2202 & s2230; - const SWord32 s2238 = ~s2230; - const SWord32 s2239 = s2174 & s2238; - const SWord32 s2240 = s2237 ^ s2239; - const SWord32 s2241 = s2236 + s2240; - const SWord32 s2243 = s2241 + 0x8cc70208UL; - const SWord32 s2244 = (s2200 >> 17) | (s2200 << 15); - const SWord32 s2245 = (s2200 >> 19) | (s2200 << 13); - const SWord32 s2246 = s2244 ^ s2245; - const SWord32 s2247 = s2200 >> 10; - const SWord32 s2248 = s2246 ^ s2247; - const SWord32 s2249 = s2005 + s2248; - const SWord32 s2250 = (s1693 >> 7) | (s1693 << 25); - const SWord32 s2251 = (s1693 >> 18) | (s1693 << 14); - const SWord32 s2252 = s2250 ^ s2251; - const SWord32 s2253 = s1693 >> 3; - const SWord32 s2254 = s2252 ^ s2253; - const SWord32 s2255 = s2249 + s2254; - const SWord32 s2256 = s1632 + s2255; - const SWord32 s2257 = s2243 + s2256; - const SWord32 s2258 = s2145 + s2257; - const SWord32 s2259 = (s2145 >> 2) | (s2145 << 30); - const SWord32 s2260 = (s2145 >> 13) | (s2145 << 19); - const SWord32 s2261 = s2259 ^ s2260; - const SWord32 s2262 = (s2145 >> 22) | (s2145 << 10); - const SWord32 s2263 = s2261 ^ s2262; - const SWord32 s2264 = s2134 & s2145; - const SWord32 s2265 = s2123 & s2145; - const SWord32 s2266 = s2264 ^ s2265; - const SWord32 s2267 = s2140 ^ s2266; - const SWord32 s2268 = s2263 + s2267; - const SWord32 s2269 = s2173 + s2268; - const SWord32 s2270 = (s2269 >> 2) | (s2269 << 30); - const SWord32 s2271 = (s2269 >> 13) | (s2269 << 19); - const SWord32 s2272 = s2270 ^ s2271; - const SWord32 s2273 = (s2269 >> 22) | (s2269 << 10); - const SWord32 s2274 = s2272 ^ s2273; - const SWord32 s2275 = s2145 & s2269; - const SWord32 s2276 = s2134 & s2269; - const SWord32 s2277 = s2275 ^ s2276; - const SWord32 s2278 = s2264 ^ s2277; - const SWord32 s2279 = s2274 + s2278; - const SWord32 s2280 = s2201 + s2279; - const SWord32 s2281 = (s2280 >> 2) | (s2280 << 30); - const SWord32 s2282 = (s2280 >> 13) | (s2280 << 19); - const SWord32 s2283 = s2281 ^ s2282; - const SWord32 s2284 = (s2280 >> 22) | (s2280 << 10); - const SWord32 s2285 = s2283 ^ s2284; - const SWord32 s2286 = s2269 & s2280; - const SWord32 s2287 = s2145 & s2280; - const SWord32 s2288 = s2286 ^ s2287; - const SWord32 s2289 = s2275 ^ s2288; - const SWord32 s2290 = s2285 + s2289; - const SWord32 s2291 = s2229 + s2290; - const SWord32 s2292 = (s2258 >> 6) | (s2258 << 26); - const SWord32 s2293 = (s2258 >> 11) | (s2258 << 21); - const SWord32 s2294 = s2292 ^ s2293; - const SWord32 s2295 = (s2258 >> 25) | (s2258 << 7); - const SWord32 s2296 = s2294 ^ s2295; - const SWord32 s2297 = s2174 + s2296; - const SWord32 s2298 = s2230 & s2258; - const SWord32 s2299 = ~s2258; - const SWord32 s2300 = s2202 & s2299; - const SWord32 s2301 = s2298 ^ s2300; - const SWord32 s2302 = s2297 + s2301; - const SWord32 s2304 = s2302 + 0x90befffaUL; - const SWord32 s2305 = (s2228 >> 17) | (s2228 << 15); - const SWord32 s2306 = (s2228 >> 19) | (s2228 << 13); - const SWord32 s2307 = s2305 ^ s2306; - const SWord32 s2308 = s2228 >> 10; - const SWord32 s2309 = s2307 ^ s2308; - const SWord32 s2310 = s2033 + s2309; - const SWord32 s2311 = (s1721 >> 7) | (s1721 << 25); - const SWord32 s2312 = (s1721 >> 18) | (s1721 << 14); - const SWord32 s2313 = s2311 ^ s2312; - const SWord32 s2314 = s1721 >> 3; - const SWord32 s2315 = s2313 ^ s2314; - const SWord32 s2316 = s2310 + s2315; - const SWord32 s2317 = s1693 + s2316; - const SWord32 s2318 = s2304 + s2317; - const SWord32 s2319 = s2269 + s2318; - const SWord32 s2320 = (s2319 >> 6) | (s2319 << 26); - const SWord32 s2321 = (s2319 >> 11) | (s2319 << 21); - const SWord32 s2322 = s2320 ^ s2321; - const SWord32 s2323 = (s2319 >> 25) | (s2319 << 7); - const SWord32 s2324 = s2322 ^ s2323; - const SWord32 s2325 = s2202 + s2324; - const SWord32 s2326 = s2258 & s2319; - const SWord32 s2327 = ~s2319; - const SWord32 s2328 = s2230 & s2327; - const SWord32 s2329 = s2326 ^ s2328; - const SWord32 s2330 = s2325 + s2329; - const SWord32 s2332 = s2330 + 0xa4506cebUL; - const SWord32 s2333 = (s2256 >> 17) | (s2256 << 15); - const SWord32 s2334 = (s2256 >> 19) | (s2256 << 13); - const SWord32 s2335 = s2333 ^ s2334; - const SWord32 s2336 = s2256 >> 10; - const SWord32 s2337 = s2335 ^ s2336; - const SWord32 s2338 = s2061 + s2337; - const SWord32 s2339 = (s1749 >> 7) | (s1749 << 25); - const SWord32 s2340 = (s1749 >> 18) | (s1749 << 14); - const SWord32 s2341 = s2339 ^ s2340; - const SWord32 s2342 = s1749 >> 3; - const SWord32 s2343 = s2341 ^ s2342; - const SWord32 s2344 = s2338 + s2343; - const SWord32 s2345 = s1721 + s2344; - const SWord32 s2346 = s2332 + s2345; - const SWord32 s2347 = s2280 + s2346; - const SWord32 s2348 = (s2347 >> 6) | (s2347 << 26); - const SWord32 s2349 = (s2347 >> 11) | (s2347 << 21); - const SWord32 s2350 = s2348 ^ s2349; - const SWord32 s2351 = (s2347 >> 25) | (s2347 << 7); - const SWord32 s2352 = s2350 ^ s2351; - const SWord32 s2353 = s2230 + s2352; - const SWord32 s2354 = s2319 & s2347; - const SWord32 s2355 = ~s2347; - const SWord32 s2356 = s2258 & s2355; - const SWord32 s2357 = s2354 ^ s2356; - const SWord32 s2358 = s2353 + s2357; - const SWord32 s2360 = s2358 + 0xbef9a3f7UL; - const SWord32 s2361 = (s2317 >> 17) | (s2317 << 15); - const SWord32 s2362 = (s2317 >> 19) | (s2317 << 13); - const SWord32 s2363 = s2361 ^ s2362; - const SWord32 s2364 = s2317 >> 10; - const SWord32 s2365 = s2363 ^ s2364; - const SWord32 s2366 = s2089 + s2365; - const SWord32 s2367 = (s1777 >> 7) | (s1777 << 25); - const SWord32 s2368 = (s1777 >> 18) | (s1777 << 14); - const SWord32 s2369 = s2367 ^ s2368; - const SWord32 s2370 = s1777 >> 3; - const SWord32 s2371 = s2369 ^ s2370; - const SWord32 s2372 = s2366 + s2371; - const SWord32 s2373 = s1749 + s2372; - const SWord32 s2374 = s2360 + s2373; - const SWord32 s2375 = s2291 + s2374; - const SWord32 s2376 = (s2375 >> 6) | (s2375 << 26); - const SWord32 s2377 = (s2375 >> 11) | (s2375 << 21); - const SWord32 s2378 = s2376 ^ s2377; - const SWord32 s2379 = (s2375 >> 25) | (s2375 << 7); - const SWord32 s2380 = s2378 ^ s2379; - const SWord32 s2381 = s2258 + s2380; - const SWord32 s2382 = s2347 & s2375; - const SWord32 s2383 = ~s2375; - const SWord32 s2384 = s2319 & s2383; - const SWord32 s2385 = s2382 ^ s2384; - const SWord32 s2386 = s2381 + s2385; - const SWord32 s2388 = s2386 + 0xc67178f2UL; - const SWord32 s2389 = (s2345 >> 17) | (s2345 << 15); - const SWord32 s2390 = (s2345 >> 19) | (s2345 << 13); - const SWord32 s2391 = s2389 ^ s2390; - const SWord32 s2392 = s2345 >> 10; - const SWord32 s2393 = s2391 ^ s2392; - const SWord32 s2394 = s2172 + s2393; - const SWord32 s2395 = (s1860 >> 7) | (s1860 << 25); - const SWord32 s2396 = (s1860 >> 18) | (s1860 << 14); - const SWord32 s2397 = s2395 ^ s2396; - const SWord32 s2398 = s1860 >> 3; - const SWord32 s2399 = s2397 ^ s2398; - const SWord32 s2400 = s2394 + s2399; - const SWord32 s2401 = s1777 + s2400; - const SWord32 s2402 = s2388 + s2401; - const SWord32 s2403 = (s2291 >> 2) | (s2291 << 30); - const SWord32 s2404 = (s2291 >> 13) | (s2291 << 19); - const SWord32 s2405 = s2403 ^ s2404; - const SWord32 s2406 = (s2291 >> 22) | (s2291 << 10); - const SWord32 s2407 = s2405 ^ s2406; - const SWord32 s2408 = s2280 & s2291; - const SWord32 s2409 = s2269 & s2291; - const SWord32 s2410 = s2408 ^ s2409; - const SWord32 s2411 = s2286 ^ s2410; - const SWord32 s2412 = s2407 + s2411; - const SWord32 s2413 = s2257 + s2412; - const SWord32 s2414 = (s2413 >> 2) | (s2413 << 30); - const SWord32 s2415 = (s2413 >> 13) | (s2413 << 19); - const SWord32 s2416 = s2414 ^ s2415; - const SWord32 s2417 = (s2413 >> 22) | (s2413 << 10); - const SWord32 s2418 = s2416 ^ s2417; - const SWord32 s2419 = s2291 & s2413; - const SWord32 s2420 = s2280 & s2413; - const SWord32 s2421 = s2419 ^ s2420; - const SWord32 s2422 = s2408 ^ s2421; - const SWord32 s2423 = s2418 + s2422; - const SWord32 s2424 = s2318 + s2423; - const SWord32 s2425 = (s2424 >> 2) | (s2424 << 30); - const SWord32 s2426 = (s2424 >> 13) | (s2424 << 19); - const SWord32 s2427 = s2425 ^ s2426; - const SWord32 s2428 = (s2424 >> 22) | (s2424 << 10); - const SWord32 s2429 = s2427 ^ s2428; - const SWord32 s2430 = s2413 & s2424; - const SWord32 s2431 = s2291 & s2424; - const SWord32 s2432 = s2430 ^ s2431; - const SWord32 s2433 = s2419 ^ s2432; - const SWord32 s2434 = s2429 + s2433; - const SWord32 s2435 = s2346 + s2434; - const SWord32 s2436 = (s2435 >> 2) | (s2435 << 30); - const SWord32 s2437 = (s2435 >> 13) | (s2435 << 19); - const SWord32 s2438 = s2436 ^ s2437; - const SWord32 s2439 = (s2435 >> 22) | (s2435 << 10); - const SWord32 s2440 = s2438 ^ s2439; - const SWord32 s2441 = s2424 & s2435; - const SWord32 s2442 = s2413 & s2435; - const SWord32 s2443 = s2441 ^ s2442; - const SWord32 s2444 = s2430 ^ s2443; - const SWord32 s2445 = s2440 + s2444; - const SWord32 s2446 = s2374 + s2445; - const SWord32 s2447 = (s2446 >> 2) | (s2446 << 30); - const SWord32 s2448 = (s2446 >> 13) | (s2446 << 19); - const SWord32 s2449 = s2447 ^ s2448; - const SWord32 s2450 = (s2446 >> 22) | (s2446 << 10); - const SWord32 s2451 = s2449 ^ s2450; - const SWord32 s2452 = s2435 & s2446; - const SWord32 s2453 = s2424 & s2446; - const SWord32 s2454 = s2452 ^ s2453; - const SWord32 s2455 = s2441 ^ s2454; - const SWord32 s2456 = s2451 + s2455; - const SWord32 s2457 = s2402 + s2456; - const SWord32 s2458 = s98 + s2457; - const SWord8 s2459 = (SWord8) (s2458 >> 24); - const SWord8 s2460 = (SWord8) (s2458 >> 16); - const SWord8 s2461 = (SWord8) (s2458 >> 8); - const SWord8 s2462 = (SWord8) s2458; - const SWord32 s2463 = s104 + s2446; - const SWord8 s2464 = (SWord8) (s2463 >> 24); - const SWord8 s2465 = (SWord8) (s2463 >> 16); - const SWord8 s2466 = (SWord8) (s2463 >> 8); - const SWord8 s2467 = (SWord8) s2463; - const SWord32 s2468 = s110 + s2435; - const SWord8 s2469 = (SWord8) (s2468 >> 24); - const SWord8 s2470 = (SWord8) (s2468 >> 16); - const SWord8 s2471 = (SWord8) (s2468 >> 8); - const SWord8 s2472 = (SWord8) s2468; - const SWord32 s2473 = s116 + s2424; - const SWord8 s2474 = (SWord8) (s2473 >> 24); - const SWord8 s2475 = (SWord8) (s2473 >> 16); - const SWord8 s2476 = (SWord8) (s2473 >> 8); - const SWord8 s2477 = (SWord8) s2473; - const SWord32 s2478 = s2402 + s2413; - const SWord32 s2479 = s101 + s2478; - const SWord8 s2480 = (SWord8) (s2479 >> 24); - const SWord8 s2481 = (SWord8) (s2479 >> 16); - const SWord8 s2482 = (SWord8) (s2479 >> 8); - const SWord8 s2483 = (SWord8) s2479; - const SWord32 s2484 = s107 + s2375; - const SWord8 s2485 = (SWord8) (s2484 >> 24); - const SWord8 s2486 = (SWord8) (s2484 >> 16); - const SWord8 s2487 = (SWord8) (s2484 >> 8); - const SWord8 s2488 = (SWord8) s2484; - const SWord32 s2489 = s113 + s2347; - const SWord8 s2490 = (SWord8) (s2489 >> 24); - const SWord8 s2491 = (SWord8) (s2489 >> 16); - const SWord8 s2492 = (SWord8) (s2489 >> 8); - const SWord8 s2493 = (SWord8) s2489; - const SWord32 s2494 = s119 + s2319; - const SWord8 s2495 = (SWord8) (s2494 >> 24); - const SWord8 s2496 = (SWord8) (s2494 >> 16); - const SWord8 s2497 = (SWord8) (s2494 >> 8); - const SWord8 s2498 = (SWord8) s2494; - - hash[0] = s2459; - hash[1] = s2460; - hash[2] = s2461; - hash[3] = s2462; - hash[4] = s2464; - hash[5] = s2465; - hash[6] = s2466; - hash[7] = s2467; - hash[8] = s2469; - hash[9] = s2470; - hash[10] = s2471; - hash[11] = s2472; - hash[12] = s2474; - hash[13] = s2475; - hash[14] = s2476; - hash[15] = s2477; - hash[16] = s2480; - hash[17] = s2481; - hash[18] = s2482; - hash[19] = s2483; - hash[20] = s2485; - hash[21] = s2486; - hash[22] = s2487; - hash[23] = s2488; - hash[24] = s2490; - hash[25] = s2491; - hash[26] = s2492; - hash[27] = s2493; - hash[28] = s2495; - hash[29] = s2496; - hash[30] = s2497; - hash[31] = s2498; +sha256HashBlock_driver.o: sha256HashBlock_driver.c sha256HashBlock.h + ${CC} ${CCFLAGS} -c $< -o $@ + +sha256HashBlock_driver: sha256HashBlock.o sha256HashBlock_driver.o + ${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} + +clean: + rm -f *.o + +veryclean: clean + rm -f sha256HashBlock_driver +== END: "Makefile" ================== +== BEGIN: "sha256HashBlock.h" ================ +/* Header file for sha256HashBlock. Automatically generated by SBV. Do not edit! */ + +#ifndef SBV_GENERATED_sha256HashBlock_HEADER_INCLUDED +#define SBV_GENERATED_sha256HashBlock_HEADER_INCLUDED + + +#include +#include +#include +#include +#include +#include +#include + +/* Floating-point calling convention: + * Enter generated code in FE_TONEAREST (round-to-nearest, ties-to-even). + * Callbacks must preserve this mode before returning or re-entering. + * Generated code does not check or change the hardware rounding mode. + * Custom builds must disable implicit FP contraction, including at LTO link time. + */ + +/* The boolean type */ +typedef bool SBool; + +/* The float type */ +typedef float SFloat; + +/* The double type */ +typedef double SDouble; + +/* Unsigned bit-vectors */ +typedef uint8_t SWord8; +typedef uint16_t SWord16; +typedef uint32_t SWord32; +typedef uint64_t SWord64; + +/* Signed bit-vectors */ +typedef int8_t SInt8; +typedef int16_t SInt16; +typedef int32_t SInt32; +typedef int64_t SInt64; + +/* Entry point prototype: */ +void sha256HashBlock(const SWord8 *hIn, const SWord8 *block, + SWord8 *hash); + +#endif /* SBV_GENERATED_sha256HashBlock_HEADER_INCLUDED */ +== END: "sha256HashBlock.h" ================== +== BEGIN: "sha256HashBlock_driver.c" ================ +/* Example driver program for sha256HashBlock. */ +/* Automatically generated by SBV. Edit as you see fit! */ + +#include +#include "sha256HashBlock.h" + +int main(void) +{ + const SWord8 sbv_driver_input_0[32] = { + 0x6a, 0x09, 0xe6, 0x67, 0xbb, 0x67, 0xae, 0x85, 0x3c, 0x6e, 0xf3, + 0x72, 0xa5, 0x4f, 0xf5, 0x3a, 0x51, 0x0e, 0x52, 0x7f, 0x9b, 0x05, + 0x68, 0x8c, 0x1f, 0x83, 0xd9, 0xab, 0x5b, 0xe0, 0xcd, 0x19 + }; + + printf("Contents of input array hIn:\n"); + int sbv_driver_input_0_ctr; + for(sbv_driver_input_0_ctr = 0; sbv_driver_input_0_ctr < 32 ; ++sbv_driver_input_0_ctr) + { printf(" hIn[%2d] = ", sbv_driver_input_0_ctr); + printf("0x%02"PRIx8"", sbv_driver_input_0[sbv_driver_input_0_ctr]); + printf("\n"); + } + + const SWord8 sbv_driver_input_1[64] = { + 0x53, 0x42, 0x56, 0x20, 0x67, 0x6f, 0x65, 0x73, 0x20, 0x53, 0x48, + 0x41, 0x32, 0x35, 0x36, 0x21, 0x21, 0x80, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88 + }; + + printf("Contents of input array block:\n"); + int sbv_driver_input_1_ctr; + for(sbv_driver_input_1_ctr = 0; sbv_driver_input_1_ctr < 64 ; ++sbv_driver_input_1_ctr) + { printf(" block[%2d] = ", sbv_driver_input_1_ctr); + printf("0x%02"PRIx8"", sbv_driver_input_1[sbv_driver_input_1_ctr]); + printf("\n"); + } + + SWord8 sbv_driver_output_0[32]; + + sha256HashBlock(sbv_driver_input_0, sbv_driver_input_1, + sbv_driver_output_0); + + printf("sha256HashBlock(hIn, block, hash) ->\n"); + int sbv_driver_output_0_ctr; + for(sbv_driver_output_0_ctr = 0; sbv_driver_output_0_ctr < 32 ; ++sbv_driver_output_0_ctr) + { printf(" hash[%2d] = ", sbv_driver_output_0_ctr); + printf("0x%02"PRIx8"", sbv_driver_output_0[sbv_driver_output_0_ctr]); + printf("\n"); + } + + return 0; +} +== END: "sha256HashBlock_driver.c" ================== +== BEGIN: "sha256HashBlock.c" ================ +/* File: "sha256HashBlock.c". Automatically generated by SBV. Do not edit! */ + +#include "sha256HashBlock.h" + +/* Exact bit-vector runtime. All arithmetic is modulo the declared width. */ +#ifndef SBV_CGEN_UNUSED +#if defined(__GNUC__) || defined(__clang__) +#define SBV_CGEN_UNUSED __attribute__((unused)) +#else +#define SBV_CGEN_UNUSED +#endif +#endif + +static inline SBV_CGEN_UNUSED SWord16 sbv_bv_join_u8_u8_u16(SWord8 high, SWord8 low) +{ + SWord16 r = (SWord16) 0; uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 8; ++i) { r = (SWord16) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 8))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_join_u16_u16_u32(SWord16 high, SWord16 low) +{ + SWord32 r = (SWord32) 0; uint64_t i; + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) low) >> (i)) & UINT64_C(1)) != 0) << (i))); } + for (i = 0; i < 16; ++i) { r = (SWord32) ((uint64_t) r | ((uint64_t) (((((uint64_t) high) >> (i)) & UINT64_C(1)) != 0) << (i + 16))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotl(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) << amount) | (((uint64_t) (SWord32) a) >> (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_rotr(SWord32 a, uint64_t amount) +{ + amount %= 32; + if (amount == 0) return a; + return (SWord32) ((((uint64_t) (SWord32) a) >> amount) | (((uint64_t) (SWord32) a) << (32 - amount))); +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_add(SWord32 a, SWord32 b) +{ + const SWord32 bits = (SWord32) ((((uint64_t) (SWord32) a) + ((uint64_t) (SWord32) b)) & UINT64_C(0x00000000ffffffff)); + return (SWord32) bits; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_shl(SWord32 a, SWord32 amount) +{ + const uint64_t n = (uint64_t) (SWord32) amount; + const SWord32 result = n >= 32 ? (SWord32) 0 : (SWord32) ((uint64_t) (SWord32) a << n); + return result; +} + +static inline SBV_CGEN_UNUSED SWord32 sbv_bv_u32_lshr(SWord32 a, SWord32 amount) +{ + const uint64_t n = (uint64_t) (SWord32) amount; + return n >= 32 ? (SWord32) 0 : (SWord32) ((uint64_t) (SWord32) a >> n); +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_31_24_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 24)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_23_16_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 16)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_15_8_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i + 8)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + +static inline SBV_CGEN_UNUSED SWord8 sbv_bv_extract_u32_7_0_u8(SWord32 a) +{ + SWord8 r = (SWord8) 0; + uint64_t i; + for (i = 0; i < 8; ++i) { r = (SWord8) ((uint64_t) r | ((uint64_t) (((((uint64_t) a) >> (i)) & UINT64_C(1)) != 0) << (i))); } + return r; +} + + +void sha256HashBlock(const SWord8 *sbv_input_0, + const SWord8 *sbv_input_1, SWord8 *sbv_output_0) +{ + const SWord8 s0 = sbv_input_0[0]; + const SWord8 s1 = sbv_input_0[1]; + const SWord8 s2 = sbv_input_0[2]; + const SWord8 s3 = sbv_input_0[3]; + const SWord8 s4 = sbv_input_0[4]; + const SWord8 s5 = sbv_input_0[5]; + const SWord8 s6 = sbv_input_0[6]; + const SWord8 s7 = sbv_input_0[7]; + const SWord8 s8 = sbv_input_0[8]; + const SWord8 s9 = sbv_input_0[9]; + const SWord8 s10 = sbv_input_0[10]; + const SWord8 s11 = sbv_input_0[11]; + const SWord8 s12 = sbv_input_0[12]; + const SWord8 s13 = sbv_input_0[13]; + const SWord8 s14 = sbv_input_0[14]; + const SWord8 s15 = sbv_input_0[15]; + const SWord8 s16 = sbv_input_0[16]; + const SWord8 s17 = sbv_input_0[17]; + const SWord8 s18 = sbv_input_0[18]; + const SWord8 s19 = sbv_input_0[19]; + const SWord8 s20 = sbv_input_0[20]; + const SWord8 s21 = sbv_input_0[21]; + const SWord8 s22 = sbv_input_0[22]; + const SWord8 s23 = sbv_input_0[23]; + const SWord8 s24 = sbv_input_0[24]; + const SWord8 s25 = sbv_input_0[25]; + const SWord8 s26 = sbv_input_0[26]; + const SWord8 s27 = sbv_input_0[27]; + const SWord8 s28 = sbv_input_0[28]; + const SWord8 s29 = sbv_input_0[29]; + const SWord8 s30 = sbv_input_0[30]; + const SWord8 s31 = sbv_input_0[31]; + const SWord8 s32 = sbv_input_1[0]; + const SWord8 s33 = sbv_input_1[1]; + const SWord8 s34 = sbv_input_1[2]; + const SWord8 s35 = sbv_input_1[3]; + const SWord8 s36 = sbv_input_1[4]; + const SWord8 s37 = sbv_input_1[5]; + const SWord8 s38 = sbv_input_1[6]; + const SWord8 s39 = sbv_input_1[7]; + const SWord8 s40 = sbv_input_1[8]; + const SWord8 s41 = sbv_input_1[9]; + const SWord8 s42 = sbv_input_1[10]; + const SWord8 s43 = sbv_input_1[11]; + const SWord8 s44 = sbv_input_1[12]; + const SWord8 s45 = sbv_input_1[13]; + const SWord8 s46 = sbv_input_1[14]; + const SWord8 s47 = sbv_input_1[15]; + const SWord8 s48 = sbv_input_1[16]; + const SWord8 s49 = sbv_input_1[17]; + const SWord8 s50 = sbv_input_1[18]; + const SWord8 s51 = sbv_input_1[19]; + const SWord8 s52 = sbv_input_1[20]; + const SWord8 s53 = sbv_input_1[21]; + const SWord8 s54 = sbv_input_1[22]; + const SWord8 s55 = sbv_input_1[23]; + const SWord8 s56 = sbv_input_1[24]; + const SWord8 s57 = sbv_input_1[25]; + const SWord8 s58 = sbv_input_1[26]; + const SWord8 s59 = sbv_input_1[27]; + const SWord8 s60 = sbv_input_1[28]; + const SWord8 s61 = sbv_input_1[29]; + const SWord8 s62 = sbv_input_1[30]; + const SWord8 s63 = sbv_input_1[31]; + const SWord8 s64 = sbv_input_1[32]; + const SWord8 s65 = sbv_input_1[33]; + const SWord8 s66 = sbv_input_1[34]; + const SWord8 s67 = sbv_input_1[35]; + const SWord8 s68 = sbv_input_1[36]; + const SWord8 s69 = sbv_input_1[37]; + const SWord8 s70 = sbv_input_1[38]; + const SWord8 s71 = sbv_input_1[39]; + const SWord8 s72 = sbv_input_1[40]; + const SWord8 s73 = sbv_input_1[41]; + const SWord8 s74 = sbv_input_1[42]; + const SWord8 s75 = sbv_input_1[43]; + const SWord8 s76 = sbv_input_1[44]; + const SWord8 s77 = sbv_input_1[45]; + const SWord8 s78 = sbv_input_1[46]; + const SWord8 s79 = sbv_input_1[47]; + const SWord8 s80 = sbv_input_1[48]; + const SWord8 s81 = sbv_input_1[49]; + const SWord8 s82 = sbv_input_1[50]; + const SWord8 s83 = sbv_input_1[51]; + const SWord8 s84 = sbv_input_1[52]; + const SWord8 s85 = sbv_input_1[53]; + const SWord8 s86 = sbv_input_1[54]; + const SWord8 s87 = sbv_input_1[55]; + const SWord8 s88 = sbv_input_1[56]; + const SWord8 s89 = sbv_input_1[57]; + const SWord8 s90 = sbv_input_1[58]; + const SWord8 s91 = sbv_input_1[59]; + const SWord8 s92 = sbv_input_1[60]; + const SWord8 s93 = sbv_input_1[61]; + const SWord8 s94 = sbv_input_1[62]; + const SWord8 s95 = sbv_input_1[63]; + const SWord16 s96 = sbv_bv_join_u8_u8_u16(s0, s1); + const SWord16 s97 = sbv_bv_join_u8_u8_u16(s2, s3); + const SWord32 s98 = sbv_bv_join_u16_u16_u32(s96, s97); + const SWord16 s99 = sbv_bv_join_u8_u8_u16(s16, s17); + const SWord16 s100 = sbv_bv_join_u8_u8_u16(s18, s19); + const SWord32 s101 = sbv_bv_join_u16_u16_u32(s99, s100); + const SWord16 s102 = sbv_bv_join_u8_u8_u16(s4, s5); + const SWord16 s103 = sbv_bv_join_u8_u8_u16(s6, s7); + const SWord32 s104 = sbv_bv_join_u16_u16_u32(s102, s103); + const SWord16 s105 = sbv_bv_join_u8_u8_u16(s20, s21); + const SWord16 s106 = sbv_bv_join_u8_u8_u16(s22, s23); + const SWord32 s107 = sbv_bv_join_u16_u16_u32(s105, s106); + const SWord16 s108 = sbv_bv_join_u8_u8_u16(s8, s9); + const SWord16 s109 = sbv_bv_join_u8_u8_u16(s10, s11); + const SWord32 s110 = sbv_bv_join_u16_u16_u32(s108, s109); + const SWord16 s111 = sbv_bv_join_u8_u8_u16(s24, s25); + const SWord16 s112 = sbv_bv_join_u8_u8_u16(s26, s27); + const SWord32 s113 = sbv_bv_join_u16_u16_u32(s111, s112); + const SWord16 s114 = sbv_bv_join_u8_u8_u16(s12, s13); + const SWord16 s115 = sbv_bv_join_u8_u8_u16(s14, s15); + const SWord32 s116 = sbv_bv_join_u16_u16_u32(s114, s115); + const SWord16 s117 = sbv_bv_join_u8_u8_u16(s28, s29); + const SWord16 s118 = sbv_bv_join_u8_u8_u16(s30, s31); + const SWord32 s119 = sbv_bv_join_u16_u16_u32(s117, s118); + const SWord32 s120 = sbv_bv_u32_rotr(s101, 6); + const SWord32 s121 = sbv_bv_u32_rotr(s101, 11); + const SWord32 s122 = s120 ^ s121; + const SWord32 s123 = sbv_bv_u32_rotr(s101, 25); + const SWord32 s124 = s122 ^ s123; + const SWord32 s125 = sbv_bv_u32_add(s119, s124); + const SWord32 s126 = s101 & s107; + const SWord32 s127 = ~s101; + const SWord32 s128 = s113 & s127; + const SWord32 s129 = s126 ^ s128; + const SWord32 s130 = sbv_bv_u32_add(s125, s129); + const SWord32 s132 = sbv_bv_u32_add(s130, 0x428a2f98UL); + const SWord16 s133 = sbv_bv_join_u8_u8_u16(s32, s33); + const SWord16 s134 = sbv_bv_join_u8_u8_u16(s34, s35); + const SWord32 s135 = sbv_bv_join_u16_u16_u32(s133, s134); + const SWord32 s136 = sbv_bv_u32_add(s132, s135); + const SWord32 s137 = sbv_bv_u32_add(s116, s136); + const SWord32 s138 = sbv_bv_u32_rotr(s137, 6); + const SWord32 s139 = sbv_bv_u32_rotr(s137, 11); + const SWord32 s140 = s138 ^ s139; + const SWord32 s141 = sbv_bv_u32_rotr(s137, 25); + const SWord32 s142 = s140 ^ s141; + const SWord32 s143 = sbv_bv_u32_add(s113, s142); + const SWord32 s144 = s101 & s137; + const SWord32 s145 = ~s137; + const SWord32 s146 = s107 & s145; + const SWord32 s147 = s144 ^ s146; + const SWord32 s148 = sbv_bv_u32_add(s143, s147); + const SWord32 s150 = sbv_bv_u32_add(s148, 0x71374491UL); + const SWord16 s151 = sbv_bv_join_u8_u8_u16(s36, s37); + const SWord16 s152 = sbv_bv_join_u8_u8_u16(s38, s39); + const SWord32 s153 = sbv_bv_join_u16_u16_u32(s151, s152); + const SWord32 s154 = sbv_bv_u32_add(s150, s153); + const SWord32 s155 = sbv_bv_u32_add(s110, s154); + const SWord32 s156 = sbv_bv_u32_rotr(s155, 6); + const SWord32 s157 = sbv_bv_u32_rotr(s155, 11); + const SWord32 s158 = s156 ^ s157; + const SWord32 s159 = sbv_bv_u32_rotr(s155, 25); + const SWord32 s160 = s158 ^ s159; + const SWord32 s161 = sbv_bv_u32_add(s107, s160); + const SWord32 s162 = s137 & s155; + const SWord32 s163 = ~s155; + const SWord32 s164 = s101 & s163; + const SWord32 s165 = s162 ^ s164; + const SWord32 s166 = sbv_bv_u32_add(s161, s165); + const SWord32 s168 = sbv_bv_u32_add(s166, 0xb5c0fbcfUL); + const SWord16 s169 = sbv_bv_join_u8_u8_u16(s40, s41); + const SWord16 s170 = sbv_bv_join_u8_u8_u16(s42, s43); + const SWord32 s171 = sbv_bv_join_u16_u16_u32(s169, s170); + const SWord32 s172 = sbv_bv_u32_add(s168, s171); + const SWord32 s173 = sbv_bv_u32_add(s104, s172); + const SWord32 s174 = sbv_bv_u32_rotr(s173, 6); + const SWord32 s175 = sbv_bv_u32_rotr(s173, 11); + const SWord32 s176 = s174 ^ s175; + const SWord32 s177 = sbv_bv_u32_rotr(s173, 25); + const SWord32 s178 = s176 ^ s177; + const SWord32 s179 = sbv_bv_u32_add(s101, s178); + const SWord32 s180 = s155 & s173; + const SWord32 s181 = ~s173; + const SWord32 s182 = s137 & s181; + const SWord32 s183 = s180 ^ s182; + const SWord32 s184 = sbv_bv_u32_add(s179, s183); + const SWord32 s186 = sbv_bv_u32_add(s184, 0xe9b5dba5UL); + const SWord16 s187 = sbv_bv_join_u8_u8_u16(s44, s45); + const SWord16 s188 = sbv_bv_join_u8_u8_u16(s46, s47); + const SWord32 s189 = sbv_bv_join_u16_u16_u32(s187, s188); + const SWord32 s190 = sbv_bv_u32_add(s186, s189); + const SWord32 s191 = sbv_bv_u32_add(s98, s190); + const SWord32 s192 = sbv_bv_u32_rotr(s98, 2); + const SWord32 s193 = sbv_bv_u32_rotr(s98, 13); + const SWord32 s194 = s192 ^ s193; + const SWord32 s195 = sbv_bv_u32_rotr(s98, 22); + const SWord32 s196 = s194 ^ s195; + const SWord32 s197 = s98 & s104; + const SWord32 s198 = s98 & s110; + const SWord32 s199 = s197 ^ s198; + const SWord32 s200 = s104 & s110; + const SWord32 s201 = s199 ^ s200; + const SWord32 s202 = sbv_bv_u32_add(s196, s201); + const SWord32 s203 = sbv_bv_u32_add(s136, s202); + const SWord32 s204 = sbv_bv_u32_rotr(s203, 2); + const SWord32 s205 = sbv_bv_u32_rotr(s203, 13); + const SWord32 s206 = s204 ^ s205; + const SWord32 s207 = sbv_bv_u32_rotr(s203, 22); + const SWord32 s208 = s206 ^ s207; + const SWord32 s209 = s98 & s203; + const SWord32 s210 = s104 & s203; + const SWord32 s211 = s209 ^ s210; + const SWord32 s212 = s197 ^ s211; + const SWord32 s213 = sbv_bv_u32_add(s208, s212); + const SWord32 s214 = sbv_bv_u32_add(s154, s213); + const SWord32 s215 = sbv_bv_u32_rotr(s214, 2); + const SWord32 s216 = sbv_bv_u32_rotr(s214, 13); + const SWord32 s217 = s215 ^ s216; + const SWord32 s218 = sbv_bv_u32_rotr(s214, 22); + const SWord32 s219 = s217 ^ s218; + const SWord32 s220 = s203 & s214; + const SWord32 s221 = s98 & s214; + const SWord32 s222 = s220 ^ s221; + const SWord32 s223 = s209 ^ s222; + const SWord32 s224 = sbv_bv_u32_add(s219, s223); + const SWord32 s225 = sbv_bv_u32_add(s172, s224); + const SWord32 s226 = sbv_bv_u32_rotr(s191, 6); + const SWord32 s227 = sbv_bv_u32_rotr(s191, 11); + const SWord32 s228 = s226 ^ s227; + const SWord32 s229 = sbv_bv_u32_rotr(s191, 25); + const SWord32 s230 = s228 ^ s229; + const SWord32 s231 = sbv_bv_u32_add(s137, s230); + const SWord32 s232 = s173 & s191; + const SWord32 s233 = ~s191; + const SWord32 s234 = s155 & s233; + const SWord32 s235 = s232 ^ s234; + const SWord32 s236 = sbv_bv_u32_add(s231, s235); + const SWord32 s238 = sbv_bv_u32_add(s236, 0x3956c25bUL); + const SWord16 s239 = sbv_bv_join_u8_u8_u16(s48, s49); + const SWord16 s240 = sbv_bv_join_u8_u8_u16(s50, s51); + const SWord32 s241 = sbv_bv_join_u16_u16_u32(s239, s240); + const SWord32 s242 = sbv_bv_u32_add(s238, s241); + const SWord32 s243 = sbv_bv_u32_add(s203, s242); + const SWord32 s244 = sbv_bv_u32_rotr(s243, 6); + const SWord32 s245 = sbv_bv_u32_rotr(s243, 11); + const SWord32 s246 = s244 ^ s245; + const SWord32 s247 = sbv_bv_u32_rotr(s243, 25); + const SWord32 s248 = s246 ^ s247; + const SWord32 s249 = sbv_bv_u32_add(s155, s248); + const SWord32 s250 = s191 & s243; + const SWord32 s251 = ~s243; + const SWord32 s252 = s173 & s251; + const SWord32 s253 = s250 ^ s252; + const SWord32 s254 = sbv_bv_u32_add(s249, s253); + const SWord32 s256 = sbv_bv_u32_add(s254, 0x59f111f1UL); + const SWord16 s257 = sbv_bv_join_u8_u8_u16(s52, s53); + const SWord16 s258 = sbv_bv_join_u8_u8_u16(s54, s55); + const SWord32 s259 = sbv_bv_join_u16_u16_u32(s257, s258); + const SWord32 s260 = sbv_bv_u32_add(s256, s259); + const SWord32 s261 = sbv_bv_u32_add(s214, s260); + const SWord32 s262 = sbv_bv_u32_rotr(s261, 6); + const SWord32 s263 = sbv_bv_u32_rotr(s261, 11); + const SWord32 s264 = s262 ^ s263; + const SWord32 s265 = sbv_bv_u32_rotr(s261, 25); + const SWord32 s266 = s264 ^ s265; + const SWord32 s267 = sbv_bv_u32_add(s173, s266); + const SWord32 s268 = s243 & s261; + const SWord32 s269 = ~s261; + const SWord32 s270 = s191 & s269; + const SWord32 s271 = s268 ^ s270; + const SWord32 s272 = sbv_bv_u32_add(s267, s271); + const SWord32 s274 = sbv_bv_u32_add(s272, 0x923f82a4UL); + const SWord16 s275 = sbv_bv_join_u8_u8_u16(s56, s57); + const SWord16 s276 = sbv_bv_join_u8_u8_u16(s58, s59); + const SWord32 s277 = sbv_bv_join_u16_u16_u32(s275, s276); + const SWord32 s278 = sbv_bv_u32_add(s274, s277); + const SWord32 s279 = sbv_bv_u32_add(s225, s278); + const SWord32 s280 = sbv_bv_u32_rotr(s279, 6); + const SWord32 s281 = sbv_bv_u32_rotr(s279, 11); + const SWord32 s282 = s280 ^ s281; + const SWord32 s283 = sbv_bv_u32_rotr(s279, 25); + const SWord32 s284 = s282 ^ s283; + const SWord32 s285 = sbv_bv_u32_add(s191, s284); + const SWord32 s286 = s261 & s279; + const SWord32 s287 = ~s279; + const SWord32 s288 = s243 & s287; + const SWord32 s289 = s286 ^ s288; + const SWord32 s290 = sbv_bv_u32_add(s285, s289); + const SWord32 s292 = sbv_bv_u32_add(s290, 0xab1c5ed5UL); + const SWord16 s293 = sbv_bv_join_u8_u8_u16(s60, s61); + const SWord16 s294 = sbv_bv_join_u8_u8_u16(s62, s63); + const SWord32 s295 = sbv_bv_join_u16_u16_u32(s293, s294); + const SWord32 s296 = sbv_bv_u32_add(s292, s295); + const SWord32 s297 = sbv_bv_u32_rotr(s225, 2); + const SWord32 s298 = sbv_bv_u32_rotr(s225, 13); + const SWord32 s299 = s297 ^ s298; + const SWord32 s300 = sbv_bv_u32_rotr(s225, 22); + const SWord32 s301 = s299 ^ s300; + const SWord32 s302 = s214 & s225; + const SWord32 s303 = s203 & s225; + const SWord32 s304 = s302 ^ s303; + const SWord32 s305 = s220 ^ s304; + const SWord32 s306 = sbv_bv_u32_add(s301, s305); + const SWord32 s307 = sbv_bv_u32_add(s190, s306); + const SWord32 s308 = sbv_bv_u32_rotr(s307, 2); + const SWord32 s309 = sbv_bv_u32_rotr(s307, 13); + const SWord32 s310 = s308 ^ s309; + const SWord32 s311 = sbv_bv_u32_rotr(s307, 22); + const SWord32 s312 = s310 ^ s311; + const SWord32 s313 = s225 & s307; + const SWord32 s314 = s214 & s307; + const SWord32 s315 = s313 ^ s314; + const SWord32 s316 = s302 ^ s315; + const SWord32 s317 = sbv_bv_u32_add(s312, s316); + const SWord32 s318 = sbv_bv_u32_add(s242, s317); + const SWord32 s319 = sbv_bv_u32_rotr(s318, 2); + const SWord32 s320 = sbv_bv_u32_rotr(s318, 13); + const SWord32 s321 = s319 ^ s320; + const SWord32 s322 = sbv_bv_u32_rotr(s318, 22); + const SWord32 s323 = s321 ^ s322; + const SWord32 s324 = s307 & s318; + const SWord32 s325 = s225 & s318; + const SWord32 s326 = s324 ^ s325; + const SWord32 s327 = s313 ^ s326; + const SWord32 s328 = sbv_bv_u32_add(s323, s327); + const SWord32 s329 = sbv_bv_u32_add(s260, s328); + const SWord32 s330 = sbv_bv_u32_rotr(s329, 2); + const SWord32 s331 = sbv_bv_u32_rotr(s329, 13); + const SWord32 s332 = s330 ^ s331; + const SWord32 s333 = sbv_bv_u32_rotr(s329, 22); + const SWord32 s334 = s332 ^ s333; + const SWord32 s335 = s318 & s329; + const SWord32 s336 = s307 & s329; + const SWord32 s337 = s335 ^ s336; + const SWord32 s338 = s324 ^ s337; + const SWord32 s339 = sbv_bv_u32_add(s334, s338); + const SWord32 s340 = sbv_bv_u32_add(s278, s339); + const SWord32 s341 = sbv_bv_u32_rotr(s340, 2); + const SWord32 s342 = sbv_bv_u32_rotr(s340, 13); + const SWord32 s343 = s341 ^ s342; + const SWord32 s344 = sbv_bv_u32_rotr(s340, 22); + const SWord32 s345 = s343 ^ s344; + const SWord32 s346 = s329 & s340; + const SWord32 s347 = s318 & s340; + const SWord32 s348 = s346 ^ s347; + const SWord32 s349 = s335 ^ s348; + const SWord32 s350 = sbv_bv_u32_add(s345, s349); + const SWord32 s351 = sbv_bv_u32_add(s296, s350); + const SWord32 s352 = sbv_bv_u32_add(s296, s307); + const SWord32 s353 = sbv_bv_u32_rotr(s352, 6); + const SWord32 s354 = sbv_bv_u32_rotr(s352, 11); + const SWord32 s355 = s353 ^ s354; + const SWord32 s356 = sbv_bv_u32_rotr(s352, 25); + const SWord32 s357 = s355 ^ s356; + const SWord32 s358 = sbv_bv_u32_add(s243, s357); + const SWord32 s359 = s279 & s352; + const SWord32 s360 = ~s352; + const SWord32 s361 = s261 & s360; + const SWord32 s362 = s359 ^ s361; + const SWord32 s363 = sbv_bv_u32_add(s358, s362); + const SWord32 s365 = sbv_bv_u32_add(s363, 0xd807aa98UL); + const SWord16 s366 = sbv_bv_join_u8_u8_u16(s64, s65); + const SWord16 s367 = sbv_bv_join_u8_u8_u16(s66, s67); + const SWord32 s368 = sbv_bv_join_u16_u16_u32(s366, s367); + const SWord32 s369 = sbv_bv_u32_add(s365, s368); + const SWord32 s370 = sbv_bv_u32_add(s318, s369); + const SWord32 s371 = sbv_bv_u32_rotr(s370, 6); + const SWord32 s372 = sbv_bv_u32_rotr(s370, 11); + const SWord32 s373 = s371 ^ s372; + const SWord32 s374 = sbv_bv_u32_rotr(s370, 25); + const SWord32 s375 = s373 ^ s374; + const SWord32 s376 = sbv_bv_u32_add(s261, s375); + const SWord32 s377 = s352 & s370; + const SWord32 s378 = ~s370; + const SWord32 s379 = s279 & s378; + const SWord32 s380 = s377 ^ s379; + const SWord32 s381 = sbv_bv_u32_add(s376, s380); + const SWord32 s383 = sbv_bv_u32_add(s381, 0x12835b01UL); + const SWord16 s384 = sbv_bv_join_u8_u8_u16(s68, s69); + const SWord16 s385 = sbv_bv_join_u8_u8_u16(s70, s71); + const SWord32 s386 = sbv_bv_join_u16_u16_u32(s384, s385); + const SWord32 s387 = sbv_bv_u32_add(s383, s386); + const SWord32 s388 = sbv_bv_u32_add(s329, s387); + const SWord32 s389 = sbv_bv_u32_rotr(s388, 6); + const SWord32 s390 = sbv_bv_u32_rotr(s388, 11); + const SWord32 s391 = s389 ^ s390; + const SWord32 s392 = sbv_bv_u32_rotr(s388, 25); + const SWord32 s393 = s391 ^ s392; + const SWord32 s394 = sbv_bv_u32_add(s279, s393); + const SWord32 s395 = s370 & s388; + const SWord32 s396 = ~s388; + const SWord32 s397 = s352 & s396; + const SWord32 s398 = s395 ^ s397; + const SWord32 s399 = sbv_bv_u32_add(s394, s398); + const SWord32 s401 = sbv_bv_u32_add(s399, 0x243185beUL); + const SWord16 s402 = sbv_bv_join_u8_u8_u16(s72, s73); + const SWord16 s403 = sbv_bv_join_u8_u8_u16(s74, s75); + const SWord32 s404 = sbv_bv_join_u16_u16_u32(s402, s403); + const SWord32 s405 = sbv_bv_u32_add(s401, s404); + const SWord32 s406 = sbv_bv_u32_add(s340, s405); + const SWord32 s407 = sbv_bv_u32_rotr(s406, 6); + const SWord32 s408 = sbv_bv_u32_rotr(s406, 11); + const SWord32 s409 = s407 ^ s408; + const SWord32 s410 = sbv_bv_u32_rotr(s406, 25); + const SWord32 s411 = s409 ^ s410; + const SWord32 s412 = sbv_bv_u32_add(s352, s411); + const SWord32 s413 = s388 & s406; + const SWord32 s414 = ~s406; + const SWord32 s415 = s370 & s414; + const SWord32 s416 = s413 ^ s415; + const SWord32 s417 = sbv_bv_u32_add(s412, s416); + const SWord32 s419 = sbv_bv_u32_add(s417, 0x550c7dc3UL); + const SWord16 s420 = sbv_bv_join_u8_u8_u16(s76, s77); + const SWord16 s421 = sbv_bv_join_u8_u8_u16(s78, s79); + const SWord32 s422 = sbv_bv_join_u16_u16_u32(s420, s421); + const SWord32 s423 = sbv_bv_u32_add(s419, s422); + const SWord32 s424 = sbv_bv_u32_add(s351, s423); + const SWord32 s425 = sbv_bv_u32_rotr(s351, 2); + const SWord32 s426 = sbv_bv_u32_rotr(s351, 13); + const SWord32 s427 = s425 ^ s426; + const SWord32 s428 = sbv_bv_u32_rotr(s351, 22); + const SWord32 s429 = s427 ^ s428; + const SWord32 s430 = s340 & s351; + const SWord32 s431 = s329 & s351; + const SWord32 s432 = s430 ^ s431; + const SWord32 s433 = s346 ^ s432; + const SWord32 s434 = sbv_bv_u32_add(s429, s433); + const SWord32 s435 = sbv_bv_u32_add(s369, s434); + const SWord32 s436 = sbv_bv_u32_rotr(s435, 2); + const SWord32 s437 = sbv_bv_u32_rotr(s435, 13); + const SWord32 s438 = s436 ^ s437; + const SWord32 s439 = sbv_bv_u32_rotr(s435, 22); + const SWord32 s440 = s438 ^ s439; + const SWord32 s441 = s351 & s435; + const SWord32 s442 = s340 & s435; + const SWord32 s443 = s441 ^ s442; + const SWord32 s444 = s430 ^ s443; + const SWord32 s445 = sbv_bv_u32_add(s440, s444); + const SWord32 s446 = sbv_bv_u32_add(s387, s445); + const SWord32 s447 = sbv_bv_u32_rotr(s446, 2); + const SWord32 s448 = sbv_bv_u32_rotr(s446, 13); + const SWord32 s449 = s447 ^ s448; + const SWord32 s450 = sbv_bv_u32_rotr(s446, 22); + const SWord32 s451 = s449 ^ s450; + const SWord32 s452 = s435 & s446; + const SWord32 s453 = s351 & s446; + const SWord32 s454 = s452 ^ s453; + const SWord32 s455 = s441 ^ s454; + const SWord32 s456 = sbv_bv_u32_add(s451, s455); + const SWord32 s457 = sbv_bv_u32_add(s405, s456); + const SWord32 s458 = sbv_bv_u32_rotr(s424, 6); + const SWord32 s459 = sbv_bv_u32_rotr(s424, 11); + const SWord32 s460 = s458 ^ s459; + const SWord32 s461 = sbv_bv_u32_rotr(s424, 25); + const SWord32 s462 = s460 ^ s461; + const SWord32 s463 = sbv_bv_u32_add(s370, s462); + const SWord32 s464 = s406 & s424; + const SWord32 s465 = ~s424; + const SWord32 s466 = s388 & s465; + const SWord32 s467 = s464 ^ s466; + const SWord32 s468 = sbv_bv_u32_add(s463, s467); + const SWord32 s470 = sbv_bv_u32_add(s468, 0x72be5d74UL); + const SWord16 s471 = sbv_bv_join_u8_u8_u16(s80, s81); + const SWord16 s472 = sbv_bv_join_u8_u8_u16(s82, s83); + const SWord32 s473 = sbv_bv_join_u16_u16_u32(s471, s472); + const SWord32 s474 = sbv_bv_u32_add(s470, s473); + const SWord32 s475 = sbv_bv_u32_add(s435, s474); + const SWord32 s476 = sbv_bv_u32_rotr(s475, 6); + const SWord32 s477 = sbv_bv_u32_rotr(s475, 11); + const SWord32 s478 = s476 ^ s477; + const SWord32 s479 = sbv_bv_u32_rotr(s475, 25); + const SWord32 s480 = s478 ^ s479; + const SWord32 s481 = sbv_bv_u32_add(s388, s480); + const SWord32 s482 = s424 & s475; + const SWord32 s483 = ~s475; + const SWord32 s484 = s406 & s483; + const SWord32 s485 = s482 ^ s484; + const SWord32 s486 = sbv_bv_u32_add(s481, s485); + const SWord32 s488 = sbv_bv_u32_add(s486, 0x80deb1feUL); + const SWord16 s489 = sbv_bv_join_u8_u8_u16(s84, s85); + const SWord16 s490 = sbv_bv_join_u8_u8_u16(s86, s87); + const SWord32 s491 = sbv_bv_join_u16_u16_u32(s489, s490); + const SWord32 s492 = sbv_bv_u32_add(s488, s491); + const SWord32 s493 = sbv_bv_u32_add(s446, s492); + const SWord32 s494 = sbv_bv_u32_rotr(s493, 6); + const SWord32 s495 = sbv_bv_u32_rotr(s493, 11); + const SWord32 s496 = s494 ^ s495; + const SWord32 s497 = sbv_bv_u32_rotr(s493, 25); + const SWord32 s498 = s496 ^ s497; + const SWord32 s499 = sbv_bv_u32_add(s406, s498); + const SWord32 s500 = s475 & s493; + const SWord32 s501 = ~s493; + const SWord32 s502 = s424 & s501; + const SWord32 s503 = s500 ^ s502; + const SWord32 s504 = sbv_bv_u32_add(s499, s503); + const SWord32 s506 = sbv_bv_u32_add(s504, 0x9bdc06a7UL); + const SWord16 s507 = sbv_bv_join_u8_u8_u16(s88, s89); + const SWord16 s508 = sbv_bv_join_u8_u8_u16(s90, s91); + const SWord32 s509 = sbv_bv_join_u16_u16_u32(s507, s508); + const SWord32 s510 = sbv_bv_u32_add(s506, s509); + const SWord32 s511 = sbv_bv_u32_add(s457, s510); + const SWord32 s512 = sbv_bv_u32_rotr(s511, 6); + const SWord32 s513 = sbv_bv_u32_rotr(s511, 11); + const SWord32 s514 = s512 ^ s513; + const SWord32 s515 = sbv_bv_u32_rotr(s511, 25); + const SWord32 s516 = s514 ^ s515; + const SWord32 s517 = sbv_bv_u32_add(s424, s516); + const SWord32 s518 = s493 & s511; + const SWord32 s519 = ~s511; + const SWord32 s520 = s475 & s519; + const SWord32 s521 = s518 ^ s520; + const SWord32 s522 = sbv_bv_u32_add(s517, s521); + const SWord32 s524 = sbv_bv_u32_add(s522, 0xc19bf174UL); + const SWord16 s525 = sbv_bv_join_u8_u8_u16(s92, s93); + const SWord16 s526 = sbv_bv_join_u8_u8_u16(s94, s95); + const SWord32 s527 = sbv_bv_join_u16_u16_u32(s525, s526); + const SWord32 s528 = sbv_bv_u32_add(s524, s527); + const SWord32 s529 = sbv_bv_u32_rotr(s457, 2); + const SWord32 s530 = sbv_bv_u32_rotr(s457, 13); + const SWord32 s531 = s529 ^ s530; + const SWord32 s532 = sbv_bv_u32_rotr(s457, 22); + const SWord32 s533 = s531 ^ s532; + const SWord32 s534 = s446 & s457; + const SWord32 s535 = s435 & s457; + const SWord32 s536 = s534 ^ s535; + const SWord32 s537 = s452 ^ s536; + const SWord32 s538 = sbv_bv_u32_add(s533, s537); + const SWord32 s539 = sbv_bv_u32_add(s423, s538); + const SWord32 s540 = sbv_bv_u32_rotr(s539, 2); + const SWord32 s541 = sbv_bv_u32_rotr(s539, 13); + const SWord32 s542 = s540 ^ s541; + const SWord32 s543 = sbv_bv_u32_rotr(s539, 22); + const SWord32 s544 = s542 ^ s543; + const SWord32 s545 = s457 & s539; + const SWord32 s546 = s446 & s539; + const SWord32 s547 = s545 ^ s546; + const SWord32 s548 = s534 ^ s547; + const SWord32 s549 = sbv_bv_u32_add(s544, s548); + const SWord32 s550 = sbv_bv_u32_add(s474, s549); + const SWord32 s551 = sbv_bv_u32_rotr(s550, 2); + const SWord32 s552 = sbv_bv_u32_rotr(s550, 13); + const SWord32 s553 = s551 ^ s552; + const SWord32 s554 = sbv_bv_u32_rotr(s550, 22); + const SWord32 s555 = s553 ^ s554; + const SWord32 s556 = s539 & s550; + const SWord32 s557 = s457 & s550; + const SWord32 s558 = s556 ^ s557; + const SWord32 s559 = s545 ^ s558; + const SWord32 s560 = sbv_bv_u32_add(s555, s559); + const SWord32 s561 = sbv_bv_u32_add(s492, s560); + const SWord32 s562 = sbv_bv_u32_rotr(s561, 2); + const SWord32 s563 = sbv_bv_u32_rotr(s561, 13); + const SWord32 s564 = s562 ^ s563; + const SWord32 s565 = sbv_bv_u32_rotr(s561, 22); + const SWord32 s566 = s564 ^ s565; + const SWord32 s567 = s550 & s561; + const SWord32 s568 = s539 & s561; + const SWord32 s569 = s567 ^ s568; + const SWord32 s570 = s556 ^ s569; + const SWord32 s571 = sbv_bv_u32_add(s566, s570); + const SWord32 s572 = sbv_bv_u32_add(s510, s571); + const SWord32 s573 = sbv_bv_u32_rotr(s572, 2); + const SWord32 s574 = sbv_bv_u32_rotr(s572, 13); + const SWord32 s575 = s573 ^ s574; + const SWord32 s576 = sbv_bv_u32_rotr(s572, 22); + const SWord32 s577 = s575 ^ s576; + const SWord32 s578 = s561 & s572; + const SWord32 s579 = s550 & s572; + const SWord32 s580 = s578 ^ s579; + const SWord32 s581 = s567 ^ s580; + const SWord32 s582 = sbv_bv_u32_add(s577, s581); + const SWord32 s583 = sbv_bv_u32_add(s528, s582); + const SWord32 s584 = sbv_bv_u32_add(s528, s539); + const SWord32 s585 = sbv_bv_u32_rotr(s584, 6); + const SWord32 s586 = sbv_bv_u32_rotr(s584, 11); + const SWord32 s587 = s585 ^ s586; + const SWord32 s588 = sbv_bv_u32_rotr(s584, 25); + const SWord32 s589 = s587 ^ s588; + const SWord32 s590 = sbv_bv_u32_add(s475, s589); + const SWord32 s591 = s511 & s584; + const SWord32 s592 = ~s584; + const SWord32 s593 = s493 & s592; + const SWord32 s594 = s591 ^ s593; + const SWord32 s595 = sbv_bv_u32_add(s590, s594); + const SWord32 s597 = sbv_bv_u32_add(s595, 0xe49b69c1UL); + const SWord32 s598 = sbv_bv_u32_rotr(s509, 17); + const SWord32 s599 = sbv_bv_u32_rotr(s509, 19); + const SWord32 s600 = s598 ^ s599; + const SWord32 s602 = sbv_bv_u32_lshr(s509, 0x0000000aUL); + const SWord32 s603 = s600 ^ s602; + const SWord32 s604 = sbv_bv_u32_add(s386, s603); + const SWord32 s605 = sbv_bv_u32_rotr(s153, 7); + const SWord32 s606 = sbv_bv_u32_rotr(s153, 18); + const SWord32 s607 = s605 ^ s606; + const SWord32 s609 = sbv_bv_u32_lshr(s153, 0x00000003UL); + const SWord32 s610 = s607 ^ s609; + const SWord32 s611 = sbv_bv_u32_add(s604, s610); + const SWord32 s612 = sbv_bv_u32_add(s135, s611); + const SWord32 s613 = sbv_bv_u32_add(s597, s612); + const SWord32 s614 = sbv_bv_u32_add(s550, s613); + const SWord32 s615 = sbv_bv_u32_rotr(s614, 6); + const SWord32 s616 = sbv_bv_u32_rotr(s614, 11); + const SWord32 s617 = s615 ^ s616; + const SWord32 s618 = sbv_bv_u32_rotr(s614, 25); + const SWord32 s619 = s617 ^ s618; + const SWord32 s620 = sbv_bv_u32_add(s493, s619); + const SWord32 s621 = s584 & s614; + const SWord32 s622 = ~s614; + const SWord32 s623 = s511 & s622; + const SWord32 s624 = s621 ^ s623; + const SWord32 s625 = sbv_bv_u32_add(s620, s624); + const SWord32 s627 = sbv_bv_u32_add(s625, 0xefbe4786UL); + const SWord32 s628 = sbv_bv_u32_rotr(s527, 17); + const SWord32 s629 = sbv_bv_u32_rotr(s527, 19); + const SWord32 s630 = s628 ^ s629; + const SWord32 s631 = sbv_bv_u32_lshr(s527, 0x0000000aUL); + const SWord32 s632 = s630 ^ s631; + const SWord32 s633 = sbv_bv_u32_add(s404, s632); + const SWord32 s634 = sbv_bv_u32_rotr(s171, 7); + const SWord32 s635 = sbv_bv_u32_rotr(s171, 18); + const SWord32 s636 = s634 ^ s635; + const SWord32 s637 = sbv_bv_u32_lshr(s171, 0x00000003UL); + const SWord32 s638 = s636 ^ s637; + const SWord32 s639 = sbv_bv_u32_add(s633, s638); + const SWord32 s640 = sbv_bv_u32_add(s153, s639); + const SWord32 s641 = sbv_bv_u32_add(s627, s640); + const SWord32 s642 = sbv_bv_u32_add(s561, s641); + const SWord32 s643 = sbv_bv_u32_rotr(s642, 6); + const SWord32 s644 = sbv_bv_u32_rotr(s642, 11); + const SWord32 s645 = s643 ^ s644; + const SWord32 s646 = sbv_bv_u32_rotr(s642, 25); + const SWord32 s647 = s645 ^ s646; + const SWord32 s648 = sbv_bv_u32_add(s511, s647); + const SWord32 s649 = s614 & s642; + const SWord32 s650 = ~s642; + const SWord32 s651 = s584 & s650; + const SWord32 s652 = s649 ^ s651; + const SWord32 s653 = sbv_bv_u32_add(s648, s652); + const SWord32 s655 = sbv_bv_u32_add(s653, 0x0fc19dc6UL); + const SWord32 s656 = sbv_bv_u32_rotr(s612, 17); + const SWord32 s657 = sbv_bv_u32_rotr(s612, 19); + const SWord32 s658 = s656 ^ s657; + const SWord32 s659 = sbv_bv_u32_lshr(s612, 0x0000000aUL); + const SWord32 s660 = s658 ^ s659; + const SWord32 s661 = sbv_bv_u32_add(s422, s660); + const SWord32 s662 = sbv_bv_u32_rotr(s189, 7); + const SWord32 s663 = sbv_bv_u32_rotr(s189, 18); + const SWord32 s664 = s662 ^ s663; + const SWord32 s665 = sbv_bv_u32_lshr(s189, 0x00000003UL); + const SWord32 s666 = s664 ^ s665; + const SWord32 s667 = sbv_bv_u32_add(s661, s666); + const SWord32 s668 = sbv_bv_u32_add(s171, s667); + const SWord32 s669 = sbv_bv_u32_add(s655, s668); + const SWord32 s670 = sbv_bv_u32_add(s572, s669); + const SWord32 s671 = sbv_bv_u32_rotr(s670, 6); + const SWord32 s672 = sbv_bv_u32_rotr(s670, 11); + const SWord32 s673 = s671 ^ s672; + const SWord32 s674 = sbv_bv_u32_rotr(s670, 25); + const SWord32 s675 = s673 ^ s674; + const SWord32 s676 = sbv_bv_u32_add(s584, s675); + const SWord32 s677 = s642 & s670; + const SWord32 s678 = ~s670; + const SWord32 s679 = s614 & s678; + const SWord32 s680 = s677 ^ s679; + const SWord32 s681 = sbv_bv_u32_add(s676, s680); + const SWord32 s683 = sbv_bv_u32_add(s681, 0x240ca1ccUL); + const SWord32 s684 = sbv_bv_u32_rotr(s640, 17); + const SWord32 s685 = sbv_bv_u32_rotr(s640, 19); + const SWord32 s686 = s684 ^ s685; + const SWord32 s687 = sbv_bv_u32_lshr(s640, 0x0000000aUL); + const SWord32 s688 = s686 ^ s687; + const SWord32 s689 = sbv_bv_u32_add(s473, s688); + const SWord32 s690 = sbv_bv_u32_rotr(s241, 7); + const SWord32 s691 = sbv_bv_u32_rotr(s241, 18); + const SWord32 s692 = s690 ^ s691; + const SWord32 s693 = sbv_bv_u32_lshr(s241, 0x00000003UL); + const SWord32 s694 = s692 ^ s693; + const SWord32 s695 = sbv_bv_u32_add(s689, s694); + const SWord32 s696 = sbv_bv_u32_add(s189, s695); + const SWord32 s697 = sbv_bv_u32_add(s683, s696); + const SWord32 s698 = sbv_bv_u32_add(s583, s697); + const SWord32 s699 = sbv_bv_u32_rotr(s583, 2); + const SWord32 s700 = sbv_bv_u32_rotr(s583, 13); + const SWord32 s701 = s699 ^ s700; + const SWord32 s702 = sbv_bv_u32_rotr(s583, 22); + const SWord32 s703 = s701 ^ s702; + const SWord32 s704 = s572 & s583; + const SWord32 s705 = s561 & s583; + const SWord32 s706 = s704 ^ s705; + const SWord32 s707 = s578 ^ s706; + const SWord32 s708 = sbv_bv_u32_add(s703, s707); + const SWord32 s709 = sbv_bv_u32_add(s613, s708); + const SWord32 s710 = sbv_bv_u32_rotr(s709, 2); + const SWord32 s711 = sbv_bv_u32_rotr(s709, 13); + const SWord32 s712 = s710 ^ s711; + const SWord32 s713 = sbv_bv_u32_rotr(s709, 22); + const SWord32 s714 = s712 ^ s713; + const SWord32 s715 = s583 & s709; + const SWord32 s716 = s572 & s709; + const SWord32 s717 = s715 ^ s716; + const SWord32 s718 = s704 ^ s717; + const SWord32 s719 = sbv_bv_u32_add(s714, s718); + const SWord32 s720 = sbv_bv_u32_add(s641, s719); + const SWord32 s721 = sbv_bv_u32_rotr(s720, 2); + const SWord32 s722 = sbv_bv_u32_rotr(s720, 13); + const SWord32 s723 = s721 ^ s722; + const SWord32 s724 = sbv_bv_u32_rotr(s720, 22); + const SWord32 s725 = s723 ^ s724; + const SWord32 s726 = s709 & s720; + const SWord32 s727 = s583 & s720; + const SWord32 s728 = s726 ^ s727; + const SWord32 s729 = s715 ^ s728; + const SWord32 s730 = sbv_bv_u32_add(s725, s729); + const SWord32 s731 = sbv_bv_u32_add(s669, s730); + const SWord32 s732 = sbv_bv_u32_rotr(s698, 6); + const SWord32 s733 = sbv_bv_u32_rotr(s698, 11); + const SWord32 s734 = s732 ^ s733; + const SWord32 s735 = sbv_bv_u32_rotr(s698, 25); + const SWord32 s736 = s734 ^ s735; + const SWord32 s737 = sbv_bv_u32_add(s614, s736); + const SWord32 s738 = s670 & s698; + const SWord32 s739 = ~s698; + const SWord32 s740 = s642 & s739; + const SWord32 s741 = s738 ^ s740; + const SWord32 s742 = sbv_bv_u32_add(s737, s741); + const SWord32 s744 = sbv_bv_u32_add(s742, 0x2de92c6fUL); + const SWord32 s745 = sbv_bv_u32_rotr(s668, 17); + const SWord32 s746 = sbv_bv_u32_rotr(s668, 19); + const SWord32 s747 = s745 ^ s746; + const SWord32 s748 = sbv_bv_u32_lshr(s668, 0x0000000aUL); + const SWord32 s749 = s747 ^ s748; + const SWord32 s750 = sbv_bv_u32_add(s491, s749); + const SWord32 s751 = sbv_bv_u32_rotr(s259, 7); + const SWord32 s752 = sbv_bv_u32_rotr(s259, 18); + const SWord32 s753 = s751 ^ s752; + const SWord32 s754 = sbv_bv_u32_lshr(s259, 0x00000003UL); + const SWord32 s755 = s753 ^ s754; + const SWord32 s756 = sbv_bv_u32_add(s750, s755); + const SWord32 s757 = sbv_bv_u32_add(s241, s756); + const SWord32 s758 = sbv_bv_u32_add(s744, s757); + const SWord32 s759 = sbv_bv_u32_add(s709, s758); + const SWord32 s760 = sbv_bv_u32_rotr(s759, 6); + const SWord32 s761 = sbv_bv_u32_rotr(s759, 11); + const SWord32 s762 = s760 ^ s761; + const SWord32 s763 = sbv_bv_u32_rotr(s759, 25); + const SWord32 s764 = s762 ^ s763; + const SWord32 s765 = sbv_bv_u32_add(s642, s764); + const SWord32 s766 = s698 & s759; + const SWord32 s767 = ~s759; + const SWord32 s768 = s670 & s767; + const SWord32 s769 = s766 ^ s768; + const SWord32 s770 = sbv_bv_u32_add(s765, s769); + const SWord32 s772 = sbv_bv_u32_add(s770, 0x4a7484aaUL); + const SWord32 s773 = sbv_bv_u32_rotr(s696, 17); + const SWord32 s774 = sbv_bv_u32_rotr(s696, 19); + const SWord32 s775 = s773 ^ s774; + const SWord32 s776 = sbv_bv_u32_lshr(s696, 0x0000000aUL); + const SWord32 s777 = s775 ^ s776; + const SWord32 s778 = sbv_bv_u32_add(s509, s777); + const SWord32 s779 = sbv_bv_u32_rotr(s277, 7); + const SWord32 s780 = sbv_bv_u32_rotr(s277, 18); + const SWord32 s781 = s779 ^ s780; + const SWord32 s782 = sbv_bv_u32_lshr(s277, 0x00000003UL); + const SWord32 s783 = s781 ^ s782; + const SWord32 s784 = sbv_bv_u32_add(s778, s783); + const SWord32 s785 = sbv_bv_u32_add(s259, s784); + const SWord32 s786 = sbv_bv_u32_add(s772, s785); + const SWord32 s787 = sbv_bv_u32_add(s720, s786); + const SWord32 s788 = sbv_bv_u32_rotr(s787, 6); + const SWord32 s789 = sbv_bv_u32_rotr(s787, 11); + const SWord32 s790 = s788 ^ s789; + const SWord32 s791 = sbv_bv_u32_rotr(s787, 25); + const SWord32 s792 = s790 ^ s791; + const SWord32 s793 = sbv_bv_u32_add(s670, s792); + const SWord32 s794 = s759 & s787; + const SWord32 s795 = ~s787; + const SWord32 s796 = s698 & s795; + const SWord32 s797 = s794 ^ s796; + const SWord32 s798 = sbv_bv_u32_add(s793, s797); + const SWord32 s800 = sbv_bv_u32_add(s798, 0x5cb0a9dcUL); + const SWord32 s801 = sbv_bv_u32_rotr(s757, 17); + const SWord32 s802 = sbv_bv_u32_rotr(s757, 19); + const SWord32 s803 = s801 ^ s802; + const SWord32 s804 = sbv_bv_u32_lshr(s757, 0x0000000aUL); + const SWord32 s805 = s803 ^ s804; + const SWord32 s806 = sbv_bv_u32_add(s527, s805); + const SWord32 s807 = sbv_bv_u32_rotr(s295, 7); + const SWord32 s808 = sbv_bv_u32_rotr(s295, 18); + const SWord32 s809 = s807 ^ s808; + const SWord32 s810 = sbv_bv_u32_lshr(s295, 0x00000003UL); + const SWord32 s811 = s809 ^ s810; + const SWord32 s812 = sbv_bv_u32_add(s806, s811); + const SWord32 s813 = sbv_bv_u32_add(s277, s812); + const SWord32 s814 = sbv_bv_u32_add(s800, s813); + const SWord32 s815 = sbv_bv_u32_add(s731, s814); + const SWord32 s816 = sbv_bv_u32_rotr(s815, 6); + const SWord32 s817 = sbv_bv_u32_rotr(s815, 11); + const SWord32 s818 = s816 ^ s817; + const SWord32 s819 = sbv_bv_u32_rotr(s815, 25); + const SWord32 s820 = s818 ^ s819; + const SWord32 s821 = sbv_bv_u32_add(s698, s820); + const SWord32 s822 = s787 & s815; + const SWord32 s823 = ~s815; + const SWord32 s824 = s759 & s823; + const SWord32 s825 = s822 ^ s824; + const SWord32 s826 = sbv_bv_u32_add(s821, s825); + const SWord32 s828 = sbv_bv_u32_add(s826, 0x76f988daUL); + const SWord32 s829 = sbv_bv_u32_rotr(s785, 17); + const SWord32 s830 = sbv_bv_u32_rotr(s785, 19); + const SWord32 s831 = s829 ^ s830; + const SWord32 s832 = sbv_bv_u32_lshr(s785, 0x0000000aUL); + const SWord32 s833 = s831 ^ s832; + const SWord32 s834 = sbv_bv_u32_add(s612, s833); + const SWord32 s835 = sbv_bv_u32_rotr(s368, 7); + const SWord32 s836 = sbv_bv_u32_rotr(s368, 18); + const SWord32 s837 = s835 ^ s836; + const SWord32 s838 = sbv_bv_u32_lshr(s368, 0x00000003UL); + const SWord32 s839 = s837 ^ s838; + const SWord32 s840 = sbv_bv_u32_add(s834, s839); + const SWord32 s841 = sbv_bv_u32_add(s295, s840); + const SWord32 s842 = sbv_bv_u32_add(s828, s841); + const SWord32 s843 = sbv_bv_u32_rotr(s731, 2); + const SWord32 s844 = sbv_bv_u32_rotr(s731, 13); + const SWord32 s845 = s843 ^ s844; + const SWord32 s846 = sbv_bv_u32_rotr(s731, 22); + const SWord32 s847 = s845 ^ s846; + const SWord32 s848 = s720 & s731; + const SWord32 s849 = s709 & s731; + const SWord32 s850 = s848 ^ s849; + const SWord32 s851 = s726 ^ s850; + const SWord32 s852 = sbv_bv_u32_add(s847, s851); + const SWord32 s853 = sbv_bv_u32_add(s697, s852); + const SWord32 s854 = sbv_bv_u32_rotr(s853, 2); + const SWord32 s855 = sbv_bv_u32_rotr(s853, 13); + const SWord32 s856 = s854 ^ s855; + const SWord32 s857 = sbv_bv_u32_rotr(s853, 22); + const SWord32 s858 = s856 ^ s857; + const SWord32 s859 = s731 & s853; + const SWord32 s860 = s720 & s853; + const SWord32 s861 = s859 ^ s860; + const SWord32 s862 = s848 ^ s861; + const SWord32 s863 = sbv_bv_u32_add(s858, s862); + const SWord32 s864 = sbv_bv_u32_add(s758, s863); + const SWord32 s865 = sbv_bv_u32_rotr(s864, 2); + const SWord32 s866 = sbv_bv_u32_rotr(s864, 13); + const SWord32 s867 = s865 ^ s866; + const SWord32 s868 = sbv_bv_u32_rotr(s864, 22); + const SWord32 s869 = s867 ^ s868; + const SWord32 s870 = s853 & s864; + const SWord32 s871 = s731 & s864; + const SWord32 s872 = s870 ^ s871; + const SWord32 s873 = s859 ^ s872; + const SWord32 s874 = sbv_bv_u32_add(s869, s873); + const SWord32 s875 = sbv_bv_u32_add(s786, s874); + const SWord32 s876 = sbv_bv_u32_rotr(s875, 2); + const SWord32 s877 = sbv_bv_u32_rotr(s875, 13); + const SWord32 s878 = s876 ^ s877; + const SWord32 s879 = sbv_bv_u32_rotr(s875, 22); + const SWord32 s880 = s878 ^ s879; + const SWord32 s881 = s864 & s875; + const SWord32 s882 = s853 & s875; + const SWord32 s883 = s881 ^ s882; + const SWord32 s884 = s870 ^ s883; + const SWord32 s885 = sbv_bv_u32_add(s880, s884); + const SWord32 s886 = sbv_bv_u32_add(s814, s885); + const SWord32 s887 = sbv_bv_u32_rotr(s886, 2); + const SWord32 s888 = sbv_bv_u32_rotr(s886, 13); + const SWord32 s889 = s887 ^ s888; + const SWord32 s890 = sbv_bv_u32_rotr(s886, 22); + const SWord32 s891 = s889 ^ s890; + const SWord32 s892 = s875 & s886; + const SWord32 s893 = s864 & s886; + const SWord32 s894 = s892 ^ s893; + const SWord32 s895 = s881 ^ s894; + const SWord32 s896 = sbv_bv_u32_add(s891, s895); + const SWord32 s897 = sbv_bv_u32_add(s842, s896); + const SWord32 s898 = sbv_bv_u32_add(s842, s853); + const SWord32 s899 = sbv_bv_u32_rotr(s898, 6); + const SWord32 s900 = sbv_bv_u32_rotr(s898, 11); + const SWord32 s901 = s899 ^ s900; + const SWord32 s902 = sbv_bv_u32_rotr(s898, 25); + const SWord32 s903 = s901 ^ s902; + const SWord32 s904 = sbv_bv_u32_add(s759, s903); + const SWord32 s905 = s815 & s898; + const SWord32 s906 = ~s898; + const SWord32 s907 = s787 & s906; + const SWord32 s908 = s905 ^ s907; + const SWord32 s909 = sbv_bv_u32_add(s904, s908); + const SWord32 s911 = sbv_bv_u32_add(s909, 0x983e5152UL); + const SWord32 s912 = sbv_bv_u32_rotr(s813, 17); + const SWord32 s913 = sbv_bv_u32_rotr(s813, 19); + const SWord32 s914 = s912 ^ s913; + const SWord32 s915 = sbv_bv_u32_lshr(s813, 0x0000000aUL); + const SWord32 s916 = s914 ^ s915; + const SWord32 s917 = sbv_bv_u32_add(s640, s916); + const SWord32 s918 = sbv_bv_u32_rotr(s386, 7); + const SWord32 s919 = sbv_bv_u32_rotr(s386, 18); + const SWord32 s920 = s918 ^ s919; + const SWord32 s921 = sbv_bv_u32_lshr(s386, 0x00000003UL); + const SWord32 s922 = s920 ^ s921; + const SWord32 s923 = sbv_bv_u32_add(s917, s922); + const SWord32 s924 = sbv_bv_u32_add(s368, s923); + const SWord32 s925 = sbv_bv_u32_add(s911, s924); + const SWord32 s926 = sbv_bv_u32_add(s864, s925); + const SWord32 s927 = sbv_bv_u32_rotr(s926, 6); + const SWord32 s928 = sbv_bv_u32_rotr(s926, 11); + const SWord32 s929 = s927 ^ s928; + const SWord32 s930 = sbv_bv_u32_rotr(s926, 25); + const SWord32 s931 = s929 ^ s930; + const SWord32 s932 = sbv_bv_u32_add(s787, s931); + const SWord32 s933 = s898 & s926; + const SWord32 s934 = ~s926; + const SWord32 s935 = s815 & s934; + const SWord32 s936 = s933 ^ s935; + const SWord32 s937 = sbv_bv_u32_add(s932, s936); + const SWord32 s939 = sbv_bv_u32_add(s937, 0xa831c66dUL); + const SWord32 s940 = sbv_bv_u32_rotr(s841, 17); + const SWord32 s941 = sbv_bv_u32_rotr(s841, 19); + const SWord32 s942 = s940 ^ s941; + const SWord32 s943 = sbv_bv_u32_lshr(s841, 0x0000000aUL); + const SWord32 s944 = s942 ^ s943; + const SWord32 s945 = sbv_bv_u32_add(s668, s944); + const SWord32 s946 = sbv_bv_u32_rotr(s404, 7); + const SWord32 s947 = sbv_bv_u32_rotr(s404, 18); + const SWord32 s948 = s946 ^ s947; + const SWord32 s949 = sbv_bv_u32_lshr(s404, 0x00000003UL); + const SWord32 s950 = s948 ^ s949; + const SWord32 s951 = sbv_bv_u32_add(s945, s950); + const SWord32 s952 = sbv_bv_u32_add(s386, s951); + const SWord32 s953 = sbv_bv_u32_add(s939, s952); + const SWord32 s954 = sbv_bv_u32_add(s875, s953); + const SWord32 s955 = sbv_bv_u32_rotr(s954, 6); + const SWord32 s956 = sbv_bv_u32_rotr(s954, 11); + const SWord32 s957 = s955 ^ s956; + const SWord32 s958 = sbv_bv_u32_rotr(s954, 25); + const SWord32 s959 = s957 ^ s958; + const SWord32 s960 = sbv_bv_u32_add(s815, s959); + const SWord32 s961 = s926 & s954; + const SWord32 s962 = ~s954; + const SWord32 s963 = s898 & s962; + const SWord32 s964 = s961 ^ s963; + const SWord32 s965 = sbv_bv_u32_add(s960, s964); + const SWord32 s967 = sbv_bv_u32_add(s965, 0xb00327c8UL); + const SWord32 s968 = sbv_bv_u32_rotr(s924, 17); + const SWord32 s969 = sbv_bv_u32_rotr(s924, 19); + const SWord32 s970 = s968 ^ s969; + const SWord32 s971 = sbv_bv_u32_lshr(s924, 0x0000000aUL); + const SWord32 s972 = s970 ^ s971; + const SWord32 s973 = sbv_bv_u32_add(s696, s972); + const SWord32 s974 = sbv_bv_u32_rotr(s422, 7); + const SWord32 s975 = sbv_bv_u32_rotr(s422, 18); + const SWord32 s976 = s974 ^ s975; + const SWord32 s977 = sbv_bv_u32_lshr(s422, 0x00000003UL); + const SWord32 s978 = s976 ^ s977; + const SWord32 s979 = sbv_bv_u32_add(s973, s978); + const SWord32 s980 = sbv_bv_u32_add(s404, s979); + const SWord32 s981 = sbv_bv_u32_add(s967, s980); + const SWord32 s982 = sbv_bv_u32_add(s886, s981); + const SWord32 s983 = sbv_bv_u32_rotr(s982, 6); + const SWord32 s984 = sbv_bv_u32_rotr(s982, 11); + const SWord32 s985 = s983 ^ s984; + const SWord32 s986 = sbv_bv_u32_rotr(s982, 25); + const SWord32 s987 = s985 ^ s986; + const SWord32 s988 = sbv_bv_u32_add(s898, s987); + const SWord32 s989 = s954 & s982; + const SWord32 s990 = ~s982; + const SWord32 s991 = s926 & s990; + const SWord32 s992 = s989 ^ s991; + const SWord32 s993 = sbv_bv_u32_add(s988, s992); + const SWord32 s995 = sbv_bv_u32_add(s993, 0xbf597fc7UL); + const SWord32 s996 = sbv_bv_u32_rotr(s952, 17); + const SWord32 s997 = sbv_bv_u32_rotr(s952, 19); + const SWord32 s998 = s996 ^ s997; + const SWord32 s999 = sbv_bv_u32_lshr(s952, 0x0000000aUL); + const SWord32 s1000 = s998 ^ s999; + const SWord32 s1001 = sbv_bv_u32_add(s757, s1000); + const SWord32 s1002 = sbv_bv_u32_rotr(s473, 7); + const SWord32 s1003 = sbv_bv_u32_rotr(s473, 18); + const SWord32 s1004 = s1002 ^ s1003; + const SWord32 s1005 = sbv_bv_u32_lshr(s473, 0x00000003UL); + const SWord32 s1006 = s1004 ^ s1005; + const SWord32 s1007 = sbv_bv_u32_add(s1001, s1006); + const SWord32 s1008 = sbv_bv_u32_add(s422, s1007); + const SWord32 s1009 = sbv_bv_u32_add(s995, s1008); + const SWord32 s1010 = sbv_bv_u32_add(s897, s1009); + const SWord32 s1011 = sbv_bv_u32_rotr(s897, 2); + const SWord32 s1012 = sbv_bv_u32_rotr(s897, 13); + const SWord32 s1013 = s1011 ^ s1012; + const SWord32 s1014 = sbv_bv_u32_rotr(s897, 22); + const SWord32 s1015 = s1013 ^ s1014; + const SWord32 s1016 = s886 & s897; + const SWord32 s1017 = s875 & s897; + const SWord32 s1018 = s1016 ^ s1017; + const SWord32 s1019 = s892 ^ s1018; + const SWord32 s1020 = sbv_bv_u32_add(s1015, s1019); + const SWord32 s1021 = sbv_bv_u32_add(s925, s1020); + const SWord32 s1022 = sbv_bv_u32_rotr(s1021, 2); + const SWord32 s1023 = sbv_bv_u32_rotr(s1021, 13); + const SWord32 s1024 = s1022 ^ s1023; + const SWord32 s1025 = sbv_bv_u32_rotr(s1021, 22); + const SWord32 s1026 = s1024 ^ s1025; + const SWord32 s1027 = s897 & s1021; + const SWord32 s1028 = s886 & s1021; + const SWord32 s1029 = s1027 ^ s1028; + const SWord32 s1030 = s1016 ^ s1029; + const SWord32 s1031 = sbv_bv_u32_add(s1026, s1030); + const SWord32 s1032 = sbv_bv_u32_add(s953, s1031); + const SWord32 s1033 = sbv_bv_u32_rotr(s1032, 2); + const SWord32 s1034 = sbv_bv_u32_rotr(s1032, 13); + const SWord32 s1035 = s1033 ^ s1034; + const SWord32 s1036 = sbv_bv_u32_rotr(s1032, 22); + const SWord32 s1037 = s1035 ^ s1036; + const SWord32 s1038 = s1021 & s1032; + const SWord32 s1039 = s897 & s1032; + const SWord32 s1040 = s1038 ^ s1039; + const SWord32 s1041 = s1027 ^ s1040; + const SWord32 s1042 = sbv_bv_u32_add(s1037, s1041); + const SWord32 s1043 = sbv_bv_u32_add(s981, s1042); + const SWord32 s1044 = sbv_bv_u32_rotr(s1010, 6); + const SWord32 s1045 = sbv_bv_u32_rotr(s1010, 11); + const SWord32 s1046 = s1044 ^ s1045; + const SWord32 s1047 = sbv_bv_u32_rotr(s1010, 25); + const SWord32 s1048 = s1046 ^ s1047; + const SWord32 s1049 = sbv_bv_u32_add(s926, s1048); + const SWord32 s1050 = s982 & s1010; + const SWord32 s1051 = ~s1010; + const SWord32 s1052 = s954 & s1051; + const SWord32 s1053 = s1050 ^ s1052; + const SWord32 s1054 = sbv_bv_u32_add(s1049, s1053); + const SWord32 s1056 = sbv_bv_u32_add(s1054, 0xc6e00bf3UL); + const SWord32 s1057 = sbv_bv_u32_rotr(s980, 17); + const SWord32 s1058 = sbv_bv_u32_rotr(s980, 19); + const SWord32 s1059 = s1057 ^ s1058; + const SWord32 s1060 = sbv_bv_u32_lshr(s980, 0x0000000aUL); + const SWord32 s1061 = s1059 ^ s1060; + const SWord32 s1062 = sbv_bv_u32_add(s785, s1061); + const SWord32 s1063 = sbv_bv_u32_rotr(s491, 7); + const SWord32 s1064 = sbv_bv_u32_rotr(s491, 18); + const SWord32 s1065 = s1063 ^ s1064; + const SWord32 s1066 = sbv_bv_u32_lshr(s491, 0x00000003UL); + const SWord32 s1067 = s1065 ^ s1066; + const SWord32 s1068 = sbv_bv_u32_add(s1062, s1067); + const SWord32 s1069 = sbv_bv_u32_add(s473, s1068); + const SWord32 s1070 = sbv_bv_u32_add(s1056, s1069); + const SWord32 s1071 = sbv_bv_u32_add(s1021, s1070); + const SWord32 s1072 = sbv_bv_u32_rotr(s1071, 6); + const SWord32 s1073 = sbv_bv_u32_rotr(s1071, 11); + const SWord32 s1074 = s1072 ^ s1073; + const SWord32 s1075 = sbv_bv_u32_rotr(s1071, 25); + const SWord32 s1076 = s1074 ^ s1075; + const SWord32 s1077 = sbv_bv_u32_add(s954, s1076); + const SWord32 s1078 = s1010 & s1071; + const SWord32 s1079 = ~s1071; + const SWord32 s1080 = s982 & s1079; + const SWord32 s1081 = s1078 ^ s1080; + const SWord32 s1082 = sbv_bv_u32_add(s1077, s1081); + const SWord32 s1084 = sbv_bv_u32_add(s1082, 0xd5a79147UL); + const SWord32 s1085 = sbv_bv_u32_rotr(s1008, 17); + const SWord32 s1086 = sbv_bv_u32_rotr(s1008, 19); + const SWord32 s1087 = s1085 ^ s1086; + const SWord32 s1088 = sbv_bv_u32_lshr(s1008, 0x0000000aUL); + const SWord32 s1089 = s1087 ^ s1088; + const SWord32 s1090 = sbv_bv_u32_add(s813, s1089); + const SWord32 s1091 = sbv_bv_u32_rotr(s509, 7); + const SWord32 s1092 = sbv_bv_u32_rotr(s509, 18); + const SWord32 s1093 = s1091 ^ s1092; + const SWord32 s1094 = sbv_bv_u32_lshr(s509, 0x00000003UL); + const SWord32 s1095 = s1093 ^ s1094; + const SWord32 s1096 = sbv_bv_u32_add(s1090, s1095); + const SWord32 s1097 = sbv_bv_u32_add(s491, s1096); + const SWord32 s1098 = sbv_bv_u32_add(s1084, s1097); + const SWord32 s1099 = sbv_bv_u32_add(s1032, s1098); + const SWord32 s1100 = sbv_bv_u32_rotr(s1099, 6); + const SWord32 s1101 = sbv_bv_u32_rotr(s1099, 11); + const SWord32 s1102 = s1100 ^ s1101; + const SWord32 s1103 = sbv_bv_u32_rotr(s1099, 25); + const SWord32 s1104 = s1102 ^ s1103; + const SWord32 s1105 = sbv_bv_u32_add(s982, s1104); + const SWord32 s1106 = s1071 & s1099; + const SWord32 s1107 = ~s1099; + const SWord32 s1108 = s1010 & s1107; + const SWord32 s1109 = s1106 ^ s1108; + const SWord32 s1110 = sbv_bv_u32_add(s1105, s1109); + const SWord32 s1112 = sbv_bv_u32_add(s1110, 0x06ca6351UL); + const SWord32 s1113 = sbv_bv_u32_rotr(s1069, 17); + const SWord32 s1114 = sbv_bv_u32_rotr(s1069, 19); + const SWord32 s1115 = s1113 ^ s1114; + const SWord32 s1116 = sbv_bv_u32_lshr(s1069, 0x0000000aUL); + const SWord32 s1117 = s1115 ^ s1116; + const SWord32 s1118 = sbv_bv_u32_add(s841, s1117); + const SWord32 s1119 = sbv_bv_u32_rotr(s527, 7); + const SWord32 s1120 = sbv_bv_u32_rotr(s527, 18); + const SWord32 s1121 = s1119 ^ s1120; + const SWord32 s1122 = sbv_bv_u32_lshr(s527, 0x00000003UL); + const SWord32 s1123 = s1121 ^ s1122; + const SWord32 s1124 = sbv_bv_u32_add(s1118, s1123); + const SWord32 s1125 = sbv_bv_u32_add(s509, s1124); + const SWord32 s1126 = sbv_bv_u32_add(s1112, s1125); + const SWord32 s1127 = sbv_bv_u32_add(s1043, s1126); + const SWord32 s1128 = sbv_bv_u32_rotr(s1127, 6); + const SWord32 s1129 = sbv_bv_u32_rotr(s1127, 11); + const SWord32 s1130 = s1128 ^ s1129; + const SWord32 s1131 = sbv_bv_u32_rotr(s1127, 25); + const SWord32 s1132 = s1130 ^ s1131; + const SWord32 s1133 = sbv_bv_u32_add(s1010, s1132); + const SWord32 s1134 = s1099 & s1127; + const SWord32 s1135 = ~s1127; + const SWord32 s1136 = s1071 & s1135; + const SWord32 s1137 = s1134 ^ s1136; + const SWord32 s1138 = sbv_bv_u32_add(s1133, s1137); + const SWord32 s1140 = sbv_bv_u32_add(s1138, 0x14292967UL); + const SWord32 s1141 = sbv_bv_u32_rotr(s1097, 17); + const SWord32 s1142 = sbv_bv_u32_rotr(s1097, 19); + const SWord32 s1143 = s1141 ^ s1142; + const SWord32 s1144 = sbv_bv_u32_lshr(s1097, 0x0000000aUL); + const SWord32 s1145 = s1143 ^ s1144; + const SWord32 s1146 = sbv_bv_u32_add(s924, s1145); + const SWord32 s1147 = sbv_bv_u32_rotr(s612, 7); + const SWord32 s1148 = sbv_bv_u32_rotr(s612, 18); + const SWord32 s1149 = s1147 ^ s1148; + const SWord32 s1150 = sbv_bv_u32_lshr(s612, 0x00000003UL); + const SWord32 s1151 = s1149 ^ s1150; + const SWord32 s1152 = sbv_bv_u32_add(s1146, s1151); + const SWord32 s1153 = sbv_bv_u32_add(s527, s1152); + const SWord32 s1154 = sbv_bv_u32_add(s1140, s1153); + const SWord32 s1155 = sbv_bv_u32_rotr(s1043, 2); + const SWord32 s1156 = sbv_bv_u32_rotr(s1043, 13); + const SWord32 s1157 = s1155 ^ s1156; + const SWord32 s1158 = sbv_bv_u32_rotr(s1043, 22); + const SWord32 s1159 = s1157 ^ s1158; + const SWord32 s1160 = s1032 & s1043; + const SWord32 s1161 = s1021 & s1043; + const SWord32 s1162 = s1160 ^ s1161; + const SWord32 s1163 = s1038 ^ s1162; + const SWord32 s1164 = sbv_bv_u32_add(s1159, s1163); + const SWord32 s1165 = sbv_bv_u32_add(s1009, s1164); + const SWord32 s1166 = sbv_bv_u32_rotr(s1165, 2); + const SWord32 s1167 = sbv_bv_u32_rotr(s1165, 13); + const SWord32 s1168 = s1166 ^ s1167; + const SWord32 s1169 = sbv_bv_u32_rotr(s1165, 22); + const SWord32 s1170 = s1168 ^ s1169; + const SWord32 s1171 = s1043 & s1165; + const SWord32 s1172 = s1032 & s1165; + const SWord32 s1173 = s1171 ^ s1172; + const SWord32 s1174 = s1160 ^ s1173; + const SWord32 s1175 = sbv_bv_u32_add(s1170, s1174); + const SWord32 s1176 = sbv_bv_u32_add(s1070, s1175); + const SWord32 s1177 = sbv_bv_u32_rotr(s1176, 2); + const SWord32 s1178 = sbv_bv_u32_rotr(s1176, 13); + const SWord32 s1179 = s1177 ^ s1178; + const SWord32 s1180 = sbv_bv_u32_rotr(s1176, 22); + const SWord32 s1181 = s1179 ^ s1180; + const SWord32 s1182 = s1165 & s1176; + const SWord32 s1183 = s1043 & s1176; + const SWord32 s1184 = s1182 ^ s1183; + const SWord32 s1185 = s1171 ^ s1184; + const SWord32 s1186 = sbv_bv_u32_add(s1181, s1185); + const SWord32 s1187 = sbv_bv_u32_add(s1098, s1186); + const SWord32 s1188 = sbv_bv_u32_rotr(s1187, 2); + const SWord32 s1189 = sbv_bv_u32_rotr(s1187, 13); + const SWord32 s1190 = s1188 ^ s1189; + const SWord32 s1191 = sbv_bv_u32_rotr(s1187, 22); + const SWord32 s1192 = s1190 ^ s1191; + const SWord32 s1193 = s1176 & s1187; + const SWord32 s1194 = s1165 & s1187; + const SWord32 s1195 = s1193 ^ s1194; + const SWord32 s1196 = s1182 ^ s1195; + const SWord32 s1197 = sbv_bv_u32_add(s1192, s1196); + const SWord32 s1198 = sbv_bv_u32_add(s1126, s1197); + const SWord32 s1199 = sbv_bv_u32_rotr(s1198, 2); + const SWord32 s1200 = sbv_bv_u32_rotr(s1198, 13); + const SWord32 s1201 = s1199 ^ s1200; + const SWord32 s1202 = sbv_bv_u32_rotr(s1198, 22); + const SWord32 s1203 = s1201 ^ s1202; + const SWord32 s1204 = s1187 & s1198; + const SWord32 s1205 = s1176 & s1198; + const SWord32 s1206 = s1204 ^ s1205; + const SWord32 s1207 = s1193 ^ s1206; + const SWord32 s1208 = sbv_bv_u32_add(s1203, s1207); + const SWord32 s1209 = sbv_bv_u32_add(s1154, s1208); + const SWord32 s1210 = sbv_bv_u32_add(s1154, s1165); + const SWord32 s1211 = sbv_bv_u32_rotr(s1210, 6); + const SWord32 s1212 = sbv_bv_u32_rotr(s1210, 11); + const SWord32 s1213 = s1211 ^ s1212; + const SWord32 s1214 = sbv_bv_u32_rotr(s1210, 25); + const SWord32 s1215 = s1213 ^ s1214; + const SWord32 s1216 = sbv_bv_u32_add(s1071, s1215); + const SWord32 s1217 = s1127 & s1210; + const SWord32 s1218 = ~s1210; + const SWord32 s1219 = s1099 & s1218; + const SWord32 s1220 = s1217 ^ s1219; + const SWord32 s1221 = sbv_bv_u32_add(s1216, s1220); + const SWord32 s1223 = sbv_bv_u32_add(s1221, 0x27b70a85UL); + const SWord32 s1224 = sbv_bv_u32_rotr(s1125, 17); + const SWord32 s1225 = sbv_bv_u32_rotr(s1125, 19); + const SWord32 s1226 = s1224 ^ s1225; + const SWord32 s1227 = sbv_bv_u32_lshr(s1125, 0x0000000aUL); + const SWord32 s1228 = s1226 ^ s1227; + const SWord32 s1229 = sbv_bv_u32_add(s952, s1228); + const SWord32 s1230 = sbv_bv_u32_rotr(s640, 7); + const SWord32 s1231 = sbv_bv_u32_rotr(s640, 18); + const SWord32 s1232 = s1230 ^ s1231; + const SWord32 s1233 = sbv_bv_u32_lshr(s640, 0x00000003UL); + const SWord32 s1234 = s1232 ^ s1233; + const SWord32 s1235 = sbv_bv_u32_add(s1229, s1234); + const SWord32 s1236 = sbv_bv_u32_add(s612, s1235); + const SWord32 s1237 = sbv_bv_u32_add(s1223, s1236); + const SWord32 s1238 = sbv_bv_u32_add(s1176, s1237); + const SWord32 s1239 = sbv_bv_u32_rotr(s1238, 6); + const SWord32 s1240 = sbv_bv_u32_rotr(s1238, 11); + const SWord32 s1241 = s1239 ^ s1240; + const SWord32 s1242 = sbv_bv_u32_rotr(s1238, 25); + const SWord32 s1243 = s1241 ^ s1242; + const SWord32 s1244 = sbv_bv_u32_add(s1099, s1243); + const SWord32 s1245 = s1210 & s1238; + const SWord32 s1246 = ~s1238; + const SWord32 s1247 = s1127 & s1246; + const SWord32 s1248 = s1245 ^ s1247; + const SWord32 s1249 = sbv_bv_u32_add(s1244, s1248); + const SWord32 s1251 = sbv_bv_u32_add(s1249, 0x2e1b2138UL); + const SWord32 s1252 = sbv_bv_u32_rotr(s1153, 17); + const SWord32 s1253 = sbv_bv_u32_rotr(s1153, 19); + const SWord32 s1254 = s1252 ^ s1253; + const SWord32 s1255 = sbv_bv_u32_lshr(s1153, 0x0000000aUL); + const SWord32 s1256 = s1254 ^ s1255; + const SWord32 s1257 = sbv_bv_u32_add(s980, s1256); + const SWord32 s1258 = sbv_bv_u32_rotr(s668, 7); + const SWord32 s1259 = sbv_bv_u32_rotr(s668, 18); + const SWord32 s1260 = s1258 ^ s1259; + const SWord32 s1261 = sbv_bv_u32_lshr(s668, 0x00000003UL); + const SWord32 s1262 = s1260 ^ s1261; + const SWord32 s1263 = sbv_bv_u32_add(s1257, s1262); + const SWord32 s1264 = sbv_bv_u32_add(s640, s1263); + const SWord32 s1265 = sbv_bv_u32_add(s1251, s1264); + const SWord32 s1266 = sbv_bv_u32_add(s1187, s1265); + const SWord32 s1267 = sbv_bv_u32_rotr(s1266, 6); + const SWord32 s1268 = sbv_bv_u32_rotr(s1266, 11); + const SWord32 s1269 = s1267 ^ s1268; + const SWord32 s1270 = sbv_bv_u32_rotr(s1266, 25); + const SWord32 s1271 = s1269 ^ s1270; + const SWord32 s1272 = sbv_bv_u32_add(s1127, s1271); + const SWord32 s1273 = s1238 & s1266; + const SWord32 s1274 = ~s1266; + const SWord32 s1275 = s1210 & s1274; + const SWord32 s1276 = s1273 ^ s1275; + const SWord32 s1277 = sbv_bv_u32_add(s1272, s1276); + const SWord32 s1279 = sbv_bv_u32_add(s1277, 0x4d2c6dfcUL); + const SWord32 s1280 = sbv_bv_u32_rotr(s1236, 17); + const SWord32 s1281 = sbv_bv_u32_rotr(s1236, 19); + const SWord32 s1282 = s1280 ^ s1281; + const SWord32 s1283 = sbv_bv_u32_lshr(s1236, 0x0000000aUL); + const SWord32 s1284 = s1282 ^ s1283; + const SWord32 s1285 = sbv_bv_u32_add(s1008, s1284); + const SWord32 s1286 = sbv_bv_u32_rotr(s696, 7); + const SWord32 s1287 = sbv_bv_u32_rotr(s696, 18); + const SWord32 s1288 = s1286 ^ s1287; + const SWord32 s1289 = sbv_bv_u32_lshr(s696, 0x00000003UL); + const SWord32 s1290 = s1288 ^ s1289; + const SWord32 s1291 = sbv_bv_u32_add(s1285, s1290); + const SWord32 s1292 = sbv_bv_u32_add(s668, s1291); + const SWord32 s1293 = sbv_bv_u32_add(s1279, s1292); + const SWord32 s1294 = sbv_bv_u32_add(s1198, s1293); + const SWord32 s1295 = sbv_bv_u32_rotr(s1294, 6); + const SWord32 s1296 = sbv_bv_u32_rotr(s1294, 11); + const SWord32 s1297 = s1295 ^ s1296; + const SWord32 s1298 = sbv_bv_u32_rotr(s1294, 25); + const SWord32 s1299 = s1297 ^ s1298; + const SWord32 s1300 = sbv_bv_u32_add(s1210, s1299); + const SWord32 s1301 = s1266 & s1294; + const SWord32 s1302 = ~s1294; + const SWord32 s1303 = s1238 & s1302; + const SWord32 s1304 = s1301 ^ s1303; + const SWord32 s1305 = sbv_bv_u32_add(s1300, s1304); + const SWord32 s1307 = sbv_bv_u32_add(s1305, 0x53380d13UL); + const SWord32 s1308 = sbv_bv_u32_rotr(s1264, 17); + const SWord32 s1309 = sbv_bv_u32_rotr(s1264, 19); + const SWord32 s1310 = s1308 ^ s1309; + const SWord32 s1311 = sbv_bv_u32_lshr(s1264, 0x0000000aUL); + const SWord32 s1312 = s1310 ^ s1311; + const SWord32 s1313 = sbv_bv_u32_add(s1069, s1312); + const SWord32 s1314 = sbv_bv_u32_rotr(s757, 7); + const SWord32 s1315 = sbv_bv_u32_rotr(s757, 18); + const SWord32 s1316 = s1314 ^ s1315; + const SWord32 s1317 = sbv_bv_u32_lshr(s757, 0x00000003UL); + const SWord32 s1318 = s1316 ^ s1317; + const SWord32 s1319 = sbv_bv_u32_add(s1313, s1318); + const SWord32 s1320 = sbv_bv_u32_add(s696, s1319); + const SWord32 s1321 = sbv_bv_u32_add(s1307, s1320); + const SWord32 s1322 = sbv_bv_u32_add(s1209, s1321); + const SWord32 s1323 = sbv_bv_u32_rotr(s1209, 2); + const SWord32 s1324 = sbv_bv_u32_rotr(s1209, 13); + const SWord32 s1325 = s1323 ^ s1324; + const SWord32 s1326 = sbv_bv_u32_rotr(s1209, 22); + const SWord32 s1327 = s1325 ^ s1326; + const SWord32 s1328 = s1198 & s1209; + const SWord32 s1329 = s1187 & s1209; + const SWord32 s1330 = s1328 ^ s1329; + const SWord32 s1331 = s1204 ^ s1330; + const SWord32 s1332 = sbv_bv_u32_add(s1327, s1331); + const SWord32 s1333 = sbv_bv_u32_add(s1237, s1332); + const SWord32 s1334 = sbv_bv_u32_rotr(s1333, 2); + const SWord32 s1335 = sbv_bv_u32_rotr(s1333, 13); + const SWord32 s1336 = s1334 ^ s1335; + const SWord32 s1337 = sbv_bv_u32_rotr(s1333, 22); + const SWord32 s1338 = s1336 ^ s1337; + const SWord32 s1339 = s1209 & s1333; + const SWord32 s1340 = s1198 & s1333; + const SWord32 s1341 = s1339 ^ s1340; + const SWord32 s1342 = s1328 ^ s1341; + const SWord32 s1343 = sbv_bv_u32_add(s1338, s1342); + const SWord32 s1344 = sbv_bv_u32_add(s1265, s1343); + const SWord32 s1345 = sbv_bv_u32_rotr(s1344, 2); + const SWord32 s1346 = sbv_bv_u32_rotr(s1344, 13); + const SWord32 s1347 = s1345 ^ s1346; + const SWord32 s1348 = sbv_bv_u32_rotr(s1344, 22); + const SWord32 s1349 = s1347 ^ s1348; + const SWord32 s1350 = s1333 & s1344; + const SWord32 s1351 = s1209 & s1344; + const SWord32 s1352 = s1350 ^ s1351; + const SWord32 s1353 = s1339 ^ s1352; + const SWord32 s1354 = sbv_bv_u32_add(s1349, s1353); + const SWord32 s1355 = sbv_bv_u32_add(s1293, s1354); + const SWord32 s1356 = sbv_bv_u32_rotr(s1322, 6); + const SWord32 s1357 = sbv_bv_u32_rotr(s1322, 11); + const SWord32 s1358 = s1356 ^ s1357; + const SWord32 s1359 = sbv_bv_u32_rotr(s1322, 25); + const SWord32 s1360 = s1358 ^ s1359; + const SWord32 s1361 = sbv_bv_u32_add(s1238, s1360); + const SWord32 s1362 = s1294 & s1322; + const SWord32 s1363 = ~s1322; + const SWord32 s1364 = s1266 & s1363; + const SWord32 s1365 = s1362 ^ s1364; + const SWord32 s1366 = sbv_bv_u32_add(s1361, s1365); + const SWord32 s1368 = sbv_bv_u32_add(s1366, 0x650a7354UL); + const SWord32 s1369 = sbv_bv_u32_rotr(s1292, 17); + const SWord32 s1370 = sbv_bv_u32_rotr(s1292, 19); + const SWord32 s1371 = s1369 ^ s1370; + const SWord32 s1372 = sbv_bv_u32_lshr(s1292, 0x0000000aUL); + const SWord32 s1373 = s1371 ^ s1372; + const SWord32 s1374 = sbv_bv_u32_add(s1097, s1373); + const SWord32 s1375 = sbv_bv_u32_rotr(s785, 7); + const SWord32 s1376 = sbv_bv_u32_rotr(s785, 18); + const SWord32 s1377 = s1375 ^ s1376; + const SWord32 s1378 = sbv_bv_u32_lshr(s785, 0x00000003UL); + const SWord32 s1379 = s1377 ^ s1378; + const SWord32 s1380 = sbv_bv_u32_add(s1374, s1379); + const SWord32 s1381 = sbv_bv_u32_add(s757, s1380); + const SWord32 s1382 = sbv_bv_u32_add(s1368, s1381); + const SWord32 s1383 = sbv_bv_u32_add(s1333, s1382); + const SWord32 s1384 = sbv_bv_u32_rotr(s1383, 6); + const SWord32 s1385 = sbv_bv_u32_rotr(s1383, 11); + const SWord32 s1386 = s1384 ^ s1385; + const SWord32 s1387 = sbv_bv_u32_rotr(s1383, 25); + const SWord32 s1388 = s1386 ^ s1387; + const SWord32 s1389 = sbv_bv_u32_add(s1266, s1388); + const SWord32 s1390 = s1322 & s1383; + const SWord32 s1391 = ~s1383; + const SWord32 s1392 = s1294 & s1391; + const SWord32 s1393 = s1390 ^ s1392; + const SWord32 s1394 = sbv_bv_u32_add(s1389, s1393); + const SWord32 s1396 = sbv_bv_u32_add(s1394, 0x766a0abbUL); + const SWord32 s1397 = sbv_bv_u32_rotr(s1320, 17); + const SWord32 s1398 = sbv_bv_u32_rotr(s1320, 19); + const SWord32 s1399 = s1397 ^ s1398; + const SWord32 s1400 = sbv_bv_u32_lshr(s1320, 0x0000000aUL); + const SWord32 s1401 = s1399 ^ s1400; + const SWord32 s1402 = sbv_bv_u32_add(s1125, s1401); + const SWord32 s1403 = sbv_bv_u32_rotr(s813, 7); + const SWord32 s1404 = sbv_bv_u32_rotr(s813, 18); + const SWord32 s1405 = s1403 ^ s1404; + const SWord32 s1406 = sbv_bv_u32_lshr(s813, 0x00000003UL); + const SWord32 s1407 = s1405 ^ s1406; + const SWord32 s1408 = sbv_bv_u32_add(s1402, s1407); + const SWord32 s1409 = sbv_bv_u32_add(s785, s1408); + const SWord32 s1410 = sbv_bv_u32_add(s1396, s1409); + const SWord32 s1411 = sbv_bv_u32_add(s1344, s1410); + const SWord32 s1412 = sbv_bv_u32_rotr(s1411, 6); + const SWord32 s1413 = sbv_bv_u32_rotr(s1411, 11); + const SWord32 s1414 = s1412 ^ s1413; + const SWord32 s1415 = sbv_bv_u32_rotr(s1411, 25); + const SWord32 s1416 = s1414 ^ s1415; + const SWord32 s1417 = sbv_bv_u32_add(s1294, s1416); + const SWord32 s1418 = s1383 & s1411; + const SWord32 s1419 = ~s1411; + const SWord32 s1420 = s1322 & s1419; + const SWord32 s1421 = s1418 ^ s1420; + const SWord32 s1422 = sbv_bv_u32_add(s1417, s1421); + const SWord32 s1424 = sbv_bv_u32_add(s1422, 0x81c2c92eUL); + const SWord32 s1425 = sbv_bv_u32_rotr(s1381, 17); + const SWord32 s1426 = sbv_bv_u32_rotr(s1381, 19); + const SWord32 s1427 = s1425 ^ s1426; + const SWord32 s1428 = sbv_bv_u32_lshr(s1381, 0x0000000aUL); + const SWord32 s1429 = s1427 ^ s1428; + const SWord32 s1430 = sbv_bv_u32_add(s1153, s1429); + const SWord32 s1431 = sbv_bv_u32_rotr(s841, 7); + const SWord32 s1432 = sbv_bv_u32_rotr(s841, 18); + const SWord32 s1433 = s1431 ^ s1432; + const SWord32 s1434 = sbv_bv_u32_lshr(s841, 0x00000003UL); + const SWord32 s1435 = s1433 ^ s1434; + const SWord32 s1436 = sbv_bv_u32_add(s1430, s1435); + const SWord32 s1437 = sbv_bv_u32_add(s813, s1436); + const SWord32 s1438 = sbv_bv_u32_add(s1424, s1437); + const SWord32 s1439 = sbv_bv_u32_add(s1355, s1438); + const SWord32 s1440 = sbv_bv_u32_rotr(s1439, 6); + const SWord32 s1441 = sbv_bv_u32_rotr(s1439, 11); + const SWord32 s1442 = s1440 ^ s1441; + const SWord32 s1443 = sbv_bv_u32_rotr(s1439, 25); + const SWord32 s1444 = s1442 ^ s1443; + const SWord32 s1445 = sbv_bv_u32_add(s1322, s1444); + const SWord32 s1446 = s1411 & s1439; + const SWord32 s1447 = ~s1439; + const SWord32 s1448 = s1383 & s1447; + const SWord32 s1449 = s1446 ^ s1448; + const SWord32 s1450 = sbv_bv_u32_add(s1445, s1449); + const SWord32 s1452 = sbv_bv_u32_add(s1450, 0x92722c85UL); + const SWord32 s1453 = sbv_bv_u32_rotr(s1409, 17); + const SWord32 s1454 = sbv_bv_u32_rotr(s1409, 19); + const SWord32 s1455 = s1453 ^ s1454; + const SWord32 s1456 = sbv_bv_u32_lshr(s1409, 0x0000000aUL); + const SWord32 s1457 = s1455 ^ s1456; + const SWord32 s1458 = sbv_bv_u32_add(s1236, s1457); + const SWord32 s1459 = sbv_bv_u32_rotr(s924, 7); + const SWord32 s1460 = sbv_bv_u32_rotr(s924, 18); + const SWord32 s1461 = s1459 ^ s1460; + const SWord32 s1462 = sbv_bv_u32_lshr(s924, 0x00000003UL); + const SWord32 s1463 = s1461 ^ s1462; + const SWord32 s1464 = sbv_bv_u32_add(s1458, s1463); + const SWord32 s1465 = sbv_bv_u32_add(s841, s1464); + const SWord32 s1466 = sbv_bv_u32_add(s1452, s1465); + const SWord32 s1467 = sbv_bv_u32_rotr(s1355, 2); + const SWord32 s1468 = sbv_bv_u32_rotr(s1355, 13); + const SWord32 s1469 = s1467 ^ s1468; + const SWord32 s1470 = sbv_bv_u32_rotr(s1355, 22); + const SWord32 s1471 = s1469 ^ s1470; + const SWord32 s1472 = s1344 & s1355; + const SWord32 s1473 = s1333 & s1355; + const SWord32 s1474 = s1472 ^ s1473; + const SWord32 s1475 = s1350 ^ s1474; + const SWord32 s1476 = sbv_bv_u32_add(s1471, s1475); + const SWord32 s1477 = sbv_bv_u32_add(s1321, s1476); + const SWord32 s1478 = sbv_bv_u32_rotr(s1477, 2); + const SWord32 s1479 = sbv_bv_u32_rotr(s1477, 13); + const SWord32 s1480 = s1478 ^ s1479; + const SWord32 s1481 = sbv_bv_u32_rotr(s1477, 22); + const SWord32 s1482 = s1480 ^ s1481; + const SWord32 s1483 = s1355 & s1477; + const SWord32 s1484 = s1344 & s1477; + const SWord32 s1485 = s1483 ^ s1484; + const SWord32 s1486 = s1472 ^ s1485; + const SWord32 s1487 = sbv_bv_u32_add(s1482, s1486); + const SWord32 s1488 = sbv_bv_u32_add(s1382, s1487); + const SWord32 s1489 = sbv_bv_u32_rotr(s1488, 2); + const SWord32 s1490 = sbv_bv_u32_rotr(s1488, 13); + const SWord32 s1491 = s1489 ^ s1490; + const SWord32 s1492 = sbv_bv_u32_rotr(s1488, 22); + const SWord32 s1493 = s1491 ^ s1492; + const SWord32 s1494 = s1477 & s1488; + const SWord32 s1495 = s1355 & s1488; + const SWord32 s1496 = s1494 ^ s1495; + const SWord32 s1497 = s1483 ^ s1496; + const SWord32 s1498 = sbv_bv_u32_add(s1493, s1497); + const SWord32 s1499 = sbv_bv_u32_add(s1410, s1498); + const SWord32 s1500 = sbv_bv_u32_rotr(s1499, 2); + const SWord32 s1501 = sbv_bv_u32_rotr(s1499, 13); + const SWord32 s1502 = s1500 ^ s1501; + const SWord32 s1503 = sbv_bv_u32_rotr(s1499, 22); + const SWord32 s1504 = s1502 ^ s1503; + const SWord32 s1505 = s1488 & s1499; + const SWord32 s1506 = s1477 & s1499; + const SWord32 s1507 = s1505 ^ s1506; + const SWord32 s1508 = s1494 ^ s1507; + const SWord32 s1509 = sbv_bv_u32_add(s1504, s1508); + const SWord32 s1510 = sbv_bv_u32_add(s1438, s1509); + const SWord32 s1511 = sbv_bv_u32_rotr(s1510, 2); + const SWord32 s1512 = sbv_bv_u32_rotr(s1510, 13); + const SWord32 s1513 = s1511 ^ s1512; + const SWord32 s1514 = sbv_bv_u32_rotr(s1510, 22); + const SWord32 s1515 = s1513 ^ s1514; + const SWord32 s1516 = s1499 & s1510; + const SWord32 s1517 = s1488 & s1510; + const SWord32 s1518 = s1516 ^ s1517; + const SWord32 s1519 = s1505 ^ s1518; + const SWord32 s1520 = sbv_bv_u32_add(s1515, s1519); + const SWord32 s1521 = sbv_bv_u32_add(s1466, s1520); + const SWord32 s1522 = sbv_bv_u32_add(s1466, s1477); + const SWord32 s1523 = sbv_bv_u32_rotr(s1522, 6); + const SWord32 s1524 = sbv_bv_u32_rotr(s1522, 11); + const SWord32 s1525 = s1523 ^ s1524; + const SWord32 s1526 = sbv_bv_u32_rotr(s1522, 25); + const SWord32 s1527 = s1525 ^ s1526; + const SWord32 s1528 = sbv_bv_u32_add(s1383, s1527); + const SWord32 s1529 = s1439 & s1522; + const SWord32 s1530 = ~s1522; + const SWord32 s1531 = s1411 & s1530; + const SWord32 s1532 = s1529 ^ s1531; + const SWord32 s1533 = sbv_bv_u32_add(s1528, s1532); + const SWord32 s1535 = sbv_bv_u32_add(s1533, 0xa2bfe8a1UL); + const SWord32 s1536 = sbv_bv_u32_rotr(s1437, 17); + const SWord32 s1537 = sbv_bv_u32_rotr(s1437, 19); + const SWord32 s1538 = s1536 ^ s1537; + const SWord32 s1539 = sbv_bv_u32_lshr(s1437, 0x0000000aUL); + const SWord32 s1540 = s1538 ^ s1539; + const SWord32 s1541 = sbv_bv_u32_add(s1264, s1540); + const SWord32 s1542 = sbv_bv_u32_rotr(s952, 7); + const SWord32 s1543 = sbv_bv_u32_rotr(s952, 18); + const SWord32 s1544 = s1542 ^ s1543; + const SWord32 s1545 = sbv_bv_u32_lshr(s952, 0x00000003UL); + const SWord32 s1546 = s1544 ^ s1545; + const SWord32 s1547 = sbv_bv_u32_add(s1541, s1546); + const SWord32 s1548 = sbv_bv_u32_add(s924, s1547); + const SWord32 s1549 = sbv_bv_u32_add(s1535, s1548); + const SWord32 s1550 = sbv_bv_u32_add(s1488, s1549); + const SWord32 s1551 = sbv_bv_u32_rotr(s1550, 6); + const SWord32 s1552 = sbv_bv_u32_rotr(s1550, 11); + const SWord32 s1553 = s1551 ^ s1552; + const SWord32 s1554 = sbv_bv_u32_rotr(s1550, 25); + const SWord32 s1555 = s1553 ^ s1554; + const SWord32 s1556 = sbv_bv_u32_add(s1411, s1555); + const SWord32 s1557 = s1522 & s1550; + const SWord32 s1558 = ~s1550; + const SWord32 s1559 = s1439 & s1558; + const SWord32 s1560 = s1557 ^ s1559; + const SWord32 s1561 = sbv_bv_u32_add(s1556, s1560); + const SWord32 s1563 = sbv_bv_u32_add(s1561, 0xa81a664bUL); + const SWord32 s1564 = sbv_bv_u32_rotr(s1465, 17); + const SWord32 s1565 = sbv_bv_u32_rotr(s1465, 19); + const SWord32 s1566 = s1564 ^ s1565; + const SWord32 s1567 = sbv_bv_u32_lshr(s1465, 0x0000000aUL); + const SWord32 s1568 = s1566 ^ s1567; + const SWord32 s1569 = sbv_bv_u32_add(s1292, s1568); + const SWord32 s1570 = sbv_bv_u32_rotr(s980, 7); + const SWord32 s1571 = sbv_bv_u32_rotr(s980, 18); + const SWord32 s1572 = s1570 ^ s1571; + const SWord32 s1573 = sbv_bv_u32_lshr(s980, 0x00000003UL); + const SWord32 s1574 = s1572 ^ s1573; + const SWord32 s1575 = sbv_bv_u32_add(s1569, s1574); + const SWord32 s1576 = sbv_bv_u32_add(s952, s1575); + const SWord32 s1577 = sbv_bv_u32_add(s1563, s1576); + const SWord32 s1578 = sbv_bv_u32_add(s1499, s1577); + const SWord32 s1579 = sbv_bv_u32_rotr(s1578, 6); + const SWord32 s1580 = sbv_bv_u32_rotr(s1578, 11); + const SWord32 s1581 = s1579 ^ s1580; + const SWord32 s1582 = sbv_bv_u32_rotr(s1578, 25); + const SWord32 s1583 = s1581 ^ s1582; + const SWord32 s1584 = sbv_bv_u32_add(s1439, s1583); + const SWord32 s1585 = s1550 & s1578; + const SWord32 s1586 = ~s1578; + const SWord32 s1587 = s1522 & s1586; + const SWord32 s1588 = s1585 ^ s1587; + const SWord32 s1589 = sbv_bv_u32_add(s1584, s1588); + const SWord32 s1591 = sbv_bv_u32_add(s1589, 0xc24b8b70UL); + const SWord32 s1592 = sbv_bv_u32_rotr(s1548, 17); + const SWord32 s1593 = sbv_bv_u32_rotr(s1548, 19); + const SWord32 s1594 = s1592 ^ s1593; + const SWord32 s1595 = sbv_bv_u32_lshr(s1548, 0x0000000aUL); + const SWord32 s1596 = s1594 ^ s1595; + const SWord32 s1597 = sbv_bv_u32_add(s1320, s1596); + const SWord32 s1598 = sbv_bv_u32_rotr(s1008, 7); + const SWord32 s1599 = sbv_bv_u32_rotr(s1008, 18); + const SWord32 s1600 = s1598 ^ s1599; + const SWord32 s1601 = sbv_bv_u32_lshr(s1008, 0x00000003UL); + const SWord32 s1602 = s1600 ^ s1601; + const SWord32 s1603 = sbv_bv_u32_add(s1597, s1602); + const SWord32 s1604 = sbv_bv_u32_add(s980, s1603); + const SWord32 s1605 = sbv_bv_u32_add(s1591, s1604); + const SWord32 s1606 = sbv_bv_u32_add(s1510, s1605); + const SWord32 s1607 = sbv_bv_u32_rotr(s1606, 6); + const SWord32 s1608 = sbv_bv_u32_rotr(s1606, 11); + const SWord32 s1609 = s1607 ^ s1608; + const SWord32 s1610 = sbv_bv_u32_rotr(s1606, 25); + const SWord32 s1611 = s1609 ^ s1610; + const SWord32 s1612 = sbv_bv_u32_add(s1522, s1611); + const SWord32 s1613 = s1578 & s1606; + const SWord32 s1614 = ~s1606; + const SWord32 s1615 = s1550 & s1614; + const SWord32 s1616 = s1613 ^ s1615; + const SWord32 s1617 = sbv_bv_u32_add(s1612, s1616); + const SWord32 s1619 = sbv_bv_u32_add(s1617, 0xc76c51a3UL); + const SWord32 s1620 = sbv_bv_u32_rotr(s1576, 17); + const SWord32 s1621 = sbv_bv_u32_rotr(s1576, 19); + const SWord32 s1622 = s1620 ^ s1621; + const SWord32 s1623 = sbv_bv_u32_lshr(s1576, 0x0000000aUL); + const SWord32 s1624 = s1622 ^ s1623; + const SWord32 s1625 = sbv_bv_u32_add(s1381, s1624); + const SWord32 s1626 = sbv_bv_u32_rotr(s1069, 7); + const SWord32 s1627 = sbv_bv_u32_rotr(s1069, 18); + const SWord32 s1628 = s1626 ^ s1627; + const SWord32 s1629 = sbv_bv_u32_lshr(s1069, 0x00000003UL); + const SWord32 s1630 = s1628 ^ s1629; + const SWord32 s1631 = sbv_bv_u32_add(s1625, s1630); + const SWord32 s1632 = sbv_bv_u32_add(s1008, s1631); + const SWord32 s1633 = sbv_bv_u32_add(s1619, s1632); + const SWord32 s1634 = sbv_bv_u32_add(s1521, s1633); + const SWord32 s1635 = sbv_bv_u32_rotr(s1521, 2); + const SWord32 s1636 = sbv_bv_u32_rotr(s1521, 13); + const SWord32 s1637 = s1635 ^ s1636; + const SWord32 s1638 = sbv_bv_u32_rotr(s1521, 22); + const SWord32 s1639 = s1637 ^ s1638; + const SWord32 s1640 = s1510 & s1521; + const SWord32 s1641 = s1499 & s1521; + const SWord32 s1642 = s1640 ^ s1641; + const SWord32 s1643 = s1516 ^ s1642; + const SWord32 s1644 = sbv_bv_u32_add(s1639, s1643); + const SWord32 s1645 = sbv_bv_u32_add(s1549, s1644); + const SWord32 s1646 = sbv_bv_u32_rotr(s1645, 2); + const SWord32 s1647 = sbv_bv_u32_rotr(s1645, 13); + const SWord32 s1648 = s1646 ^ s1647; + const SWord32 s1649 = sbv_bv_u32_rotr(s1645, 22); + const SWord32 s1650 = s1648 ^ s1649; + const SWord32 s1651 = s1521 & s1645; + const SWord32 s1652 = s1510 & s1645; + const SWord32 s1653 = s1651 ^ s1652; + const SWord32 s1654 = s1640 ^ s1653; + const SWord32 s1655 = sbv_bv_u32_add(s1650, s1654); + const SWord32 s1656 = sbv_bv_u32_add(s1577, s1655); + const SWord32 s1657 = sbv_bv_u32_rotr(s1656, 2); + const SWord32 s1658 = sbv_bv_u32_rotr(s1656, 13); + const SWord32 s1659 = s1657 ^ s1658; + const SWord32 s1660 = sbv_bv_u32_rotr(s1656, 22); + const SWord32 s1661 = s1659 ^ s1660; + const SWord32 s1662 = s1645 & s1656; + const SWord32 s1663 = s1521 & s1656; + const SWord32 s1664 = s1662 ^ s1663; + const SWord32 s1665 = s1651 ^ s1664; + const SWord32 s1666 = sbv_bv_u32_add(s1661, s1665); + const SWord32 s1667 = sbv_bv_u32_add(s1605, s1666); + const SWord32 s1668 = sbv_bv_u32_rotr(s1634, 6); + const SWord32 s1669 = sbv_bv_u32_rotr(s1634, 11); + const SWord32 s1670 = s1668 ^ s1669; + const SWord32 s1671 = sbv_bv_u32_rotr(s1634, 25); + const SWord32 s1672 = s1670 ^ s1671; + const SWord32 s1673 = sbv_bv_u32_add(s1550, s1672); + const SWord32 s1674 = s1606 & s1634; + const SWord32 s1675 = ~s1634; + const SWord32 s1676 = s1578 & s1675; + const SWord32 s1677 = s1674 ^ s1676; + const SWord32 s1678 = sbv_bv_u32_add(s1673, s1677); + const SWord32 s1680 = sbv_bv_u32_add(s1678, 0xd192e819UL); + const SWord32 s1681 = sbv_bv_u32_rotr(s1604, 17); + const SWord32 s1682 = sbv_bv_u32_rotr(s1604, 19); + const SWord32 s1683 = s1681 ^ s1682; + const SWord32 s1684 = sbv_bv_u32_lshr(s1604, 0x0000000aUL); + const SWord32 s1685 = s1683 ^ s1684; + const SWord32 s1686 = sbv_bv_u32_add(s1409, s1685); + const SWord32 s1687 = sbv_bv_u32_rotr(s1097, 7); + const SWord32 s1688 = sbv_bv_u32_rotr(s1097, 18); + const SWord32 s1689 = s1687 ^ s1688; + const SWord32 s1690 = sbv_bv_u32_lshr(s1097, 0x00000003UL); + const SWord32 s1691 = s1689 ^ s1690; + const SWord32 s1692 = sbv_bv_u32_add(s1686, s1691); + const SWord32 s1693 = sbv_bv_u32_add(s1069, s1692); + const SWord32 s1694 = sbv_bv_u32_add(s1680, s1693); + const SWord32 s1695 = sbv_bv_u32_add(s1645, s1694); + const SWord32 s1696 = sbv_bv_u32_rotr(s1695, 6); + const SWord32 s1697 = sbv_bv_u32_rotr(s1695, 11); + const SWord32 s1698 = s1696 ^ s1697; + const SWord32 s1699 = sbv_bv_u32_rotr(s1695, 25); + const SWord32 s1700 = s1698 ^ s1699; + const SWord32 s1701 = sbv_bv_u32_add(s1578, s1700); + const SWord32 s1702 = s1634 & s1695; + const SWord32 s1703 = ~s1695; + const SWord32 s1704 = s1606 & s1703; + const SWord32 s1705 = s1702 ^ s1704; + const SWord32 s1706 = sbv_bv_u32_add(s1701, s1705); + const SWord32 s1708 = sbv_bv_u32_add(s1706, 0xd6990624UL); + const SWord32 s1709 = sbv_bv_u32_rotr(s1632, 17); + const SWord32 s1710 = sbv_bv_u32_rotr(s1632, 19); + const SWord32 s1711 = s1709 ^ s1710; + const SWord32 s1712 = sbv_bv_u32_lshr(s1632, 0x0000000aUL); + const SWord32 s1713 = s1711 ^ s1712; + const SWord32 s1714 = sbv_bv_u32_add(s1437, s1713); + const SWord32 s1715 = sbv_bv_u32_rotr(s1125, 7); + const SWord32 s1716 = sbv_bv_u32_rotr(s1125, 18); + const SWord32 s1717 = s1715 ^ s1716; + const SWord32 s1718 = sbv_bv_u32_lshr(s1125, 0x00000003UL); + const SWord32 s1719 = s1717 ^ s1718; + const SWord32 s1720 = sbv_bv_u32_add(s1714, s1719); + const SWord32 s1721 = sbv_bv_u32_add(s1097, s1720); + const SWord32 s1722 = sbv_bv_u32_add(s1708, s1721); + const SWord32 s1723 = sbv_bv_u32_add(s1656, s1722); + const SWord32 s1724 = sbv_bv_u32_rotr(s1723, 6); + const SWord32 s1725 = sbv_bv_u32_rotr(s1723, 11); + const SWord32 s1726 = s1724 ^ s1725; + const SWord32 s1727 = sbv_bv_u32_rotr(s1723, 25); + const SWord32 s1728 = s1726 ^ s1727; + const SWord32 s1729 = sbv_bv_u32_add(s1606, s1728); + const SWord32 s1730 = s1695 & s1723; + const SWord32 s1731 = ~s1723; + const SWord32 s1732 = s1634 & s1731; + const SWord32 s1733 = s1730 ^ s1732; + const SWord32 s1734 = sbv_bv_u32_add(s1729, s1733); + const SWord32 s1736 = sbv_bv_u32_add(s1734, 0xf40e3585UL); + const SWord32 s1737 = sbv_bv_u32_rotr(s1693, 17); + const SWord32 s1738 = sbv_bv_u32_rotr(s1693, 19); + const SWord32 s1739 = s1737 ^ s1738; + const SWord32 s1740 = sbv_bv_u32_lshr(s1693, 0x0000000aUL); + const SWord32 s1741 = s1739 ^ s1740; + const SWord32 s1742 = sbv_bv_u32_add(s1465, s1741); + const SWord32 s1743 = sbv_bv_u32_rotr(s1153, 7); + const SWord32 s1744 = sbv_bv_u32_rotr(s1153, 18); + const SWord32 s1745 = s1743 ^ s1744; + const SWord32 s1746 = sbv_bv_u32_lshr(s1153, 0x00000003UL); + const SWord32 s1747 = s1745 ^ s1746; + const SWord32 s1748 = sbv_bv_u32_add(s1742, s1747); + const SWord32 s1749 = sbv_bv_u32_add(s1125, s1748); + const SWord32 s1750 = sbv_bv_u32_add(s1736, s1749); + const SWord32 s1751 = sbv_bv_u32_add(s1667, s1750); + const SWord32 s1752 = sbv_bv_u32_rotr(s1751, 6); + const SWord32 s1753 = sbv_bv_u32_rotr(s1751, 11); + const SWord32 s1754 = s1752 ^ s1753; + const SWord32 s1755 = sbv_bv_u32_rotr(s1751, 25); + const SWord32 s1756 = s1754 ^ s1755; + const SWord32 s1757 = sbv_bv_u32_add(s1634, s1756); + const SWord32 s1758 = s1723 & s1751; + const SWord32 s1759 = ~s1751; + const SWord32 s1760 = s1695 & s1759; + const SWord32 s1761 = s1758 ^ s1760; + const SWord32 s1762 = sbv_bv_u32_add(s1757, s1761); + const SWord32 s1764 = sbv_bv_u32_add(s1762, 0x106aa070UL); + const SWord32 s1765 = sbv_bv_u32_rotr(s1721, 17); + const SWord32 s1766 = sbv_bv_u32_rotr(s1721, 19); + const SWord32 s1767 = s1765 ^ s1766; + const SWord32 s1768 = sbv_bv_u32_lshr(s1721, 0x0000000aUL); + const SWord32 s1769 = s1767 ^ s1768; + const SWord32 s1770 = sbv_bv_u32_add(s1548, s1769); + const SWord32 s1771 = sbv_bv_u32_rotr(s1236, 7); + const SWord32 s1772 = sbv_bv_u32_rotr(s1236, 18); + const SWord32 s1773 = s1771 ^ s1772; + const SWord32 s1774 = sbv_bv_u32_lshr(s1236, 0x00000003UL); + const SWord32 s1775 = s1773 ^ s1774; + const SWord32 s1776 = sbv_bv_u32_add(s1770, s1775); + const SWord32 s1777 = sbv_bv_u32_add(s1153, s1776); + const SWord32 s1778 = sbv_bv_u32_add(s1764, s1777); + const SWord32 s1779 = sbv_bv_u32_rotr(s1667, 2); + const SWord32 s1780 = sbv_bv_u32_rotr(s1667, 13); + const SWord32 s1781 = s1779 ^ s1780; + const SWord32 s1782 = sbv_bv_u32_rotr(s1667, 22); + const SWord32 s1783 = s1781 ^ s1782; + const SWord32 s1784 = s1656 & s1667; + const SWord32 s1785 = s1645 & s1667; + const SWord32 s1786 = s1784 ^ s1785; + const SWord32 s1787 = s1662 ^ s1786; + const SWord32 s1788 = sbv_bv_u32_add(s1783, s1787); + const SWord32 s1789 = sbv_bv_u32_add(s1633, s1788); + const SWord32 s1790 = sbv_bv_u32_rotr(s1789, 2); + const SWord32 s1791 = sbv_bv_u32_rotr(s1789, 13); + const SWord32 s1792 = s1790 ^ s1791; + const SWord32 s1793 = sbv_bv_u32_rotr(s1789, 22); + const SWord32 s1794 = s1792 ^ s1793; + const SWord32 s1795 = s1667 & s1789; + const SWord32 s1796 = s1656 & s1789; + const SWord32 s1797 = s1795 ^ s1796; + const SWord32 s1798 = s1784 ^ s1797; + const SWord32 s1799 = sbv_bv_u32_add(s1794, s1798); + const SWord32 s1800 = sbv_bv_u32_add(s1694, s1799); + const SWord32 s1801 = sbv_bv_u32_rotr(s1800, 2); + const SWord32 s1802 = sbv_bv_u32_rotr(s1800, 13); + const SWord32 s1803 = s1801 ^ s1802; + const SWord32 s1804 = sbv_bv_u32_rotr(s1800, 22); + const SWord32 s1805 = s1803 ^ s1804; + const SWord32 s1806 = s1789 & s1800; + const SWord32 s1807 = s1667 & s1800; + const SWord32 s1808 = s1806 ^ s1807; + const SWord32 s1809 = s1795 ^ s1808; + const SWord32 s1810 = sbv_bv_u32_add(s1805, s1809); + const SWord32 s1811 = sbv_bv_u32_add(s1722, s1810); + const SWord32 s1812 = sbv_bv_u32_rotr(s1811, 2); + const SWord32 s1813 = sbv_bv_u32_rotr(s1811, 13); + const SWord32 s1814 = s1812 ^ s1813; + const SWord32 s1815 = sbv_bv_u32_rotr(s1811, 22); + const SWord32 s1816 = s1814 ^ s1815; + const SWord32 s1817 = s1800 & s1811; + const SWord32 s1818 = s1789 & s1811; + const SWord32 s1819 = s1817 ^ s1818; + const SWord32 s1820 = s1806 ^ s1819; + const SWord32 s1821 = sbv_bv_u32_add(s1816, s1820); + const SWord32 s1822 = sbv_bv_u32_add(s1750, s1821); + const SWord32 s1823 = sbv_bv_u32_rotr(s1822, 2); + const SWord32 s1824 = sbv_bv_u32_rotr(s1822, 13); + const SWord32 s1825 = s1823 ^ s1824; + const SWord32 s1826 = sbv_bv_u32_rotr(s1822, 22); + const SWord32 s1827 = s1825 ^ s1826; + const SWord32 s1828 = s1811 & s1822; + const SWord32 s1829 = s1800 & s1822; + const SWord32 s1830 = s1828 ^ s1829; + const SWord32 s1831 = s1817 ^ s1830; + const SWord32 s1832 = sbv_bv_u32_add(s1827, s1831); + const SWord32 s1833 = sbv_bv_u32_add(s1778, s1832); + const SWord32 s1834 = sbv_bv_u32_add(s1778, s1789); + const SWord32 s1835 = sbv_bv_u32_rotr(s1834, 6); + const SWord32 s1836 = sbv_bv_u32_rotr(s1834, 11); + const SWord32 s1837 = s1835 ^ s1836; + const SWord32 s1838 = sbv_bv_u32_rotr(s1834, 25); + const SWord32 s1839 = s1837 ^ s1838; + const SWord32 s1840 = sbv_bv_u32_add(s1695, s1839); + const SWord32 s1841 = s1751 & s1834; + const SWord32 s1842 = ~s1834; + const SWord32 s1843 = s1723 & s1842; + const SWord32 s1844 = s1841 ^ s1843; + const SWord32 s1845 = sbv_bv_u32_add(s1840, s1844); + const SWord32 s1847 = sbv_bv_u32_add(s1845, 0x19a4c116UL); + const SWord32 s1848 = sbv_bv_u32_rotr(s1749, 17); + const SWord32 s1849 = sbv_bv_u32_rotr(s1749, 19); + const SWord32 s1850 = s1848 ^ s1849; + const SWord32 s1851 = sbv_bv_u32_lshr(s1749, 0x0000000aUL); + const SWord32 s1852 = s1850 ^ s1851; + const SWord32 s1853 = sbv_bv_u32_add(s1576, s1852); + const SWord32 s1854 = sbv_bv_u32_rotr(s1264, 7); + const SWord32 s1855 = sbv_bv_u32_rotr(s1264, 18); + const SWord32 s1856 = s1854 ^ s1855; + const SWord32 s1857 = sbv_bv_u32_lshr(s1264, 0x00000003UL); + const SWord32 s1858 = s1856 ^ s1857; + const SWord32 s1859 = sbv_bv_u32_add(s1853, s1858); + const SWord32 s1860 = sbv_bv_u32_add(s1236, s1859); + const SWord32 s1861 = sbv_bv_u32_add(s1847, s1860); + const SWord32 s1862 = sbv_bv_u32_add(s1800, s1861); + const SWord32 s1863 = sbv_bv_u32_rotr(s1862, 6); + const SWord32 s1864 = sbv_bv_u32_rotr(s1862, 11); + const SWord32 s1865 = s1863 ^ s1864; + const SWord32 s1866 = sbv_bv_u32_rotr(s1862, 25); + const SWord32 s1867 = s1865 ^ s1866; + const SWord32 s1868 = sbv_bv_u32_add(s1723, s1867); + const SWord32 s1869 = s1834 & s1862; + const SWord32 s1870 = ~s1862; + const SWord32 s1871 = s1751 & s1870; + const SWord32 s1872 = s1869 ^ s1871; + const SWord32 s1873 = sbv_bv_u32_add(s1868, s1872); + const SWord32 s1875 = sbv_bv_u32_add(s1873, 0x1e376c08UL); + const SWord32 s1876 = sbv_bv_u32_rotr(s1777, 17); + const SWord32 s1877 = sbv_bv_u32_rotr(s1777, 19); + const SWord32 s1878 = s1876 ^ s1877; + const SWord32 s1879 = sbv_bv_u32_lshr(s1777, 0x0000000aUL); + const SWord32 s1880 = s1878 ^ s1879; + const SWord32 s1881 = sbv_bv_u32_add(s1604, s1880); + const SWord32 s1882 = sbv_bv_u32_rotr(s1292, 7); + const SWord32 s1883 = sbv_bv_u32_rotr(s1292, 18); + const SWord32 s1884 = s1882 ^ s1883; + const SWord32 s1885 = sbv_bv_u32_lshr(s1292, 0x00000003UL); + const SWord32 s1886 = s1884 ^ s1885; + const SWord32 s1887 = sbv_bv_u32_add(s1881, s1886); + const SWord32 s1888 = sbv_bv_u32_add(s1264, s1887); + const SWord32 s1889 = sbv_bv_u32_add(s1875, s1888); + const SWord32 s1890 = sbv_bv_u32_add(s1811, s1889); + const SWord32 s1891 = sbv_bv_u32_rotr(s1890, 6); + const SWord32 s1892 = sbv_bv_u32_rotr(s1890, 11); + const SWord32 s1893 = s1891 ^ s1892; + const SWord32 s1894 = sbv_bv_u32_rotr(s1890, 25); + const SWord32 s1895 = s1893 ^ s1894; + const SWord32 s1896 = sbv_bv_u32_add(s1751, s1895); + const SWord32 s1897 = s1862 & s1890; + const SWord32 s1898 = ~s1890; + const SWord32 s1899 = s1834 & s1898; + const SWord32 s1900 = s1897 ^ s1899; + const SWord32 s1901 = sbv_bv_u32_add(s1896, s1900); + const SWord32 s1903 = sbv_bv_u32_add(s1901, 0x2748774cUL); + const SWord32 s1904 = sbv_bv_u32_rotr(s1860, 17); + const SWord32 s1905 = sbv_bv_u32_rotr(s1860, 19); + const SWord32 s1906 = s1904 ^ s1905; + const SWord32 s1907 = sbv_bv_u32_lshr(s1860, 0x0000000aUL); + const SWord32 s1908 = s1906 ^ s1907; + const SWord32 s1909 = sbv_bv_u32_add(s1632, s1908); + const SWord32 s1910 = sbv_bv_u32_rotr(s1320, 7); + const SWord32 s1911 = sbv_bv_u32_rotr(s1320, 18); + const SWord32 s1912 = s1910 ^ s1911; + const SWord32 s1913 = sbv_bv_u32_lshr(s1320, 0x00000003UL); + const SWord32 s1914 = s1912 ^ s1913; + const SWord32 s1915 = sbv_bv_u32_add(s1909, s1914); + const SWord32 s1916 = sbv_bv_u32_add(s1292, s1915); + const SWord32 s1917 = sbv_bv_u32_add(s1903, s1916); + const SWord32 s1918 = sbv_bv_u32_add(s1822, s1917); + const SWord32 s1919 = sbv_bv_u32_rotr(s1918, 6); + const SWord32 s1920 = sbv_bv_u32_rotr(s1918, 11); + const SWord32 s1921 = s1919 ^ s1920; + const SWord32 s1922 = sbv_bv_u32_rotr(s1918, 25); + const SWord32 s1923 = s1921 ^ s1922; + const SWord32 s1924 = sbv_bv_u32_add(s1834, s1923); + const SWord32 s1925 = s1890 & s1918; + const SWord32 s1926 = ~s1918; + const SWord32 s1927 = s1862 & s1926; + const SWord32 s1928 = s1925 ^ s1927; + const SWord32 s1929 = sbv_bv_u32_add(s1924, s1928); + const SWord32 s1931 = sbv_bv_u32_add(s1929, 0x34b0bcb5UL); + const SWord32 s1932 = sbv_bv_u32_rotr(s1888, 17); + const SWord32 s1933 = sbv_bv_u32_rotr(s1888, 19); + const SWord32 s1934 = s1932 ^ s1933; + const SWord32 s1935 = sbv_bv_u32_lshr(s1888, 0x0000000aUL); + const SWord32 s1936 = s1934 ^ s1935; + const SWord32 s1937 = sbv_bv_u32_add(s1693, s1936); + const SWord32 s1938 = sbv_bv_u32_rotr(s1381, 7); + const SWord32 s1939 = sbv_bv_u32_rotr(s1381, 18); + const SWord32 s1940 = s1938 ^ s1939; + const SWord32 s1941 = sbv_bv_u32_lshr(s1381, 0x00000003UL); + const SWord32 s1942 = s1940 ^ s1941; + const SWord32 s1943 = sbv_bv_u32_add(s1937, s1942); + const SWord32 s1944 = sbv_bv_u32_add(s1320, s1943); + const SWord32 s1945 = sbv_bv_u32_add(s1931, s1944); + const SWord32 s1946 = sbv_bv_u32_add(s1833, s1945); + const SWord32 s1947 = sbv_bv_u32_rotr(s1833, 2); + const SWord32 s1948 = sbv_bv_u32_rotr(s1833, 13); + const SWord32 s1949 = s1947 ^ s1948; + const SWord32 s1950 = sbv_bv_u32_rotr(s1833, 22); + const SWord32 s1951 = s1949 ^ s1950; + const SWord32 s1952 = s1822 & s1833; + const SWord32 s1953 = s1811 & s1833; + const SWord32 s1954 = s1952 ^ s1953; + const SWord32 s1955 = s1828 ^ s1954; + const SWord32 s1956 = sbv_bv_u32_add(s1951, s1955); + const SWord32 s1957 = sbv_bv_u32_add(s1861, s1956); + const SWord32 s1958 = sbv_bv_u32_rotr(s1957, 2); + const SWord32 s1959 = sbv_bv_u32_rotr(s1957, 13); + const SWord32 s1960 = s1958 ^ s1959; + const SWord32 s1961 = sbv_bv_u32_rotr(s1957, 22); + const SWord32 s1962 = s1960 ^ s1961; + const SWord32 s1963 = s1833 & s1957; + const SWord32 s1964 = s1822 & s1957; + const SWord32 s1965 = s1963 ^ s1964; + const SWord32 s1966 = s1952 ^ s1965; + const SWord32 s1967 = sbv_bv_u32_add(s1962, s1966); + const SWord32 s1968 = sbv_bv_u32_add(s1889, s1967); + const SWord32 s1969 = sbv_bv_u32_rotr(s1968, 2); + const SWord32 s1970 = sbv_bv_u32_rotr(s1968, 13); + const SWord32 s1971 = s1969 ^ s1970; + const SWord32 s1972 = sbv_bv_u32_rotr(s1968, 22); + const SWord32 s1973 = s1971 ^ s1972; + const SWord32 s1974 = s1957 & s1968; + const SWord32 s1975 = s1833 & s1968; + const SWord32 s1976 = s1974 ^ s1975; + const SWord32 s1977 = s1963 ^ s1976; + const SWord32 s1978 = sbv_bv_u32_add(s1973, s1977); + const SWord32 s1979 = sbv_bv_u32_add(s1917, s1978); + const SWord32 s1980 = sbv_bv_u32_rotr(s1946, 6); + const SWord32 s1981 = sbv_bv_u32_rotr(s1946, 11); + const SWord32 s1982 = s1980 ^ s1981; + const SWord32 s1983 = sbv_bv_u32_rotr(s1946, 25); + const SWord32 s1984 = s1982 ^ s1983; + const SWord32 s1985 = sbv_bv_u32_add(s1862, s1984); + const SWord32 s1986 = s1918 & s1946; + const SWord32 s1987 = ~s1946; + const SWord32 s1988 = s1890 & s1987; + const SWord32 s1989 = s1986 ^ s1988; + const SWord32 s1990 = sbv_bv_u32_add(s1985, s1989); + const SWord32 s1992 = sbv_bv_u32_add(s1990, 0x391c0cb3UL); + const SWord32 s1993 = sbv_bv_u32_rotr(s1916, 17); + const SWord32 s1994 = sbv_bv_u32_rotr(s1916, 19); + const SWord32 s1995 = s1993 ^ s1994; + const SWord32 s1996 = sbv_bv_u32_lshr(s1916, 0x0000000aUL); + const SWord32 s1997 = s1995 ^ s1996; + const SWord32 s1998 = sbv_bv_u32_add(s1721, s1997); + const SWord32 s1999 = sbv_bv_u32_rotr(s1409, 7); + const SWord32 s2000 = sbv_bv_u32_rotr(s1409, 18); + const SWord32 s2001 = s1999 ^ s2000; + const SWord32 s2002 = sbv_bv_u32_lshr(s1409, 0x00000003UL); + const SWord32 s2003 = s2001 ^ s2002; + const SWord32 s2004 = sbv_bv_u32_add(s1998, s2003); + const SWord32 s2005 = sbv_bv_u32_add(s1381, s2004); + const SWord32 s2006 = sbv_bv_u32_add(s1992, s2005); + const SWord32 s2007 = sbv_bv_u32_add(s1957, s2006); + const SWord32 s2008 = sbv_bv_u32_rotr(s2007, 6); + const SWord32 s2009 = sbv_bv_u32_rotr(s2007, 11); + const SWord32 s2010 = s2008 ^ s2009; + const SWord32 s2011 = sbv_bv_u32_rotr(s2007, 25); + const SWord32 s2012 = s2010 ^ s2011; + const SWord32 s2013 = sbv_bv_u32_add(s1890, s2012); + const SWord32 s2014 = s1946 & s2007; + const SWord32 s2015 = ~s2007; + const SWord32 s2016 = s1918 & s2015; + const SWord32 s2017 = s2014 ^ s2016; + const SWord32 s2018 = sbv_bv_u32_add(s2013, s2017); + const SWord32 s2020 = sbv_bv_u32_add(s2018, 0x4ed8aa4aUL); + const SWord32 s2021 = sbv_bv_u32_rotr(s1944, 17); + const SWord32 s2022 = sbv_bv_u32_rotr(s1944, 19); + const SWord32 s2023 = s2021 ^ s2022; + const SWord32 s2024 = sbv_bv_u32_lshr(s1944, 0x0000000aUL); + const SWord32 s2025 = s2023 ^ s2024; + const SWord32 s2026 = sbv_bv_u32_add(s1749, s2025); + const SWord32 s2027 = sbv_bv_u32_rotr(s1437, 7); + const SWord32 s2028 = sbv_bv_u32_rotr(s1437, 18); + const SWord32 s2029 = s2027 ^ s2028; + const SWord32 s2030 = sbv_bv_u32_lshr(s1437, 0x00000003UL); + const SWord32 s2031 = s2029 ^ s2030; + const SWord32 s2032 = sbv_bv_u32_add(s2026, s2031); + const SWord32 s2033 = sbv_bv_u32_add(s1409, s2032); + const SWord32 s2034 = sbv_bv_u32_add(s2020, s2033); + const SWord32 s2035 = sbv_bv_u32_add(s1968, s2034); + const SWord32 s2036 = sbv_bv_u32_rotr(s2035, 6); + const SWord32 s2037 = sbv_bv_u32_rotr(s2035, 11); + const SWord32 s2038 = s2036 ^ s2037; + const SWord32 s2039 = sbv_bv_u32_rotr(s2035, 25); + const SWord32 s2040 = s2038 ^ s2039; + const SWord32 s2041 = sbv_bv_u32_add(s1918, s2040); + const SWord32 s2042 = s2007 & s2035; + const SWord32 s2043 = ~s2035; + const SWord32 s2044 = s1946 & s2043; + const SWord32 s2045 = s2042 ^ s2044; + const SWord32 s2046 = sbv_bv_u32_add(s2041, s2045); + const SWord32 s2048 = sbv_bv_u32_add(s2046, 0x5b9cca4fUL); + const SWord32 s2049 = sbv_bv_u32_rotr(s2005, 17); + const SWord32 s2050 = sbv_bv_u32_rotr(s2005, 19); + const SWord32 s2051 = s2049 ^ s2050; + const SWord32 s2052 = sbv_bv_u32_lshr(s2005, 0x0000000aUL); + const SWord32 s2053 = s2051 ^ s2052; + const SWord32 s2054 = sbv_bv_u32_add(s1777, s2053); + const SWord32 s2055 = sbv_bv_u32_rotr(s1465, 7); + const SWord32 s2056 = sbv_bv_u32_rotr(s1465, 18); + const SWord32 s2057 = s2055 ^ s2056; + const SWord32 s2058 = sbv_bv_u32_lshr(s1465, 0x00000003UL); + const SWord32 s2059 = s2057 ^ s2058; + const SWord32 s2060 = sbv_bv_u32_add(s2054, s2059); + const SWord32 s2061 = sbv_bv_u32_add(s1437, s2060); + const SWord32 s2062 = sbv_bv_u32_add(s2048, s2061); + const SWord32 s2063 = sbv_bv_u32_add(s1979, s2062); + const SWord32 s2064 = sbv_bv_u32_rotr(s2063, 6); + const SWord32 s2065 = sbv_bv_u32_rotr(s2063, 11); + const SWord32 s2066 = s2064 ^ s2065; + const SWord32 s2067 = sbv_bv_u32_rotr(s2063, 25); + const SWord32 s2068 = s2066 ^ s2067; + const SWord32 s2069 = sbv_bv_u32_add(s1946, s2068); + const SWord32 s2070 = s2035 & s2063; + const SWord32 s2071 = ~s2063; + const SWord32 s2072 = s2007 & s2071; + const SWord32 s2073 = s2070 ^ s2072; + const SWord32 s2074 = sbv_bv_u32_add(s2069, s2073); + const SWord32 s2076 = sbv_bv_u32_add(s2074, 0x682e6ff3UL); + const SWord32 s2077 = sbv_bv_u32_rotr(s2033, 17); + const SWord32 s2078 = sbv_bv_u32_rotr(s2033, 19); + const SWord32 s2079 = s2077 ^ s2078; + const SWord32 s2080 = sbv_bv_u32_lshr(s2033, 0x0000000aUL); + const SWord32 s2081 = s2079 ^ s2080; + const SWord32 s2082 = sbv_bv_u32_add(s1860, s2081); + const SWord32 s2083 = sbv_bv_u32_rotr(s1548, 7); + const SWord32 s2084 = sbv_bv_u32_rotr(s1548, 18); + const SWord32 s2085 = s2083 ^ s2084; + const SWord32 s2086 = sbv_bv_u32_lshr(s1548, 0x00000003UL); + const SWord32 s2087 = s2085 ^ s2086; + const SWord32 s2088 = sbv_bv_u32_add(s2082, s2087); + const SWord32 s2089 = sbv_bv_u32_add(s1465, s2088); + const SWord32 s2090 = sbv_bv_u32_add(s2076, s2089); + const SWord32 s2091 = sbv_bv_u32_rotr(s1979, 2); + const SWord32 s2092 = sbv_bv_u32_rotr(s1979, 13); + const SWord32 s2093 = s2091 ^ s2092; + const SWord32 s2094 = sbv_bv_u32_rotr(s1979, 22); + const SWord32 s2095 = s2093 ^ s2094; + const SWord32 s2096 = s1968 & s1979; + const SWord32 s2097 = s1957 & s1979; + const SWord32 s2098 = s2096 ^ s2097; + const SWord32 s2099 = s1974 ^ s2098; + const SWord32 s2100 = sbv_bv_u32_add(s2095, s2099); + const SWord32 s2101 = sbv_bv_u32_add(s1945, s2100); + const SWord32 s2102 = sbv_bv_u32_rotr(s2101, 2); + const SWord32 s2103 = sbv_bv_u32_rotr(s2101, 13); + const SWord32 s2104 = s2102 ^ s2103; + const SWord32 s2105 = sbv_bv_u32_rotr(s2101, 22); + const SWord32 s2106 = s2104 ^ s2105; + const SWord32 s2107 = s1979 & s2101; + const SWord32 s2108 = s1968 & s2101; + const SWord32 s2109 = s2107 ^ s2108; + const SWord32 s2110 = s2096 ^ s2109; + const SWord32 s2111 = sbv_bv_u32_add(s2106, s2110); + const SWord32 s2112 = sbv_bv_u32_add(s2006, s2111); + const SWord32 s2113 = sbv_bv_u32_rotr(s2112, 2); + const SWord32 s2114 = sbv_bv_u32_rotr(s2112, 13); + const SWord32 s2115 = s2113 ^ s2114; + const SWord32 s2116 = sbv_bv_u32_rotr(s2112, 22); + const SWord32 s2117 = s2115 ^ s2116; + const SWord32 s2118 = s2101 & s2112; + const SWord32 s2119 = s1979 & s2112; + const SWord32 s2120 = s2118 ^ s2119; + const SWord32 s2121 = s2107 ^ s2120; + const SWord32 s2122 = sbv_bv_u32_add(s2117, s2121); + const SWord32 s2123 = sbv_bv_u32_add(s2034, s2122); + const SWord32 s2124 = sbv_bv_u32_rotr(s2123, 2); + const SWord32 s2125 = sbv_bv_u32_rotr(s2123, 13); + const SWord32 s2126 = s2124 ^ s2125; + const SWord32 s2127 = sbv_bv_u32_rotr(s2123, 22); + const SWord32 s2128 = s2126 ^ s2127; + const SWord32 s2129 = s2112 & s2123; + const SWord32 s2130 = s2101 & s2123; + const SWord32 s2131 = s2129 ^ s2130; + const SWord32 s2132 = s2118 ^ s2131; + const SWord32 s2133 = sbv_bv_u32_add(s2128, s2132); + const SWord32 s2134 = sbv_bv_u32_add(s2062, s2133); + const SWord32 s2135 = sbv_bv_u32_rotr(s2134, 2); + const SWord32 s2136 = sbv_bv_u32_rotr(s2134, 13); + const SWord32 s2137 = s2135 ^ s2136; + const SWord32 s2138 = sbv_bv_u32_rotr(s2134, 22); + const SWord32 s2139 = s2137 ^ s2138; + const SWord32 s2140 = s2123 & s2134; + const SWord32 s2141 = s2112 & s2134; + const SWord32 s2142 = s2140 ^ s2141; + const SWord32 s2143 = s2129 ^ s2142; + const SWord32 s2144 = sbv_bv_u32_add(s2139, s2143); + const SWord32 s2145 = sbv_bv_u32_add(s2090, s2144); + const SWord32 s2146 = sbv_bv_u32_add(s2090, s2101); + const SWord32 s2147 = sbv_bv_u32_rotr(s2146, 6); + const SWord32 s2148 = sbv_bv_u32_rotr(s2146, 11); + const SWord32 s2149 = s2147 ^ s2148; + const SWord32 s2150 = sbv_bv_u32_rotr(s2146, 25); + const SWord32 s2151 = s2149 ^ s2150; + const SWord32 s2152 = sbv_bv_u32_add(s2007, s2151); + const SWord32 s2153 = s2063 & s2146; + const SWord32 s2154 = ~s2146; + const SWord32 s2155 = s2035 & s2154; + const SWord32 s2156 = s2153 ^ s2155; + const SWord32 s2157 = sbv_bv_u32_add(s2152, s2156); + const SWord32 s2159 = sbv_bv_u32_add(s2157, 0x748f82eeUL); + const SWord32 s2160 = sbv_bv_u32_rotr(s2061, 17); + const SWord32 s2161 = sbv_bv_u32_rotr(s2061, 19); + const SWord32 s2162 = s2160 ^ s2161; + const SWord32 s2163 = sbv_bv_u32_lshr(s2061, 0x0000000aUL); + const SWord32 s2164 = s2162 ^ s2163; + const SWord32 s2165 = sbv_bv_u32_add(s1888, s2164); + const SWord32 s2166 = sbv_bv_u32_rotr(s1576, 7); + const SWord32 s2167 = sbv_bv_u32_rotr(s1576, 18); + const SWord32 s2168 = s2166 ^ s2167; + const SWord32 s2169 = sbv_bv_u32_lshr(s1576, 0x00000003UL); + const SWord32 s2170 = s2168 ^ s2169; + const SWord32 s2171 = sbv_bv_u32_add(s2165, s2170); + const SWord32 s2172 = sbv_bv_u32_add(s1548, s2171); + const SWord32 s2173 = sbv_bv_u32_add(s2159, s2172); + const SWord32 s2174 = sbv_bv_u32_add(s2112, s2173); + const SWord32 s2175 = sbv_bv_u32_rotr(s2174, 6); + const SWord32 s2176 = sbv_bv_u32_rotr(s2174, 11); + const SWord32 s2177 = s2175 ^ s2176; + const SWord32 s2178 = sbv_bv_u32_rotr(s2174, 25); + const SWord32 s2179 = s2177 ^ s2178; + const SWord32 s2180 = sbv_bv_u32_add(s2035, s2179); + const SWord32 s2181 = s2146 & s2174; + const SWord32 s2182 = ~s2174; + const SWord32 s2183 = s2063 & s2182; + const SWord32 s2184 = s2181 ^ s2183; + const SWord32 s2185 = sbv_bv_u32_add(s2180, s2184); + const SWord32 s2187 = sbv_bv_u32_add(s2185, 0x78a5636fUL); + const SWord32 s2188 = sbv_bv_u32_rotr(s2089, 17); + const SWord32 s2189 = sbv_bv_u32_rotr(s2089, 19); + const SWord32 s2190 = s2188 ^ s2189; + const SWord32 s2191 = sbv_bv_u32_lshr(s2089, 0x0000000aUL); + const SWord32 s2192 = s2190 ^ s2191; + const SWord32 s2193 = sbv_bv_u32_add(s1916, s2192); + const SWord32 s2194 = sbv_bv_u32_rotr(s1604, 7); + const SWord32 s2195 = sbv_bv_u32_rotr(s1604, 18); + const SWord32 s2196 = s2194 ^ s2195; + const SWord32 s2197 = sbv_bv_u32_lshr(s1604, 0x00000003UL); + const SWord32 s2198 = s2196 ^ s2197; + const SWord32 s2199 = sbv_bv_u32_add(s2193, s2198); + const SWord32 s2200 = sbv_bv_u32_add(s1576, s2199); + const SWord32 s2201 = sbv_bv_u32_add(s2187, s2200); + const SWord32 s2202 = sbv_bv_u32_add(s2123, s2201); + const SWord32 s2203 = sbv_bv_u32_rotr(s2202, 6); + const SWord32 s2204 = sbv_bv_u32_rotr(s2202, 11); + const SWord32 s2205 = s2203 ^ s2204; + const SWord32 s2206 = sbv_bv_u32_rotr(s2202, 25); + const SWord32 s2207 = s2205 ^ s2206; + const SWord32 s2208 = sbv_bv_u32_add(s2063, s2207); + const SWord32 s2209 = s2174 & s2202; + const SWord32 s2210 = ~s2202; + const SWord32 s2211 = s2146 & s2210; + const SWord32 s2212 = s2209 ^ s2211; + const SWord32 s2213 = sbv_bv_u32_add(s2208, s2212); + const SWord32 s2215 = sbv_bv_u32_add(s2213, 0x84c87814UL); + const SWord32 s2216 = sbv_bv_u32_rotr(s2172, 17); + const SWord32 s2217 = sbv_bv_u32_rotr(s2172, 19); + const SWord32 s2218 = s2216 ^ s2217; + const SWord32 s2219 = sbv_bv_u32_lshr(s2172, 0x0000000aUL); + const SWord32 s2220 = s2218 ^ s2219; + const SWord32 s2221 = sbv_bv_u32_add(s1944, s2220); + const SWord32 s2222 = sbv_bv_u32_rotr(s1632, 7); + const SWord32 s2223 = sbv_bv_u32_rotr(s1632, 18); + const SWord32 s2224 = s2222 ^ s2223; + const SWord32 s2225 = sbv_bv_u32_lshr(s1632, 0x00000003UL); + const SWord32 s2226 = s2224 ^ s2225; + const SWord32 s2227 = sbv_bv_u32_add(s2221, s2226); + const SWord32 s2228 = sbv_bv_u32_add(s1604, s2227); + const SWord32 s2229 = sbv_bv_u32_add(s2215, s2228); + const SWord32 s2230 = sbv_bv_u32_add(s2134, s2229); + const SWord32 s2231 = sbv_bv_u32_rotr(s2230, 6); + const SWord32 s2232 = sbv_bv_u32_rotr(s2230, 11); + const SWord32 s2233 = s2231 ^ s2232; + const SWord32 s2234 = sbv_bv_u32_rotr(s2230, 25); + const SWord32 s2235 = s2233 ^ s2234; + const SWord32 s2236 = sbv_bv_u32_add(s2146, s2235); + const SWord32 s2237 = s2202 & s2230; + const SWord32 s2238 = ~s2230; + const SWord32 s2239 = s2174 & s2238; + const SWord32 s2240 = s2237 ^ s2239; + const SWord32 s2241 = sbv_bv_u32_add(s2236, s2240); + const SWord32 s2243 = sbv_bv_u32_add(s2241, 0x8cc70208UL); + const SWord32 s2244 = sbv_bv_u32_rotr(s2200, 17); + const SWord32 s2245 = sbv_bv_u32_rotr(s2200, 19); + const SWord32 s2246 = s2244 ^ s2245; + const SWord32 s2247 = sbv_bv_u32_lshr(s2200, 0x0000000aUL); + const SWord32 s2248 = s2246 ^ s2247; + const SWord32 s2249 = sbv_bv_u32_add(s2005, s2248); + const SWord32 s2250 = sbv_bv_u32_rotr(s1693, 7); + const SWord32 s2251 = sbv_bv_u32_rotr(s1693, 18); + const SWord32 s2252 = s2250 ^ s2251; + const SWord32 s2253 = sbv_bv_u32_lshr(s1693, 0x00000003UL); + const SWord32 s2254 = s2252 ^ s2253; + const SWord32 s2255 = sbv_bv_u32_add(s2249, s2254); + const SWord32 s2256 = sbv_bv_u32_add(s1632, s2255); + const SWord32 s2257 = sbv_bv_u32_add(s2243, s2256); + const SWord32 s2258 = sbv_bv_u32_add(s2145, s2257); + const SWord32 s2259 = sbv_bv_u32_rotr(s2145, 2); + const SWord32 s2260 = sbv_bv_u32_rotr(s2145, 13); + const SWord32 s2261 = s2259 ^ s2260; + const SWord32 s2262 = sbv_bv_u32_rotr(s2145, 22); + const SWord32 s2263 = s2261 ^ s2262; + const SWord32 s2264 = s2134 & s2145; + const SWord32 s2265 = s2123 & s2145; + const SWord32 s2266 = s2264 ^ s2265; + const SWord32 s2267 = s2140 ^ s2266; + const SWord32 s2268 = sbv_bv_u32_add(s2263, s2267); + const SWord32 s2269 = sbv_bv_u32_add(s2173, s2268); + const SWord32 s2270 = sbv_bv_u32_rotr(s2269, 2); + const SWord32 s2271 = sbv_bv_u32_rotr(s2269, 13); + const SWord32 s2272 = s2270 ^ s2271; + const SWord32 s2273 = sbv_bv_u32_rotr(s2269, 22); + const SWord32 s2274 = s2272 ^ s2273; + const SWord32 s2275 = s2145 & s2269; + const SWord32 s2276 = s2134 & s2269; + const SWord32 s2277 = s2275 ^ s2276; + const SWord32 s2278 = s2264 ^ s2277; + const SWord32 s2279 = sbv_bv_u32_add(s2274, s2278); + const SWord32 s2280 = sbv_bv_u32_add(s2201, s2279); + const SWord32 s2281 = sbv_bv_u32_rotr(s2280, 2); + const SWord32 s2282 = sbv_bv_u32_rotr(s2280, 13); + const SWord32 s2283 = s2281 ^ s2282; + const SWord32 s2284 = sbv_bv_u32_rotr(s2280, 22); + const SWord32 s2285 = s2283 ^ s2284; + const SWord32 s2286 = s2269 & s2280; + const SWord32 s2287 = s2145 & s2280; + const SWord32 s2288 = s2286 ^ s2287; + const SWord32 s2289 = s2275 ^ s2288; + const SWord32 s2290 = sbv_bv_u32_add(s2285, s2289); + const SWord32 s2291 = sbv_bv_u32_add(s2229, s2290); + const SWord32 s2292 = sbv_bv_u32_rotr(s2258, 6); + const SWord32 s2293 = sbv_bv_u32_rotr(s2258, 11); + const SWord32 s2294 = s2292 ^ s2293; + const SWord32 s2295 = sbv_bv_u32_rotr(s2258, 25); + const SWord32 s2296 = s2294 ^ s2295; + const SWord32 s2297 = sbv_bv_u32_add(s2174, s2296); + const SWord32 s2298 = s2230 & s2258; + const SWord32 s2299 = ~s2258; + const SWord32 s2300 = s2202 & s2299; + const SWord32 s2301 = s2298 ^ s2300; + const SWord32 s2302 = sbv_bv_u32_add(s2297, s2301); + const SWord32 s2304 = sbv_bv_u32_add(s2302, 0x90befffaUL); + const SWord32 s2305 = sbv_bv_u32_rotr(s2228, 17); + const SWord32 s2306 = sbv_bv_u32_rotr(s2228, 19); + const SWord32 s2307 = s2305 ^ s2306; + const SWord32 s2308 = sbv_bv_u32_lshr(s2228, 0x0000000aUL); + const SWord32 s2309 = s2307 ^ s2308; + const SWord32 s2310 = sbv_bv_u32_add(s2033, s2309); + const SWord32 s2311 = sbv_bv_u32_rotr(s1721, 7); + const SWord32 s2312 = sbv_bv_u32_rotr(s1721, 18); + const SWord32 s2313 = s2311 ^ s2312; + const SWord32 s2314 = sbv_bv_u32_lshr(s1721, 0x00000003UL); + const SWord32 s2315 = s2313 ^ s2314; + const SWord32 s2316 = sbv_bv_u32_add(s2310, s2315); + const SWord32 s2317 = sbv_bv_u32_add(s1693, s2316); + const SWord32 s2318 = sbv_bv_u32_add(s2304, s2317); + const SWord32 s2319 = sbv_bv_u32_add(s2269, s2318); + const SWord32 s2320 = sbv_bv_u32_rotr(s2319, 6); + const SWord32 s2321 = sbv_bv_u32_rotr(s2319, 11); + const SWord32 s2322 = s2320 ^ s2321; + const SWord32 s2323 = sbv_bv_u32_rotr(s2319, 25); + const SWord32 s2324 = s2322 ^ s2323; + const SWord32 s2325 = sbv_bv_u32_add(s2202, s2324); + const SWord32 s2326 = s2258 & s2319; + const SWord32 s2327 = ~s2319; + const SWord32 s2328 = s2230 & s2327; + const SWord32 s2329 = s2326 ^ s2328; + const SWord32 s2330 = sbv_bv_u32_add(s2325, s2329); + const SWord32 s2332 = sbv_bv_u32_add(s2330, 0xa4506cebUL); + const SWord32 s2333 = sbv_bv_u32_rotr(s2256, 17); + const SWord32 s2334 = sbv_bv_u32_rotr(s2256, 19); + const SWord32 s2335 = s2333 ^ s2334; + const SWord32 s2336 = sbv_bv_u32_lshr(s2256, 0x0000000aUL); + const SWord32 s2337 = s2335 ^ s2336; + const SWord32 s2338 = sbv_bv_u32_add(s2061, s2337); + const SWord32 s2339 = sbv_bv_u32_rotr(s1749, 7); + const SWord32 s2340 = sbv_bv_u32_rotr(s1749, 18); + const SWord32 s2341 = s2339 ^ s2340; + const SWord32 s2342 = sbv_bv_u32_lshr(s1749, 0x00000003UL); + const SWord32 s2343 = s2341 ^ s2342; + const SWord32 s2344 = sbv_bv_u32_add(s2338, s2343); + const SWord32 s2345 = sbv_bv_u32_add(s1721, s2344); + const SWord32 s2346 = sbv_bv_u32_add(s2332, s2345); + const SWord32 s2347 = sbv_bv_u32_add(s2280, s2346); + const SWord32 s2348 = sbv_bv_u32_rotr(s2347, 6); + const SWord32 s2349 = sbv_bv_u32_rotr(s2347, 11); + const SWord32 s2350 = s2348 ^ s2349; + const SWord32 s2351 = sbv_bv_u32_rotr(s2347, 25); + const SWord32 s2352 = s2350 ^ s2351; + const SWord32 s2353 = sbv_bv_u32_add(s2230, s2352); + const SWord32 s2354 = s2319 & s2347; + const SWord32 s2355 = ~s2347; + const SWord32 s2356 = s2258 & s2355; + const SWord32 s2357 = s2354 ^ s2356; + const SWord32 s2358 = sbv_bv_u32_add(s2353, s2357); + const SWord32 s2360 = sbv_bv_u32_add(s2358, 0xbef9a3f7UL); + const SWord32 s2361 = sbv_bv_u32_rotr(s2317, 17); + const SWord32 s2362 = sbv_bv_u32_rotr(s2317, 19); + const SWord32 s2363 = s2361 ^ s2362; + const SWord32 s2364 = sbv_bv_u32_lshr(s2317, 0x0000000aUL); + const SWord32 s2365 = s2363 ^ s2364; + const SWord32 s2366 = sbv_bv_u32_add(s2089, s2365); + const SWord32 s2367 = sbv_bv_u32_rotr(s1777, 7); + const SWord32 s2368 = sbv_bv_u32_rotr(s1777, 18); + const SWord32 s2369 = s2367 ^ s2368; + const SWord32 s2370 = sbv_bv_u32_lshr(s1777, 0x00000003UL); + const SWord32 s2371 = s2369 ^ s2370; + const SWord32 s2372 = sbv_bv_u32_add(s2366, s2371); + const SWord32 s2373 = sbv_bv_u32_add(s1749, s2372); + const SWord32 s2374 = sbv_bv_u32_add(s2360, s2373); + const SWord32 s2375 = sbv_bv_u32_add(s2291, s2374); + const SWord32 s2376 = sbv_bv_u32_rotr(s2375, 6); + const SWord32 s2377 = sbv_bv_u32_rotr(s2375, 11); + const SWord32 s2378 = s2376 ^ s2377; + const SWord32 s2379 = sbv_bv_u32_rotr(s2375, 25); + const SWord32 s2380 = s2378 ^ s2379; + const SWord32 s2381 = sbv_bv_u32_add(s2258, s2380); + const SWord32 s2382 = s2347 & s2375; + const SWord32 s2383 = ~s2375; + const SWord32 s2384 = s2319 & s2383; + const SWord32 s2385 = s2382 ^ s2384; + const SWord32 s2386 = sbv_bv_u32_add(s2381, s2385); + const SWord32 s2388 = sbv_bv_u32_add(s2386, 0xc67178f2UL); + const SWord32 s2389 = sbv_bv_u32_rotr(s2345, 17); + const SWord32 s2390 = sbv_bv_u32_rotr(s2345, 19); + const SWord32 s2391 = s2389 ^ s2390; + const SWord32 s2392 = sbv_bv_u32_lshr(s2345, 0x0000000aUL); + const SWord32 s2393 = s2391 ^ s2392; + const SWord32 s2394 = sbv_bv_u32_add(s2172, s2393); + const SWord32 s2395 = sbv_bv_u32_rotr(s1860, 7); + const SWord32 s2396 = sbv_bv_u32_rotr(s1860, 18); + const SWord32 s2397 = s2395 ^ s2396; + const SWord32 s2398 = sbv_bv_u32_lshr(s1860, 0x00000003UL); + const SWord32 s2399 = s2397 ^ s2398; + const SWord32 s2400 = sbv_bv_u32_add(s2394, s2399); + const SWord32 s2401 = sbv_bv_u32_add(s1777, s2400); + const SWord32 s2402 = sbv_bv_u32_add(s2388, s2401); + const SWord32 s2403 = sbv_bv_u32_rotr(s2291, 2); + const SWord32 s2404 = sbv_bv_u32_rotr(s2291, 13); + const SWord32 s2405 = s2403 ^ s2404; + const SWord32 s2406 = sbv_bv_u32_rotr(s2291, 22); + const SWord32 s2407 = s2405 ^ s2406; + const SWord32 s2408 = s2280 & s2291; + const SWord32 s2409 = s2269 & s2291; + const SWord32 s2410 = s2408 ^ s2409; + const SWord32 s2411 = s2286 ^ s2410; + const SWord32 s2412 = sbv_bv_u32_add(s2407, s2411); + const SWord32 s2413 = sbv_bv_u32_add(s2257, s2412); + const SWord32 s2414 = sbv_bv_u32_rotr(s2413, 2); + const SWord32 s2415 = sbv_bv_u32_rotr(s2413, 13); + const SWord32 s2416 = s2414 ^ s2415; + const SWord32 s2417 = sbv_bv_u32_rotr(s2413, 22); + const SWord32 s2418 = s2416 ^ s2417; + const SWord32 s2419 = s2291 & s2413; + const SWord32 s2420 = s2280 & s2413; + const SWord32 s2421 = s2419 ^ s2420; + const SWord32 s2422 = s2408 ^ s2421; + const SWord32 s2423 = sbv_bv_u32_add(s2418, s2422); + const SWord32 s2424 = sbv_bv_u32_add(s2318, s2423); + const SWord32 s2425 = sbv_bv_u32_rotr(s2424, 2); + const SWord32 s2426 = sbv_bv_u32_rotr(s2424, 13); + const SWord32 s2427 = s2425 ^ s2426; + const SWord32 s2428 = sbv_bv_u32_rotr(s2424, 22); + const SWord32 s2429 = s2427 ^ s2428; + const SWord32 s2430 = s2413 & s2424; + const SWord32 s2431 = s2291 & s2424; + const SWord32 s2432 = s2430 ^ s2431; + const SWord32 s2433 = s2419 ^ s2432; + const SWord32 s2434 = sbv_bv_u32_add(s2429, s2433); + const SWord32 s2435 = sbv_bv_u32_add(s2346, s2434); + const SWord32 s2436 = sbv_bv_u32_rotr(s2435, 2); + const SWord32 s2437 = sbv_bv_u32_rotr(s2435, 13); + const SWord32 s2438 = s2436 ^ s2437; + const SWord32 s2439 = sbv_bv_u32_rotr(s2435, 22); + const SWord32 s2440 = s2438 ^ s2439; + const SWord32 s2441 = s2424 & s2435; + const SWord32 s2442 = s2413 & s2435; + const SWord32 s2443 = s2441 ^ s2442; + const SWord32 s2444 = s2430 ^ s2443; + const SWord32 s2445 = sbv_bv_u32_add(s2440, s2444); + const SWord32 s2446 = sbv_bv_u32_add(s2374, s2445); + const SWord32 s2447 = sbv_bv_u32_rotr(s2446, 2); + const SWord32 s2448 = sbv_bv_u32_rotr(s2446, 13); + const SWord32 s2449 = s2447 ^ s2448; + const SWord32 s2450 = sbv_bv_u32_rotr(s2446, 22); + const SWord32 s2451 = s2449 ^ s2450; + const SWord32 s2452 = s2435 & s2446; + const SWord32 s2453 = s2424 & s2446; + const SWord32 s2454 = s2452 ^ s2453; + const SWord32 s2455 = s2441 ^ s2454; + const SWord32 s2456 = sbv_bv_u32_add(s2451, s2455); + const SWord32 s2457 = sbv_bv_u32_add(s2402, s2456); + const SWord32 s2458 = sbv_bv_u32_add(s98, s2457); + const SWord8 s2459 = sbv_bv_extract_u32_31_24_u8(s2458); + const SWord8 s2460 = sbv_bv_extract_u32_23_16_u8(s2458); + const SWord8 s2461 = sbv_bv_extract_u32_15_8_u8(s2458); + const SWord8 s2462 = sbv_bv_extract_u32_7_0_u8(s2458); + const SWord32 s2463 = sbv_bv_u32_add(s104, s2446); + const SWord8 s2464 = sbv_bv_extract_u32_31_24_u8(s2463); + const SWord8 s2465 = sbv_bv_extract_u32_23_16_u8(s2463); + const SWord8 s2466 = sbv_bv_extract_u32_15_8_u8(s2463); + const SWord8 s2467 = sbv_bv_extract_u32_7_0_u8(s2463); + const SWord32 s2468 = sbv_bv_u32_add(s110, s2435); + const SWord8 s2469 = sbv_bv_extract_u32_31_24_u8(s2468); + const SWord8 s2470 = sbv_bv_extract_u32_23_16_u8(s2468); + const SWord8 s2471 = sbv_bv_extract_u32_15_8_u8(s2468); + const SWord8 s2472 = sbv_bv_extract_u32_7_0_u8(s2468); + const SWord32 s2473 = sbv_bv_u32_add(s116, s2424); + const SWord8 s2474 = sbv_bv_extract_u32_31_24_u8(s2473); + const SWord8 s2475 = sbv_bv_extract_u32_23_16_u8(s2473); + const SWord8 s2476 = sbv_bv_extract_u32_15_8_u8(s2473); + const SWord8 s2477 = sbv_bv_extract_u32_7_0_u8(s2473); + const SWord32 s2478 = sbv_bv_u32_add(s2402, s2413); + const SWord32 s2479 = sbv_bv_u32_add(s101, s2478); + const SWord8 s2480 = sbv_bv_extract_u32_31_24_u8(s2479); + const SWord8 s2481 = sbv_bv_extract_u32_23_16_u8(s2479); + const SWord8 s2482 = sbv_bv_extract_u32_15_8_u8(s2479); + const SWord8 s2483 = sbv_bv_extract_u32_7_0_u8(s2479); + const SWord32 s2484 = sbv_bv_u32_add(s107, s2375); + const SWord8 s2485 = sbv_bv_extract_u32_31_24_u8(s2484); + const SWord8 s2486 = sbv_bv_extract_u32_23_16_u8(s2484); + const SWord8 s2487 = sbv_bv_extract_u32_15_8_u8(s2484); + const SWord8 s2488 = sbv_bv_extract_u32_7_0_u8(s2484); + const SWord32 s2489 = sbv_bv_u32_add(s113, s2347); + const SWord8 s2490 = sbv_bv_extract_u32_31_24_u8(s2489); + const SWord8 s2491 = sbv_bv_extract_u32_23_16_u8(s2489); + const SWord8 s2492 = sbv_bv_extract_u32_15_8_u8(s2489); + const SWord8 s2493 = sbv_bv_extract_u32_7_0_u8(s2489); + const SWord32 s2494 = sbv_bv_u32_add(s119, s2319); + const SWord8 s2495 = sbv_bv_extract_u32_31_24_u8(s2494); + const SWord8 s2496 = sbv_bv_extract_u32_23_16_u8(s2494); + const SWord8 s2497 = sbv_bv_extract_u32_15_8_u8(s2494); + const SWord8 s2498 = sbv_bv_extract_u32_7_0_u8(s2494); + + sbv_output_0[0] = s2459; + sbv_output_0[1] = s2460; + sbv_output_0[2] = s2461; + sbv_output_0[3] = s2462; + sbv_output_0[4] = s2464; + sbv_output_0[5] = s2465; + sbv_output_0[6] = s2466; + sbv_output_0[7] = s2467; + sbv_output_0[8] = s2469; + sbv_output_0[9] = s2470; + sbv_output_0[10] = s2471; + sbv_output_0[11] = s2472; + sbv_output_0[12] = s2474; + sbv_output_0[13] = s2475; + sbv_output_0[14] = s2476; + sbv_output_0[15] = s2477; + sbv_output_0[16] = s2480; + sbv_output_0[17] = s2481; + sbv_output_0[18] = s2482; + sbv_output_0[19] = s2483; + sbv_output_0[20] = s2485; + sbv_output_0[21] = s2486; + sbv_output_0[22] = s2487; + sbv_output_0[23] = s2488; + sbv_output_0[24] = s2490; + sbv_output_0[25] = s2491; + sbv_output_0[26] = s2492; + sbv_output_0[27] = s2493; + sbv_output_0[28] = s2495; + sbv_output_0[29] = s2496; + sbv_output_0[30] = s2497; + sbv_output_0[31] = s2498; } == END: "sha256HashBlock.c" ================== diff --git a/SBVTestSuite/GoldFiles/unint-axioms-empty.gold b/SBVTestSuite/GoldFiles/unint-axioms-empty.gold --- a/SBVTestSuite/GoldFiles/unint-axioms-empty.gold +++ b/SBVTestSuite/GoldFiles/unint-axioms-empty.gold @@ -12,10 +12,8 @@ [GOOD] (declare-sort Thing 0) ; N.B. Uninterpreted sort. [GOOD] ; --- literal constants --- [GOOD] ; --- top level inputs --- -[GOOD] (declare-fun s2 () Thing) ; tracks user variable "__internal_sbv_s2" -[GOOD] (declare-fun s3 () Thing) ; tracks user variable "__internal_sbv_s3" -[GOOD] (declare-fun s5 () Thing) -[GOOD] (declare-fun s6 () Thing) +[GOOD] (declare-fun s2 () Thing) +[GOOD] (declare-fun s3 () Thing) [GOOD] ; --- constant tables --- [GOOD] ; --- non-constant tables --- [GOOD] ; --- uninterpreted constants --- @@ -29,15 +27,14 @@ (let ((l1_s2 (thingMerge l1_s0 l1_s1))) (let ((l1_s3 (distinct l1_s0 l1_s2))) l1_s3)))) -[GOOD] (define-fun s4 () Thing (thingMerge s2 s3)) -[GOOD] (define-fun s7 () Bool (= s5 s6)) -[GOOD] (define-fun s8 () Bool (thingCompare s5 s6)) -[GOOD] (define-fun s9 () Bool (=> s7 s8)) +[GOOD] (define-fun s4 () Bool (= s2 s3)) +[GOOD] (define-fun s5 () Bool (thingCompare s2 s3)) +[GOOD] (define-fun s6 () Bool (=> s4 s5)) [GOOD] ; --- delayedEqualities --- [GOOD] ; --- formula --- [GOOD] (assert s0) [GOOD] (assert s1) -[GOOD] (assert (not s9)) +[GOOD] (assert (not s6)) [SEND] (check-sat) [RECV] unsat *** Solver : Z3 diff --git a/SBVTestSuite/SBVTest.hs b/SBVTestSuite/SBVTest.hs --- a/SBVTestSuite/SBVTest.hs +++ b/SBVTestSuite/SBVTest.hs @@ -19,6 +19,7 @@ import qualified TestSuite.ADT.Expr import qualified TestSuite.ADT.MutRec import qualified TestSuite.ADT.PExpr +import qualified TestSuite.ADT.Registration import qualified TestSuite.Arrays.InitVals import qualified TestSuite.Arrays.Memory import qualified TestSuite.Arrays.Query @@ -64,12 +65,21 @@ import qualified TestSuite.CantTypeCheck.Misc import qualified TestSuite.Char.Char import qualified TestSuite.CodeGeneration.AddSub +import qualified TestSuite.CodeGeneration.ArbitraryBits +import qualified TestSuite.CodeGeneration.ArbitraryFloats +import qualified TestSuite.CodeGeneration.ArrayCaptures +import qualified TestSuite.CodeGeneration.Boundaries import qualified TestSuite.CodeGeneration.CgTests import qualified TestSuite.CodeGeneration.CRC_USB5 +import qualified TestSuite.CodeGeneration.ExactNumbers import qualified TestSuite.CodeGeneration.Fibonacci import qualified TestSuite.CodeGeneration.Floats import qualified TestSuite.CodeGeneration.GCD import qualified TestSuite.CodeGeneration.PopulationCount +import qualified TestSuite.CodeGeneration.LibraryBuild +import qualified TestSuite.CodeGeneration.PseudoBoolean +import qualified TestSuite.CodeGeneration.RegExp +import qualified TestSuite.CodeGeneration.ScalarSafety import qualified TestSuite.CodeGeneration.Uninterpreted import qualified TestSuite.CRC.CCITT import qualified TestSuite.CRC.CCITT_Unidir @@ -116,6 +126,7 @@ import qualified TestSuite.Queries.Int_Z3 import qualified TestSuite.Queries.Interpolants import qualified TestSuite.Queries.Lists +import qualified TestSuite.Queries.Registration import qualified TestSuite.Queries.Strings import qualified TestSuite.Queries.Sums import qualified TestSuite.Queries.Tables @@ -142,6 +153,7 @@ , TestSuite.ADT.Expr.tests , TestSuite.ADT.MutRec.tests , TestSuite.ADT.PExpr.tests + , TestSuite.ADT.Registration.tests , TestSuite.Arrays.InitVals.tests , TestSuite.Arrays.Memory.tests , TestSuite.Arrays.Query.tests @@ -189,12 +201,21 @@ , TestSuite.CantTypeCheck.Misc.tests , TestSuite.Char.Char.tests , TestSuite.CodeGeneration.AddSub.tests + , TestSuite.CodeGeneration.ArbitraryBits.tests + , TestSuite.CodeGeneration.ArbitraryFloats.tests + , TestSuite.CodeGeneration.ArrayCaptures.tests + , TestSuite.CodeGeneration.Boundaries.tests , TestSuite.CodeGeneration.CgTests.tests , TestSuite.CodeGeneration.CRC_USB5.tests + , TestSuite.CodeGeneration.ExactNumbers.tests , TestSuite.CodeGeneration.Fibonacci.tests , TestSuite.CodeGeneration.Floats.tests , TestSuite.CodeGeneration.GCD.tests , TestSuite.CodeGeneration.PopulationCount.tests + , TestSuite.CodeGeneration.LibraryBuild.tests + , TestSuite.CodeGeneration.PseudoBoolean.tests + , TestSuite.CodeGeneration.RegExp.tests + , TestSuite.CodeGeneration.ScalarSafety.tests , TestSuite.CodeGeneration.Uninterpreted.tests , TestSuite.CRC.CCITT.tests , TestSuite.CRC.CCITT_Unidir.tests @@ -241,6 +262,7 @@ , TestSuite.Queries.Int_Mathsat.tests , TestSuite.Queries.Int_Yices.tests , TestSuite.Queries.Lists.tests + , TestSuite.Queries.Registration.tests , TestSuite.Queries.Strings.tests , TestSuite.Queries.Sums.tests , TestSuite.Queries.Tables.tests diff --git a/SBVTestSuite/TestSuite/ADT/Registration.hs b/SBVTestSuite/TestSuite/ADT/Registration.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/ADT/Registration.hs @@ -0,0 +1,124 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.ADT.Registration +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Registration of ADT dependencies without incidental uses of their fields. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.ADT.Registration (tests) where + +import Data.Proxy (Proxy(..)) +import Control.DeepSeq (force) +import Control.Exception (evaluate) +import Control.Monad (void) +import Data.SBV.Control +import Test.Tasty.HUnit (assertEqual) +import Utils.SBVTestFramework + +-- | A parameterized leaf whose definition must be discovered from its uses. +newtype RegistrationLeaf a = RegistrationLeaf a deriving (Eq, Ord, Show) + +-- | An ADT reference underneath a tuple field. +newtype RegistrationTuple = RegistrationTuple (RegistrationLeaf Word8, Word8) deriving Show + +-- | An ADT reference underneath a list field. +newtype RegistrationList = RegistrationList [RegistrationLeaf Word8] deriving Show + +-- | An ADT reference underneath a set field. +newtype RegistrationSet = RegistrationSet (RCSet (RegistrationLeaf Word8)) deriving Show + +-- | An ADT reference in an array's index type. +newtype RegistrationKey = RegistrationKey (ArrayModel (RegistrationLeaf Word8) Word8) deriving Show + +-- | An ADT reference in an array's element type. +newtype RegistrationValue = RegistrationValue (ArrayModel Word8 (RegistrationLeaf Word8)) deriving Show + +-- | A synonym must not hide dependencies from the registration traversal. +type RegistrationAlias = ([RegistrationLeaf Word8], Word8) + +-- | A field whose container structure is supplied by a type synonym. +newtype RegistrationSynonym = RegistrationSynonym RegistrationAlias deriving Show + +-- | Type arguments may themselves contain ADT references behind containers. +newtype RegistrationParameter a = RegistrationParameter (Maybe ([RegistrationLeaf a], a)) deriving Show + +-- | Discover dependencies of an ADT that is itself only referenced by name. +newtype RegistrationChain = RegistrationChain RegistrationTuple deriving Show + +-- | The root of a mutually recursive group, with a nested reference to its peer. +data RegistrationEven = RegistrationEnd | RegistrationEven (RegistrationOdd, Word8) deriving Show + +-- | The return edge of the mutually recursive group. +newtype RegistrationOdd = RegistrationOdd RegistrationEven deriving Show + +-- | Recursion through a type argument must not make retained metadata cyclic. +data RegistrationParamCycle = RegistrationParamEnd + | RegistrationParamNext (RegistrationParamLink RegistrationParamCycle) + deriving Show + +-- | A parameter carrying the return edge of a recursive dependency. +newtype RegistrationParamLink a = RegistrationParamLink a deriving Show + +-- | Generate all schemas without registering any symbolic values in advance. +mkSymbolic [''RegistrationLeaf, ''RegistrationTuple, ''RegistrationList, ''RegistrationSet, ''RegistrationKey, ''RegistrationValue, ''RegistrationSynonym, ''RegistrationParameter, ''RegistrationChain, ''RegistrationEven, ''RegistrationOdd, ''RegistrationParamCycle, ''RegistrationParamLink] + +-- | Each fresh solver session uses only its root type, through either a literal +-- or a fresh variable. Field selectors and extra inner-type inputs must not mask +-- missing schemas. +tests :: TestTree +tests = testGroup "ADT.Registration" $ + [ testCase "literal-only symbolic constraint" $ do + result <- runSMT $ do + constrain (uninterpret "observeRegistrationEnd" (literal RegistrationEnd) :: SBool) + query checkSat + assertEqual "A leaf literal must register its unused recursive partner" Sat result + , testCase "literal-only query constraint" $ do + result <- runSMT $ query $ do + constrain (uninterpret "observeRegistrationEnd" (literal RegistrationEnd) :: SBool) + checkSat + assertEqual "A query literal must register its unused recursive partner" Sat result + , testCase "finite parameter-mediated recursive metadata" $ do + let leaf = literal RegistrationParamEnd + void $ evaluate (force (kindOf leaf)) + result <- runSMT $ do + constrain (uninterpret "observeRegistrationParamEnd" leaf :: SBool) + query checkSat + assertEqual "Recursive type arguments must retain a finite declaration registry" Sat result + ] ++ [ testGroup phase + [ check interactive "tuple" (Proxy @RegistrationTuple) + , check interactive "list" (Proxy @RegistrationList) + , check interactive "set" (Proxy @RegistrationSet) + , check interactive "array key" (Proxy @RegistrationKey) + , check interactive "array value" (Proxy @RegistrationValue) + , check interactive "type synonym" (Proxy @RegistrationSynonym) + , check interactive "parameter" (Proxy @(RegistrationParameter Word8)) + , check interactive "transitive" (Proxy @RegistrationChain) + , check interactive "mutual root" (Proxy @RegistrationEven) + , check interactive "mutual peer" (Proxy @RegistrationOdd) + ] + | (phase, interactive) <- [("symbolic", Nothing), ("query named", Just False), ("query unnamed", Just True)] + ] + where check :: forall a. SymVal a => Maybe Bool -> String -> Proxy a -> TestTree + check interactive testName _ = testCase testName $ do + result <- runSMT $ case interactive of + Just anonymous -> query $ do left <- if anonymous then freshVar_ @a else freshVar @a "left" + right <- if anonymous then freshVar_ @a else freshVar @a "right" + constrain (left ./= right) + checkSat + Nothing -> do left <- free "left" :: Symbolic (SBV a) + right <- free "right" :: Symbolic (SBV a) + constrain (left ./= right) + query checkSat + assertEqual "Distinct root values must be satisfiable without explicit subfield registration" Sat result diff --git a/SBVTestSuite/TestSuite/Basics/ArbFloats.hs b/SBVTestSuite/TestSuite/Basics/ArbFloats.hs --- a/SBVTestSuite/TestSuite/Basics/ArbFloats.hs +++ b/SBVTestSuite/TestSuite/Basics/ArbFloats.hs @@ -17,14 +17,23 @@ module TestSuite.Basics.ArbFloats(tests) where import Utils.SBVTestFramework +import Test.Tasty.HUnit (assertEqual) +import Control.Monad (forM, forM_) +import Data.SBV.Control --- # of inhabitants is 2^sb(2^eb - 1) + 3 +-- | Number of inhabitants: @2^sb(2^eb - 1) + 3@. count :: Integer -> Integer -> Integer count eb sb = 2^sb * (2^eb - 1) + 3 +-- | Concrete and symbolic arbitrary-format floating-point checks. tests :: TestTree tests = testGroup "Basics.ArbFloats" - [ testCase "FP_2_2" (assert $ (== fromIntegral (count 2 2)) <$> numberOfModels (const sTrue :: SFloatingPoint 2 2 -> SBool)) + [ testCase "integral conversion rounding" integralConversionRounding + , testCase "integral conversion format widths" integralConversionWidths + , testCase "symbolic integral conversion rounding" symbolicIntegralConversionRounding + , testCase "native integral conversion rounding" nativeIntegralConversionRounding + , testCase "native integral conversion solver agreement" nativeIntegralConversionAgreement + , testCase "FP_2_2" (assert $ (== fromIntegral (count 2 2)) <$> numberOfModels (const sTrue :: SFloatingPoint 2 2 -> SBool)) , testCase "FP_2_3" (assert $ (== fromIntegral (count 2 3)) <$> numberOfModels (const sTrue :: SFloatingPoint 2 3 -> SBool)) , testCase "FP_2_4" (assert $ (== fromIntegral (count 2 4)) <$> numberOfModels (const sTrue :: SFloatingPoint 2 4 -> SBool)) @@ -38,3 +47,128 @@ , goldenVsStringShow "arbFp_opt_1" (optimize Lexicographic $ \x -> do {constrain (fpIsPoint x); maximize "x" (x::SFPHalf)}) ] + +-- | Integer literals must fold in the requested direction, including both +-- tie parities and overflow. Expectations use exactly representable values. +integralConversionRounding :: Assertion +integralConversionRounding = do + mapM_ check + [ (0, [0, 0, 0, 0, 0]) + , (2049, [2048, 2050, 2050, 2048, 2048]) + , (2051, [2052, 2052, 2052, 2050, 2050]) + , (-2049, [-2048, -2050, -2048, -2050, -2048]) + , (-2051, [-2052, -2052, -2050, -2052, -2050]) + , (65536, [halfInfinity, halfInfinity, halfInfinity, 65504, 65504]) + , (-65536, [-halfInfinity, -halfInfinity, -65504, -halfInfinity, -65504]) + , (2 ^ (200 :: Int), [halfInfinity, halfInfinity, halfInfinity, 65504, 65504]) + ] + mapM_ (\(mode, signed, unsigned) -> do + assertEqual (show mode ++ ": signed native source") (Just signed) + (unliteral (toSFloatingPoint (literal mode) (literal (-2049 :: Int16))) :: Maybe FPHalf) + assertEqual (show mode ++ ": unsigned native source") (Just unsigned) + (unliteral (toSFloatingPoint (literal mode) (literal (2049 :: Word16))) :: Maybe FPHalf)) + (zip3 modes [-2048, -2050, -2048, -2050, -2048] [2048, 2050, 2050, 2048, 2048]) + where modes = [RoundNearestTiesToEven, RoundNearestTiesToAway, RoundTowardPositive, RoundTowardNegative, RoundTowardZero] + halfInfinity = 1 / 0 :: FPHalf + + check (sample, expected) = mapM_ (\(mode, value) -> + assertEqual (show (sample, mode) ++ ": integer source") (Just value) + (unliteral (toSFloatingPoint (literal mode) (literal sample :: SInteger)))) + (zip modes expected) + +-- | Conversion must use the target format, not a binary64 intermediate. +-- Check a tiny nonstandard format and integer information beyond double's +-- precision, including a halfway value beyond quadruple's precision. +integralConversionWidths :: Assertion +integralConversionWidths = do + assertEqual "tiny upward tie" (Just 10) + (unliteral (toSFloatingPoint sRTP (9 :: SInteger)) :: Maybe (FloatingPoint 4 3)) + assertEqual "tiny downward negative tie" (Just (-10)) + (unliteral (toSFloatingPoint sRTN (-9 :: SInteger)) :: Maybe (FloatingPoint 4 3)) + let large = 2 ^ (100 :: Int) + 1 + tie = 2 ^ (113 :: Int) + 1 + assertEqual "retain integer bits beyond binary64" (Just (fromInteger large)) + (unliteral (toSFloatingPoint sRNE (literal large :: SInteger)) :: Maybe FPQuad) + assertEqual "quadruple upward tie" (Just (fromInteger (tie + 1))) + (unliteral (toSFloatingPoint sRTP (literal tie :: SInteger)) :: Maybe FPQuad) + +-- | Symbolic operands must still reach the solver; a symbolic rounding mode +-- must not be ignored merely because the integer operand is concrete. +symbolicIntegralConversionRounding :: Assertion +symbolicIntegralConversionRounding = do + assertIsThm $ \mode -> (toSFloatingPoint mode (2049 :: SInteger) :: SFPHalf) + .== ite (mode .== sRNA .|| mode .== sRTP) 2050 2048 + assertIsThm $ \(value :: SInt16) -> value .== -2049 + .=> (toSFloatingPoint sRTN value :: SFPHalf) .== -2050 + +-- | Check both native target formats at ties of either parity, with both +-- signs and directed overflow. All expectations are exactly representable. +nativeIntegralConversionRounding :: Assertion +nativeIntegralConversionRounding = do + check (toSFloat, 24, 128) + check (toSDouble, 53, 1024) + source (literal (-127) :: SInt8) + source (literal (-32767) :: SInt16) + source (literal (-16777217) :: SInt32) + source (literal (-9007199254740993) :: SInt64) + source (literal 255 :: SWord8) + source (literal 65535 :: SWord16) + source (literal 16777217 :: SWord32) + source (literal 9007199254740993 :: SWord64) + where check :: (RealFloat a, SymVal a, Show a) => (SRoundingMode -> SInteger -> SBV a, Int, Int) -> Assertion + check (convert, precision, exponentLimit) = do + let base = 2 ^ precision :: Integer + number = fromInteger + nativeInfinity = 1 / 0 + largest = number ((2 ^ precision - 1) * 2 ^ (exponentLimit - precision)) + cases = [ (0, [0, 0, 0, 0, 0]) + , (base + 1, map number [base, base + 2, base + 2, base, base]) + , (base + 3, map number [base + 4, base + 4, base + 4, base + 2, base + 2]) + , (negate (base + 1), map (negate . number) [base, base + 2, base, base + 2, base]) + , (negate (base + 3), map (negate . number) [base + 4, base + 4, base + 2, base + 4, base + 2]) + , (2 ^ exponentLimit, [nativeInfinity, nativeInfinity, nativeInfinity, largest, largest]) + , (negate (2 ^ exponentLimit), [-nativeInfinity, -nativeInfinity, -largest, -nativeInfinity, -largest]) + , (2 ^ (exponentLimit + 200), [nativeInfinity, nativeInfinity, nativeInfinity, largest, largest]) + ] + forM_ cases $ \(sample, expected) -> + forM_ (zip [minBound .. maxBound] expected) $ \(mode, value) -> + assertEqual (show (precision, sample, mode)) (Just value) (unliteral (convert (literal mode) (literal sample))) + forM_ [sRNE, sRNA, sRTP, sRTN, sRTZ] $ \mode -> + assertEqual "Integer zero stays positive" (Just False) (isNegativeZero <$> unliteral (convert mode 0)) + + source :: (Integral a, IEEEFloatConvertible a) => SBV a -> Assertion + source value = forM_ [minBound .. maxBound] $ \mode -> do + let integer = literal (maybe (error "Expected a literal source") toInteger (unliteral value)) :: SInteger + rm = literal mode + assertEqual "Native source to Float" (unliteral (toSFloat rm integer)) (unliteral (toSFloat rm value)) + assertEqual "Native source to Double" (unliteral (toSDouble rm integer)) (unliteral (toSDouble rm value)) + +-- | Compare native folding with solver casts, keeping both the integer and +-- rounding mode symbolic. Include near-ties that exceed binary64 precision +-- to detect accidental rounding through Double on the way to Float. +nativeIntegralConversionAgreement :: Assertion +nativeIntegralConversionAgreement = do + observations <- runSMT $ do + input <- sInteger "input" + mode <- free "mode" + query $ forM [(n, rm) | n <- samples, rm <- [minBound .. maxBound]] $ \(n, rm) -> inNewAssertionStack $ do + constrain (input .== literal n) + constrain (mode .== literal rm) + status <- checkSat + case status of + Sat -> do f <- getValue (toSFloat mode input) + d <- getValue (toSDouble mode input) + pure (n, rm, status, Just f, Just d) + _ -> pure (n, rm, status, Nothing, Nothing) + forM_ observations $ \(n, rm, status, f, d) -> do + assertEqual "Concrete input and rounding mode are satisfiable" Sat status + assertEqual (show (n, rm) ++ ": Float") f (unliteral (toSFloat (literal rm) (literal n :: SInteger))) + assertEqual (show (n, rm) ++ ": Double") d (unliteral (toSDouble (literal rm) (literal n :: SInteger))) + assertIsThm $ \mode -> toSFloat mode (16777217 :: SInteger) + .== ite (mode .== sRNA .|| mode .== sRTP) 16777218 16777216 + assertIsThm $ \mode -> toSDouble mode (-9007199254740993 :: SInteger) + .== ite (mode .== sRNA .|| mode .== sRTN) (-9007199254740994) (-9007199254740992) + where samples = 0 : [sign * n | sign <- [1, -1], n <- [2 ^ (24 :: Int) + 1, 2 ^ (24 :: Int) + 3, + 2 ^ (53 :: Int) + 1, 2 ^ (53 :: Int) + 3, + 2 ^ (54 :: Int) + 2 ^ (30 :: Int) + 1, + 2 ^ (128 :: Int), 2 ^ (1024 :: Int)]] diff --git a/SBVTestSuite/TestSuite/Basics/String.hs b/SBVTestSuite/TestSuite/Basics/String.hs --- a/SBVTestSuite/TestSuite/Basics/String.hs +++ b/SBVTestSuite/TestSuite/Basics/String.hs @@ -26,8 +26,10 @@ import qualified Data.SBV.Char as SC import qualified Data.SBV.RegExp as R -import Control.Monad (unless) -import Data.List (sort) +import Control.Monad (forM, forM_, replicateM, unless, void) +import Control.Exception (ErrorCall, displayException, evaluate, try) +import Data.List (isInfixOf, nub, sort) +import Test.Tasty.HUnit (assertBool, assertEqual) import qualified Data.Map.Strict as M @@ -55,7 +57,109 @@ , goldenCapturedIO "strExamples12" $ \rf -> checkWith z3{redirectVerbose=Just rf} strExamples12 Unsat , goldenCapturedIO "strExamples13" $ \rf -> checkWith z3{redirectVerbose=Just rf} strExamples13 Unsat , testCase "strExamples14" $ assert strExamples14 + , testGroup "literal regex semantics" + [testCase (show sample P.++ " against " P.++ show regex) + (assertEqual "Literal regex membership" (Just expected) (unliteral (literal sample `R.match` regex))) + | (sample, regex, expected) <- regexLiteralCases] + , testCase "regex literal and solver agreement" regexLiteralAgreement + , testCase "invalid regex repetition bounds" regexInvalidBounds ] + +-- | Regressions for continuation handling: universal matching must not +-- discard a suffix, and Boolean operations must inspect the same prefix. +-- Include nullable repetition, empty inputs, Unicode, and embedded NULs. +regexLiteralCases :: [(String, R.RegExp, Bool)] +regexLiteralCases = + [ ("", R.Conc [], True) + , ("a", R.Conc [], False) + , ("a", R.Conc [R.Conc [], "a", R.Conc []], True) + , ("", R.Loop 0 0 "a", True) + , ("a", R.Loop 0 0 "a", False) + , ("", R.Power 0 "a", True) + , ("aa", R.Loop 2 2 "a", True) + , ("a", R.Conc [R.All, "b"], False) + , ("ab", R.Conc [R.All, "b"], True) + , ("b", R.Conc [R.All, "b"], True) + , ("", R.Conc [R.All, "b"], False) + , ("", R.All, True) + , ("a", R.Conc [R.Comp "a", "b"], False) + , ("b", R.Conc [R.Comp "a", "b"], True) + , ("ab", R.Conc [R.Comp "a", "b"], False) + , ("aab", R.Conc [R.Comp "a", "b"], True) + , ("ab", R.Conc [R.Diff "ab" "a", R.Opt "b"], True) + , ("ab", R.Conc [R.Diff "a" "ab", R.Opt "b"], True) + , ("ab", R.Conc [R.Inter "a" "ab", R.All], False) + , ("ab", R.Conc [R.Inter "a" (R.Opt "a"), "b"], True) + , ("a", R.Conc [R.Diff R.All "", "a"], False) + , ("ba", R.Conc [R.Diff R.All "", "a"], True) + , ("", R.KStar (R.Opt "a"), True) + , ("aaa", R.KStar (R.Inter (R.Opt "a") (R.Comp "b")), True) + , ("b", R.KStar (R.Inter (R.Opt "a") (R.Comp "b")), False) + , ("a", R.KStar (R.Conc [R.All, "b"]), False) + , ("b", R.Conc [R.Loop 0 2 (R.Opt "a"), "b"], True) + , ("aab", R.Conc [R.Power 2 (R.Diff "a" "b"), "b"], True) + , ("a\0", R.Conc [R.Comp "b", "\0"], True) + , ("\0a", R.Conc [R.All, "\0"], False) + , ("\955b", R.Conc [R.Inter R.All (R.Comp "a"), "b"], True) + , ("\955a", R.Conc [R.All, "b"], False) + ] + +-- | Compare folding with actual solver evaluation over a bounded matrix of +-- regexes and strings. Keep the solver input symbolic and constrain its value +-- so the reference path cannot silently reuse literal constant folding. +regexLiteralAgreement :: Assertion +regexLiteralAgreement = do + observations <- runSMT $ do + input <- sString "input" + query $ forM samples $ \sample -> inNewAssertionStack $ do + constrain (input .== literal sample) + status <- checkSat + actual <- case status of + Sat -> getValue (S.implode [input `R.match` regex | regex <- regexes]) + _ -> pure [] + pure (sample, status, actual) + forM_ observations $ \(sample, status, actual) -> do + assertEqual "A concrete string assignment must be satisfiable" Sat status + assertEqual "One result per regex" (length regexes) (length actual) + forM_ (zip regexes actual) $ \(regex, expected) -> + assertEqual ("Literal/solver disagreement for " P.++ show sample P.++ " against " P.++ show regex) + (Just expected) (unliteral (literal sample `R.match` regex)) + where atoms = [R.All, R.None, R.Conc [], "", "a", "ab"] + unary = [op regex | op <- [R.Comp, R.KStar, R.KPlus, R.Opt, R.Loop 0 2], regex <- atoms] + binary = [op left right | op <- [R.Inter, R.Diff, \a b -> R.Union [a, b]], left <- atoms, right <- atoms] + base = atoms P.++ unary P.++ binary + regexes = nub $ [regex | (_, regex, _) <- regexLiteralCases] + P.++ [wrapped | regex <- base, wrapped <- [regex, R.Conc [regex, "b"], R.Conc ["a", regex]]] + samples = nub $ concatMap (`replicateM` "ab") [0 .. 3] P.++ [sample | (sample, _, _) <- regexLiteralCases] + +-- | Invalid bounds must fail on both literal and symbolic inputs, even when +-- matching could skip the offending branch. The printer uses the same check. +regexInvalidBounds :: Assertion +regexInvalidBounds = forM_ invalid $ \(regex, diagnostic) -> + forM_ wrappers $ \wrap -> do + let r = wrap regex + forM_ ["", "aa"] $ \sample -> + rejects diagnostic $ void $ evaluate (unliteral ((literal sample :: SString) `R.match` r)) + rejects diagnostic $ void $ evaluate (length (show r)) + rejects diagnostic $ runSMT $ do + input <- sString "input" + constrain (input `R.match` r) + -- Language equality bypasses match and exercises SMT serialization itself. + rejects diagnostic $ void $ sat (r .== R.All) + where invalid = [ (R.Loop 2 1 "a", "Loop with arguments: (2,1)") + , (R.Loop (-1) 2 "a", "Loop with arguments: (-1,2)") + , (R.Loop 0 (-1) "a", "Loop with arguments: (0,-1)") + , (R.Power (-1) "a", "Power with arguments: -1") + ] + wrappers = [id, \r -> R.Union [R.All, r], \r -> R.Conc [R.None, r], + R.KStar, R.KPlus, R.Opt, R.Comp, R.Loop 0 0, R.Power 0, + R.Inter R.None, R.Diff R.None] + + rejects diagnostic action = do + result <- try action :: IO (Either ErrorCall ()) + case result of + Left err -> assertBool ("Expected diagnostic: " P.++ diagnostic) (diagnostic `isInfixOf` displayException err) + Right () -> assertFailure ("Accepted invalid regex: " P.++ diagnostic) checkWith :: SMTConfig -> Symbolic () -> CheckSatResult -> IO () checkWith cfg props csExpected = runSMTWith cfg{verbose=True} $ do diff --git a/SBVTestSuite/TestSuite/Basics/UISat.hs b/SBVTestSuite/TestSuite/Basics/UISat.hs --- a/SBVTestSuite/TestSuite/Basics/UISat.hs +++ b/SBVTestSuite/TestSuite/Basics/UISat.hs @@ -9,12 +9,17 @@ -- Testing UI function sat examples ----------------------------------------------------------------------------- +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} + {-# OPTIONS_GHC -Wall -Werror #-} module TestSuite.Basics.UISat(tests) where import Utils.SBVTestFramework +import Data.SBV.Control + -- Test suite tests :: TestTree tests = @@ -22,6 +27,36 @@ goldenCapturedIO "uiSat_test1" $ \rf -> checkWith rf test1 , goldenCapturedIO "uiSat_test2" $ \rf -> checkWith rf test2 , goldenCapturedIO "uiSat_test3" $ \rf -> checkWith rf test3 + , testCase "register_float_nan" $ assertIsSat $ do + let f = uninterpret "nanFloat" :: SInteger -> SFloat + constrain $ \(Forall x) -> fpIsNaN (f x) + registerFunction f + pure sTrue + , testCase "register_double_nan" $ assertIsSat $ do + let f = uninterpret "nanDouble" :: SInteger -> SDouble + constrain $ \(Forall x) -> fpIsNaN (f x) + registerFunction f + pure sTrue + , testCase "register_sized_float_nan" $ assertIsSat $ do + let f = uninterpret "nanHalf" :: SInteger -> SFPHalf + constrain $ \(Forall x) -> fpIsNaN (f x) + registerFunction f + pure sTrue + , testCase "register_defined_nan" $ assertIsSat $ do + let f = smtFunction "definedNaN" $ \(_ :: SInteger) -> (sNaN :: SFloat) + registerFunction f + pure sTrue + , testCase "register_nan_literal" $ assertIsSat $ do + registerFunction (sNaN :: SFloat) + pure sTrue + , testCase "register_unused_binary_function_model" $ do + result <- runSMT $ do + registerFunction q2 + query $ do ensureSat + getFunction q2 + case result of + Right{} -> pure () + Left{} -> assertFailure "Expected a binary Boolean function interpretation" ] cfg :: FilePath -> SMTConfig diff --git a/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryBits.hs b/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryBits.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryBits.hs @@ -0,0 +1,450 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.ArbitraryBits +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Compile-and-run tests for C lowering of arbitrary-width bit-vectors. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.ArbitraryBits (tests) where + +import Data.List (isInfixOf) +import Data.Proxy (Proxy(..)) +import Numeric (showHex) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Internals +import Data.SBV.Tools.Overflow + +import Utils.SBVTestFramework hiding ((#), bvExtract) + +-- | Arbitrary-width C backend tests. +tests :: TestTree +tests = testGroup "CodeGeneration.ArbitraryBits" + [ testCase "compile and execute 673-bit arithmetic" wide673 + , testCase "compile and execute signed 673-bit arithmetic" signed673 + , testCase "compile and execute non-aligned join/extract" joinExtract + , testCase "compile and execute unsigned overflow predicates" unsignedOverflow + , testCase "compile and execute signed overflow predicates" signedOverflow + , testCase "compile and execute native overflow predicates" nativeOverflow + , testCase "compile and execute one-bit overflow predicates" oneBitOverflow + , testCase "compile and execute exact native bit operations" nativeBitOperations + , testCase "compile and execute exact native arithmetic" nativeArithmetic + , testCase "convert mapped integers and arbitrary-width bit-vectors" mappedIntegerBitVectorCasts + , testCase "compile and execute checked wide table lookup" wideLookup + , testCase "compile and execute wide array keys and values" wideArray + , testCase "compile and execute a wide callback-backed array" wideArrayInput + , testCase "compile and execute a wide structured lambda array" wideLambdaArray + , testCase "compile and execute a wide structured lambda table" wideLambdaTable + , testCase "compile and execute arithmetic boundary cases" arithmeticBoundaries + ] + +-- | Mapped integers sign-extend from their selected representation and reduce +-- incoming bit-vectors modulo that width. One-bit targets must retain bit 0, +-- not C's nonzero-to-Boolean interpretation. +mappedIntegerBitVectorCasts :: Assertion +mappedIntegerBitVectorCasts = mapM_ check [(width, sample) | width <- [8, 16, 32, 64], sample <- [-2, negate (2 ^ (width - 1)), 2 ^ (width - 1) - 1]] + where check (width, sample) = withSystemTempDirectory "sbv-mapped-integer-bit-vectors" $ \dir -> do + let signedSample = negate (2 ^ (670 :: Int)) - 129 + unsignedSample = 2 ^ (672 :: Int) + 131 + program = do + cgOverwriteFiles True + cgIntegerSize width + cgSetDriverValues [sample, signedSample, unsignedSample, 2 ^ (64 :: Int) - 1, -3] + value <- cgInput "value" :: SBVCodeGen SInteger + signed <- cgInput "signedValue" :: SBVCodeGen (SInt 673) + unsigned <- cgInput "unsignedValue" :: SBVCodeGen (SWord 673) + native <- cgInput "native" :: SBVCodeGen SWord64 + small <- cgInput "small" :: SBVCodeGen SInt8 + cgReturn $ sAnd + [ (sFromIntegral value :: SWord 1) .== fromInteger sample + , (sFromIntegral value :: SInt 7) .== fromInteger sample + , (sFromIntegral value :: SWord 9) .== fromInteger sample + , (sFromIntegral value :: SInt 65) .== fromInteger sample + , (sFromIntegral value :: SWord 673) .== fromInteger sample + , (sFromIntegral value :: SInt64) .== fromInteger sample + , (sFromIntegral signed :: SInteger) .== fromInteger signedSample + , (sFromIntegral unsigned :: SInteger) .== fromInteger unsignedSample + , (sFromIntegral native :: SInteger) .== -1 + , (sFromIntegral small :: SInteger) .== -3 + ] + compileAndRun dir "mappedIntegerBitVectors" program ") = 1" + +-- | Exercise unsigned 673-bit arithmetic, shifts, rotation, and division. +wide673 :: Assertion +wide673 = withSystemTempDirectory "sbv-wide673" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [x, y] + a <- cgInput "a" :: SBVCodeGen (SWord 673) + b <- cgInput "b" :: SBVCodeGen (SWord 673) + let symbolicResult = rotateL (((a + b) * (a - b)) `xor` shiftR a 67) 193 + cgReturn (symbolicResult `sQuot` (b + 1)) + compileAndRun dir "wide673" program (asHex 11 result) + where w = 673 + modulus = 2 ^ w + mask = modulus - 1 + x = 2 ^ (672 :: Int) + 9 + y = 17 + add a b = (a + b) .&. mask + sub a b = (a - b) .&. mask + mul a b = (a * b) .&. mask + shr a n = a `shiftR` n + rotl a n = let r = n `mod` w in ((a `shiftLInteger` r) .|. (a `shiftR` (w - r))) .&. mask + expectedZ = rotl (mul (add x y) (sub x y) `xor` shr x 67) 193 + result = expectedZ `quot` add y 1 + shiftLInteger a n = a * (2 ^ n) + +-- | Exercise signed 673-bit ordering, quotient, remainder, and arithmetic shift. +signed673 :: Assertion +signed673 = withSystemTempDirectory "sbv-signed673" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [x, y] + a <- cgInput "a" :: SBVCodeGen (SInt 673) + b <- cgInput "b" :: SBVCodeGen (SInt 673) + let q = a `sQuot` b + r = a `sRem` b + cgReturn $ ite (a .< b) (q + r) (shiftR a 130) + compileAndRun dir "signed673" program (asHex 11 expectedRaw) + where modulus = 2 ^ (673 :: Int) + x = negate (2 ^ (671 :: Int)) + 12345 + y = -17 + expectedRaw = ((x `quot` y) + (x `rem` y)) `mod` modulus + +-- | Exercise non-aligned concatenation and extraction across limb boundaries. +joinExtract :: Assertion +joinExtract = withSystemTempDirectory "sbv-join-extract" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [hi, lo] + a <- cgInput "high" :: SBVCodeGen (SWord 337) + b <- cgInput "low" :: SBVCodeGen (SWord 336) + let joined = a # b :: SWord 673 + cgReturn (bvExtract (Proxy @511) (Proxy @128) joined :: SWord 384) + compileAndRun dir "joinExtract" program (asHex 6 expected) + where hi = 2 ^ (336 :: Int) + 0x123456789abcdef + lo = 2 ^ (335 :: Int) + 0xfedcba987654321 + expectedJoined = hi * 2 ^ (336 :: Int) + lo + expected = (expectedJoined `shiftR` 128) .&. (2 ^ (384 :: Int) - 1) + +-- | Exercise unsigned overflow and underflow predicates at a non-native width. +unsignedOverflow :: Assertion +unsignedOverflow = withSystemTempDirectory "sbv-unsigned-overflow" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2 ^ (65 :: Int) - 1, 2] + a <- cgInput "a" :: SBVCodeGen (SWord 65) + b <- cgInput "b" :: SBVCodeGen (SWord 65) + cgReturn $ pack [bvAddO a b, bvSubO 0 b, bvMulO a b, bvMulO b 3] + compileAndRun dir "unsignedOverflow" program (asHex 2 7) + where pack :: [SBool] -> SWord 65 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8]) + +-- | Exercise signed overflow predicates, including both signed extrema. +signedOverflow :: Assertion +signedOverflow = withSystemTempDirectory "sbv-signed-overflow" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2 ^ (64 :: Int) - 1, 1] + a <- cgInput "a" :: SBVCodeGen (SInt 65) + b <- cgInput "b" :: SBVCodeGen (SInt 65) + let minValue = fromInteger (negate (2 ^ (64 :: Int))) :: SInt 65 + cgReturn $ pack [bvAddO a b, bvSubO minValue b, bvMulO a (b + b), bvDivO minValue (negate b), bvNegO minValue, bvMulO a b] + compileAndRun dir "signedOverflow" program (asHex 2 31) + where pack :: [SBool] -> SWord 65 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32]) + +-- | Exercise every unsigned and signed overflow predicate at native C widths, +-- including promotion-sensitive 8-bit and undefined-in-C 64-bit boundaries. +nativeOverflow :: Assertion +nativeOverflow = withSystemTempDirectory "sbv-native-overflow" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [maxWord, 2, maxInt, 1, minInt, minInt8] + unsignedMax <- cgInput "unsignedMax" :: SBVCodeGen SWord64 + unsignedTwo <- cgInput "unsignedTwo" :: SBVCodeGen SWord64 + signedMax <- cgInput "signedMax" :: SBVCodeGen SInt64 + signedOne <- cgInput "signedOne" :: SBVCodeGen SInt64 + signedMin <- cgInput "signedMin" :: SBVCodeGen SInt64 + signedMin8 <- cgInput "signedMin8" :: SBVCodeGen SInt8 + let flags = [ bvAddO unsignedMax unsignedTwo + , bvSubO 0 unsignedTwo + , bvMulO unsignedMax unsignedTwo + , bvMulO unsignedTwo 3 + , bvAddO signedMax signedOne + , bvSubO signedMin signedOne + , bvMulO signedMax 2 + , bvDivO signedMin (negate signedOne) + , bvNegO signedMin + , bvMulO signedMax signedOne + , bvNegO signedMin8 + , bvMulO signedMin8 (-1) + ] + cgReturn $ pack flags + maxWord = 2 ^ (64 :: Int) - 1 + maxInt = 2 ^ (63 :: Int) - 1 + minInt = negate (2 ^ (63 :: Int)) + minInt8 = -128 + compileAndRun dir "nativeOverflow" program "0x0df7U" + where pack :: [SBool] -> SWord16 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]) + +-- | Exercise the Boolean truth tables for overflow and underflow on an +-- unsigned one-bit vector, including the public constant-false predicates. +oneBitOverflow :: Assertion +oneBitOverflow = withSystemTempDirectory "sbv-one-bit-overflow" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 0] + oneBit <- cgInput "oneBit" :: SBVCodeGen (SWord 1) + zeroBit <- cgInput "zeroBit" :: SBVCodeGen (SWord 1) + cgReturn $ pack [ bvAddO oneBit oneBit + , bvAddO oneBit zeroBit + , bvAddO zeroBit oneBit + , bvAddO zeroBit zeroBit + , bvSubO zeroBit oneBit + , bvSubO oneBit zeroBit + , bvSubO oneBit oneBit + , bvSubO zeroBit zeroBit + , bvMulO oneBit oneBit + , bvMulO oneBit zeroBit + , bvMulO zeroBit oneBit + , bvMulO zeroBit zeroBit + , bvDivO oneBit oneBit + , bvNegO oneBit + ] + compileAndRun dir "oneBitOverflow" program "0x0011U" + where pack :: [SBool] -> SWord16 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]) + +-- | Exercise non-byte-aligned native extraction and signed rotations, +-- including counts larger than the operand width and SBV's unchanged result +-- for a negative constant count. +nativeBitOperations :: Assertion +nativeBitOperations = withSystemTempDirectory "sbv-native-bit-operations" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [wordSample, signedSample] + wordValue <- cgInput "wordValue" :: SBVCodeGen (SWord 32) + signedValue <- cgInput "signedValue" :: SBVCodeGen (SInt 32) + let extracted = bvExtract (Proxy @10) (Proxy @3) wordValue :: SWord 8 + highHalf = bvExtract (Proxy @31) (Proxy @16) wordValue :: SWord 16 + lowHalf = bvExtract (Proxy @15) (Proxy @0) wordValue :: SWord 16 + rejoined = highHalf # lowHalf :: SWord 32 + signExtended = signExtend signedValue :: SInt 64 + zeroExtended = zeroExtend wordValue :: SWord 64 + narrowed = sFromIntegral signedValue :: SWord8 + shiftedLeft = signed32 (raw32 (raw32 signedSample * 2 ^ (3 :: Int))) + shiftedRight = signedSample `div` 2 ^ (3 :: Int) + flags = [ extracted .== fromInteger extractedExpected + , rotateL signedValue 37 .== fromInteger rotatedLeftExpected + , rotateR signedValue 39 .== fromInteger rotatedRightExpected + , rotateR signedValue (-5) .== signedValue + , signExtended .== fromInteger signedSample + , zeroExtended .== fromInteger wordSample + , narrowed .== fromInteger (raw32 signedSample `mod` 2 ^ (8 :: Int)) + , rejoined .== wordValue + , shiftL signedValue 3 .== fromInteger shiftedLeft + , shiftR signedValue 3 .== fromInteger shiftedRight + , shiftL signedValue 32 .== 0 + , shiftR signedValue 32 .== (-1) + ] + cgReturn $ pack flags + compileAndRun dir "nativeBitOperations" program "0x0fffU" + where wordSample :: Integer + wordSample = 0xdeadbeef + + signedSample :: Integer + signedSample = -19088744 + + extractedExpected :: Integer + extractedExpected = (wordSample `div` (2 ^ (3 :: Int))) `mod` (2 ^ (8 :: Int)) + + rotatedLeftExpected :: Integer + rotatedLeftExpected = signed32 (rotateLeft32 signedSample 5) + + rotatedRightExpected :: Integer + rotatedRightExpected = signed32 (rotateRight32 signedSample 7) + + rotateLeft32 :: Integer -> Int -> Integer + rotateLeft32 value amount = (raw32 value * 2 ^ amount + raw32 value `div` 2 ^ (32 - amount)) `mod` 2 ^ (32 :: Int) + + rotateRight32 :: Integer -> Int -> Integer + rotateRight32 value amount = (raw32 value `div` 2 ^ amount + raw32 value * 2 ^ (32 - amount)) `mod` 2 ^ (32 :: Int) + + raw32 :: Integer -> Integer + raw32 value = value `mod` 2 ^ (32 :: Int) + + signed32 :: Integer -> Integer + signed32 value + | value >= 2 ^ (31 :: Int) = value - 2 ^ (32 :: Int) + | True = value + + pack :: [SBool] -> SWord16 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]) + +-- | Exercise modular native arithmetic and the two division cases that would +-- otherwise be undefined in C. +nativeArithmetic :: Assertion +nativeArithmetic = withSystemTempDirectory "sbv-native-arithmetic" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [minimumInt64, -1, maximumInt64, maximumInt32, maximumWord16] + minimum64 <- cgInput "minimum64" :: SBVCodeGen SInt64 + negative1 <- cgInput "negative1" :: SBVCodeGen SInt64 + maximum64 <- cgInput "maximum64" :: SBVCodeGen SInt64 + maximum32 <- cgInput "maximum32" :: SBVCodeGen SInt32 + maximum16 <- cgInput "maximum16" :: SBVCodeGen SWord16 + let flags = [ maximum64 + 1 .== fromInteger minimumInt64 + , minimum64 + negative1 .== fromInteger maximumInt64 + , minimum64 - 1 .== fromInteger maximumInt64 + , maximum64 * 2 .== (-2) + , negate minimum64 .== minimum64 + , abs minimum64 .== minimum64 + , minimum64 `sQuot` negative1 .== minimum64 + , minimum64 `sRem` negative1 .== 0 + , minimum64 `sQuot` 0 .== 0 + , minimum64 `sRem` 0 .== minimum64 + , maximum32 * maximum32 .== 1 + , maximum16 * maximum16 .== 1 + ] + cgReturn $ pack flags + compileAndRun dir "nativeArithmetic" program "0x0fffU" + where minimumInt64 :: Integer + minimumInt64 = negate (2 ^ (63 :: Int)) + + maximumInt64 :: Integer + maximumInt64 = 2 ^ (63 :: Int) - 1 + + maximumInt32 :: Integer + maximumInt32 = 2 ^ (31 :: Int) - 1 + + maximumWord16 :: Integer + maximumWord16 = 2 ^ (16 :: Int) - 1 + + pack :: [SBool] -> SWord16 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048]) + +-- | Exercise checked table lookup with both a wide index and wide elements. +wideLookup :: Assertion +wideLookup = withSystemTempDirectory "sbv-wide-lookup" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs True + cgSetDriverValues [2 ^ (64 :: Int) + 1] + index <- cgInput "index" :: SBVCodeGen (SWord 65) + cgReturn (select [11, 22] 99 index :: SWord 673) + compileAndRun dir "wideLookup" program (asHex 11 99) + +-- | Exercise persistent arrays whose keys and values both use exact-width +-- limb representations. +wideArray :: Assertion +wideArray = withSystemTempDirectory "sbv-wide-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [keySample, valueSample] + key <- cgInput "key" :: SBVCodeGen (SWord 673) + value <- cgInput "value" :: SBVCodeGen (SWord 257) + let base = constArray 3 + updated = writeArray base key value + cgOutput "defaultRead" (readArray updated (key + 1)) + cgReturn (readArray updated key) + keySample = 2 ^ (672 :: Int) + 17 + valueSample = 2 ^ (256 :: Int) + 5 + compileAndRun dir "wideArray" program (asHex 5 valueSample) + +-- | Exercise the public callback descriptor when both its key and returned +-- value use multi-limb bit-vector representations. +wideArrayInput :: Assertion +wideArrayInput = withSystemTempDirectory "sbv-wide-array-input" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [valueSample, keySample] + source <- cgInput "source" :: SBVCodeGen (SArray (WordN 673) (WordN 257)) + key <- cgInput "key" :: SBVCodeGen (SWord 673) + cgReturn (readArray source key) + keySample = 2 ^ (672 :: Int) + 17 + valueSample = 2 ^ (256 :: Int) + 5 + compileAndRun dir "wideArrayInput" program (asHex 5 valueSample) + +-- | Exercise a structured array lambda whose parameter, local arithmetic, +-- and result all use the 673-bit limb representation. +wideLambdaArray :: Assertion +wideLambdaArray = withSystemTempDirectory "sbv-wide-lambda-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [keySample] + key <- cgInput "key" :: SBVCodeGen (SWord 673) + let source = lambdaArray (\index -> index * 3 + 5) :: SArray (WordN 673) (WordN 673) + cgReturn (readArray source key) + keySample = 2 ^ (672 :: Int) + 17 + expected = (keySample * 3 + 5) `mod` (2 ^ (673 :: Int)) + compileAndRun dir "wideLambdaArray" program (asHex 11 expected) + +-- | Exercise a parameter-dependent lookup table entirely within a structured +-- lambda using arbitrary-width indices, elements, and results. +wideLambdaTable :: Assertion +wideLambdaTable = withSystemTempDirectory "sbv-wide-lambda-table" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + key <- cgInput "key" :: SBVCodeGen (SWord 673) + let source = lambdaArray (\index -> select [index + 1, index * 3] 99 index) :: SArray (WordN 673) (WordN 673) + cgReturn (readArray source key) + compileAndRun dir "wideLambdaTable" program (asHex 11 3) + +-- | Exercise division-by-zero, extreme shifts, and signed-minimum division. +arithmeticBoundaries :: Assertion +arithmeticBoundaries = withSystemTempDirectory "sbv-arithmetic-boundaries" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [negate (2 ^ (64 :: Int))] + a <- cgInput "a" :: SBVCodeGen (SInt 65) + let z = 0 :: SInt 65 + cgReturn $ pack [a `sQuot` z .== z + , a `sRem` z .== a + , shiftL a 65 .== z + , shiftR a 65 .== (-1) + , a `sQuot` (-1) .== a + , a `sRem` (-1) .== z + , rotateL a 66 .== 1] + compileAndRun dir "arithmeticBoundaries" program (asHex 2 127) + where pack :: [SBool] -> SWord 65 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64]) + +-- | Generate, compile, and execute a C program, checking its encoded result. +-- @SBV_C_TEST_FLAGS@ supplies extra flags for optimization and sanitizer runs. +compileAndRun :: FilePath -> String -> SBVCodeGen () -> String -> Assertion +compileAndRun dir functionName program expected = do + (_, cfg, bundle) <- compileToC' functionName program + renderCgPgmBundle (Just dir) (cfg, bundle) + + let source = dir functionName ++ ".c" + driver = dir functionName ++ "_driver.c" + exe = dir functionName ++ "_driver" + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + (ccExit, _, ccErr) <- readProcessWithExitCode "cc" (["-std=c11", "-Wall", "-Werror", source, driver, "-o", exe] ++ extraFlags) "" + assertEqual ccErr ExitSuccess ccExit + + (runExit, out, runErr) <- readProcessWithExitCode exe [] "" + assertEqual runErr ExitSuccess runExit + assertBool ("Expected generated output to contain " ++ expected ++ ", received:\n" ++ out) (expected `isInfixOf` out) + +-- | Render the fixed-limb hexadecimal form printed by generated drivers. +asHex :: Int -> Integer -> String +asHex limbCount value = "0x" ++ replicate (16 * limbCount - length h) '0' ++ h + where h = showHex value "" diff --git a/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryFloats.hs b/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryFloats.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/ArbitraryFloats.hs @@ -0,0 +1,1073 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.ArbitraryFloats +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Compile-and-run tests for LibBF-backed arbitrary floating-point C lowering. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE ScopedTypeVariables #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.ArbitraryFloats (tests) where + +import Control.Monad (when) +import Data.List (isInfixOf) +import Data.Maybe (fromMaybe) +import Numeric (showHex) +import System.Directory (doesFileExist) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import qualified Data.SBV.Dynamic as D +import qualified Data.SBV.Rational as Rat + +import Data.SBV.Internals +import Data.SBV.Tuple (tuple, untuple) + +import Utils.SBVTestFramework hiding ((#)) +import Utils.CCodeGen (locateLibBF, generatedMakeOptions) + +-- | Arbitrary floating-point C backend tests. +tests :: TestTree +tests = testGroup "CodeGeneration.ArbitraryFloats" + [ testCase "compile and execute arithmetic" arbitraryFloatArithmetic + , testCase "preserve division, signed zero, and extreme-exponent FMA" reviewedFloatArithmetic + , testCase "compile and execute a nonstandard wide format" arbitraryFloatWideFormat + , testCase "compile and execute classification" arbitraryFloatClassification + , testCase "compile and execute rounding modes" arbitraryFloatRoundingModes + , testCase "compile and execute symbolic rounding modes" arbitraryFloatSymbolicRoundingMode + , testCase "compile and execute native rounding modes" nativeFloatRoundingModes + , testCase "preserve native floating rounding steps under optimization" nativeFloatRoundingSteps + , testCase "reject unsafe floating compiler modes" nativeFloatCompilerModes + , testCase "convert between native floats and bit-vectors" nativeFloatBitVectorConversions + , testCase "convert native floats across non-native widths" nativeFloatWidthConversions + , testCase "preserve native floating casts under caller rounding modes" nativeFloatCastEnvironment + , testCase "totalize exceptional native floating casts without C overflow" nativeFloatExceptionalCasts + , testCase "keep exact native floating casts free of LibBF" nativeExactFloatConversions + , testCase "convert between native floats and exact numbers" nativeFloatExactConversions + , testCase "convert mapped integers with explicit float rounding" mappedIntegerFloatConversions + , testCase "convert mapped reals across numeric representations" mappedRealConversions + , testCase "preserve target long-double precision across numeric bridges" longDoubleNumericBoundaries + , testCase "reject unsupported target long-double formats explicitly" unsupportedLongDoubleFormat + , testCase "compile and execute special arithmetic" arbitraryFloatSpecialArithmetic + , testCase "compile and execute arbitrary-float table lookup" arbitraryFloatTableLookup + , testCase "preserve arbitrary floating-point array-key equality" arbitraryFloatArrayKeys + , testCase "compile and execute an arbitrary-float callback-backed array" arbitraryFloatArrayInput + , testCase "compile and execute an arbitrary-float structured lambda array" arbitraryFloatLambdaArray + , testCase "compile and execute an arbitrary-float structured lambda table" arbitraryFloatLambdaTable + , testCase "convert between arbitrary floats and exact numbers" arbitraryFloatExactConversions + , testCase "compile and execute a mixed repeated-type library" mixedRepeatedTypeLibrary + , testCase "compile a repeated-type library without a driver" repeatedTypeLibraryWithoutDriver + , testCase "compile a wide arbitrary-float tuple" wideFloatingTuple + , testCase "preserve dependencies with optional library files" optionalLibraryFiles + ] + +-- | Exercise the ordinary fractional operator, both same-sign zero arguments, +-- and cancellation after a product beyond the target format's exponent range. +reviewedFloatArithmetic :: Assertion +reviewedFloatArithmetic = withSystemTempDirectory "sbv-reviewed-floats" $ \dir -> do + let bias = 2 ^ (28 :: Int) - 1 + aBits = (bias + 2 ^ (27 :: Int)) * 4 + cBits = 2 ^ (31 :: Int) + (2 ^ (29 :: Int) - 2) * 4 + 3 + program = do + cgOverwriteFiles True + cgSetDriverValues [6, 2, 0x8000, 0x8000, aBits, cBits] + dividendValue <- cgInput "numerator" :: SBVCodeGen SFPQuad + divisorValue <- cgInput "denominator" :: SBVCodeGen SFPQuad + negativeZeroBits <- cgInput "zeroBits" :: SBVCodeGen (SWord 16) + otherZeroBits <- cgInput "otherZeroBits" :: SBVCodeGen (SWord 16) + aRaw <- cgInput "aBits" :: SBVCodeGen (SWord 32) + cRaw <- cgInput "cBits" :: SBVCodeGen (SWord 32) + let negativeZero = sWordAsSFloatingPoint negativeZeroBits :: SFPHalf + otherNegativeZero = sWordAsSFloatingPoint otherZeroBits :: SFPHalf + a = sWordAsSFloatingPoint aRaw :: SFloatingPoint 29 3 + c = sWordAsSFloatingPoint cRaw :: SFloatingPoint 29 3 + result = fpFMA sRNE a a c + expected = literal (fromInteger ((bias + 2 ^ (28 :: Int) - 3) * 4)) :: SWord 32 + cgReturn $ dividendValue / divisorValue .== 3 + .&& fpIsEqualObject (fpMin negativeZero otherNegativeZero) negativeZero + .&& fpIsEqualObject (fpMax negativeZero otherNegativeZero) negativeZero + .&& sFloatingPointAsSWord result .== expected + compileAndRunLibBF dir "reviewedFloatArithmetic" program ") = 1" + +-- | Keep LibBF requirements when its component disables Makefile generation, +-- and associate an enabled driver with its own component after a disabled one. +optionalLibraryFiles :: Assertion +optionalLibraryFiles = mapM_ check [False, True] + where check generateMakefile = withSystemTempDirectory "sbv-optional-library-files" $ \dir -> do + (includeDir, archive) <- locateLibBF + (_, cfg, bundle) <- compileToCLib' "optionalLibrary" + [ ("scalar", do + cgOverwriteFiles True + cgGenerateDriver False + cgGenerateMakefile generateMakefile + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (value + 1)) + , ("half", do + cgOverwriteFiles True + cgGenerateMakefile False + cgSetDriverValues [1] + value <- cgInput "value" :: SBVCodeGen SFPHalf + cgReturn (value + 1)) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + hasMakefile <- doesFileExist (dir "Makefile") + assertEqual "Unexpected optional Makefile" generateMakefile hasMakefile + when generateMakefile $ do + makefile <- readFile (dir "Makefile") + assertBool "Hidden component lost its LibBF link dependency" ("-lbf" `isInfixOf` makefile) + let driverPath = dir "driver" + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + (buildExit, _, buildError) <- readProcessWithExitCode "cc" + ([ "-std=c11", "-Wall", "-Werror", "-I" ++ includeDir + , dir "scalar.c", dir "half.c", dir "optionalLibrary_driver.c" + , archive, "-lm", "-o", driverPath + ] ++ extraFlags) "" + assertEqual buildError ExitSuccess buildExit + (runExit, outputText, runError) <- readProcessWithExitCode driverPath [] "" + assertEqual runError ExitSuccess runExit + assertBool outputText ("Driver run for half:" `isInfixOf` outputText && asHex 1 0x4000 `isInfixOf` outputText) + +-- | Exercise tuple fields whose value representations are generated wide +-- bit-vector and arbitrary floating-point structures. +wideFloatingTuple :: Assertion +wideFloatingTuple = withSystemTempDirectory "sbv-wide-floating-tuple" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5] + source <- cgInput "source" :: SBVCodeGen (SBV (WordN 65, FloatingPoint 7 19)) + let (word, float) = untuple source + cgReturn (tuple (word + 1, float + 1)) + + compileAndRunLibBF dir "wideFloatingTuple" program "(0x00000000000000000000000000000006, 0x" + +-- | Exercise LibBF-backed quadruple arithmetic and floating-point predicates. +arbitraryFloatArithmetic :: Assertion +arbitraryFloatArithmetic = withSystemTempDirectory "sbv-arbitrary-float" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 2, -17] + a <- cgInput "a" :: SBVCodeGen SFPQuad + b <- cgInput "b" :: SBVCodeGen SFPQuad + c <- cgInput "c" :: SBVCodeGen SInt64 + let added = fpAdd sRNE a b + fused = fpFMA sRNE a b b + half = toSFloatingPoint sRNE fused :: SFPHalf + viaHalf = toSFloatingPoint sRNE half :: SFPQuad + asDouble = fromSFloatingPoint sRNE fused :: SDouble + viaDouble = toSFloatingPoint sRNE asDouble :: SFPQuad + fromInt = toSFloatingPoint sRNE c :: SFPQuad + backInt = fromSFloatingPoint sRNE fromInt :: SInt64 + bits = sFloatingPointAsSWord viaDouble :: SWord 128 + roundTrip = sWordAsSFloatingPoint bits :: SFPQuad + cgOutput "added" added + cgOutput "fusedBits" bits + cgReturn $ ite (fpIsNormal a .&& a .> b .&& fpIsEqualObject fused viaHalf .&& fpIsEqualObject fused roundTrip .&& backInt .== c) roundTrip added + bias = 2 ^ (14 :: Int) - 1 :: Integer + eightRaw = (bias + 3) * 2 ^ (112 :: Int) + compileAndRunLibBF dir "arbitraryFloatArithmetic" program (asHex 2 eightRaw) + +-- | Exercise a nonstandard format whose interchange value spans four limbs. +arbitraryFloatWideFormat :: Assertion +arbitraryFloatWideFormat = withSystemTempDirectory "sbv-arbitrary-float-wide-format" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 5] + a <- cgInput "a" :: SBVCodeGen (SFloatingPoint 17 237) + b <- cgInput "b" :: SBVCodeGen (SFloatingPoint 17 237) + let result = fpAdd sRNE a b + bits = sFloatingPointAsSWord result :: SWord 254 + cgOutput "bits" bits + cgReturn result + bias = 2 ^ (16 :: Int) - 1 :: Integer + eightRaw = (bias + 3) * 2 ^ (236 :: Int) + compileAndRunLibBF dir "arbitraryFloatWideFormat" program (asHex 4 eightRaw) + +-- | Exercise special-value classification through raw half-precision inputs. +arbitraryFloatClassification :: Assertion +arbitraryFloatClassification = withSystemTempDirectory "sbv-arbitrary-float-classification" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x7e00, 0x8000, 0x0001, 0x7c00] + nanBits <- cgInput "nanBits" :: SBVCodeGen (SWord 16) + nzBits <- cgInput "negativeZeroBits" :: SBVCodeGen (SWord 16) + subBits <- cgInput "subnormalBits" :: SBVCodeGen (SWord 16) + infBits <- cgInput "infinityBits" :: SBVCodeGen (SWord 16) + let nanValue = sWordAsSFloatingPoint nanBits :: SFPHalf + negativeZero = sWordAsSFloatingPoint nzBits :: SFPHalf + subnormal = sWordAsSFloatingPoint subBits :: SFPHalf + infValue = sWordAsSFloatingPoint infBits :: SFPHalf + positiveZero = 0 :: SFPHalf + cgReturn $ pack [fpIsNaN nanValue + , nanValue ./= nanValue + , fpIsEqualObject nanValue nanValue + , fpIsZero negativeZero + , fpIsNegative negativeZero + , sNot (fpIsEqualObject negativeZero positiveZero) + , negativeZero .== positiveZero + , fpIsSubnormal subnormal + , fpIsPositive subnormal + , sNot (fpIsNormal subnormal) + , fpIsInfinite infValue + , sNot (fpIsNormal infValue) + , distinct [nanValue, nanValue, positiveZero] + , sNot (distinct [negativeZero, positiveZero])] + compileAndRunLibBF dir "arbitraryFloatClassification" program "0x3fff" + where pack :: [SBool] -> SWord16 + pack flags = sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]) + +-- | Exercise all IEEE rounding modes on an exactly halfway format conversion. +arbitraryFloatRoundingModes :: Assertion +arbitraryFloatRoundingModes = withSystemTempDirectory "sbv-arbitrary-float-rounding" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2049, 2048] + numValue <- cgInput "numerator" :: SBVCodeGen SFPQuad + denValue <- cgInput "denominator" :: SBVCodeGen SFPQuad + let value = fpDiv sRNE numValue denValue + rne = rawHalf (toSFloatingPoint sRNE value) + rna = rawHalf (toSFloatingPoint sRNA value) + rtp = rawHalf (toSFloatingPoint sRTP value) + rtn = rawHalf (toSFloatingPoint sRTN value) + rtz = rawHalf (toSFloatingPoint sRTZ value) + cgReturn (rne # rna # rtp # rtn # rtz :: SWord 80) + expected = foldl (\acc word -> acc * 2 ^ (16 :: Int) + word) 0 [0x3c00, 0x3c01, 0x3c01, 0x3c00, 0x3c00] + compileAndRunLibBF dir "arbitraryFloatRoundingModes" program (asHex 2 expected) + where rawHalf :: SFPHalf -> SWord 16 + rawHalf = sFloatingPointAsSWord + +-- | Exercise a runtime-selected rounding mode in arithmetic and conversion. +arbitraryFloatSymbolicRoundingMode :: Assertion +arbitraryFloatSymbolicRoundingMode = withSystemTempDirectory "sbv-arbitrary-float-symbolic-rounding" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 0, 1, 2, 3, 4, 2049, 2048, 1, 3] + choose <- cgInput "chooseInputMode" :: SBVCodeGen SBool + modeRNE <- cgInput "rne" :: SBVCodeGen SRoundingMode + modeRNA <- cgInput "rna" :: SBVCodeGen SRoundingMode + modeRTP <- cgInput "rtp" :: SBVCodeGen SRoundingMode + modeRTN <- cgInput "rtn" :: SBVCodeGen SRoundingMode + modeRTZ <- cgInput "rtz" :: SBVCodeGen SRoundingMode + numValue <- cgInput "numerator" :: SBVCodeGen SFPQuad + denValue <- cgInput "denominator" :: SBVCodeGen SFPQuad + one <- cgInput "one" :: SBVCodeGen SFPHalf + three <- cgInput "three" :: SBVCodeGen SFPHalf + let runtimeMode mode = ite choose mode sRTZ + value = fpDiv sRNE numValue denValue + rne = rawHalf (toSFloatingPoint (runtimeMode modeRNE) value) + rna = rawHalf (toSFloatingPoint (runtimeMode modeRNA) value) + rtp = rawHalf (toSFloatingPoint (runtimeMode modeRTP) value) + rtn = rawHalf (toSFloatingPoint (runtimeMode modeRTN) value) + rtz = rawHalf (toSFloatingPoint (runtimeMode modeRTZ) value) + divided = rawHalf (fpDiv (runtimeMode modeRTP) one three) + cgOutput "selectedMode" (runtimeMode modeRTP) + cgReturn (rne # rna # rtp # rtn # rtz # divided :: SWord 96) + expected = foldl (\acc word -> acc * 2 ^ (16 :: Int) + word) 0 [0x3c00, 0x3c01, 0x3c01, 0x3c00, 0x3c00, 0x3556] + compileAndRunLibBF dir "arbitraryFloatSymbolicRoundingMode" program (asHex 2 expected) + where rawHalf :: SFPHalf -> SWord 16 + rawHalf = sFloatingPointAsSWord + +-- | Separate multiplication and addition round the product before adding; +-- explicit FMA must keep the exact product until the final rounding. The +-- near-one factors make these results differ in both native formats. +nativeRoundingProgram :: SBVCodeGen () +nativeRoundingProgram = do + cgOverwriteFiles True + cgSetDriverValues [0x3f800001, 0x3f7ffffe, 0x3ff0000000000001, 0x3feffffffffffffe] + floatLeft <- cgInput "floatLeft" :: SBVCodeGen SWord32 + floatRight <- cgInput "floatRight" :: SBVCodeGen SWord32 + doubleLeft <- cgInput "doubleLeft" :: SBVCodeGen SWord64 + doubleRight <- cgInput "doubleRight" :: SBVCodeGen SWord64 + let xf = sWord32AsSFloat floatLeft + yf = sWord32AsSFloat floatRight + xd = sWord64AsSDouble doubleLeft + yd = sWord64AsSDouble doubleRight + cgReturn $ sAnd + [ fpAdd sRNE (fpMul sRNE xf yf) (-1) .== 0 + , fpAdd sRNE (fpMul sRNE xd yd) (-1) .== 0 + , xf * yf - 1 .== 0 + , xd * yd - 1 .== 0 + , fpFMA sRNE xf yf (-1) .== literal (-(2 ** (-46)) :: Float) + , fpFMA sRNE xd yd (-1) .== literal (-(2 ** (-104)) :: Double) + ] + +-- | Generated standalone and library Makefiles must preserve rounding steps +-- under optimization and LTO, even when user CCFLAGS enable contraction. +nativeFloatRoundingSteps :: Assertion +nativeFloatRoundingSteps = mapM_ check [(library, flags) | library <- [False, True], flags <- ["-O3", "-O3 -ffp-contract=fast", "-O3 -flto -ffp-contract=fast"]] + where check (library, flags) = withSystemTempDirectory "sbv-native-rounding-steps" $ \dir -> do + let functionName = "nativeRoundingSteps" + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("roundingComponent", nativeRoundingProgram)] + else compileToC' functionName ((:[]) <$> nativeRoundingProgram) + renderCgPgmBundle (Just dir) (cfg, bundle) + extraFlags <- fromMaybe "" <$> lookupEnv "SBV_C_TEST_FLAGS" + writeFile (dir "rounding.mk") ("CCFLAGS=-Wall -Werror " ++ flags ++ " " ++ extraFlags ++ "\n") + (makeExit, _, makeError) <- readProcessWithExitCode "make" ["-C", dir] "" + assertEqual makeError ExitSuccess makeExit + (runExit, outputText, runError) <- readProcessWithExitCode (dir functionName ++ "_driver") [] "" + assertEqual runError ExitSuccess runExit + assertBool (flags ++ ":\n" ++ outputText) (") = 1" `isInfixOf` outputText) + +-- | Reject detectable compiler modes that can discard NaNs, signed zeros, +-- or IEEE rounding, instead of silently compiling a different computation. +nativeFloatCompilerModes :: Assertion +nativeFloatCompilerModes = withSystemTempDirectory "sbv-native-unsafe-compiler-modes" $ \dir -> do + let functionName = "nativeCompilerModes" + (_, cfg, bundle) <- compileToC' functionName nativeRoundingProgram + renderCgPgmBundle (Just dir) (cfg, bundle) + let check flag = do + (ccExit, _, ccError) <- readProcessWithExitCode "cc" + ["-std=c11", "-O3", flag, "-c", dir functionName ++ ".c", "-o", dir "unsafe.o"] "" + assertBool ("Expected rejection of " ++ flag) (ccExit /= ExitSuccess) + assertBool ccError ("SBV-generated C requires IEEE floating-point semantics" `isInfixOf` ccError) + mapM_ check ["-ffast-math", "-ffinite-math-only"] + +-- | Exercise all constant rounding modes and runtime-selected modes while +-- retaining native @float@ and @double@ values at the generated C boundary. +nativeFloatRoundingModes :: Assertion +nativeFloatRoundingModes = withSystemTempDirectory "sbv-native-float-rounding" $ \dir -> do + let floatProgram = do + cgOverwriteFiles True + cgSetDriverValues [0x3f800000, 0x33800000, 1, 2] + oneRaw <- cgInput "oneBits" :: SBVCodeGen SWord32 + halfBits <- cgInput "halfBits" :: SBVCodeGen SWord32 + modeRNA <- cgInput "modeRNA" :: SBVCodeGen SRoundingMode + modeRTP <- cgInput "modeRTP" :: SBVCodeGen SRoundingMode + let one = sWord32AsSFloat oneRaw + halfUlp = sWord32AsSFloat halfBits + raw mode = sFromIntegral (sFloatAsSWord32 (fpAdd mode one halfUlp)) :: SWord 32 + cgReturn (raw sRNE # raw sRNA # raw sRTP # raw sRTN # raw sRTZ # raw modeRNA # raw modeRTP :: SWord 224) + + doubleProgram = do + cgOverwriteFiles True + cgSetDriverValues [0x3ff0000000000000, 0x3ca0000000000000, 1, 2] + oneRaw <- cgInput "oneBits" :: SBVCodeGen SWord64 + halfBits <- cgInput "halfBits" :: SBVCodeGen SWord64 + modeRNA <- cgInput "modeRNA" :: SBVCodeGen SRoundingMode + modeRTP <- cgInput "modeRTP" :: SBVCodeGen SRoundingMode + let one = sWord64AsSDouble oneRaw + halfUlp = sWord64AsSDouble halfBits + raw mode = sFromIntegral (sDoubleAsSWord64 (fpAdd mode one halfUlp)) :: SWord 64 + cgReturn (raw sRNE # raw sRNA # raw sRTP # raw sRTN # raw sRTZ # raw modeRNA # raw modeRTP :: SWord 448) + + scalarProgram = do + cgOverwriteFiles True + cgSetDriverValues [0x3f800000, 0x33800000] + oneRaw <- cgInput "oneBits" :: SBVCodeGen SWord32 + halfBits <- cgInput "halfBits" :: SBVCodeGen SWord32 + let result = fpAdd sRNA (sWord32AsSFloat oneRaw) (sWord32AsSFloat halfBits) + cgOutput "resultBits" (sFloatAsSWord32 result) + cgReturn result + + floatOne = 0x3f800000 + floatNext = 0x3f800001 + doubleOne = 0x3ff0000000000000 + doubleNext = 0x3ff0000000000001 + assemble width = foldl (\acc word -> acc * 2 ^ width + word) 0 + floatExpected = assemble (32 :: Int) [floatOne, floatNext, floatNext, floatOne, floatOne, floatNext, floatNext] + doubleExpected = assemble (64 :: Int) [doubleOne, doubleNext, doubleNext, doubleOne, doubleOne, doubleNext, doubleNext] + + compileAndRunLibBF dir "nativeFloatRoundingModesFloat" floatProgram (asHex 4 floatExpected) + compileAndRunLibBF dir "nativeFloatRoundingModesDouble" doubleProgram (asHex 7 doubleExpected) + compileAndRunLibBF dir "nativeFloatRoundingScalar" scalarProgram "resultBits = 0x3f800001UL" + +-- | Exercise all rounding directions between native floats and exact-width +-- bit-vectors. +nativeFloatBitVectorConversions :: Assertion +nativeFloatBitVectorConversions = withSystemTempDirectory "sbv-native-float-bit-vector" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [16777217, 5, 2] + nativeInteger <- cgInput "nativeInteger" :: SBVCodeGen SInt32 + five <- cgInput "five" :: SBVCodeGen SFloat + two <- cgInput "two" :: SBVCodeGen SFloat + let nativeRNE = toSFloat sRNE nativeInteger + nativeRTP = toSFloat sRTP nativeInteger + twoAndAHalf = fpDiv sRNE five two + nativeEven = fromSFloat sRNE twoAndAHalf :: SInt32 + nativeAway = fromSFloat sRNA twoAndAHalf :: SInt32 + nativeDown = fromSFloat sRTN twoAndAHalf :: SInt32 + nativeUp = fromSFloat sRTP twoAndAHalf :: SInt32 + cgReturn $ nativeRNE .== 16777216 + .&& nativeRTP .== 16777218 + .&& nativeEven .== 2 + .&& nativeAway .== 3 + .&& nativeDown .== 2 + .&& nativeUp .== 3 + compileAndRunLibBF dir "nativeFloatBitVectorConversions" program "= 1" + +-- | Exercise explicitly rounded native float-to-float conversion, RNE +-- conversion to and from a limb-backed bit-vector, and the one-bit scalar +-- fallback type. +nativeFloatWidthConversions :: Assertion +nativeFloatWidthConversions = withSystemTempDirectory "sbv-native-float-width-conversions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [halfwayBits, 42, 1, 1] + rawHalfway <- cgInput "rawHalfway" :: SBVCodeGen SWord64 + wideValue <- svCgInput wideKind "wideValue" + oneBit <- svCgInput oneBitKind "oneBit" + runtimeRNA <- cgInput "runtimeRNA" :: SBVCodeGen SRoundingMode + let halfway = sWord64AsSDouble rawHalfway + floatBits rm = sFloatAsSWord32 (toSFloat rm halfway) + nativeChecks = floatBits sRNE .== floatOne + .&& floatBits sRNA .== floatNext + .&& floatBits sRTP .== floatNext + .&& floatBits sRTN .== floatOne + .&& floatBits sRTZ .== floatOne + .&& floatBits runtimeRNA .== floatNext + wideAsDouble = D.svCastToFP KDouble rneValue wideValue + wideAgain = D.svCastFromFP wideKind rneValue wideAsDouble + oneAsFloat = D.svCastToFP KFloat rneValue oneBit + oneAgain = D.svCastFromFP oneBitKind rneValue oneAsFloat + allChecks = foldl D.svAnd (unSBV nativeChecks) [D.svEqual wideAgain wideValue, D.svEqual oneAgain oneBit] + svCgReturn allChecks + halfwayBits = 0x3ff0000010000000 + floatOne = 0x3f800000 + floatNext = 0x3f800001 + rneValue = unSBV sRNE + wideKind = KBounded True 673 + oneBitKind = KBounded False 1 + compileAndRunLibBF dir "nativeFloatWidthConversions" program "= 1" + +-- | A separately compiled caller changes the hardware rounding mode around +-- explicitly rounded casts. Check halfway values at native and non-native +-- bit widths, large signed/unsigned integers, and binary64-to-binary32 narrowing. +-- This deliberately tests a stronger property of the conversion bridges than +-- the public FE_TONEAREST entry-point precondition; it is not a supported +-- calling convention for general generated arithmetic. +nativeFloatCastEnvironment :: Assertion +nativeFloatCastEnvironment = withSystemTempDirectory "sbv-native-float-cast-environment" $ \dir -> do + let program = do + cgOverwriteFiles True + cgGenerateDriver False + floatBits <- cgInput "floatBits" :: SBVCodeGen SWord32 + doubleBits <- cgInput "doubleBits" :: SBVCodeGen SWord64 + halfBits <- cgInput "halfBits" :: SBVCodeGen SWord32 + signed <- cgInput "signedValue" :: SBVCodeGen SInt64 + unsigned <- cgInput "unsignedValue" :: SBVCodeGen SWord64 + let float = sWord32AsSFloat floatBits + double = sWord64AsSDouble doubleBits + half = sWord32AsSFloat halfBits + modes = [sRNE, sRNA, sRTP, sRTN, sRTZ] + widths = [1, 7, 8, 9, 16, 32, 64, 65, 673] + checks signedKind width = zipWith check modes expected + where kind = KBounded signedKind width + positive = if width == 1 then half else float + value = if signedKind then negate positive else positive + expected + | width == 1 = if signedKind then [0, -1, 0, -1, 0] else [0, 1, 1, 0, 0] + | signedKind = [-2, -3, -2, -3, -2] + | True = [2, 3, 3, 2, 2] + check rm result = D.svEqual (D.svCastFromFP kind (unSBV rm) (unSBV value)) (D.svInteger kind result) + nativeChecks = sFloatAsSWord32 (toSFloat sRNE double) .== 0x3f800000 + .&& toSDouble sRNE signed .== -9007199254740992 + .&& toSFloat sRNE signed .== -9007199254740992 + .&& toSDouble sRNE unsigned .== 18446744073709551616 + .&& toSFloat sRNE unsigned .== 18446744073709551616 + svCgReturn (foldl D.svAnd (unSBV nativeChecks) (concat [checks sign width | sign <- [False, True], width <- widths])) + caller = unlines + [ "#include " + , "#include \"nativeFloatCastEnvironment.h\"" + , "int main(void)" + , "{" + , " const int modes[] = { FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO };" + , " const int original = fegetround();" + , " for (size_t i = 0; i < sizeof modes / sizeof modes[0]; ++i) {" + , " if (fesetround(modes[i]) != 0) return 1;" + , " if (!nativeFloatCastEnvironment(UINT32_C(0x40200000), UINT64_C(0x3ff0000010000000), UINT32_C(0x3f000000), -INT64_C(9007199254740993), UINT64_MAX)) return 2;" + , " if (fegetround() != modes[i]) return 3;" + , " }" + , " return fesetround(original) != 0;" + , "}" + ] + compileAndRunLibBFCaller dir "nativeFloatCastEnvironment" program caller + +-- | SMT leaves non-finite and out-of-range floating-to-bit-vector results +-- unspecified. The backend chooses zero for non-finite inputs and low bits +-- for finite ones, without invoking an overflowing native C integer cast. +nativeFloatExceptionalCasts :: Assertion +nativeFloatExceptionalCasts = mapM_ check [0x7ff0000000000000, 0xfff0000000000000, 0x7ff8000000000000, 0x8000000000000000, 0x7e70000000000000, 0xfe70000000000000] + where check bits = withSystemTempDirectory "sbv-native-float-exceptional-casts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [bits] + raw <- cgInput "raw" :: SBVCodeGen SWord64 + let value = sWord64AsSDouble raw + values = [unSBV value, unSBV (toSFloat sRNE value)] + kinds = [KBounded sign width | sign <- [False, True], width <- [1, 7, 8, 16, 32, 64, 65, 673]] + checks = [D.svEqual (D.svCastFromFP kind (unSBV sRNE) source) (D.svInteger kind 0) | kind <- kinds, source <- values] + svCgReturn (foldl D.svAnd (unSBV sTrue) checks) + compileAndRunLibBF dir "nativeFloatExceptionalCasts" program ") = 1" + +-- | Exactly representable casts stay native even with symbolic rounding. +-- Include negative zero so widening cannot accidentally change its sign. +nativeExactFloatConversions :: Assertion +nativeExactFloatConversions = withSystemTempDirectory "sbv-exact-native-float-casts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [-32768, 4294967295, 0x80000000, 2] + small <- cgInput "small" :: SBVCodeGen SInt16 + unsigned <- cgInput "word" :: SBVCodeGen SWord32 + zeroRaw <- cgInput "zeroBits" :: SBVCodeGen SWord32 + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + let checks rm = [ toSFloat rm small .== -32768 + , toSDouble rm unsigned .== 4294967295 + , sDoubleAsSWord64 (toSDouble rm (sWord32AsSFloat zeroRaw)) .== 0x8000000000000000 + ] + cgReturn (sAnd (concatMap checks [sRNE, sRNA, sRTP, sRTN, sRTZ, mode])) + compileAndRunWith ["-lm"] dir "nativeExactFloatConversions" program ") = 1" + source <- readFile (dir "nativeExactFloatConversions.c") + makefile <- readFile (dir "Makefile") + assertBool "Exact native conversions must not include LibBF" (not ("" `isInfixOf` source)) + assertBool "Exact native conversions must not link LibBF" (not ("-lbf" `isInfixOf` makefile)) + +-- | Exercise LibBF-mediated conversion between native floats and GMP-backed +-- exact numbers without introducing an arbitrary floating-point format. +nativeFloatExactConversions :: Assertion +nativeFloatExactConversions = withSystemTempDirectory "sbv-native-float-exact" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [16777217, 3, 2, 5, 2] + integer <- cgInput "integer" :: SBVCodeGen SInteger + realNumerator <- cgInput "realNumerator" :: SBVCodeGen SReal + realDenominator <- cgInput "realDenominator" :: SBVCodeGen SReal + five <- cgInput "five" :: SBVCodeGen SFloat + two <- cgInput "two" :: SBVCodeGen SFloat + let rational = realNumerator / realDenominator + integerRNE = toSFloat sRNE integer + integerRTP = toSFloat sRTP integer + rationalValue = toSDouble sRNE rational + twoAndAHalf = fpDiv sRNE five two + roundedEven = fromSFloat sRNE twoAndAHalf :: SInteger + roundedAway = fromSFloat sRNA twoAndAHalf :: SInteger + roundedUp = fromSFloat sRTP twoAndAHalf :: SInteger + roundedDown = fromSFloat sRTN twoAndAHalf :: SInteger + roundedZero = fromSFloat sRTZ twoAndAHalf :: SInteger + exactRational = fromSDouble sRNE rationalValue :: SReal + cgReturn $ integerRNE .== 16777216 + .&& integerRTP .== 16777218 + .&& rationalValue .== 1.5 + .&& roundedEven .== 2 + .&& roundedAway .== 3 + .&& roundedUp .== 3 + .&& roundedDown .== 2 + .&& roundedZero .== 2 + .&& exactRational .== 3 / 2 + compileAndRunLibBFGMP dir "nativeFloatExactConversions" program "= 1" + +-- | Mapped integer casts must use the selected width in both directions while +-- preserving every explicit rounding mode, including halfway negative values. +mappedIntegerFloatConversions :: Assertion +mappedIntegerFloatConversions = mapM_ check [(width, exposeChecks, arbitraryResult) | width <- [8, 16, 32, 64], exposeChecks <- [True, False], arbitraryResult <- [False, True]] + where check (width, exposeChecks, arbitraryResult) = withSystemTempDirectory "sbv-mapped-integer-float" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize width + cgSetDriverValues [sample, -5, 65539] + value <- cgInput "value" :: SBVCodeGen SInteger + five <- cgInput "five" :: SBVCodeGen SDouble + large <- cgInput "large" :: SBVCodeGen SDouble + let fraction = fpDiv sRNE five 2 + half rm = toSFloatingPoint rm value :: SFPHalf + halfFraction = fpDiv sRNE (toSFloatingPoint sRNE five :: SFPHalf) 2 + reference rm + | width == 8 = 5 + | True = ite (rm .== sRNA .|| rm .== sRTP) 2050 2048 :: SFPHalf + checks (rm, expected) = + [ sFloatingPointAsSWord (half rm) .== sFloatingPointAsSWord (reference rm) + , (fromSDouble rm fraction :: SInteger) .== expected + , toSDouble rm value .== fromInteger sample + ] + ++ [(fromSFloatingPoint rm halfFraction :: SInteger) .== expected | arbitraryResult] + allChecks = ((fromSDouble sRNE large :: SInteger) .== 65539) + : concatMap checks [(sRNE, -2), (sRNA, -3), (sRTP, -2), (sRTN, -3), (sRTZ, -2)] + when exposeChecks $ do + cgOutputArr "checks" allChecks + cgOutputArr "actual" (map (sFloatingPointAsSWord . half) [sRNE, sRNA, sRTP, sRTN, sRTZ]) + cgOutputArr "expected" (map (sFloatingPointAsSWord . reference) [sRNE, sRNA, sRTP, sRTN, sRTZ]) + cgReturn (sAnd allChecks) + sample = if width == 8 then 5 else 2049 + compileAndRunLibBF dir "mappedIntegerFloat" program ") = 1" + +-- | Native real mappings still require representation-aware conversion: +-- exact integers round to the selected real format, real-to-integer casts +-- floor, and explicit floating casts honor their requested rounding mode. +mappedRealConversions :: Assertion +mappedRealConversions = mapM_ check [(realType, mappedInteger) | realType <- [CgFloat, CgDouble, CgLongDouble], mappedInteger <- [False, True]] + where check (realType, mappedInteger) = withSystemTempDirectory "sbv-mapped-real-conversions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSRealType realType + when mappedInteger $ cgIntegerSize 32 + cgSetDriverValues [16777217, -5, 7] + value <- cgInput "value" :: SBVCodeGen SInteger + real <- cgInput "real" :: SBVCodeGen SReal + seven <- cgInput "seven" :: SBVCodeGen SFPHalf + let expected = case realType of + CgFloat -> 16777216 + _ -> 16777217 + half = toSFloatingPoint sRTP real :: SFPHalf + cgReturn $ (sFromIntegral value :: SReal) .== expected + .&& sRealToSIntegerFloor (real / 2) .== -3 + .&& (fromSFloatingPoint sRNE seven :: SReal) .== 7 + .&& half .== -5 + .&& toSDouble sRNE real .== -5 + compileAndRunLibBFGMP dir "mappedRealConversions" program "= 1" + +-- | Exercise target-dependent precision, exponent extremes, signed zero, NaN, +-- and all five rounding modes through an independent library caller. On targets +-- wider than binary64 the same tests explicitly preserve the additional bits. +longDoubleNumericBoundaries :: Assertion +longDoubleNumericBoundaries = withSystemTempDirectory "sbv-long-double-bridges" $ \dir -> do + let prepare program = cgOverwriteFiles True >> cgGenerateDriver False >> cgSRealType CgLongDouble >> program + wide :: SReal -> SFloatingPoint 20 200 + wide = toSFloatingPoint sRNE + components = + [ ("integerToLong", do + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (sFromIntegral value :: SReal)) + , ("wordToLong", do + value <- cgInput "value" :: SBVCodeGen SWord64 + cgReturn (sFromIntegral value :: SReal)) + , ("rationalToLong", do + value <- cgInput "value" :: SBVCodeGen SRational + cgReturn (Rat.sRationalToSReal value)) + , ("floorLong", do + value <- cgInput "value" :: SBVCodeGen SReal + cgOutput "result" (sRealToSIntegerFloor value)) + , ("roundedInteger", do + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + value <- cgInput "value" :: SBVCodeGen SInteger + let exact = toSFloatingPoint sRNE value :: SFloatingPoint 20 200 + cgReturn (fromSFloatingPoint mode exact :: SReal)) + , ("wideRoundTrip", do + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (fromSFloatingPoint sRNE (wide value) :: SReal)) + , ("tinyLong", do + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (fromSFloatingPoint mode (fpDiv sRNE (wide value) 2) :: SReal)) + , ("narrowFloat", do + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (toSFloat mode value)) + , ("nativeRoundTrip", do + value <- cgInput "value" :: SBVCodeGen SDouble + cgReturn (toSDouble sRNE (fromSDouble sRNE value :: SReal))) + ] + _ <- D.compileToCLib (Just dir) "longBridges" [(functionName, prepare program) | (functionName, program) <- components] + writeFile (dir "caller.c") $ unlines + [ "#include " + , "#include " + , "#include " + , "#include \"longBridges.h\"" + , "int main(int argc, char **argv)" + , "{" + , " mpz_t input, output; mpz_inits(input, output, NULL);" + , " (void) argv; if (argc > 1) { floorLong(HUGE_VALL, output); return 0; }" + , " const long double base = ldexpl(1.0L, LDBL_MANT_DIG);" + , " for (int negative = 0; negative < 2; ++negative) for (int odd = 0; odd < 2; ++odd) {" + , " mpz_set_ui(input, 1); mpz_mul_2exp(input, input, LDBL_MANT_DIG); mpz_add_ui(input, input, 1 + 2 * odd);" + , " if (negative) mpz_neg(input, input);" + , " for (int mode = 0; mode < 5; ++mode) {" + , " const bool up = mode == SBV_RM_RNA || (mode == SBV_RM_RNE && odd) || (mode == SBV_RM_RTP && !negative) || (mode == SBV_RM_RTN && negative);" + , " const long double magnitude = base + 2 * odd + (up ? 2 : 0);" + , " assert(roundedInteger((RoundingMode) mode, input) == (negative ? -magnitude : magnitude));" + , " }" + , " const long double nearest = base + (odd ? 4 : 0);" + , " assert(integerToLong(input) == (negative ? -nearest : nearest));" + , " }" + , " mpz_set_ui(input, 1); mpz_mul_2exp(input, input, LDBL_MANT_DIG - 1); mpz_add_ui(input, input, 1);" + , " const long double precise = ldexpl(1.0L, LDBL_MANT_DIG - 1) + 1;" + , " assert(integerToLong(input) == precise); floorLong(precise, output); assert(mpz_cmp(input, output) == 0);" + , " mpq_t rational; mpq_init(rational); mpz_set(mpq_numref(rational), input);" + , " mpz_set_ui(mpq_denref(rational), 1); mpz_mul_2exp(mpq_denref(rational), mpq_denref(rational), LDBL_MANT_DIG - 1);" + , " assert(rationalToLong(rational) == 1.0L + ldexpl(1.0L, 1 - LDBL_MANT_DIG)); mpq_clear(rational);" + , " assert(wordToLong(UINT64_C(9007199254740993)) == (LDBL_MANT_DIG > 53 ? 9007199254740993.0L : 9007199254740992.0L));" + , " floorLong(-2.5L, output); assert(mpz_cmp_si(output, -3) == 0);" + , " const long double tiny = nextafterl(0.0L, 1.0L);" + , " const long double values[] = {0.0L, -0.0L, tiny, -tiny, LDBL_MIN, -LDBL_MIN, LDBL_MAX, -LDBL_MAX, precise, -precise, HUGE_VALL, -HUGE_VALL};" + , " for (size_t i = 0; i < sizeof values / sizeof *values; ++i) {" + , " const long double result = wideRoundTrip(values[i]);" + , " assert(result == values[i] && (signbit(result) != 0) == (signbit(values[i]) != 0));" + , " }" + , " assert(isnan(wideRoundTrip(nanl(\"\"))));" + , " for (int mode = 0; mode < 5; ++mode) {" + , " const RoundingMode rm = (RoundingMode) mode;" + , " const long double positive = tinyLong(rm, tiny), negative = tinyLong(rm, -tiny);" + , " assert(positive == ((rm == SBV_RM_RNA || rm == SBV_RM_RTP) ? tiny : 0));" + , " assert(negative == ((rm == SBV_RM_RNA || rm == SBV_RM_RTN) ? -tiny : 0));" + , " assert(signbit(negative));" + , " assert(narrowFloat(rm, 1.0L + 0x1p-24L) == ((rm == SBV_RM_RNA || rm == SBV_RM_RTP) ? 0x1.000002p0f : 1.0f));" + , " mpz_set_ui(input, 1); mpz_mul_2exp(input, input, LDBL_MAX_EXP);" + , " const long double large = roundedInteger(rm, input);" + , " assert(large == ((rm == SBV_RM_RTZ || rm == SBV_RM_RTN) ? LDBL_MAX : HUGE_VALL));" + , " mpz_neg(input, input); const long double small = roundedInteger(rm, input);" + , " assert(small == ((rm == SBV_RM_RTZ || rm == SBV_RM_RTP) ? -LDBL_MAX : -HUGE_VALL));" + , " }" + , " assert(nativeRoundTrip(DBL_MAX) == DBL_MAX); assert(signbit(nativeRoundTrip(-0.0)));" + , " assert(isinf(nativeRoundTrip(HUGE_VAL))); assert(isnan(nativeRoundTrip(NAN)));" + , " mpz_clears(input, output, NULL); return 0;" + , "}" + ] + writeFile (dir "caller.mk") $ unlines + [ "caller: caller.c longBridges.h longBridges.a" + , "\t${CC} ${CCFLAGS} ${GMP_CFLAGS} caller.c longBridges.a ${LDFLAGS} ${SBV_LIBS} -o $@" + ] + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, "caller"] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (runExit, _, runError) <- readProcessWithExitCode (dir "caller") [] "" + assertEqual runError ExitSuccess runExit + (invalidExit, _, invalidError) <- readProcessWithExitCode (dir "caller") ["nonfinite"] "" + assertBool "Non-finite real flooring must terminate" (invalidExit /= ExitSuccess) + assertBool invalidError ("Cannot convert a non-finite mapped SReal to exact SInteger" `isInfixOf` invalidError) + +-- | Simulate an unsupported double-double target format at the generated +-- translation unit's feature check, without pretending to execute that ABI. +unsupportedLongDoubleFormat :: Assertion +unsupportedLongDoubleFormat = withSystemTempDirectory "sbv-long-double-format" $ \dir -> do + D.compileToC (Just dir) "unsupportedLongDouble" $ do + cgOverwriteFiles True + cgGenerateDriver False + cgSRealType CgLongDouble + cgAddDecl ["#include ", "#undef LDBL_MANT_DIG", "#define LDBL_MANT_DIG 106"] + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (toSFloatingPoint sRNE value :: SFPHalf) + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, "unsupportedLongDouble.o"] ++ makeOptions) "" + assertBool "Unsupported long-double formats must not compile" (buildExit /= ExitSuccess) + assertBool buildError ("long-double conversions require binary64, x87 extended, or binary128" `isInfixOf` buildError) + +-- | Exercise LibBF encoding of subnormal results, NaN, and signed zero. +arbitraryFloatSpecialArithmetic :: Assertion +arbitraryFloatSpecialArithmetic = withSystemTempDirectory "sbv-arbitrary-float-special" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x0001, 0x7c00, 0x8000, 5, 2] + subBits <- cgInput "subnormalBits" :: SBVCodeGen (SWord 16) + infBits <- cgInput "infinityBits" :: SBVCodeGen (SWord 16) + nzBits <- cgInput "negativeZeroBits" :: SBVCodeGen (SWord 16) + five <- cgInput "five" :: SBVCodeGen SFPHalf + two <- cgInput "two" :: SBVCodeGen SFPHalf + let subnormal = sWordAsSFloatingPoint subBits :: SFPHalf + infValue = sWordAsSFloatingPoint infBits :: SFPHalf + negativeZero = sWordAsSFloatingPoint nzBits :: SFPHalf + doubled = rawHalf (fpAdd sRNE subnormal subnormal) + nanResult = rawHalf (fpSub sRNE infValue infValue) + zeroResult = rawHalf (fpSqrt sRNE negativeZero) + remResult = rawHalf (fpRem five two) + roundResult = rawHalf (fpRoundToIntegral sRNE (fpDiv sRNE five two)) + minResult = rawHalf (fpMin five two) + maxResult = rawHalf (fpMax five two) + absResult = rawHalf (abs (negate five)) + cgReturn (doubled # nanResult # zeroResult # remResult # roundResult # minResult # maxResult # absResult :: SWord 128) + expected = foldl (\acc word -> acc * 2 ^ (16 :: Int) + word) 0 [0x0002, 0x7e00, 0x8000, 0x3c00, 0x4000, 0x4000, 0x4500, 0x4500] + compileAndRunLibBF dir "arbitraryFloatSpecialArithmetic" program (asHex 2 expected) + where rawHalf :: SFPHalf -> SWord 16 + rawHalf = sFloatingPointAsSWord + +-- | Exercise a finite table containing computed arbitrary-precision floating +-- point values. The table is emitted after the computation on which it +-- depends and its result remains an ordinary by-value interchange object. +arbitraryFloatTableLookup :: Assertion +arbitraryFloatTableLookup = withSystemTempDirectory "sbv-arbitrary-float-table" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs True + cgSetDriverValues [1, 3] + index <- cgInput "index" :: SBVCodeGen SWord8 + value <- cgInput "value" :: SBVCodeGen SFPQuad + let selected = select [value, fpAdd sRNE value 2] 99 index + cgReturn (sFloatingPointAsSWord selected :: SWord 128) + bias = 2 ^ (14 :: Int) - 1 :: Integer + fiveRaw = (bias + 2) * 2 ^ (112 :: Int) + 2 ^ (110 :: Int) + compileAndRunLibBF dir "arbitraryFloatTableLookup" program (asHex 2 fiveRaw) + +-- | Check that LibBF-backed array keys use SMT object equality: NaNs match, +-- while positive and negative zero remain distinct. +arbitraryFloatArrayKeys :: Assertion +arbitraryFloatArrayKeys = withSystemTempDirectory "sbv-arbitrary-float-array-keys" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x7e00, 0x0000, 0x8000] + nanBits <- cgInput "nanBits" :: SBVCodeGen (SWord 16) + positiveBits <- cgInput "positiveBits" :: SBVCodeGen (SWord 16) + negativeBits <- cgInput "negativeBits" :: SBVCodeGen (SWord 16) + let nanKey = sWordAsSFloatingPoint nanBits :: SFPHalf + positiveZero = sWordAsSFloatingPoint positiveBits :: SFPHalf + negativeZero = sWordAsSFloatingPoint negativeBits :: SFPHalf + base = constArray 3 + withNaN = writeArray base nanKey 11 + withZero = writeArray withNaN positiveZero 12 + flags = [ readArray withZero nanKey .== (11 :: SWord8) + , readArray withZero positiveZero .== (12 :: SWord8) + , readArray withZero negativeZero .== (3 :: SWord8) + ] + cgReturn (sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4]) :: SWord8) + compileAndRunLibBF dir "arbitraryFloatArrayKeys" program "= 7" + +-- | Exercise a callback-backed array whose returned values use LibBF's raw +-- arbitrary floating-point interchange representation. +arbitraryFloatArrayInput :: Assertion +arbitraryFloatArrayInput = withSystemTempDirectory "sbv-arbitrary-float-array-input" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 7] + source <- cgInput "source" :: SBVCodeGen (SArray Word8 (FloatingPoint 15 113)) + key <- cgInput "key" :: SBVCodeGen SWord8 + cgReturn (sFloatingPointAsSWord (readArray source key) :: SWord 128) + bias = 2 ^ (14 :: Int) - 1 :: Integer + threeRaw = (bias + 1) * 2 ^ (112 :: Int) + 2 ^ (111 :: Int) + compileAndRunLibBF dir "arbitraryFloatArrayInput" program (asHex 2 threeRaw) + +-- | Exercise a LibBF conversion that occurs only inside a retained array +-- lambda, ensuring its format-specific runtime helper is still discovered. +arbitraryFloatLambdaArray :: Assertion +arbitraryFloatLambdaArray = withSystemTempDirectory "sbv-arbitrary-float-lambda-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3] + key <- cgInput "key" :: SBVCodeGen SWord8 + let source = lambdaArray (\index -> toSFloatingPoint sRNE index :: SFloatingPoint 15 113) + :: SArray Word8 (FloatingPoint 15 113) + cgReturn (sFloatingPointAsSWord (readArray source key) :: SWord 128) + bias = 2 ^ (14 :: Int) - 1 :: Integer + threeRaw = (bias + 1) * 2 ^ (112 :: Int) + 2 ^ (111 :: Int) + compileAndRunLibBF dir "arbitraryFloatLambdaArray" program (asHex 2 threeRaw) + +-- | Exercise LibBF-valued table entries constructed from a structured +-- lambda's parameter and selected entirely inside its retained DAG. +arbitraryFloatLambdaTable :: Assertion +arbitraryFloatLambdaTable = withSystemTempDirectory "sbv-arbitrary-float-lambda-table" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + key <- cgInput "key" :: SBVCodeGen SWord8 + let source = lambdaArray (\index -> select [toFP index, fpAdd sRNE (toFP index) 1] 0 index) + :: SArray Word8 (FloatingPoint 15 113) + cgReturn (sFloatingPointAsSWord (readArray source key) :: SWord 128) + toFP value = toSFloatingPoint sRNE value :: SFloatingPoint 15 113 + bias = 2 ^ (14 :: Int) - 1 :: Integer + twoRaw = (bias + 1) * 2 ^ (112 :: Int) + compileAndRunLibBF dir "arbitraryFloatLambdaTable" program (asHex 2 twoRaw) + +-- | Exercise correctly rounded conversions between LibBF formats and +-- GMP-backed unbounded integers and rational reals. +arbitraryFloatExactConversions :: Assertion +arbitraryFloatExactConversions = withSystemTempDirectory "sbv-arbitrary-float-exact" $ \dir -> do + let largeSample = negate (2 ^ (200 :: Int) + 2 ^ (100 :: Int)) + program = do + cgOverwriteFiles True + cgSetDriverValues [2049, largeSample, 7, 2, 5, 2] + integer <- cgInput "integer" :: SBVCodeGen SInteger + largeInteger <- cgInput "largeInteger" :: SBVCodeGen SInteger + realNumerator <- cgInput "numerator" :: SBVCodeGen SReal + realDenominator <- cgInput "denominator" :: SBVCodeGen SReal + five <- cgInput "five" :: SBVCodeGen SFPHalf + two <- cgInput "two" :: SBVCodeGen SFPHalf + let rational = realNumerator / realDenominator + integerRNE = toSFloatingPoint sRNE integer :: SFPHalf + integerRTP = toSFloatingPoint sRTP integer :: SFPHalf + largeQuad = toSFloatingPoint sRNE largeInteger :: SFPQuad + largeRoundTrip = fromSFloatingPoint sRNE largeQuad :: SInteger + rationalHalf = toSFloatingPoint sRNE rational :: SFPHalf + twoAndAHalf = fpDiv sRNE five two + roundedEven = fromSFloatingPoint sRNE twoAndAHalf :: SInteger + roundedAway = fromSFloatingPoint sRNA twoAndAHalf :: SInteger + roundedUp = fromSFloatingPoint sRTP twoAndAHalf :: SInteger + roundedDown = fromSFloatingPoint sRTN twoAndAHalf :: SInteger + roundedZero = fromSFloatingPoint sRTZ twoAndAHalf :: SInteger + exactRational = fromSFloatingPoint sRNE rationalHalf :: SReal + integerRNEBits = sFloatingPointAsSWord integerRNE :: SWord 16 + integerRTPBits = sFloatingPointAsSWord integerRTP :: SWord 16 + cgReturn $ integerRNEBits .== 0x6800 + .&& integerRTPBits .== 0x6801 + .&& largeRoundTrip .== largeInteger + .&& rationalHalf .== 3.5 + .&& roundedEven .== 2 + .&& roundedAway .== 3 + .&& roundedUp .== 3 + .&& roundedDown .== 2 + .&& roundedZero .== 2 + .&& exactRational .== 7 / 2 + compileAndRunLibBFGMP dir "arbitraryFloatExactConversions" program "= 1" + +-- | Exercise repeated declarations and dependencies in a mixed generated library. +mixedRepeatedTypeLibrary :: Assertion +mixedRepeatedTypeLibrary = withSystemTempDirectory "sbv-mixed-repeated-library" $ \dir -> do + let configure values = do + cgOverwriteFiles True + cgSetDriverValues values + + wideAddProgram = do + configure [5] + value <- cgInput "value" :: SBVCodeGen (SWord 673) + cgReturn (value + 1) + + wideXorProgram = do + configure [7] + value <- cgInput "value" :: SBVCodeGen (SWord 673) + cgReturn (value `xor` 3) + + fpDivideProgram = do + configure [2, 1, 3] + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + value <- cgInput "value" :: SBVCodeGen SFPHalf + three <- cgInput "three" :: SBVCodeGen SFPHalf + cgReturn (fpDiv mode value three) + + fpDivideAgainProgram = do + configure [3, 1, 3] + mode <- cgInput "mode" :: SBVCodeGen SRoundingMode + value <- cgInput "value" :: SBVCodeGen SFPHalf + three <- cgInput "three" :: SBVCodeGen SFPHalf + cgReturn (fpDiv mode value three) + + integerAddProgram = do + configure [2 ^ (130 :: Int)] + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (value + 7) + + integerMulProgram = do + configure [9] + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (value * 3) + + realDivideProgram = do + configure [5] + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (value / 3) + + realAddProgram = do + configure [2] + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (value + 1 / 7) + + components = [ ("wideAdd", wideAddProgram) + , ("wideXor", wideXorProgram) + , ("fpDivide", fpDivideProgram) + , ("fpDivideAgain", fpDivideAgainProgram) + , ("integerAdd", integerAddProgram) + , ("integerMul", integerMulProgram) + , ("realDivide", realDivideProgram) + , ("realAdd", realAddProgram) + ] + + (_, cfg, bundle) <- compileToCLib' "mixedRepeatedTypeLibrary" components + renderCgPgmBundle (Just dir) (cfg, bundle) + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + + let driverExecutable = dir "mixedRepeatedTypeLibrary_driver" + (runExit, stdoutText, runError) <- readProcessWithExitCode driverExecutable [] "" + assertEqual runError ExitSuccess runExit + mapM_ (assertOutput stdoutText) + [ asHex 11 6 + , asHex 11 4 + , "0x0000000000003556" + , "0x0000000000003555" + , show (2 ^ (130 :: Int) + 7 :: Integer) + , "27" + , "5/3" + , "15/7" + ] + + makefile <- readFile (dir "Makefile") + assertBool "Mixed library Makefile lost the LibBF dependency" ("-lbf" `isInfixOf` makefile) + assertBool "Mixed library Makefile lost the GMP dependency" ("${GMP_LIBS}" `isInfixOf` makefile) + where assertOutput stdoutText fragment = + assertBool ("Expected generated library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText) + +-- | Exercise archive-only generation with a type shared across translation units. +repeatedTypeLibraryWithoutDriver :: Assertion +repeatedTypeLibraryWithoutDriver = withSystemTempDirectory "sbv-repeated-library-no-driver" $ \dir -> do + let component operation = do + cgOverwriteFiles True + cgGenerateDriver False + value <- cgInput "value" :: SBVCodeGen (SWord 673) + cgReturn (operation value) + components = [ ("increment", component (+ 1)) + , ("decrement", component (subtract 1)) + ] + + (_, cfg, bundle) <- compileToCLib' "repeatedTypeLibraryWithoutDriver" components + renderCgPgmBundle (Just dir) (cfg, bundle) + + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + archiveExists <- doesFileExist (dir "repeatedTypeLibraryWithoutDriver.a") + driverExists <- doesFileExist (dir "repeatedTypeLibraryWithoutDriver_driver.c") + assertBool "Generated library archive is missing" archiveExists + assertBool "Driver generation was disabled, but a driver was emitted" (not driverExists) + +-- | Generate and execute a C program linked to the LibBF bundled with the +-- Haskell @libBF@ package. +compileAndRunLibBF :: FilePath -> String -> SBVCodeGen () -> String -> Assertion +compileAndRunLibBF dir functionName program expected = do + (includeDir, archive) <- locateLibBF + compileAndRunWith ["-I" ++ includeDir, archive, "-lm"] dir functionName program expected + +-- | Generate and execute a C program using both LibBF and GMP. +compileAndRunLibBFGMP :: FilePath -> String -> SBVCodeGen () -> String -> Assertion +compileAndRunLibBFGMP dir functionName program expected = do + (includeDir, archive) <- locateLibBF + (pkgExit, pkgOutput, pkgError) <- readProcessWithExitCode "pkg-config" ["--cflags", "--libs", "gmp"] "" + assertEqual pkgError ExitSuccess pkgExit + compileAndRunWith (["-I" ++ includeDir, archive, "-lm"] ++ words pkgOutput) dir functionName program expected + +-- | Generate, compile, and execute C with additional compiler/linker options. +-- @SBV_C_TEST_FLAGS@ supplies extra flags for optimization and sanitizer runs. +compileAndRunWith :: [String] -> FilePath -> String -> SBVCodeGen () -> String -> Assertion +compileAndRunWith ccOptions dir functionName program expected = do + (_, cfg, bundle) <- compileToC' functionName program + renderCgPgmBundle (Just dir) (cfg, bundle) + + out <- compileAndRunGenerated ccOptions dir functionName + assertBool ("Expected generated output to contain " ++ expected ++ ", received:\n" ++ out) (expected `isInfixOf` out) + +-- | Exercise a generated native ABI from an independent caller, linked with +-- LibBF. Enable dynamic rounding for callers that modify the floating-point +-- environment; the caller reports failure through its exit status. +compileAndRunLibBFCaller :: FilePath -> String -> SBVCodeGen () -> String -> Assertion +compileAndRunLibBFCaller dir functionName program caller = do + (includeDir, archive) <- locateLibBF + (_, cfg, bundle) <- compileToC' functionName program + renderCgPgmBundle (Just dir) (cfg, bundle) + writeFile (dir functionName ++ "_driver.c") caller + _ <- compileAndRunGenerated ["-frounding-math", "-I" ++ includeDir, archive, "-lm"] dir functionName + pure () + +-- | Compile and run an already rendered program and driver. Honor optional +-- optimization and sanitizer flags supplied by @SBV_C_TEST_FLAGS@. +compileAndRunGenerated :: [String] -> FilePath -> String -> IO String +compileAndRunGenerated ccOptions dir functionName = do + let source = dir functionName ++ ".c" + driver = dir functionName ++ "_driver.c" + exe = dir functionName ++ "_driver" + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + (ccExit, _, ccErr) <- readProcessWithExitCode "cc" (["-std=c11", "-Wall", "-Werror", source, driver, "-o", exe] ++ extraFlags ++ ccOptions) "" + assertEqual ccErr ExitSuccess ccExit + + (runExit, out, runErr) <- readProcessWithExitCode exe [] "" + assertEqual runErr ExitSuccess runExit + pure out + +-- | Render the fixed-limb hexadecimal form printed by generated drivers. +asHex :: Int -> Integer -> String +asHex limbCount value = "0x" ++ replicate (16 * limbCount - length h) '0' ++ h + where h = showHex value "" diff --git a/SBVTestSuite/TestSuite/CodeGeneration/ArrayCaptures.hs b/SBVTestSuite/TestSuite/CodeGeneration/ArrayCaptures.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/ArrayCaptures.hs @@ -0,0 +1,119 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.ArrayCaptures +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Reject unsupported array-lambda captures before emitting C artifacts. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.ArrayCaptures (tests) where + +import Control.Exception (ErrorCall, displayException, try) +import Control.Monad (void) +import Data.List (isInfixOf) +import System.Directory (listDirectory) +import System.IO.Temp (withSystemTempDirectory) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Tools.CodeGen +import Utils.SBVTestFramework + +-- | Captures in ordinary and operator-embedded operands must fail clearly, +-- including in nested callbacks and library components. Existing frontend +-- restrictions remain in place; closed callbacks remain supported. +tests :: TestTree +tests = testGroup "CodeGeneration.ArrayCaptures" + [ rejects "direct result capture" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (const value) :: SArray Word8 Word32) + , rejects "arithmetic capture" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (+ value) :: SArray Word32 Word32) + , rejects "managed value capture" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen SString + cgReturn (lambdaArray (const value) :: SArray Word8 String) + , rejects "array descriptor capture" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen (SArray Word32 Word32) + cgReturn (lambdaArray (readArray value) :: SArray Word32 Word32) + , rejects "table entry capture" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (select [value, 17] 0) :: SArray Word8 Word32) + , rejects "table default capture" captureDiagnostic $ do + cgPerformRTCs True + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (select [3, 17] value) :: SArray Word8 Word32) + , rejects "unchecked table default capture" captureDiagnostic $ do + cgPerformRTCs False + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (select [3, 17] value) :: SArray Word8 Word32) + , rejects "rounding-mode operand capture" captureDiagnostic $ do + rounding <- cgInput "rounding" :: SBVCodeGen SRoundingMode + cgReturn (lambdaArray (toSFloat rounding) :: SArray Word32 Float) + , rejects "capture hidden in nested array" captureDiagnostic $ do + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (\_ -> lambdaArray (+ value)) :: SArray Word8 (ArrayModel Word32 Word32)) + , rejects "nested parameter hidden in a rounding-mode operand" captureDiagnostic $ + cgReturn (lambdaArray (lambdaArray . toSFloat) :: SArray RoundingMode (ArrayModel Word32 Float)) + , rejects "defined-function parameter hidden in a rounding-mode operand" captureDiagnostic $ do + rounding <- cgInput "rounding" :: SBVCodeGen SRoundingMode + cgReturn (smtFunction "rounding array" (\mode -> lambdaArray (toSFloat mode) :: SArray Word32 Float) rounding) + , rejects "nested parameter capture remains frontend-rejected" "Detected free variables passed to a lambda" $ + cgReturn (lambdaArray (\outer -> lambdaArray (+ outer)) :: SArray Word32 (ArrayModel Word32 Word32)) + , rejects "defined-function parameter capture remains frontend-rejected" "Detected free variables passed to a lambda" $ do + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (smtFunction "capturing array" (\offset -> lambdaArray (+ offset) :: SArray Word32 Word32) value) + , testCase "library rejects captures without writing earlier components" libraryCapture + , testCase "closed nested callbacks with literal constants still compile" closedArrays + ] + +-- | Stable user-facing diagnostic shared by all C-side capture failures. +captureDiagnostic :: String +captureDiagnostic = "Array lambdas that capture outer symbolic values are not supported" + +-- | A failed standalone generation must create no files and must not expose +-- the scheduler's internal missing-assignment error as its capture diagnostic. +rejects :: String -> String -> SBVCodeGen () -> TestTree +rejects testName diagnostic program = testCase testName $ + withSystemTempDirectory "sbv-c-array-capture-rejection" $ \dir -> do + result <- try (compileToC (Just dir) "capturingArray" (cgGenerateDriver False >> program)) :: IO (Either ErrorCall ()) + checkRejection diagnostic result + assertEqual "Rejected generation must not create files" [] =<< listDirectory dir + +-- | Keep whole-library preflight atomic even when a valid component precedes +-- the component with an unsupported capture. +libraryCapture :: Assertion +libraryCapture = withSystemTempDirectory "sbv-c-array-capture-library" $ \dir -> do + let closed = cgGenerateDriver False >> cgReturn (lambdaArray (+ 3) :: SArray Word32 Word32) + capturing = do + cgGenerateDriver False + value <- cgInput "value" :: SBVCodeGen SWord32 + cgReturn (lambdaArray (+ value) :: SArray Word32 Word32) + result <- try (void $ compileToCLib (Just dir) "captureLibrary" [("closedArray", closed), ("capturingArray", capturing)]) + checkRejection captureDiagnostic result + assertEqual "Rejected library must not create any component files" [] =<< listDirectory dir + +-- | Check the explicit unsupported boundary instead of accepting any failure. +checkRejection :: String -> Either ErrorCall () -> Assertion +checkRejection diagnostic result = case result of + Left err -> do + let message = displayException err + assertBool message (diagnostic `isInfixOf` message) + assertBool "Capture diagnostics must not expose an internal scheduling failure" + (not ("Missing assignment" `isInfixOf` message)) + Right () -> assertFailure "Expected generation to reject an array-lambda capture" + +-- | Haskell lexical bindings that contain only literal constants do not +-- require a runtime environment, nor does nesting otherwise closed lambdas. +closedArrays :: Assertion +closedArrays = withSystemTempDirectory "sbv-c-closed-array-lambdas" $ \dir -> do + compileToC (Just dir) "closedArrays" $ do + cgOverwriteFiles True + cgGenerateDriver False + let offset = literal (3 :: Word32) + cgReturn (lambdaArray (\_ -> lambdaArray (+ offset)) :: SArray Word8 (ArrayModel Word32 Word32)) + assertBool "Closed callbacks still produce C artifacts" . not . null =<< listDirectory dir diff --git a/SBVTestSuite/TestSuite/CodeGeneration/Boundaries.hs b/SBVTestSuite/TestSuite/CodeGeneration/Boundaries.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/Boundaries.hs @@ -0,0 +1,142 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.Boundaries +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Executable contracts for deliberately unsupported C-backend features. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE EmptyDataDecls #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.Boundaries (tests) where + +import Control.Exception (ErrorCall, displayException, try) +import Control.Monad (void) +import Data.List (isInfixOf) +import System.Directory (listDirectory) +import System.IO.Temp (withSystemTempDirectory) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Internals (AlgRealPoly(..)) +import Data.SBV.Control (SMTOption(..)) +import qualified Data.SBV.List as SL +import Data.SBV.Tools.CodeGen +import Utils.SBVTestFramework + +-- | An abstract solver sort deliberately lacking a C representation. +data Opaque + +-- | Recursive references hidden inside a by-value tuple cannot have a finite C layout. +data NestedRecursion = EndRecursion | NestedRecursion (Word8, NestedRecursion) + +mkSymbolic [''Opaque, ''NestedRecursion] + +-- | Every rejected feature is checked through both public entry points; +-- library failures must not leave even an earlier, valid component behind. +tests :: TestTree +tests = testGroup "CodeGeneration.Boundaries" + [ rejects "uninterpreted sort" "uninterpreted sorts" $ do + value <- cgInput "value" :: SBVCodeGen (SBV Opaque) + cgReturn value + , rejects "nested recursive ADT" "Recursive ADT references nested inside composite fields" $ do + value <- cgInput "value" :: SBVCodeGen (SBV NestedRecursion) + cgReturn value + , rejects "solver option" "SMT solver options have no executable C semantics" $ do + setOption (ProduceAssertions True) + cgReturn sTrue + , rejects "solver option through cgSym" "SMT solver options have no executable C semantics" $ do + cgSym $ setOption (ProduceAssertions True) + cgReturn sTrue + , rejects "nested uninterpreted sort" "uninterpreted sorts" $ do + value <- cgInput "value" :: SBVCodeGen (SList (Maybe Opaque)) + cgReturn value + , rejects "finite quantifier" "quantified" $ do + value <- cgInput "value" :: SBVCodeGen SBool + cgReturn (quantifiedBool (\(Forall b) -> b .|| value)) + , rejects "infinite quantifier" "quantified" $ do + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (quantifiedBool (\(Forall n) -> n .>= value)) + , rejects "quantifier in private function" "quantified" $ do + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (smtFunction "quantifiedFunction" (\v -> quantifiedBool (\(Forall n) -> n .>= v)) value) + , rejects "quantifier in array lambda" "quantified" $ + cgReturn (lambdaArray (\v -> quantifiedBool (\(Forall n) -> n .>= v)) :: SArray Integer Bool) + , rejects "special relation" "special relations" $ + cgReturn (isPartialOrder "order" (uncurry ((.<=) :: SInteger -> SInteger -> SBool))) + , rejects "soft constraint" "Soft constraints" $ do + value <- cgInput "value" :: SBVCodeGen SBool + softConstrain value + cgReturn value + , rejects "SMT-only constraint attribute" "Constraint attributes: :weight" $ do + value <- cgInput "value" :: SBVCodeGen SBool + constrainWithAttribute [(":weight", "2")] value + cgReturn value + , rejects "minimize" "Optimization objectives require a solver" $ do + value <- cgInput "value" :: SBVCodeGen SInteger + cgSym $ minimize "minimum" value + cgReturn value + , rejects "maximize" "Optimization objectives require a solver" $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgSym $ maximize "maximum" value + cgReturn value + , rejects "implicit higher-order capture" "Defined functions with implicit captures" $ do + offset <- cgInput "offset" :: SBVCodeGen SInteger + values <- cgInput "values" :: SBVCodeGen (SList Integer) + cgReturn (SL.map (+ offset) values) + , rejects "implicit managed higher-order capture" "Defined functions with implicit captures" $ do + offset <- cgInput "offset" :: SBVCodeGen SString + values <- cgInput "values" :: SBVCodeGen (SList String) + cgReturn (SL.map (.== offset) values) + , rejects "penalized assertion" "Optimization objectives require a solver" $ do + value <- cgInput "value" :: SBVCodeGen SBool + cgSym $ assertWithPenalty "penalty" value DefaultPenalty + cgReturn value + , rejects "algebraic real literal" "Algebraic SReal literals" $ cgReturn (literal algebraic) + , rejects "nested algebraic real literal" "Algebraic SReal literals" $ cgReturn (literal [algebraic]) + , rejects "mapped algebraic real literal" "Algebraic SReal literals" $ cgSRealType CgDouble >> cgReturn (literal algebraic) + , rejects "inexact real literal" "Inexact SReal literals" $ cgReturn (literal (AlgRational False (1 / 3))) + , rejects "exact transcendental" "exact GMP-rational SReal representation cannot represent" $ do + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (sin value) + , rejects "private exact transcendental" "exact GMP-rational SReal representation cannot represent" $ do + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (smtFunction "exactSine" sin value) + , rejects "sparse infinite-domain equality" "cannot enumerate key domain" $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + let base = constArray 0 :: SArray Integer Word8 + cgReturn (writeArray base 1 value .== writeArray base 2 value) + ] + +-- | The positive square root of two, represented without an approximation. +algebraic :: AlgReal +algebraic = AlgPolyRoot (2, AlgRealPoly [(1, 2), (-2, 0)]) Nothing + +-- | Check an intentional diagnostic, not just any exception, and ensure that +-- validation completes before standalone or library output is written. +rejects :: String -> String -> SBVCodeGen () -> TestTree +rejects testName diagnostic program = testGroup testName + [ testCase mode $ withSystemTempDirectory "sbv-c-boundary" $ \dir -> do + let prepare body = cgGenerateDriver False >> cgOverwriteFiles True >> body + action | library = void $ compileToCLib (Just dir) "rejectedLibrary" + [("validComponent", prepare (cgReturn sTrue)), ("rejectedComponent", prepare program)] + | True = compileToC (Just dir) "rejectedComponent" (prepare program) + result <- try action :: IO (Either ErrorCall ()) + case result of + Left exception -> do + let message = displayException exception + assertBool message (diagnostic `isInfixOf` message) + assertBool message (not (any (`isInfixOf` message) ["Unexpected:", "Missing assignment", "Impossible happened"])) + Right () -> assertFailure "Expected an explicit unsupported-feature diagnostic" + assertEqual "Rejected generation must not write any files" [] =<< listDirectory dir + | (mode, library) <- [("standalone", False), ("library", True)] + ] diff --git a/SBVTestSuite/TestSuite/CodeGeneration/CgTests.hs b/SBVTestSuite/TestSuite/CodeGeneration/CgTests.hs --- a/SBVTestSuite/TestSuite/CodeGeneration/CgTests.hs +++ b/SBVTestSuite/TestSuite/CodeGeneration/CgTests.hs @@ -9,37 +9,5074 @@ -- Test suite for code-generation features ----------------------------------------------------------------------------- -{-# LANGUAGE ScopedTypeVariables #-} - -{-# OPTIONS_GHC -Wall -Werror #-} - -module TestSuite.CodeGeneration.CgTests(tests) where - -import Data.SBV.Internals - -import Utils.SBVTestFramework - --- Test suite -tests :: TestTree -tests = testGroup "CodeGeneration.CgTests" [ - goldenVsStringShow "selChecked" $ genSelect True "selChecked" - , goldenVsStringShow "selUnchecked" $ genSelect False "selUnChecked" - , goldenVsStringShow "codeGen1" foo - ] - where thd (_, _, r) = r - - genSelect b n = thd <$> 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 = thd <$> 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)) +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.CgTests(tests) where + +import Control.Exception (ErrorCall, displayException, evaluate, try) +import Control.DeepSeq (force) +import Control.Monad (forM, forM_, unless, void, when) +import qualified Data.Bifunctor as B +import Data.List (isInfixOf) +import Data.Proxy (Proxy(..)) +import Data.SBV.Internals +import Data.SBV.Tools.CodeGen (compileToC, compileToCLib) +import qualified Data.SBV.Char as SC +import qualified Data.SBV.List as SL +import qualified Data.SBV.Set as SS +import Data.SBV.Tuple (tuple, untuple) +import qualified Data.SBV.Tools.CodeGen.Legacy as PublicLegacy + +import System.Directory (listDirectory) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) + +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Utils.SBVTestFramework +import Utils.CCodeGen (generatedMakeOptions) + +-- | A non-recursive, parameterized sum type used to exercise C tagged-union +-- generation with nullary, unary, and product constructors. +data CodeGenADT a = CGEmpty + | CGOne a + | CGPair a Word16 + deriving Show + +-- | A finite enumeration used to check that constructor order is preserved by +-- the C tag representation. +data CodeGenEnum = CGRed | CGGreen | CGBlue deriving (Eq, Ord, Show) + +-- | An acyclic parameterized ADT reference used to exercise 'KApp' +-- resolution and dependency-ordered C declarations. +data CodeGenEnvelope a = CGNoEnvelope | CGEnvelope (CodeGenADT a) deriving Show + +-- | A recursive type used to verify the current C ABI boundary. +data CodeGenTree = CGLeaf Word8 | CGNode CodeGenTree CodeGenTree deriving (Eq, Ord, Show) + +-- | An acyclic wrapper around a recursive value, used to check transitive +-- ownership without changing its embedded by-value layout. +newtype CodeGenForest = CGForest CodeGenTree deriving Show + +-- | The even layer of a mutually recursive pair used to exercise C forward +-- declarations and cross-type ownership helpers. +data CodeGenEven = CGEvenEnd Word8 | CGEvenStep CodeGenOdd deriving Show + +-- | The odd layer of the mutually recursive code-generation test pair. +newtype CodeGenOdd = CGOddStep CodeGenEven deriving Show + +-- | A recursive type with no finite inhabitant, used to check generated-driver +-- diagnostics. +newtype CodeGenLoop = CGLoop CodeGenLoop deriving Show + +-- | A managed aggregate used to exercise direct and tuple-nested collection +-- fields in generated C ADTs. +data CodeGenCollections = CGNoCollections + | CGCollections [Integer] (RCSet Rational) ([Integer], RCSet Rational) + deriving Show + +-- | A managed aggregate used to exercise native-width collection ownership +-- without relying on exact-element storage to select the owned ABI. +data CodeGenNativeCollections = CGNativeCollections [Word16] (RCSet Word16) deriving Show + +-- | A managed aggregate used to exercise direct text fields and collections +-- whose elements are strings. +data CodeGenText = CGText String [String] (RCSet String) deriving Show + +-- | An aggregate used to exercise retained array fields in generated C ADTs. +data CodeGenArrayBox = CGArrayBox (ArrayModel Word8 Word32) Word8 deriving Show + +-- | An ADT that hides an array-owning ADT behind an intermediate tuple. +newtype CodeGenArrayEnvelope = CGArrayEnvelope (CodeGenArrayBox, Word16) deriving Show + +-- | A recursive managed aggregate whose leaf owns exact-element collections. +data CodeGenCollectionTree = CGCollectionLeaf [Integer] (RCSet Rational) + | CGCollectionBranch CodeGenCollectionTree + deriving Show + +-- | A recursive type whose spelling differs from 'CodeGenCASE' only in case. +data CodeGenCase = CGCaseLeaf Word8 | CGCaseNext CodeGenCase deriving (Eq, Ord, Show) + +-- | The case-sensitive companion used to expose collisions in generated +-- declaration guards, constructor tags, and transitive collection helpers. +data CodeGenCASE = CGCASELeaf Word8 | CGCASENext CodeGenCASE deriving (Eq, Ord, Show) + +-- | Generate the symbolic interfaces for the code-generation ADTs. +mkSymbolic [''CodeGenADT, ''CodeGenEnum, ''CodeGenEnvelope, ''CodeGenTree, ''CodeGenForest, ''CodeGenEven, ''CodeGenOdd, ''CodeGenLoop, ''CodeGenCollections, ''CodeGenNativeCollections, ''CodeGenText, ''CodeGenArrayBox, ''CodeGenArrayEnvelope, ''CodeGenCollectionTree, ''CodeGenCase, ''CodeGenCASE] + +-- | Code-generation tests. +tests :: TestTree +tests = testGroup "CodeGeneration.CgTests" + [ goldenVsStringShow "selChecked" $ genSelect True "selChecked" + , goldenVsStringShow "selUnchecked" $ genSelect False "selUnChecked" + , goldenVsStringShow "codeGen1" foo + , testCase "compile through the public legacy facade" legacyPublicFacade + , testCase "execute guarded pseudo-Boolean reductions in functions and array lambdas" scopedPseudoBoolean + , testCase "floor long doubles inside functions and array lambdas" scopedMappedRealFloor + , testCase "collect C runtime requirements" dependencyRequirements + , testCase "escape assertion messages in generated C" escapedAssertionMessages + , escapedValueLabels + , testCase "execute IEEE native floating-point remainders" nativeFloatingRemainders + , testCase "declare rounding modes in nested collections" collectionRoundingModes + , testCase "relink library drivers after component changes" libraryDriverDependencies + , arrayCollectionComparisons + , testCase "preserve external prototypes in libraries" libraryExternalPrototypes + , testCase "reject empty or conflicting libraries before rendering" libraryValidation + , testCase "terminate on failed library preconditions and assertions" libraryRuntimeFailures + , testCase "reject invalid and reserved public C names before rendering" publicCNameValidation + , testCase "preserve public C names without local collisions" privateCBindings + , testCase "preserve case through ADTs and structural type guards" caseSensitiveCKinds + , testCase "frame nested array key and value type names" structuralCNameFraming + , testCase "honor ownership across independent C library calls" libraryOwnershipContract + , testCase "compare finite ADT set universes" finiteADTSetUniverses + , testCase "compile exact symbolic rationals" exactSymbolicRationals + , testCase "compile rationals with mapped integers" mappedIntegerRationals + , testCase "compile divisibility with mapped integers" mappedIntegerDivisibility + , testCase "compile mapped real non-linear operations" mappedRealNonLinearOperations + , testCase "compile mapped integer exponentiation" mappedIntegerExponentiation + , testCase "execute mapped integer arithmetic at every native width" mappedIntegerArithmetic + , testCase "reject non-linear exact real operations" exactRealNonLinearDiagnostic + , testCase "compile repeated exact rationals into a library" exactRationalLibrary + , testCase "compile and execute persistent arrays" persistentArrays + , testCase "compare finite arrays including callback and defined-function values" finiteArrayEquality + , testCase "configure finite array equality limits" finiteArrayEqualityLimits + , testCase "enumerate scalar and aggregate finite array keys" finiteArrayKeyKinds + , testCase "observe finite array callback coverage and short circuiting" finiteArrayCallbacks + , testCase "reject unsupported finite array equality domains before rendering" finiteArrayRejections + , testCase "compare managed and floating finite array values" finiteArrayValues + , testCase "compile and execute nested persistent arrays" nestedPersistentArrays + , testCase "compile and execute arrays stored in tuples" tupleStoredArrays + , testCase "compile and execute arrays stored in ADTs" adtStoredArrays + , testCase "compile and execute arrays stored in lists" listStoredArrays + , testCase "initialize aggregate inputs containing arrays" aggregateArrayInputs + , testCase "initialize transitively nested array inputs" transitiveAggregateArrayInputs + , testCase "preserve native floating-point array-key equality" nativeFloatArrayKeys + , testCase "compile repeated array types into a library" persistentArrayLibrary + , testCase "compile and execute a callback-backed array input" callbackArrayInput + , testCase "compile and execute a structured lambda array" structuredLambdaArray + , testCase "compile managed structured lambda arrays" managedStructuredLambdaArrays + , testCase "retain an escaping managed lambda array" escapingManagedLambdaArray + , testCase "call defined functions inside array lambdas" definedFunctionsInsideArrayLambdas + , testCase "call defined functions from library array lambdas" definedFunctionArrayLambdaLibrary + , testCase "return arrays from structured array lambdas" arrayValuedLambdaResults + , testCase "return array-valued lambdas from a library" arrayValuedLambdaLibrary + , testCase "compile nested structured array lambdas" nestedStructuredArrayLambdas + , testCase "compile nested structured lambdas in a library" nestedStructuredArrayLambdaLibrary + , testCase "compile and execute structured lambda tables" structuredLambdaTables + , testCase "compile and execute a defined SBV function" definedSBVFunction + , testCase "compose acyclic defined SBV functions" composedDefinedSBVFunctions + , testCase "guard inactive branches in acyclic defined functions" guardedAcyclicDefinedFunctions + , testCase "guard inactive branches in entry points" (guardedProgramEvaluation False) + , testCase "guard inactive branches in array lambdas" (guardedProgramEvaluation True) + , testCase "retain checks as demand-driven evaluation roots" guardedRuntimeChecks + , testCase "preserve sharing across guarded evaluation diamonds" guardedEvaluationSharing + , testCase "evaluate shared external calls at most once on each path" guardedExternalSharing + , testCase "force and execute a deep memoized chain beneath nested branches" deepGuardedSharing + , testCase "reuse the full ADT registry for nested and leaf-only literals" sharedADTConstantRegistry + , testCase "register ADT dependencies without symbolic ADT inputs" literalADTRegistration + , testCase "straight-line sharing needs no runtime readiness flags" straightLineSharing + , testCase "text arena rejects allocation-size overflow" textAllocationOverflow + , testCase "shared arenas preserve allocation and cleanup contracts" ownershipArenaChecks + , testCase "empty concatenation borrows internally and owns outputs" emptyConcatenation + , testCase "original bundle header patterns cover both backends" compatibleHeaderPatterns + , testCase "merged configuration describes artifacts and protects existing files" mergedConfiguration + , testCase "reject excess-precision floating-point compilation" excessFloatingPrecision + , testCase "honor linker overrides, ignored assertions, and nonreserved macro prefixes" reviewedBuildOptions + , testCase "remove all matching elements from borrowed duplicate sets" borrowedDuplicateRemoval + , testCase "guard unselected finite-table entries and defaults" guardedTableEvaluation + , testCase "check wide and exact indices before guarded table selection" guardedTableIndices + , testCase "compile structural defined SBV functions" structuralDefinedSBVFunctions + , testCase "compile managed scalar defined SBV functions" managedScalarDefinedSBVFunctions + , testCase "compile collection defined SBV functions" collectionDefinedSBVFunctions + , testCase "compile persistent-array defined SBV functions" persistentArrayDefinedSBVFunctions + , testCase "compile owned-ADT defined SBV functions" ownedADTDefinedSBVFunctions + , testCase "compile recursive defined SBV functions" recursiveDefinedSBVFunctions + , testCase "compile recursive defined SBV functions in a library" recursiveDefinedSBVFunctionLibrary + , testCase "compile recursive persistent-array functions" recursivePersistentArrayFunctions + , testCase "compile recursive ADT functions" recursiveADTDefinedSBVFunctions + , testCase "compile recursive ADT functions in a library" recursiveADTDefinedSBVFunctionLibrary + , testCase "compile firstified higher-order list functions" higherOrderListFunctions + , testCase "compile higher-order list functions in a library" higherOrderListFunctionLibrary + , testCase "compile explicit hard constraints" explicitHardConstraints + , testCase "reject solver-only constraint features" unsupportedConstraintFeatures + , testCase "return a non-atomic value group" nonAtomicReturnGroup + , testCase "return multiple value groups" multipleReturnGroups + , testCase "return managed non-atomic value groups" managedReturnGroups + , testCase "return grouped values from a library" groupedReturnLibrary + , testCase "borrow symbolic-array input groups" (groupedArrayInputs False) + , testCase "borrow symbolic-array input groups in a library" (groupedArrayInputs True) + , testCase "retain grouped callback inputs across independent library calls" groupedArrayInputOwnership + , testCase "initialize and release managed input groups" (groupedManagedInputs False) + , testCase "share driver initialization for mixed aggregate fields" sharedDriverInitialization + , testCase "pair collection driver cleanup with storage selection" collectionDriverStorageModes + , testCase "initialize and release managed input groups in a library" (groupedManagedInputs True) + , testCase "compile and execute a free array with a C definition" definedFreeArray + , testCase "return and output owned arrays" ownedArrayResults + , testCase "retain an escaping callback array" escapingCallbackArray + , testCase "compile arrays with managed aggregate fields" managedAggregateArrays + , testCase "return managed aggregate arrays from a library" managedAggregateArrayLibrary + , testCase "compile managed aggregate lookup tables" managedAggregateTables + , testCase "compile array-valued lookup tables" (arrayValuedTables False) + , testCase "retain ready array-valued lookup tables" (arrayValuedTables True) + , testCase "return managed table values from a library" managedAggregateTableLibrary + , testCase "compile and execute structural tuples" structuralTuples + , testCase "compile repeated tuple types into a library" structuralTupleLibrary + , testCase "compile and execute tuples containing strings" ownedTextTuples + , testCase "return string tuples from a generated library" ownedTextTupleLibrary + , testCase "compile and execute tuples containing collections" ownedCollectionTuples + , testCase "return collection tuples from a generated library" ownedCollectionTupleLibrary + , testCase "compile tuple-valued symbolic collections" tupleValuedCollections + , testCase "return tuple-valued collections from a library" tupleValuedCollectionLibrary + , testCase "compile managed tuple-valued collections" managedTupleValuedCollections + , testCase "return managed tuple-valued collections from a library" managedTupleValuedCollectionLibrary + , testCase "compile string-valued collections and text ADTs" textAggregateCollections + , testCase "return text ADTs from a library" textAggregateLibrary + , testCase "compile directly nested collections" directlyNestedCollections + , testCase "return nested collections from a library" directlyNestedCollectionLibrary + , testCase "compile ADT-valued collections" adtValuedCollections + , testCase "return ADT-valued collections from a library" adtValuedCollectionLibrary + , testCase "compile and execute characters and strings" characterStrings + , testCase "compile strings with mapped integers" mappedIntegerStrings + , testCase "return owned strings from a generated library" ownedStringLibrary + , testCase "compile and execute symbolic lists" symbolicLists + , testCase "compile arbitrary-width symbolic lists" wideSymbolicLists + , testCase "compile arbitrary floating-point symbolic lists" arbitraryFloatLists + , testCase "preserve native floating-point list equality" nativeFloatLists + , testCase "compile lists with mapped numeric elements" mappedNumericLists + , testCase "return owned lists from a generated library" ownedListLibrary + , testCase "compile lists of exact GMP values" exactGMPLists + , testCase "compile and execute symbolic sets" symbolicSets + , testCase "compare finite and cofinite Boolean sets" finiteUniverseSets + , testCase "compile arbitrary-width symbolic sets" wideSymbolicSets + , testCase "compile character symbolic sets" characterSets + , testCase "compile arbitrary floating-point symbolic sets" arbitraryFloatSets + , testCase "preserve native floating-point set equality" nativeFloatSets + , testCase "compile sets with mapped numeric elements" mappedNumericSets + , testCase "return owned sets from a generated library" ownedSetLibrary + , testCase "compile sets of exact GMP values" exactGMPSets + , testCase "compile and execute non-recursive ADTs" nonRecursiveADTs + , testCase "compile and execute nested ADTs" nestedADTs + , testCase "compile repeated ADT types into a library" nonRecursiveADTLibrary + , testCase "compile ADTs containing managed collections" collectionADTs + , testCase "compile recursive ADTs containing collections" recursiveCollectionADTs + , testCase "return collection ADTs from a generated library" collectionADTLibrary + , testCase "preserve ADT aggregate equality" adtAggregateEquality + , testCase "compile and execute recursive ADTs" recursiveADTs + , testCase "embed recursive ADTs by value" wrappedRecursiveADTs + , testCase "compile and execute mutually recursive ADTs" mutuallyRecursiveADTs + , testCase "compile repeated recursive ADTs into a library" recursiveADTLibrary + , testCase "report recursive ADTs without finite samples" uninhabitedRecursiveADT + ] + where thd (_, _, r) = r + + genSelect b n = thd <$> 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 = thd <$> compileToC' "foo" fooProgram + + fooProgram = 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) + +-- | Preserve diagnostic text literally, both in C comments and as a printf +-- argument, including characters that could otherwise alter the generated C. +escapedAssertionMessages :: Assertion +escapedAssertionMessages = withSystemTempDirectory "sbv-assertion-escaping" $ \dir -> do + let message = "must be \"small\"; 100% %n */\n\\\n??/" + compileToC (Just dir) "escapedAssertion" $ do + cgOverwriteFiles True + cgSetDriverValues [7] + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (sAssert Nothing message (value .< 5) value) + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, _, runError) <- readProcessWithExitCode (dir "escapedAssertion_driver") [] "" + assertBool "Expected the violated assertion to terminate the driver" (runExit /= ExitSuccess) + assertBool ("Assertion text was changed: " ++ runError) (("ASSERTION FAILED: " ++ message) `isInfixOf` runError) + +-- | Labels are semantic no-ops even when their text contains C statements, +-- nested comment markers, preprocessing splices, trigraphs, or control bytes. +-- Exercise scalar, tuple, acyclic/recursive ADT, and persistent-array labels in +-- entry points, private functions, and closed lambdas, including static libraries. +escapedValueLabels :: TestTree +escapedValueLabels = testGroup "escaped C labels" + [ testCase (form ++ "/" ++ scopeName ++ "/" ++ sampleName) (check (library, scope, message)) + | (form, library) <- [("program", False), ("library", True)] + , (scopeName, scope) <- [("entry", 0 :: Int), ("function", 1), ("array lambda", 2)] + , (sampleName, message) <- messages + ] + where messages = [ ("statements", "*/; abort(); /*") + , ("preprocessing", "nested /* comment; \\\n??/\n*/") + , ("control characters", "Unicode \955, NUL \0, CR \r, tab \t and control \SOH") + ] + + check (library, scope, message) = withSystemTempDirectory "sbv-c-label-escaping" $ \dir -> do + let functionName = "escapedLabels" + evaluateValue :: SWord8 -> SBool + evaluateValue value = + let annotate :: SymVal a => SBV a -> SBV a + annotate = label message + (firstField, secondField) = untuple (annotate (tuple (value, value + 1))) + tagged = annotate (sCGOne value) + tree = annotate (sCGNode (sCGLeaf value) (sCGLeaf (value + 1))) + array = annotate (constArray value :: SArray Word8 Word8) + in sAnd [ annotate value .== value + , firstField .== value + , secondField .== value + 1 + , getCGOne_1 tagged .== value + , getCGLeaf_1 (getCGNode_1 tree) .== value + , readArray array value .== value + ] + evaluateScoped value = case scope of + 0 -> evaluateValue value + 1 -> smtFunction "C escaped labels" evaluateValue value + _ -> readArray (lambdaArray evaluateValue) value + program = do + cgOverwriteFiles True + cgSetDriverValues [7] + value <- cgInput "value" + cgReturn (evaluateScoped value) + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("labelComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Compare executed native remainders against constant SBV evaluation, +-- including quotient ties, negative operands, and a negative divisor. +nativeFloatingRemainders :: Assertion +nativeFloatingRemainders = mapM_ check [(7, 4), (6, 4), (-7, 4), (7, -4)] + where check (left, right) = withSystemTempDirectory "sbv-native-remainder" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [left, right, left, right] + leftFloat <- cgInput "leftFloat" :: SBVCodeGen SFloat + rightFloat <- cgInput "rightFloat" :: SBVCodeGen SFloat + leftDouble <- cgInput "leftDouble" :: SBVCodeGen SDouble + rightDouble <- cgInput "rightDouble" :: SBVCodeGen SDouble + let expectedFloat = fpRem (fromInteger left) (fromInteger right) :: SFloat + expectedDouble = fpRem (fromInteger left) (fromInteger right) :: SDouble + cgReturn ((fpRem leftFloat rightFloat .== expectedFloat) .&& (fpRem leftDouble rightDouble .== expectedDouble)) + outputText <- compileProgramAndRunGenerated dir "nativeRemainder" program + assertBool ("Incorrect native remainder: " ++ outputText) ("= 1" `isInfixOf` outputText) + +-- | Equality observes every key, including a mismatch at the last key. The +-- same helper is available inside defined functions and retained lambdas. +finiteArrayEquality :: Assertion +finiteArrayEquality = mapM_ check [(library, identical) | library <- [False, True], identical <- [False, True]] + where check (library, identical) = withSystemTempDirectory "sbv-finite-array-equality" $ \dir -> do + let functionName = "finiteArrayEquality" + program = do + cgOverwriteFiles True + cgSetDriverValues [3, if identical then 3 else 4] + left <- cgInput "left" :: SBVCodeGen (SArray Word8 Word32) + right <- cgInput "right" :: SBVCodeGen (SArray Word8 Word32) + let equalArrays = smtFunction "C finite array equality" ((.==) :: SArray Word8 Word32 -> SArray Word8 Word32 -> SBool) + changed = writeArray left 255 (readArray left 255 + 1) + another = writeArray left 255 (readArray left 255 + 2) + callback = lambdaArray (\key -> (constArray key :: SArray Bool Bool) .== constArray sTrue) :: SArray Bool Bool + cgReturn $ sAnd [ (left .== right) .== literal identical + , equalArrays left right .== literal identical + , left ./= changed + , distinct [left, changed, another] + , (left .=== right) .== literal identical + , readArray callback sTrue + , sNot (readArray callback sFalse) + ] + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("equalityComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | The limit rejects excessive work during generation, can be raised to +-- admit a 16-bit key domain, and can be set to zero to disable enumeration. +finiteArrayEqualityLimits :: Assertion +finiteArrayEqualityLimits = do + let program limit = do + cgOverwriteFiles True + cgSetDriverValues [7, 7] + mapM_ cgArrayEqualityLimit limit + left <- cgInput "left" :: SBVCodeGen (SArray Word16 Word8) + right <- cgInput "right" :: SBVCodeGen (SArray Word16 Word8) + cgReturn (left .== right) + mapM_ (\limit -> do + result <- try (do (_, _, bundle) <- compileToC' "limitedEquality" (program limit) + evaluate (length (show bundle))) :: IO (Either ErrorCall Int) + case result of + Left exception -> assertBool (displayException exception) ("cgArrayEqualityLimit" `isInfixOf` displayException exception) + Right _ -> assertFailure "Expected the array equality limit to reject generation") [Nothing, Just 0, Just (-1)] + withSystemTempDirectory "sbv-configured-array-equality" $ \dir -> do + outputText <- compileProgramAndRunGenerated dir "configuredEquality" (program (Just 65536)) + sourceText <- readFile (dir "configuredEquality.c") + assertBool outputText (") = 1" `isInfixOf` outputText) + assertBool "Equality must use a compact loop, not an unrolled key table" (length sourceText < 50000) + +-- | Enumerate signed bit patterns, sub-native bit-vectors, sums, products, +-- and rounding modes without relying on the example driver's sample keys. +finiteArrayKeyKinds :: Assertion +finiteArrayKeyKinds = withSystemTempDirectory "sbv-finite-array-key-kinds" $ \dir -> do + let pair :: forall key. SymVal key => Proxy key -> String -> SBVCodeGen SBool + pair _ prefix = do + left <- cgInput (prefix ++ "Left") :: SBVCodeGen (SArray key Word8) + right <- cgInput (prefix ++ "Right") :: SBVCodeGen (SArray key Word8) + pure (left .=== right) + program = do + cgOverwriteFiles True + cgSetDriverValues (repeat 3) + results <- sequence [ pair (Proxy @Bool) "bool" + , pair (Proxy @Int8) "signed" + , pair (Proxy @(WordN 1)) "bit" + , pair (Proxy @(IntN 1)) "signedBit" + , pair (Proxy @(WordN 5)) "wide" + , pair (Proxy @(IntN 5)) "signedWide" + , pair (Proxy @(Bool, WordN 2)) "tuple" + , pair (Proxy @(Maybe Bool)) "maybe" + , pair (Proxy @(Either Bool (WordN 2))) "either" + , pair (Proxy @CodeGenEnum) "enum" + , pair (Proxy @RoundingMode) "rounding" + , pair (Proxy @(FloatingPoint 2 3)) "tinyFloat" + , pair (Proxy @()) "unit" + ] + cgReturn (sAnd results) + outputText <- compileProgramAndRunGenerated dir "finiteArrayKeys" program + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Exercise actual C callbacks, counting complete enumeration and early +-- mismatches. Tiny floats cover every object exactly once, including both +-- zeros and a single NaN, and library components retain independent limits. +finiteArrayCallbacks :: Assertion +finiteArrayCallbacks = withSystemTempDirectory "sbv-finite-array-callbacks" $ \dir -> do + let component :: forall key. SymVal key => Proxy key -> Integer -> SBVCodeGen () + component _ limit = do + cgOverwriteFiles True + cgGenerateDriver False + cgArrayEqualityLimit limit + left <- cgInput "left" :: SBVCodeGen (SArray key Word8) + right <- cgInput "right" :: SBVCodeGen (SArray key Word8) + cgReturn (left .=== right) + large = do + cgOverwriteFiles True + cgGenerateDriver False + cgArrayEqualityLimit 65536 + left <- cgInput "left" :: SBVCodeGen (SArray Word16 Word8) + right <- cgInput "right" :: SBVCodeGen (SArray Word16 Word8) + let compareArrays = smtFunction "C configured equality" ((.==) :: SArray Word16 Word8 -> SArray Word16 Word8 -> SBool) + cgReturn (compareArrays left right) + _ <- compileToCLib (Just dir) "arrayEqualityLibrary" + [("compareBytes", component (Proxy @Word8) 256) + , ("compareTinyFloats", component (Proxy @(FloatingPoint 2 3)) 27) + , ("compareChars", component (Proxy @Char) 0x30000) + , ("compareLarge", large) + ] + compileAndRunCaller dir "arrayEqualityLibrary" $ unlines + ["#include \"arrayEqualityLibrary.h\"" + , "#include " + , "static unsigned calls, nans, positive_zeros, negative_zeros;" + , "static SWord8 byte_lookup(const void *context, SWord8 key)" + , "{ ++calls; return context != NULL && key == *(const unsigned *) context; }" + , "static SWord8 float_lookup(const void *context, SFP2_3 key)" + , "{" + , " (void) context; ++calls;" + , " unsigned raw = (unsigned) key.limb[0];" + , " bool nan = (raw & 12) == 12 && (raw & 3) != 0;" + , " nans += nan; positive_zeros += raw == 0; negative_zeros += raw == 16;" + , " return nan ? 1 : (SWord8) raw;" + , "}" + , "static SWord8 char_lookup(const void *context, SChar key)" + , "{ (void) context; ++calls; return (SWord8) key; }" + , "static SWord8 large_lookup(const void *context, SWord16 key)" + , "{ (void) context; ++calls; return (SWord8) key; }" + , "int main(void)" + , "{" + , " unsigned changed = 255;" + , " SBVArrayInput_2_u8_2_u8 left = {byte_lookup, NULL, NULL, NULL};" + , " SBVArrayInput_2_u8_2_u8 right = {byte_lookup, &changed, NULL, NULL};" + , " assert(!compareBytes(left, right) && calls == 512);" + , " calls = 0; changed = 0; assert(!compareBytes(left, right) && calls == 2);" + , " calls = 0; assert(compareBytes(left, left) && calls == 512);" + , " SBVArrayInput_8_fp_e2_s3_2_u8 floats = {float_lookup, NULL, NULL, NULL};" + , " calls = 0; assert(compareTinyFloats(floats, floats) && calls == 54);" + , " assert(nans == 2 && positive_zeros == 2 && negative_zeros == 2);" + , " SBVArrayInput_4_char_2_u8 chars = {char_lookup, NULL, NULL, NULL};" + , " calls = 0; assert(compareChars(chars, chars) && calls == 0x60000);" + , " SBVArrayInput_3_u16_2_u8 large = {large_lookup, NULL, NULL, NULL};" + , " calls = 0; assert(compareLarge(large, large) && calls == 131072);" + , " return 0;" + , "}" + ] + +-- | Reject disabled, oversized, infinite, recursive, and nested-array comparisons +-- with user-facing diagnostics before creating standalone or library files. +-- Opt-in permits compact native-floating and wide +-- bit-vector loops to be generated without attempting to execute them. +finiteArrayRejections :: Assertion +finiteArrayRejections = do + let comparison :: forall key. SymVal key => Proxy key -> SBVCodeGen () + comparison _ = do + cgGenerateDriver False + left <- cgInput "left" :: SBVCodeGen (SArray key Word8) + right <- cgInput "right" :: SBVCodeGen (SArray key Word8) + cgReturn (left .=== right) + reject diagnostic program = mapM_ (checkRejection diagnostic program) [False, True] + checkRejection diagnostic program library = withSystemTempDirectory "sbv-array-equality-rejection" $ \dir -> do + let closed = cgGenerateDriver False >> cgReturn sTrue + action | library = void $ compileToCLib (Just dir) "rejectedLibrary" [("closedComponent", closed), ("rejectedEquality", program)] + | True = compileToC (Just dir) "rejectedEquality" program + result <- try action :: IO (Either ErrorCall ()) + case result of + Left exception -> do + let message = displayException exception + assertBool message (diagnostic `isInfixOf` message) + assertBool "An intentional array-equality limit must not be reported as an internal error" + (not ("Unexpected" `isInfixOf` message)) + Right _ -> assertFailure "Expected array equality to reject generation" + assertEqual "Rejected equality must not create any component files" [] =<< listDirectory dir + checkCompact program = do + (_, _, bundle) <- compileToC' "largeDomain" (cgArrayEqualityLimit (2 ^ (673 :: Int)) >> program) + assertBool "Explicitly admitted large domains must generate compact loops" (length (show bundle) < 100000) + mapM_ (reject "cgArrayEqualityLimit") + [comparison (Proxy @Word32), comparison (Proxy @(WordN 673)), comparison (Proxy @Float) + , cgArrayEqualityLimit 26 >> comparison (Proxy @(FloatingPoint 2 3))] + reject "disabled by cgArrayEqualityLimit 0" (cgArrayEqualityLimit 0 >> comparison (Proxy @Bool)) + mapM_ (reject "cannot enumerate key domain") + [comparison (Proxy @Integer), comparison (Proxy @String), comparison (Proxy @CodeGenTree)] + reject "Nested extensional array equality" $ do + cgGenerateDriver False + left <- cgInput "left" :: SBVCodeGen (SArray Bool (ArrayModel Bool Word8)) + right <- cgInput "right" :: SBVCodeGen (SArray Bool (ArrayModel Bool Word8)) + cgReturn (left .== right) + mapM_ checkCompact [comparison (Proxy @Float), comparison (Proxy @Double), comparison (Proxy @(WordN 673))] + +-- | Array values use structural object equality, including managed GMP, +-- collection and ADT values, NaNs, and the distinction between signed zeros. +finiteArrayValues :: Assertion +finiteArrayValues = withSystemTempDirectory "sbv-finite-array-values" $ \dir -> do + let pair :: forall value. SymVal value => Proxy value -> String -> SBVCodeGen SBool + pair _ prefix = do + left <- cgInput (prefix ++ "Left") :: SBVCodeGen (SArray Bool value) + right <- cgInput (prefix ++ "Right") :: SBVCodeGen (SArray Bool value) + pure (left .=== right) + program = do + cgOverwriteFiles True + cgSetDriverValues (repeat 3) + results <- sequence [ pair (Proxy @Integer) "integer" + , pair (Proxy @Rational) "rational" + , pair (Proxy @String) "string" + , pair (Proxy @[Integer]) "list" + , pair (Proxy @(RCSet Word8)) "set" + , pair (Proxy @(Maybe Integer)) "adt" + ] + bits <- cgInput "bits" :: SBVCodeGen SWord32 + let array value = constArray value :: SArray Bool Float + nanValue = sWord32AsSFloat (bits .|. 0x7fc00000) + positive = sWord32AsSFloat (bits .&. 0) + negative = sWord32AsSFloat ((bits .&. 0) .|. 0x80000000) + cgReturn $ sAnd (results ++ [array nanValue .=== array (nanValue + 1), sNot (array positive .=== array negative)]) + outputText <- compileProgramAndRunGenerated dir "finiteArrayValues" program + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Discover rounding-mode declarations through collection element kinds, +-- and compile their borrowed/owned interfaces with strict C warnings. +collectionRoundingModes :: Assertion +collectionRoundingModes = withSystemTempDirectory "sbv-collection-rounding" $ \dir -> do + compileToC (Just dir) "collectionRounding" $ do + cgOverwriteFiles True + values <- cgInput "values" :: SBVCodeGen (SList RoundingMode) + modes <- cgInput "modes" :: SBVCodeGen (SList [RoundingMode]) + cgOutput "modesResult" modes + cgReturn values + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + _ <- compileAndRunGenerated dir "collectionRounding" + pure () + +-- | The driver must wait for its archive in parallel builds and become stale +-- whenever a component source changes, even if the public header is unchanged. +libraryDriverDependencies :: Assertion +libraryDriverDependencies = withSystemTempDirectory "sbv-library-dependencies" $ \dir -> do + _ <- compileToCLib (Just dir) "dependencyLibrary" + [("component", do cgOverwriteFiles True + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (value + 1))] + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-j2", "-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (queryExit, _, queryError) <- readProcessWithExitCode "make" ["-q", "-C", dir, "-W", "component.c", "dependencyLibrary_driver"] "" + assertEqual queryError (ExitFailure 1) queryExit + +-- | Reject direct and nested array comparisons, including sequence operations +-- that implicitly compare elements and comparisons inside defined functions. +-- Every rejection must precede file creation, even after a valid library entry. +arrayCollectionComparisons :: TestTree +arrayCollectionComparisons = testGroup "reject comparisons of array-valued collections" + [ testCase (testName ++ if library then " library" else " standalone") (checkOutput testName program library) + | (testName, program) <- programs, library <- [False, True] + ] + where binary :: forall a b. (SymVal a, SymVal b) => Proxy a -> (SBV a -> SBV a -> SBV b) -> SBVCodeGen () + binary _ operation = do + cgGenerateDriver False + left <- cgInput "left" :: SBVCodeGen (SBV a) + right <- cgInput "right" :: SBVCodeGen (SBV a) + cgReturn (operation left right) + + comparisons :: SymVal a => Proxy a -> [(String, SBVCodeGen ())] + comparisons proxy = [("equal", binary proxy (.==)), ("distinct", binary proxy (./=)), ("objectEqual", binary proxy (.===))] + + -- ArrayModel deliberately has no Haskell Eq instance, so construct the + -- sequence primitives directly to test the backend boundary independently + -- of the public list API's concrete-folding constraints. + sequenceExpr :: forall a b. (SymVal a, SymVal b) + => (Kind -> SeqOp) -> SList a -> SList a -> [SVal] -> SBV b + sequenceExpr operation left right extra = SBV $ SVal resultKind $ Right $ cache $ \st -> do + arguments <- mapM (svToSV st) ([unSBV left, unSBV right] ++ extra) + newExpr st resultKind (SBVApp (SeqOp (operation (kindOf (Proxy @a)))) arguments) + where resultKind = kindOf (Proxy @b) + + sequences :: forall a. SymVal a => Proxy [a] -> [(String, SBVCodeGen ())] + sequences proxy = comparisons proxy ++ + [ ("indexOf", binary proxy (\left right -> sequenceExpr SeqIndexOf left right [unSBV (1 :: SInteger)] :: SInteger)) + , ("contains", predicate SeqContains) + , ("prefix", predicate SeqPrefixOf) + , ("suffix", predicate SeqSuffixOf) + , ("replace", binary proxy (\left right -> sequenceExpr SeqReplace left right [unSBV left] :: SList a)) + ] + where predicate operation = binary proxy (\left right -> sequenceExpr operation left right [] :: SBool) + + named prefix = map (B.first (prefix ++)) + + programs = named "list_" (sequences (Proxy @[ArrayModel Word8 Word8])) + ++ named "listTuple_" (sequences (Proxy @[(Word8, ArrayModel Word8 Word8)])) + ++ named "nested_" (sequences (Proxy @[[ArrayModel Word8 Word8]])) + ++ named "tuple_" (comparisons (Proxy @(Word8, ArrayModel Word8 Word8))) + ++ named "adt_" (comparisons (Proxy @CodeGenArrayBox)) + ++ named "envelope_" (comparisons (Proxy @CodeGenArrayEnvelope)) + ++ named "recursive_" (comparisons (Proxy @(Either CodeGenTree CodeGenArrayBox))) + ++ [ ("defined", binary (Proxy @[ArrayModel Word8 Word8]) (smtFunction "compareArrayElements" (.===))) + , ("definedSearch", binary (Proxy @[ArrayModel Word8 Word8]) + (smtFunction "findArrayElements" (\left right -> sequenceExpr SeqIndexOf left right [unSBV (0 :: SInteger)] :: SInteger))) + , ("lambda", cgReturn (lambdaArray (\index -> tuple (constArray index :: SArray Word8 Word8, index) + .=== tuple (constArray (index + 1) :: SArray Word8 Word8, index)) + :: SArray Word8 Bool)) + , ("arrayKeys", do value <- cgInput "value" :: SBVCodeGen (SArray (Word8, ArrayModel Word8 Word8) Word8) + cgReturn value) + ] + + checkOutput testName program library = withSystemTempDirectory "sbv-array-comparison-rejection" $ \dir -> do + let valid = cgGenerateDriver False >> cgReturn sTrue + action | library = void $ compileToCLib (Just dir) "rejectedLibrary" [("validComponent", valid), (testName, program)] + | True = compileToC (Just dir) testName program + result <- try action :: IO (Either ErrorCall ()) + case result of + Left exception -> do + let message = displayException exception + assertBool (testName ++ ": " ++ message) ("extensional array equality" `isInfixOf` message) + assertBool (testName ++ ": intentional rejection must not be an internal compiler error") + (not ("Unexpected" `isInfixOf` message)) + Right _ -> assertFailure (testName ++ ": expected generation to reject array-element comparison") + assertEqual (testName ++ ": rejected comparisons must not create any files") [] =<< listDirectory dir + +-- | An external C provider may return a borrowed set containing duplicates. +-- Removing an element must count every retained slot before exporting it. +borrowedDuplicateRemoval :: Assertion +borrowedDuplicateRemoval = withSystemTempDirectory "sbv-duplicate-set" $ \dir -> do + compileToC (Just dir) "removeDuplicates" $ do + cgOverwriteFiles True + cgGenerateDriver False + cgAddPrototype ["SBVSet_u8 duplicates(SWord8);"] + cgAddDecl [ "SBVSet_u8 duplicates(SWord8 unused) { (void) unused; static const SWord8 values[] = {7, 7, 9};" + , "return (SBVSet_u8) {values, 3, false}; }" + , "int main(void) { SBVSet_u8 result = removeDuplicates(0);" + , "int failed = result.length != 1 || result.data[0] != 9;" + , "sbv_set_release_u8(&result); return failed; }" + ] + input <- cgInput "input" :: SBVCodeGen SWord8 + cgReturn (SS.delete 7 (uninterpret "duplicates" input :: SSet Word8)) + runEmbeddedCaller dir "removeDuplicates" + +-- | Instrument an external function: a branch-local demand followed by an +-- unconditional demand must not repeat the call, and a dead arm must not call it. +guardedExternalSharing :: Assertion +guardedExternalSharing = withSystemTempDirectory "sbv-shared-external" $ \dir -> do + compileToC (Just dir) "sharedExternal" $ do + cgOverwriteFiles True + cgGenerateDriver False + cgAddPrototype ["SWord8 counted(SWord8);"] + cgAddDecl [ "static unsigned calls;" + , "SWord8 counted(SWord8 x) { ++calls; return x; }" + , "int main(void) { SWord8 first, second;" + , "sharedExternal(true, 7, &first, &second); if (calls != 1 || first != 7 || second != 7) return 1;" + , "calls = 0; sharedExternal(false, 8, &first, &second); return calls != 1 || first != 0 || second != 8; }" + ] + condition <- cgInput "condition" :: SBVCodeGen SBool + value <- cgInput "value" :: SBVCodeGen SWord8 + let shared = uninterpret "counted" value :: SWord8 + cgOutput "first" (ite condition shared 0) + cgOutput "second" shared + source <- readFile (dir "sharedExternal.c") + assertEqual "Only the post-join demand needs a readiness guard" 1 + (length (filter ("if(!sbv_ready_" `isInfixOf`) (lines source))) + runEmbeddedCaller dir "sharedExternal" + +-- | Force the full bundle for a three-stage dependency chain first demanded +-- beneath nested branches. All eight paths must reuse every computed stage; +-- a later unconditional demand must also compute any previously skipped stage. +deepGuardedSharing :: Assertion +deepGuardedSharing = withSystemTempDirectory "sbv-deep-sharing" $ \dir -> do + (_, cfg, bundle) <- compileToC' "deepSharing" $ do + cgOverwriteFiles True + cgGenerateDriver False + cgAddPrototype ["SWord8 stageOne(SWord8);", "SWord8 stageTwo(SWord8);", "SWord8 stageThree(SWord8);"] + cgAddDecl [ "static unsigned calls[3];" + , "SWord8 stageOne(SWord8 x) { ++calls[0]; return x + 1; }" + , "SWord8 stageTwo(SWord8 x) { ++calls[1]; return x + 1; }" + , "SWord8 stageThree(SWord8 x) { ++calls[2]; return x + 1; }" + , "int main(void) {" + , " for (SWord8 flags = 0; flags < 8; ++flags) {" + , " SWord8 first, second, intermediate; calls[0] = calls[1] = calls[2] = 0;" + , " deepSharing(flags, 7, &first, &second, &intermediate);" + , " if (first != (flags == 7 ? 10 : 0) || second != 10 || intermediate != 9) return 1;" + , " if (calls[0] != 1 || calls[1] != 1 || calls[2] != 1) return 2;" + , " }" + , " return 0;" + , "}" + ] + flags <- cgInput "flags" :: SBVCodeGen SWord8 + value <- cgInput "value" :: SBVCodeGen SWord8 + let stage1 = uninterpret "stageOne" value :: SWord8 + stage2 = uninterpret "stageTwo" stage1 :: SWord8 + stage3 = uninterpret "stageThree" stage2 :: SWord8 + cgOutput "first" (ite (sTestBit flags 0) (ite (sTestBit flags 1) (ite (sTestBit flags 2) stage3 0) 0) 0) + cgOutput "second" stage3 + cgOutput "intermediate" stage2 + void $ evaluate (length (show bundle)) + renderCgPgmBundle (Just dir) (cfg, bundle) + source <- readFile (dir "deepSharing.c") + assertEqual "Each stage needs a post-join readiness guard" 3 + (length (filter ("if(!sbv_ready_" `isInfixOf`) (lines source))) + runEmbeddedCaller dir "deepSharing" + +-- | A leaf literal contains no value of the mutually recursive partner type, +-- but its type's other constructor still needs that partner's declaration. +-- An ADT input registers the full mutually recursive group; both leaf-only and +-- nested literals inside a managed collection must reuse that same registry. +sharedADTConstantRegistry :: Assertion +sharedADTConstantRegistry = mapM_ check [0, 1] + where check seed = withSystemTempDirectory "sbv-adt-constant-registry" $ \dir -> do + outputText <- compileProgramAndRunGenerated dir "sharedADTRegistry" $ do + cgOverwriteFiles True + cgSetDriverValues [seed, 0] + chooseLeaf <- cgInput "chooseLeaf" :: SBVCodeGen SBool + value <- cgInput "value" :: SBVCodeGen SCodeGenEven + cgOutput "copy" value + cgReturn (ite chooseLeaf (literal [CGEvenEnd 7]) + (literal [CGEvenStep (CGOddStep (CGEvenEnd 9))])) + let expected | seed == 0 = "CGEvenStep(CGOddStep(CGEvenEnd(9)))" + | True = "CGEvenEnd(7)" + assertBool outputText (expected `isInfixOf` outputText) + +-- | Literal-only ADTs retain their complete declarations without an ADT input +-- or explicit registration. Metadata remains finite and does not affect kind +-- identity, structural traversal, or constant folding, even under containers. +literalADTRegistration :: Assertion +literalADTRegistration = do + let leaf = literal (CGEvenEnd 7) + rootKind = kindOf leaf + assertEqual "The leaf remains concrete" (Just "CGEvenEnd 7") (show <$> unliteral leaf) + assertEqual "The symbolic constructor remains concrete" (Just "CGEvenEnd 7") (show <$> unliteral (sCGEvenEnd 7)) + void $ evaluate (force rootKind) + case rootKind of + KADT typeName parameters constructors -> do + let bare = KADT typeName parameters constructors + assertEqual "Metadata preserves kind equality" bare rootKind + assertEqual "Metadata preserves kind ordering" EQ (compare bare rootKind) + assertEqual "Metadata is not part of structural kind traversal" (expandKinds bare) (expandKinds rootKind) + _ -> assertFailure "Expected an ADT kind" + let parameterKind = kindOf (Proxy @(CodeGenEnvelope Word8)) + assertEqual "Substitution must not enter independent declaration scopes" + (adtKindDependencies parameterKind) + (adtKindDependencies (substituteADTVars "CodeGenEnvelope" [("a", KBounded False 8)] parameterKind)) + forM_ [ ("literalLeaf", cgReturn leaf, "CGEvenEnd(7)") + , ("constructorLeaf", cgReturn (sCGEvenEnd 7), "CGEvenEnd(7)") + , ("literalLeaves", cgReturn (literal [CGEvenEnd 7]), "CGEvenEnd(7)") + , ("literalEmptyLeaves", cgReturn (literal [] :: SList CodeGenEven), "") + , ("literalTupleLeaf", cgReturn (literal (CGEvenEnd 7, True)), "CGEvenEnd(7)") + , ("literalArrayLeaf", cgReturn (constArray leaf :: SArray Word8 CodeGenEven), "CGEvenEnd(7)") + ] $ \(entry, program, expected) -> withSystemTempDirectory "sbv-literal-adt" $ \dir -> do + outputText <- compileProgramAndRunGenerated dir entry program + headerText <- readFile (dir entry ++ ".h") + assertBool outputText (expected `isInfixOf` outputText) + assertBool "The unused partner still needs a declaration" + ("typedef struct SBVADT_CodeGenOdd SBVADT_CodeGenOdd;" `isInfixOf` headerText) + withSystemTempDirectory "sbv-literal-adt-parameter" $ \dir -> do + outputText <- compileProgramAndRunGenerated dir "literalEnvelope" $ + cgReturn (literal CGNoEnvelope :: SCodeGenEnvelope Word8) + headerText <- readFile (dir "literalEnvelope.h") + assertBool outputText ("CGNoEnvelope" `isInfixOf` outputText) + assertBool "The unused constructor must instantiate its dependency at Word8" + ("SBVADT_CodeGenADT_2_u8" `isInfixOf` headerText) + assertBool "The placeholder registration schema is not the generated ADT" + (not ("SBVADT_CodeGenADT_7_integer" `isInfixOf` headerText)) + +-- | The original four-way file-kind match must stay exhaustive under -Werror +-- and expose signatures for current and legacy generated headers alike. +compatibleHeaderPatterns :: Assertion +compatibleHeaderPatterns = mapM_ check [compileToC', PublicLegacy.compileToC'] + where check compiler = do + (_, _, CgPgmBundle _ files) <- compiler "compatibleHeader" $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (value + 1) + assertEqual "One header with one public signature" [1] + [count | (_, (fileKind, _)) <- files, Just count <- [signatures fileKind]] + signatures (CgMakefile _) = Nothing + signatures (CgHeader ds) = Just (length ds) + signatures CgSource = Nothing + signatures CgDriver = Nothing + +-- | Per-component generation options need not agree, but a library's returned +-- artifact flags must reflect the union, and overwriting needs unanimous opt-in. +mergedConfiguration :: Assertion +mergedConfiguration = do + (_, cfg, _) <- compileToCLib' "mixedConfiguration" + [ ("withoutDriver", do cgGenerateDriver False + cgGenerateMakefile False + cgOverwriteFiles True + cgReturn sTrue) + , ("withDriver", cgReturn sFalse) + ] + assertBool "Merged library includes a driver" (cgGenDriver cfg) + assertBool "Merged library includes a Makefile" (cgGenMakefile cfg) + assertBool "One component cannot authorize overwriting for the others" (not (cgOverwriteGenerated cfg)) + +-- | Detect unsupported excess precision at C compilation, without depending +-- on whether the local processor offers an x87-style evaluation mode. +excessFloatingPrecision :: Assertion +excessFloatingPrecision = mapM_ check [-1, 1, 2 :: Int] + where check evaluationMethod = withSystemTempDirectory "sbv-excess-precision" $ \dir -> do + compileToC (Just dir) "floatingPrecision" $ do + cgOverwriteFiles True + cgGenerateDriver False + value <- cgInput "value" :: SBVCodeGen SDouble + cgReturn (value + 1) + writeFile (dir "excess.c") $ unlines + [ "#include " + , "#undef FLT_EVAL_METHOD" + , "#define FLT_EVAL_METHOD " ++ show evaluationMethod + , "#include \"floatingPrecision.h\"" + ] + (compileExit, _, compileError) <- readProcessWithExitCode "cc" ["-std=c11", "-fsyntax-only", dir "excess.c"] "" + assertBool "Excess precision must be rejected" (compileExit /= ExitSuccess) + assertBool compileError ("indeterminate or excess-precision floating evaluation is unsupported" `isInfixOf` compileError) + +-- | Exercise the arena's size check directly, without constructing an invalid +-- borrowed string or relying on an enormous allocation to fail incidentally. +textAllocationOverflow :: Assertion +textAllocationOverflow = withSystemTempDirectory "sbv-text-overflow" $ \dir -> do + compileToC (Just dir) "textOverflow" $ do + cgOverwriteFiles True + cgGenerateDriver False + value <- cgInput "value" :: SBVCodeGen SString + cgReturn (value SL.++ value) + appendFile (dir "textOverflow.c") $ unlines + [ "int main(void) {" + , " sbv_text_ctx ctx = {NULL};" + , " (void) sbv_text_alloc(&ctx, SIZE_MAX);" + , " sbv_text_ctx_end(&ctx); return 0;" + , "}" + ] + writeFile (dir "caller.mk") $ unlines + [ "textOverflow: textOverflow.o" + , "\t${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} ${SBV_LIBS}" + ] + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, "textOverflow"] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (runExit, _, runError) <- readProcessWithExitCode (dir "textOverflow") [] "" + assertBool ("Expected allocation overflow to abort: " ++ runError) (runExit /= ExitSuccess) + +-- | Mix literal-backed collections with owned numbers, ADTs, and collections +-- of ADTs in one driver input. Only fields needing initialization get element +-- variables, and the cloned output survives cleanup of the borrowed input. +sharedDriverInitialization :: Assertion +sharedDriverInitialization = withSystemTempDirectory "sbv-shared-driver-init" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5] + value <- cgInput "value" :: SBVCodeGen (SBV (Integer, [Word8], RCSet Word8, CodeGenADT Integer, [CodeGenADT Word8])) + let (_, listValue, setValue, _, _) = untuple value + cgOutput "copy" value + cgReturn (SL.head listValue .== 6 .&& sNot (SS.member 7 setValue)) + stdoutText <- compileProgramAndRunGenerated dir "sharedDriverInitialization" program + assertBool ("Expected the mixed input's driver samples to agree: " ++ stdoutText) (") = 1" `isInfixOf` stdoutText) + driverText <- readFile (dir "sharedDriverInitialization_driver.c") + assertBool "Literal-backed list elements need no separate driver variables" + (not ("sbv_driver_input_0_field_2_element_" `isInfixOf` driverText)) + assertBool "Literal-backed set elements need no separate driver variables" + (not ("sbv_driver_input_0_field_3_element_" `isInfixOf` driverText)) + assertBool "ADT collection elements retain their explicit initialization" + ("sbv_driver_input_0_field_5_element_0" `isInfixOf` driverText) + +-- | The same tuple-element collections require individual initialization and +-- cleanup with exact integers, but borrow compound literals with mapped ones. +-- Keep both decisions tied to the selected representation, including when the +-- collections occur inside an independently owned outer tuple. +collectionDriverStorageModes :: Assertion +collectionDriverStorageModes = mapM_ check [False, True] + where check mapped = withSystemTempDirectory "sbv-collection-driver-storage" $ \dir -> do + let program = do + cgOverwriteFiles True + when mapped (cgIntegerSize 64) + cgSetDriverValues [10] + value <- cgInput "value" :: SBVCodeGen (SBV (String, [(Integer, Word8)], RCSet (Integer, Word8))) + let (_, listValue, setValue) = untuple value + (firstValue, _) = untuple (SL.head listValue) + cgOutput "copy" value + cgReturn (firstValue .== 11 .&& SS.member (tuple (12, 13)) setValue) + stdoutText <- compileProgramAndRunGenerated dir "collectionDriverStorage" program + assertBool ("Expected the collection driver samples to agree: " ++ stdoutText) (") = 1" `isInfixOf` stdoutText) + driverText <- readFile (dir "collectionDriverStorage_driver.c") + forM_ [2, 3 :: Int] $ \fieldIndex -> forM_ [0 .. 2 :: Int] $ \elementIndex -> do + let elementName = "sbv_driver_input_0_field_" ++ show fieldIndex ++ "_element_" ++ show elementIndex + clearsElement line = "sbv_tuple_owned_release_" `isInfixOf` line && ("(&" ++ elementName ++ ");") `isInfixOf` line + assertEqual ("Element variables follow storage selection: " ++ elementName) + (not mapped) (elementName `isInfixOf` driverText) + assertEqual ("Element cleanup follows initialization: " ++ elementName) + (not mapped) (any clearsElement (lines driverText)) + +-- | Exercise all three instances of the shared arena emitter, including empty +-- allocation, element alignment, independent payloads, repeated cleanup, and +-- overflow of both the payload multiplication and allocation-header addition. +ownershipArenaChecks :: Assertion +ownershipArenaChecks = withSystemTempDirectory "sbv-ownership-arenas" $ \dir -> do + compileToC (Just dir) "ownershipArenas" $ do + cgOverwriteFiles True + cgGenerateDriver False + stringValue <- cgInput "string" :: SBVCodeGen SString + listValue <- cgInput "list" :: SBVCodeGen (SList Word32) + setValue <- cgInput "set" :: SBVCodeGen (SSet Word32) + cgOutput "stringCopy" (stringValue SL.++ stringValue) + cgOutput "listCopy" (listValue SL.++ listValue) + cgOutput "setCopy" (SS.insert 7 setValue) + appendFile (dir "ownershipArenas.c") $ unlines + [ "int main(int argc, char **argv) {" + , " sbv_text_ctx text_ctx = {NULL};" + , " sbv_list_ctx list_ctx = {NULL};" + , " sbv_set_ctx set_ctx = {NULL};" + , " if (argc != 2) return 2;" + , " switch (argv[1][0]) {" + , " case '0': {" + , " if (sbv_text_alloc(&text_ctx, 0) != NULL) return 3;" + , " if (sbv_list_alloc(&list_ctx, 0, 0) != NULL) return 4;" + , " if (sbv_set_alloc(&set_ctx, 0, 0) != NULL) return 5;" + , " if (text_ctx.head != NULL || list_ctx.head != NULL || set_ctx.head != NULL) return 6;" + , " uint8_t *first = sbv_text_alloc(&text_ctx, 2); first[0] = 17; first[1] = 19;" + , " uint8_t *second = sbv_text_alloc(&text_ctx, 1); second[0] = 23;" + , " long double *items = (long double *) sbv_list_alloc(&list_ctx, 2, sizeof(*items));" + , " long double *members = (long double *) sbv_set_alloc(&set_ctx, 2, sizeof(*members));" + , " if ((uintptr_t) items % _Alignof(long double) != 0) return 7;" + , " if ((uintptr_t) members % _Alignof(long double) != 0) return 8;" + , " items[0] = 29; items[1] = 31; members[0] = 37; members[1] = 41;" + , " (void) sbv_list_alloc(&list_ctx, 3, sizeof(*items));" + , " (void) sbv_set_alloc(&set_ctx, 3, sizeof(*members));" + , " if (first[0] != 17 || first[1] != 19 || second[0] != 23) return 9;" + , " if (items[0] != 29 || items[1] != 31 || members[0] != 37 || members[1] != 41) return 10;" + , " break;" + , " }" + , " case '1': (void) sbv_text_alloc(&text_ctx, SIZE_MAX); break;" + , " case '2': (void) sbv_list_alloc(&list_ctx, 1, 0); break;" + , " case '3': (void) sbv_set_alloc(&set_ctx, 1, 0); break;" + , " case '4': (void) sbv_list_alloc(&list_ctx, SIZE_MAX / 2 + 1, 2); break;" + , " case '5': (void) sbv_set_alloc(&set_ctx, SIZE_MAX / 2 + 1, 2); break;" + , " case '6': (void) sbv_list_alloc(&list_ctx, SIZE_MAX, 1); break;" + , " case '7': (void) sbv_set_alloc(&set_ctx, SIZE_MAX, 1); break;" + , " default: return 11;" + , " }" + , " sbv_text_ctx_end(&text_ctx); sbv_list_ctx_end(&list_ctx); sbv_set_ctx_end(&set_ctx);" + , " if (text_ctx.head != NULL || list_ctx.head != NULL || set_ctx.head != NULL) return 12;" + , " sbv_text_ctx_end(&text_ctx); sbv_list_ctx_end(&list_ctx); sbv_set_ctx_end(&set_ctx);" + , " return 0;" + , "}" + ] + writeFile (dir "caller.mk") $ unlines + [ "ownershipArenas: ownershipArenas.o" + , "\t${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} ${SBV_LIBS}" + ] + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, "ownershipArenas"] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (normalExit, _, normalError) <- readProcessWithExitCode (dir "ownershipArenas") ["0"] "" + assertEqual normalError ExitSuccess normalExit + forM_ [1 :: Int .. 7] $ \scenario -> do + (runExit, _, runError) <- readProcessWithExitCode (dir "ownershipArenas") [show scenario] "" + assertBool ("Expected arena size check " ++ show scenario ++ " to abort: " ++ runError) (runExit /= ExitSuccess) + +-- | Runtime-empty operands require no arena allocation for text, scalar lists, +-- or lists of owned strings. Public outputs must still be independent copies, +-- including when both operands are nonempty or contain embedded NULs and UTF-8. +emptyConcatenation :: Assertion +emptyConcatenation = withSystemTempDirectory "sbv-empty-concat" $ \dir -> do + compileToC (Just dir) "emptyConcat" $ do + cgOverwriteFiles True + cgGenerateDriver False + textLeft <- cgInput "textLeft" :: SBVCodeGen SString + textRight <- cgInput "textRight" :: SBVCodeGen SString + listLeft <- cgInput "listLeft" :: SBVCodeGen (SList Word32) + listRight <- cgInput "listRight" :: SBVCodeGen (SList Word32) + ownedLeft <- cgInput "ownedLeft" :: SBVCodeGen (SList String) + ownedRight <- cgInput "ownedRight" :: SBVCodeGen (SList String) + cgOutput "textCopy" (textLeft SL.++ textRight) + cgOutput "listCopy" (listLeft SL.++ listRight) + cgOutput "ownedCopy" (ownedLeft SL.++ ownedRight) + appendFile (dir "emptyConcat.c") $ unlines + [ "#include " + , "int main(void) {" + , " for (unsigned scenario = 0; scenario < 4; ++scenario) {" + , " sbv_text_ctx text_ctx = {NULL}; sbv_list_ctx list_ctx = {NULL};" + , " uint8_t bytes[] = {0xc3, 0xa9, 0}; SWord32 numbers[] = {7, 11};" + , " SString text_value = sbv_string_borrow(bytes, 3, 2);" + , " SString text_empty = sbv_string_borrow(NULL, 0, 0);" + , " SBVList_u32 list_value = {numbers, 2}, list_empty = {NULL, 0};" + , " SBVList_string owned_value = {&text_value, 1}, owned_empty = {NULL, 0};" + , " SString text_left = (scenario & 1) ? text_value : text_empty;" + , " SString text_right = (scenario & 2) ? text_value : text_empty;" + , " SBVList_u32 list_left = (scenario & 1) ? list_value : list_empty;" + , " SBVList_u32 list_right = (scenario & 2) ? list_value : list_empty;" + , " SBVList_string owned_left = (scenario & 1) ? owned_value : owned_empty;" + , " SBVList_string owned_right = (scenario & 2) ? owned_value : owned_empty;" + , " SString text_result = sbv_text_concat(&text_ctx, text_left, text_right);" + , " SBVList_u32 list_result = sbv_list_u32_concat(&list_ctx, list_left, list_right);" + , " SBVList_string owned_result = sbv_list_string_concat(&list_ctx, owned_left, owned_right);" + , " const size_t copies = ((scenario & 1) != 0) + ((scenario & 2) != 0);" + , " assert(text_result.byte_length == 3 * copies && text_result.length == 2 * copies);" + , " assert(list_result.length == 2 * copies && owned_result.length == copies);" + , " if (scenario != 3) {" + , " assert(text_ctx.head == NULL && list_ctx.head == NULL);" + , " assert(text_result.data == (scenario == 0 ? NULL : bytes));" + , " assert(list_result.data == (scenario == 0 ? NULL : numbers));" + , " assert(owned_result.data == (scenario == 0 ? NULL : &text_value));" + , " } else {" + , " assert(text_ctx.head != NULL && list_ctx.head != NULL);" + , " }" + , " sbv_text_ctx_end(&text_ctx); sbv_list_ctx_end(&list_ctx);" + , " SString text_copy; SBVList_u32 list_copy; SBVList_string owned_copy;" + , " emptyConcat(text_left, text_right, list_left, list_right, owned_left, owned_right," + , " &text_copy, &list_copy, &owned_copy);" + , " bytes[0] = 'x'; numbers[0] = 99;" + , " assert(text_copy.byte_length == 3 * copies && text_copy.length == 2 * copies);" + , " assert(list_copy.length == 2 * copies && owned_copy.length == copies);" + , " for (size_t i = 0; i < copies; ++i) {" + , " assert(text_copy.data[3 * i] == 0xc3 && text_copy.data[3 * i + 1] == 0xa9 && text_copy.data[3 * i + 2] == 0);" + , " assert(list_copy.data[2 * i] == 7 && list_copy.data[2 * i + 1] == 11);" + , " assert(owned_copy.data[i].byte_length == 3 && owned_copy.data[i].length == 2);" + , " assert(owned_copy.data[i].data[0] == 0xc3 && owned_copy.data[i].data[1] == 0xa9 && owned_copy.data[i].data[2] == 0);" + , " }" + , " sbv_string_release(&text_copy); sbv_list_release_u32(&list_copy); sbv_list_release_string(&owned_copy);" + , " }" + , " return 0;" + , "}" + ] + runEmbeddedCaller dir "emptyConcat" + +-- | Sharing non-speculatable arithmetic in a straight-line program needs one +-- assignment, not a zero initializer, readiness flag, or conditional wrapper. +straightLineSharing :: Assertion +straightLineSharing = mapM_ check [("sharedDouble", doubles), ("sharedInteger", integers)] + where doubles = do + value <- cgInput "value" :: SBVCodeGen SDouble + let productValue = value * value + cgOutput "first" productValue + cgOutput "second" productValue + integers = do + value <- cgInput "value" :: SBVCodeGen SInteger + let productValue = value * value + cgOutput "first" productValue + cgOutput "second" productValue + check (entry, program) = withSystemTempDirectory "sbv-straight-sharing" $ \dir -> do + outputText <- compileProgramAndRunGenerated dir entry $ do + cgOverwriteFiles True + cgSetDriverValues [7] + program + source <- readFile (dir entry ++ ".c") + assertBool source (not ("sbv_ready_" `isInfixOf` source)) + assertBool source (not ("= {0}" `isInfixOf` source)) + assertBool source (not ("sbv_gmp_integer_shift" `isInfixOf` source)) + assertBool outputText ("49" `isInfixOf` outputText || "0x1.88p+5" `isInfixOf` outputText) + +-- | Build a translation unit containing its own test main, preserving the +-- same compilation, sanitizer, and dependency flags at the final link step. +runEmbeddedCaller :: FilePath -> String -> Assertion +runEmbeddedCaller dir entry = do + writeFile (dir "caller.mk") $ unlines + [entry ++ ": " ++ entry ++ ".o" + , "\t${CC} ${CCFLAGS} $^ -o $@ ${LDFLAGS} ${SBV_LIBS}" + ] + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, entry] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (runExit, _, runError) <- readProcessWithExitCode (dir entry) [] "" + assertEqual runError ExitSuccess runExit + +-- | Linker settings must survive a caller's LDFLAGS, and disabling assertions +-- must remove executable checks without imposing floating rules on integer C. +reviewedBuildOptions :: Assertion +reviewedBuildOptions = withSystemTempDirectory "sbv-reviewed-options" $ \dir -> do + compileToC (Just dir) "INTERVAL" $ do + cgOverwriteFiles True + cgIgnoreSAssert True + cgAddLDFlags ["-lm"] + cgSetDriverValues [7] + value <- cgInput "PRIMARY" :: SBVCodeGen SInteger + cgReturn (sAssert Nothing "deliberately disabled" (value .< 0) (value + 1)) + makefile <- readFile (dir "Makefile") + header <- readFile (dir "INTERVAL.h") + assertBool makefile (not ("-ffp-contract" `isInfixOf` makefile)) + assertBool "cgAddLDFlags must contribute to separately retained link dependencies" + ("SBV_LIBS?=" `isInfixOf` makefile && "-lm" `isInfixOf` makefile) + assertBool header (not ("__FAST_MATH__" `isInfixOf` header)) + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir, "LDFLAGS="] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (runExit, outputText, runError) <- readProcessWithExitCode (dir "INTERVAL_driver") [] "" + assertEqual runError ExitSuccess runExit + assertBool outputText ("=8" `isInfixOf` outputText) + +-- | A library header must retain user prototypes needed by its translation +-- units, even when the external implementation is supplied at final linking. +libraryExternalPrototypes :: Assertion +libraryExternalPrototypes = withSystemTempDirectory "sbv-library-prototypes" $ \dir -> do + _ <- compileToCLib (Just dir) "prototypeLibrary" + [("externalCall", do cgOverwriteFiles True + cgAddPrototype ["SWord8 external(SWord8);"] + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (uninterpret "external" value :: SWord8))] + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir, "externalCall.o"] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + +-- | Reject invalid library layouts before rendering any files. Driver symbols +-- are checked separately from file names, and disabled drivers reserve neither. +libraryValidation :: Assertion +libraryValidation = do + mapM_ check + [("emptyLibrary", [], "at least one component") + , ("duplicateLibrary", [("duplicate", program True), ("duplicate", program True)], "Duplicate component names") + , ("fileLibrary", [("fileLibrary_driver", program True)], "Conflicting generated file names") + , ("symbolLibrary", [("entry", program True), ("entry_driver", program False)], "Conflicting generated entry points") + , ("mainLibrary", [("main", program True)], "reserved C/backend name") + , ("caseLibrary", [("entry", program True), ("Entry", program True)], "Conflicting generated file names") + ] + withSystemTempDirectory "sbv-library-no-drivers" $ \dir -> do + _ <- compileToCLib (Just dir) "noDriverLibrary" + [("noDriverLibrary_driver", program False), ("entry", program False), ("entry_driver", program False)] + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + where program driver = do + cgOverwriteFiles True + cgGenerateDriver driver + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn value + + check (libName, components, diagnostic) = withSystemTempDirectory "sbv-library-validation" $ \dir -> do + result <- try (compileToCLib (Just dir) libName components) :: IO (Either ErrorCall [()]) + case result of + Left exception -> assertBool (displayException exception) (diagnostic `isInfixOf` displayException exception) + Right _ -> assertBool ("Expected library rejection: " ++ libName) False + assertEqual "Invalid libraries must not write files" [] =<< listDirectory dir + +-- | Check all public naming entry points and ensure diagnostics precede any +-- file writes, including names that could otherwise escape the output directory. +publicCNameValidation :: Assertion +publicCNameValidation = do + mapM_ (\badName -> rejects $ \dir -> compileToC (Just dir) badName scalar) + ["", "my-function", "../escape", "line\nbreak", "switch", "9lives", "caf\233", "sbv_bv_s16_mul", "SBVList_u8", "SFP7_19", "__result", "printf", "remainder", "uint32_t"] + rejects $ \dir -> compileToC (Just dir) "badInput" $ do + value <- cgInput "switch" :: SBVCodeGen SWord8 + cgReturn value + rejects $ \dir -> compileToC (Just dir) "badOutput" $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgOutput "sbv_output_0" value + rejects $ \dir -> compileToC (Just dir) "badInputGroup" $ do + values <- cgInputArr 2 "my-values" :: SBVCodeGen [SWord8] + cgReturnArr values + rejects $ \dir -> compileToC (Just dir) "badOutputGroup" $ cgOutputArr "int" [literal (3 :: Word8)] + rejects $ \dir -> void $ compileToCLib (Just dir) "my-library" [("component", scalar)] + rejects $ \dir -> void $ compileToCLib (Just dir) "validLibrary" [("my-component", scalar)] + where scalar = do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn value + + rejects generate = withSystemTempDirectory "sbv-c-names" $ \dir -> do + result <- try (generate dir) :: IO (Either ErrorCall ()) + case result of + Left exception -> assertBool (displayException exception) ("Invalid" `isInfixOf` displayException exception) + Right _ -> assertBool "Expected a public name diagnostic" False + assertEqual "Invalid names must not write files" [] =<< listDirectory dir + +-- | Keep valid identifiers in the ABI while isolating symbolic temporaries, +-- table names, and recursively generated driver storage from user names. +privateCBindings :: Assertion +privateCBindings = withSystemTempDirectory "sbv-private-c-bindings" $ \dir -> do + compileToC (Just dir) "s0" $ do + cgOverwriteFiles True + cgSetDriverValues [7, 2, 3, 4, 5] + value <- cgInput "s0" :: SBVCodeGen SWord8 + tableValue <- cgInput "table0" :: SBVCodeGen SWord8 + values <- cgInput "values" :: SBVCodeGen (SList Integer) + moreValues <- cgInput "values_data" :: SBVCodeGen (SList Integer) + group <- cgInputArr 1 "group" :: SBVCodeGen [SWord8] + cgOutput "s1" (select [value, value+1, value+2] 0 tableValue) + cgOutput "group_ctr" (sum group) + cgOutput "values_element_0" moreValues + cgReturn values + headerText <- readFile (dir "s0.h") + mapM_ (\fragment -> assertBool headerText (fragment `isInfixOf` headerText)) + ["SWord8 s0", "SWord8 table0", "*s1", "*group_ctr"] + outputText <- compileAndRunGenerated dir "s0" + mapM_ (\fragment -> assertBool outputText (fragment `isInfixOf` outputText)) + ["s1 = 9", "group_ctr = 5", "values_element_0 =", "s0(7, 2, values, values_data, group"] + +-- | Distinct recursive ADTs must coexist both directly and through every +-- structural wrapper. Repeated library components must deduplicate each +-- type's helpers without suppressing the differently-cased companion. +caseSensitiveCKinds :: Assertion +caseSensitiveCKinds = mapM_ check [False, True] + where check library = withSystemTempDirectory "sbv-case-sensitive-kinds" $ \dir -> do + if library + then do _ <- compileToCLib (Just dir) "caseSensitiveKinds" [("firstCase", program), ("secondCase", program)] + pure () + else compileToC (Just dir) "caseSensitiveKinds" program + outputText <- compileAndRunGenerated dir "caseSensitiveKinds" + mapM_ (\fragment -> assertBool outputText (fragment `isInfixOf` outputText)) + ["CGCaseNext", "CGCASENext", "lowerList =", "upperList =", "lowerSet =", "upperSet ="] + + program = do + cgOverwriteFiles True + cgSetDriverValues (repeat 1) + lower <- cgInput "lower" :: SBVCodeGen (SBV CodeGenCase) + upper <- cgInput "upper" :: SBVCodeGen (SBV CodeGenCASE) + lowerTuple <- cgInput "lowerTuple" :: SBVCodeGen (SBV (CodeGenCase, Word8)) + upperTuple <- cgInput "upperTuple" :: SBVCodeGen (SBV (CodeGenCASE, Word8)) + lowerList <- cgInput "lowerListInput" :: SBVCodeGen (SList CodeGenCase) + upperList <- cgInput "upperListInput" :: SBVCodeGen (SList CodeGenCASE) + lowerSet <- cgInput "lowerSetInput" :: SBVCodeGen (SSet CodeGenCase) + upperSet <- cgInput "upperSetInput" :: SBVCodeGen (SSet CodeGenCASE) + lowerArray <- cgInput "lowerArray" :: SBVCodeGen (SArray Word8 CodeGenCase) + upperArray <- cgInput "upperArray" :: SBVCodeGen (SArray Word8 CodeGenCASE) + cgOutput "lowerChild" (getCGCaseNext_1 lower) + cgOutput "upperChild" (getCGCASENext_1 upper) + cgOutput "lowerPair" lowerTuple + cgOutput "upperPair" upperTuple + cgOutput "lowerList" lowerList + cgOutput "upperList" upperList + cgOutput "lowerSet" lowerSet + cgOutput "upperSet" upperSet + cgOutput "lowerArrayResult" (writeArray lowerArray 0 lower) + cgOutput "upperArrayResult" (writeArray upperArray 0 upper) + cgReturn (tuple (sCGCaseNext lower, sCGCASENext upper)) + +-- | Different placements of tuple and array boundaries produce distinct C +-- descriptor names, and the framed names agree across declarations, storage, +-- access helpers, and driver-side ownership operations. +structuralCNameFraming :: Assertion +structuralCNameFraming = withSystemTempDirectory "sbv-structural-c-names" $ \dir -> do + compileToC (Just dir) "structuralNames" $ do + cgOverwriteFiles True + cgSetDriverValues [7, 0, 0] + value <- cgInput "value" :: SBVCodeGen SWord32 + keyed <- cgInput "keyed" :: SBVCodeGen (SArray (Word8, Word16) Word32) + paired <- cgInput "paired" :: SBVCodeGen (SArray Word8 (Word16, Word32)) + let key = tuple (1 :: SWord8, 2 :: SWord16) + keyedResult = writeArray keyed key value + pairedResult = writeArray paired 1 (tuple (2 :: SWord16, value)) + nested = constArray (constArray value :: SArray Word16 Word32) :: SArray Word8 (ArrayModel Word16 Word32) + (_, pairedValue) = untuple (readArray pairedResult 1) + cgOutput "keyedResult" keyedResult + cgOutput "pairedResult" pairedResult + cgOutput "nested" nested + cgReturn (readArray keyedResult key .== value .&& pairedValue .== value .&& readArray (readArray nested 1) 2 .== value) + headerText <- readFile (dir "structuralNames.h") + mapM_ (\typeName -> assertBool headerText (typeName `isInfixOf` headerText)) + ["SBVArrayOutput_13_t2_2_u8_3_u16_3_u32" + , "SBVArrayOutput_2_u8_14_t2_3_u16_3_u32" + , "SBVArrayOutput_2_u8_20_array_11_3_u16_3_u32" + ] + outputText <- compileAndRunGenerated dir "structuralNames" + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Use a hand-written caller to check output reuse, independent ownership, +-- borrowed array reads, and balanced callback lifetimes across library calls. +libraryOwnershipContract :: Assertion +libraryOwnershipContract = withSystemTempDirectory "sbv-library-ownership" $ \dir -> do + let component program = do + cgOverwriteFiles True + cgGenerateDriver False + program + _ <- compileToCLib (Just dir) "ownershipLibrary" + [("copyLists", component $ do + values <- cgInput "values" :: SBVCodeGen (SList Word16) + cgOutput "copy" values + cgReturn values) + , ("listArray", component $ do + values <- cgInput "values" :: SBVCodeGen (SList Word16) + cgReturn (constArray values :: SArray Word8 [Word16])) + , ("retainArray", component $ do + values <- cgInput "values" :: SBVCodeGen (SArray Word8 Word16) + cgReturn (writeArray values 0 42)) + , ("readArrayValue", component $ do + values <- cgInput "values" :: SBVCodeGen (SArray Word8 Word16) + cgReturn (readArray values 1)) + , ("exactOutputs", component $ do + value <- cgInput "value" :: SBVCodeGen SInteger + cgOutput "copy" (value + 1) + cgReturn (value + 2)) + ] + compileAndRunCaller dir "ownershipLibrary" $ unlines + ["#include \"ownershipLibrary.h\"" + , "#include " + , "typedef struct { unsigned references; SWord16 value; } Context;" + , "static unsigned live_contexts;" + , "static SWord16 lookup(const void *opaque, SWord8 key)" + , "{ const Context *context = opaque; return context->value + key; }" + , "static const void *retain(const void *opaque)" + , "{ Context *context = (Context *) opaque; ++context->references; return context; }" + , "static void release(const void *opaque)" + , "{ Context *context = (Context *) opaque; if (--context->references == 0) { --live_contexts; free(context); } }" + , "int main(void)" + , "{" + , " mpz_t input, first, second; mpz_inits(input, first, second, NULL);" + , " for (unsigned i = 0; i < 32; ++i) {" + , " SWord16 data[] = {7, 11}; SBVList_u16 borrowed = {data, 2}, copy;" + , " SBVList_u16 result = copyLists(borrowed, ©);" + , " data[0] = 99;" + , " assert(copy.data[0] == 7 && result.data[0] == 7);" + , " sbv_list_release_u16(©);" + , " assert(result.data[1] == 11);" + , " copy = copyLists(result, &borrowed);" + , " sbv_list_release_u16(&result); sbv_list_release_u16(&borrowed);" + , " SBVArrayOutput_2_u8_10_list_3_u16 array = listArray(copy);" + , " sbv_list_release_u16(©);" + , " SBVList_u16 read = sbv_array_output_read_2_u8_10_list_3_u16(array, 3);" + , " SBVList_u16 saved = sbv_list_clone_u16(read);" + , " sbv_array_output_release_2_u8_10_list_3_u16(&array);" + , " assert(saved.length == 2 && saved.data[0] == 7); sbv_list_release_u16(&saved);" + , " Context *context = malloc(sizeof *context); assert(context != NULL);" + , " *context = (Context) {1, 17}; ++live_contexts;" + , " SBVArrayInput_2_u8_3_u16 source = {lookup, context, retain, release};" + , " assert(readArrayValue(source) == 18 && context->references == 1);" + , " SBVArrayOutput_2_u8_3_u16 owned = retainArray(source);" + , " release(context);" + , " SBVArrayOutput_2_u8_3_u16 retained = sbv_array_output_retain_2_u8_3_u16(owned);" + , " sbv_array_output_release_2_u8_3_u16(&owned);" + , " assert(readArrayValue(sbv_array_output_as_input_2_u8_3_u16(retained)) == 18);" + , " assert(sbv_array_output_read_2_u8_3_u16(retained, 0) == 42);" + , " sbv_array_output_release_2_u8_3_u16(&retained); assert(live_contexts == 0);" + , " mpz_set_ui(input, i); exactOutputs(input, first, second);" + , " assert(mpz_cmp_ui(first, i + 1) == 0 && mpz_cmp_ui(second, i + 2) == 0);" + , " }" + , " mpz_clears(input, first, second, NULL); return 0;" + , "}" + ] + +-- | Compile and execute an independent C caller against a generated library. +-- Use its Makefile so compiler overrides, dependencies, and runtime link flags +-- match those used for the generated translation units. +compileAndRunCaller :: FilePath -> String -> String -> Assertion +compileAndRunCaller dir libraryName source = do + writeFile (dir "caller.c") source + writeFile (dir "caller.mk") $ unlines + ["caller: caller.c " ++ libraryName ++ ".h " ++ libraryName ++ ".a" + , "\t${CC} ${CCFLAGS} ${GMP_CFLAGS} caller.c " ++ libraryName ++ ".a ${LDFLAGS} ${SBV_LIBS} -o $@" + ] + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir, "caller"] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, _, runError) <- readProcessWithExitCode (dir "caller") [] "" + assertEqual runError ExitSuccess runExit + +-- | Library calls share the standalone fail-fast contract. Exercise both +-- executable hard constraints and explicit assertions in separate processes. +libraryRuntimeFailures :: Assertion +libraryRuntimeFailures = mapM_ check [False, True] + where check assertion = withSystemTempDirectory "sbv-library-fail-fast" $ \dir -> do + _ <- compileToCLib (Just dir) "failFastLibrary" + [("checkedEntry", do cgOverwriteFiles True + cgSetDriverValues [7] + value <- cgInput "value" :: SBVCodeGen SWord8 + if assertion + then cgReturn (sAssert Nothing "library assertion" (value .< 5) value) + else do constrain (value .< 5) + cgReturn value)] + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, _, runError) <- readProcessWithExitCode (dir "failFastLibrary_driver") [] "" + assertBool "Expected a failed library call to terminate the process" (runExit /= ExitSuccess) + let diagnostic = if assertion then "ASSERTION FAILED" else "CONSTRAINT FAILED" + assertBool runError (diagnostic `isInfixOf` runError) + +-- | Finite sums and products have complete universes even when constructors +-- carry fields. Dynamic inputs prevent constant folding from hiding the C +-- finite/cofinite comparison; both regular and complemented inputs are tested. +finiteADTSetUniverses :: Assertion +finiteADTSetUniverses = mapM_ check [1, 2] + where check seed = withSystemTempDirectory "sbv-finite-adt-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [seed, seed] + simple <- cgInput "simple" :: SBVCodeGen (SSet (Maybe Bool)) + nested <- cgInput "nested" :: SBVCodeGen (SSet (Maybe (Either Bool Bool), Bool)) + let simpleUniverse = SS.fromList [Nothing, Just False, Just True] + alternatives = [Nothing, Just (Left False), Just (Left True), Just (Right False), Just (Right True)] + nestedUniverse = SS.fromList [(value, flag) | value <- alternatives, flag <- [False, True]] + simpleFull = simple `SS.union` simpleUniverse + nestedFull = nested `SS.union` nestedUniverse + cgReturn (simpleFull .== SS.full .&& nestedFull .== SS.full .&& SS.full `SS.isSubsetOf` nestedFull) + outputText <- compileProgramAndRunGenerated dir "finiteADTUniverses" program + assertBool outputText ("= 1" `isInfixOf` outputText) + +-- | Compile and execute a scalar program using only the public compatibility +-- module's code-generation interface. +legacyPublicFacade :: Assertion +legacyPublicFacade = withSystemTempDirectory "sbv-legacy-c-backend" $ \dir -> do + let programDir = dir "program" + libraryDir = dir "library" + + PublicLegacy.compileToC (Just programDir) "legacyFacade" $ do + PublicLegacy.cgOverwriteFiles True + PublicLegacy.cgSetDriverValues [41] + value <- PublicLegacy.cgInput "value" :: PublicLegacy.SBVCodeGen SWord32 + PublicLegacy.cgReturn (value + 1) + + programOutput <- compileAndRunGenerated programDir "legacyFacade" + let expectedProgram = "0x0000002aUL" + assertBool ("Expected legacy generated output to contain " ++ expectedProgram ++ ", received:\n" ++ programOutput) (expectedProgram `isInfixOf` programOutput) + + let component operation = do + PublicLegacy.cgOverwriteFiles True + PublicLegacy.cgSetDriverValues [41] + value <- PublicLegacy.cgInput "value" :: PublicLegacy.SBVCodeGen SWord32 + PublicLegacy.cgReturn (operation value) + _ <- PublicLegacy.compileToCLib (Just libraryDir) "legacyLibrary" + [ ("increment", component (+ 1)) + , ("twice", component (* 2)) + ] + libraryOutput <- compileAndRunGenerated libraryDir "legacyLibrary" + let expectedLibrary = ["0x0000002aUL", "0x00000052UL"] + mapM_ (\expected -> assertBool ("Expected legacy library output to contain " ++ expected ++ ", received:\n" ++ libraryOutput) (expected `isInfixOf` libraryOutput)) expectedLibrary + (_, _, lowLevelProgram) <- PublicLegacy.compileToC' "legacyLowLevel" (component (+ 1)) + (_, _, lowLevelLibrary) <- PublicLegacy.compileToCLib' "legacyLowLevelLibrary" [("increment", component (+ 1))] + assertBool "Public Legacy low-level entry points must generate bundles" + ("legacyLowLevel.c" `isInfixOf` show lowLevelProgram && "legacyLowLevelLibrary.a" `isInfixOf` show lowLevelLibrary) + +-- | Build and execute a generated C program or library driver with strict +-- warnings so representation and ownership qualifier errors cannot pass silently. +compileAndRunGenerated :: FilePath -> String -> IO String +compileAndRunGenerated dir executableName = do + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, outputText, runError) <- readProcessWithExitCode (dir executableName ++ "_driver") [] "" + assertEqual runError ExitSuccess runExit + pure outputText + +-- | Exercise Unicode and embedded-NUL literals, character-based indexing, +-- string combinators, exact numeric conversions, printing, and owned results. +characterStrings :: Assertion +characterStrings = withSystemTempDirectory "sbv-character-strings" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [7, 1, 65] + value <- cgInput "value" :: SBVCodeGen SString + index <- cgInput "index" :: SBVCodeGen SInteger + character <- cgInput "character" :: SBVCodeGen SChar + let joined = value SL.++ literal "\955\NUL" + numeric = SL.replace value value (literal "123") + parsed = SL.strToNat numeric + indexedChar = SL.elemAt joined index + cgOutput "length" (SL.length joined) + cgOutput "lambdaIndex" (SL.indexOf joined (literal "\955")) + cgOutput "contains" (literal "v7" `SL.isInfixOf` joined) + cgOutput "prefix" (literal "sbv" `SL.isPrefixOf` joined) + cgOutput "suffix" (literal "\955\NUL" `SL.isSuffixOf` joined) + cgOutput "sameObject" (value .=== value) + cgOutput "ordered" (value .< joined) + cgOutput "slice" (SL.subList joined 3 2) + cgOutput "replacement" (SL.replace joined (literal "bv") (literal "X")) + cgOutput "indexedChar" indexedChar + cgOutput "characterCode" (SC.ord indexedChar) + cgOutput "roundTripChar" (SC.chr (SC.ord indexedChar)) + cgOutput "inputCharacter" character + cgOutput "parsed" parsed + cgOutput "rendered" (SL.natToStr (parsed + 1)) + cgReturn joined + + stdoutText <- compileProgramAndRunGenerated dir "characterStrings" program + headerText <- readFile (dir "characterStrings.h") + mapM_ (\fragment -> assertBool ("Expected generated text output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =sbv7\955\NUL" + , "length =6" + , "lambdaIndex =4" + , "contains = 1" + , "prefix = 1" + , "suffix = 1" + , "sameObject = 1" + , "ordered = 1" + , "slice =7\955" + , "replacement =sX7\955\NUL" + , "indexedChar =b" + , "characterCode =98" + , "roundTripChar =b" + , "inputCharacter =a" + , "parsed =123" + , "rendered =124" + ] + assertBool "Expected a length-aware public string descriptor" + ("size_t byte_length;" `isInfixOf` headerText && "size_t length;" `isInfixOf` headerText) + assertBool "Expected public string ownership helpers" + ("sbv_string_clone" `isInfixOf` headerText && "sbv_string_release" `isInfixOf` headerText) + +-- | Exercise string indices and numeric conversions when the user explicitly +-- selects the historical lossy native mapping for 'SInteger'. +mappedIntegerStrings :: Assertion +mappedIntegerStrings = withSystemTempDirectory "sbv-mapped-integer-strings" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 64 + cgSetDriverValues [42, 1] + value <- cgInput "value" :: SBVCodeGen SString + index <- cgInput "index" :: SBVCodeGen SInteger + cgOutput "selected" (SL.elemAt value index) + cgOutput "numeric" (SL.strToNat (SL.replace value value (literal "99"))) + cgReturn (SL.natToStr (SL.length value + 1)) + + stdoutText <- compileProgramAndRunGenerated dir "mappedIntegerStrings" program + mapM_ (\fragment -> assertBool ("Expected mapped-integer text output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =6" + , "selected =b" + , "numeric = 99LL" + ] + +-- | Exercise guarded string declarations and independent owned returns from +-- multiple generated library translation units. +ownedStringLibrary :: Assertion +ownedStringLibrary = withSystemTempDirectory "sbv-owned-string-library" $ \dir -> do + let component suffix seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + value <- cgInput "value" :: SBVCodeGen SString + cgReturn (value SL.++ suffix) + + (_, cfg, bundle) <- compileToCLib' "ownedStringLibrary" + [ ("firstText", component (literal "\955") 4) + , ("secondText", component (literal "!") 5) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "ownedStringLibrary" + assertBool ("Expected both owned string results, received:\n" ++ stdoutText) + ("sbv4\955" `isInfixOf` stdoutText && "sbv5!" `isInfixOf` stdoutText) + +-- | Exercise the primitive symbolic-list operations, exact indices, borrowed +-- inputs, and independently owned output and return values. +symbolicLists :: Assertion +symbolicLists = withSystemTempDirectory "sbv-symbolic-lists" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 1] + values <- cgInput "values" :: SBVCodeGen (SList Word16) + index <- cgInput "index" :: SBVCodeGen SInteger + let suffix = literal ([99, 100] :: [Word16]) + joined = values SL.++ suffix + contains = suffix `SL.isInfixOf` joined + slice = SL.subList joined 2 2 + replaced = SL.replace joined (literal ([11, 12] :: [Word16])) (SL.singleton 77) + cgOutput "length" (SL.length joined) + cgOutput "selected" (SL.elemAt joined index) + cgOutput "suffixIndex" (SL.indexOf joined suffix) + cgOutput "contains" contains + cgOutput "prefix" (values `SL.isPrefixOf` joined) + cgOutput "suffix" (suffix `SL.isSuffixOf` joined) + cgOutput "sameObject" (values .=== values) + cgOutput "different" (values ./== suffix) + cgOutput "conditional" (ite contains joined values) + cgOutput "slice" slice + cgOutput "replaced" replaced + cgReturn joined + + stdoutText <- compileProgramAndRunGenerated dir "symbolicLists" program + headerText <- readFile (dir "symbolicLists.h") + mapM_ (\fragment -> assertBool ("Expected generated list output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =[0x000aU, 0x000bU, 0x000cU, 0x0063U, 0x0064U]" + , "length =5" + , "selected = 0x000bU" + , "suffixIndex =3" + , "contains = 1" + , "prefix = 1" + , "suffix = 1" + , "sameObject = 1" + , "different = 1" + , "conditional =[0x000aU, 0x000bU, 0x000cU, 0x0063U, 0x0064U]" + , "slice =[0x000cU, 0x0063U]" + , "replaced =[0x000aU, 0x004dU, 0x0063U, 0x0064U]" + ] + assertBool "Expected a typed public list descriptor" + ("struct SBVList_u16 { const SWord16 *data; size_t length; };" `isInfixOf` headerText) + assertBool "Expected public list ownership helpers" + ("sbv_list_clone_u16" `isInfixOf` headerText && "sbv_list_release_u16" `isInfixOf` headerText) + +-- | Check that list descriptors remain agnostic to element width by compiling +-- and executing a list whose elements use the arbitrary-width bit-vector ABI. +wideSymbolicLists :: Assertion +wideSymbolicLists = withSystemTempDirectory "sbv-wide-symbolic-lists" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + values <- cgInput "values" :: SBVCodeGen (SList (WordN 673)) + cgOutput "length" (SL.length values) + cgReturn values + + stdoutText <- compileProgramAndRunGenerated dir "wideSymbolicLists" program + headerText <- readFile (dir "wideSymbolicLists.h") + assertBool ("Expected the wide-list driver to report its three sample elements, received:\n" ++ stdoutText) + ("length =3" `isInfixOf` stdoutText) + assertBool "Expected an arbitrary-width typed list descriptor" + ("struct SBVList_u673 { const SWord673 *data; size_t length; };" `isInfixOf` headerText) + +-- | Check that arbitrary floating-point elements retain their raw interchange +-- representation and use the LibBF-backed object-equality semantics. +arbitraryFloatLists :: Assertion +arbitraryFloatLists = do + (_, _, bundle) <- compileToC' "arbitraryFloatLists" $ do + cgSetDriverValues [1] + values <- cgInput "values" :: SBVCodeGen (SList (FloatingPoint 7 19)) + cgOutput "sameObject" (values .=== values) + cgReturn values + let generated = show bundle + assertBool "Expected a typed arbitrary-float list descriptor" + ("struct SBVList_fp_e7_s19 { const SFP7_19 *data; size_t length; };" `isInfixOf` generated) + assertBool "Expected arbitrary-float list equality to use object equality" + ("sbv_fp_e7_s19_obj_eq(left, right)" `isInfixOf` generated) + +-- | Check that native floating-point list equality treats NaNs as identical +-- objects while distinguishing positive and negative zero. +nativeFloatLists :: Assertion +nativeFloatLists = withSystemTempDirectory "sbv-native-float-lists" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x7fc00000, 0x00000000, 0x80000000] + nanBits <- cgInput "nanBits" :: SBVCodeGen SWord32 + positiveBits <- cgInput "positiveBits" :: SBVCodeGen SWord32 + negativeBits <- cgInput "negativeBits" :: SBVCodeGen SWord32 + let nanList = SL.singleton (sWord32AsSFloat nanBits) + positiveList = SL.singleton (sWord32AsSFloat positiveBits) + negativeList = SL.singleton (sWord32AsSFloat negativeBits) + cgOutput "nanSameObject" (nanList .=== nanList) + cgOutput "zeroObjectsDiffer" (positiveList ./== negativeList) + cgReturn (nanList SL.++ positiveList) + + stdoutText <- compileProgramAndRunGenerated dir "nativeFloatLists" program + assertBool ("Expected native floating-point list object equality, received:\n" ++ stdoutText) + ("nanSameObject = 1" `isInfixOf` stdoutText && "zeroObjectsDiffer = 1" `isInfixOf` stdoutText) + +-- | Exercise lists after explicitly selecting the historical native mappings +-- for unbounded integers and reals, including declaration dependency order. +mappedNumericLists :: Assertion +mappedNumericLists = withSystemTempDirectory "sbv-mapped-numeric-lists" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 64 + cgSRealType CgDouble + cgSetDriverValues [7, 9] + integers <- cgInput "integers" :: SBVCodeGen (SList Integer) + reals <- cgInput "reals" :: SBVCodeGen (SList AlgReal) + cgOutput "integerLength" (SL.length integers) + cgOutput "realSameObject" (reals .=== reals) + cgReturn integers + + stdoutText <- compileProgramAndRunGenerated dir "mappedNumericLists" program + mapM_ (\fragment -> assertBool ("Expected mapped-numeric list output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "integerLength = 3LL" + , "realSameObject = 1" + , "[7LL, 8LL, 9LL]" + ] + +-- | Exercise guarded list declarations and independent owned returns from +-- multiple generated library translation units. +ownedListLibrary :: Assertion +ownedListLibrary = withSystemTempDirectory "sbv-owned-list-library" $ \dir -> do + let component suffix seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + values <- cgInput "values" :: SBVCodeGen (SList Word16) + cgReturn (values SL.++ literal suffix) + + (_, cfg, bundle) <- compileToCLib' "ownedListLibrary" + [ ("firstList", component ([40] :: [Word16]) 4) + , ("secondList", component ([50] :: [Word16]) 5) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "ownedListLibrary" + assertBool ("Expected both owned list results, received:\n" ++ stdoutText) + ("[0x0004U, 0x0005U, 0x0006U, 0x0028U]" `isInfixOf` stdoutText + && "[0x0005U, 0x0006U, 0x0007U, 0x0032U]" `isInfixOf` stdoutText) + +-- | Exercise borrowed exact elements, exact indexing and comparison, list +-- operations, and deep-cloned list results across the generated C ABI. +exactGMPLists :: Assertion +exactGMPLists = withSystemTempDirectory "sbv-exact-gmp-lists" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 20, 30, 1] + integers <- cgInput "integers" :: SBVCodeGen (SList Integer) + reals <- cgInput "reals" :: SBVCodeGen (SList AlgReal) + rationals <- cgInput "rationals" :: SBVCodeGen (SList Rational) + index <- cgInput "index" :: SBVCodeGen SInteger + let joinedIntegers = integers SL.++ literal ([13, 14] :: [Integer]) + joinedReals = reals SL.++ literal ([23, 24] :: [AlgReal]) + joinedRationals = rationals SL.++ literal ([33, 34] :: [Rational]) + cgOutput "length" (SL.length joinedIntegers) + cgOutput "selectedInteger" (SL.elemAt joinedIntegers index) + cgOutput "selectedReal" (SL.elemAt joinedReals index) + cgOutput "selectedRational" (SL.elemAt joinedRationals index) + cgOutput "outOfRange" (SL.elemAt joinedRationals 99) + cgOutput "sameIntegers" (joinedIntegers .== literal ([10, 11, 12, 13, 14] :: [Integer])) + cgOutput "realSlice" (SL.subList joinedReals 1 3) + cgOutput "rationalResult" joinedRationals + cgReturn joinedIntegers + + stdoutText <- compileProgramAndRunGenerated dir "exactGMPLists" program + headerText <- readFile (dir "exactGMPLists.h") + mapM_ (\fragment -> assertBool ("Expected exact-list output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =[10, 11, 12, 13, 14]" + , "length =5" + , "selectedInteger =11" + , "selectedReal =21" + , "selectedRational =31" + , "outOfRange =0" + , "sameIntegers = 1" + , "realSlice =[21, 22, 23]" + , "rationalResult =[30, 31, 32, 33, 34]" + ] + assertBool "Expected exact list ownership to clone and clear individual GMP elements" + ("mpz_init_set(element, value.data[i]);" `isInfixOf` headerText + && "mpz_clear(element); free(element);" `isInfixOf` headerText + && "mpq_set(element, value.data[i]);" `isInfixOf` headerText + && "mpq_clear(element); free(element);" `isInfixOf` headerText) + +-- | Exercise finite and cofinite symbolic sets, normalization, every primitive +-- set operation, and independently owned outputs and returns. +symbolicSets :: Assertion +symbolicSets = withSystemTempDirectory "sbv-symbolic-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 12, 11, 13] + left <- cgInput "left" :: SBVCodeGen (SSet Word16) + right <- cgInput "right" :: SBVCodeGen (SSet Word16) + cofinite <- cgInput "cofinite" :: SBVCodeGen (SSet Word16) + element <- cgInput "element" :: SBVCodeGen SWord16 + let inserted = SS.insert element left + deleted = SS.delete 11 inserted + unioned = SS.union left right + intersected = SS.intersection left right + subtracted = SS.difference left right + mixedUnion = SS.union left cofinite + mixedIntersection = SS.intersection left cofinite + cofiniteDifference = SS.difference cofinite left + cofiniteInserted = SS.insert 12 cofinite + cofiniteDeleted = SS.delete 14 cofinite + otherCofinite = SS.complement right + cofiniteUnion = SS.union cofinite otherCofinite + cofiniteIntersection = SS.intersection cofinite otherCofinite + cofiniteSubtraction = SS.difference cofinite otherCofinite + containsElement = element `SS.member` unioned + conditional = ite containsElement intersected subtracted + cgOutput "inserted" inserted + cgOutput "deleted" deleted + cgOutput "unioned" unioned + cgOutput "intersected" intersected + cgOutput "subtracted" subtracted + cgOutput "mixedUnion" mixedUnion + cgOutput "mixedIntersection" mixedIntersection + cgOutput "cofiniteDifference" cofiniteDifference + cgOutput "cofiniteInserted" cofiniteInserted + cgOutput "cofiniteDeleted" cofiniteDeleted + cgOutput "cofiniteUnion" cofiniteUnion + cgOutput "cofiniteIntersection" cofiniteIntersection + cgOutput "cofiniteSubtraction" cofiniteSubtraction + cgOutput "complemented" (SS.complement left) + cgOutput "containsElement" containsElement + cgOutput "subset" (intersected `SS.isSubsetOf` left) + cgOutput "sameObject" (left .=== left) + cgOutput "different" (left ./== right) + cgOutput "conditional" conditional + cgReturn unioned + + stdoutText <- compileProgramAndRunGenerated dir "symbolicSets" program + headerText <- readFile (dir "symbolicSets.h") + mapM_ (\fragment -> assertBool ("Expected generated set output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") ={0x000aU, 0x000bU, 0x000cU, 0x000dU, 0x000eU}" + , "inserted ={0x000aU, 0x000bU, 0x000cU, 0x000dU}" + , "deleted ={0x000aU, 0x000cU, 0x000dU}" + , "unioned ={0x000aU, 0x000bU, 0x000cU, 0x000dU, 0x000eU}" + , "intersected ={0x000cU}" + , "subtracted ={0x000aU, 0x000bU}" + , "mixedUnion =U - {0x000dU}" + , "mixedIntersection ={0x000aU}" + , "cofiniteDifference =U - {0x000bU, 0x000cU, 0x000dU, 0x000aU}" + , "cofiniteInserted =U - {0x000bU, 0x000dU}" + , "cofiniteDeleted =U - {0x000bU, 0x000cU, 0x000dU, 0x000eU}" + , "cofiniteUnion =U - {0x000cU, 0x000dU}" + , "cofiniteIntersection =U - {0x000bU, 0x000cU, 0x000dU, 0x000eU}" + , "cofiniteSubtraction ={0x000eU}" + , "complemented =U - {0x000aU, 0x000bU, 0x000cU}" + , "containsElement = 1" + , "subset = 1" + , "sameObject = 1" + , "different = 1" + , "conditional ={0x000cU}" + ] + assertBool "Expected a finite/cofinite public set descriptor" + ("struct SBVSet_u16 { const SWord16 *data; size_t length; bool is_complement; };" `isInfixOf` headerText) + assertBool "Expected public set ownership helpers" + ("sbv_set_clone_u16" `isInfixOf` headerText && "sbv_set_release_u16" `isInfixOf` headerText) + +-- | Check equality and subset relations when regular and complemented forms +-- denote the same set over the complete Boolean universe. +finiteUniverseSets :: Assertion +finiteUniverseSets = withSystemTempDirectory "sbv-finite-universe-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0] + inputFull <- cgInput "inputFull" :: SBVCodeGen (SSet Bool) + let regularTrue = SS.fromList [True] + cofiniteFalse = SS.complement (SS.fromList [False]) + regularFull = SS.fromList [False, True] + universal = SS.full :: SSet Bool + cgOutput "sameSingleton" (regularTrue .== cofiniteFalse) + cgOutput "sameUniverse" (regularFull .== universal) + cgOutput "leftSubset" (regularTrue `SS.isSubsetOf` cofiniteFalse) + cgOutput "rightSubset" (cofiniteFalse `SS.isSubsetOf` regularTrue) + cgOutput "normalizedInput" (inputFull .== universal) + cgReturn (regularTrue .== cofiniteFalse .&& regularFull .== universal .&& inputFull .== universal) + + stdoutText <- compileProgramAndRunGenerated dir "finiteUniverseSets" program + mapM_ (\fragment -> assertBool ("Expected finite-universe set output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") = 1" + , "sameSingleton = 1" + , "sameUniverse = 1" + , "leftSubset = 1" + , "rightSubset = 1" + , "normalizedInput = 1" + ] + +-- | Check that set descriptors remain agnostic to element width by compiling +-- and executing insert and membership over 673-bit elements. +wideSymbolicSets :: Assertion +wideSymbolicSets = withSystemTempDirectory "sbv-wide-symbolic-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 13] + values <- cgInput "values" :: SBVCodeGen (SSet (WordN 673)) + element <- cgInput "element" :: SBVCodeGen (SWord 673) + let updated = SS.insert element values + cgOutput "contains" (element `SS.member` updated) + cgReturn updated + + stdoutText <- compileProgramAndRunGenerated dir "wideSymbolicSets" program + headerText <- readFile (dir "wideSymbolicSets.h") + assertBool ("Expected arbitrary-width set membership to hold, received:\n" ++ stdoutText) + ("contains = 1" `isInfixOf` stdoutText) + assertBool "Expected an arbitrary-width typed set descriptor" + ("struct SBVSet_u673 { const SWord673 *data; size_t length; bool is_complement; };" `isInfixOf` headerText) + +-- | Exercise character elements through the shared scalar text representation +-- without requiring string ownership inside the set descriptor. +characterSets :: Assertion +characterSets = withSystemTempDirectory "sbv-character-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [64, 70] + values <- cgInput "values" :: SBVCodeGen (SSet Char) + character <- cgInput "character" :: SBVCodeGen SChar + let updated = SS.insert character values + cgOutput "contains" (character `SS.member` updated) + cgReturn updated + + stdoutText <- compileProgramAndRunGenerated dir "characterSets" program + headerText <- readFile (dir "characterSets.h") + assertBool ("Expected character-set membership to hold, received:\n" ++ stdoutText) + ("contains = 1" `isInfixOf` stdoutText) + assertBool "Expected a typed character set descriptor" + ("struct SBVSet_char { const SChar *data; size_t length; bool is_complement; };" `isInfixOf` headerText) + +-- | Check that arbitrary floating-point set elements retain their raw +-- interchange representation and use LibBF-backed object equality. +arbitraryFloatSets :: Assertion +arbitraryFloatSets = do + (_, _, bundle) <- compileToC' "arbitraryFloatSets" $ do + cgSetDriverValues [1] + values <- cgInput "values" :: SBVCodeGen (SSet (FloatingPoint 7 19)) + cgOutput "sameObject" (values .=== values) + cgReturn values + let generated = show bundle + assertBool "Expected a typed arbitrary-float set descriptor" + ("struct SBVSet_fp_e7_s19 { const SFP7_19 *data; size_t length; bool is_complement; };" `isInfixOf` generated) + assertBool "Expected arbitrary-float set equality to use object equality" + ("sbv_fp_e7_s19_obj_eq(left, right)" `isInfixOf` generated) + +-- | Check that native floating-point set operations treat NaNs as identical +-- objects while distinguishing positive and negative zero. +nativeFloatSets :: Assertion +nativeFloatSets = withSystemTempDirectory "sbv-native-float-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x7fc00000, 0x00000000, 0x80000000] + nanBits <- cgInput "nanBits" :: SBVCodeGen SWord32 + positiveBits <- cgInput "positiveBits" :: SBVCodeGen SWord32 + negativeBits <- cgInput "negativeBits" :: SBVCodeGen SWord32 + let nanValue = sWord32AsSFloat nanBits + positiveValue = sWord32AsSFloat positiveBits + negativeValue = sWord32AsSFloat negativeBits + nanSet = SS.singleton nanValue + positiveSet = SS.singleton positiveValue + negativeSet = SS.singleton negativeValue + cgOutput "nanMember" (nanValue `SS.member` nanSet) + cgOutput "zeroObjectsDiffer" (positiveSet ./== negativeSet) + cgReturn (SS.union nanSet positiveSet) + + stdoutText <- compileProgramAndRunGenerated dir "nativeFloatSets" program + assertBool ("Expected native floating-point set object equality, received:\n" ++ stdoutText) + ("nanMember = 1" `isInfixOf` stdoutText && "zeroObjectsDiffer = 1" `isInfixOf` stdoutText) + +-- | Exercise sets after explicitly selecting the historical native mappings +-- for unbounded integers and reals. +mappedNumericSets :: Assertion +mappedNumericSets = withSystemTempDirectory "sbv-mapped-numeric-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 64 + cgSRealType CgDouble + cgSetDriverValues [8, 10] + integers <- cgInput "integers" :: SBVCodeGen (SSet Integer) + reals <- cgInput "reals" :: SBVCodeGen (SSet AlgReal) + cgOutput "integerMember" (8 `SS.member` integers) + cgOutput "realSameObject" (reals .=== reals) + cgReturn integers + + stdoutText <- compileProgramAndRunGenerated dir "mappedNumericSets" program + mapM_ (\fragment -> assertBool ("Expected mapped-numeric set output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "integerMember = 1" + , "realSameObject = 1" + , "{8LL, 9LL, 10LL}" + ] + +-- | Exercise guarded set declarations and independent owned returns from +-- multiple generated library translation units. +ownedSetLibrary :: Assertion +ownedSetLibrary = withSystemTempDirectory "sbv-owned-set-library" $ \dir -> do + let component element seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + values <- cgInput "values" :: SBVCodeGen (SSet Word16) + cgReturn (SS.insert element values) + + (_, cfg, bundle) <- compileToCLib' "ownedSetLibrary" + [ ("firstSet", component 40 4) + , ("secondSet", component 50 6) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "ownedSetLibrary" + assertBool ("Expected both owned set results, received:\n" ++ stdoutText) + ("{0x0004U, 0x0005U, 0x0006U, 0x0028U}" `isInfixOf` stdoutText + && "{0x0006U, 0x0007U, 0x0008U, 0x0032U}" `isInfixOf` stdoutText) + +-- | Exercise exact-value normalization and comparison, finite/cofinite set +-- algebra, and deep-cloned exact set results across the generated C ABI. +exactGMPSets :: Assertion +exactGMPSets = withSystemTempDirectory "sbv-exact-gmp-sets" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 12, 11, 20, 30] + left <- cgInput "left" :: SBVCodeGen (SSet Integer) + right <- cgInput "right" :: SBVCodeGen (SSet Integer) + cofinite <- cgInput "cofinite" :: SBVCodeGen (SSet Integer) + reals <- cgInput "reals" :: SBVCodeGen (SSet AlgReal) + rationals <- cgInput "rationals" :: SBVCodeGen (SSet Rational) + let unioned = SS.union left right + inserted = SS.insert 13 left + intersected = SS.intersection left right + mixedUnion = SS.union left cofinite + realResult = SS.insert 23 reals + rationalResult = SS.delete 31 rationals + cgOutput "sameIntegers" (left .== SS.fromList [10, 11, 12]) + cgOutput "member" (13 `SS.member` unioned) + cgOutput "inserted" inserted + cgOutput "intersected" intersected + cgOutput "mixedUnion" mixedUnion + cgOutput "realMember" (21 `SS.member` reals) + cgOutput "rationalMember" (31 `SS.member` rationals) + cgOutput "realResult" realResult + cgOutput "rationalResult" rationalResult + cgReturn unioned + + stdoutText <- compileProgramAndRunGenerated dir "exactGMPSets" program + headerText <- readFile (dir "exactGMPSets.h") + mapM_ (\fragment -> assertBool ("Expected exact-set output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") ={10, 11, 12, 13, 14}" + , "sameIntegers = 1" + , "member = 1" + , "inserted ={10, 11, 12, 13}" + , "intersected ={12}" + , "mixedUnion =U - {13}" + , "realMember = 1" + , "rationalMember = 1" + , "realResult ={20, 21, 22, 23}" + , "rationalResult ={30, 32}" + ] + assertBool "Expected exact set ownership to clone and clear individual GMP elements" + ("mpz_init_set(element, value.data[i]);" `isInfixOf` headerText + && "mpz_clear(element); free(element);" `isInfixOf` headerText + && "mpq_set(element, value.data[i]);" `isInfixOf` headerText + && "mpq_clear(element); free(element);" `isInfixOf` headerText) + +-- | Exercise exact symbolic-rational construction, decomposition, arithmetic, +-- comparison, arbitrary-width conversion, and caller-owned results. +exactSymbolicRationals :: Assertion +exactSymbolicRationals = withSystemTempDirectory "sbv-exact-symbolic-rationals" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2, 5, 3, 7, 1] + input <- cgInput "input" :: SBVCodeGen SRational + top <- cgInput "numerator" :: SBVCodeGen SInteger + bot <- cgInput "denominator" :: SBVCodeGen SInteger + wide <- cgInput "wide" :: SBVCodeGen (SWord 673) + selector <- cgInput "selector" :: SBVCodeGen SWord8 + let constructed = top .% bot + summed = input + constructed + multiplied = input * constructed + divided = constructed / input + converted = sFromIntegral wide :: SRational + paired = tuple (constructed, summed) + wrapped = sCGOne constructed :: SCodeGenADT Rational + rationalMap = writeArray (constArray input :: SArray Word8 Rational) 1 constructed + stored = readArray rationalMap 1 + keyed = readArray (writeArray (constArray (9 :: SWord8) :: SArray Rational Word8) constructed 7) constructed + fiveThirds = 5 / 3 :: SRational + selected = select [constructed, summed] input selector + cgOutput "constructed" constructed + cgOutput "summed" summed + cgOutput "multiplied" multiplied + cgOutput "divided" divided + cgOutput "ordered" (constructed .< summed) + cgOutput "converted" converted + cgOutput "paired" paired + cgOutput "wrapped" wrapped + cgOutput "stored" stored + cgOutput "rationalMap" rationalMap + cgOutput "keyed" keyed + cgOutput "sameValue" (constructed .== fiveThirds) + cgOutput "wrappedSame" (wrapped .== wrapped) + cgOutput "selected" selected + cgReturn summed + + stdoutText <- compileProgramAndRunGenerated dir "exactSymbolicRationals" program + headerText <- readFile (dir "exactSymbolicRationals.h") + mapM_ (\fragment -> assertBool ("Expected exact-rational output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =11/3" + , "constructed =5/3" + , "summed =11/3" + , "multiplied =10/3" + , "divided =5/6" + , "ordered = 1" + , "converted =7" + , "paired =(5/3, 11/3)" + , "wrapped =CGOne(5/3)" + , "stored =5/3" + , "rationalMap[0] =2" + , "keyed = 7" + , "sameValue = 1" + , "wrappedSame = 1" + , "selected =11/3" + ] + assertBool "Expected a public exact-rational input type" + ("typedef mpq_srcptr SRational;" `isInfixOf` headerText) + assertBool "Expected caller-owned exact-rational output and return parameters" + ("mpq_ptr constructed" `isInfixOf` headerText && "mpq_ptr sbv_result" `isInfixOf` headerText) + +-- | Exercise exact rationals when their symbolic numerator and denominator +-- operations use an explicitly selected bounded SInteger representation. +mappedIntegerRationals :: Assertion +mappedIntegerRationals = withSystemTempDirectory "sbv-mapped-integer-rationals" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 16 + cgSetDriverValues [2, 5, 3] + input <- cgInput "input" :: SBVCodeGen SRational + top <- cgInput "numerator" :: SBVCodeGen SInteger + bot <- cgInput "denominator" :: SBVCodeGen SInteger + let constructed = top .% bot + cgOutput "constructed" constructed + cgOutput "converted" (sFromIntegral top :: SRational) + cgOutput "asReal" (sRationalToSReal constructed) + cgReturn (input + constructed) + + stdoutText <- compileProgramAndRunGenerated dir "mappedIntegerRationals" program + mapM_ (\fragment -> assertBool ("Expected mapped-integer rational output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =11/3" + , "constructed =5/3" + , "converted =5" + , "asReal =5/3" + ] + +-- | Exercise mapped integer divisibility for an ordinary divisor, the +-- absolute value of the minimum signed integer, and an unrepresentable +-- divisor whose only representable multiple is zero. +mappedIntegerDivisibility :: Assertion +mappedIntegerDivisibility = withSystemTempDirectory "sbv-mapped-integer-divisibility" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 8 + cgSetDriverValues [-126, -128, 0, 127] + multiple <- cgInput "multiple" :: SBVCodeGen SInteger + minValue <- cgInput "minimum" :: SBVCodeGen SInteger + zeroValue <- cgInput "zero" :: SBVCodeGen SInteger + maxValue <- cgInput "maximum" :: SBVCodeGen SInteger + cgReturn $ sDivides 3 multiple + .&& sDivides 128 minValue + .&& sDivides 129 zeroValue + .&& sNot (sDivides 128 multiple) + .&& sNot (sDivides 129 maxValue) + + stdoutText <- compileProgramAndRunGenerated dir "mappedIntegerDivisibility" program + assertBool ("Expected mapped integer divisibility to succeed, received:\n" ++ stdoutText) + (") = 1" `isInfixOf` stdoutText) + +-- | Exercise every supported mapped-real transcendental operation across +-- the @float@, @double@, and @long double@ C representations. +mappedRealNonLinearOperations :: Assertion +mappedRealNonLinearOperations = withSystemTempDirectory "sbv-mapped-real-non-linear" $ \dir -> do + let program realType = do + cgOverwriteFiles True + cgSRealType realType + cgSetDriverValues [0, 1, 2, 3, 4] + zeroValue <- cgInput "zero" :: SBVCodeGen SReal + oneValue <- cgInput "one" :: SBVCodeGen SReal + twoValue <- cgInput "two" :: SBVCodeGen SReal + threeValue <- cgInput "three" :: SBVCodeGen SReal + fourValue <- cgInput "four" :: SBVCodeGen SReal + cgReturn $ sin zeroValue .== 0 + .&& cos zeroValue .== 1 + .&& tan zeroValue .== 0 + .&& asin zeroValue .== 0 + .&& acos oneValue .== 0 + .&& atan zeroValue .== 0 + .&& sqrt fourValue .== 2 + .&& sinh zeroValue .== 0 + .&& cosh zeroValue .== 1 + .&& tanh zeroValue .== 0 + .&& exp zeroValue .== 1 + .&& log oneValue .== 0 + .&& twoValue ** threeValue .== 8 + + mappings = [("float", CgFloat), ("double", CgDouble), ("longDouble", CgLongDouble)] + + runMapping (suffix, realType) = do + let executableName = "mappedRealNonLinear" ++ suffix + stdoutText <- compileProgramAndRunGenerated dir executableName (program realType) + assertBool ("Expected " ++ suffix ++ " non-linear operations to succeed, received:\n" ++ stdoutText) + (") = 1" `isInfixOf` stdoutText) + + mapM_ runMapping mappings + +-- | Exercise mapped integer exponentiation with modular overflow, negative +-- exponents, signed units, and the @0 ** 0@ boundary. +mappedIntegerExponentiation :: Assertion +mappedIntegerExponentiation = withSystemTempDirectory "sbv-mapped-integer-exponentiation" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize 8 + cgSetDriverValues [3, 5, -1, -3, 2, 0, 0] + base <- cgInput "base" :: SBVCodeGen SInteger + exponentValue <- cgInput "exponent" :: SBVCodeGen SInteger + negativeUnit <- cgInput "negativeUnit" :: SBVCodeGen SInteger + negativeExponent <- cgInput "negativeExponent" :: SBVCodeGen SInteger + positiveBase <- cgInput "positiveBase" :: SBVCodeGen SInteger + zeroBase <- cgInput "zeroBase" :: SBVCodeGen SInteger + zeroExponent <- cgInput "zeroExponent" :: SBVCodeGen SInteger + cgReturn $ base .** exponentValue .== -13 + .&& negativeUnit .** negativeExponent .== -1 + .&& negativeUnit .** (negativeExponent + 1) .== 1 + .&& positiveBase .** negativeExponent .== 0 + .&& zeroBase .** zeroExponent .== 1 + + stdoutText <- compileProgramAndRunGenerated dir "mappedIntegerExponentiation" program + assertBool ("Expected mapped integer exponentiation to succeed, received:\n" ++ stdoutText) + (") = 1" `isInfixOf` stdoutText) + +-- | Check fixed-width integer arithmetic against independently reduced +-- mathematical results. Include signed overflow, Euclidean versus truncating +-- division, negative divisors, and the totalized public zero-divisor cases. +mappedIntegerArithmetic :: Assertion +mappedIntegerArithmetic = mapM_ check [8, 16, 32, 64] + where check bits = withSystemTempDirectory "sbv-mapped-integer-arithmetic" $ \dir -> do + let half = 2 ^ (bits - 1) + low = negate half + high = half - 1 + oversized = 2 ^ (137 :: Int) + 3 + wrap value = (value + half) `mod` (2 * half) - half + operands = [(high, 1), (low, -1), (low, 3), (-7, 3), (-7, -3), (7, -3) + , (low, low), (-1, low), (high, low), (low, 0), (0, 0), (high, high), (high, 2)] + program = do + cgOverwriteFiles True + cgIntegerSize bits + cgSetDriverValues (concatMap (\(a, b) -> [a, b]) operands ++ [oversized]) + checks <- forM (zip [0 :: Int ..] operands) $ \(index, (a, b)) -> do + left <- cgInput ("left" ++ show index) :: SBVCodeGen SInteger + right <- cgInput ("right" ++ show index) :: SBVCodeGen SInteger + let agrees actual expected = actual .== literal (wrap expected) + (quotient, remainder) = if b == 0 then (0, a) else quotRem a b + (division, modulus) = if b == 0 then (0, a) else divMod a b + euclidean + | b == 0 = [] -- The internal Euclidean operators leave this case unconstrained. + | True = [ agrees (sEDiv left right) ((a `div` abs b) * signum b) + , agrees (sEMod left right) (a `mod` abs b) + ] + pure $ sAnd $ euclidean ++ + [ agrees (left + right) (a + b) + , agrees (left - right) (a - b) + , agrees (left * right) (a * b) + , agrees (negate left) (negate a) + , agrees (abs left) (abs a) + , agrees (left + literal oversized) (a + oversized) + , agrees (sQuot left right) quotient + , agrees (sRem left right) remainder + , agrees (sDiv left right) division + , agrees (sMod left right) modulus + ] + oversizedInput <- cgInput "oversized" :: SBVCodeGen SInteger + cgReturn (sAnd checks .&& oversizedInput .== literal (wrap oversized)) + outputText <- compileProgramAndRunGenerated dir "mappedArithmetic" program + assertBool ("Incorrect " ++ show bits ++ "-bit arithmetic: " ++ outputText) (") = 1" `isInfixOf` outputText) + +-- | Check that transcendental operations over exact rational reals explain +-- how to opt into an approximate native C representation. +exactRealNonLinearDiagnostic :: Assertion +exactRealNonLinearDiagnostic = do + result <- try (do + (_, _, bundle) <- compileToC' "exactRealNonLinear" $ do + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (sin value) + evaluate (length (show bundle))) :: IO (Either ErrorCall Int) + case result of + Left exception -> assertBool ("Expected an exact-real non-linear diagnostic, received:\n" ++ displayException exception) + ("cannot represent sin" `isInfixOf` displayException exception + && "cgSRealType" `isInfixOf` displayException exception) + Right _ -> assertBool "Expected C generation to reject non-linear exact real arithmetic" False + +-- | Exercise guarded rational declarations and caller-owned rational returns +-- across multiple generated library translation units. +exactRationalLibrary :: Assertion +exactRationalLibrary = withSystemTempDirectory "sbv-exact-rational-library" $ \dir -> do + let component increment = do + cgOverwriteFiles True + cgSetDriverValues [1] + value <- cgInput "value" :: SBVCodeGen SRational + cgReturn (value + literal increment) + + (_, cfg, bundle) <- compileToCLib' "exactRationalLibrary" + [ ("addOneRational", component 1) + , ("addTwoRational", component 2) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "exactRationalLibrary" + assertBool ("Expected both exact-rational library results, received:\n" ++ stdoutText) + (") =2" `isInfixOf` stdoutText && ") =3" `isInfixOf` stdoutText) + +-- | Check that ABI kinds and scalar operations contribute the exact external +-- runtime dependencies needed by their generated C bundles. The documented +-- RNE precondition must not introduce hardware-mode guards or LibBF fallbacks. +dependencyRequirements :: Assertion +dependencyRequirements = do + (_, _, wideBundle) <- compileToC' "requirementsWide" $ do + value <- cgInput "value" :: SBVCodeGen (SWord 673) + cgReturn value + + (_, _, fpBundle) <- compileToC' "requirementsFP" $ do + value <- cgInput "value" :: SBVCodeGen (SFloatingPoint 7 19) + cgReturn value + + (_, _, integerBundle) <- compileToC' "requirementsInteger" $ do + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn value + + (_, _, rationalBundle) <- compileToC' "requirementsRational" $ do + value <- cgInput "value" :: SBVCodeGen SRational + cgReturn value + + (_, _, nativeFloatBundle) <- compileToC' "requirementsNativeFloat" $ do + value <- cgInput "value" :: SBVCodeGen SFloat + cgReturn (fpSqrt sRoundNearestTiesToEven value) + + (_, _, roundedNativeFloatBundle) <- compileToC' "requirementsRoundedNativeFloat" $ do + value <- cgInput "value" :: SBVCodeGen SFloat + cgReturn (fpSqrt sRoundNearestTiesToAway value) + + (_, _, nativeLibraryBundle) <- compileToCLib' "requirementsNativeLibrary" + [("addOne", do value <- cgInput "value" :: SBVCodeGen SFloat + cgReturn (fpAdd sRNE value 1))] + + assertEqual "wide bit-vectors should not add an external library" [[]] (linkerFlags wideBundle) + assertEqual "arbitrary floats should request LibBF and libm" [["-lbf", "-lm"]] (linkerFlags fpBundle) + assertEqual "exact integers should request GMP" [["-lgmp"]] (linkerFlags integerBundle) + assertEqual "exact rationals should request GMP" [["-lgmp"]] (linkerFlags rationalBundle) + assertEqual "native floating-point sqrt should request libm" [["-lm"]] (linkerFlags nativeFloatBundle) + assertEqual "explicit native rounding should request LibBF and libm" [["-lbf", "-lm"]] (linkerFlags roundedNativeFloatBundle) + assertEqual "native RNE arithmetic should not add an external library" [[]] (linkerFlags nativeLibraryBundle) + let checkConvention bundle = do + let rendered = show bundle + assertBool "Generated header must document the RNE calling convention" + ("Enter generated code in FE_TONEAREST" `isInfixOf` rendered) + assertBool "The RNE precondition must not add runtime mode checks or changes" + (not (any (`isInfixOf` rendered) ["fegetround(", "fesetround("])) + mapM_ checkConvention [nativeFloatBundle, nativeLibraryBundle] + +-- | Exercise symbolic constant initialization, immutable writes, reads, and +-- an array-valued conditional without exposing arrays at the public C ABI. +persistentArrays :: Assertion +persistentArrays = withSystemTempDirectory "sbv-persistent-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [11, 22, 7, 99, 1] + firstKey <- cgInput "firstKey" :: SBVCodeGen SWord8 + secondKey <- cgInput "secondKey" :: SBVCodeGen SWord8 + defaultValue <- cgInput "defaultValue" :: SBVCodeGen SWord32 + storedValue <- cgInput "storedValue" :: SBVCodeGen SWord32 + chooseNewest <- cgInput "chooseNewest" :: SBVCodeGen SBool + let base = constArray defaultValue + firstWrite = writeArray base firstKey storedValue + newest = writeArray firstWrite secondKey (storedValue + 1) + selected = ite chooseNewest newest firstWrite + literalMap = listArray [(11, 42), (11, 43)] 44 :: SArray Word8 Word32 + cgOutput "baseStillDefault" (readArray base firstKey) + cgOutput "oldVersionDefault" (readArray firstWrite secondKey) + cgOutput "literalMapValue" (readArray literalMap firstKey) + cgReturn (readArray selected secondKey) + + stdoutText <- compileProgramAndRunGenerated dir "persistentArrays" program + mapM_ (\fragment -> assertBool ("Expected generated output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000064UL" + , "baseStillDefault = 0x00000007UL" + , "oldVersionDefault = 0x00000007UL" + , "literalMapValue = 0x0000002aUL" + ] + +-- | Exercise array-valued initialization, immutable writes, and reads without +-- exposing a call-scoped inner array through the generated C ABI. +nestedPersistentArrays :: Assertion +nestedPersistentArrays = withSystemTempDirectory "sbv-nested-persistent-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5, 17, 7, 29, 2, 2, 1] + firstDefault <- cgInput "firstDefault" :: SBVCodeGen SWord32 + firstStored <- cgInput "firstStored" :: SBVCodeGen SWord32 + secondDefault <- cgInput "secondDefault" :: SBVCodeGen SWord32 + secondStored <- cgInput "secondStored" :: SBVCodeGen SWord32 + outerStoreKey <- cgInput "outerStoreKey" :: SBVCodeGen SWord16 + outerReadKey <- cgInput "outerReadKey" :: SBVCodeGen SWord16 + innerReadKey <- cgInput "innerReadKey" :: SBVCodeGen SWord8 + let firstInner = writeArray (constArray firstDefault :: SArray Word8 Word32) 1 firstStored + secondInner = writeArray (constArray secondDefault :: SArray Word8 Word32) 1 secondStored + outerBase = constArray firstInner :: SArray Word16 (ArrayModel Word8 Word32) + outer = writeArray outerBase outerStoreKey secondInner + selected = readArray outer outerReadKey + original = readArray outer (outerReadKey + 1) + cgOutput "selected" (readArray selected innerReadKey) + cgReturn (readArray original innerReadKey) + + stdoutText <- compileProgramAndRunGenerated dir "nestedPersistentArrays" program + sourceText <- readFile (dir "nestedPersistentArrays.c") + mapM_ (\fragment -> assertBool ("Expected nested-array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000011UL" + , "selected = 0x0000001dUL" + ] + assertBool ("Expected nested array values to use retained temporary descriptors, received:\n" ++ sourceText) + ( "sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "sbv_array_ctx_end(&sbv_local_array_ctx)" `isInfixOf` sourceText + && "sbv_local_array_descriptor_" `isInfixOf` sourceText + ) + +-- | Exercise retained array descriptors in tuple construction and projection. +tupleStoredArrays :: Assertion +tupleStoredArrays = withSystemTempDirectory "sbv-tuple-stored-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5, 17, 1] + defaultValue <- cgInput "defaultValue" :: SBVCodeGen SWord32 + storedValue <- cgInput "storedValue" :: SBVCodeGen SWord32 + key <- cgInput "key" :: SBVCodeGen SWord8 + let source = writeArray (constArray defaultValue :: SArray Word8 Word32) 1 storedValue + pair = tuple (source, key) :: SBV (ArrayModel Word8 Word32, Word8) + (restored, restoredKey) = untuple pair + cgOutput "restoredKey" restoredKey + cgOutput "pair" pair + cgReturn (readArray restored key) + + stdoutText <- compileProgramAndRunGenerated dir "tupleStoredArrays" program + sourceText <- readFile (dir "tupleStoredArrays.c") + mapM_ (\fragment -> assertBool ("Expected tuple-stored array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000011UL" + , "restoredKey = 1" + , "pair =([0] =0x00000005UL, 1)" + ] + assertBool ("Expected tuple construction and projection to bridge retained arrays, received:\n" ++ sourceText) + ( ".field1 = sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "sbv_local_array_descriptor_" `isInfixOf` sourceText + ) + +-- | Exercise retained array descriptors in ADT construction and projection. +adtStoredArrays :: Assertion +adtStoredArrays = withSystemTempDirectory "sbv-adt-stored-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5, 17, 1] + defaultValue <- cgInput "defaultValue" :: SBVCodeGen SWord32 + storedValue <- cgInput "storedValue" :: SBVCodeGen SWord32 + key <- cgInput "key" :: SBVCodeGen SWord8 + let source = writeArray (constArray defaultValue :: SArray Word8 Word32) 1 storedValue + boxed = sCGArrayBox source key + cgOutput "boxedKey" (getCGArrayBox_2 boxed) + cgOutput "boxed" boxed + cgReturn (readArray (getCGArrayBox_1 boxed) key) + + stdoutText <- compileProgramAndRunGenerated dir "adtStoredArrays" program + sourceText <- readFile (dir "adtStoredArrays.c") + mapM_ (\fragment -> assertBool ("Expected ADT-stored array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000011UL" + , "boxedKey = 1" + , "boxed =CGArrayBox([0] =0x00000005UL, 1)" + ] + assertBool ("Expected ADT construction and projection to bridge retained arrays, received:\n" ++ sourceText) + ( ".field1 = sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "sbv_local_array_descriptor_" `isInfixOf` sourceText + ) + +-- | Exercise retained array descriptors in list construction, indexing, and +-- owned list outputs. +listStoredArrays :: Assertion +listStoredArrays = withSystemTempDirectory "sbv-list-stored-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5, 17, 1] + defaultValue <- cgInput "defaultValue" :: SBVCodeGen SWord32 + storedValue <- cgInput "storedValue" :: SBVCodeGen SWord32 + key <- cgInput "key" :: SBVCodeGen SWord8 + let source = writeArray (constArray defaultValue :: SArray Word8 Word32) 1 storedValue + arrays = SL.singleton source :: SList (ArrayModel Word8 Word32) + restored = SL.elemAt arrays 0 + cgOutput "arrays" arrays + cgReturn (readArray restored key) + + stdoutText <- compileProgramAndRunGenerated dir "listStoredArrays" program + sourceText <- readFile (dir "listStoredArrays.c") + mapM_ (\fragment -> assertBool ("Expected list-stored array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000011UL" + , "arrays =[[0] =0x00000005UL]" + ] + assertBool ("Expected list construction and indexing to bridge retained arrays, received:\n" ++ sourceText) + ( "sbv_list_array_" `isInfixOf` sourceText + && "sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "sbv_local_array_descriptor_" `isInfixOf` sourceText + ) + +-- | Exercise generated-driver initialization and cleanup for array fields in +-- tuple, ADT, and list inputs that share a single per-kind callback family. +aggregateArrayInputs :: Assertion +aggregateArrayInputs = withSystemTempDirectory "sbv-aggregate-array-inputs" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 7, 11] + tupleInput <- cgInput "tupleInput" :: SBVCodeGen (SBV (ArrayModel Word8 (ArrayModel Word8 Word32), Word8)) + adtInput <- cgInput "adtInput" :: SBVCodeGen (SBV CodeGenArrayBox) + listInput <- cgInput "listInput" :: SBVCodeGen (SList (ArrayModel Word8 Word32)) + let (tupleOuterArray, tupleKey) = untuple tupleInput + tupleInnerArray = readArray tupleOuterArray tupleKey + adtArray = getCGArrayBox_1 adtInput + adtKey = getCGArrayBox_2 adtInput + listHeadArray = SL.head listInput + tupleValue = readArray tupleInnerArray 0 + adtValue = readArray adtArray adtKey + listValue = readArray listHeadArray 0 + cgOutput "tupleValue" tupleValue + cgOutput "adtValue" adtValue + cgOutput "listValue" listValue + cgReturn (tupleValue + adtValue + listValue) + + stdoutText <- compileProgramAndRunGenerated dir "aggregateArrayInputs" program + driverText <- readFile (dir "aggregateArrayInputs_driver.c") + mapM_ (\fragment -> assertBool ("Expected aggregate-array driver output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "= 0x00000015UL" + , "tupleValue = 0x00000003UL" + , "adtValue = 0x00000007UL" + , "listValue = 0x0000000bUL" + ] + assertBool ("Expected retained descriptors for all aggregate array inputs, received:\n" ++ driverText) + (length (filter (isInfixOf "sbv_array_output_retain_2_u8_3_u32") (lines driverText)) >= 5) + +-- | Exercise transitive ownership when tuples, lists, and ADTs hide retained +-- arrays behind one or more concrete ADT fields. +transitiveAggregateArrayInputs :: Assertion +transitiveAggregateArrayInputs = withSystemTempDirectory "sbv-transitive-array-inputs" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 7, 11] + tupleInput <- cgInput "tupleInput" :: SBVCodeGen (SBV (CodeGenArrayBox, Word8)) + listInput <- cgInput "listInput" :: SBVCodeGen (SList (CodeGenArrayBox, Word8)) + envelopeInput <- cgInput "envelopeInput" :: SBVCodeGen (SBV CodeGenArrayEnvelope) + let (tupleBox, tupleKey) = untuple tupleInput + (listBox, listKey) = untuple (SL.head listInput) + (envelopeBox, _) = untuple (getCGArrayEnvelope_1 envelopeInput) + tupleValue = readArray (getCGArrayBox_1 tupleBox) tupleKey + listValue = readArray (getCGArrayBox_1 listBox) listKey + envelopeValue = readArray (getCGArrayBox_1 envelopeBox) 0 + cgOutput "tupleValue" tupleValue + cgOutput "listValue" listValue + cgOutput "envelopeValue" envelopeValue + cgReturn (tupleValue + listValue + envelopeValue) + + stdoutText <- compileProgramAndRunGenerated dir "transitiveAggregateArrayInputs" program + headerText <- readFile (dir "transitiveAggregateArrayInputs.h") + mapM_ (\fragment -> assertBool ("Expected transitive aggregate-array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "= 0x00000015UL" + , "tupleValue = 0x00000003UL" + , "listValue = 0x00000007UL" + , "envelopeValue = 0x0000000bUL" + ] + assertBool ("Expected tuple ownership to cross concrete ADT fields, received:\n" ++ headerText) + ( "sbv_adt_owned_clone_SBVADT_CodeGenArrayBox(source.field1)" `isInfixOf` headerText + && "sbv_adt_owned_release_SBVADT_CodeGenArrayBox(&value->field1)" `isInfixOf` headerText + ) + +-- | Check that native floating-point array keys use SMT object equality: +-- NaNs match, while positive and negative zero remain distinct. +nativeFloatArrayKeys :: Assertion +nativeFloatArrayKeys = withSystemTempDirectory "sbv-native-float-array-keys" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0x7fc00000, 0x00000000, 0x80000000] + nanBits <- cgInput "nanBits" :: SBVCodeGen SWord32 + positiveBits <- cgInput "positiveBits" :: SBVCodeGen SWord32 + negativeBits <- cgInput "negativeBits" :: SBVCodeGen SWord32 + let nanKey = sWord32AsSFloat nanBits + positiveZero = sWord32AsSFloat positiveBits + negativeZero = sWord32AsSFloat negativeBits + base = constArray 3 + withNaN = writeArray base nanKey 11 + withZero = writeArray withNaN positiveZero 12 + flags = [ readArray withZero nanKey .== (11 :: SWord8) + , readArray withZero positiveZero .== (12 :: SWord8) + , readArray withZero negativeZero .== (3 :: SWord8) + ] + cgReturn (sum (zipWith (\flag weight -> ite flag weight 0) flags [1, 2, 4]) :: SWord8) + + stdoutText <- compileProgramAndRunGenerated dir "nativeFloatArrayKeys" program + assertBool ("Expected all native array-key checks to pass, received:\n" ++ stdoutText) ("= 7" `isInfixOf` stdoutText) + +-- | Exercise array-type merging across generated library translation units, +-- including an owned array returned through the public library ABI. +persistentArrayLibrary :: Assertion +persistentArrayLibrary = withSystemTempDirectory "sbv-persistent-array-library" $ \dir -> do + let component increment = do + cgOverwriteFiles True + cgSetDriverValues [40, 9] + source <- cgInput "source" :: SBVCodeGen (SArray Word16 Word32) + key <- cgInput "key" :: SBVCodeGen SWord16 + let updated = writeArray source key (readArray source key + increment) + cgReturn (readArray updated key) + + lambdaComponent = do + cgOverwriteFiles True + cgSetDriverValues [1] + key <- cgInput "key" :: SBVCodeGen SWord16 + let source = lambdaArray (\index -> select [sFromIntegral index * 3 + 1, sFromIntegral index * 3 + 2] 0 index :: SWord32) + :: SArray Word16 Word32 + cgReturn (readArray source key) + + ownedComponent = do + cgOverwriteFiles True + let source = lambdaArray (\index -> sFromIntegral index + 5) :: SArray Word16 Word32 + cgReturn (writeArray source 0 55) + + (_, cfg, bundle) <- compileToCLib' "persistentArrayLibrary" + [ ("increment", component 1) + , ("addTwo", component 2) + , ("lambdaValue", lambdaComponent) + , ("ownedArray", ownedComponent) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "persistentArrayLibrary" + mapM_ (\fragment -> assertBool ("Expected generated library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000029UL" + , "0x0000002aUL" + , "0x00000005UL" + , "ownedArray()[0] =0x00000037UL" + ] + +-- | Exercise the borrowed callback descriptor used for a public array input, +-- including local writes that shadow the callback only at matching keys. +callbackArrayInput :: Assertion +callbackArrayInput = withSystemTempDirectory "sbv-callback-array-input" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [40, 9] + source <- cgInput "source" :: SBVCodeGen (SArray Word8 Word32) + key <- cgInput "key" :: SBVCodeGen SWord8 + let updated = writeArray source key 99 + cgOutput "sourceValue" (readArray source key) + cgOutput "unshadowedValue" (readArray updated (key + 1)) + cgReturn (readArray updated key) + + stdoutText <- compileProgramAndRunGenerated dir "callbackArrayInput" program + mapM_ (\fragment -> assertBool ("Expected callback-backed output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000063UL" + , "sourceValue = 0x00000028UL" + , "unshadowedValue = 0x00000028UL" + ] + +-- | Exercise a retained lambda DAG together with a persistent write that +-- shadows exactly one value produced by the lambda. +structuredLambdaArray :: Assertion +structuredLambdaArray = withSystemTempDirectory "sbv-structured-lambda-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [9] + key <- cgInput "key" :: SBVCodeGen SWord16 + let source = lambdaArray (\index -> sFromIntegral index * 3 + 1) :: SArray Word16 Word32 + updated = writeArray source key 99 + cgOutput "nextValue" (readArray updated (key + 1)) + cgReturn (readArray updated key) + + stdoutText <- compileProgramAndRunGenerated dir "structuredLambdaArray" program + mapM_ (\fragment -> assertBool ("Expected structured-lambda output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000063UL" + , "nextValue = 0x0000001fUL" + ] + +-- | Exercise text, list, and set allocation inside retained array callbacks, +-- including an exact list element that shares both the GMP and list arenas. +managedStructuredLambdaArrays :: Assertion +managedStructuredLambdaArrays = withSystemTempDirectory "sbv-managed-structured-lambda-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2] + key <- cgInput "key" :: SBVCodeGen SWord8 + let textSource = lambdaArray (\index -> + ite (index .== 2) (literal "hit") (literal "miss") SL.++ literal "!") + :: SArray Word8 String + listSource = lambdaArray (\index -> + SL.singleton (sFromIntegral index :: SInteger) SL.++ literal [100]) + :: SArray Word8 [Integer] + setSource = lambdaArray (\index -> + SS.insert (sFromIntegral index :: SInteger) (SS.singleton 100)) + :: SArray Word8 (RCSet Integer) + cgOutput "textValue" (readArray textSource key) + cgOutput "listValue" (readArray listSource key) + cgReturn (readArray setSource key) + + stdoutText <- compileProgramAndRunGenerated dir "managedStructuredLambdaArrays" program + mapM_ (\fragment -> assertBool ("Expected managed structured-lambda output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") ={100, 2}" + , "textValue =hit!" + , "listValue =[2, 100]" + ] + +-- | Return a retained lambda array whose callback constructs a tuple with +-- fresh text and list storage, then read it after the generated call returns. +escapingManagedLambdaArray :: Assertion +escapingManagedLambdaArray = withSystemTempDirectory "sbv-escaping-managed-lambda-array" $ \dir -> do + let program = do + cgOverwriteFiles True + let source = lambdaArray (\index -> + tuple ( literal "item" SL.++ literal "!" + , SL.singleton (sFromIntegral index :: SWord16) SL.++ literal [99] + )) + :: SArray Word8 (String, [Word16]) + cgReturn source + + stdoutText <- compileProgramAndRunGenerated dir "escapingManagedLambdaArray" program + sourceText <- readFile (dir "escapingManagedLambdaArray.c") + assertBool ("Expected an escaping managed lambda array to retain its callback arenas, received:\n" ++ stdoutText) + ("[0] =(item!, [0x0000U, 0x0063U])" `isInfixOf` stdoutText) + assertBool ("Expected the escaping callback to clone managed results into retained storage, received:\n" ++ sourceText) + ("sbv_function_ctx_retain_empty" `isInfixOf` sourceText + && "sbv_function_result_clone_" `isInfixOf` sourceText) + +-- | Call scalar and managed first-order 'smtFunction' definitions from array +-- lambdas, including a scalar signature whose body uses hidden managed arenas +-- and a managed callback that remains callable after its array escapes. +definedFunctionsInsideArrayLambdas :: Assertion +definedFunctionsInsideArrayLambdas = withSystemTempDirectory "sbv-defined-functions-in-array-lambdas" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [12] + key <- cgInput "key" :: SBVCodeGen SWord8 + let countDigits :: SWord8 -> SWord8 + countDigits = smtFunction "C lambda digit count" $ \value -> + sFromIntegral (SL.length (SL.natToStr (sFromIntegral value :: SInteger))) + + decorate :: SString -> SString + decorate = smtFunction "C lambda text decoration" $ \value -> + literal "<" SL.++ value SL.++ literal ">" + + numericSource = lambdaArray countDigits :: SArray Word8 Word8 + textSource = lambdaArray (\index -> + decorate (ite (index .== 0) (literal "zero") (literal "other"))) + :: SArray Word8 String + cgOutput "digits" (readArray numericSource key) + cgReturn textSource + + stdoutText <- compileProgramAndRunGenerated dir "definedFunctionsInsideArrayLambdas" program + sourceText <- readFile (dir "definedFunctionsInsideArrayLambdas.c") + mapM_ (\fragment -> assertBool ("Expected a defined-function lambda output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "[0] =" + , "digits = 2" + ] + assertBool ("Expected array callbacks to forward the function ownership context, received:\n" ++ sourceText) + ("/* Uninterpreted function */ sbv_function_" `isInfixOf` sourceText + && "sbv_function_ctx sbv_local_function_ctx" `isInfixOf` sourceText) + +-- | Exercise retained arrays that call managed 'smtFunction' definitions in +-- separate translation units of one generated static library. +definedFunctionArrayLambdaLibrary :: Assertion +definedFunctionArrayLambdaLibrary = withSystemTempDirectory "sbv-defined-function-array-lambda-library" $ \dir -> do + let component :: String -> SBVCodeGen () + component prefix = do + cgOverwriteFiles True + let decorate :: SString -> SString + decorate = smtFunction ("C library lambda " ++ prefix) $ \value -> + literal prefix SL.++ value + + source = lambdaArray (\index -> + decorate (SL.natToStr (sFromIntegral index :: SInteger))) + :: SArray Word8 String + cgReturn source + + (_, cfg, bundle) <- compileToCLib' "definedFunctionArrayLambdaLibrary" + [ ("firstLambda", component "first-") + , ("secondLambda", component "second-") + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "definedFunctionArrayLambdaLibrary" + mapM_ (\fragment -> assertBool ("Expected a library function-backed lambda output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstLambda()[0] =first-0" + , "secondLambda()[0] =second-0" + ] + +-- | Return direct and tuple-contained persistent arrays from retained +-- callbacks, read them during the generated call, and read the direct result +-- again after its outer array escapes. +arrayValuedLambdaResults :: Assertion +arrayValuedLambdaResults = withSystemTempDirectory "sbv-array-valued-lambda-results" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5] + key <- cgInput "key" :: SBVCodeGen SWord8 + let inner :: SWord8 -> SArray Word8 Word32 + inner index = writeArray + (constArray (sFromIntegral index + 1 :: SWord32) :: SArray Word8 Word32) + index + 99 + + makeInner :: SWord8 -> SArray Word8 Word32 + makeInner = smtFunction "C lambda inner array" inner + + directSource = lambdaArray inner :: SArray Word8 (ArrayModel Word8 Word32) + functionSource = lambdaArray makeInner :: SArray Word8 (ArrayModel Word8 Word32) + boxedSource = lambdaArray (\index -> tuple (inner index, sFromIntegral index + 10 :: SWord16)) + :: SArray Word8 (ArrayModel Word8 Word32, Word16) + directInner = readArray directSource key + functionInner = readArray functionSource key + (boxedInner, marker) = untuple (readArray boxedSource key) + cgOutput "directStored" (readArray directInner key) + cgOutput "directDefault" (readArray directInner (key + 1)) + cgOutput "functionStored" (readArray functionInner key) + cgOutput "boxedStored" (readArray boxedInner key) + cgOutput "marker" marker + cgReturn directSource + + stdoutText <- compileProgramAndRunGenerated dir "arrayValuedLambdaResults" program + sourceText <- readFile (dir "arrayValuedLambdaResults.c") + mapM_ (\fragment -> assertBool ("Expected an array-valued lambda output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ")[0] =[0] =0x00000063UL" + , "directStored = 0x00000063UL" + , "directDefault = 0x00000006UL" + , "functionStored = 0x00000063UL" + , "boxedStored = 0x00000063UL" + , "marker = 0x000fU" + ] + assertBool ("Expected array callback results to cross through retained descriptors, received:\n" ++ sourceText) + ("sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "SBVArrayOutput_2_u8_3_u32 * sbv_array_lambda_" `isInfixOf` sourceText) + +-- | Exercise array-valued callback results in independent translation units +-- of a generated static library. +arrayValuedLambdaLibrary :: Assertion +arrayValuedLambdaLibrary = withSystemTempDirectory "sbv-array-valued-lambda-library" $ \dir -> do + let component :: Word32 -> SBVCodeGen () + component value = do + cgOverwriteFiles True + let source = lambdaArray (\index -> + writeArray (constArray (literal value) :: SArray Word8 Word32) index (literal value + 1)) + :: SArray Word8 (ArrayModel Word8 Word32) + cgReturn source + + (_, cfg, bundle) <- compileToCLib' "arrayValuedLambdaLibrary" + [ ("firstNestedArray", component 20) + , ("secondNestedArray", component 30) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "arrayValuedLambdaLibrary" + mapM_ (\fragment -> assertBool ("Expected a library array-valued lambda output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstNestedArray()[0] =[0] =0x00000015UL" + , "secondNestedArray()[0] =[0] =0x0000001fUL" + ] + +-- | Lambda-lift closed array callbacks from a defined function and from an +-- outer array callback whose result is itself a selected callback array. +nestedStructuredArrayLambdas :: Assertion +nestedStructuredArrayLambdas = withSystemTempDirectory "sbv-nested-structured-array-lambdas" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 5, 1] + chooseFirst <- cgInput "chooseFirst" :: SBVCodeGen SBool + key <- cgInput "key" :: SBVCodeGen SWord8 + outerKey <- cgInput "outerKey" :: SBVCodeGen SWord8 + let choose :: SBool -> SArray Word8 Word16 + choose = smtFunction "C nested lambda choice" $ \condition -> + ite condition + (lambdaArray (\index -> sFromIntegral index + 10)) + (lambdaArray (\index -> sFromIntegral index + 20)) + + recursiveChoose :: SWord8 -> SArray Word8 Word16 + recursiveChoose = smtFunctionNoTermination "C recursive nested lambda choice" $ \count -> + ite (count .== 0) + (lambdaArray (\index -> sFromIntegral index + 60)) + (recursiveChoose (count - 1)) + + nested = lambdaArray (\outer -> + ite (outer .== 0) + (lambdaArray (\index -> sFromIntegral index + 30)) + (lambdaArray (\index -> sFromIntegral index + 40))) + :: SArray Word8 (ArrayModel Word8 Word16) + + deep = lambdaArray (\_ -> + lambdaArray (\_ -> + lambdaArray (\index -> sFromIntegral index + 50))) + :: SArray Word8 (ArrayModel Word8 (ArrayModel Word8 Word16)) + + chosen = choose chooseFirst + selected = readArray chosen key + nestedInner = readArray nested outerKey + deepMiddle = readArray deep outerKey + deepInner = readArray deepMiddle outerKey + recursive = recursiveChoose outerKey + + cgOutput "selected" selected + cgOutput "nestedSelected" (readArray nestedInner key) + cgOutput "deepSelected" (readArray deepInner key) + cgOutput "recursive" (readArray recursive key) + cgReturn chosen + + stdoutText <- compileProgramAndRunGenerated dir "nestedStructuredArrayLambdas" program + sourceText <- readFile (dir "nestedStructuredArrayLambdas.c") + mapM_ (\fragment -> assertBool ("Expected nested structured-lambda output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ")[0] =0x000aU" + , "selected = 0x000fU" + , "nestedSelected = 0x002dU" + , "deepSelected = 0x0037U" + , "recursive = 0x0041U" + ] + assertBool ("Expected nested callbacks to receive lexical-scope-qualified names, received:\n" ++ sourceText) + ("_nested_l" `isInfixOf` sourceText) + +-- | Exercise lambda-lifted callbacks from private defined functions in +-- independent translation units of a generated static library. +nestedStructuredArrayLambdaLibrary :: Assertion +nestedStructuredArrayLambdaLibrary = withSystemTempDirectory "sbv-nested-structured-array-lambda-library" $ \dir -> do + let component :: Word16 -> SBVCodeGen () + component offset = do + cgOverwriteFiles True + let choose :: SBool -> SArray Word8 Word16 + choose = smtFunction "C library nested lambda" $ \condition -> + ite condition + (lambdaArray (\index -> sFromIntegral index + literal offset)) + (lambdaArray (\index -> sFromIntegral index + literal offset + 100)) + cgReturn (choose (literal True)) + + (_, cfg, bundle) <- compileToCLib' "nestedStructuredArrayLambdaLibrary" + [ ("firstNestedLambda", component 10) + , ("secondNestedLambda", component 20) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "nestedStructuredArrayLambdaLibrary" + mapM_ (\fragment -> assertBool ("Expected nested structured-lambda library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstNestedLambda()[0] =0x000aU" + , "secondNestedLambda()[0] =0x0014U" + ] + +-- | Exercise parameter-dependent tables in two structured lambdas, ensuring +-- their independently numbered local table declarations do not collide. +structuredLambdaTables :: Assertion +structuredLambdaTables = withSystemTempDirectory "sbv-structured-lambda-tables" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + key <- cgInput "key" :: SBVCodeGen SWord8 + let first = lambdaArray (\index -> select [sFromIntegral index + 10, sFromIntegral index + 20] 99 index :: SWord32) + :: SArray Word8 Word32 + second = lambdaArray (\index -> select [sFromIntegral index * 2, sFromIntegral index * 3] 77 index :: SWord32) + :: SArray Word8 Word32 + cgOutput "firstValue" (readArray first key) + cgReturn (readArray second key) + + stdoutText <- compileProgramAndRunGenerated dir "structuredLambdaTables" program + mapM_ (\fragment -> assertBool ("Expected structured-lambda table output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "0x00000003UL" + , "firstValue = 0x00000015UL" + ] + +-- | Exercise structured lowering of a multi-argument 'smtFunction', including +-- collision-free C encoding of a quoted SMT identifier. +definedSBVFunction :: Assertion +definedSBVFunction = withSystemTempDirectory "sbv-defined-function" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 4, 5] + left <- cgInput "left" :: SBVCodeGen SWord32 + right <- cgInput "right" :: SBVCodeGen SWord32 + wide <- cgInput "wide" :: SBVCodeGen (SWord 673) + let combine = smtFunction "defined function/@1" $ \x y -> ite (x .< y) (x + y) (x * y) + increment = smtFunction "wide defined function" (+ 1) + cgOutput "wideResult" (increment wide) + cgReturn (combine left right) + + stdoutText <- compileProgramAndRunGenerated dir "definedSBVFunction" program + sourceText <- readFile (dir "definedSBVFunction.c") + assertBool ("Expected defined-function output to contain 0x00000007UL, received:\n" ++ stdoutText) + ("0x00000007UL" `isInfixOf` stdoutText) + assertBool ("Expected the quoted SMT function name to use a private encoded C identifier, received:\n" ++ sourceText) + ("static SWord32 sbv_function_" `isInfixOf` sourceText + && "/* Uninterpreted function */ sbv_function_" `isInfixOf` sourceText) + assertBool ("Expected a defined function body to contribute its wide-bit-vector runtime, received:\n" ++ sourceText) + ("static SWord673 sbv_function_" `isInfixOf` sourceText + && "sbv_bv_u673_add" `isInfixOf` sourceText) + +-- | Exercise an acyclic diamond of 'smtFunction' calls whose lexical name +-- ordering requires prototypes for callees emitted after their caller. +composedDefinedSBVFunctions :: Assertion +composedDefinedSBVFunctions = withSystemTempDirectory "sbv-composed-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4] + input <- cgInput "input" :: SBVCodeGen SWord32 + let base :: SWord32 -> SWord32 + base = smtFunction "C function base" (+ 1) + + twice :: SWord32 -> SWord32 + twice = smtFunction "C function twice" $ \value -> base value * 2 + + plusThree :: SWord32 -> SWord32 + plusThree = smtFunction "C function plus three" $ \value -> base value + 3 + + diamond :: SWord32 -> SWord32 + diamond = smtFunction "C function diamond" $ \value -> twice value + plusThree value + cgReturn (diamond input) + + stdoutText <- compileProgramAndRunGenerated dir "composedDefinedSBVFunctions" program + sourceText <- readFile (dir "composedDefinedSBVFunctions.c") + assertBool ("Expected composed defined-function output to contain 0x00000012UL, received:\n" ++ stdoutText) + ("0x00000012UL" `isInfixOf` stdoutText) + assertBool ("Expected private prototypes before the composed defined-function bodies, received:\n" ++ sourceText) + (length (filter ("static SWord32 sbv_function_" `isInfixOf`) (lines sourceText)) == 8) + +-- | Exercise private by-value C signatures for 'smtFunction' definitions over +-- a tuple and a scalar-only ADT, including projection and reconstruction. +structuralDefinedSBVFunctions :: Assertion +structuralDefinedSBVFunctions = withSystemTempDirectory "sbv-structural-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + let adjustTuple :: SBV (Word8, Word16) -> SBV (Word8, Word16) + adjustTuple = smtFunction "C structural tuple" $ \value -> + let (first, second) = untuple value + in tuple (first + 1, second + 2) + + adjustADT :: SCodeGenADT Word8 -> SCodeGenADT Word8 + adjustADT = smtFunction "C structural ADT" $ \value -> + sCGPair (getCGPair_1 value + 1) (getCGPair_2 value + 2) + + cgOutput "tupleResult" (adjustTuple (literal (4, 10))) + cgReturn (adjustADT (literal (CGPair 7 9))) + + stdoutText <- compileProgramAndRunGenerated dir "structuralDefinedSBVFunctions" program + mapM_ (\fragment -> assertBool ("Expected structural defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGPair(8, 0x000bU)" + , "tupleResult =(5, 0x000cU)" + ] + +-- | Exercise transitive ownership-arena threading through composed +-- 'smtFunction' definitions producing strings and exact GMP integers. +managedScalarDefinedSBVFunctions :: Assertion +managedScalarDefinedSBVFunctions = withSystemTempDirectory "sbv-managed-scalar-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4, 5] + inputText <- cgInput "inputText" :: SBVCodeGen SString + inputInteger <- cgInput "inputInteger" :: SBVCodeGen SInteger + let addSuffix :: SString -> SString + addSuffix = smtFunction "C managed string suffix" $ \value -> value SL.++ literal "!" + + decorate :: SString -> SString + decorate = smtFunction "C managed string decorate" $ \value -> literal "<" SL.++ addSuffix value SL.++ literal ">" + + increment :: SInteger -> SInteger + increment = smtFunction "C managed integer increment" (+ 1) + + squareIncrement :: SInteger -> SInteger + squareIncrement = smtFunction "C managed integer square" $ \value -> increment value * increment value + + cgOutput "decorated" (decorate inputText) + cgReturn (squareIncrement inputInteger) + + stdoutText <- compileProgramAndRunGenerated dir "managedScalarDefinedSBVFunctions" program + sourceText <- readFile (dir "managedScalarDefinedSBVFunctions.c") + mapM_ (\fragment -> assertBool ("Expected managed scalar defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =36" + , "decorated =" + ] + assertBool "Expected private defined-function calls to thread the shared ownership context" + ("sbv_function_ctx *const sbv_local_parent_function_ctx" `isInfixOf` sourceText + && "(&sbv_local_function_ctx," `isInfixOf` sourceText) + +-- | Private bodies must request the shared floor helper and math linkage even +-- when their entry point contains only a function call or array lookup. +scopedMappedRealFloor :: Assertion +scopedMappedRealFloor = mapM_ check [(library, useLambda, width) | library <- [False, True], useLambda <- [False, True], width <- [8, 64]] + where check (library, useLambda, width) = withSystemTempDirectory "sbv-scoped-real-floor" $ \dir -> do + let functionName = "scopedRealFloor" + floorHalf :: SReal -> SInteger + floorHalf value = sRealToSIntegerFloor (value / 2) + program = do + cgOverwriteFiles True + cgSRealType CgLongDouble + cgIntegerSize width + cgSetDriverValues [-5] + value <- cgInput "value" + let result = if useLambda + then readArray (lambdaArray floorHalf) value + else smtFunction "C long-double floor" floorHalf value + cgReturn (result .== -3) + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("floorComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Check overflow-safe statement blocks in conditionals, private functions, +-- and closed array lambdas. Every five-bit input is compared against equivalent +-- unweighted predicates, including sums that exceed the entire unsigned range. +scopedPseudoBoolean :: Assertion +scopedPseudoBoolean = mapM_ check [(library, scope) | library <- [False, True], scope <- [0 :: Int, 1, 2]] + where check (library, scope) = withSystemTempDirectory "sbv-scoped-pseudo-boolean" $ \dir -> do + let functionName = "scopedPseudoBoolean" + evaluateBits :: SWord8 -> SBool + evaluateBits value = + let bits = map (sTestBit value) [0, 1, 2] + weighted = zip [maxBound, maxBound, maxBound] bits + in ite (sTestBit value 3) + (pbLe weighted maxBound .== pbAtMost bits 1) + (pbEq weighted maxBound .== pbExactly bits 1) + .&& (pbGe weighted maxBound .== sOr bits) + evaluateScoped value = case scope of + 0 -> evaluateBits value + 1 -> smtFunction "C scoped pseudo-Boolean" evaluateBits value + _ -> readArray (lambdaArray evaluateBits) value + program = do + cgOverwriteFiles True + cgIntegerSize 8 + cgSetDriverValues [0..31] + inputs <- cgInputArr 32 "inputs" + cgReturn (sAnd (map evaluateScoped inputs)) + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("scopedComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Exercise composed 'smtFunction' definitions over exact-element lists and +-- sets, requiring coordinated list, set, and GMP ownership arenas. +collectionDefinedSBVFunctions :: Assertion +collectionDefinedSBVFunctions = withSystemTempDirectory "sbv-collection-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + let addPrefix :: SList Integer -> SList Integer + addPrefix = smtFunction "C managed list prefix" $ \values -> literal [0] SL.++ values + + finishList :: SList Integer -> SList Integer + finishList = smtFunction "C managed list finish" $ \values -> addPrefix values SL.++ literal [3] + + addThree :: SSet Integer -> SSet Integer + addThree = smtFunction "C managed set three" $ SS.insert 3 + + finishSet :: SSet Integer -> SSet Integer + finishSet = smtFunction "C managed set finish" $ \values -> SS.insert 4 (addThree values) + + finishCollections :: SBV ([Integer], RCSet Integer) -> SBV ([Integer], RCSet Integer) + finishCollections = smtFunction "C managed collection tuple" $ \collections -> + let (values, members) = untuple collections + in tuple (finishList values, finishSet members) + + cgOutput "listResult" (finishList (literal [1, 2])) + cgReturn (finishCollections (tuple (literal [1, 2], SS.fromList [1, 2]))) + + stdoutText <- compileProgramAndRunGenerated dir "collectionDefinedSBVFunctions" program + mapM_ (\fragment -> assertBool ("Expected collection defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =([0, 1, 2, 3], {1, 2, 3, 4})" + , "listResult =[0, 1, 2, 3]" + ] + +-- | Exercise persistent array roots passed through composed 'smtFunction' +-- calls and returned inside a tuple containing its eventual lookup key. +persistentArrayDefinedSBVFunctions :: Assertion +persistentArrayDefinedSBVFunctions = withSystemTempDirectory "sbv-persistent-array-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + let storeAt :: SArray Word8 Word32 -> SWord8 -> SWord32 -> SArray Word8 Word32 + storeAt = smtFunction "C managed array store" writeArray + + storeTwice :: SArray Word8 Word32 -> SArray Word8 Word32 + storeTwice = smtFunction "C managed array stores" $ \values -> + storeAt (storeAt values 1 11) 2 22 + + package :: SArray Word8 Word32 -> SBV (ArrayModel Word8 Word32, Word8) + package = smtFunction "C managed array package" $ \values -> tuple (storeTwice values, literal 2) + + base = constArray 5 :: SArray Word8 Word32 + (updated, selectedKey) = untuple (package base) + + cgOutput "atOne" (readArray updated 1) + cgOutput "fallback" (readArray updated 7) + cgReturn (readArray updated selectedKey) + + stdoutText <- compileProgramAndRunGenerated dir "persistentArrayDefinedSBVFunctions" program + mapM_ (\fragment -> assertBool ("Expected persistent-array defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") = 0x00000016UL" + , "atOne = 0x0000000bUL" + , "fallback = 0x00000005UL" + ] + +-- | Exercise managed and recursive ADTs returned through composed +-- 'smtFunction' calls, including stabilization of recursive stack literals. +ownedADTDefinedSBVFunctions :: Assertion +ownedADTDefinedSBVFunctions = withSystemTempDirectory "sbv-owned-adt-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 1] + let extendCollections :: SCodeGenCollections -> SCodeGenCollections + extendCollections = smtFunction "C managed ADT collections" $ \value -> + let values = getCGCollections_1 value + members = getCGCollections_2 value + nested = getCGCollections_3 value + (nestedValues, nestedSet) = untuple nested + in sCGCollections + (values SL.++ literal [7]) + (SS.insert 8 members) + (tuple (nestedValues SL.++ literal [9], SS.insert 10 nestedSet)) + + wrapTree :: SCodeGenTree -> SCodeGenTree + wrapTree = smtFunction "C managed ADT wrap" $ \tree -> sCGNode tree (sCGLeaf 99) + + wrapTreeTwice :: SCodeGenTree -> SCodeGenTree + wrapTreeTwice = smtFunction "C managed ADT wrap twice" $ \tree -> wrapTree (wrapTree tree) + + collections <- cgInput "collectionsInput" :: SBVCodeGen SCodeGenCollections + tree <- cgInput "treeInput" :: SBVCodeGen SCodeGenTree + cgOutput "collections" (extendCollections collections) + cgReturn (wrapTreeTwice tree) + + stdoutText <- compileProgramAndRunGenerated dir "ownedADTDefinedSBVFunctions" program + sourceText <- readFile (dir "ownedADTDefinedSBVFunctions.c") + mapM_ (\fragment -> assertBool ("Expected owned-ADT defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =CGNode(CGNode(" + , "CGLeaf(99)), CGLeaf(99))" + , "collections =CGCollections([1, 2, 3, 7], {2, 3, 4, 8}, ([3, 4, 5, 9], {4, 5, 6, 10}))" + ] + assertBool ("Expected private owned ADT results to use stable arena clones, received:\n" + ++ unlines (filter ("sbv_function" `isInfixOf`) (lines sourceText))) + ("sbv_function_result_clone_" `isInfixOf` sourceText) + assertBool "Expected private owned ADT result storage to be released" + ("sbv_function_result_ctx_end(&sbv_local_function_result_ctx);" `isInfixOf` sourceText) + +-- | An inactive branch must not dereference the null child returned by a +-- mismatched recursive-ADT selector. Exercise Ite, Boolean short-circuiting, +-- and a managed result in acyclic functions, standalone and in a library. +guardedAcyclicDefinedFunctions :: Assertion +guardedAcyclicDefinedFunctions = mapM_ check [(library, sample) | library <- [False, True], sample <- [1, 0]] + where check (library, sample) = withSystemTempDirectory "sbv-guarded-acyclic-functions" $ \dir -> do + let functionName = "guardedAcyclicFunctions" + program = do + cgOverwriteFiles True + cgSetDriverValues [sample] + chooseLeaf <- cgInput "chooseLeaf" :: SBVCodeGen SBool + let guardedLeft :: SCodeGenTree -> SWord8 + guardedLeft = smtFunction "C guarded acyclic left" $ \tree -> + ite (isCGLeaf tree) (getCGLeaf_1 tree) (getCGLeaf_1 (getCGNode_1 tree)) + + guardedAnd :: SCodeGenTree -> SBool + guardedAnd = smtFunction "C guarded acyclic and" $ \tree -> + isCGNode tree .&& getCGLeaf_1 (getCGNode_1 tree) .== 7 + + guardedOr :: SCodeGenTree -> SBool + guardedOr = smtFunction "C guarded acyclic or" $ \tree -> + isCGLeaf tree .|| getCGLeaf_1 (getCGNode_1 tree) .== 7 + + guardedImplies :: SCodeGenTree -> SBool + guardedImplies = smtFunction "C guarded acyclic implication" $ \tree -> + isCGNode tree .=> getCGLeaf_1 (getCGNode_1 tree) .== 7 + + guardedTree :: SCodeGenTree -> SCodeGenTree + guardedTree = smtFunction "C guarded acyclic tree" $ \tree -> + ite (isCGLeaf tree) (sCGLeaf (getCGLeaf_1 tree)) (sCGLeaf (getCGLeaf_1 (getCGNode_1 tree))) + + rootTree = ite chooseLeaf (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + cgOutput "selectedTree" (guardedTree rootTree) + cgReturn $ sAnd [guardedLeft rootTree .== 7, guardedAnd rootTree .== sNot chooseLeaf, guardedOr rootTree, guardedImplies rootTree] + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("guardedComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText && "selectedTree =CGLeaf(7)" `isInfixOf` outputText) + +-- | Demand-driven evaluation must protect partial selectors both in public +-- entry points and in retained array callbacks, including owned branch results. +guardedProgramEvaluation :: Bool -> Assertion +guardedProgramEvaluation useLambda = mapM_ check [(library, sample) | library <- [False, True], sample <- [1, 0]] + where check (library, sample) = withSystemTempDirectory "sbv-guarded-evaluation" $ \dir -> do + let functionName = "guardedEvaluation" + evaluateTree :: SBool -> SBV (CodeGenTree, Bool) + evaluateTree chooseLeaf = + let rootTree = ite chooseLeaf (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + child = getCGLeaf_1 (getCGNode_1 rootTree) + selected = ite (isCGLeaf rootTree) (sCGLeaf (getCGLeaf_1 rootTree)) (sCGLeaf child) + valid = sAnd [ (isCGNode rootTree .&& child .== 7) .== sNot chooseLeaf + , isCGLeaf rootTree .|| child .== 7 + , isCGNode rootTree .=> child .== 7 + ] + in tuple (selected, valid) + program = do + cgOverwriteFiles True + cgSetDriverValues [sample] + chooseLeaf <- cgInput "chooseLeaf" :: SBVCodeGen SBool + let (selected, valid) = untuple $ if useLambda + then readArray (lambdaArray evaluateTree) chooseLeaf + else evaluateTree chooseLeaf + cgOutput "selectedTree" selected + cgReturn valid + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("guardedComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText && "selectedTree =CGLeaf(7)" `isInfixOf` outputText) + +-- | Preconditions must run before dependent outputs, and must not disappear +-- when an entry point has no outputs. A rejected leaf must report the named +-- constraint instead of crashing in the node-only output selector. +guardedRuntimeChecks :: Assertion +guardedRuntimeChecks = mapM_ check [(library, noResult, sample) | library <- [False, True], noResult <- [False, True], sample <- [0, 1]] + where check (library, noResult, sample) = withSystemTempDirectory "sbv-guarded-checks" $ \dir -> do + let functionName = "guardedChecks" + program = do + cgOverwriteFiles True + cgSetDriverValues [sample] + chooseLeaf <- cgInput "chooseLeaf" :: SBVCodeGen SBool + let rootTree = ite chooseLeaf (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + namedConstraint "node required" (isCGNode rootTree) + unless noResult $ cgReturn (getCGLeaf_1 (getCGNode_1 rootTree)) + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("guardedComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, _, runError) <- readProcessWithExitCode (dir functionName ++ "_driver") [] "" + if sample == 0 + then assertEqual runError ExitSuccess runExit + else do assertBool "Expected a rejected input" (runExit /= ExitSuccess) + assertBool runError ("CONSTRAINT FAILED: node required" `isInfixOf` runError) + +-- | A shared partial dependency must stay below its guard without being +-- copied exponentially into subsequent conditionals. The generated DAG has +-- only a few dozen nodes even though its expanded expression tree is large. +guardedEvaluationSharing :: Assertion +guardedEvaluationSharing = withSystemTempDirectory "sbv-guarded-sharing" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0] + flags <- cgInput "flags" :: SBVCodeGen SWord32 + let rootTree = ite (sTestBit flags 31) (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + initial = ite (isCGLeaf rootTree) (getCGLeaf_1 rootTree) (getCGLeaf_1 (getCGNode_1 rootTree)) + result = foldl (\previous bitIndex -> ite (sTestBit flags bitIndex) (previous + 1) (previous + 2)) initial [0 .. 17] + cgReturn result + (_, cfg, bundle) <- compileToC' "guardedSharing" program + assertBool "Guarded evaluation expanded a shared DAG exponentially" (length (show bundle) < 100000) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir "guardedSharing" + assertBool outputText (") = 43" `isInfixOf` outputText) + +-- | Finite selection demands only the chosen entry or the out-of-range +-- default. Exercise dynamic owned entries and constant-table defaults at all +-- three lowering sites, with both standalone and library entry points. +guardedTableEvaluation :: Assertion +guardedTableEvaluation = mapM_ check [ (library, scope, checked, sample) + | library <- [False, True] + , scope <- [0 :: Int, 1, 2] + , checked <- [False, True] + , sample <- if checked then [0, 1, 2] else [0, 1] + ] + where check (library, scope, checked, sample) = withSystemTempDirectory "sbv-guarded-tables" $ \dir -> do + let functionName = "guardedTables" + evaluateTable :: SWord8 -> SBV (CodeGenTree, Word8) + evaluateTable index = + let rootTree = ite (index .== 0) (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + child = getCGLeaf_1 (getCGNode_1 rootTree) + selected = select [sCGLeaf (getCGLeaf_1 rootTree), sCGLeaf child] (sCGLeaf (child + 1)) index + constant = select [7, 9] (child + 1) index + in tuple (selected, constant) + program = do + cgOverwriteFiles True + cgPerformRTCs checked + cgSetDriverValues [sample] + index <- cgInput "index" :: SBVCodeGen SWord8 + let result = case scope of + 0 -> evaluateTable index + 1 -> smtFunction "C guarded table function" evaluateTable index + _ -> readArray (lambdaArray evaluateTable) index + (selected, constant) = untuple result + expected = ite (index .< 2) 7 8 + cgOutput "selectedTree" selected + cgReturn (getCGLeaf_1 selected .== expected .&& constant .== ite (index .== 1) 9 expected) + (_, cfg, bundle) <- if library + then compileToCLib' functionName [("guardedComponent", program)] + else compileToC' functionName ((:[]) <$> program) + renderCgPgmBundle (Just dir) (cfg, bundle) + outputText <- compileAndRunGenerated dir functionName + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Check the original index before machine-index narrowing. Large exact, +-- signed-wide, and unsigned-wide indices must select the default, not alias +-- slot zero; unselected partial entries remain protected in all three cases. +guardedTableIndices :: Assertion +guardedTableIndices = mapM_ check [-1, 0, 1, 2, 2 ^ (80 :: Int)] + where check sample = withSystemTempDirectory "sbv-guarded-table-indices" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs True + cgSetDriverValues [sample] + index <- cgInput "index" :: SBVCodeGen SInteger + let rootTree = ite (index .== 0) (sCGLeaf 7) (sCGNode (sCGLeaf 7) (sCGLeaf 9)) + child = getCGLeaf_1 (getCGNode_1 rootTree) + entries = [sCGLeaf (getCGLeaf_1 rootTree), sCGLeaf child] + fallback = sCGLeaf (child + 1) + exact = select entries fallback index + signed = select entries fallback (sFromIntegral index :: SInt 673) + unsigned = select entries fallback (sFromIntegral index :: SWord 673) + expected = ite (index .>= 0 .&& index .< 2) 7 8 + cgReturn $ sAnd [getCGLeaf_1 selected .== expected | selected <- [exact, signed, unsigned]] + outputText <- compileProgramAndRunGenerated dir "guardedTableIndices" program + assertBool outputText (") = 1" `isInfixOf` outputText) + +-- | Exercise self-recursion, mutually recursive Boolean short-circuiting, and +-- an owned recursive list result. Each base case must avoid evaluating the +-- recursive branch in the generated C program. +recursiveDefinedSBVFunctions :: Assertion +recursiveDefinedSBVFunctions = withSystemTempDirectory "sbv-recursive-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5] + input <- cgInput "input" :: SBVCodeGen SWord8 + let countdown :: SWord8 -> SWord8 + countdown = smtFunctionNoTermination "C recursive countdown" $ \value -> + ite (value .== 0) 0 (1 + countdown (value - 1)) + + isEven :: SWord8 -> SBool + isEven = smtFunctionNoTermination "C mutually recursive even" $ \value -> + value .== 0 .|| isOdd (value - 1) + + isOdd :: SWord8 -> SBool + isOdd = smtFunctionNoTermination "C mutually recursive odd" $ \value -> + value ./= 0 .&& isEven (value - 1) + + implicationChain :: SWord8 -> SBool + implicationChain = smtFunctionNoTermination "C recursive implication" $ \value -> + value ./= 0 .=> implicationChain (value - 1) + + tableCount :: SWord8 -> SWord8 + tableCount = smtFunctionNoTermination "C recursive local table" $ \value -> + ite (value .== 0) 0 + (select [value, value + 1] 3 (ite (value .== 1) 1 0 :: SWord8) + tableCount (value - 1)) + + countdownList :: SWord8 -> SList Word8 + countdownList = smtFunctionNoTermination "C recursive list" $ \value -> + ite (value .== 0) + (literal [] :: SList Word8) + (value SL..: countdownList (value - 1)) + + factorial :: SInteger -> SInteger + factorial = smtFunctionNoTermination "C recursive exact factorial" $ \value -> + ite (value .<= 1) 1 (value * factorial (value - 1)) + + mcCarthy91 :: SInteger -> SInteger + mcCarthy91 = smtFunctionNoTermination "C nested recursive McCarthy 91" $ \value -> + ite (value .> 100) (value - 10) (mcCarthy91 (mcCarthy91 (value + 11))) + cgOutput "steps" (countdown input) + cgOutput "even" (isEven input) + cgOutput "odd" (isOdd input) + cgOutput "implication" (implicationChain input) + cgOutput "tableCount" (tableCount input) + cgOutput "factorial" (factorial 5) + cgOutput "mcCarthy91" (mcCarthy91 87) + cgReturn (countdownList input) + + stdoutText <- compileProgramAndRunGenerated dir "recursiveDefinedSBVFunctions" program + sourceText <- readFile (dir "recursiveDefinedSBVFunctions.c") + mapM_ (\fragment -> assertBool ("Expected recursive defined-function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =[5, 4, 3, 2, 1]" + , "steps = 5" + , "even = 0" + , "odd = 1" + , "implication = 1" + , "tableCount = 16" + , "factorial =120" + , "mcCarthy91 =91" + ] + assertBool ("Expected recursive calls to remain inside generated control flow, received:\n" ++ sourceText) + ("if(" `isInfixOf` sourceText + && length (filter ("/* Uninterpreted function */ sbv_function_" `isInfixOf`) (lines sourceText)) >= 4) + +-- | Exercise recursive private functions in independent translation units of +-- a generated static library. +recursiveDefinedSBVFunctionLibrary :: Assertion +recursiveDefinedSBVFunctionLibrary = withSystemTempDirectory "sbv-recursive-defined-function-library" $ \dir -> do + let component :: Word16 -> SBVCodeGen () + component offset = do + cgOverwriteFiles True + let sumTo :: SWord8 -> SWord16 + sumTo = smtFunctionNoTermination "C library recursive sum" $ \value -> + ite (value .== 0) 0 (sFromIntegral value + sumTo (value - 1)) + cgReturn (literal offset + sumTo 4) + + (_, cfg, bundle) <- compileToCLib' "recursiveDefinedSBVFunctionLibrary" + [ ("firstRecursive", component 10) + , ("secondRecursive", component 20) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "recursiveDefinedSBVFunctionLibrary" + mapM_ (\fragment -> assertBool ("Expected recursive library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstRecursive() = 0x0014U" + , "secondRecursive() = 0x001eU" + ] + +-- | Construct and update persistent arrays recursively, then use the returned +-- arrays after their defining C stack frames have unwound. +recursivePersistentArrayFunctions :: Assertion +recursivePersistentArrayFunctions = withSystemTempDirectory "sbv-recursive-persistent-array-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3] + input <- cgInput "input" :: SBVCodeGen SWord8 + let build :: SWord8 -> SArray Word8 Word8 + build = smtFunctionNoTermination "C recursive array build" $ \value -> + ite (value .== 0) + (constArray 7) + (writeArray (build (value - 1)) value (value + 10)) + + fill :: SWord8 -> SArray Word8 Word8 -> SArray Word8 Word8 + fill = smtFunctionNoTermination "C recursive array fill" $ \value array -> + ite (value .== 0) + array + (fill (value - 1) (writeArray array value (value + 20))) + + built = build input + filled = fill input built + + cgOutput "builtAtOne" (readArray built 1) + cgOutput "builtAtInput" (readArray built input) + cgOutput "filledAtOne" (readArray filled 1) + cgOutput "fallback" (readArray filled 9) + cgReturn filled + + stdoutText <- compileProgramAndRunGenerated dir "recursivePersistentArrayFunctions" program + sourceText <- readFile (dir "recursivePersistentArrayFunctions.c") + mapM_ (\fragment -> assertBool ("Expected recursive persistent-array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ")[0] =7" + , "builtAtOne = 11" + , "builtAtInput = 13" + , "filledAtOne = 21" + , "fallback = 7" + ] + assertBool ("Expected recursive array nodes to be declared outside guarded branches, received:\n" ++ sourceText) + ("sbv_array_node_2_u8_2_u8 sbv_local_array_s" `isInfixOf` sourceText + && "sbv_array_stored_export_2_u8_2_u8(&sbv_local_array_ctx" `isInfixOf` sourceText) + +-- | Construct, traverse, and return a recursive ADT through private recursive +-- functions after every child-producing C stack frame has unwound. +recursiveADTDefinedSBVFunctions :: Assertion +recursiveADTDefinedSBVFunctions = withSystemTempDirectory "sbv-recursive-adt-defined-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3] + input <- cgInput "input" :: SBVCodeGen SWord8 + let build :: SWord8 -> SCodeGenTree + build = smtFunctionNoTermination "C recursive ADT build" $ \value -> + ite (value .== 0) + (literal (CGNode (CGLeaf 4) (CGLeaf 5))) + (sCGNode (build (value - 1)) (sCGLeaf value)) + + leftmost :: SCodeGenTree -> SWord8 + leftmost = smtFunctionNoTermination "C recursive ADT leftmost" $ \tree -> + ite (isCGLeaf tree) + (getCGLeaf_1 tree) + (leftmost (getCGNode_1 tree)) + + leafSum :: SCodeGenTree -> SWord16 + leafSum = smtFunctionNoTermination "C recursive ADT leaf sum" $ \tree -> + ite (isCGLeaf tree) + (sFromIntegral (getCGLeaf_1 tree)) + (leafSum (getCGNode_1 tree) + leafSum (getCGNode_2 tree)) + + buildEven :: SWord8 -> SCodeGenEven + buildEven = smtFunctionNoTermination "C mutually recursive ADT even" $ \value -> + ite (value .== 0) + (sCGEvenEnd 0) + (sCGEvenStep (buildOdd (value - 1))) + + buildOdd :: SWord8 -> SCodeGenOdd + buildOdd = smtFunctionNoTermination "C mutually recursive ADT odd" $ sCGOddStep . buildEven + + result = build input + + cgOutput "leftmost" (leftmost result) + cgOutput "leafSum" (leafSum result) + cgOutput "mutual" (buildEven input) + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "recursiveADTDefinedSBVFunctions" program + sourceText <- readFile (dir "recursiveADTDefinedSBVFunctions.c") + mapM_ (\fragment -> assertBool ("Expected recursive-ADT function output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =CGNode(CGNode(CGNode(CGNode(CGLeaf(4), CGLeaf(5)), CGLeaf(1)), CGLeaf(2)), CGLeaf(3))" + , "leftmost = 4" + , "leafSum = 0x000fU" + , "mutual =CGEvenStep(CGOddStep(CGEvenStep(CGOddStep(CGEvenStep(CGOddStep(CGEvenEnd(0)))))))" + ] + assertBool ("Expected recursive ADT fields to use function-scoped backing values, received:\n" ++ sourceText) + ("SBVADT_CodeGenTree sbv_local_adt_recursive_" `isInfixOf` sourceText + && "sbv_function_result_clone_adt_" `isInfixOf` sourceText + && any (\line -> "const SBVADT_CodeGenTree l1_s" `isInfixOf` line + && "= (SBVADT_CodeGenTree)" `isInfixOf` line) + (lines sourceText)) + +-- | Exercise private recursive ADT builders in independent translation units +-- of a generated static library. +recursiveADTDefinedSBVFunctionLibrary :: Assertion +recursiveADTDefinedSBVFunctionLibrary = withSystemTempDirectory "sbv-recursive-adt-defined-function-library" $ \dir -> do + let component :: Word8 -> SBVCodeGen () + component offset = do + cgOverwriteFiles True + let build :: SWord8 -> SCodeGenTree + build = smtFunctionNoTermination "C library recursive ADT build" $ \value -> + ite (value .== 0) + (sCGLeaf (literal offset)) + (sCGNode (build (value - 1)) (sCGLeaf (literal offset + value))) + cgReturn (build 2) + + (_, cfg, bundle) <- compileToCLib' "recursiveADTDefinedSBVFunctionLibrary" + [ ("firstRecursiveADT", component 10) + , ("secondRecursiveADT", component 20) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "recursiveADTDefinedSBVFunctionLibrary" + mapM_ (\fragment -> assertBool ("Expected recursive-ADT library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstRecursiveADT() =CGNode(CGNode(CGLeaf(10), CGLeaf(11)), CGLeaf(12))" + , "secondRecursiveADT() =CGNode(CGNode(CGLeaf(20), CGLeaf(21)), CGLeaf(22))" + ] + +-- | Compile SBV's firstified higher-order list operations, including an +-- explicit symbolic closure environment, into ordinary private C functions. +higherOrderListFunctions :: Assertion +higherOrderListFunctions = withSystemTempDirectory "sbv-higher-order-list-functions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10, 5] + values <- cgInput "values" :: SBVCodeGen (SList Word8) + offset <- cgInput "offset" :: SBVCodeGen SWord8 + let mapped = SL.map (+ (1 :: SWord8)) values + filtered = SL.filter (\value -> value .> (11 :: SWord8)) mapped + folded = SL.foldl ((+) @SWord8) 0 mapped + paired = SL.zipWith ((+) @SWord8) values mapped + + closureShift :: Closure SWord8 (SWord8 -> SWord8) + closureShift = Closure { closureEnv = offset + , closureFun = (+) + } + + shifted = SL.map closureShift values + + cgOutput "mapped" mapped + cgOutput "filtered" filtered + cgOutput "folded" folded + cgOutput "paired" paired + cgReturn shifted + + stdoutText <- compileProgramAndRunGenerated dir "higherOrderListFunctions" program + sourceText <- readFile (dir "higherOrderListFunctions.c") + mapM_ (\fragment -> assertBool ("Expected firstified higher-order output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =[15, 16, 17]" + , "mapped =[11, 12, 13]" + , "filtered =[12, 13]" + , "folded = 36" + , "paired =[21, 23, 25]" + ] + assertBool ("Expected higher-order instances to become private first-order C functions, received:\n" ++ sourceText) + ("/* Uninterpreted function */ sbv_function_" `isInfixOf` sourceText) + +-- | Exercise independently specialized higher-order functions in separate +-- translation units of a generated static library. +higherOrderListFunctionLibrary :: Assertion +higherOrderListFunctionLibrary = withSystemTempDirectory "sbv-higher-order-list-function-library" $ \dir -> do + let component :: Word8 -> SBVCodeGen () + component offset = do + cgOverwriteFiles True + cgSetDriverValues [10] + values <- cgInput "values" :: SBVCodeGen (SList Word8) + cgReturn (SL.map (\(value :: SWord8) -> value + literal offset) values) + + (_, cfg, bundle) <- compileToCLib' "higherOrderListFunctionLibrary" + [ ("addTen", component 10) + , ("addTwenty", component 20) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "higherOrderListFunctionLibrary" + mapM_ (\fragment -> assertBool ("Expected higher-order library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "addTen(((SBVList_u8) {(const SWord8[]) {10, 11, 12}, 3})) =[20, 21, 22]" + , "addTwenty(((SBVList_u8) {(const SWord8[]) {10, 11, 12}, 3})) =[30, 31, 32]" + ] + +-- | Exercise unnamed and named hard constraints as generated-C precondition +-- checks, including a Boolean input used only by a constraint and an escaped +-- UTF-8 diagnostic name. +explicitHardConstraints :: Assertion +explicitHardConstraints = withSystemTempDirectory "sbv-explicit-hard-constraints" $ \dir -> do + let constraintName = "value is \"seven\" (100%) \955" + program driverValues = do + cgOverwriteFiles True + cgSetDriverValues driverValues + enabled <- cgInput "enabled" :: SBVCodeGen SBool + value <- cgInput "value" :: SBVCodeGen SWord8 + constrain enabled + namedConstraint constraintName (value .== 7) + cgReturn (value + 1) + + validDir = dir "valid" + invalidDir = dir "invalid" + + validOutput <- compileProgramAndRunGenerated validDir "explicitHardConstraints" (program [1, 7]) + assertBool ("Expected constrained output to contain 8, received:\n" ++ validOutput) + (") = 8" `isInfixOf` validOutput) + + (_, invalidCfg, invalidBundle) <- compileToC' "explicitHardConstraints" (program [1, 6]) + renderCgPgmBundle (Just invalidDir) (invalidCfg, invalidBundle) + makeOptions <- generatedMakeOptions invalidDir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", invalidDir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + (runExit, _, runError) <- readProcessWithExitCode (invalidDir "explicitHardConstraints_driver") [] "" + assertBool "Expected a violated hard constraint to terminate the generated driver" + (case runExit of ExitFailure _ -> True; ExitSuccess -> False) + assertBool ("Expected the named constraint diagnostic, received:\n" ++ runError) + (("CONSTRAINT FAILED: " ++ constraintName) `isInfixOf` runError) + +-- | Check that constraint forms requiring solver optimization or SMT-only +-- attributes receive focused diagnostics instead of being silently weakened. +unsupportedConstraintFeatures :: Assertion +unsupportedConstraintFeatures = do + softResult <- try (do + (_, _, bundle) <- compileToC' "softConstraint" $ do + value <- cgInput "value" :: SBVCodeGen SBool + softConstrain value + cgReturn value + evaluate (length (show bundle))) :: IO (Either ErrorCall Int) + case softResult of + Left exception -> assertBool ("Expected a soft-constraint diagnostic, received:\n" ++ displayException exception) + ("Soft constraints" `isInfixOf` displayException exception) + Right _ -> assertBool "Expected C generation to reject a soft constraint" False + + attributeResult <- try (do + (_, _, bundle) <- compileToC' "attributedConstraint" $ do + value <- cgInput "value" :: SBVCodeGen SBool + constrainWithAttribute [(":weight", "2")] value + cgReturn value + evaluate (length (show bundle))) :: IO (Either ErrorCall Int) + case attributeResult of + Left exception -> assertBool ("Expected a constraint-attribute diagnostic, received:\n" ++ displayException exception) + ("Constraint attributes: :weight" `isInfixOf` displayException exception) + Right _ -> assertBool "Expected C generation to reject an SMT-only constraint attribute" False + +-- | Exercise a sole 'cgReturnArr' group through the generated output-parameter +-- ABI while preserving the return elements' declaration order. +nonAtomicReturnGroup :: Assertion +nonAtomicReturnGroup = withSystemTempDirectory "sbv-non-atomic-return-group" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4] + input <- cgInput "input" :: SBVCodeGen SWord16 + cgReturnArr [input + 1, input + 2, input + 3] + + stdoutText <- compileProgramAndRunGenerated dir "nonAtomicReturnGroup" program + headerText <- readFile (dir "nonAtomicReturnGroup.h") + mapM_ (\fragment -> assertBool ("Expected non-atomic return output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "result_0[0] = 0x0005U" + , "result_0[1] = 0x0006U" + , "result_0[2] = 0x0007U" + ] + assertBool "Expected a sole array return group to use a void output-parameter ABI" + ("void nonAtomicReturnGroup(" `isInfixOf` headerText + && "SWord16 *result_0" `isInfixOf` headerText) + +-- | Exercise multiple ordered return groups containing a scalar, an owned +-- symbolic list, and a fixed-size C array. +multipleReturnGroups :: Assertion +multipleReturnGroups = withSystemTempDirectory "sbv-multiple-return-groups" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4] + input <- cgInput "input" :: SBVCodeGen SWord16 + cgReturn (input + 1) + cgReturn (literal ([10, 11] :: [Word16])) + cgReturn (sFromIntegral input + 20 :: SInteger) + cgReturnArr [input + 2, input + 3] + + stdoutText <- compileProgramAndRunGenerated dir "multipleReturnGroups" program + headerText <- readFile (dir "multipleReturnGroups.h") + mapM_ (\fragment -> assertBool ("Expected multiple-return output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "result_0 = 0x0005U" + , "result_1 =[0x000aU, 0x000bU]" + , "result_2 =24" + , "result_3[0] = 0x0006U" + , "result_3[1] = 0x0007U" + ] + assertBool "Expected multiple return groups to use ordered output parameters" + ("void multipleReturnGroups(" `isInfixOf` headerText + && "SWord16 *result_0" `isInfixOf` headerText + && "SWord16 *result_3" `isInfixOf` headerText) + +-- | Fixed-size symbolic-array inputs use public callback descriptors rather +-- than private array nodes. Distinct seeds must initialize each callback, and +-- managed defaults and returned arrays have independent ownership. +groupedArrayInputs :: Bool -> Assertion +groupedArrayInputs library = withSystemTempDirectory "sbv-grouped-array-inputs" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 7, 11, 15] + native <- cgInputArr 2 "native" :: SBVCodeGen [SArray Word8 Word16] + exact <- cgInputArr 2 "exact" :: SBVCodeGen [SArray Word8 [Integer]] + cgOutputArr "nativeValues" [readArray value 0 | value <- native] + cgOutputArr "exactHeads" [SL.head (readArray value 0) | value <- exact] + cgReturnArr native + cgReturnArr exact + outputText <- runGroupedInputProgram dir "groupedArrayInputs" library program + headerText <- readFile (dir "groupedArrayInputs.h") + mapM_ (\fragment -> assertBool outputText (fragment `isInfixOf` outputText)) + [ "nativeValues[0] = 0x0003U" + , "nativeValues[1] = 0x0007U" + , "exactHeads[0] = 11" + , "exactHeads[1] = 15" + , "result_0[1][0] =0x0007U" + , "result_1[1][0] =[15, 16, 17]" + ] + assertBool "Expected public callback descriptors for grouped array inputs" + ("const SBVArrayInput_2_u8_3_u16 *native" `isInfixOf` headerText) + +-- | A hand-written caller can pass callback groups without private runtime +-- nodes. Returned groups retain each context independently across later calls. +groupedArrayInputOwnership :: Assertion +groupedArrayInputOwnership = withSystemTempDirectory "sbv-grouped-array-ownership" $ \dir -> do + _ <- compileToCLib (Just dir) "arrayGroupLibrary" + [("copyArrayGroup", do + cgOverwriteFiles True + cgGenerateDriver False + values <- cgInputArr 2 "values" :: SBVCodeGen [SArray Word8 Word16] + cgReturnArr values)] + compileAndRunCaller dir "arrayGroupLibrary" $ unlines + [ "#include \"arrayGroupLibrary.h\"" + , "#include " + , "static unsigned live_contexts;" + , "static SWord16 lookup(const void *context, SWord8 key)" + , "{ return *(const SWord16 *) context + key; }" + , "static const void *retain(const void *context)" + , "{ SWord16 *copy = malloc(sizeof(*copy)); assert(copy != NULL); *copy = *(const SWord16 *) context; ++live_contexts; return copy; }" + , "static void release(const void *context)" + , "{ --live_contexts; free((void *) context); }" + , "int main(void)" + , "{" + , " for (unsigned i = 0; i < 32; ++i) {" + , " SWord16 data[] = {7, 23};" + , " const SBVArrayInput_2_u8_3_u16 inputs[] = {{lookup, &data[0], retain, release}, {lookup, &data[1], retain, release}};" + , " SBVArrayOutput_2_u8_3_u16 first[2], second[2];" + , " copyArrayGroup(inputs, first);" + , " data[0] = 99; data[1] = 101;" + , " const SBVArrayInput_2_u8_3_u16 borrowed[] = {sbv_array_output_as_input_2_u8_3_u16(first[1]), sbv_array_output_as_input_2_u8_3_u16(first[0])};" + , " copyArrayGroup(borrowed, second);" + , " for (unsigned j = 0; j < 2; ++j) sbv_array_output_release_2_u8_3_u16(&first[j]);" + , " assert(live_contexts == 2);" + , " assert(sbv_array_output_read_2_u8_3_u16(second[0], 1) == 24);" + , " assert(sbv_array_output_read_2_u8_3_u16(second[1], 1) == 8);" + , " for (unsigned j = 0; j < 2; ++j) sbv_array_output_release_2_u8_3_u16(&second[j]);" + , " assert(live_contexts == 0);" + , " }" + , " return 0;" + , "}" + ] + +-- | Managed input groups need per-element initialization, including nested +-- exact values and retained arrays, followed by exactly one owner cleanup. +groupedManagedInputs :: Bool -> Assertion +groupedManagedInputs library = withSystemTempDirectory "sbv-grouped-managed-inputs" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 7, 11, 15, 21, 25, 1, 5, 31, 35] + lists <- cgInputArr 2 "lists" :: SBVCodeGen [SList Integer] + sets <- cgInputArr 2 "sets" :: SBVCodeGen [SSet Rational] + pairs <- cgInputArr 2 "pairs" :: SBVCodeGen [SBV (Integer, [Integer])] + adts <- cgInputArr 2 "adts" :: SBVCodeGen [SCodeGenCollections] + arrays <- cgInputArr 2 "arrays" :: SBVCodeGen [SList (ArrayModel Word8 Word16)] + cgOutputArr "listHeads" (map SL.head lists) + cgOutputArr "pairIntegers" (map (fst . untuple) pairs) + cgOutputArr "arrayHeads" [readArray (SL.head value) 0 | value <- arrays] + cgReturnArr lists + cgReturnArr sets + cgReturnArr pairs + cgReturnArr adts + cgReturnArr arrays + outputText <- runGroupedInputProgram dir "groupedManagedInputs" library program + mapM_ (\fragment -> assertBool outputText (fragment `isInfixOf` outputText)) + [ "listHeads[0] = 3" + , "listHeads[1] = 7" + , "pairIntegers[0] = 21" + , "pairIntegers[1] = 25" + , "arrayHeads[0] = 0x001fU" + , "arrayHeads[1] = 0x0023U" + , "result_0[1] = [7, 8, 9]" + ] + +-- | Exercise the same grouped-input program through standalone generation +-- and two translation units sharing one library header and combined driver. +runGroupedInputProgram :: FilePath -> String -> Bool -> SBVCodeGen () -> IO String +runGroupedInputProgram dir programName library program + | library = do + (_, cfg, bundle) <- compileToCLib' programName [(programName ++ "First", program), (programName ++ "Second", program)] + renderCgPgmBundle (Just dir) (cfg, bundle) + compileAndRunGenerated dir programName + | True = compileProgramAndRunGenerated dir programName program + +-- | Exercise deep ownership and element-wise cleanup for non-atomic return +-- groups containing lists, exact integers, and persistent arrays. +managedReturnGroups :: Assertion +managedReturnGroups = withSystemTempDirectory "sbv-managed-return-groups" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4] + input <- cgInput "input" :: SBVCodeGen SWord16 + let baseArray = constArray 5 :: SArray Word8 Word16 + cgReturnArr [ literal ([1, 2] :: [Word16]) + , literal ([3, 4] :: [Word16]) + ] + cgReturnArr [ sFromIntegral input + 30 :: SInteger + , sFromIntegral input + 31 + ] + cgReturnArr [baseArray, writeArray baseArray 0 9] + + stdoutText <- compileProgramAndRunGenerated dir "managedReturnGroups" program + headerText <- readFile (dir "managedReturnGroups.h") + sourceText <- readFile (dir "managedReturnGroups.c") + driverText <- readFile (dir "managedReturnGroups_driver.c") + mapM_ (\fragment -> assertBool ("Expected managed return-group output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "result_0[0] = [0x0001U, 0x0002U]" + , "result_0[1] = [0x0003U, 0x0004U]" + , "result_1[0] = 34" + , "result_1[1] = 35" + , "result_2[0][0] =0x0005U" + , "result_2[1][0] =0x0009U" + ] + assertBool "Expected exact and persistent-array groups to expose mutable output arrays" + ("mpz_t *result_1" `isInfixOf` headerText + && "SBVArrayOutput_2_u8_3_u16 *result_2" `isInfixOf` headerText) + assertBool ("Expected managed group elements to be cloned and released independently, received:\n" + ++ unlines (filter ("sbv_" `isInfixOf`) (lines (sourceText ++ driverText)))) + ("sbv_output_0[0] = sbv_list_clone_u16" `isInfixOf` sourceText + && "sbv_list_release_u16(&sbv_driver_output_0[0]);" `isInfixOf` driverText + && "sbv_array_output_release_2_u8_3_u16(&sbv_driver_output_2[0]);" `isInfixOf` driverText) + +-- | Exercise grouped return ABIs across multiple generated library +-- translation units. +groupedReturnLibrary :: Assertion +groupedReturnLibrary = withSystemTempDirectory "sbv-grouped-return-library" $ \dir -> do + let component increment seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + input <- cgInput "input" :: SBVCodeGen SWord16 + cgReturnArr [input + literal increment, input + literal increment + 1] + cgReturn (literal ([increment, increment + 1] :: [Word16])) + + (_, cfg, bundle) <- compileToCLib' "groupedReturnLibrary" + [ ("firstGroups", component 1 4) + , ("secondGroups", component 2 8) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "groupedReturnLibrary" + headerText <- readFile (dir "groupedReturnLibrary.h") + mapM_ (\fragment -> assertBool ("Expected grouped library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "result_0[0] = 0x0005U" + , "result_0[1] = 0x0006U" + , "result_1 =[0x0001U, 0x0002U]" + , "result_0[0] = 0x000aU" + , "result_0[1] = 0x000bU" + , "result_1 =[0x0002U, 0x0003U]" + ] + assertBool "Expected both library components to publish grouped output parameters" + ("void firstGroups(" `isInfixOf` headerText + && "void secondGroups(" `isInfixOf` headerText + && length (filter ("SWord16 *result_0" `isInfixOf`) (lines headerText)) == 2) + +-- | Exercise 'freeArray' by supplying the corresponding total C function as +-- a user declaration, preserving the existing uninterpreted-function escape hatch. +definedFreeArray :: Assertion +definedFreeArray = withSystemTempDirectory "sbv-defined-free-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [9] + cgAddDecl ["static SWord32 free_source(SWord16 key) { return (SWord32) key + UINT32_C(5); }"] + key <- cgInput "key" :: SBVCodeGen SWord16 + let source = freeArray "free_source" :: SArray Word16 Word32 + cgReturn (readArray source key) + + stdoutText <- compileProgramAndRunGenerated dir "definedFreeArray" program + assertBool ("Expected defined free-array output to contain 0x0000000eUL, received:\n" ++ stdoutText) ("0x0000000eUL" `isInfixOf` stdoutText) + +-- | Exercise independent owned descriptors for an array output parameter and +-- an array return, including persistent stores above a structured callback. +ownedArrayResults :: Assertion +ownedArrayResults = withSystemTempDirectory "sbv-owned-array-results" $ \dir -> do + let program = do + cgOverwriteFiles True + let source = lambdaArray (\index -> sFromIntegral index + 5) :: SArray Word8 Word32 + cgOutput "owned" (writeArray source 0 99) + cgReturn (writeArray source 0 42) + + stdoutText <- compileProgramAndRunGenerated dir "ownedArrayResults" program + mapM_ (\fragment -> assertBool ("Expected owned-array output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "ownedArrayResults(&owned)[0] =0x0000002aUL" + , "owned[0] =0x00000063UL" + ] + +-- | Exercise retention of a borrowed input callback when a persistent array +-- derived from it escapes through an owned return descriptor. +escapingCallbackArray :: Assertion +escapingCallbackArray = withSystemTempDirectory "sbv-escaping-callback-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [7] + source <- cgInput "source" :: SBVCodeGen (SArray Word8 Word32) + cgReturn (writeArray source 1 99) + + stdoutText <- compileProgramAndRunGenerated dir "escapingCallbackArray" program + assertBool ("Expected retained callback output to contain 0x00000007UL, received:\n" ++ stdoutText) ("[0] =0x00000007UL" `isInfixOf` stdoutText) + +-- | Exercise structural object equality and deep ownership for array keys and +-- values containing lists, sets, strings, tuples, and concrete ADTs. +managedAggregateArrays :: Assertion +managedAggregateArrays = withSystemTempDirectory "sbv-managed-aggregate-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4, 10, 12] + source <- cgInput "source" :: SBVCodeGen (SArray [Word16] CodeGenNativeCollections) + key <- cgInput "key" :: SBVCodeGen (SList Word16) + exactSource <- cgInput "exactSource" :: SBVCodeGen (SArray Word8 (String, Integer)) + let storedADT = sCGNativeCollections + (literal ([90, 91] :: [Word16])) + (SS.fromList [92, 93]) + updatedADT = writeArray source key storedADT + stringKey = literal "stored" :: SString + defaultTuple = tuple (literal "default" :: SString, literal ([1, 2] :: [Integer])) + storedTuple = tuple (literal "stored-value" :: SString, literal ([7, 8] :: [Integer])) + tupleArray = writeArray (constArray defaultTuple :: SArray String (String, [Integer])) stringKey storedTuple + setKey = SS.fromList [5, 6] :: SSet Word16 + storedList = literal ([7, 8] :: [Word16]) + setArray = writeArray (constArray (literal ([1, 2] :: [Word16])) :: SArray (RCSet Word16) [Word16]) setKey storedList + enumArray = writeArray (constArray 3 :: SArray CodeGenEnum Word8) sCGBlue 9 + cgOutput "matchedADT" (readArray updatedADT key .=== storedADT) + cgOutput "matchedSet" (readArray setArray setKey .=== storedList) + cgOutput "matchedEnum" (readArray enumArray sCGBlue .== (9 :: SWord8)) + cgOutput "storedADT" (readArray updatedADT key) + cgOutput "tupleArray" tupleArray + cgOutput "storedTuple" (readArray tupleArray stringKey) + cgOutput "setArray" setArray + cgOutput "enumArray" enumArray + cgOutput "exactSourceCopy" exactSource + cgReturn updatedADT + + stdoutText <- compileProgramAndRunGenerated dir "managedAggregateArrays" program + headerText <- readFile (dir "managedAggregateArrays.h") + sourceText <- readFile (dir "managedAggregateArrays.c") + driverText <- readFile (dir "managedAggregateArrays_driver.c") + mapM_ (\fragment -> assertBool ("Expected managed aggregate-array output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "matchedADT = 1" + , "matchedSet = 1" + , "matchedEnum = 1" + , "storedADT =CGNativeCollections([0x005aU, 0x005bU], {0x005cU, 0x005dU})" + , "storedTuple =(stored-value, [7, 8])" + , "tupleArray[0] =(default, [1, 2])" + , "setArray[0] =[0x0001U, 0x0002U]" + , "enumArray[0] =3" + , "exactSourceCopy[0] =(sbv12, 13)" + ] + assertBool "Expected exported arrays to own aggregate keys and values" + ("sbv_list_clone_u16(source->key)" `isInfixOf` sourceText + && "sbv_adt_owned_clone_SBVADT_CodeGenNativeCollections(source->value)" `isInfixOf` sourceText + && "sbv_string_clone(source->key)" `isInfixOf` sourceText + && "sbv_tuple_owned_clone_" `isInfixOf` sourceText + && "sbv_set_clone_u16(source->key)" `isInfixOf` sourceText + && "sbv_list_clone_u16(source->value)" `isInfixOf` sourceText + && "sbv_adt_owned_clone_SBVADT_CodeGenEnum(source->key)" `isInfixOf` sourceText + && "sbv_adt_owned_release_SBVADT_CodeGenNativeCollections" `isInfixOf` sourceText) + assertBool "Expected managed callback defaults to use deep retain and release helpers" + ("sbv_adt_owned_clone_SBVADT_CodeGenNativeCollections" `isInfixOf` headerText + && "sbv_local_array_retain_" `isInfixOf` driverText + && "sbv_local_array_release_" `isInfixOf` driverText + && "sbv_tuple_owned_clone_" `isInfixOf` driverText + && "sbv_tuple_owned_release_" `isInfixOf` driverText) + +-- | Exercise guarded aggregate-array declarations and owned return values +-- shared by multiple generated library translation units. +managedAggregateArrayLibrary :: Assertion +managedAggregateArrayLibrary = withSystemTempDirectory "sbv-managed-aggregate-array-library" $ \dir -> do + let component :: Integer -> Word16 -> SBVCodeGen () + component seed keyValue = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen (SArray (RCSet Word16) CodeGenNativeCollections) + let key = SS.singleton (literal keyValue) + value = sCGNativeCollections + (literal ([keyValue, keyValue + 1] :: [Word16])) + (SS.fromList [keyValue + 2, keyValue + 3]) + cgReturn (writeArray source key value) + + (_, cfg, bundle) <- compileToCLib' "managedAggregateArrayLibrary" + [ ("firstManagedArray", component 1 20) + , ("secondManagedArray", component 4 30) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "managedAggregateArrayLibrary" + headerText <- readFile (dir "managedAggregateArrayLibrary.h") + mapM_ (\fragment -> assertBool ("Expected managed aggregate-array library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "firstManagedArray(source)[0] =CGNativeCollections([0x0001U, 0x0002U, 0x0003U]" + , "secondManagedArray(source)[0] =CGNativeCollections([0x0004U, 0x0005U, 0x0006U]" + ] + assertBool "Expected one reusable guarded aggregate-array ABI" + ("SBVArrayOutput_9_set_3_u16_39_adt_SBVADT_x5f_CodeGenNativeCollections" `isInfixOf` headerText + && "sbv_array_output_release_9_set_3_u16_39_adt_SBVADT_x5f_CodeGenNativeCollections" `isInfixOf` headerText) + +-- | Exercise static and runtime-local finite tables containing text, lists, +-- sets, and ADTs with managed collection fields. +managedAggregateTables :: Assertion +managedAggregateTables = withSystemTempDirectory "sbv-managed-aggregate-tables" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 5] + selector <- cgInput "selector" :: SBVCodeGen SWord8 + source <- cgInput "source" :: SBVCodeGen (SList Word16) + let staticText :: SString + staticText = select [literal "zero", literal "one"] (literal "other") selector + staticList = select [literal ([1, 2] :: [Word16]), literal ([3, 4] :: [Word16])] + (literal ([9] :: [Word16])) selector + dynamicList = select [source, source SL.++ SL.singleton 9] + (literal ([10] :: [Word16])) selector + staticSet :: SSet Word16 + staticSet = select [SS.fromList [1, 2], SS.fromList [3, 4]] + (SS.singleton 9) selector + firstADT = sCGNativeCollections source (SS.singleton 20) + secondADT = sCGNativeCollections (source SL.++ SL.singleton 21) (SS.fromList [22, 23]) + selectedADT = select [firstADT, secondADT] (sCGNativeCollections SL.nil SS.empty) selector + cgOutput "staticText" staticText + cgOutput "staticList" staticList + cgOutput "dynamicList" dynamicList + cgOutput "staticSet" staticSet + cgOutput "selectedADT" selectedADT + cgReturn selectedADT + + stdoutText <- compileProgramAndRunGenerated dir "managedAggregateTables" program + sourceText <- readFile (dir "managedAggregateTables.c") + mapM_ (\fragment -> assertBool ("Expected managed aggregate-table output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =CGNativeCollections([0x0005U, 0x0006U, 0x0007U, 0x0015U], {0x0016U, 0x0017U})" + , "staticText =one" + , "staticList =[0x0003U, 0x0004U]" + , "dynamicList =[0x0005U, 0x0006U, 0x0007U, 0x0009U]" + , "staticSet ={0x0003U, 0x0004U}" + , "selectedADT =CGNativeCollections([0x0005U, 0x0006U, 0x0007U, 0x0015U], {0x0016U, 0x0017U})" + ] + assertBool "Expected ready aggregates to use automatic tables and dynamic entries to remain guarded" + ( "const SString table" `isInfixOf` sourceText + && "const SBVList_u16 table" `isInfixOf` sourceText + && "const SBVSet_u16 table" `isInfixOf` sourceText + && "switch((uint64_t)" `isInfixOf` sourceText + && not ("static const SString table" `isInfixOf` sourceText) + && not ("static const SBVList_u16 table" `isInfixOf` sourceText) + && not ("static const SBVSet_u16 table" `isInfixOf` sourceText) + && not ("static const SBVADT_CodeGenNativeCollections table" `isInfixOf` sourceText) + ) + +-- | Exercise finite tables whose cells and default are retained arrays, both +-- when entries are already demanded by earlier outputs and when the lookup +-- must initialize only the selected entry. +arrayValuedTables :: Bool -> Assertion +arrayValuedTables readyEntries = withSystemTempDirectory "sbv-array-valued-tables" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs True + cgSetDriverValues [1, 3] + selector <- cgInput "selector" :: SBVCodeGen SWord8 + key <- cgInput "key" :: SBVCodeGen SWord8 + let first = writeArray (constArray 10) key 11 :: SArray Word8 Word32 + second = writeArray (constArray 20) key 21 :: SArray Word8 Word32 + fallback = constArray 30 :: SArray Word8 Word32 + selected = select [first, second] fallback selector + defaulted = select [first, second] fallback (selector + 2) + when readyEntries $ do cgOutput "first" first + cgOutput "second" second + cgOutput "selected" selected + cgOutput "defaultValue" (readArray defaulted key) + cgReturn (readArray selected key) + + stdoutText <- compileProgramAndRunGenerated dir "arrayValuedTables" program + sourceText <- readFile (dir "arrayValuedTables.c") + assertBool ("Expected the selected array value, received:\n" ++ stdoutText) ("0x00000015UL" `isInfixOf` stdoutText) + assertBool ("Expected the out-of-range default array value, received:\n" ++ stdoutText) ("defaultValue = 0x0000001eUL" `isInfixOf` stdoutText) + if readyEntries + then assertBool ("Expected retained array-valued table storage, received:\n" ++ sourceText) + ( "SBVArrayOutput_2_u8_3_u32 * const table" `isInfixOf` sourceText + && "sbv_array_stored_export_2_u8_3_u32(&sbv_local_array_ctx" `isInfixOf` sourceText + && "sbv_local_array_descriptor_" `isInfixOf` sourceText + ) + else assertBool "Expected guarded array initialization followed by an owned output export" + ( "switch((uint64_t)" `isInfixOf` sourceText + && "sbv_array_export_2_u8_3_u32(" `isInfixOf` sourceText + && "sbv_local_array_s" `isInfixOf` sourceText + ) + +-- | Exercise managed finite-table results returned independently from +-- multiple generated library translation units. +managedAggregateTableLibrary :: Assertion +managedAggregateTableLibrary = withSystemTempDirectory "sbv-managed-aggregate-table-library" $ \dir -> do + let component :: Integer -> Word16 -> SBVCodeGen () + component driverSeed base = do + cgOverwriteFiles True + cgSetDriverValues [driverSeed] + selector <- cgInput "selector" :: SBVCodeGen SWord8 + cgReturn (select [ literal ([base, base + 1] :: [Word16]) + , literal ([base + 2, base + 3] :: [Word16]) + ] (literal ([] :: [Word16])) selector) + + (_, cfg, bundle) <- compileToCLib' "managedAggregateTableLibrary" + [ ("firstManagedTable", component 0 10) + , ("secondManagedTable", component 1 20) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "managedAggregateTableLibrary" + mapM_ (\fragment -> assertBool ("Expected managed aggregate-table library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "[0x000aU, 0x000bU]" + , "[0x0016U, 0x0017U]" + ] + +-- | Exercise nested tuple inputs, construction, projection, conditionals, +-- tuple constants in finite tables, public outputs, and returns. +structuralTuples :: Assertion +structuralTuples = withSystemTempDirectory "sbv-structural-tuples" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [3, 0] + source <- cgInput "source" :: SBVCodeGen (SBV (Word8, (Word16, Word32))) + selector <- cgInput "selector" :: SBVCodeGen SWord8 + let (first, nested) = untuple source + (second, third) = untuple nested + rebuilt = tuple (first + 1, tuple (second + 2, third + 3)) + alternate = tuple (9, tuple (10, 11)) + selected = select [rebuilt, alternate] alternate selector + conditional = ite (selector .== 0) rebuilt alternate + cgOutput "selected" selected + cgOutput "rounding" (tuple (sRTN, first)) + cgOutput "unit" (literal () :: SBV ()) + cgReturn conditional + + stdoutText <- compileProgramAndRunGenerated dir "structuralTuples" program + mapM_ (\fragment -> assertBool ("Expected tuple output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "(4, (0x0006U, 0x00000008UL))" + , "selected =(4, (0x0006U, 0x00000008UL))" + , "rounding =(3, 3)" + , "unit =()" + ] + +-- | Exercise guarded tuple declarations shared by multiple generated library +-- translation units and returned through the public by-value ABI. +structuralTupleLibrary :: Assertion +structuralTupleLibrary = withSystemTempDirectory "sbv-structural-tuple-library" $ \dir -> do + let component :: Integer -> SBVCodeGen () + component increment = do + cgOverwriteFiles True + cgSetDriverValues [4] + source <- cgInput "source" :: SBVCodeGen (SBV (Word8, Word16)) + let (first, second) = untuple source + cgReturn (tuple (first + fromInteger increment, second + fromInteger increment)) + + (_, cfg, bundle) <- compileToCLib' "structuralTupleLibrary" + [ ("incrementTuple", component 1) + , ("addTwoTuple", component 2) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "structuralTupleLibrary" + mapM_ (\fragment -> assertBool ("Expected tuple library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "(5, 0x0006U)" + , "(6, 0x0007U)" + ] + +-- | Exercise borrowed nested tuple strings and independently owned tuple +-- outputs and returns. +ownedTextTuples :: Assertion +ownedTextTuples = withSystemTempDirectory "sbv-owned-text-tuples" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [4] + source <- cgInput "source" :: SBVCodeGen (SBV (String, (String, Word8))) + let (first, nested) = untuple source + (second, count) = untuple nested + result = tuple (first SL.++ literal ":" SL.++ second, tuple (second SL.++ literal "!", count + 1)) + cgOutput "sourceCopy" source + cgOutput "result" result + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "ownedTextTuples" program + headerText <- readFile (dir "ownedTextTuples.h") + mapM_ (\fragment -> assertBool ("Expected owned text-tuple output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =(sbv4:sbv5, (sbv5!, 7))" + , "sourceCopy =(sbv4, (sbv5, 6))" + , "result =(sbv4:sbv5, (sbv5!, 7))" + ] + assertBool "Expected recursive string ownership in generated tuple helpers" + ("sbv_string_clone(source.field1)" `isInfixOf` headerText + && "sbv_string_release(&value->field1)" `isInfixOf` headerText) + +-- | Exercise guarded string-tuple ownership helpers shared by multiple +-- generated library translation units. +ownedTextTupleLibrary :: Assertion +ownedTextTupleLibrary = withSystemTempDirectory "sbv-owned-text-tuple-library" $ \dir -> do + let component suffix resultValue seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen SString + cgReturn (tuple (source SL.++ suffix, literal resultValue :: SWord8)) + + (_, cfg, bundle) <- compileToCLib' "ownedTextTupleLibrary" + [ ("firstTextTuple", component (literal "!") 9 4) + , ("secondTextTuple", component (literal "?") 8 5) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "ownedTextTupleLibrary" + mapM_ (\fragment -> assertBool ("Expected text-tuple library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "(sbv4!, 9)" + , "(sbv5?, 8)" + ] + +-- | Exercise recursively nested tuple ownership across strings, exact-element +-- lists, and exact-element finite sets. +ownedCollectionTuples :: Assertion +ownedCollectionTuples = withSystemTempDirectory "sbv-owned-collection-tuples" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [10] + source <- cgInput "source" :: SBVCodeGen (SBV (String, ([Integer], RCSet Rational))) + let (prefix, nested) = untuple source + (values, members) = untuple nested + result = tuple (prefix SL.++ literal "!", tuple (values SL.++ literal ([14] :: [Integer]), SS.insert 15 members)) + cgOutput "sourceCopy" source + cgOutput "result" result + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "ownedCollectionTuples" program + headerText <- readFile (dir "ownedCollectionTuples.h") + mapM_ (\fragment -> assertBool ("Expected owned collection-tuple output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =(sbv10!, ([11, 12, 13, 14], {12, 13, 14, 15}))" + , "sourceCopy =(sbv10, ([11, 12, 13], {12, 13, 14}))" + , "result =(sbv10!, ([11, 12, 13, 14], {12, 13, 14, 15}))" + ] + assertBool "Expected recursive collection ownership in generated tuple helpers" + ("sbv_list_clone_integer(source.field1)" `isInfixOf` headerText + && "sbv_list_release_integer(&value->field1)" `isInfixOf` headerText + && "sbv_set_clone_rational(source.field2)" `isInfixOf` headerText + && "sbv_set_release_rational(&value->field2)" `isInfixOf` headerText) + +-- | Exercise guarded collection-tuple declarations and exact-element +-- ownership helpers shared by multiple generated library translation units. +ownedCollectionTupleLibrary :: Assertion +ownedCollectionTupleLibrary = withSystemTempDirectory "sbv-owned-collection-tuple-library" $ \dir -> do + let component :: Integer -> Integer -> SBVCodeGen () + component seed extra = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen (SBV ([Integer], RCSet Rational)) + let (values, members) = untuple source + cgReturn (tuple (values SL.++ literal [extra], SS.insert (fromInteger extra) members)) + + (_, cfg, bundle) <- compileToCLib' "ownedCollectionTupleLibrary" + [ ("firstCollectionTuple", component 3 9) + , ("secondCollectionTuple", component 5 10) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "ownedCollectionTupleLibrary" + mapM_ (\fragment -> assertBool ("Expected collection-tuple library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "([3, 4, 5, 9], {4, 5, 6, 9})" + , "([5, 6, 7, 10], {6, 7, 8, 10})" + ] + +-- | Exercise sequence and finite-set operations over recursively nested, +-- by-value tuple elements and return both descriptors through an owned tuple. +tupleValuedCollections :: Assertion +tupleValuedCollections = withSystemTempDirectory "sbv-tuple-valued-collections" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 4] + values <- cgInput "values" :: SBVCodeGen (SList (Word16, Word8)) + members <- cgInput "members" :: SBVCodeGen (SSet (Word16, Word8)) + let extra = tuple (literal 9 :: SWord16, literal 10 :: SWord8) + joined = values SL.++ SL.singleton extra + inserted = SS.insert extra members + cgOutput "listSameObject" (values .=== values) + cgOutput "containsExtra" (extra `SS.member` inserted) + cgOutput "joined" joined + cgOutput "inserted" inserted + cgReturn (tuple (joined, inserted)) + + stdoutText <- compileProgramAndRunGenerated dir "tupleValuedCollections" program + headerText <- readFile (dir "tupleValuedCollections.h") + mapM_ (\fragment -> assertBool ("Expected tuple-valued collection output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "listSameObject = 1" + , "containsExtra = 1" + , "joined =[(0x0001U, 2), (0x0002U, 3), (0x0003U, 4), (0x0009U, 10)]" + , "inserted ={(0x0004U, 5), (0x0005U, 6), (0x0006U, 7), (0x0009U, 10)}" + ] + assertBool "Expected tuple forward declarations before collection descriptors" + ("typedef struct SBVTuple_" `isInfixOf` headerText + && "const SBVTuple_" `isInfixOf` headerText) + +-- | Exercise guarded tuple-element list and set descriptors shared by +-- multiple generated library translation units. +tupleValuedCollectionLibrary :: Assertion +tupleValuedCollectionLibrary = withSystemTempDirectory "sbv-tuple-valued-collection-library" $ \dir -> do + let component :: Integer -> Word16 -> Word8 -> SBVCodeGen () + component seed first second = do + cgOverwriteFiles True + cgSetDriverValues [seed, seed + 3] + values <- cgInput "values" :: SBVCodeGen (SList (Word16, Word8)) + members <- cgInput "members" :: SBVCodeGen (SSet (Word16, Word8)) + let extra = tuple (literal first, literal second) + cgReturn (tuple (values SL.++ SL.singleton extra, SS.insert extra members)) + + (_, cfg, bundle) <- compileToCLib' "tupleValuedCollectionLibrary" + [ ("firstTupleCollections", component 1 9 10) + , ("secondTupleCollections", component 2 10 11) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "tupleValuedCollectionLibrary" + mapM_ (\fragment -> assertBool ("Expected tuple-valued collection library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "[(0x0001U, 2), (0x0002U, 3), (0x0003U, 4), (0x0009U, 10)]" + , "[(0x0002U, 3), (0x0003U, 4), (0x0004U, 5), (0x000aU, 11)]" + ] + +-- | Exercise deep ownership and structural equality for collection elements +-- that are tuples containing strings, exact values, and nested collections. +managedTupleValuedCollections :: Assertion +managedTupleValuedCollections = withSystemTempDirectory "sbv-managed-tuple-valued-collections" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 4, 7] + values <- cgInput "values" :: SBVCodeGen (SList (String, Integer)) + members <- cgInput "members" :: SBVCodeGen (SSet (String, Integer)) + nested <- cgInput "nested" :: SBVCodeGen (SList ([Integer], RCSet Rational)) + let extra = tuple (literal "extra" :: SString, literal 9 :: SInteger) + nestedExtra = tuple (literal ([9, 10] :: [Integer]), SS.singleton (literal 11 :: SRational)) + joined = values SL.++ SL.singleton extra + inserted = SS.insert extra members + nestedJoin = nested SL.++ SL.singleton nestedExtra + cgOutput "listSameObject" (values .=== values) + cgOutput "nestedSameObject" (nested .=== nested) + cgOutput "containsExtra" (extra `SS.member` inserted) + cgOutput "joined" joined + cgOutput "inserted" inserted + cgOutput "nestedJoin" nestedJoin + cgReturn (tuple (joined, tuple (inserted, nestedJoin))) + + stdoutText <- compileProgramAndRunGenerated dir "managedTupleValuedCollections" program + headerText <- readFile (dir "managedTupleValuedCollections.h") + mapM_ (\fragment -> assertBool ("Expected managed tuple-valued collection output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "listSameObject = 1" + , "nestedSameObject = 1" + , "containsExtra = 1" + , "joined =[(sbv1, 2), (sbv2, 3), (sbv3, 4), (extra, 9)]" + , "inserted ={(sbv4, 5), (sbv5, 6), (sbv6, 7), (extra, 9)}" + , "([9, 10], {11})" + ] + assertBool "Expected collection ownership to recurse through managed tuple elements" + ("sbv_tuple_owned_clone_" `isInfixOf` headerText + && "sbv_tuple_owned_release_" `isInfixOf` headerText + && "sbv_string_clone(source.field1)" `isInfixOf` headerText + && "sbv_list_clone_integer(source.field1)" `isInfixOf` headerText + && "sbv_set_clone_rational(source.field2)" `isInfixOf` headerText) + +-- | Exercise guarded ownership helpers for managed tuple-valued collections +-- shared by multiple generated library translation units. +managedTupleValuedCollectionLibrary :: Assertion +managedTupleValuedCollectionLibrary = withSystemTempDirectory "sbv-managed-tuple-valued-collection-library" $ \dir -> do + let component :: Integer -> String -> Integer -> SBVCodeGen () + component seed textValue extraValue = do + cgOverwriteFiles True + cgSetDriverValues [seed, seed + 3] + values <- cgInput "values" :: SBVCodeGen (SList (String, Integer)) + members <- cgInput "members" :: SBVCodeGen (SSet (String, Integer)) + let extra = tuple (literal textValue :: SString, literal extraValue :: SInteger) + cgReturn (tuple (values SL.++ SL.singleton extra, SS.insert extra members)) + + (_, cfg, bundle) <- compileToCLib' "managedTupleValuedCollectionLibrary" + [ ("firstManagedTupleCollections", component 1 "first" 9) + , ("secondManagedTupleCollections", component 2 "second" 10) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "managedTupleValuedCollectionLibrary" + mapM_ (\fragment -> assertBool ("Expected managed tuple-valued collection library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "[(sbv1, 2), (sbv2, 3), (sbv3, 4), (first, 9)]" + , "[(sbv2, 3), (sbv3, 4), (sbv4, 5), (second, 10)]" + ] + +-- | Exercise string-valued symbolic collections and ADTs with direct string, +-- list-of-string, and set-of-string fields through operations and owned ABI +-- results. +textAggregateCollections :: Assertion +textAggregateCollections = withSystemTempDirectory "sbv-text-aggregate-collections" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 4, 6] + values <- cgInput "values" :: SBVCodeGen (SList String) + members <- cgInput "members" :: SBVCodeGen (SSet String) + source <- cgInput "source" :: SBVCodeGen SCodeGenText + let extra = literal "extra" :: SString + sourceName = getCGText_1 source + sourceValues = getCGText_2 source + sourceMembers = getCGText_3 source + joined = values SL.++ SL.singleton extra + inserted = SS.insert extra members + result = sCGText + (sourceName SL.++ literal "!") + (sourceValues SL.++ SL.singleton extra) + (SS.insert extra sourceMembers) + cgOutput "sameValues" (values .=== values) + cgOutput "sameMembers" (members .=== members) + cgOutput "sameSource" (source .== source) + cgOutput "containsExtra" (extra `SS.member` inserted) + cgOutput "joined" joined + cgOutput "inserted" inserted + cgOutput "result" result + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "textAggregateCollections" program + headerText <- readFile (dir "textAggregateCollections.h") + mapM_ (\fragment -> assertBool ("Expected text-aggregate output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "sameValues = 1" + , "sameMembers = 1" + , "sameSource = 1" + , "containsExtra = 1" + , "joined =[sbv1, sbv2, sbv3, extra]" + , "inserted ={sbv4, sbv5, sbv6, extra}" + , "CGText(sbv6!, [sbv7, sbv8, sbv9, extra], {sbv8, sbv9, sbv10, extra})" + ] + assertBool "Expected ownership to recurse through direct and collection text fields" + ( "struct SBVList_string { const SString *data; size_t length; };" `isInfixOf` headerText + && "struct SBVSet_string { const SString *data; size_t length; bool is_complement; };" `isInfixOf` headerText + && "sbv_string_clone(source.payload.constructor1.field1)" `isInfixOf` headerText + && "sbv_string_release(&value->payload.constructor1.field1)" `isInfixOf` headerText + && "sbv_list_clone_string(source.payload.constructor1.field2)" `isInfixOf` headerText + && "sbv_set_clone_string(source.payload.constructor1.field3)" `isInfixOf` headerText + ) + +-- | Exercise independently owned text-containing ADT results emitted by +-- multiple generated library translation units. +textAggregateLibrary :: Assertion +textAggregateLibrary = withSystemTempDirectory "sbv-text-aggregate-library" $ \dir -> do + let component :: Integer -> SBVCodeGen () + component seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen SCodeGenText + cgReturn source + + (_, cfg, bundle) <- compileToCLib' "textAggregateLibrary" + [ ("firstTextAggregate", component 2) + , ("secondTextAggregate", component 4) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "textAggregateLibrary" + mapM_ (\fragment -> assertBool ("Expected text-aggregate library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGText(sbv2, [sbv3, sbv4, sbv5], {sbv4, sbv5, sbv6})" + , "CGText(sbv4, [sbv5, sbv6, sbv7], {sbv6, sbv7, sbv8})" + ] + +-- | Exercise every direct list/set nesting pair admitted by SBV through +-- symbolic operations, printing, and recursively owned tuple outputs and +-- returns. Sets of sets are not SBV values because 'RCSet' has no 'Ord' +-- instance. +directlyNestedCollections :: Assertion +directlyNestedCollections = withSystemTempDirectory "sbv-directly-nested-collections" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 2, 4] + nestedLists <- cgInput "nestedLists" :: SBVCodeGen (SList [Word16]) + listOfSets <- cgInput "listOfSets" :: SBVCodeGen (SList (RCSet Word16)) + setOfLists <- cgInput "setOfLists" :: SBVCodeGen (SSet [Word16]) + let extraList = literal ([90, 91] :: [Word16]) + extraSet = SS.fromList [92, 93] :: SSet Word16 + joinedLists = nestedLists SL.++ SL.singleton extraList + joinedSets = listOfSets SL.++ SL.singleton extraSet + insertedLists = SS.insert extraList setOfLists + result = tuple (joinedLists, tuple (joinedSets, insertedLists)) + cgOutput "sameNestedLists" (nestedLists .=== nestedLists) + cgOutput "sameListOfSets" (listOfSets .=== listOfSets) + cgOutput "sameSetOfLists" (setOfLists .=== setOfLists) + cgOutput "joinedLists" joinedLists + cgOutput "joinedSets" joinedSets + cgOutput "insertedLists" insertedLists + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "directlyNestedCollections" program + headerText <- readFile (dir "directlyNestedCollections.h") + mapM_ (\fragment -> assertBool ("Expected directly nested collection output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "sameNestedLists = 1" + , "sameListOfSets = 1" + , "sameSetOfLists = 1" + , "[0x005aU, 0x005bU]" + , "{0x005cU, 0x005dU}" + ] + assertBool "Expected mutually forward-declared descriptors and recursive ownership helpers" + ( "typedef struct SBVList_u16 SBVList_u16;" `isInfixOf` headerText + && "typedef struct SBVSet_u16 SBVSet_u16;" `isInfixOf` headerText + && "struct SBVList_set_3_u16 { const SBVSet_u16 *data; size_t length; };" `isInfixOf` headerText + && "struct SBVSet_list_3_u16 { const SBVList_u16 *data; size_t length; bool is_complement; };" `isInfixOf` headerText + && "sbv_list_clone_list_3_u16" `isInfixOf` headerText + && "sbv_list_clone_set_3_u16" `isInfixOf` headerText + && "sbv_set_clone_list_3_u16" `isInfixOf` headerText + ) + +-- | Exercise independently owned list-of-set results emitted by multiple +-- generated library translation units. +directlyNestedCollectionLibrary :: Assertion +directlyNestedCollectionLibrary = withSystemTempDirectory "sbv-directly-nested-collection-library" $ \dir -> do + let component :: Integer -> Word16 -> SBVCodeGen () + component seed extra = do + cgOverwriteFiles True + cgSetDriverValues [seed] + values <- cgInput "values" :: SBVCodeGen (SList (RCSet Word16)) + cgReturn (values SL.++ SL.singleton (SS.fromList [extra, extra + 1])) + + (_, cfg, bundle) <- compileToCLib' "directlyNestedCollectionLibrary" + [ ("firstNestedCollection", component 2 90) + , ("secondNestedCollection", component 4 92) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "directlyNestedCollectionLibrary" + mapM_ (\fragment -> assertBool ("Expected nested-collection library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "{0x005aU, 0x005bU}" + , "{0x005cU, 0x005dU}" + ] + +-- | Exercise lists and sets whose elements are managed or recursive ADTs, +-- including deep ownership and both symbolic equality modes. +adtValuedCollections :: Assertion +adtValuedCollections = withSystemTempDirectory "sbv-adt-valued-collections" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 2, 4] + values <- cgInput "values" :: SBVCodeGen (SList CodeGenCollections) + trees <- cgInput "trees" :: SBVCodeGen (SSet CodeGenTree) + colors <- cgInput "colors" :: SBVCodeGen (SSet CodeGenEnum) + let extraValue = sCGCollections + (literal ([9, 10] :: [Integer])) + (SS.singleton (literal 11 :: SRational)) + (tuple (literal ([12] :: [Integer]), SS.singleton (literal 13 :: SRational))) + extraTree = sCGLeaf 99 + joined = values SL.++ SL.singleton extraValue + inserted = SS.insert extraTree trees + colored = SS.insert sCGBlue colors + allColors = SS.fromList [CGRed, CGGreen, CGBlue] + cgOutput "sameValues" (values .=== values) + cgOutput "containsExtraTree" (extraTree `SS.member` inserted) + cgOutput "containsBlue" (sCGBlue `SS.member` colored) + cgOutput "sameColorUniverse" (allColors .== (SS.full :: SSet CodeGenEnum)) + cgOutput "joined" joined + cgOutput "inserted" inserted + cgOutput "colored" colored + cgReturn (tuple (joined, inserted)) + + stdoutText <- compileProgramAndRunGenerated dir "adtValuedCollections" program + headerText <- readFile (dir "adtValuedCollections.h") + sourceText <- readFile (dir "adtValuedCollections.c") + mapM_ (\fragment -> assertBool ("Expected ADT-valued collection output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "sameValues = 1" + , "containsExtraTree = 1" + , "containsBlue = 1" + , "sameColorUniverse = 1" + , "CGCollections([9, 10], {11}, ([12], {13}))" + , "CGLeaf(99)" + , "CGBlue" + ] + assertBool "Expected ADT forward declarations before collection descriptors" + ("typedef struct SBVADT_CodeGenCollections SBVADT_CodeGenCollections;" `isInfixOf` headerText + && "const SBVADT_CodeGenCollections *data" `isInfixOf` headerText) + assertBool "Expected collection ownership and equality to dispatch through ADT helpers" + ("sbv_adt_owned_clone_SBVADT_CodeGenCollections" `isInfixOf` headerText + && "sbv_adt_owned_release_SBVADT_CodeGenTree" `isInfixOf` headerText + && "sbv_adt_object_equal_SBVADT_CodeGenCollections" `isInfixOf` sourceText + && "sbv_adt_equal_SBVADT_CodeGenTree" `isInfixOf` sourceText) + +-- | Exercise guarded recursive-ADT collection helpers shared by multiple +-- generated library translation units. +adtValuedCollectionLibrary :: Assertion +adtValuedCollectionLibrary = withSystemTempDirectory "sbv-adt-valued-collection-library" $ \dir -> do + let component :: Integer -> Word8 -> SBVCodeGen () + component seed extraValue = do + cgOverwriteFiles True + cgSetDriverValues [seed] + values <- cgInput "values" :: SBVCodeGen (SList CodeGenTree) + cgReturn (values SL.++ SL.singleton (sCGLeaf (literal extraValue))) + + (_, cfg, bundle) <- compileToCLib' "adtValuedCollectionLibrary" + [ ("firstADTCollections", component 1 98) + , ("secondADTCollections", component 2 99) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "adtValuedCollectionLibrary" + mapM_ (\fragment -> assertBool ("Expected ADT-valued collection library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGLeaf(98)" + , "CGLeaf(99)" + ] + +-- | Exercise parameter substitution, constructors, tests, accessors, +-- structural equality, constants, tables, public outputs, and returns. +nonRecursiveADTs :: Assertion +nonRecursiveADTs = withSystemTempDirectory "sbv-non-recursive-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2, 1, 0, 1] + source <- cgInput "source" :: SBVCodeGen (SCodeGenADT Word8) + choose <- cgInput "choose" :: SBVCodeGen SBool + selector <- cgInput "selector" :: SBVCodeGen SWord8 + color <- cgInput "color" :: SBVCodeGen SCodeGenEnum + let first = getCGPair_1 source + second = getCGPair_2 source + constructed = ite choose (sCGPair (first + 1) (second + 1)) (sCGOne first) + constant = literal (CGPair 9 10) + selected = select [source, constructed, constant] sCGEmpty selector + cgOutput "sourceCopy" source + cgOutput "constructed" constructed + cgOutput "constant" constant + cgOutput "isPair" (isCGPair source) + cgOutput "sameValue" (source .== literal (CGPair 2 3)) + cgOutput "colorBeforeBlue" (color .< sCGBlue) + cgReturn selected + + stdoutText <- compileProgramAndRunGenerated dir "nonRecursiveADTs" program + mapM_ (\fragment -> assertBool ("Expected ADT output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "CGPair(2, 0x0003U)" + , "constructed =CGPair(3, 0x0004U)" + , "constant =CGPair(9, 0x000aU)" + , "isPair = 1" + , "sameValue = 1" + , "colorBeforeBlue = 1" + ] + +-- | Exercise an acyclic parameterized 'KApp' reference through construction, +-- access, structural equality against a literal, and the public return ABI. +nestedADTs :: Assertion +nestedADTs = withSystemTempDirectory "sbv-nested-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + source <- cgInput "source" :: SBVCodeGen (SCodeGenEnvelope Word8) + let inner = getCGEnvelope_1 source + result = sCGEnvelope (sCGOne (getCGOne_1 inner + 3)) + cgOutput "sameValue" (source .== literal (CGEnvelope (CGOne 1))) + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "nestedADTs" program + headerText <- readFile (dir "nestedADTs.h") + mapM_ (\fragment -> assertBool ("Expected nested ADT output to contain " ++ fragment + ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGEnvelope(CGOne(4))" + , "sameValue = 1" + ] + assertBool "Expected the concrete Word8 inner ADT declaration" + ("SBVADT_CodeGenADT_2_u8" `isInfixOf` headerText) + assertBool "Unexpected placeholder Integer ADT declaration" + (not ("SBVADT_CodeGenADT_7_integer" `isInfixOf` headerText)) + +-- | Exercise guarded ADT declarations shared by multiple generated library +-- translation units and returned through the public by-value ABI. +nonRecursiveADTLibrary :: Assertion +nonRecursiveADTLibrary = withSystemTempDirectory "sbv-non-recursive-adt-library" $ \dir -> do + let component :: Word8 -> SBVCodeGen () + component increment = do + cgOverwriteFiles True + cgSetDriverValues [1] + source <- cgInput "source" :: SBVCodeGen (SCodeGenADT Word8) + cgReturn (ite (isCGOne source) (sCGOne (getCGOne_1 source + literal increment)) sCGEmpty) + + (_, cfg, bundle) <- compileToCLib' "nonRecursiveADTLibrary" + [ ("incrementADT", component 1) + , ("addTwoADT", component 2) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "nonRecursiveADTLibrary" + mapM_ (\fragment -> assertBool ("Expected ADT library output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "CGOne(2)" + , "CGOne(3)" + ] + +-- | Exercise direct and tuple-nested exact-element collections through ADT +-- construction, access, equality, outputs, and an independently owned return. +collectionADTs :: Assertion +collectionADTs = withSystemTempDirectory "sbv-collection-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + source <- cgInput "source" :: SBVCodeGen SCodeGenCollections + let values = getCGCollections_1 source + members = getCGCollections_2 source + nested = getCGCollections_3 source + (nestedValues, nestedSet) = untuple nested + result = sCGCollections + (values SL.++ literal ([4] :: [Integer])) + (SS.insert 5 members) + (tuple (nestedValues SL.++ literal ([6] :: [Integer]), SS.insert 7 nestedSet)) + cgOutput "sourceCopy" source + cgOutput "sameValue" (source .== source) + cgOutput "result" result + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "collectionADTs" program + headerText <- readFile (dir "collectionADTs.h") + mapM_ (\fragment -> assertBool ("Expected collection ADT output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ ") =CGCollections([1, 2, 3, 4], {2, 3, 4, 5}, ([3, 4, 5, 6], {4, 5, 6, 7}))" + , "sourceCopy =CGCollections([1, 2, 3], {2, 3, 4}, ([3, 4, 5], {4, 5, 6}))" + , "sameValue = 1" + , "result =CGCollections([1, 2, 3, 4], {2, 3, 4, 5}, ([3, 4, 5, 6], {4, 5, 6, 7}))" + ] + assertBool "Expected direct and tuple-nested collection ownership in ADT helpers" + ("sbv_list_clone_integer(source.payload.constructor2.field1)" `isInfixOf` headerText + && "sbv_set_release_rational(&value->payload.constructor2.field2)" `isInfixOf` headerText + && "sbv_tuple_owned_set_" `isInfixOf` headerText) + +-- | Exercise recursive pointer ownership whose terminal constructor contains +-- exact-element list and set fields, including recursive structural equality. +recursiveCollectionADTs :: Assertion +recursiveCollectionADTs = withSystemTempDirectory "sbv-recursive-collection-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + source <- cgInput "source" :: SBVCodeGen SCodeGenCollectionTree + cgOutput "sameTree" (source .== source) + cgOutput "treeCopy" source + cgReturn source + + stdoutText <- compileProgramAndRunGenerated dir "recursiveCollectionADTs" program + sourceText <- readFile (dir "recursiveCollectionADTs.c") + mapM_ (\fragment -> assertBool ("Expected recursive collection ADT output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGCollectionBranch(CGCollectionBranch(" + , "CGCollectionLeaf([1, 2, 3], {2, 3, 4})" + , "sameTree = 1" + ] + assertBool "Expected private recursive equality to use collection semantics after their runtimes" + ("sbv_list_integer_equal" `isInfixOf` sourceText + && "sbv_set_rational_equal" `isInfixOf` sourceText) + +-- | Exercise guarded collection-owning ADT helpers shared by multiple +-- generated library translation units. +collectionADTLibrary :: Assertion +collectionADTLibrary = withSystemTempDirectory "sbv-collection-adt-library" $ \dir -> do + let component :: Integer -> SBVCodeGen () + component seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen SCodeGenNativeCollections + cgReturn source + + (_, cfg, bundle) <- compileToCLib' "collectionADTLibrary" + [ ("firstCollectionADT", component 1) + , ("secondCollectionADT", component 3) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "collectionADTLibrary" + mapM_ (\fragment -> assertBool ("Expected collection ADT library output to contain " ++ show fragment ++ ", received:\n" ++ stdoutText) + (fragment `isInfixOf` stdoutText)) + [ "CGNativeCollections([0x0001U, 0x0002U, 0x0003U], {0x0002U, 0x0003U, 0x0004U})" + , "CGNativeCollections([0x0003U, 0x0004U, 0x0005U], {0x0004U, 0x0005U, 0x0006U})" + ] + +-- | Exercise structural equality for ADTs instantiated with wide bit-vectors, +-- arbitrary floating-point formats, and native floating-point values. +adtAggregateEquality :: Assertion +adtAggregateEquality = withSystemTempDirectory "sbv-adt-aggregate-equality" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1, 1, 1, 1, 9, 9] + wideLeft <- cgInput "wideLeft" :: SBVCodeGen (SCodeGenADT (WordN 673)) + wideRight <- cgInput "wideRight" :: SBVCodeGen (SCodeGenADT (WordN 673)) + floatLeft <- cgInput "floatLeft" :: SBVCodeGen (SCodeGenADT Float) + floatRight <- cgInput "floatRight" :: SBVCodeGen (SCodeGenADT Float) + integerLeft <- cgInput "integerLeft" :: SBVCodeGen SInteger + integerRight <- cgInput "integerRight" :: SBVCodeGen SInteger + cgOutput "wideEqual" (wideLeft .== wideRight) + cgOutput "exactEqual" (sCGOne integerLeft .== sCGOne integerRight) + cgReturn (floatLeft .=== floatRight) + + stdoutText <- compileProgramAndRunGenerated dir "adtAggregateEquality" program + mapM_ (\fragment -> assertBool ("Expected aggregate equality output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText)) + [ "= 1" + , "wideEqual = 1" + , "exactEqual = 1" + ] + + (_, _, arbitraryFPBundle) <- compileToC' "adtArbitraryFPEquality" $ do + left <- cgInput "left" :: SBVCodeGen (SCodeGenADT (FloatingPoint 7 19)) + right <- cgInput "right" :: SBVCodeGen (SCodeGenADT (FloatingPoint 7 19)) + cgReturn (left .=== right) + let generated = show arbitraryFPBundle + assertBool "Expected a concrete arbitrary-float ADT declaration" ("SBVADT_CodeGenADT_9_fp_e7_s19" `isInfixOf` generated) + assertBool "Expected arbitrary-float object equality in the ADT comparison" ("sbv_fp_e7_s19_obj_eq" `isInfixOf` generated) + +-- | Exercise a recursive input layout, including a pointer-backed accessor and +-- a bounded generated-driver value. +recursiveADTs :: Assertion +recursiveADTs = withSystemTempDirectory "sbv-recursive-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + value <- cgInput "value" :: SBVCodeGen SCodeGenTree + let left = getCGNode_1 value + result = sCGNode left (sCGLeaf 99) + cgOutput "isNode" (isCGNode value) + cgOutput "sameTree" (value .== value) + cgOutput "sameTreeObject" (value .=== value) + cgOutput "treeCopy" value + cgReturn result + + stdoutText <- compileProgramAndRunGenerated dir "recursiveADTs" program + headerText <- readFile (dir "recursiveADTs.h") + sourceText <- readFile (dir "recursiveADTs.c") + assertBool ("Expected the recursive driver to select a node, received:\n" ++ stdoutText) + ("isNode = 1" `isInfixOf` stdoutText) + assertBool ("Expected recursive structural equality, received:\n" ++ stdoutText) + ("sameTree = 1" `isInfixOf` stdoutText) + assertBool ("Expected recursive strong equality, received:\n" ++ stdoutText) + ("sameTreeObject = 1" `isInfixOf` stdoutText) + assertBool ("Expected a deeply owned recursive result, received:\n" ++ stdoutText) + ("CGLeaf(99)" `isInfixOf` stdoutText) + assertBool "Expected a forward-declared recursive ADT" + ("typedef struct SBVADT_CodeGenTree SBVADT_CodeGenTree;" `isInfixOf` headerText) + assertBool "Expected recursive fields to use pointers" + ("SBVADT_CodeGenTree * field1;" `isInfixOf` headerText) + assertBool "Expected recursive equality to reject null child pointers" + ("== NULL) abort();" `isInfixOf` sourceText) + +-- | Exercise transitive ownership when an acyclic ADT embeds a recursive ADT +-- by value. +wrappedRecursiveADTs :: Assertion +wrappedRecursiveADTs = withSystemTempDirectory "sbv-wrapped-recursive-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + value <- cgInput "value" :: SBVCodeGen SCodeGenForest + cgOutput "sameForest" (value .== value) + cgReturn value + + stdoutText <- compileProgramAndRunGenerated dir "wrappedRecursiveADTs" program + headerText <- readFile (dir "wrappedRecursiveADTs.h") + assertBool ("Expected the wrapped recursive value to survive an owned return, received:\n" ++ stdoutText) + ("CGForest(CGNode" `isInfixOf` stdoutText) + assertBool ("Expected wrapped recursive structural equality, received:\n" ++ stdoutText) + ("sameForest = 1" `isInfixOf` stdoutText) + assertBool "Expected an acyclic wrapper field to remain embedded by value" + ("SBVADT_CodeGenTree field1;" `isInfixOf` headerText) + +-- | Exercise mutually recursive layouts, bounded samples, equality, printing, +-- accessors, and deep-owned outputs and returns. +mutuallyRecursiveADTs :: Assertion +mutuallyRecursiveADTs = withSystemTempDirectory "sbv-mutually-recursive-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + value <- cgInput "value" :: SBVCodeGen SCodeGenOdd + cgOutput "sameValue" (value .== value) + cgOutput "valueCopy" value + cgReturn (getCGOddStep_1 value) + + stdoutText <- compileProgramAndRunGenerated dir "mutuallyRecursiveADTs" program + headerText <- readFile (dir "mutuallyRecursiveADTs.h") + assertBool ("Expected mutually recursive structural equality, received:\n" ++ stdoutText) + ("sameValue = 1" `isInfixOf` stdoutText) + assertBool ("Expected mutually recursive values to print, received:\n" ++ stdoutText) + ("CGOddStep(CGEven" `isInfixOf` stdoutText) + assertBool "Expected the odd-to-even edge to use a pointer" + ("SBVADT_CodeGenEven * field1;" `isInfixOf` headerText) + assertBool "Expected the even-to-odd edge to use a pointer" + ("SBVADT_CodeGenOdd * field1;" `isInfixOf` headerText) + +-- | Exercise guarded recursive declarations and ownership helpers shared by +-- multiple generated library components. +recursiveADTLibrary :: Assertion +recursiveADTLibrary = withSystemTempDirectory "sbv-recursive-adt-library" $ \dir -> do + let component :: Integer -> SBVCodeGen () + component seed = do + cgOverwriteFiles True + cgSetDriverValues [seed] + value <- cgInput "value" :: SBVCodeGen SCodeGenTree + cgReturn value + + (_, cfg, bundle) <- compileToCLib' "recursiveADTLibrary" + [ ("copyRecursiveLeaf", component 0) + , ("copyRecursiveTree", component 1) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + stdoutText <- compileAndRunGenerated dir "recursiveADTLibrary" + assertBool ("Expected recursive library results, received:\n" ++ stdoutText) + ("CGLeaf" `isInfixOf` stdoutText && "CGNode" `isInfixOf` stdoutText) + +-- | Check that bounded driver generation rejects recursive ADTs without any +-- finite constructor path. +uninhabitedRecursiveADT :: Assertion +uninhabitedRecursiveADT = do + recursiveResult <- try (do + (_, _, bundle) <- compileToC' "uninhabitedRecursiveADT" $ do + value <- cgInput "value" :: SBVCodeGen SCodeGenLoop + cgReturn (isCGLoop value) + evaluate (length (show bundle))) :: IO (Either ErrorCall Int) + case recursiveResult of + Left exception -> assertBool ("Expected a finite-constructor diagnostic, received:\n" ++ displayException exception) + ("has no finite constructor" `isInfixOf` displayException exception) + Right _ -> assertBool "Expected driver generation to reject an uninhabited recursive ADT" False + +-- | Generate, compile, and execute one standalone C program quietly in its +-- temporary directory. +compileProgramAndRunGenerated :: FilePath -> String -> SBVCodeGen () -> IO String +compileProgramAndRunGenerated dir executableName program = do + (_, cfg, bundle) <- compileToC' executableName (program >> cgOverwriteFiles True) + renderCgPgmBundle (Just dir) (cfg, bundle) + compileAndRunGenerated dir executableName + +-- | Extract linker-option lists from the Makefile entries in a generated C +-- bundle. +linkerFlags :: CgPgmBundle -> [[String]] +linkerFlags (CgPgmBundle _ files) = [flags | (_, (CgMakefile flags, _)) <- files] diff --git a/SBVTestSuite/TestSuite/CodeGeneration/ExactNumbers.hs b/SBVTestSuite/TestSuite/CodeGeneration/ExactNumbers.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/ExactNumbers.hs @@ -0,0 +1,667 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.ExactNumbers +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Compile-and-run tests for GMP-backed exact integer and real C lowering. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.ExactNumbers (tests) where + +import Data.List (isInfixOf) +import Numeric (showHex) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Internals +import Data.SBV.Tuple (tuple, untuple) +import qualified Data.SBV.List as SL + +import Utils.SBVTestFramework +import Utils.CCodeGen (generatedMakeOptions) + +-- | An exact-number ADT nested inside 'ExactAggregate'. +data ExactLeaf = ExactLeaf Integer AlgReal deriving Show + +-- | A sum type combining nested ADT and tuple ownership. +data ExactAggregate = ExactAbsent + | ExactAggregate ExactLeaf (Integer, AlgReal) + deriving Show + +-- | A recursive exact-number ADT used to exercise combined heap and GMP +-- ownership. +data ExactChain = ExactEnd Integer | ExactNext Integer ExactChain deriving Show + +-- | Generate symbolic interfaces for the exact-number ADTs. +mkSymbolic [''ExactLeaf, ''ExactAggregate, ''ExactChain] + +-- | GMP-backed exact-number C backend tests. +tests :: TestTree +tests = testGroup "CodeGeneration.ExactNumbers" + [ testCase "compile and execute unbounded arithmetic" exactIntegerArithmetic + , testCase "compile and execute Euclidean division" exactIntegerDivision + , testCase "preserve zero-divisor semantics across integer representations" integerZeroDivision + , testCase "count exact decimal text without its terminator" exactDecimalText + , testCase "compile and execute exact divisibility" exactIntegerDivisibility + , testCase "compile and execute exact integer exponentiation" exactIntegerExponentiation + , testCase "compile and execute native conversions" exactNativeConversions + , testCase "reduce exact integers into native bit patterns" exactNativeBitPatterns + , testCase "floor exact reals into mapped integers" exactRealMappedIntegers + , testCase "compile and execute wide conversions" exactWideConversions + , testCase "compile and execute wide real conversions" exactWideRealConversions + , testCase "compile and execute rational arithmetic" exactRealArithmetic + , testCase "compile and execute exact table lookup" exactTableLookup + , testCase "do not alias narrowed unchecked exact table indices" uncheckedExactTableIndices + , testCase "compile and execute exact array keys and values" exactArray + , testCase "compile and execute an exact callback-backed array" exactArrayInput + , testCase "compile and execute fixed exact input arrays" exactFixedInputArrays + , testCase "compile and execute an exact structured lambda array" exactLambdaArray + , testCase "compile and execute an exact structured lambda table" exactLambdaTable + , testCase "return and output owned exact arrays" ownedExactArrays + , testCase "use exact fields inside tuples" exactTupleFields + , testCase "use owned exact tuples across the public ABI" ownedExactTuples + , testCase "use owned exact ADTs across the public ABI" ownedExactADTs + , testCase "use owned recursive exact ADTs across the public ABI" ownedRecursiveExactADTs + , testCase "compile and execute an exact-number library" exactNumberLibrary + ] + +-- | Exercise arithmetic well beyond any native or wide fixed-width integer. +exactIntegerArithmetic :: Assertion +exactIntegerArithmetic = withSystemTempDirectory "sbv-exact-integer" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [x, y] + a <- cgInput "a" :: SBVCodeGen SInteger + b <- cgInput "b" :: SBVCodeGen SInteger + let added = a + b + result = abs (added * (a - b)) + bitResult = (added `xor` a) .&. complement b + selected = ite (a .> b) result (negate result) + cgOutput "added" added + cgOutput "bitResult" bitResult + cgReturn selected + x = 2 ^ (700 :: Int) + 123456789 + y = negate (2 ^ (511 :: Int)) + 987654321 + expected = abs ((x + y) * (x - y)) + expectedBit = ((x + y) `xor` x) .&. complement y + compileAndRunGMP dir "exactIntegerArithmetic" program [show expected, show (x + y), show expectedBit] + +-- | Huge and negative integers cannot alias valid entries during conversion +-- to a machine index, even with optional runtime checks disabled. +uncheckedExactTableIndices :: Assertion +uncheckedExactTableIndices = mapM_ check [-1, 2 ^ (128 :: Int) + 1] + where check index = withSystemTempDirectory "sbv-unchecked-exact-index" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs False + cgSetDriverValues [index] + input <- cgInput "input" :: SBVCodeGen SInteger + cgReturn (select [10, 11, 12] 99 input :: SWord8) + compileAndRunGMP dir "uncheckedExactIndex" program ["= 99"] + +-- | Exercise SMT-Lib Euclidean quotient and nonnegative remainder semantics. +exactIntegerDivision :: Assertion +exactIntegerDivision = withSystemTempDirectory "sbv-exact-integer-division" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [-20, -6] + a <- cgInput "a" :: SBVCodeGen SInteger + b <- cgInput "b" :: SBVCodeGen SInteger + let quotient = a `sEDiv` b + remainder = a `sEMod` b + cgOutput "quotient" quotient + cgOutput "remainder" remainder + cgReturn (quotient .== 4 .&& remainder .== 4) + compileAndRunGMP dir "exactIntegerDivision" program ["= 1", "quotient =4", "remainder =4"] + +-- | Raw Euclidean division uses SBV's concrete zero-divisor choice, whereas +-- public truncated quotient explicitly totalizes the same input to zero. +integerZeroDivision :: Assertion +integerZeroDivision = mapM_ check [Nothing, Just 8, Just 16, Just 32, Just 64] + where check mapping = withSystemTempDirectory "sbv-integer-zero-division" $ \dir -> do + let program = do + cgOverwriteFiles True + maybe (pure ()) cgIntegerSize mapping + cgSetDriverValues [7, 0] + a <- cgInput "a" :: SBVCodeGen SInteger + b <- cgInput "b" :: SBVCodeGen SInteger + cgReturn $ a `sEDiv` b .== a .&& a `sEMod` b .== a .&& a `sQuot` b .== 0 + (_, generatedConfig, bundle) <- compileToC' "integerZeroDivision" program + renderCgPgmBundle (Just dir) (generatedConfig, bundle) + makeOptions <- generatedMakeOptions dir + (buildExit, _, buildError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual buildError ExitSuccess buildExit + (runExit, outputText, runError) <- readProcessWithExitCode (dir "integerZeroDivision_driver") [] "" + assertEqual runError ExitSuccess runExit + assertBool outputText ("= 1" `isInfixOf` outputText) + +-- | GMP's decimal allocation bound can exceed the actual digit count by one. +exactDecimalText :: Assertion +exactDecimalText = mapM_ check [0, 1, 7, 8, 9, 10, 99, 100, 999, 1000, 2 ^ (257 :: Int)] + where check value = withSystemTempDirectory "sbv-exact-decimal-text" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [value] + input <- cgInput "input" :: SBVCodeGen SInteger + let rendered = SL.natToStr input + cgReturn $ rendered .== literal (show value) .&& SL.length rendered .== literal (toInteger (length (show value))) + compileAndRunGMP dir "exactDecimalText" program ["= 1"] + +-- | Exercise exact divisibility with a divisor too large for any native C +-- integer, positive and negative multiples, and a neighboring non-multiple. +exactIntegerDivisibility :: Assertion +exactIntegerDivisibility = withSystemTempDirectory "sbv-exact-integer-divisibility" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [divisor * 7, negate (divisor * 3), divisor * 5 + 1] + positive <- cgInput "positive" :: SBVCodeGen SInteger + negative <- cgInput "negative" :: SBVCodeGen SInteger + nonMultiple <- cgInput "nonMultiple" :: SBVCodeGen SInteger + cgReturn $ sDivides divisor positive + .&& sDivides divisor negative + .&& sNot (sDivides divisor nonMultiple) + divisor = 2 ^ (257 :: Int) + 93 + compileAndRunGMP dir "exactIntegerDivisibility" program ["= 1"] + +-- | Exercise symbolic exact integer exponentiation, including zero and +-- negative exponents with the SMT-LIB integer-power semantics. +exactIntegerExponentiation :: Assertion +exactIntegerExponentiation = withSystemTempDirectory "sbv-exact-integer-exponentiation" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2, 200, -1, -3, 0, 0] + base <- cgInput "base" :: SBVCodeGen SInteger + exponentValue <- cgInput "exponent" :: SBVCodeGen SInteger + negativeUnit <- cgInput "negativeUnit" :: SBVCodeGen SInteger + negativeExponent <- cgInput "negativeExponent" :: SBVCodeGen SInteger + zeroBase <- cgInput "zeroBase" :: SBVCodeGen SInteger + zeroExponent <- cgInput "zeroExponent" :: SBVCodeGen SInteger + cgReturn $ base .** exponentValue .== 2 ^ (200 :: Int) + .&& negativeUnit .** negativeExponent .== -1 + .&& negativeUnit .** (negativeExponent + 1) .== 1 + .&& base .** negativeExponent .== 0 + .&& zeroBase .** negativeExponent .== 0 + .&& zeroBase .** zeroExponent .== 1 + compileAndRunGMP dir "exactIntegerExponentiation" program ["= 1"] + +-- | Exercise exact conversions to and from native signed and unsigned words. +exactNativeConversions :: Assertion +exactNativeConversions = withSystemTempDirectory "sbv-exact-native-conversions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [maxWord, minInt] + unsignedValue <- cgInput "unsignedValue" :: SBVCodeGen SWord64 + signedValue <- cgInput "signedValue" :: SBVCodeGen SInt64 + let exactUnsigned = sFromIntegral unsignedValue :: SInteger + exactSigned = sFromIntegral signedValue :: SInteger + wrapped = sFromIntegral (exactUnsigned + 1) :: SWord64 + asReal = sFromIntegral signedValue :: SReal + cgOutput "wrapped" wrapped + cgOutput "asReal" asReal + cgReturn (exactUnsigned + exactSigned) + maxWord = 2 ^ (64 :: Int) - 1 + minInt = negate (2 ^ (63 :: Int)) + expected = 2 ^ (63 :: Int) - 1 :: Integer + compileAndRunGMP dir "exactNativeConversions" program [show expected, "wrapped = 0x0000000000000000ULL", "asReal =-9223372036854775808"] + +-- | Narrowing an exact integer preserves low bits, including the one-bit +-- representation. Signed results interpret those bits as two's complement. +exactNativeBitPatterns :: Assertion +exactNativeBitPatterns = mapM_ check [2, 3, -2, -129, 2 ^ (180 :: Int) + 32768] + where check sample = withSystemTempDirectory "sbv-exact-native-bits" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [sample] + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn $ sAnd + [ (sFromIntegral value :: SWord 1) .== fromInteger sample + , (sFromIntegral value :: SInt8) .== fromInteger sample + , (sFromIntegral value :: SInt16) .== fromInteger sample + , (sFromIntegral value :: SInt32) .== fromInteger sample + , (sFromIntegral value :: SInt64) .== fromInteger sample + ] + compileAndRunGMP dir "exactNativeBits" program ["= 1"] + +-- | Flooring a GMP real into a mapped integer first rounds exactly, then +-- reduces modulo the requested width, even far outside the native range. +exactRealMappedIntegers :: Assertion +exactRealMappedIntegers = mapM_ check [(width, sample) | width <- [8, 16, 32, 64], sample <- [-huge, huge]] + where huge = 2 ^ (180 :: Int) + 5 + + check (width, sample) = withSystemTempDirectory "sbv-exact-real-mapped-integer" $ \dir -> do + let program = do + cgOverwriteFiles True + cgIntegerSize width + cgSetDriverValues [sample] + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (sRealToSIntegerFloor (value / 3) .== fromInteger (sample `div` 3)) + compileAndRunGMP dir "exactRealMappedInteger" program ["= 1"] + +-- | Exercise signed and unsigned conversions between GMP integers and +-- limb-backed bit-vectors in both directions. +exactWideConversions :: Assertion +exactWideConversions = withSystemTempDirectory "sbv-exact-wide-conversions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [unsignedSample, signedSample, exactSample] + unsignedValue <- cgInput "unsignedValue" :: SBVCodeGen (SWord 673) + signedValue <- cgInput "signedValue" :: SBVCodeGen (SInt 673) + exactValue <- cgInput "exactValue" :: SBVCodeGen SInteger + let exactUnsigned = sFromIntegral unsignedValue :: SInteger + exactSigned = sFromIntegral signedValue :: SInteger + unsignedRoundTrip = (sFromIntegral exactUnsigned :: SWord 673) .== unsignedValue + signedRoundTrip = (sFromIntegral exactSigned :: SInt 673) .== signedValue + wrappedUnsigned = sFromIntegral exactValue :: SWord 673 + wrappedSigned = sFromIntegral exactValue :: SInt 673 + cgOutput "unsignedRoundTrip" unsignedRoundTrip + cgOutput "signedRoundTrip" signedRoundTrip + cgOutput "wrappedUnsigned" wrappedUnsigned + cgOutput "wrappedSigned" wrappedSigned + cgReturn (exactUnsigned + exactSigned) + unsignedSample = 2 ^ (672 :: Int) + 0x123456789abcdef + signedSample = negate (2 ^ (671 :: Int)) + 0xfedcba987654321 + exactSample = negate (2 ^ (700 :: Int)) + 0x112233445566778899 + expected = unsignedSample + signedSample + wrapped = exactSample `mod` 2 ^ (673 :: Int) + compileAndRunGMP dir "exactWideConversions" program + [ show expected + , "unsignedRoundTrip = 1" + , "signedRoundTrip = 1" + , "wrappedUnsigned =" ++ asHex 11 wrapped + , "wrappedSigned =" ++ asHex 11 wrapped + ] + +-- | Exercise exact conversion of signed and unsigned limb-backed values to +-- rational reals, followed by explicit floor and truncation back to wide +-- bit-vectors through 'SInteger'. +exactWideRealConversions :: Assertion +exactWideRealConversions = withSystemTempDirectory "sbv-exact-wide-real-conversions" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [unsignedSample, signedSample] + unsignedValue <- cgInput "unsignedValue" :: SBVCodeGen (SWord 673) + signedValue <- cgInput "signedValue" :: SBVCodeGen (SInt 673) + let unsignedReal = sFromIntegral unsignedValue :: SReal + signedReal = sFromIntegral signedValue :: SReal + fraction = signedReal / 3 + floorWide = sFromIntegral (sRealToSIntegerFloor fraction) :: SInt 673 + truncateWide = sFromIntegral (sRealToSIntegerTruncate fraction) :: SInt 673 + cgOutput "unsignedReal" unsignedReal + cgOutput "signedReal" signedReal + cgOutput "fraction" fraction + cgOutput "floorWide" floorWide + cgOutput "truncateWide" truncateWide + cgReturn (unsignedReal + signedReal) + unsignedSample = 2 ^ (672 :: Int) + 0x123456789abcdef + signedSample = negate (2 ^ (671 :: Int)) + 0xfedcba987654321 + floorResult = signedSample `div` 3 + truncateResult = signedSample `quot` 3 + modulus = 2 ^ (673 :: Int) + compileAndRunGMP dir "exactWideRealConversions" program + [ show (unsignedSample + signedSample) + , "unsignedReal =" ++ show unsignedSample + , "signedReal =" ++ show signedSample + , "fraction =" ++ show signedSample ++ "/3" + , "floorWide =" ++ asHex 11 (floorResult `mod` modulus) + , "truncateWide =" ++ asHex 11 (truncateResult `mod` modulus) + ] + +-- | Exercise exact rational arithmetic and integer-to-real conversion. +exactRealArithmetic :: Assertion +exactRealArithmetic = withSystemTempDirectory "sbv-exact-real" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [5, 2, 2] + a <- cgInput "a" :: SBVCodeGen SReal + b <- cgInput "b" :: SBVCodeGen SReal + integer <- cgInput "integer" :: SBVCodeGen SInteger + let converted = sFromIntegral integer :: SReal + base = a / 3 + b / 7 + converted + result = ite (a .> b) (abs (base * (-3))) 0 + cgOutput "converted" converted + cgOutput "base" base + cgReturn result + compileAndRunGMP dir "exactRealArithmetic" program ["83/7", "converted =2", "base =83/21"] + +-- | Exercise finite tables with an unbounded index and GMP-backed integer and +-- rational results, including negative and oversized default cases. +exactTableLookup :: Assertion +exactTableLookup = withSystemTempDirectory "sbv-exact-table" $ \dir -> do + let program = do + cgOverwriteFiles True + cgPerformRTCs True + cgSetDriverValues [1, -1, 500, 2 ^ (200 :: Int)] + inRangeIndex <- cgInput "inRangeIndex" :: SBVCodeGen SInteger + negativeIndex <- cgInput "negativeIndex" :: SBVCodeGen SInteger + oversizedIndex <- cgInput "oversizedIndex" :: SBVCodeGen SInteger + tableValue <- cgInput "tableValue" :: SBVCodeGen SInteger + let integerResult = select [2 ^ (130 :: Int), tableValue + 7] (-11) inRangeIndex :: SInteger + negativeResult = select [3 / 2, 5 / 3] (7 / 4) negativeIndex :: SReal + oversizedResult = select [13, 17] 19 oversizedIndex :: SInteger + cgOutput "negativeResult" negativeResult + cgOutput "oversizedResult" oversizedResult + cgReturn integerResult + compileAndRunGMP dir "exactTableLookup" program [show (2 ^ (200 :: Int) + 7 :: Integer), "negativeResult =7/4", "oversizedResult =19"] + +-- | Exercise a persistent array with GMP-backed integer keys and rational +-- values, including a read from the unchanged base version. +exactArray :: Assertion +exactArray = withSystemTempDirectory "sbv-exact-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [2 ^ (300 :: Int) + 9, 20] + key <- cgInput "key" :: SBVCodeGen SInteger + value <- cgInput "value" :: SBVCodeGen SInteger + let stored = sFromIntegral value / 3 :: SReal + base = constArray (1 / 3 :: SReal) + updated = writeArray base key stored + cgOutput "baseValue" (readArray base key) + cgReturn (readArray updated key) + compileAndRunGMP dir "exactArray" program ["20/3", "baseValue =1/3"] + +-- | Exercise borrowed callback input and overlay semantics with GMP-backed +-- integer keys and rational values. +exactArrayInput :: Assertion +exactArrayInput = withSystemTempDirectory "sbv-exact-array-input" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [7, 2 ^ (300 :: Int) + 9, 20] + source <- cgInput "source" :: SBVCodeGen (SArray Integer AlgReal) + key <- cgInput "key" :: SBVCodeGen SInteger + value <- cgInput "value" :: SBVCodeGen SInteger + let updated = writeArray source key (sFromIntegral value / 3) + cgOutput "sourceValue" (readArray source key) + cgReturn (readArray updated key) + compileAndRunGMP dir "exactArrayInput" program ["20/3", "sourceValue =7"] + +-- | Exercise borrowed fixed-size GMP input arrays for integers, reals, and +-- rationals, including caller initialization and cleanup in the driver. +exactFixedInputArrays :: Assertion +exactFixedInputArrays = withSystemTempDirectory "sbv-exact-fixed-input-arrays" $ \dir -> do + let integerSeed = 2 ^ (300 :: Int) + 11 + program = do + cgOverwriteFiles True + cgSetDriverValues [integerSeed, -7, 5, 2, 9, 4] + [integerA, integerB] <- cgInputArr 2 "integers" :: SBVCodeGen [SInteger] + [realA, realB] <- cgInputArr 2 "reals" :: SBVCodeGen [SReal] + [rationalA, rationalB] <- cgInputArr 2 "rationals" :: SBVCodeGen [SRational] + cgOutput "integerResult" (integerA + integerB) + cgOutput "realResult" (realA / realB) + cgOutput "rationalResult" (rationalA / rationalB) + cgReturn (integerA .> integerB .&& realA .> realB .&& rationalA .> rationalB) + + compileAndRunGMP dir "exactFixedInputArrays" program + [ show (integerSeed - 7) + , "realResult =5/2" + , "rationalResult =9/4" + , ") = 1" + ] + headerText <- readFile (dir "exactFixedInputArrays.h") + driverText <- readFile (dir "exactFixedInputArrays_driver.c") + assertBool "Expected fixed exact inputs to use borrowed GMP array parameters" + ("const mpz_t *integers" `isInfixOf` headerText + && "const mpq_t *reals" `isInfixOf` headerText + && "const mpq_t *rationals" `isInfixOf` headerText) + assertBool "Expected the generated driver to release every GMP input-array element" + ("mpz_clear(sbv_driver_input_0[0]);" `isInfixOf` driverText + && "mpz_clear(sbv_driver_input_0[1]);" `isInfixOf` driverText + && "mpq_clear(sbv_driver_input_1[0]);" `isInfixOf` driverText + && "mpq_clear(sbv_driver_input_2[1]);" `isInfixOf` driverText) + +-- | Exercise repeated reads from a structured array lambda whose arithmetic +-- allocates exact rational results in the enclosing generated-call arena. +exactLambdaArray :: Assertion +exactLambdaArray = withSystemTempDirectory "sbv-exact-lambda-array" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [20] + key <- cgInput "key" :: SBVCodeGen SInteger + let source = lambdaArray (\index -> sFromIntegral index / 3) :: SArray Integer AlgReal + cgOutput "value" (readArray source key) + cgReturn (readArray source (key + 1)) + compileAndRunGMP dir "exactLambdaArray" program ["7", "value =20/3"] + +-- | Exercise a parameter-dependent exact table whose entries allocate in the +-- structured lambda's enclosing GMP arena. +exactLambdaTable :: Assertion +exactLambdaTable = withSystemTempDirectory "sbv-exact-lambda-table" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + key <- cgInput "key" :: SBVCodeGen SInteger + let source = lambdaArray (\index -> select [sFromIntegral index / 3, sFromIntegral index / 5] 7 index) + :: SArray Integer AlgReal + cgReturn (readArray source key) + compileAndRunGMP dir "exactLambdaTable" program ["1/5"] + +-- | Exercise exact store cloning and a structured callback that allocates +-- after the generated function's original GMP arena has been released. +ownedExactArrays :: Assertion +ownedExactArrays = withSystemTempDirectory "sbv-owned-exact-arrays" $ \dir -> do + let program = do + cgOverwriteFiles True + let source = lambdaArray (\index -> sFromIntegral index / 3) :: SArray Integer AlgReal + cgOutput "stored" (writeArray source 0 (5 / 3)) + cgReturn source + + compileAndRunGMP dir "ownedExactArrays" program ["ownedExactArrays(&stored)[0] =0", "stored[0] =5/3"] + +-- | Exercise exact tuple construction, constants in a finite table, +-- projection, and copying into scalar caller-owned results. +exactTupleFields :: Assertion +exactTupleFields = withSystemTempDirectory "sbv-exact-tuple-fields" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [0] + index <- cgInput "index" :: SBVCodeGen SWord8 + let first, second :: SBV (AlgReal, Integer) + first = tuple (1 / 3, 2 ^ (130 :: Int)) + second = tuple (5 / 7, 9) + selected = select [first] second index + (realValue, integerValue) = untuple selected + cgOutput "integerValue" integerValue + cgReturn realValue + + compileAndRunGMP dir "exactTupleFields" program ["1/3", show (2 ^ (130 :: Int) :: Integer)] + +-- | Exercise borrowed exact-tuple inputs and independently owned outputs and +-- returns whose GMP fields survive the generated call's temporary arena. +ownedExactTuples :: Assertion +ownedExactTuples = withSystemTempDirectory "sbv-owned-exact-tuples" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen (SBV (Integer, (AlgReal, Integer))) + let (integerValue, nested) = untuple source + (realValue, secondInteger) = untuple nested + outputTuple = tuple (integerValue + 1, tuple (realValue / 3, secondInteger + 2)) + result = tuple (integerValue * 2, tuple (realValue + 1, secondInteger * 3)) + cgOutput "output" outputTuple + cgReturn result + seed = 2 ^ (130 :: Int) + expectedOutput = "output =(" ++ show (seed + 1) ++ ", (" ++ show (seed + 1) ++ "/3, " ++ show (seed + 4) ++ "))" + expectedReturn = "(" ++ show (seed * 2) ++ ", (" ++ show (seed + 2) ++ ", " ++ show ((seed + 2) * 3) ++ "))" + + compileAndRunGMP dir "ownedExactTuples" program [expectedReturn, expectedOutput] + +-- | Exercise borrowed exact-field ADT inputs and independently owned outputs +-- and returns, including exact fields nested through another ADT and a tuple. +ownedExactADTs :: Assertion +ownedExactADTs = withSystemTempDirectory "sbv-owned-exact-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [seed] + source <- cgInput "source" :: SBVCodeGen SExactAggregate + let leaf = getExactAggregate_1 source + values = getExactAggregate_2 source + integerValue = getExactLeaf_1 leaf + realValue = getExactLeaf_2 leaf + (tupleInteger, tupleReal) = untuple values + outputValues = tuple (tupleInteger + 2, tupleReal + 3) + outputLeaf = sExactLeaf (integerValue + 1) (realValue / 7) + outputAggregate = sExactAggregate outputLeaf outputValues + resultValues = tuple (tupleInteger * 3, tupleReal / 5) + resultLeaf = sExactLeaf (integerValue * 2) (realValue + 1) + resultAggregate = sExactAggregate resultLeaf resultValues + cgOutput "output" outputAggregate + cgOutput "sameAsResult" (source .== resultAggregate) + cgReturn resultAggregate + seed = 2 ^ (130 :: Int) + 1 + expectedOutput = "output =ExactAggregate(ExactLeaf(" ++ show (seed + 1) + ++ ", " ++ show (seed + 1) ++ "/7), (" ++ show (seed + 3) + ++ ", " ++ show (seed + 5) ++ "))" + expectedReturn = "ExactAggregate(ExactLeaf(" ++ show (seed * 2) + ++ ", " ++ show (seed + 2) ++ "), (" ++ show (3 * (seed + 1)) + ++ ", " ++ show (seed + 2) ++ "/5))" + + compileAndRunGMP dir "ownedExactADTs" program [expectedReturn, expectedOutput, "sameAsResult = 0"] + +-- | Exercise deep cloning and release for an ADT that combines recursive +-- pointer nodes with GMP-backed fields. +ownedRecursiveExactADTs :: Assertion +ownedRecursiveExactADTs = withSystemTempDirectory "sbv-owned-recursive-exact-adts" $ \dir -> do + let program = do + cgOverwriteFiles True + cgSetDriverValues [1] + source <- cgInput "source" :: SBVCodeGen SExactChain + cgOutput "sameChain" (source .== source) + cgOutput "chainCopy" source + cgReturn source + + compileAndRunGMP dir "ownedRecursiveExactADTs" program + [ "sameChain = 1" + , "ExactNext(1, ExactEnd(2))" + ] + +-- | Exercise merged headers, archives, and drivers for exact-number libraries. +exactNumberLibrary :: Assertion +exactNumberLibrary = withSystemTempDirectory "sbv-exact-library" $ \dir -> do + let integerProgram = do + cgOverwriteFiles True + cgSetDriverValues [2 ^ (130 :: Int)] + value <- cgInput "value" :: SBVCodeGen SInteger + cgReturn (value + 7) + realProgram = do + cgOverwriteFiles True + cgSetDriverValues [5] + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (value / 3) + wideProgram = do + cgOverwriteFiles True + cgSetDriverValues [wideSample] + value <- cgInput "value" :: SBVCodeGen (SInt 673) + cgReturn (sFromIntegral value :: SInteger) + arrayProgram = do + cgOverwriteFiles True + cgSetDriverValues [arraySeed, 3] + [first, second] <- cgInputArr 2 "values" :: SBVCodeGen [SInteger] + cgReturn (first - second) + tupleProgram increment = do + cgOverwriteFiles True + cgSetDriverValues [tupleSeed] + source <- cgInput "source" :: SBVCodeGen (SBV (Integer, AlgReal)) + let (integerValue, realValue) = untuple source + cgReturn (tuple (integerValue + fromInteger increment, realValue + fromInteger increment)) + adtProgram increment = do + cgOverwriteFiles True + cgSetDriverValues [adtSeed] + source <- cgInput "source" :: SBVCodeGen SExactAggregate + let leaf = getExactAggregate_1 source + integerValue = getExactLeaf_1 leaf + realValue = getExactLeaf_2 leaf + (tupleInteger, tupleReal) = untuple (getExactAggregate_2 source) + integerAmount = fromInteger increment :: SInteger + realAmount = fromInteger increment :: SReal + resultLeaf = sExactLeaf (integerValue + integerAmount) (realValue + realAmount) + resultValues = tuple (tupleInteger + integerAmount, tupleReal + realAmount) + cgReturn (sExactAggregate resultLeaf resultValues) + wideSample = negate (2 ^ (670 :: Int)) + 12345 + arraySeed = 2 ^ (180 :: Int) + 9 + tupleSeed = 2 ^ (140 :: Int) + adtSeed = 2 ^ (150 :: Int) + 1 + + (_, cfg, bundle) <- compileToCLib' "exactNumberLibrary" + [ ("integerPart", integerProgram) + , ("realPart", realProgram) + , ("widePart", wideProgram) + , ("arrayPart", arrayProgram) + , ("incrementTuple", tupleProgram 1) + , ("addTwoTuple", tupleProgram 2) + , ("incrementADT", adtProgram 1) + , ("addTwoADT", adtProgram 2) + ] + renderCgPgmBundle (Just dir) (cfg, bundle) + + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + + let driverExecutable = dir "exactNumberLibrary_driver" + (runExit, stdoutText, runError) <- readProcessWithExitCode driverExecutable [] "" + assertEqual runError ExitSuccess runExit + assertOutput stdoutText (show (2 ^ (130 :: Int) + 7 :: Integer)) + assertOutput stdoutText "5/3" + assertOutput stdoutText (show wideSample) + assertOutput stdoutText (show (arraySeed - 3)) + assertOutput stdoutText ("(" ++ show (tupleSeed + 1) ++ ", " ++ show (tupleSeed + 2) ++ ")") + assertOutput stdoutText ("(" ++ show (tupleSeed + 2) ++ ", " ++ show (tupleSeed + 3) ++ ")") + assertOutput stdoutText ("ExactAggregate(ExactLeaf(" ++ show (adtSeed + 1) ++ ", " ++ show (adtSeed + 2) + ++ "), (" ++ show (adtSeed + 2) ++ ", " ++ show (adtSeed + 3) ++ "))") + assertOutput stdoutText ("ExactAggregate(ExactLeaf(" ++ show (adtSeed + 2) ++ ", " ++ show (adtSeed + 3) + ++ "), (" ++ show (adtSeed + 3) ++ ", " ++ show (adtSeed + 4) ++ "))") + +-- | Generate, compile, and execute a program against the system GMP package. +-- Exercise both a direct compiler invocation and the generated Makefile, honoring +-- @SBV_C_TEST_FLAGS@ in both paths so rebuilding cannot hide sanitizer failures. +compileAndRunGMP :: FilePath -> String -> SBVCodeGen () -> [String] -> Assertion +compileAndRunGMP dir functionName program expected = do + (_, cfg, bundle) <- compileToC' functionName program + renderCgPgmBundle (Just dir) (cfg, bundle) + + (pkgExit, pkgOutput, pkgError) <- readProcessWithExitCode "pkg-config" ["--cflags", "--libs", "gmp"] "" + assertEqual pkgError ExitSuccess pkgExit + + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + let source = dir functionName ++ ".c" + driver = dir functionName ++ "_driver.c" + exe = dir functionName ++ "_driver" + args = ["-std=c11", "-Wall", "-Werror", "-ffp-contract=off", source, driver, "-o", exe] ++ extraFlags ++ words pkgOutput + checkRun = do (runExit, stdoutText, runError) <- readProcessWithExitCode exe [] "" + assertEqual runError ExitSuccess runExit + mapM_ (assertOutput stdoutText) expected + (ccExit, _, ccError) <- readProcessWithExitCode "cc" args "" + assertEqual ccError ExitSuccess ccExit + checkRun + + makeOptions <- generatedMakeOptions dir + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + checkRun + + makefile <- readFile (dir "Makefile") + assertBool "Generated Makefile does not request GMP compiler flags" ("pkg-config --cflags gmp" `isInfixOf` makefile) + assertBool "Generated Makefile does not request GMP linker flags" ("pkg-config --libs gmp" `isInfixOf` makefile) + +-- | Assert that generated driver output contains an expected fragment. +assertOutput :: String -> String -> Assertion +assertOutput stdoutText fragment = + assertBool ("Expected generated output to contain " ++ fragment ++ ", received:\n" ++ stdoutText) (fragment `isInfixOf` stdoutText) + +-- | Render the fixed-limb hexadecimal form printed by generated drivers. +asHex :: Int -> Integer -> String +asHex limbCount value = "0x" ++ replicate (16 * limbCount - length rendered) '0' ++ rendered + where rendered = showHex value "" diff --git a/SBVTestSuite/TestSuite/CodeGeneration/LibraryBuild.hs b/SBVTestSuite/TestSuite/CodeGeneration/LibraryBuild.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/LibraryBuild.hs @@ -0,0 +1,125 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.LibraryBuild +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Incremental build regressions for generated C static libraries. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.LibraryBuild (tests, testsWith) where + +import Control.Monad (void) +import qualified Data.ByteString as BS +import System.Directory (doesFileExist) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath ((), takeExtension) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Tools.CodeGen +import qualified Data.SBV.Tools.CodeGen.Legacy as Legacy +import Utils.SBVTestFramework + +-- | Generate a library named @buildLibrary@ with the supplied components. +type LibraryGenerator = FilePath -> [(String, SBVCodeGen ())] -> IO () + +-- | Exercise both the current and legacy public library generators. +tests :: TestTree +tests = testGroup "CodeGeneration.LibraryBuild" + [ testsWith "current" $ \dir components -> void $ compileToCLib (Just dir) "buildLibrary" components + , testsWith "legacy" $ \dir components -> void $ Legacy.compileToCLib (Just dir) "buildLibrary" components + ] + +-- | Apply the same archive and driver checks to either public C backend. +testsWith :: String -> LibraryGenerator -> TestTree +testsWith groupName generate = testGroup groupName + [ testCase "driver archive dependency" (driverDependencies generate) + , testCase "remove retired components with a driver" (archiveRegeneration generate True) + , testCase "remove retired components without a driver" (archiveRegeneration generate False) + , testCase "preserve archive after a failed rebuild" (failedArchiveRebuild generate) + ] + +-- | Generate a trivial scalar component with predictable driver output. +component :: Bool -> Word8 -> SBVCodeGen () +component driver value = do + cgOverwriteFiles True + cgGenerateDriver driver + cgSetDriverValues [] + cgReturn (literal value) + +-- | Building the driver directly must first build its archive, including in +-- parallel builds. Both archive and component changes must invalidate it. +driverDependencies :: LibraryGenerator -> Assertion +driverDependencies generate = withSystemTempDirectory "sbv-c-library-driver" $ \dir -> do + generate dir [("component", component True 7)] + build dir ["-j2", "buildLibrary_driver"] + (runExit, _, runError) <- readProcessWithExitCode (dir "buildLibrary_driver") [] "" + assertEqual runError ExitSuccess runExit + (freshExit, _, freshError) <- readProcessWithExitCode "make" ["-C", dir, "-q", "buildLibrary_driver"] "" + assertEqual freshError ExitSuccess freshExit + mapM_ (checkDependency dir) ["component.c", "buildLibrary.a", "buildLibrary.h"] + where checkDependency dir prerequisite = do + (staleExit, _, staleError) <- readProcessWithExitCode "make" + ["-C", dir, "-q", "-W", prerequisite, "buildLibrary_driver"] "" + assertEqual (prerequisite ++ ": " ++ staleError) (ExitFailure 1) staleExit + +-- | Regeneration must replace the archive's membership, not merely update +-- members still present. Old component files outside the archive are retained. +archiveRegeneration :: LibraryGenerator -> Bool -> Assertion +archiveRegeneration generate driver = withSystemTempDirectory "sbv-c-library-regeneration" $ \dir -> do + let retained = ("retained", component driver 11) + retired = ("retired", component driver 22) + generate dir [retained, retired] + build dir ["buildLibrary.a"] + checkMembers dir ["retained.o", "retired.o"] + generate dir [retained] + build dir ["-B", "buildLibrary.a"] + checkMembers dir ["retained.o"] + assertBool "Unselected component objects must not be deleted" =<< doesFileExist (dir "retired.o") + generate dir [retired, retained] + build dir ["-B", "buildLibrary.a"] + checkMembers dir ["retired.o", "retained.o"] + +-- | An unsuccessful archiver must leave the previous valid archive intact. +-- A subsequent successful rebuild must recover without manual cleanup. +failedArchiveRebuild :: LibraryGenerator -> Assertion +failedArchiveRebuild generate = withSystemTempDirectory "sbv-c-library-failed-rebuild" $ \dir -> do + generate dir [("component", component False 7)] + build dir ["buildLibrary.a"] + original <- BS.readFile (dir "buildLibrary.a") + makeOptions <- buildOptions + (failedExit, _, _) <- readProcessWithExitCode "make" + (["-C", dir, "-B", "buildLibrary.a", "AR=false"] ++ makeOptions) "" + assertBool "The failed archiver must fail the build" (failedExit /= ExitSuccess) + assertBool "The previous archive must still exist" =<< doesFileExist (dir "buildLibrary.a") + assertEqual "The previous archive must remain unchanged" original =<< BS.readFile (dir "buildLibrary.a") + build dir ["-B", "buildLibrary.a"] + checkMembers dir ["component.o"] + +-- | Build with strict C warnings and optional local sanitizer flags. +build :: FilePath -> [String] -> Assertion +build dir targets = do + makeOptions <- buildOptions + (makeExit, _, makeError) <- readProcessWithExitCode "make" (["-C", dir] ++ targets ++ makeOptions) "" + assertEqual makeError ExitSuccess makeExit + +-- | Preserve caller-selected instrumentation during compilation and linking. +buildOptions :: IO [String] +buildOptions = do + extraFlags <- maybe "" (" " ++) <$> lookupEnv "SBV_C_TEST_FLAGS" + pure ["CCFLAGS=-std=c11 -Wall -Wextra -Werror -O2" ++ extraFlags] + +-- | Compare object membership and order, ignoring platform-specific symbol +-- index members such as the BSD archiver's @__.SYMDEF@ entry. +checkMembers :: FilePath -> [String] -> Assertion +checkMembers dir expected = do + (arExit, members, arError) <- readProcessWithExitCode "ar" ["t", dir "buildLibrary.a"] "" + assertEqual arError ExitSuccess arExit + assertEqual "Archive components" expected (filter ((== ".o") . takeExtension) (lines members)) diff --git a/SBVTestSuite/TestSuite/CodeGeneration/PseudoBoolean.hs b/SBVTestSuite/TestSuite/CodeGeneration/PseudoBoolean.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/PseudoBoolean.hs @@ -0,0 +1,130 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.PseudoBoolean +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Executed pseudo-Boolean comparisons at native overflow boundaries. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.PseudoBoolean (tests, testsWith) where + +import Control.Monad (replicateM, void) +import Data.List (intercalate) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertEqual) + +import Data.SBV.Tools.CodeGen +import qualified Data.SBV.Tools.CodeGen.Legacy as Legacy +import Utils.SBVTestFramework + +-- | Exercise both backends through their public standalone and library APIs. +tests :: TestTree +tests = testGroup "CodeGeneration.PseudoBoolean" + [ testsWith "current" $ \dir library functionName program -> + if library + then void $ compileToCLib (Just dir) "pbLibrary" [(functionName, program)] + else compileToC (Just dir) functionName program + , testsWith "legacy" $ \dir library functionName program -> + if library + then void $ Legacy.compileToCLib (Just dir) "pbLibrary" [(functionName, program)] + else Legacy.compileToC (Just dir) functionName program + ] + +-- | Reuse the execution matrix for a compatibility backend without changing its +-- import facade. Every truth assignment is checked against unbounded Haskell +-- arithmetic, at both optimization levels and with undefined-behavior checking. +testsWith :: String -> (FilePath -> Bool -> String -> SBVCodeGen () -> IO ()) -> TestTree +testsWith groupName generate = testGroup groupName + [ testCase (form ++ " mapped" ++ show integerWidth ++ " " ++ optimization) $ withSystemTempDirectory "sbv-c-pseudo-boolean" $ \dir -> do + let functionName = "pbChecks" + artifact = if library then "pbLibrary.a" else functionName ++ ".o" + header = if library then "pbLibrary.h" else functionName ++ ".h" + generate dir library functionName $ do + cgOverwriteFiles True + cgGenerateDriver False + cgIntegerSize integerWidth + inputs <- cgInputArr 5 "inputs" + cgOutputArr "checks" (comparisons inputs) + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + let flags = ["-std=c11", "-Wall", "-Wextra", "-Werror"] ++ words optimization ++ extraFlags + (makeExit, _, makeError) <- readProcessWithExitCode "make" + ["-C", dir, artifact, "CCFLAGS=" ++ unwords flags] "" + assertEqual makeError ExitSuccess makeExit + writeFile (dir "caller.c") (caller header functionName) + let executablePath = dir "caller" + (ccExit, _, ccError) <- readProcessWithExitCode "cc" + (flags ++ [dir "caller.c", dir artifact, "-o", executablePath]) "" + assertEqual ccError ExitSuccess ccExit + (runExit, _, runError) <- readProcessWithExitCode executablePath [] "" + assertEqual runError ExitSuccess runExit + mapM_ (\values -> assertEqual "Concrete SBV comparisons must agree with mathematical sums" + (map Just (expected values)) (map unliteral (comparisons (map literal values)))) assignments + | (form, library) <- [("standalone", False), ("library", True)] + , integerWidth <- [8, 64] + , optimization <- ["-O0", "-O2", "-O1 -fsanitize=undefined -fno-sanitize-recover=all"] + ] + +-- | Coefficients and bounds covering signed 32-bit overflow, signed and unsigned +-- 64-bit overflow, zero weights, exact ties, and crossing a bound late in a sum. +scenarios :: [([Int], Int)] +scenarios = [ ([2000000000, 2000000000, 0, 0, 0], 2100000000) + , ([maxBound, maxBound, 0, 0, 0], maxBound) + , (replicate 5 maxBound, maxBound) + , ([maxBound, 1, maxBound, 1, 0], maxBound) + , ([0, 0, 0, 0, 0], 0) + , ([0, 1, 0, 1, 0], 0) + , ([1, 2, 3, 4, 5], 7) + , ([1, 2, 3, 4, 5], maxBound) + , ([maxBound, maxBound, maxBound, 0, 0], 0) + , ([maxBound - 1, 1, 1, maxBound - 1, 1], maxBound) + ] + +-- | All assignments to the five independent input Booleans. +assignments :: [[Bool]] +assignments = replicateM 5 [False, True] + +-- | Exercise all six pseudo-Boolean operators, plus their empty-list semantics. +comparisons :: [SBool] -> [SBool] +comparisons inputs = concat [let weighted = zip coefficients inputs + in [pbLe weighted bound, pbGe weighted bound, pbEq weighted bound] + | (coefficients, bound) <- scenarios] + ++ [pbAtMost inputs 2, pbAtLeast inputs 2, pbExactly inputs 2] + ++ [pbAtMost [] 0, pbAtLeast [] 1, pbExactly [] 0] + +-- | Compute expected answers with mathematical integers, never machine sums. +expected :: [Bool] -> [Bool] +expected inputs = concat [compareSum (sum [toInteger coefficient | (coefficient, True) <- zip coefficients inputs]) (toInteger bound) + | (coefficients, bound) <- scenarios] + ++ compareSum (toInteger (length (filter id inputs))) 2 + ++ [True, False, True] + where compareSum total bound = [total <= bound, total >= bound, total == bound] + +-- | An independent C caller supplies all input combinations and exact expected +-- outputs. Its arrays are shared across calls to check that temporary sums reset. +caller :: String -> String -> String +caller header functionName = unlines + [ "#include " + , "#include \"" ++ header ++ "\"" + , "int main(void)" + , "{" + , " static const SBool inputs[][5] = {" ++ intercalate ", " (map row assignments) ++ "};" + , " static const SBool expected[][" ++ show count ++ "] = {" ++ intercalate ", " (map (row . expected) assignments) ++ "};" + , " SBool output[" ++ show count ++ "];" + , " for (size_t i = 0; i < sizeof inputs / sizeof inputs[0]; ++i) {" + , " " ++ functionName ++ "(inputs[i], output);" + , " for (size_t j = 0; j < " ++ show count ++ "; ++j) assert(output[j] == expected[i][j]);" + , " }" + , " return 0;" + , "}" + ] + where count = length (expected (replicate 5 False)) + row values = "{" ++ intercalate ", " [if value then "true" else "false" | value <- values] ++ "}" diff --git a/SBVTestSuite/TestSuite/CodeGeneration/RegExp.hs b/SBVTestSuite/TestSuite/CodeGeneration/RegExp.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/RegExp.hs @@ -0,0 +1,351 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.RegExp +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Execute bounded, dependency-free C regex automata against solver results. +----------------------------------------------------------------------------- + +{-# LANGUAGE OverloadedStrings #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.RegExp (tests) where + +import Control.Exception (ErrorCall, displayException, evaluate, try) +import Control.Monad (forM, forM_, replicateM, void) +import Data.Char (ord) +import Data.List (intercalate, isInfixOf, nub) +import System.Directory (listDirectory) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Control +import Data.SBV.Internals (compileToC', compileToCLib', renderCgPgmBundle) +import Data.SBV.Tools.CodeGen +import qualified Data.SBV.List as SL +import qualified Data.SBV.RegExp as R +import Utils.SBVTestFramework + +-- | Full-operator matching, language comparisons, scope integration, and +-- generation budgets, including absence of overhead for non-regex code. +tests :: TestTree +tests = testGroup "CodeGeneration.RegExp" + [ testCase "regex membership agrees with Z3 and literal folding" membershipAgreement + , testCase "regex language equality and inequality" languageAgreement + , testCase "regex definitions and escaping array lambdas in a library" regexLibrary + , testCase "regex generation limits fail before writing" regexLimits + , testCase "default regex budgets accommodate ordinary bounded repetitions" calibratedRegexLimits + , testCase "regex limits apply to comparisons, definitions, and library components" regexLimitScopes + , testCase "regex character matching and dynamic tables" regexCharacterTable + , testCase "regex state limits do not bound input length" longRegexInput + , testCase "non-regex and dead-regex code require no regex support" noRegexOverhead + ] + +-- | Shared syntax and balanced-map lookup must not be charged as repeated +-- whole-tree copies and linear scans of the entire state set. +calibratedRegexLimits :: Assertion +calibratedRegexLimits = do + mapM_ generate [R.Loop 0 30 "a", R.Power 510 "a"] + result <- try (generate (R.Power 1023 "a")) :: IO (Either ErrorCall ()) + case result of + Left err -> assertBool (displayException err) ("state limit (1024)" `isInfixOf` displayException err) + Right () -> assertFailure "Expected the default state cap to reject 1025 states" + where generate regex = do + (_, _, bundle) <- compileToC' "calibratedRegex" $ do + cgGenerateDriver False + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` regex) + void $ evaluate (length (show bundle)) + assertBool "Default-sized automata use compact transition entries" + (any (\line -> "static const uint16_t sbv_regex_" `isInfixOf` line && "_step" `isInfixOf` line) (lines (show bundle))) + +-- | Ordinary and Boolean operators, empty languages/concatenations, and +-- nullable repetitions; include boundaries of every supported encoding width. +regexes :: [R.RegExp] +regexes = nub $ atoms + ++ [op r | op <- [R.Comp, R.KStar, R.KPlus, R.Opt, R.Loop 0 2, R.Power 2], r <- atoms] + ++ [op a b | op <- [R.Inter, R.Diff, \a b -> R.Union [a, b], \a b -> R.Conc [a, b]], a <- atoms, b <- atoms] + ++ [ R.Conc [R.Inter "a" "ab", R.All] + , R.Conc [R.Diff "ab" "a", R.Opt "b"] + , R.Conc [R.Comp "a", "b"] + , R.KStar (R.Inter (R.Opt "a") (R.Comp "b")) + , R.KStar (R.Comp "a") + , R.Loop 2 3 (R.Opt "a") + , R.Conc [R.All, "b"] + , R.Range '\0' '\x2ffff' + , R.Range '\xd800' '\xdfff' + , R.Range '\x7f' '\x800' + , R.Literal "\0\955\xd800\x2ffff" + ] + where atoms = [R.All, R.AllChar, R.None, R.Conc [], "a", "ab", R.Range 'a' 'b', R.Range 'b' 'a'] + +-- | Query a genuinely symbolic string for each sample, then feed the same +-- code points to compiled C. Literal folding is checked as a third evaluator. +membershipAgreement :: Assertion +membershipAgreement = withSystemTempDirectory "sbv-c-regex-agreement" $ \dir -> do + expected <- runSMT $ do + input <- sString "input" + query $ forM samples $ \sample -> inNewAssertionStack $ do + constrain (input .== literal sample) + status <- checkSat + case status of + Sat -> getValue (SL.implode [input `R.match` r | r <- regexes]) + _ -> error $ "Unexpected regex reference status: " ++ show status + forM_ (zip samples expected) $ \(sample, values) -> + assertEqual ("Literal regex agreement: " ++ show sample) (map Just values) + [unliteral (literal sample `R.match` r) | r <- regexes] + let program = do + cgOverwriteFiles True + cgGenerateDriver False + cgAddDecl (membershipHarness "regexMembership" samples (length regexes)) + input <- cgInput "input" :: SBVCodeGen SString + cgOutputArr "matches" [input `R.match` r | r <- regexes] + (_, cfg, bundle) <- compileToC' "regexMembership" program + renderCgPgmBundle (Just dir) (cfg, bundle) + actual <- runC dir ["regexMembership"] + assertEqual "C automata agree with Z3 for every regex/sample" (map (map bitChar) expected) (lines actual) + where samples = nub $ concatMap (`replicateM` "ab") [0 .. 3] + ++ ["\0", "\955", "\x7f", "\x80", "\x7ff", "\x800", "\xd800", "\xdfff", "\xffff", "\x10000", "\x2ffff" + , "\0\955\xd800\x2ffff", "\955b", "a\0"] + bitChar True = '1' + bitChar False = '0' + +-- | Build strings from numeric code points instead of relying on C source +-- encoding or NUL termination. Every sample shares one generated matcher. +membershipHarness :: String -> [String] -> Int -> [String] +membershipHarness function samples count = + [ "int main(void) {" + , " uint8_t bytes[" ++ show (max 1 (4 * maximum (map length samples))) ++ "];" + , " SBool matches[" ++ show count ++ "];" + ] ++ concatMap sampleBlock samples ++ [" return 0;", "}"] + where sampleBlock sample = + [ " {" + , " const SChar points[] = {" ++ intercalate ", " (map (show . ord) sample ++ ["0"]) ++ "};" + , " size_t size = 0;" + , " for (size_t i = 1; i < sizeof(points) / sizeof(points[0]); ++i) size += sbv_char_encode(points[i - 1], bytes + size);" + , " " ++ function ++ "(sbv_string_borrow(bytes, size, sizeof(points) / sizeof(points[0]) - 1), matches);" + , " for (size_t i = 0; i < " ++ show count ++ "; ++i) putchar(matches[i] ? '1' : '0');" + , " putchar('\\n');" + , " }" + ] + +-- | Decide language equality at generation time, including equality expressed +-- by structurally different regexes and languages distinguished only by epsilon. +languageAgreement :: Assertion +languageAgreement = withSystemTempDirectory "sbv-c-regex-languages" $ \dir -> do + expected <- runSMT $ query $ do + status <- checkSat + case status of + Sat -> mapM (\(a, b) -> getValue (a .== b)) pairs + _ -> error $ "Unexpected regex reference status: " ++ show status + let program = do + cgOverwriteFiles True + cgGenerateDriver False + cgAddDecl ["int main(void) { SBool values[" ++ show (2 * length pairs) ++ "]; regexLanguages(values);" + , "for (size_t i = 0; i < " ++ show (2 * length pairs) ++ "; ++i) putchar(values[i] ? '1' : '0'); return 0; }"] + cgOutputArr "values" (concat [[a .== b, a ./= b] | (a, b) <- pairs]) + (_, cfg, bundle) <- compileToC' "regexLanguages" program + renderCgPgmBundle (Just dir) (cfg, bundle) + actual <- runC dir ["regexLanguages"] + assertEqual "Exact language comparisons" (concatMap (\equal -> if equal then "10" else "01") expected) actual + source <- readFile (dir "regexLanguages.c") + assertBool "Language comparisons need no runtime regex tables" (not ("sbv_regex_" `isInfixOf` source)) + where pairs = [ (R.Conc [], "") + , (R.Union [], R.None) + , (R.Comp R.None, R.All) + , (R.Inter (R.Comp "a") (R.Comp "b"), R.Comp (R.Union ["a", "b"])) + , (R.Diff R.All "a", R.Comp "a") + , (R.KPlus "a", R.Conc ["a", R.KStar "a"]) + , (R.KStar (R.Opt "a"), R.KStar "a") + , (R.Loop 0 0 "a", R.Conc []) + , (R.Range '\0' '\x2ffff', R.AllChar) + , (R.All, R.AllChar) + , (R.KStar "a", R.KPlus "a") + , (R.Power 3 "a", R.Loop 2 3 "a") + , (R.Range 'a' 'b', R.Range 'a' 'c') + ] + +-- | Library components may use independent budgets, and regex tables remain +-- private even when definitions and escaping closed lambdas reuse node IDs. +regexLibrary :: Assertion +regexLibrary = withSystemTempDirectory "sbv-c-regex-library" $ \dir -> do + let matcher = smtFunction "regex in a defined function" (\value -> value `R.match` R.Conc [R.All, "b"]) + component = do + cgOverwriteFiles True + cgGenerateDriver False + let array = lambdaArray matcher :: SArray String Bool + cgReturn array + direct = do + cgOverwriteFiles True + cgGenerateDriver False + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (matcher input) + plain = do + cgOverwriteFiles True + cgGenerateDriver False + cgRegexLimits 0 0 0 + cgAddDecl ["int main(void) {" + , " SBVArrayOutput_6_string_2_u1 array = regexClosure();" + , " const SString ab = sbv_string_borrow_utf8(\"ab\"), a = sbv_string_borrow_utf8(\"a\");" + , " const int ok = array.lookup(array.context, ab) && !array.lookup(array.context, a) && regexDirect(ab) && !regexDirect(a) && plainComponent();" + , " sbv_array_output_release_6_string_2_u1(&array);" + , " return ok ? 0 : 1;" + , "}"] + cgReturn sTrue + (_, cfg, bundle) <- compileToCLib' "regexLibrary" [("regexClosure", component), ("regexDirect", direct), ("plainComponent", plain)] + renderCgPgmBundle (Just dir) (cfg, bundle) + void $ runC dir ["regexClosure", "regexDirect", "plainComponent"] + source <- readFile (dir "plainComponent.c") + assertBool "Non-regex library component has no regex implementation" (not ("sbv_regex_" `isInfixOf` source)) + +-- | Exercise each independent budget and verify rejection precedes file +-- creation. Large repetition counts must fail without expanding them first. +regexLimits :: Assertion +regexLimits = do + rejects "state" (cgRegexLimits 2 100 10000) "a" + rejects "expression-node" (cgRegexLimits 100 4 10000) "abcdef" + rejects "work" (cgRegexLimits 100 100 1) "a" + rejects "disabled" (cgRegexLimits 0 100 10000) "a" + rejects "expression-node" (pure ()) (R.Power maxBound "a") + rejects "expression-node" (pure ()) (R.Loop 0 maxBound "a") + rejects "state" (cgRegexLimits 8 4096 1000000) (R.Conc [R.All, "a", R.Power 8 R.AllChar]) + withSystemTempDirectory "sbv-c-regex-raised-limit" $ \dir -> do + (_, cfg, bundle) <- compileToC' "raisedRegex" $ do + cgRegexLimits 3 100 10000 + cgOverwriteFiles True + cgGenerateDriver False + cgAddDecl ["int main(void) { return raisedRegex(sbv_string_borrow_utf8(\"a\")) ? 0 : 1; }"] + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` R.Literal "a") + renderCgPgmBundle (Just dir) (cfg, bundle) + void $ runC dir ["raisedRegex"] + where rejects :: String -> SBVCodeGen () -> R.RegExp -> Assertion + rejects diagnostic limits regex = withSystemTempDirectory "sbv-c-regex-limit" $ \dir -> do + result <- try (compileToC (Just dir) "limitedRegex" $ do + limits + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` regex)) :: IO (Either ErrorCall ()) + case result of + Left err -> assertBool (displayException err) (diagnostic `isInfixOf` displayException err && "cgRegexLimits" `isInfixOf` displayException err) + Right () -> assertFailure "Expected regex budget rejection" + assertEqual "Rejected regex must not create files" [] =<< listDirectory dir + +-- | Successful bounded generation accepts strings far longer than any budget +-- dimension. The runtime matcher uses neither recursion nor heap allocation. +longRegexInput :: Assertion +longRegexInput = withSystemTempDirectory "sbv-c-regex-long-input" $ \dir -> do + (_, cfg, bundle) <- compileToC' "longRegex" $ do + cgRegexLimits 2 16 1000 + cgOverwriteFiles True + cgGenerateDriver False + cgAddDecl ["int main(void) { uint8_t bytes[100000]; memset(bytes, 'a', sizeof bytes);" + , "return longRegex(sbv_string_borrow(bytes, sizeof bytes, sizeof bytes)) ? 0 : 1; }"] + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` R.KStar "a") + renderCgPgmBundle (Just dir) (cfg, bundle) + void $ runC dir ["longRegex"] + +-- | Apply budgets to every lowering scope, not just entry-point membership. +-- Library preflight must not leave files from an earlier successful component. +regexLimitScopes :: Assertion +regexLimitScopes = do + forM_ [(-1, 100, 10000), (100, -1, 10000), (100, 100, -1)] $ \(states, nodes, work) -> + rejects "nonnegative" (cgRegexLimits states nodes work >> cgReturn sTrue) + rejects "state" $ do + cgRegexLimits 2 100 10000 + cgReturn (R.Literal "a" .== R.Literal "a") + rejects "state" $ do + cgRegexLimits 2 100 10000 + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (smtFunction "limited regex definition" (\s -> s `R.match` R.Literal "a") input) + rejects "state" $ do + cgRegexLimits 2 100 10000 + cgReturn (lambdaArray (\s -> s `R.match` R.Literal "a") :: SArray String Bool) + rejects "domain" $ do + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` R.Literal "\x30000") + withSystemTempDirectory "sbv-c-regex-library-limit" $ \dir -> do + let plain = cgGenerateDriver False >> cgRegexLimits 0 0 0 >> cgReturn sTrue + limited = do cgGenerateDriver False + cgRegexLimits 2 100 10000 + input <- cgInput "input" :: SBVCodeGen SString + cgReturn (input `R.match` R.Literal "a") + result <- try (compileToCLib (Just dir) "limitedLibrary" [("plain", plain), ("limited", limited)]) :: IO (Either ErrorCall [()]) + case result of + Left err -> assertBool (displayException err) ("state" `isInfixOf` displayException err) + Right _ -> assertFailure "Expected library regex budget rejection" + assertEqual "Library budget failure must not write any component" [] =<< listDirectory dir + where rejects :: String -> SBVCodeGen () -> Assertion + rejects diagnostic program = withSystemTempDirectory "sbv-c-regex-scoped-limit" $ \dir -> do + result <- try (compileToC (Just dir) "scopedLimit" program) :: IO (Either ErrorCall ()) + case result of + Left err -> assertBool (displayException err) (diagnostic `isInfixOf` displayException err) + Right () -> assertFailure "Expected scoped regex budget rejection" + assertEqual "Scoped budget failure must not write files" [] =<< listDirectory dir + +-- | Character membership uses the existing singleton-string lowering. Regex +-- computations in a dynamic lookup table keep their function-local tables and +-- setup statements correctly scoped under demand-driven selection. +regexCharacterTable :: Assertion +regexCharacterTable = withSystemTempDirectory "sbv-c-regex-character-table" $ \dir -> do + (_, cfg, bundle) <- compileToC' "regexCharacterTable" $ do + cgOverwriteFiles True + cgGenerateDriver False + cgPerformRTCs True + cgAddDecl ["int main(void) {" + , " return regexCharacterTable(0xd800, 0) && !regexCharacterTable('a', 0)" + , " && regexCharacterTable('a', 1) && !regexCharacterTable('b', 1)" + , " && regexCharacterTable('b', 2) && !regexCharacterTable('a', 2)" + , " && !regexCharacterTable('a', 255) ? 0 : 1;" + , "}"] + input <- cgInput "input" :: SBVCodeGen SChar + index <- cgInput "index" :: SBVCodeGen SWord8 + cgReturn $ select [input `R.match` r | r <- [R.Range '\xd800' '\xdfff', "a", R.Comp "a"]] sFalse index + renderCgPgmBundle (Just dir) (cfg, bundle) + void $ runC dir ["regexCharacterTable"] + +-- | Disabled regex compilation leaves non-regex generation unchanged and +-- never examines a dead regex operation, including when regex compilation is disabled. +noRegexOverhead :: Assertion +noRegexOverhead = do + baseline <- generated (pure ()) False + disabled <- generated (cgRegexLimits 0 0 0) False + assertEqual "Regex budgets do not alter non-regex C" baseline disabled + dead <- generated (cgRegexLimits 0 0 0) True + assertBool "Dead regex has no runtime code" (not ("sbv_regex_" `isInfixOf` dead)) + where generated :: SBVCodeGen () -> Bool -> IO String + generated limits useDead = do + (_, _, bundle) <- compileToC' "noRegex" $ do + limits + cgGenerateDriver False + cgSetDriverValues [1] + input <- cgInput "input" :: SBVCodeGen SBool + if useDead + then do string <- cgInput "string" :: SBVCodeGen SString + cgReturn (ite sTrue input (string `R.match` R.Power 100 "a")) + else cgReturn input + let source = show bundle + void $ evaluate (length source) + pure source + +-- | Compile generated translation units with strict C warnings and optional +-- sanitizer flags. Regex support must need no nonstandard library or header. +runC :: FilePath -> [String] -> IO String +runC dir components = do + flags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + let executablePath = dir "regex-test" + (status, _, errors) <- readProcessWithExitCode "cc" (["-std=c11", "-Wall", "-Wextra", "-Werror", "-O2"] ++ flags + ++ [dir component ++ ".c" | component <- components] + ++ ["-o", executablePath]) "" + assertEqual errors ExitSuccess status + (runStatus, outputText, runError) <- readProcessWithExitCode executablePath [] "" + assertEqual runError ExitSuccess runStatus + pure outputText diff --git a/SBVTestSuite/TestSuite/CodeGeneration/ScalarSafety.hs b/SBVTestSuite/TestSuite/CodeGeneration/ScalarSafety.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/CodeGeneration/ScalarSafety.hs @@ -0,0 +1,215 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.CodeGeneration.ScalarSafety +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Executed regressions for diagnostic escaping, mapped real flooring, and +-- incremental C builds. +----------------------------------------------------------------------------- + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.CodeGeneration.ScalarSafety (tests, testsWith) where + +import Control.Monad (void) +import Data.List (isInfixOf) +import System.Environment (lookupEnv) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertBool, assertEqual) + +import Data.SBV.Tools.CodeGen +import qualified Data.SBV.Tools.CodeGen.Legacy as Legacy +import Utils.SBVTestFramework + +-- | Generate a standalone function or a single-component static library. +type Generator = FilePath -> Bool -> SBVCodeGen () -> IO () + +-- | Exercise both public backends with the same scalar safety matrix. +tests :: TestTree +tests = testGroup "CodeGeneration.ScalarSafety" + [ testsWith "current" $ \dir library program -> + if library + then void $ compileToCLib (Just dir) "scalarLibrary" [("scalarChecks", program)] + else compileToC (Just dir) "scalarChecks" program + , testsWith "legacy" $ \dir library program -> + if library + then void $ Legacy.compileToCLib (Just dir) "scalarLibrary" [("scalarChecks", program)] + else Legacy.compileToC (Just dir) "scalarChecks" program + ] + +-- | Reuse the same strict-warning, optimization, and sanitizer matrix for a +-- compatibility backend. Independent C callers supply fractional inputs and +-- check against mathematical integer results rather than C casts. +testsWith :: String -> Generator -> TestTree +testsWith groupName generate = testGroup groupName $ + [ testGroup (form ++ "/" ++ optimization) + [ testGroup "floor" + [ testCase (show realType ++ "/" ++ show width) $ withSystemTempDirectory "sbv-c-real-floor" $ \dir -> do + executablePath <- compileCaller generate dir library optimization (floorCaller realType width) $ do + cgSRealType realType + cgIntegerSize width + value <- cgInput "value" :: SBVCodeGen SReal + cgReturn (sRealToSIntegerFloor value) + makefile <- readFile (dir "Makefile") + assertBool "Flooring must link the standard math library" ("-lm" `isInfixOf` makefile) + runSuccessfully executablePath + mapM_ (checkNonFinite executablePath) ["nan", "inf", "negative-inf"] + | realType <- [CgFloat, CgDouble, CgLongDouble] + , width <- [8, 16, 32, 64] + ] + , testGroup "labels" + [ testCase sampleName $ withSystemTempDirectory "sbv-c-scalar-label" $ \dir -> do + executablePath <- compileCaller generate dir library optimization labelCaller $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (label message value) + runSuccessfully executablePath + | (sampleName, message) <- labelSamples + ] + , testCase "assertion message" $ withSystemTempDirectory "sbv-c-assertion-text" $ \dir -> do + let message = "must be \"small\"; %n %s 100% */\n/* \\\n??/ \955" + executablePath <- compileCaller generate dir library optimization labelCaller $ do + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn (sAssert Nothing message (value .< 5) value) + (runExit, _, runError) <- readProcessWithExitCode executablePath [] "" + assertBool "The failed assertion must terminate the caller" (runExit /= ExitSuccess) + assertBool runError (("ASSERTION FAILED: " ++ message) `isInfixOf` runError) + ] + | (form, library) <- [("program", False), ("library", True)] + , optimization <- ["-O0", "-O2 -fsanitize=undefined,float-cast-overflow -fno-sanitize-recover=all"] + ] + ++ [testCase "driver header dependency" (driverHeaderDependency generate)] + +-- | Header changes must invalidate the separately compiled standalone driver. +-- Make's hypothetical-newer prerequisite avoids sleeps and timestamp races. +driverHeaderDependency :: Generator -> Assertion +driverHeaderDependency generate = withSystemTempDirectory "sbv-c-driver-header" $ \dir -> do + generate dir False $ do + cgOverwriteFiles True + cgSetDriverValues [41] + value <- cgInput "value" :: SBVCodeGen SWord8 + cgReturn value + extraFlags <- maybe "" (" " ++) <$> lookupEnv "SBV_C_TEST_FLAGS" + let target = "scalarChecks_driver.o" + (makeExit, _, makeError) <- readProcessWithExitCode "make" + ["-C", dir, target, "CCFLAGS=-std=c11 -Wall -Wextra -Werror -O2" ++ extraFlags] "" + assertEqual makeError ExitSuccess makeExit + (freshExit, _, freshError) <- readProcessWithExitCode "make" ["-C", dir, "-q", target] "" + assertEqual freshError ExitSuccess freshExit + (staleExit, _, staleError) <- readProcessWithExitCode "make" ["-C", dir, "-q", "-W", "scalarChecks.h", target] "" + assertEqual ("Changing the header must invalidate the driver object: " ++ staleError) (ExitFailure 1) staleExit + +-- | Text must remain a semantic no-op even when it resembles C statements or +-- affects preprocessing. Embedded NUL/control bytes must also compile cleanly. +labelSamples :: [(String, String)] +labelSamples = [ ("statements", "*/; abort(); /*") + , ("preprocessing", "nested /* comment; \\\n??/\n*/") + , ("control characters", "Unicode \955, NUL \0, CR \r, tab \t and control \SOH") + ] + +-- | Generate and build the selected artifact, then link an independent caller. +-- Additional local sanitizer flags apply to both the generated C and caller. +compileCaller :: Generator -> FilePath -> Bool -> String -> String -> SBVCodeGen () -> IO FilePath +compileCaller generate dir library optimization source program = do + generate dir library $ do + cgOverwriteFiles True + cgGenerateDriver False + program + extraFlags <- maybe [] words <$> lookupEnv "SBV_C_TEST_FLAGS" + let flags = ["-std=c11", "-Wall", "-Wextra", "-Werror", "-trigraphs"] ++ words optimization ++ extraFlags + artifact = if library then "scalarLibrary.a" else "scalarChecks.o" + header = if library then "scalarLibrary.h" else "scalarChecks.h" + executablePath = dir "caller" + (makeExit, _, makeError) <- readProcessWithExitCode "make" ["-C", dir, artifact, "CCFLAGS=" ++ unwords flags] "" + assertEqual makeError ExitSuccess makeExit + writeFile (dir "caller.c") ("#include \"" ++ header ++ "\"\n" ++ source) + (ccExit, _, ccError) <- readProcessWithExitCode "cc" (flags ++ [dir "caller.c", dir artifact, "-lm", "-o", executablePath]) "" + assertEqual ccError ExitSuccess ccExit + pure executablePath + +-- | Require successful execution, reporting captured diagnostics on failure. +runSuccessfully :: FilePath -> Assertion +runSuccessfully executablePath = do + (runExit, _, runError) <- readProcessWithExitCode executablePath [] "" + assertEqual runError ExitSuccess runExit + +-- | Non-finite mapped real inputs must fail explicitly before an integer cast. +checkNonFinite :: FilePath -> String -> Assertion +checkNonFinite executablePath sample = do + (runExit, _, runError) <- readProcessWithExitCode executablePath [sample] "" + assertBool "Non-finite real flooring must terminate the caller" (runExit /= ExitSuccess) + assertBool runError ("Cannot floor a non-finite mapped SReal" `isInfixOf` runError) + assertBool runError (not ("runtime error:" `isInfixOf` runError)) + +-- | A successful label is observationally identical to its scalar argument. +labelCaller :: String +labelCaller = unlines ["#include ", "int main(void) { assert(scalarChecks(7) == 7); return 0; }"] + +-- | Supply exact binary fractions, signed boundaries, large finite values, +-- and subnormals. Precision-dependent boundary cases run only when the actual +-- C real representation can distinguish the adjacent integers. +floorCaller :: CgSRealType -> Int -> String +floorCaller realType width = unlines $ + [ "#include " + , "#include " + , "#define REAL_MANT_DIG " ++ floatMacro "MANT_DIG" + , "int main(int argc, char **argv)" + , "{" + , " if (argc > 1) {" + , " SReal value = argv[1][0] == 'n' ? (argv[1][1] == 'a' ? (SReal) NAN : (SReal) -INFINITY) : (SReal) INFINITY;" + , " (void) scalarChecks(value); return 0;" + , " }" + ] + ++ [check input (floor value) | (input, value) <- samples] + ++ [ "#if REAL_MANT_DIG >= 32" + , check "0x7fffffffp0L" (2 ^ (31 :: Int) - 1) + , "#endif" + , "#if REAL_MANT_DIG >= 64" + , check "0xffffffffffffffffp0L" (2 ^ (64 :: Int) - 1) + , check "-0x8000000000000001p0L" (negate (2 ^ (63 :: Int) + 1)) + , "#endif" + , check (floatMacro "TRUE_MIN") 0 + , check ("-" ++ floatMacro "TRUE_MIN") (-1) + , "#if " ++ floatMacro "MAX_EXP" ++ " - REAL_MANT_DIG >= 64" + , check (floatMacro "MAX") 0 + , check ("-" ++ floatMacro "MAX") 0 + , "#endif" + , " return 0;" + , "}" + ] + where floatMacro suffix = case realType of + CgFloat -> "FLT_" ++ suffix + CgDouble -> "DBL_" ++ suffix + CgLongDouble -> "LDBL_" ++ suffix + + check :: String -> Integer -> String + check input expected = " assert(scalarChecks((SReal) (" ++ input ++ ")) == (SInteger) " ++ signedLiteral (wrap expected) ++ ");" + wrap value = let modulus = 2 ^ width + bits = value `mod` modulus + in if bits >= modulus `div` 2 then bits - modulus else bits + signedLiteral value + | value == negate (2 ^ (63 :: Int)) = "(-INT64_C(9223372036854775807) - INT64_C(1))" + | True = "INT64_C(" ++ show value ++ ")" + +-- | Values exactly representable even by binary32. Integer expectations use +-- arbitrary-precision Haskell arithmetic, independently of the C helper. +samples :: [(String, Rational)] +samples = [ ("0.0L", 0), ("-0.0L", 0) + , ("2.5L", 5 % 2), ("-2.5L", -(5 % 2)) + , ("0.5L", 1 % 2), ("-0.5L", -(1 % 2)) + , ("127.75L", 511 % 4), ("-128.25L", -(513 % 4)) + , ("255.75L", 1023 % 4), ("-256.25L", -(1025 % 4)) + , ("65535.75L", 262143 % 4), ("-65536.25L", -(262145 % 4)) + , ("0x1p31L", 2 ^ (31 :: Int)), ("-0x1p31L", negate (2 ^ (31 :: Int))) + , ("0x1p63L", 2 ^ (63 :: Int)), ("-0x1p63L", negate (2 ^ (63 :: Int))) + , ("0x1p64L", 2 ^ (64 :: Int)), ("-0x1p64L", negate (2 ^ (64 :: Int))) + , ("0x1p100L", 2 ^ (100 :: Int)), ("-0x1p100L", negate (2 ^ (100 :: Int))) + , ("(0x1p63L + 0x1p40L)", 2 ^ (63 :: Int) + 2 ^ (40 :: Int)) + , ("(0x1p64L - 0x1p40L)", 2 ^ (64 :: Int) - 2 ^ (40 :: Int)) + , ("(0x1p40L + 0x1p20L)", 2 ^ (40 :: Int) + 2 ^ (20 :: Int)) + ] diff --git a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr --- a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase17.stderr @@ -15,8 +15,8 @@ (isLet e ==> (e .== e =: qed))] PCase17.hs:18:14: error: [GHC-83865] " Couldn't match expected type: Proof SBool - with actual type: sbv-14.7:Data.SBV.TP.TP.TPProofGen - (SBV Bool) [sbv-14.7:Data.SBV.TP.TP.Helper] () + with actual type: sbv-14.8:Data.SBV.TP.TP.TPProofGen + (SBV Bool) [sbv-14.8:Data.SBV.TP.TP.Helper] () " In the expression: cases [(isZero e ==> (e .== e =: qed)), (isNum e ==> (e .== e =: qed)), diff --git a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr --- a/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/PCase/PCase38.stderr @@ -15,8 +15,8 @@ (isLet e ==> undefined)] PCase38.hs:12:14: error: [GHC-83865] " Couldn't match expected type: Proof SBool - with actual type: sbv-14.7:Data.SBV.TP.TP.TPProofGen - a0 [sbv-14.7:Data.SBV.TP.TP.Helper] () + with actual type: sbv-14.8:Data.SBV.TP.TP.TPProofGen + a0 [sbv-14.8:Data.SBV.TP.TP.Helper] () " In the expression: cases [(isZero e ==> undefined), (isNum e ==> undefined), diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase101.stderr @@ -28,4 +28,4 @@ ((\ _ -> 1) (Data.SBV.Maybe.getJust_1 m)) (ite (Data.SBV.Maybe.isNothing m) 0 - (symWithKind "unmatched_sCase_Maybe_6989586621679035057"))) + (symWithKind "unmatched_sCase_Maybe_6989586621679035188"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase59.stderr @@ -24,4 +24,4 @@ ((\ _ -> Data.SBV.Either.isRight (Data.SBV.Maybe.getJust_1 m)) (Data.SBV.Maybe.getJust_1 m))) ((\ _ -> 1) (Data.SBV.Maybe.getJust_1 m)) - (symWithKind "unmatched_sCase_Maybe_6989586621679035057"))) + (symWithKind "unmatched_sCase_Maybe_6989586621679035188"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase66.stderr @@ -30,4 +30,4 @@ (ite (Data.SBV.Either.isRight e) ((\ _ -> 1) (Data.SBV.Either.getRight_1 e)) - (symWithKind "unmatched_sCase_Either_6989586621679035019"))) + (symWithKind "unmatched_sCase_Either_6989586621679035150"))) diff --git a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr --- a/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr +++ b/SBVTestSuite/TestSuite/CompileTests/SCase/SCase89.stderr @@ -40,4 +40,4 @@ (isVar e) ((\ _ -> 1) (getVar_1 e)) (ite (isLet e) ((\ _ _ _ -> 3) (getLet_1 e) (getLet_2 e) (getLet_3 e)) - (symWithKind "unmatched_sCase_Expr_6989586621679080602")))))) + (symWithKind "unmatched_sCase_Expr_6989586621679080842")))))) diff --git a/SBVTestSuite/TestSuite/Crypto/AES.hs b/SBVTestSuite/TestSuite/Crypto/AES.hs --- a/SBVTestSuite/TestSuite/Crypto/AES.hs +++ b/SBVTestSuite/TestSuite/Crypto/AES.hs @@ -11,11 +11,22 @@ {-# OPTIONS_GHC -Wall -Werror #-} +{-# LANGUAGE DataKinds #-} + module TestSuite.Crypto.AES(tests) where +import Data.List (intercalate) +import System.Exit (ExitCode(..)) +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) +import System.Process (readProcessWithExitCode) +import Test.Tasty.HUnit (assertEqual) + import Data.SBV.Internals +import Data.SBV.Tools.CodeGen (compileToC, compileToCLib) import Documentation.SBV.Examples.Crypto.AES +import Utils.CCodeGen (generatedMakeOptions) import Utils.SBVTestFramework -- Test suite @@ -24,6 +35,10 @@ goldenVsStringShow "aes128Enc" $ thd <$> compileToC' "aes128Enc" (aes128EncDec True) , goldenVsStringShow "aes128Dec" $ thd <$> compileToC' "aes128Dec" (aes128EncDec False) , goldenVsStringShow "aes128Lib" $ thd <$> compileToCLib' "aes128Lib" aes128Comps + , testCase "generated standalone encryption" standaloneEncryption + , testCase "generated AES128 library" $ libraryVector 128 aes128Key aes128CT + , testCase "generated AES192 library" $ libraryVector 192 aes192Key aes192CT + , testCase "generated AES256 library" $ libraryVector 256 aes256Key aes256CT ] where aes128EncDec d = do pt <- cgInputArr 4 "pt" key <- cgInputArr 4 "key" @@ -35,3 +50,73 @@ aes128Comps = [(f, setVals c) | (f, _, c) <- aesLibComponents 128] setVals c = cgSetDriverValues (repeat 0) >> c thd (_, _, r) = r + +-- | Exercise the exact code-generation action shown in the documentation. +standaloneEncryption :: Assertion +standaloneEncryption = withSystemTempDirectory "sbv-aes-block" $ \dir -> do + compileToC (Just dir) "aes128BlockEncrypt" (aes128BlockEncrypt >> cgOverwriteFiles True) + runCaller dir "aes128BlockEncrypt" "aes128BlockEncrypt.o" + [ cArray "pt" commonPT + , cArray "key" aes128Key + , cArray "expected" aes128CT + , "SWord32 ct[4];" + , "aes128BlockEncrypt(pt, key, ct);" + , "assert(memcmp(ct, expected, sizeof expected) == 0);" + ] + +-- | Compose the generated key-schedule and block functions in C, checking +-- encryption and both decryption paths against the standard's test vectors. +-- Using an independent caller ensures that the key schedules are computed +-- by generated C, rather than supplied as precomputed Haskell driver values. +libraryVector :: Int -> Key -> [SWord 32] -> Assertion +libraryVector size key ciphertext = withSystemTempDirectory "sbv-aes-library" $ \dir -> do + _ <- compileToCLib (Just dir) libraryName + [(functionName, cgSetDriverValues values >> program >> cgOverwriteFiles True) + | (functionName, values, program) <- aesLibComponents size] + runCaller dir libraryName (libraryName ++ ".a") + [ cArray "pt" commonPT + , cArray "key" key + , cArray "expected" ciphertext + -- The public inverse-schedule wrapper reverses each group of key words. + , cArray "invKey" (concatMap reverse (chop4 (extractFinalKey key))) + , "SWord32 encKS[" ++ show expandedWords ++ "], decKS[" ++ show expandedWords ++ "], invKS[" ++ show expandedWords ++ "];" + , "SWord32 ct[4], recovered[4];" + , prefix ++ "KeySchedule(key, encKS, decKS);" + , prefix ++ "BlockEncrypt(pt, encKS, ct);" + , "assert(memcmp(ct, expected, sizeof expected) == 0);" + , prefix ++ "BlockDecrypt(expected, decKS, recovered);" + , "assert(memcmp(recovered, pt, sizeof pt) == 0);" + , prefix ++ "InvKeySchedule(invKey, invKS);" + , prefix ++ "OTFDecrypt(expected, invKS, recovered);" + , "assert(memcmp(recovered, pt, sizeof pt) == 0);" + ] + where prefix = "aes" ++ show size + libraryName = prefix ++ "Lib" + expandedWords = 4 * (size `div` 32 + 7) + +-- | Render the existing concrete test vectors as C arrays. +cArray :: String -> [SWord 32] -> String +cArray arrayName values = "const SWord32 " ++ arrayName ++ "[] = {" + ++ intercalate ", " ["0x" ++ hex8 value ++ "UL" | value <- values] ++ "};" + +-- | Build and run a caller using the generated Makefile's compiler and flags. +-- Keep assertions enabled, and preserve optional sanitizer instrumentation. +runCaller :: FilePath -> String -> FilePath -> [String] -> Assertion +runCaller dir header dependency body = do + writeFile (dir "caller.c") $ unlines $ + [ "#undef NDEBUG" + , "#include " + , "#include " + , "#include \"" ++ header ++ ".h\"" + , "int main(void) {" + ] ++ map (" " ++) body ++ [" return 0;", "}"] + writeFile (dir "caller.mk") $ unlines + [ "caller: caller.c " ++ header ++ ".h " ++ dependency + , "\t${CC} ${CCFLAGS} caller.c " ++ dependency ++ " ${LDFLAGS} ${SBV_LIBS} -o $@" + ] + makeOptions <- generatedMakeOptions dir + (buildExit, buildOutput, buildError) <- readProcessWithExitCode "make" + (["-C", dir, "caller"] ++ makeOptions) "" + assertEqual (buildOutput ++ buildError) ExitSuccess buildExit + (runExit, runOutput, runError) <- readProcessWithExitCode (dir "caller") [] "" + assertEqual (runOutput ++ runError) ExitSuccess runExit diff --git a/SBVTestSuite/TestSuite/Crypto/SHA.hs b/SBVTestSuite/TestSuite/Crypto/SHA.hs --- a/SBVTestSuite/TestSuite/Crypto/SHA.hs +++ b/SBVTestSuite/TestSuite/Crypto/SHA.hs @@ -20,7 +20,7 @@ -- Test suite tests :: TestTree -tests = testGroup "Crypto.AES" [ +tests = testGroup "Crypto.SHA" [ goldenVsStringShow "sha256HashBlock" $ (\(_, _, r) -> r) <$> compileToC' "sha256HashBlock" c ] where c = do let algorithm = sha256P diff --git a/SBVTestSuite/TestSuite/Queries/Lists.hs b/SBVTestSuite/TestSuite/Queries/Lists.hs --- a/SBVTestSuite/TestSuite/Queries/Lists.hs +++ b/SBVTestSuite/TestSuite/Queries/Lists.hs @@ -12,6 +12,7 @@ {-# LANGUAGE OverloadedLists #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeApplications #-} {-# OPTIONS_GHC -Wall -Werror #-} @@ -19,20 +20,45 @@ import Data.SBV import Data.SBV.Control +import qualified Data.SBV.List as L +import qualified Data.SBV.Tuple as T +import Data.List (isInfixOf) + +import qualified Control.Exception as C + import Utils.SBVTestFramework --- Test suite +-- | Test suite. tests :: TestTree tests = testGroup "Basics.QueryLists" [ goldenCapturedIO "query_Lists1" $ testQuery queryLists1 + , testCase "query_Lists2" $ do result <- runSMT queryLists2 + result == 3 @? "Expected the filtered value 3, received: " ++ show result + , testCase "query_function_dependency" $ do result <- runSMT queryFunctionDependency + result == 11 @? "Expected the dependent function value 11, received: " ++ show result + , testCase "query_function_reuse" $ do result <- runSMT queryFunctionReuse + result == (6, 7) @? "Expected the reused function values (6, 7), received: " ++ show result + , testCase "query_function_body_kind" $ do result <- runSMT queryFunctionBodyKind + result == 11 @? "Expected the tuple-backed function value 11, received: " ++ show result + , testCase "query_function_ui" $ do result <- runSMT queryFunctionUI + result == 11 @? "Expected the helper-backed function value 11, received: " ++ show result + , testCase "query_mutual_functions" $ do result <- runSMT queryMutualFunctions + result @? "Expected the mutually recursive function to return true" + , testCase "query_bad_termination" $ do result <- C.try (runSMT queryBadTermination) + case result of + Left (e :: C.SomeException) -> "does not strictly decrease" `isInfixOf` show e + @? "Expected a termination-check failure, received: " ++ show e + Right value -> assertFailure $ "Expected a termination-check failure, received: " ++ show value ] +-- | Run a query with its verbose transcript redirected to the given file. testQuery :: Show a => Symbolic a -> FilePath -> IO () testQuery t rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} t appendFile rf ("\nFINAL OUTPUT:\n" ++ show r ++ "\n") +-- | Retrieve a concrete list from a solver query. queryLists1 :: Symbolic [Integer] queryLists1 = do a :: SList Integer <- sList "a" @@ -45,3 +71,85 @@ if av == [1..5] then return av else error $ "Didn't expect this: " ++ show av + +-- | Exercise an SMT function first encountered after entering query mode. +queryLists2 :: Symbolic Integer +queryLists2 = query $ do x <- freshVar @Integer "x" + y <- freshVar @[Integer] "y" + constrain $ y .== literal [1 .. 20] + constrain $ x .== L.head (L.filter (.== literal 3) y) + getValue x + +-- | Exercise dependency ordering between SMT functions first encountered in query mode. +queryFunctionDependency :: Symbolic Integer +queryFunctionDependency = query $ do n <- freshVar @Integer "n" + x <- freshVar @Integer "x" + constrain $ n .== 5 + constrain $ x .== outer n + getValue x + where inner :: SInteger -> SInteger + inner = smtFunction "query.inner" (* 2) + + outer :: SInteger -> SInteger + outer = smtFunction "query.outer" ((+ 1) . inner) + +-- | Exercise repeated use of an SMT function after its query-mode definition has been sent. +queryFunctionReuse :: Symbolic (Integer, Integer) +queryFunctionReuse = query $ do n <- freshVar @Integer "n" + x <- freshVar @Integer "x" + y <- freshVar @Integer "y" + constrain $ n .== 5 + constrain $ x .== increment n + constrain $ y .== increment x + (,) <$> getValue x <*> getValue y + where increment :: SInteger -> SInteger + increment = smtFunction "query.increment" (+ 1) + +-- | Exercise a datatype used only inside an SMT function first encountered in query mode. +queryFunctionBodyKind :: Symbolic Integer +queryFunctionBodyKind = query $ do n <- freshVar @Integer "n" + x <- freshVar @Integer "x" + constrain $ n .== 5 + constrain $ x .== pairSum n + getValue x + where pairSum :: SInteger -> SInteger + pairSum = smtFunction "query.pairSum" $ \n -> let p :: STuple Integer Integer + p = T.tuple (n, n + 1) + in T.fst p + T.snd p + +-- | Exercise an uninterpreted helper used by an SMT function first encountered in query mode. +queryFunctionUI :: Symbolic Integer +queryFunctionUI = query $ do n <- freshVar @Integer "n" + x <- freshVar @Integer "x" + constrain $ n .== 5 + constrain $ x .== applyHelper n + constrain $ helper n .== 10 + getValue x + where helper :: SInteger -> SInteger + helper = uninterpret "query.helper" + + applyHelper :: SInteger -> SInteger + applyHelper = smtFunction "query.applyHelper" ((+ 1) . helper) + +-- | Exercise mutually recursive SMT functions first encountered in query mode. +queryMutualFunctions :: Symbolic Bool +queryMutualFunctions = query $ do n <- freshVar @Bool "n" + x <- freshVar @Bool "x" + constrain n + constrain $ x .== isEven n + getValue x + where isEven :: SBool -> SBool + isEven = smtFunctionNoTermination "query.even" $ \b -> ite b (isOdd sFalse) sFalse + + isOdd :: SBool -> SBool + isOdd = smtFunctionNoTermination "query.odd" $ \b -> ite b (isEven sFalse) sTrue + +-- | Ensure query-mode definitions still undergo termination checking before reaching the solver. +queryBadTermination :: Symbolic Integer +queryBadTermination = query $ do n <- freshVar @Integer "n" + x <- freshVar @Integer "x" + constrain $ n .== 5 + constrain $ x .== diverges n + getValue x + where diverges :: SInteger -> SInteger + diverges = smtFunctionWithMeasure "query.diverges" (abs, []) $ \n -> ite (n .<= 0) 0 (diverges (n + 1)) diff --git a/SBVTestSuite/TestSuite/Queries/Registration.hs b/SBVTestSuite/TestSuite/Queries/Registration.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/TestSuite/Queries/Registration.hs @@ -0,0 +1,291 @@ +----------------------------------------------------------------------------- +-- | +-- Module : TestSuite.Queries.Registration +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Registration and function discovery during incremental solver interaction. +----------------------------------------------------------------------------- + +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE TypeApplications #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module TestSuite.Queries.Registration (tests) where + +import Control.Monad (when) +import Control.Monad.Reader (ReaderT(..), runReaderT) +import qualified Control.Exception as C +import Data.List (isInfixOf, isPrefixOf) +import Data.Maybe (fromMaybe) +import Data.Proxy +import System.FilePath (()) +import System.IO.Temp (withSystemTempDirectory) + +import Data.SBV.Control +import Data.SBV.Internals (QueryT(..), SMTModel(..), SExpr(..), parseSExpr, formatFunctionResponse) +import Utils.SBVTestFramework + +-- | A rational field must be declared before the containing datatype. +newtype RationalBox = RationalBox Rational deriving (Eq, Show) + +-- | An empty datatype represents an uninterpreted solver sort. +data RegistrationSort + +mkSymbolic [''RationalBox, ''RegistrationSort] + +tests :: TestTree +tests = testGroup "Queries.Registration" + [ testGroup "rationals" + [ rationalTest "automatic" False False + , rationalTest "registered before query" True False + , rationalTest "registered inside query" False True + , rationalTest "registered in both phases" True True + ] + , testCase "rational function first used in query" $ do + let half :: SInteger -> SRational + half = smtFunction "registration.half" $ \n -> ite (n .== 1) (1/2) (2/3) + result <- runSMT $ query $ do + n <- freshVar @Integer "n" + constrain $ n .== 1 + getValue (half n) + result == 1 % 2 @? "Expected a rational result from a query-mode definition" + , testCase "nested rational types first used in query" $ do + result <- runSMT $ query $ do + x <- freshVar @(RationalBox, [Rational]) "x" + let expected = (RationalBox (1 % 2), [2 % 3]) + constrain $ x .== literal expected + getValue x + result == (RationalBox (1 % 2), [2 % 3]) @? "Expected nested rational values" + , testCase "explicit nested type registration inside query" $ do + result <- runSMT $ query $ do + registerType (Proxy @(RationalBox, [Rational])) + registerType (Proxy @(RationalBox, [Rational])) + ensureSat + x <- freshVar @(RationalBox, [Rational]) "x" + constrain $ x .== literal (RationalBox (1 % 2), [2 % 3]) + getValue x + result == (RationalBox (1 % 2), [2 % 3]) @? "Explicit registration must reach the solver" + , testCase "explicit uninterpreted sort registration inside query" $ do + result <- runSMT $ query $ do + registerType (Proxy @RegistrationSort) + registerType (Proxy @RegistrationSort) + ensureSat + x <- freshVar @RegistrationSort "x" + y <- freshVar_ @RegistrationSort + constrain $ x ./= y + checkSat + result == Sat @? "Explicit registration must declare an uninterpreted sort exactly once" + , testCase "quantified function first used in query" $ do + result <- runSMT $ query $ do + let f = uninterpret "registration.quantified" :: SInteger -> SInteger + constrain $ \(Forall (x :: SInteger)) -> f x .== f x + checkSat + result == Sat @? "Quantified uses must register their functions automatically" + , testGroup "function discovery" $ map discoveryTests [("z3", z3), ("cvc5", cvc5)] + , fallbackTests + ] + +-- | Discovery must support sorts without concrete defaults and preserve the +-- model produced by checkSatAssuming, including when discovery fails. +discoveryTests :: (String, SMTConfig) -> TestTree +discoveryTests (solverName, cfg) = testGroup solverName + [ testCase "quoted function expression formatting" $ do + let f = uninterpret "|quotedPretty|" :: SInteger -> SInteger + result <- runSMTWith cfg $ do + setupFunctionModels solverName + constrain $ \(Forall x) -> f x .== 3 * x + query $ ensureSat >> getFunction f + case result of + Left (rendered, _) -> do + "quotedPretty " `isPrefixOf` rendered @? "Expected the function name in the formatted interpretation" + not ("fromSMTLib" `isInfixOf` rendered) @? "Expected the lambda to be formatted despite optional name quoting" + Right{} -> assertFailure "Expected an expression for the nonconstant integer function" + , testGroup "registered calling convention" + [ testCase (if registeredCurried then "curried" else "uncurried") $ do + let curried = uninterpret "registeredShape" :: SInteger -> SInteger -> SInteger + uncurried = uninterpret "registeredShape" :: (SInteger, SInteger) -> SInteger + f x y | registeredCurried = curried x y + | True = uncurried (x, y) + result <- runSMTWith cfg $ do + setupFunctionModels solverName + constrain $ \(Forall x) (Forall y) -> f x y .== 3 * x + y + query $ do + ensureSat + if registeredCurried then getFunction uncurried else getFunction curried + case result of + Left (_, (isCurried, _, _)) -> isCurried == registeredCurried @? "Reading through an alias must preserve the registered display convention" + Right{} -> assertFailure "Expected an expression for the nonconstant integer function" + | registeredCurried <- [True, False] + ] + , testCase "uninterpreted argument sort" $ do + let f = uninterpret "discovery.sort" :: SBV RegistrationSort -> SInteger + result <- runSMTWith cfg $ do + registerFunction f + query $ ensureSat >> getFunction f + case result of + Right{} -> pure () + Left{} -> assertFailure "Expected an interpretation of the unused function" + , testCase "uncurried function with an uninterpreted argument sort" $ do + let f = uninterpret "discovery.uncurried" :: (SBV RegistrationSort, SBool) -> SInteger + result <- runSMTWith cfg $ do + registerFunction f + query $ ensureSat >> getFunction f + case result of + Right{} -> pure () + Left{} -> assertFailure "Expected an interpretation of the unused uncurried function" + , testCase "function first used in a query" $ do + let f = uninterpret "discovery.used" :: SInteger -> SInteger + result <- runSMTWith cfg $ query $ do + constrain $ f 5 .== 17 + ensureSat + getFunction f + case result of + Right (table, def) -> fromMaybe def (lookup 5 table) == 17 @? "The interpretation must satisfy the constraint" + Left{} -> assertFailure "Expected a value association for the constrained function" + , testGroup "quoted names" + [ testCase nm $ withSystemTempDirectory "sbv-quoted-function" $ \dir -> do + let logFile = dir "solver.smt2" + f = uninterpret nm :: SInteger -> SInteger + result <- runSMTWith cfg{transcript = Just logFile} $ do + constrain $ f 5 .== 17 + query $ ensureSat >> getFunction f + case result of + Right (table, def) -> fromMaybe def (lookup 5 table) == 17 @? "The quoted function must satisfy its constraint" + Left{} -> assertFailure "Expected a value association for the quoted function" + logText <- readFile logFile + ("(get-value (" ++ nm ++ "))") `isInfixOf` logText @? "Expected an explicitly quoted function lookup" + | nm <- ["|quotedFunction|", "|function with spaces|"] + ] + , testGroup "quoted names in models" + [ testCase (nm ++ if constrained then " constrained" else " unused") $ do + let f = uninterpret nm :: SInteger -> SInteger + model <- runSMTWith cfg $ do + if constrained then constrain $ f 5 .== 17 else registerFunction f + query $ ensureSat >> getModel + case modelUIFuns model of + [(modelName, (_, _, Right (table, def)))] -> do + modelName == filter (/= '|') nm @? "Expected the quoted function in the model" + when constrained $ do + let values = [(map (fromCV @Integer) args, fromCV @Integer value) | (args, value) <- table] + fromMaybe (fromCV @Integer def) (lookup [5] values) == 17 @? "The model interpretation must satisfy the constraint" + other -> assertFailure $ "Expected a function interpretation in the model, received: " ++ show other + | nm <- ["|quotedFunction|", "|function with spaces|"], constrained <- [False, True] + ] + , testCase "discovery preserves the current model" $ + withSystemTempDirectory "sbv-discovery" $ \dir -> do + let logFile = dir "solver.smt2" + f = uninterpret "discovery.binary" :: SBool -> SBool -> SBool + runSMTWith cfg{transcript = Just logFile} $ do + x <- sBool "x" + registerFunction f + query $ do + cs <- checkSatAssuming [x] + io $ cs == Sat @? "Expected satisfiable assumptions" + before <- getValue x + _ <- getFunction f + _ <- getFunction f + after <- getValue x + io $ before && after @? "Function discovery must preserve the assumed model" + logText <- readFile logFile + let commands = filter ("(" `isPrefixOf`) $ lines logText + afterCheck = drop 1 $ dropWhile (not . ("(check-sat" `isPrefixOf`)) commands + length (filter ("(check-sat-assuming" `isPrefixOf`) commands) == 1 + @? "Expected exactly one check with assumptions in the transcript" + all (\cmd -> not $ any (`isPrefixOf` cmd) ["(declare-", "(define-", "(assert", "(check-sat"]) afterCheck + @? "Model inspection must not emit declarations, assertions, or another satisfiability check" + , testCase "failed discovery leaves the query usable" $ do + let f = uninterpret "discovery.missing" :: SInteger -> SInteger + wrongType = uninterpret "discovery.existing" :: SBool -> SBool + existing = uninterpret "discovery.existing" :: SInteger -> SInteger + runSMTWith cfg $ do + x <- sBool "x" + registerFunction existing + query $ do + cs <- checkSatAssuming [x] + io $ cs == Sat @? "Expected satisfiable assumptions" + expectQueryError "is not registered in this context" $ getFunction f + expectQueryError "used at incompatible SMT signatures" $ getFunction wrongType + expectQueryError "Must be called on an uninterpreted function" $ getFunction ((+1) :: SInteger -> SInteger) + value <- getValue x + io $ value @? "Failed discovery must preserve the assumed model" + -- A failed lookup must not poison the registry and prevent a later + -- ordinary use from declaring the function to the solver. + constrain $ f 0 .== 42 + ensureSat + result <- getValue (f 0) + io $ result == 42 @? "The function must remain usable after failed discovery" + ] + +-- | CVC5 needs first-order ALL (rather than SBV's default HO_ALL) and macro +-- expansion to produce models of these quantified function definitions. +setupFunctionModels :: String -> Symbolic () +setupFunctionModels solverName = when (solverName == "cvc5") $ do + setLogic $ CustomLogic "ALL" + setOption $ OptionKeyword ":macros-quant" ["true"] + setOption $ OptionKeyword ":macros-quant-mode" ["all"] + +-- | Assert the positive raw fallback exactly, including whitespace and literal +-- spelling. Let-wrapped lambdas and as-array values bypass lambda formatting. +fallbackTests :: TestTree +fallbackTests = testGroup "raw function rendering" + [ testGroup quotingCase + [ testCase bodyName $ do + let response = " \n ( ( " ++ actual ++ " ; before value )\n " ++ body ++ " ) ; after value\n ) \n" + case parseSExpr response of + Right (EApp [EApp [ECon _, value]]) -> do + let rendered = formatFunctionResponse value response wanted True Nothing + rendered == wanted ++ " = fromSMTLib " ++ body @? "Raw fallback changed the function value: " ++ show rendered + other -> assertFailure $ "Expected a function response, received: " ++ show other + | (bodyName, body) <- + [ ("as-array", "(_ as-array helper)") + , ("let-wrapped lambda", "(let ((offset 3))\n (lambda ((x!1 Int)) (+ offset (* 2 x!1))))") + , ("comments and spacing", "(let ((offset 3)) ; keep this ) comment\n\t(lambda ((x!1 Int)) (+ offset x!1)))") + , ("quoted literals", "(let ((|text )| \"he said \"\"hi\"\"; )))\")) (lambda ((x String)) |text )|))") + , ("bit-vector spelling", "(let ((mask #x0f) (wide (_ bv7 16))) (lambda ((x (_ BitVec 8))) (bvand x mask)))") + ] + ] + | (quotingCase, wanted, actual) <- + [ ("unquoted", "f", "f") + , ("solver unquotes", "|f|", "f") + , ("solver quotes", "f", "|f|") + , ("quoted", "|f|", "|f|") + , ("spaces in name", "|name with spaces|", "|name with spaces|") + ] + ] + +-- | Catch an error inside the same query so subsequent solver interactions +-- verify that discovery has not corrupted either side of the connection. +expectQueryError :: String -> Query a -> Query () +expectQueryError expected (QueryT action) = QueryT $ ReaderT $ \st -> do + result <- C.try $ runReaderT action st + case result of + Left (err :: C.ErrorCall) -> expected `isInfixOf` C.displayException err @? "Unexpected diagnostic: " ++ C.displayException err + Right _ -> assertFailure $ "Expected diagnostic containing: " ++ expected + +-- | Exercise both rational equality helpers, repeated declarations, named and +-- unnamed fresh variables, and declarations surviving assertion-stack changes. +rationalTest :: String -> Bool -> Bool -> TestTree +rationalTest testName before inside = testCase testName $ do + result <- runSMT $ do + when before $ registerType (Proxy @Rational) + query $ do + when inside $ do registerType (Proxy @Rational) + registerType (Proxy @Rational) + push 1 + x <- freshVar @Rational "x" + constrain $ x .== 1/2 + first <- getValue x + pop 1 + y <- freshVar_ @Rational + constrain $ y .== 1/3 + constrain $ y ./= 0 + later <- getValue y + pure (first, later) + result == (1 % 2, 1 % 3) @? "Expected rational values across incremental contexts, received: " ++ show result diff --git a/SBVTestSuite/TestSuite/Queries/UISatEx.hs b/SBVTestSuite/TestSuite/Queries/UISatEx.hs --- a/SBVTestSuite/TestSuite/Queries/UISatEx.hs +++ b/SBVTestSuite/TestSuite/Queries/UISatEx.hs @@ -76,7 +76,6 @@ constrain $ q1 (-3) .== 9 constrain $ q1 x .== x+1 - registerFunction q2 -- Not really necessary, but testing it doesn't break anything constrain $ q2 sTrue 3 .== 5 constrain $ q2 sFalse 7 .== 6 constrain $ q2 sFalse 12 .== 3 diff --git a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs --- a/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs +++ b/SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs @@ -59,7 +59,6 @@ p1 :: Symbolic SBool p1 = do constrain $ \(Forall x) -> thingCompare x x constrain $ \(Forall k1) (Forall k2) -> k1 ./= thingMerge k1 k2 - registerFunction thingMerge k1 <- free_ k2 <- free_ return $ k1 .== k2 .=> thingCompare k1 k2 diff --git a/SBVTestSuite/Utils/CCodeGen.hs b/SBVTestSuite/Utils/CCodeGen.hs new file mode 100644 --- /dev/null +++ b/SBVTestSuite/Utils/CCodeGen.hs @@ -0,0 +1,114 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Utils.CCodeGen +-- Copyright : (c) Levent Erkok +-- License : BSD3 +-- Maintainer: erkokl@gmail.com +-- Stability : experimental +-- +-- Shared dependency discovery for generated-C integration tests. +----------------------------------------------------------------------------- + +{-# LANGUAGE ScopedTypeVariables #-} + +{-# OPTIONS_GHC -Wall -Werror #-} + +module Utils.CCodeGen (locateLibBF, generatedMakeOptions) where + +import Control.Exception (IOException, catch) +import Control.Concurrent.MVar (MVar, modifyMVar, newMVar) +import Data.List (isInfixOf, isPrefixOf, isSuffixOf, sort) +import System.Directory (doesDirectoryExist, doesFileExist, listDirectory) +import System.Environment (lookupEnv) +import System.FilePath ((), takeDirectory) +import System.Process (readProcessWithExitCode) +import System.Exit (ExitCode(..)) +import System.IO.Unsafe (unsafePerformIO) + +-- | Locate the header and static archive installed for the Haskell @libBF@ +-- dependency so integration tests exercise the same C implementation. +locateLibBF :: IO (FilePath, FilePath) +locateLibBF = modifyMVar libBFLocation $ \cached -> do + result <- maybe discoverLibBF pure cached + pure (Just result, result) + +-- | Share immutable dependency discovery across parallel integration tests. +{-# NOINLINE libBFLocation #-} +libBFLocation :: MVar (Maybe (FilePath, FilePath)) +libBFLocation = unsafePerformIO (newMVar Nothing) + +-- | Allow explicit installations; otherwise find a matching header/archive +-- pair from one Cabal package, never from different package versions. +discoverLibBF :: IO (FilePath, FilePath) +discoverLibBF = do + includeOverride <- lookupEnv "SBV_C_LIBBF_INCLUDE" + libraryOverride <- lookupEnv "SBV_C_LIBBF_LIBRARY" + case (includeOverride, libraryOverride) of + (Just includeDir, Just archive) -> do + headerExists <- doesFileExist (includeDir "libbf.h") + archiveExists <- doesFileExist archive + if headerExists && archiveExists then pure (includeDir, archive) + else fail "SBV_C_LIBBF_INCLUDE/SBV_C_LIBBF_LIBRARY must name an installed libbf.h and library." + (Nothing, Nothing) -> discoverStoredLibBF + _ -> fail "Set both SBV_C_LIBBF_INCLUDE and SBV_C_LIBBF_LIBRARY, or neither." + +-- | Discover the installed Haskell dependency's bundled C library. +discoverStoredLibBF :: IO (FilePath, FilePath) +discoverStoredLibBF = do + (pathExit, pathOutput, pathError) <- readProcessWithExitCode "cabal" ["path"] "" + case pathExit of + ExitSuccess -> pure () + _ -> fail $ "Unable to query Cabal store: " ++ pathError + let storePrefix = "compiler-store-path: " + stores = [drop (length storePrefix) line | line <- lines pathOutput, storePrefix `isInfixOf` line] + store <- case stores of + path:_ -> pure path + [] -> fail $ "Unable to find Cabal store: " ++ pathError + packages <- listDirectory store + let libBFDirs = [store entry | entry <- sort packages, "lbBF-" `isPrefixOf` entry] + firstSuccessful [do header <- findInstalledFile path "libbf.h" + archive <- findInstalledFile path "libHSlbBF" + pure (takeDirectory header, archive) + | path <- libBFDirs] + +-- | Recursively find an installed file by exact name or filename prefix. +findInstalledFile :: FilePath -> String -> IO FilePath +findInstalledFile root sought = do + entries <- listDirectory root + search entries + where search [] = fail $ "Unable to find " ++ sought ++ " below " ++ root + search (entry:rest) = do + let path = root entry + isDir <- doesDirectoryExist path + isFile <- doesFileExist path + if isFile && matches entry + then pure path + else if isDir + then findInstalledFile path sought `catchIO` search rest + else search rest + + matches entry + | sought == "libHSlbBF" = sought `isPrefixOf` entry && ".a" `isSuffixOf` entry + | True = entry == sought + +-- | Return the first successful filesystem search result. +firstSuccessful :: [IO a] -> IO a +firstSuccessful = foldr catchIO (fail "Unable to locate the installed libBF package") + +-- | Recover from an expected filesystem-search failure with another search. +catchIO :: IO a -> IO a -> IO a +catchIO action fallback = action `catch` \(_ :: IOException) -> fallback + +-- | Build generated Makefiles with strict warnings, resolving LibBF from the +-- Cabal store when needed. Keep compiler overrides and GMP discovery intact. +-- Append @SBV_C_TEST_FLAGS@ to both compilation and linking commands, allowing +-- optimization and sanitizer runs to cover generated programs and library callers. +generatedMakeOptions :: FilePath -> IO [String] +generatedMakeOptions dir = do + makefile <- readFile (dir "Makefile") + extraFlags <- maybe "" (" " ++) <$> lookupEnv "SBV_C_TEST_FLAGS" + let flags = "CCFLAGS=-std=c11 -Wall -Werror -O2" ++ extraFlags + if "-lbf" `isInfixOf` makefile + then do (includeDir, archive) <- locateLibBF + pure [flags ++ " -I\"" ++ includeDir ++ "\"", "SBV_LIBS=\"" ++ archive ++ "\" -lm ${GMP_LIBS}"] + else pure [flags] diff --git a/sbv.cabal b/sbv.cabal --- a/sbv.cabal +++ b/sbv.cabal @@ -1,7 +1,7 @@ Cabal-Version: 2.2 Name : sbv -Version : 14.7 +Version : 14.8 Category : Formal Methods, Theorem Provers, Bit vectors, Symbolic Computation, Math, SMT Synopsis : SMT Based Verification: Symbolic Haskell theorem prover using SMT solving. Description : Express properties about Haskell programs and automatically prove them using SMT @@ -54,6 +54,7 @@ DeriveLift DeriveTraversable DerivingStrategies + EmptyDataDecls ExistentialQuantification FlexibleContexts FlexibleInstances @@ -73,6 +74,7 @@ OverloadedStrings PackageImports ParallelListComp + PatternSynonyms QuantifiedConstraints QuasiQuotes RankNTypes @@ -142,6 +144,7 @@ , Data.SBV.Tools.BVOptimize , Data.SBV.Tools.Induction , Data.SBV.Tools.CodeGen + , Data.SBV.Tools.CodeGen.Legacy , Data.SBV.Tools.GenTest , Data.SBV.Tools.Overflow , Data.SBV.Tools.Polynomial @@ -154,6 +157,7 @@ if flag(compile_examples) Exposed-modules : Documentation.SBV.Examples.ADT.Expr , Documentation.SBV.Examples.ADT.Param + , Documentation.SBV.Examples.ADT.Shapes , Documentation.SBV.Examples.ADT.Types , Documentation.SBV.Examples.BitPrecise.Adders , Documentation.SBV.Examples.BitPrecise.BitTricks @@ -314,6 +318,29 @@ , Data.SBV.Control.Types , Data.SBV.Control.Utils , Data.SBV.Compilers.C + , Data.SBV.Compilers.C.ADT + , Data.SBV.Compilers.C.Arena + , Data.SBV.Compilers.C.Array + , Data.SBV.Compilers.C.BV + , Data.SBV.Compilers.C.FP + , Data.SBV.Compilers.C.Finite + , Data.SBV.Compilers.C.GMP + , Data.SBV.Compilers.C.Legacy + , Data.SBV.Compilers.C.Legacy.Internal + , Data.SBV.Compilers.C.List + , Data.SBV.Compilers.C.Lowering + , Data.SBV.Compilers.C.NonLinear + , Data.SBV.Compilers.C.Backend + , Data.SBV.Compilers.C.PseudoBoolean + , Data.SBV.Compilers.C.Real + , Data.SBV.Compilers.C.RegExp + , Data.SBV.Compilers.C.Set + , Data.SBV.Compilers.C.Syntax + , Data.SBV.Compilers.C.Table + , Data.SBV.Compilers.C.Text + , Data.SBV.Compilers.C.Types + , Data.SBV.Compilers.C.Tuple + , Data.SBV.Compilers.C.Value , Data.SBV.Compilers.CodeGen , Data.SBV.Lambda , Data.SBV.SCase @@ -369,10 +396,12 @@ hs-source-dirs : SBVTestSuite main-is : SBVTest.hs other-modules : Utils.SBVTestFramework + , Utils.CCodeGen , TestSuite.ADT.ADT , TestSuite.ADT.Expr , TestSuite.ADT.MutRec , TestSuite.ADT.PExpr + , TestSuite.ADT.Registration , TestSuite.Arrays.InitVals , TestSuite.Arrays.Memory , TestSuite.Arrays.Query @@ -422,12 +451,21 @@ , TestSuite.BitPrecise.MergeSort , TestSuite.BitPrecise.PrefixSum , TestSuite.CodeGeneration.AddSub + , TestSuite.CodeGeneration.ArbitraryBits + , TestSuite.CodeGeneration.ArbitraryFloats + , TestSuite.CodeGeneration.ArrayCaptures + , TestSuite.CodeGeneration.Boundaries , TestSuite.CodeGeneration.CgTests , TestSuite.CodeGeneration.CRC_USB5 + , TestSuite.CodeGeneration.ExactNumbers , TestSuite.CodeGeneration.Fibonacci , TestSuite.CodeGeneration.Floats , TestSuite.CodeGeneration.GCD , TestSuite.CodeGeneration.PopulationCount + , TestSuite.CodeGeneration.LibraryBuild + , TestSuite.CodeGeneration.PseudoBoolean + , TestSuite.CodeGeneration.RegExp + , TestSuite.CodeGeneration.ScalarSafety , TestSuite.CodeGeneration.Uninterpreted , TestSuite.CompileTests.SCase , TestSuite.CompileTests.PCase @@ -471,6 +509,7 @@ , TestSuite.Queries.Int_Z3 , TestSuite.Queries.Interpolants , TestSuite.Queries.Lists + , TestSuite.Queries.Registration , TestSuite.Queries.Strings , TestSuite.Queries.Sums , TestSuite.Queries.Tables