sbv-5.12/0000755000000000000000000000000012725411266010427 5ustar0000000000000000sbv-5.12/CHANGES.md0000644000000000000000000015405612725411266012034 0ustar0000000000000000* Hackage: * GitHub: * Latest Hackage released version: 5.12, 2016-06-06 ### Version 5.12, 2016-06-06 * Fix GHC8.0 compliation issues, and warning clean-up. Thanks to Adam Foltzer for the bulk of the work and Tom Sydney Kerckhove for the initial patch for 8.0 compatibility. * Minor fix to printing models with floats when the base is 2/16, making sure the alignment is done properly accommodating for the crackNum output. * Wait for external process to die on exception, to avoid spawning zombies. Thanks to Daniel Wagner for the patch. * Fix hash-consed arrays: Previously we were caching based only on elements, which is not sufficient as you can have conflicts differing only on the address type, but same contents. Thanks to Brian Huffman for reporting and the corresponding patch. ### Version 5.11, 2016-01-15 * Fix documentation issue; no functional changes ### Version 5.10, 2016-01-14 * Documentation: Fix a bunch of dead http links. Thanks to Andres Sicard-Ramirez for reporting. * Additions to the Dynamic API: * svSetBit : set a given bit * svBlastLE, svBlastBE : Bit-blast to big/little endian * svWordFromLE, svWordFromBE: Unblast from big/little endian * svAddConstant : Add a constant to an SVal * svIncrement, svDecrement : Add/subtract 1 from an SVal ### Version 5.9, 2016-01-05 * Default definition for 'symbolicMerge', which allows types that are instances of 'Generic' to have an automatically derivable merge (i.e., ite) instance. Thanks to Christian Conkle for the patch. * Add support for "non-model-vars," where we can now tell SBV not to take into account certain variables from a model-building perspective. This comes handy in doing an `allSat` calls where there might be witness variables that we do not care the uniqueness for. See "Data/SBV/Examples/Misc/Auxiliary.hs" for an example, and the discussion in https://github.com/LeventErkok/sbv/issues/208 for motivation. * Yices interface: If Reals are used, then pick the logic QF_UFLRA, instead of QF_AUFLIA. Unfortunately, logic selection remains tricky since the SMTLib story for logic selection is rather messy. Other solvers are not impacted by this change. ### Version 5.8, 2016-01-01 * Fix some typos * Add 'svEnumFromThenTo' to the Dynamic interface, allowing dynamic construction of [x, y .. z] and [x .. y] when the involved values are concrete. * Add 'svExp' to the Dynamic interface, implementing exponentation ### Version 5.7, 2015-12-21 * Export HasKind(..) from the Dynamic interface. Thanks to Adam Foltzer for the patch. * More careful handling of SMT-Lib reserved names. * Update tested version of MathSAT to 5.3.9 * Generalize sShiftLeft/sShiftRight/sRotateLeft/sRotateRight to work with signed shift/rotate amounts, where negative values revert the direction. Similar generalizations are also done for the dynamic variants. ### Version 5.6, 2015-12-06 * Minor changes to how we print models: * Align by the type * Always print the type (previously we were skipping for Bool) * Rework how SBV properties are quick-checked; much more usable and robust * Provide a function sbvQuickCheck, which is essentially the same as quickCheck, except it also returns a boolean. Useful for the programmable API. (The dynamic version is called svQuickCheck) * Several changes/additions in support of the sbvPlugin development: * Data.SBV.Dynamic: Define/export svFloat/svDouble/sReal/sNumerator/sDenominator * Data.SBV.Internals: Export constructors of Result, SMTModel, and the function showModel * Simplify how Uninterpreted-types are internally represented. ### Version 5.5, 2015-11-10 * This is essentially the same release as 5.4 below, except to allow SBV compile with GHC 7.8 series. Thanks to Adam Foltzer for the patch. ### Version 5.4, 2015-11-09 * Add 'sAssert', which allows users to pepper their code with boolean conditions, much like the usual ASSERT calls. Note that the semantics of an 'sAssert' is that it is a NOOP, i.e., it simply returns its final argument. Use in coordination with 'safe' and 'safeWith', see below. * Implement 'safe' and 'safeWith', which statically determine all calls to 'sAssert' being safe to execute. Any vilations will be flagged. * SBV->C: Translate 'sAssert' calls to dynamic checks in the generated C code. If this is not desired, use the 'cgIgnoreSAssert' function to turn it off. * Add 'isSafe': Which converts a 'SafeResult' to a 'Bool', when we are only interested in a boolean result. * Add Data/SBV/Examples/Misc/NoDiv0 to demonstrate the use of the 'safe' function. ### Version 5.3, 2015-10-20 * Main point of this release to make SBV compile with GHC 7.8 again, to accommodate mainly for Cryptol. As Cryptol moves to GHC >= 7.10, we intend to remove the "compatibility" changes again. Thanks to Adam Foltzer for the patch. * Minor mods to how bitvector equality/inequality are translated to SMTLib. No user visible impact. ### Version 5.2, 2015-10-12 * Regression on 5.1: Fix a minor bug in base 2/16 printing where uninterpreted constants were not handled correctly. ### Version 5.1, 2015-10-10 * fpMin, fpMax: If these functions receive +0/-0 as their two arguments, i.e., both zeros but alternating signs in any order, then SMTLib requires the output to be nondeterministicly chosen. Previously, we fixed this result as +0 following the interpretation in Z3, but Z3 recently changed and now incorporates the nondeterministic output. SBV similarly changed to allow for non-determinism here. * Change the types of the following Floating-point operations: * sFloatAsSWord32, sFloatAsSWord32, blastSFloat, blastSDouble These were previously coded as relations, since NaN values were not representable in the target domain uniquely. While it was OK, it was hard to use them. We now simply implement these as functions, and they are underspecified if the inputs are NaNs: In those cases, we simply get a symbolic output. The new types are: * sFloatAsSWord32 :: SFloat -> SWord32 * sDoubleAsSWord64 :: SDouble -> SWord64 * blastSFloat :: SFloat -> (SBool, [SBool], [SBool]) * blastSDouble :: SDouble -> (SBool, [SBool], [SBool]) * MathSAT backend: Use the SMTLib interpretation of fp.min/fp.max by passing the "-theory.fp.minmax_zero_mode=4" argument explicitly. * Fix a bug in hash-consing of floating-point constants, where we were confusing +0 and -0 since we were using them as keys into the map though they compare equal. We now explicitly keep track of the negative-zero status to make sure this confusion does not arise. Note that this bug only exhibited itself in rare occurrences of both constants being present in a benchmark; a true corner case. Note that @NaN@ values are also interesting in this context: Since NaN /= NaN, we never hash-cons floating point constants that have the value NaN. But that is actually OK; it is a bit wasteful in case you have a lot of NaN constants around, but there is no soundness issue: We just waste a little bit of space. * Remove the functions `allSatWithAny` and `allSatWithAll`. These two variants do *not* make sense when run with multiple solvers, as they internally sequentialize the solutions due to the nature of `allSat`. Not really needed anyhow; so removed. The variants `satWithAny/All` and `proveWithAny/All` are still available. * Export SMTLibVersion from the library, forgotten export needed by Cryptol. Thanks to Adam Foltzer for the patch. * Slightly modify model-outputs so the variables are aligned vertically. (Only matters if we have model-variable names that are of differing length.) * Move to Travis-CI "docker" based infrastructure for builds * Enable local builds to use the Herbie plugin. Currently SBV does not have any expressions that can benefit from Herbie, but it is nice to have this support in general. ### Version 5.0, 2015-09-22 * Note: This is a backwards-compatibility breaking release, see below for details. * SBV now requires GHC 7.10.1 or newer to be compiled, taking advantage of newer features/bug-fixes in GHC. If you really need SBV to compile with older GHCs, please get in touch. * SBV no longer supports SMTLib1. We now exclusively use SMTLib2 for communicating with backend solvers. Strictly speaking, this means some loss in functionality: Uninterpreted-function models that we supported via Yices-1 are no longer available. In practice this facility was not really used, and required a very old version of Yices that was no longer supported by SRI and has lacked in other features. So, in reality this change should hardly matter for end-users. * Added function "label", which is useful in emitting comments around expressions. It is essentially a no-op, but does generate a comment with the given text in the SMT-Lib and C output, for diagnostic purposes. * Added "sFromIntegral": Conversions from all integral types (SInteger, SWord/SInts) between each other. Similar to the "fromIntegral" function of Haskell. These generate simple casts when used in code-generation to C, and thus are very efficient. * SBV no longer supports the functions sBranch/sAssert, as we realized these functions can cause soundness issues under certain conditions. While the triggering scenarios are not common use-cases for these functions, we are opting for safety, and thus removing support. See http://github.com/LeventErkok/sbv/issues/180 for details; and see below for the new function 'isSatisfiableInCurrentPath'. * A new function 'isSatisfiableInCurrentPath' is added, which checks for satisfiability during a symbolic simulation run. This function can be used as the basis of sBranch/sAssert like functionality if needed. The difference is that this is a much lower level call, and also exposes the fact that the result is in the 'Symbolic' monad (which avoids the soundness issue). Of course, the new type makes it less useful as it will not be a drop-in replacement for if-then-else like structure. Intended to be used by tools built on top of SBV, as opposed to end-users. * SBV no longer implements the 'SignCast' class, as its functionality is replaced by the 'sFromIntegral' function. Programs using the functions 'signCast' and 'unsignCast' should simply replace both with calls to 'sFromIntegral'. (Note that extra type-annotations might be necessary, similar to the uses of the 'fromIntegral' function in Haskell.) * Backend solver related changes: * Yices: Upgraded to work with Yices release 2.4.1. Note that earlier versions of Yices are *not* supported. * Boolector: Upgraded to work with new Boolector release 2.0.7. Note that earlier versions of Boolector are *not* supported. * MathSAT: Upgraded to work with latest release 5.3.7. Note that earlier versions of MathSAT are *not* supported (due to a buffering issue in MathSAT itself.) * MathSAT: Enabled floating-point support in MathSAT. * New examples: * Add Data.SBV.Examples.Puzzles.Birthday, which solves the Cheryl-Birthday problem that went viral in April 2015. Turns out really easy to solve for SMT, but the formalization of the problem is still interesting as an exercise in formal reasoning. * Add Data.SBV.Examples.Puzzles.SendMoreMoney, which solves the classic send + more = money problem. Really a trivial example, but included since it is pretty much the hello-world for basic constraint solving. * Add Data.SBV.Examples.Puzzles.Fish, which solves a typical logic puzzle; finding the unique solution to a set of assertions made about a bunch of people, their pets, beverage choices, etc. Not particularly interesting, but could be fun to play around with for modeling purposes. * Add Data.SBV.Examples.BitPrecise.MultMask, which demonstrates the use of the bitvector solver to an interesting bit-shuffling problem. * Rework floating-point arithmetic, and add missing floating-point operations: * fpRem : remainder * fpRoundToIntegral: truncating round * fpMin : min * fpMax : max * fpIsEqualObject : FP equality as object (i.e., NaN equals NaN, +0 does not equal -0, etc.) This brings SBV up-to par with everything supported by the SMT-Lib FP theory. * Add the IEEEFloatConvertable class, which provides conversions to/from Floats and other types. (i.e., value conversions from all other types to Floats and Doubles; and back.) * Add SWord32/SWord64 to/from SFloat/SDouble conversions, as bit-pattern reinterpretation; using the IEEE754 interchange format. The functions are: sWord32AsSFloat, sWord64AsSDouble, sFloatAsSWord32, sDoubleAsSWord64. Note that the sWord32AsSFloat and sWord64ToSDouble are regular functions, but sFloatToSWord32 and sDoubleToSWord64 are "relations", since NaN values are not uniquely convertable. * Add 'sExtractBits', which takes a list of indices to extract bits from, essentially equivalent to 'map sTestBit'. * Rename a set of symbolic functions for consistency. Here are the old/new names: * sbvTestBit --> sTestBit * sbvPopCount --> sPopCount * sbvShiftLeft --> sShiftLeft * sbvShiftRight --> sShiftRight * sbvRotateLeft --> sRotateLeft * sbvRotateRight --> sRotateRight * sbvSignedShiftArithRight --> sSignedShiftArithRight * Rename all FP recognizers to be in sync with FP operations. Here are the old/new names: * isNormalFP --> fpIsNormal * isSubnormalFP --> fpIsSubnormal * isZeroFP --> fpIsZero * isInfiniteFP --> fpIsInfinite * isNaNFP --> fpIsNaN * isNegativeFP --> fpIsNegative * isPositiveFP --> fpIsPositive * isNegativeZeroFP --> fpIsNegativeZero * isPositiveZeroFP --> fpIsPositiveZero * isPointFP --> fpIsPoint * Lots of other work around floating-point, test cases, reorg, etc. * Introduce shorter variants for rounding modes: sRNE, sRNA, sRTP, sRTN, sRTZ; aliases for sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, and sRoundTowardZero; respectively. ### Version 4.4, 2015-04-13 * Hook-up crackNum package; so counter-examples involving floats and doubles can be printed in detail when the printBase is chosen to be 2 or 16. (With base 10, we still get the simple output.) ``` Prelude Data.SBV> satWith z3{printBase=2} $ \x -> x .== (2::SFloat) Satisfiable. Model: s0 = 2.0 :: Float 3 2 1 0 1 09876543 21098765432109876543210 S ---E8--- ----------F23---------- Binary: 0 10000000 00000000000000000000000 Hex: 4000 0000 Precision: SP Sign: Positive Exponent: 1 (Stored: 128, Bias: 127) Value: +2.0 (NORMAL) ``` * Change how we print type info; for models insted of SType just print Type (i.e., for SWord8, instead print Word8) which makes more sense and is more consistent. This change should be mostly relevant as how we see the counter-example output. * Fix long standing bug #75, where we now support arrays with Boolean source/targets. This is not a very commonly used case, but by letting the solver pick the logic, we now allow arrays to be uniformly supported. ### Version 4.3, 2015-04-10 * Introduce Data.SBV.Dynamic, by Brian Huffman. This is mostly an internal reorg of the SBV codebase, and end-users should not be impacted by the changes. The introduction of the Dynamic SBV variant (i.e., one that does not mandate a phantom type as in "SBV Word8" etc. allows library writers more flexibility as they deal with arbitrary bit-vector sizes. The main customor of these changes are the Cryptol language and the associated toolset, but other developers building on top of SBV can find it useful as well. NB: The "strongly-typed" aspect of SBV is still the main way end-users should interact with SBV, and nothing changed in that respect! * Add symbolic variants of floating-point rounding-modes for convenience * Rename toSReal to sIntegerToSReal, which captures the intent more clearly * Code clean-up: remove mbMinBound/mbMaxBound thus allowing less calls to unliteral. Contributed by Brian Huffman. * Introduce FP conversion functions: * Between SReal and SFloat/SDouble * fpToSReal * sRealToSFloat * sRealToSDouble * Between SWord32 and SFloat * sWord32ToSFloat * sFloatToSWord32 * Between SWord64 and SDouble. (Relational, due to non-unique NaNs) * sWord64ToSDouble * sDoubleToSWord64 * From float to sign/exponent/mantissa fields: (Relational, due to non-unique NaNs) * blastSFloat * blastSDouble * Rework floating point classifiers. Remove isSNaN and isFPPoint (both renamed), and add the following new recognizers: * isNormalFP * isSubnormalFP * isZeroFP * isInfiniteFP * isNaNFP * isNegativeFP * isPositiveFP * isNegativeZeroFP * isPositiveZeroFP * isPointFP (corresponds to a real number, i.e., neither NaN nor infinity) * Reimplement sbvTestBit, by Brian Huffman. This version is much faster at large word sizes, as it avoids the costly mask generation. * Code changes to suppress warnings with GHC7.10. General clean-up. ### Version 4.2, 2015-03-17 * Add exponentiation (.^). Thanks to Daniel Wagner for contributing the code! * Better handling of SBV_$SOLVER_OPTIONS, in particular keeping track of proper quoting in environment variables. Thanks to Adam Foltzer for the patch! * Silence some hlint/ghci warnings. Thanks to Trevor Elliott for the patch! * Haddock documentation fixes, improvements, etc. * Change ABC default option string to %blast; "&sweep -C 5000; &syn4; &cec -s -m -C 2000" which seems to give good results. Use SBV_ABC_OPTIONS environment variable (or via abc.rc file and a combination of SBV_ABC_OPTIONS) to experiment. ### Version 4.1, 2015-03-06 * Add support for the ABC solver from Berkeley. Thanks to Adam Foltzer for the required infrastructure! See: http://www.eecs.berkeley.edu/~alanmi/abc/ And Alan Mishchenko for adding infrastructure to ABC to work with SBV. * Upgrade the Boolector connection to use a SMT-Lib2 based interaction. NB. You need at least Boolector 2.0.6 installed! * Tracking changes in the SMT-Lib floating-point theory. If you are using symbolic floating-point types (i.e., SFloat and SDouble), then you should upgrade to this version and also get a very latest (unstable) Z3 release. See http://smtlib.cs.uiowa.edu/theories-FloatingPoint.shtml for details. * Introduce a new class, 'RoundingFloat', which supports floating-point operations with arbitrary rounding-modes. Note that Haskell only allows RoundNearestTiesToAway, but with SBV, we get all 5 IEEE754 rounding-modes and all the basic operations ('fpAdd', 'fpMul', 'fpDiv', etc.) with these modes. * Allow Floating-Point RoundingMode to be symbolic as well * Improve the example "Data/SBV/Examples/Misc/Floating.hs" to include rounding-mode based addition example. * Changes required to make SBV compile with GHC 7.10; mostly around instance NFData declarations. Thanks to Iavor Diatchki for the patch. * Export a few extra symbols from the Internals module (mainly for Cryptol usage.) ### Version 4.0, 2015-01-22 This release mainly contains contributions from Brian Huffman, allowing end-users to define new symbolic types, such as Word4, that SBV does not natively support. When GHC gets type-level literals, we shall most likely incorporate arbitrary bit-sized vectors and ints using this mechanism, but in the interim, this release provides a means for the users to introduce individual instances. * Modifications to support arbitrary bit-sized vectors; These changes have been contributed by Brian Huffman of Galois.. Thanks Brian. * A new example "Data/SBV/Examples/Misc/Word4.hs" showing how users can add new symbolic types. * Support for rotate-left/rotate-right with variable rotation amounts. (From Brian Huffman.) ### Version 3.5, 2015-01-15 This release is mainly adding support for enumerated types in Haskell being translated to their symbolic counterparts; instead of going completely uninterpreted. * Keep track of data-type details for uninterpreted sorts. * Rework the U2Bridge example to use enumerated types. * The "Uninterpreted" name no longer makes sense with this change, so rework the relevant names to ensure proper internal naming. * Add Data/SBV/Examples/Misc/Enumerate.hs as an example for demonstrating how enumerations are translated. * Fix a long-standing bug in the implementation of select when translated as SMT-Lib tables. (Github issue #103.) Thanks to Brian Huffman for reporting. ### Version 3.4, 2014-12-21 * This release is mainly addressing floating-point changes in SMT-Lib. * Track changes in the QF_FPA logic standard; new constants and alike. If you are using the floating-point logic, then you need a relatively new version of Z3 installed (4.3.3 or newer). * Add unary-negation as an explicit operator. Previously, we merely used the "0-x" semantics; but with floating point, this does not hold as 0-0 is 0, and is not -0! (Note that negative-zero is a valid floating point value, that is different than positive-zero; yet it compares equal to it. Sigh..) * Similarly, add abs as a native method; to make sure we map it to fp.abs for floating point values. * Test suite improvements ### Version 3.3, 2014-12-05 * Implement 'safe' and 'safeWith', which statically determine all calls to 'sAssert' being safe to execute. This way, users can pepper their programs with liberal calls to 'sAssert' and check they are all safe in one go without further worry. * Robustify the interface to external solvers, by making sure we catch cases where the external solver might exist but not be runnable (library dependency missing, for example). It is impossible to be absolutely foolproof, but we now catch a few more cases and fail gracefully. ### Version 3.2, 2014-11-18 * Implement 'sAssert'. This adds conditional symbolic simulation, by ensuring arbitrary boolean conditions hold during simulation; similar to ASSERT calls in other languages. Note that failures will be detected at symbolic-simulation time, i.e., each assert will generate a call to the external solver to ensure that the condition is never violated. If violation is possible the user will get an error, indicating the failure conditions. * Also implement 'sAssertCont' which allows for a programmatic way to extract/display results for consumers of 'sAssert'. While the latter simply calls 'error' in case of an assertion violation, the 'sAssertCont' variant takes a continuation which can be used to program how the results should be interpreted/displayed. (This is useful for libraries built on top of SBV.) Note that the type of the continuation is such that execution should still stop, i.e., once an assertion violation is detected, symbolic simulation will never continue. * Rework/simplify the 'Mergeable' class to make sure 'sBranch' is sufficiently lazy in case of structural merges. The original implementation was only lazy at the Word instance, but not at lists/tuples etc. Thanks to Brian Huffman for reporting this bug. * Add a few constant-folding optimizations for 'sDiv'and 'sRem' * Boolector: Modify output parser to conform to the new Boolector output format. This means that you need at least v2.0.0 of Boolector installed if you want to use that particular solver. * Fix long-standing translation bug regarding boolean Ord class comparisons. (i.e., 'False > True' etc.) While Haskell allows for this, SMT-Lib does not; and hence we have to be careful in translating. Thanks to Brian Huffman for reporting. * C code generation: Correctly translate square-root and fusedMA functions to C. ### Version 3.1, 2014-07-12 NB: GHC 7.8.1 and 7.8.2 has a serious bug that causes SBV to crash under heavy/repeated calls. The bug is addressed in GHC 7.8.3; so upgrading to GHC 7.8.3 is essential for using SBV! New features/bug-fixes in v3.1: * Using multiple-SMT solvers in parallel: * Added functions that let the user run multiple solvers, using asynchronous threads. All results can be obtained (proveWithAll, proveWithAny, satWithAll), or SBV can return the fastest result (satWithAny, allSatWithAll, allSatWithAny). These functions are good for playing with multiple-solvers, especially on machines with multiple-cores. * Add function: sbvAvailableSolvers; which returns the list of solvers currently available, as installed on the machine we are running. (Not the list that SBV supports, but those that are actually available at run-time.) This function is useful with the multi-solve API. * Implement sBranch: * sBranch is a variant of 'ite' that consults the external SMT solver to see if a given branch condition is satisfiable before evaluating it. This can make certain otherwise recursive and thus not-symbolically-terminating inputs amenable to symbolic simulation, if termination can be established this way. Needless to say, this problem is always decidable as far as SBV programs are concerned, but it does not mean the decision procedure is cheap! Use with care. * sBranchTimeOut config parameter can be used to curtail long runs when sBranch is used. Of course, if time-out happens, SBV will assume the branch is feasible, in which case symbolic-termination may come back to bite you.) * New API: * Add predicate 'isSNaN' which allows testing 'SFloat'/'SDouble' values for nan-ness. This is similar to the Prelude function 'isNaN', except the Prelude version requires a RealFrac instance, which unfortunately is not currently implementable for cases. (Requires trigonometric functions etc.) Thus, we provide 'isSNaN' separately (along with the already existing 'isFPPoint') to simplify reasoning with floating-point. * Examples: * Add Data/SBV/Examples/Misc/SBranch.hs, to illustrate the use of sBranch. * Bug fixes: * Fix pipe-blocking issue, which exhibited itself in the presence of large numbers of variables (> 10K or so). See github issue #86. Thanks to Philipp Meyer for the fine report. * Misc: * Add missing SFloat/SDouble instances for SatModel class * Explicitly support KBool as a kind, separating it from "KUnbounded False 1". Thanks to Brian Huffman for contributing the changes. This should have no user-visible impact, but comes in handy for internal reasons. ### Version 3.0, 2014-02-16 * Support for floating-point numbers: * Preliminary support for IEEE-floating point arithmetic, introducing the types `SFloat` and `SDouble`. The support is still quite new, and Z3 is the only solver that currently features a solver for this logic. Likely to have bugs, both at the SBV level, and at the Z3 level; so any bug reports are welcome! * New backend solvers: * SBV now supports MathSAT from Fondazione Bruno Kessler and DISI-University of Trento. See: http://mathsat.fbk.eu/ * Support all-sat calls in the presence of uninterpreted sorts: * Implement better support for `allSat` in the presence of uninterpreted sorts. Previously, SBV simply rejected running `allSat` queries in the presence of uninterpreted sorts, since it was not possible to generate a refuting model. The model returned by the SMT solver is simply not usable, since it names constants that is not visible in a subsequent run. Eric Seidel came up with the idea that we can actually compute equivalence classes based on a produced model, and assert the constraint that the new model should disallow the previously found equivalence classes instead. The idea seems to work well in practice, and there is also an example program demonstrating the functionality: Examples/Uninterpreted/UISortAllSat.hs * Programmable model extraction improvements: * Add functions `getModelDictionary` and `getModelDictionaries`, which provide low-level access to models returned from SMT solvers. Former for `sat` and `prove` calls, latter for `allSat` calls. Together with the exported utils from the `Data.SBV.Internals` module, this should allow for expert users to dissect the models returned and do fancier programming on top of SBV. * Add `getModelValue`, `getModelValues`, `getModelUninterpretedValue`, and `getModelUninterpretedValues`; which further aid in model value extraction. * Other: * Allow users to specify the SMT-Lib logic to use, if necessary. SBV will still pick the logic automatically, but users can now override that choice. Comes in handy when playing with custom logics. * Bug fixes: * Address allsat-laziness issue (#78 in github issue tracker). Essentially, simplify how all-sat is called so we can avoid calling the solver for solutions that are not needed. Thanks to Eric Seidel for reporting. * Examples: * Add Data/SBV/Examples/Misc/ModelExtract.hs as a simple example for programmable model extraction and usage. * Add Data/SBV/Examples/Misc/Floating.hs for some FP examples. * Use the AUFLIA logic in Examples.Existentials.Diophantine which helps z3 complete the proof quickly. (The BV logics take too long for this problem.) ### Version 2.10, 2013-03-22 * Add support for the Boolector SMT solver * See: http://fmv.jku.at/boolector/ * Use `import Data.SBV.Bridge.Boolector` to use Boolector from SBV * Boolector supports QF_BV (with an without arrays). In the last SMT-Lib competition it won both bit-vector categories. It is definitely worth trying it out for bitvector problems. * Changes to the library: * Generalize types of `allDifferent` and `allEqual` to take arbitrary EqSymbolic values. (Previously was just over SBV values.) * Add `inRange` predicate, which checks if a value is bounded within two others. * Add `sElem` predicate, which checks for symbolic membership * Add `fullAdder`: Returns the carry-over as a separate boolean bit. * Add `fullMultiplier`: Returns both the lower and higher bits resulting from multiplication. * Use the SMT-Lib Bool sort to represent SBool, instead of bit-vectors of length 1. While this is an under-the-hood mechanism that should be user-transparent, it turns out that one can no longer write axioms that return booleans in a direct way due to this translation. This change makes it easier to write axioms that utilize booleans as there is now a 1-to-1 match. (Suggested by Thomas DuBuisson.) * Solvers changes: * Z3: Update to the new parameter naming schema of Z3. This implies that you need to have a really recent version of Z3 installed, something in the Z3-4.3 series. * Examples: * Add Examples/Uninterpreted/Shannon.hs: Demonstrating Shannon expansion, boolean derivatives, etc. * Bug-fixes: * Gracefully handle the case if the backend-SMT solver does not put anything in stdout. (Reported by Thomas DuBuisson.) * Handle uninterpreted sort values, if they happen to be only created via function calls, as opposed to being inputs. (Reported by Thomas DuBuisson.) ### Version 2.9, 2013-01-02 * Add support for the CVC4 SMT solver from New York University and the University of Iowa. . NB. Z3 remains the default solver for SBV. To use CVC4, use the *With variants of the interface (i.e., proveWith, satWith, ..) by passing cvc4 as the solver argument. (Similarly, use 'yices' as the argument for the *With functions for invoking yices.) * Latest release of Yices calls the SMT-Lib based solver executable yices-smt. Updated the default value of the executable to have this name for ease of use. * Add an extra boolean flag to compileToSMTLib and generateSMTBenchmarks functions to control if the translation should keep the query as is (for SAT cases), or negate it (for PROVE cases). Previously, this value was hard-coded to do the PROVE case only. * Add bridge modules, to simplify use of different solvers. You can now say: import Data.SBV.Bridge.CVC4 import Data.SBV.Bridge.Yices import Data.SBV.Bridge.Z3 to pick the appropriate default solver. if you simply 'import Data.SBV', then you will get the default SMT solver, which is currently Z3. The value 'defaultSMTSolver' refers to z3 (currently), and 'sbvCurrentSolver' refers to the chosen solver as determined by the imported module. (The latter is useful for modifying options to the SMT solver in an solver-agnostic way.) * Various improvements to Z3 model parsing routines. * New web page for SBV: http://leventerkok.github.com/sbv/ is now online. ### Version 2.8, 2012-11-29 * Rename the SNum class to SIntegral, and make it index over regular types. This makes it much more useful, simplifying coding of polymorphic symbolic functions over integral types, which is the common case. * Add the functions: * sbvShiftLeft * sbvShiftRight which can accommodate unsigned symbolic shift amounts. Note that one cannot use the Haskell shiftL/shiftR functions from the Bits class since they are hard-wired to take 'Int' values as the shift amounts only. * Add a new function 'sbvArithShiftRight', which is the same as a shift-right, except it uses the MSB of the input as the bit to fill in (instead of always filling in with 0 bits). Note that this is the same as shiftRight for signed values, but differs from a shiftRight when the input is unsigned. (There is no Haskell analogue of this function, as Haskell shiftR is always arithmetic for signed types and logical for unsigned ones.) This variant is designed for use cases when one uses the underlying unsigned SMT-Lib representation to implement custom signed operations, for instance. * Several typo fixes. ### Version 2.7, 2012-10-21 * Add missing QuickCheck instance for SReal * When dealing with concrete SReals, make sure to operate only on exact algebraic reals on the Haskell side, leaving true algebraic reals (i.e., those that are roots of polynomials that cannot be expressed as a rational) symbolic. This avoids issues with functions that we cannot implement directly on the Haskell side, like exact square-roots. * Documentation tweaks, typo fixes etc. * Rename BVDivisible class to SDivisible; since SInteger is also an instance of this class, and SDivisible is a more appropriate name to start with. Also add sQuot and sRem methods; along with sDivMod, sDiv, and sMod, with usual semantics. * Improve test suite, adding many constant-folding tests and start using cabal based tests (--enable-tests option.) ### Versions 2.4, 2.5, and 2.6: Around mid October 2012 * Workaround issues related hackage compilation, in particular to the problem with the new containers package release, which does provide an NFData instance for sequences. * Add explicit Num requirements when necessary, as the Bits class no longer does this. * Remove dependency on the hackage package strict-concurrency, as hackage can no longer compile it due to some dependency mismatch. * Add forgotten Real class instance for the type 'AlgReal' * Stop putting bounds on hackage dependencies, as they cause more trouble then they actually help. (See the discussion here: .) ### Version 2.3, 2012-07-20 * Maintanence release, no new features. * Tweak cabal dependencies to avoid using packages that are newer than those that come with ghc-7.4.2. Apparently this is a no-no that breaks many things, see the discussion in this thread: http://www.haskell.org/pipermail/haskell-cafe/2012-July/102352.html In particular, the use of containers >= 0.5 is *not* OK until we have a version of GHC that comes with that version. ### Version 2.2, 2012-07-17 * Maintanence release, no new features. * Update cabal dependencies, in particular fix the regression with respect to latest version of the containers package. ### Version 2.1, 2012-05-24 * Library: * Add support for uninterpreted sorts, together with user defined domain axioms. See Data.SBV.Examples.Uninterpreted.Sort and Data.SBV.Examples.Uninterpreted.Deduce for basic examples of this feature. * Add support for C code-generation with SReals. The user picks one of 3 possible C types for the SReal type: CgFloat, CgDouble or CgLongDouble, using the function cgSRealType. Naturally, the resulting C program will suffer a loss of precision, as it will be subject to IEE-754 rounding as implied by the underlying type. * Add toSReal :: SInteger -> SReal, which can be used to promote symbolic integers to reals. Comes handy in mixed integer/real computations. * Examples: * Recast the dog-cat-mouse example to use the solver over reals. * Add Data.SBV.Examples.Uninterpreted.Sort, and Data.SBV.Examples.Uninterpreted.Deduce for illustrating uninterpreted sorts and axioms. ### Version 2.0, 2012-05-10 This is a major release of SBV, adding support for symbolic algebraic reals: SReal. See http://en.wikipedia.org/wiki/Algebraic_number for details. In brief, algebraic reals are solutions to univariate polynomials with rational coefficients. The arithmetic on algebraic reals is precise, with no approximation errors. Note that algebraic reals are a proper subset of all reals, in particular transcendental numbers are not representable in this way. (For instance, "sqrt 2" is algebraic, but pi, e are not.) However, algebraic reals is a superset of rationals, so SBV now also supports symbolic rationals as well. You *should* use Z3 v4.0 when working with real numbers. While the interface will work with older versions of Z3 (or other SMT solvers in general), it uses Z3 root-obj construct to retrieve and query algebraic reals. While SReal values have infinite precision, printing such values is not trivial since we might need an infinite number of digits if the result happens to be irrational. The user controls printing precision, by specifying how many digits after the decimal point should be printed. The default number of decimal digits to print is 10. (See the 'printRealPrec' field of SMT-solver configuration.) The acronym SBV used to stand for Symbolic Bit Vectors. However, SBV has grown beyond bit-vectors, especially with the addition of support for SInteger and SReal types and other code-generation utilities. Therefore, "SMT Based Verification" is now a better fit for the expansion of the acronym SBV. Other notable changes in the library: * Add functions s[TYPE] and s[TYPE]s for each symbolic type we support (i.e., sBool, sBools, sWord8, sWord8s, etc.), to create symbolic variables of the right kind. Strictly speaking these are just synonyms for 'free' and 'mapM free' (plural versions), so they are not adding any additional power. Except, they are specialized at their respective types, and might be easier to remember. * Add function solve, which is merely a synonym for (return . bAnd), but it simplifies expressing problems. * Add class SNum, which simplifies writing polymorphic code over symbolic values * Increase haddock coverage metrics * Major code refactoring around symbolic kinds * SMTLib2: Emit ":produce-models" call before setting the logic, as required by the SMT-Lib2 standard. [Patch provided by arrowdodger on github, thanks!] Bugs fixed: * [Performance] Use a much simpler default definition for "select": While the older version (based on binary search on the bits of the indexer) was correct, it created unnecessarily big expressions. Since SBV does not have a notion of concrete subwords, the binary-search trick was not bringing any advantage in any case. Instead, we now simply use a linear walk over the elements. Examples: * Change dog-cat-mouse example to use SInteger for the counts * Add merge-sort example: Data.SBV.Examples.BitPrecise.MergeSort * Add diophantine solver example: Data.SBV.Examples.Existentials.Diophantine ### Version 1.4, 2012-05-10 * Interim release for test purposes ### Version 1.3, 2012-02-25 * Workaround cabal/hackage issue, functionally the same as release 1.2 below ### Version 1.2, 2012-02-25 Library: * Add a hook so users can add custom script segments for SMT solvers. The new "solverTweaks" field in the SMTConfig data-type can be used for this purpose. The need for this came about due to the need to workaround a Z3 v3.2 issue detalied below: http://stackoverflow.com/questions/9426420/soundness-issue-with-integer-bv-mixed-benchmarks As a consequence, mixed Integer/BV problems can cause soundness issues in Z3 and does in SBV. Unfortunately, it is too severe for SBV to add the woraround option, as it slows down the solver as a side effect as well. Thus, we are making this optionally available if/when needed. (Note that the work-around should not be necessary with Z3 v3.3; which is not released yet.) * Other minor clean-up ### Version 1.1, 2012-02-14 Library: * Rename bitValue to sbvTestBit * Add sbvPopCount * Add a custom implementation of 'popCount' for the Bits class instance of SBV (GHC >= 7.4.1 only) * Add 'sbvCheckSolverInstallation', which can be used to check that the given solver is installed and good to go. * Add 'generateSMTBenchmarks', simplifying the generation of SMTLib benchmarks for offline sharing. ### Version 1.0, 2012-02-13 Library: * Z3 is now the "default" SMT solver. Yices is still available, but has to be specifically selected. (Use satWith, allSatWith, proveWith, etc.) * Better handling of the pConstrain probability threshold for test case generation and quickCheck purposes. * Add 'renderTest', which accompanies 'genTest' to render test vectors as Haskell/C/Forte program segments. * Add 'expectedValue' which can compute the expected value of a symbolic value under the given constraints. Useful for statistical analysis and probability computations. * When saturating provable values, use forAll_ for proofs and forSome_ for sat/allSat. (Previously we were allways using forAll_, which is not incorrect but less intuitive.) * add function: extractModels :: SatModel a => AllSatResult -> [a] which simplifies accessing allSat results greatly. Code-generation: * add "cgGenerateMakefile" which allows the user to choose if SBV should generate a Makefile. (default: True) Other * Changes to make it compile with GHC 7.4.1. ### Version 0.9.24, 2011-12-28 Library: * Add "forSome," analogous to "forAll." (The name "exists" would've been better, but it's already taken.) This is not as useful as one might think as forAll and forSome do not nest, as an inner application of one pushes its argument to a Predicate, making the outer one useless, but it is nonetheless useful by itself. * Add a "Modelable" class, which simplifies model extraction. * Add support for quick-check at the "Symbolic SBool" level. Previously SBV only allowed functions returning SBool to be quick-checked, which forced a certain style of coding. In particular with the addition of quantifiers, the new coding style mostly puts the top-level expressions in the Symbolic monad, which were not quick-checkable before. With new support, the quickCheck, prove, sat, and allSat commands are all interchangeable with obvious meanings. * Add support for concrete test case generation, see the genTest function. * Improve optimize routines and add support for iterative optimization. * Add "constrain", simplifying conjunctive constraints, especially useful for adding constraints at variable generation time via forall/exists. Note that the interpretation of such constraints is different for genTest and quickCheck functions, where constraints will be used for appropriately filtering acceptable test values in those two cases. * Add "pConstrain", which probabilistically adds constraints. This is useful for quickCheck and genTest functions for filtering acceptable test values. (Calls to pConstrain will be rejected for sat/prove calls.) * Add "isVacuous" which can be used to check that the constraints added via constrain are satisfable. This is useful to prevent vacuous passes, i.e., when a proof is not just passing because the constraints imposed are inconsistent. (Also added accompanying isVacuousWith.) * Add "free" and "free_", analogous to "forall/forall_" and "exists/exists_" The difference is that free behaves universally in a proof context, while it behaves existentially in a sat context. This allows us to express properties more succinctly, since the intended semantics is usually this way depending on the context. (i.e., in a proof, we want our variables universal, in a sat call existential.) Of course, exists/forall are still available when mixed quantifiers are needed, or when the user wants to be explicit about the quantifiers. Examples * Add Data/SBV/Examples/Puzzles/Coins.hs. (Shows the usage of "constrain".) Dependencies * Bump up random package dependency to 1.0.1.1 (from 1.0.0.2) Internal * Major reorganization of files to and build infrastructure to decrease build times and better layout * Get rid of custom Setup.hs, just use simple build. The extra work was not worth the complexity. ### Version 0.9.23, 2011-12-05 Library: * Add support for SInteger, the type of signed unbounded integer values. SBV can now prove theorems about unbounded numbers, following the semantics of Haskell Integer type. (Requires z3 to be used as the backend solver.) * Add functions 'optimize', 'maximize', and 'minimize' that can be used to find optimal solutions to given constraints with respect to a given cost function. * Add 'cgUninterpret', which simplifies code generation when we want to use an alternate definition in the target language (i.e., C). This is important for efficient code generation, when we want to take advantage of native libraries available in the target platform. Other: * Change getModel to return a tuple in the success case, where the first component is a boolean indicating whether the model is "potential." This is used to indicate that the solver actually returned "unknown" for the problem and the model might therefore be bogus. Note that we did not need this before since we only supported bounded bit-vectors, which has a decidable theory. With the addition of unbounded Integers and quantifiers, the solvers can now return unknown. This should still be rare in practice, but can happen with the use of non-linear constructs. (i.e., multiplication of two variables.) ### Version 0.9.22, 2011-11-13 The major change in this release is the support for quantifiers. The SBV library *no* longer assumes all variables are universals in a proof, (and correspondingly existential in a sat) call. Instead, the user marks free-variables appropriately using forall/exists functions, and the solver translates them accordingly. Note that this is a non-backwards compatible change in sat calls, as the semantics of formulas is essentially changing. While this is unfortunate, it is more uniform and simpler to understand in general. This release also adds support for the Z3 solver, which is the main SMT-solver used for solving formulas involving quantifiers. More formally, we use the new AUFBV/ABV/UFBV logics when quantifiers are involved. Also, the communication with Z3 is now done via SMT-Lib2 format. Eventually the SMTLib1 connection will be severed. The other main change is the support for C code generation with uninterpreted functions enabling users to interface with external C functions defined elsewhere. See below for details. Other changes: Code: * Change getModel, so it returns an Either value to indicate something went wrong; instead of throwing an error * Add support for computing CRCs directly (without needing polynomial division). Code generation: * Add "cgGenerateDriver" function, which can be used to turn on/off driver program generation. Default is to generate a driver. (Issue "cgGenerateDriver False" to skip the driver.) For a library, a driver will be generated if any of the constituent parts has a driver. Otherwise it will be skipped. * Fix a bug in C code generation where "Not" over booleans were incorrectly getting translated due to need for masking. * Add support for compilation with uninterpreted functions. Users can now specify the corresponding C code and SBV will simply call the "native" functions instead of generating it. This enables interfacing with other C programs. See the functions: cgAddPrototype, cgAddDecl, cgAddLDFlags Examples: * Add CRC polynomial generation example via existentials * Add USB CRC code generation example, both via polynomials and using the internal CRC functionality ### Version 0.9.21, 2011-08-05 Code generation: * Allow for inclusion of user makefiles * Allow for CCFLAGS to be set by the user * Other minor clean-up ### Version 0.9.20, 2011-06-05 Regression on 0.9.19; add missing file to cabal ### Version 0.9.19, 2011-06-05 * Add SignCast class for conversion between signed/unsigned quantities for same-sized bit-vectors * Add full-binary trees that can be indexed symbolically (STree). The advantage of this type is that the reads and writes take logarithmic time. Suitable for implementing faster symbolic look-up. * Expose HasSignAndSize class through Data.SBV.Internals * Many minor improvements, file re-orgs Examples: * Add sentence-counting example * Add an implementation of RC4 ### Version 0.9.18, 2011-04-07 Code: * Re-engineer code-generation, and compilation to C. In particular, allow arrays of inputs to be specified, both as function arguments and output reference values. * Add support for generation of generation of C-libraries, allowing code generation for a set of functions that work together. Examples: * Update code-generation examples to use the new API. * Include a library-generation example for doing 128-bit AES encryption ### Version 0.9.17, 2011-03-29 Code: * Simplify and reorganize the test suite Examples: * Improve AES decryption example, by using table-lookups in InvMixColumns. ### Version 0.9.16, 2011-03-28 Code: * Further optimizations on Bits instance of SBV Examples: * Add AES algorithm as an example, showing how encryption algorithms are particularly suitable for use with the code-generator ### Version 0.9.15, 2011-03-24 Bug fixes: * Fix rotateL/rotateR instances on concrete words. Previous versions was bogus since it relied on the Integer instance, which does the wrong thing after normalization. * Fix conversion of signed numbers from bits, previous version did not handle twos complement layout correctly Testing: * Add a sleuth of concrete test cases on arithmetic to catch bugs. (There are many of them, ~30K, but they run quickly.) ### Version 0.9.14, 2011-03-19 * Reimplement sharing using Stable names, inspired by the Data.Reify techniques. This avoids tricks with unsafe memory stashing, and hence is safe. Thus, issues with respect to CAFs are now resolved. ### Version 0.9.13, 2011-03-16 Bug fixes: * Make sure SBool short-cut evaluations are done as early as possible, as these help with coding recursion-depth based algorithms, when dealing with symbolic termination issues. Examples: * Add fibonacci code-generation example, original code by Lee Pike. * Add a GCD code-generation/verification example ### Version 0.9.12, 2011-03-10 New features: * Add support for compilation to C * Add a mechanism for offline saving of SMT-Lib files Bug fixes: * Output naming bug, reported by Josef Svenningsson * Specification bug in Legatos multipler example ### Version 0.9.11, 2011-02-16 * Make ghc-7.0 happy, minor re-org on the cabal file/Setup.hs ### Version 0.9.10, 2011-02-15 * Integrate commits from Iavor: Generalize SBVs to keep track the integer directly without resorting to different leaf types * Remove the unnecessary CLC instruction from the Legato example * More tests ### Version 0.9.9, 2011-01-23 * Support for user-defined SMT-Lib axioms to be specified for uninterpreted constants/functions * Move to using doctest style inline tests ### Version 0.9.8, 2011-01-22 * Better support for uninterpreted-functions * Support counter-examples with SArrays * Ladner-Fischer scheme example * Documentation updates ### Version 0.9.7, 2011-01-18 * First stable public hackage release ### Versions 0.0.0 - 0.9.6, Mid 2010 through early 2011 * Basic infrastructure, design exploration sbv-5.12/COPYRIGHT0000644000000000000000000000024712725411266011725 0ustar0000000000000000Copyright (c) 2010-2016, Levent Erkok (erkokl@gmail.com) All rights reserved. The sbv library is distributed with the BSD3 license. See the LICENSE file for details. sbv-5.12/INSTALL0000644000000000000000000000131212725411266011455 0ustar0000000000000000The sbv library can be installed simply by issuing cabal install like this: cabal install sbv Once the installation is done, you will get the Data.SBV library. The installation will also put a binary named SBVUnitTests in your .cabal/bin directory (or wherever you installed it.) It's highly recommended that you run this program to ensure everything is working correctly. In particular, you will first need to install Z3, the default SMT solver used by sbv, from Microsoft. (You can get it from .) Please make sure that the "z3" executable is in your path. Once you have installed sbv, you can use it in your Haskell programs by simply importing the Data.SBV module. sbv-5.12/LICENSE0000644000000000000000000000303712725411266011437 0ustar0000000000000000SBV: SMT Based Verification in Haskell Copyright (c) 2010-2016, Levent Erkok (erkokl@gmail.com) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the developer (Levent Erkok) nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LEVENT ERKOK BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. sbv-5.12/README.md0000644000000000000000000000050412725411266011705 0ustar0000000000000000## SBV: SMT Based Verification in Haskell [![Hackage version](http://img.shields.io/hackage/v/sbv.svg?label=Hackage)](http://hackage.haskell.org/package/sbv) [![Build Status](http://img.shields.io/travis/LeventErkok/sbv.svg?label=Build)](http://travis-ci.org/LeventErkok/sbv) Please see: http://leventerkok.github.io/sbv/ sbv-5.12/sbv.cabal0000644000000000000000000002332212725411266012207 0ustar0000000000000000Name: sbv Version: 5.12 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 (Satisfiability Modulo Theories) solvers. . For details, please see: Copyright: Levent Erkok, 2010-2016 License: BSD3 License-file: LICENSE Stability: Experimental Author: Levent Erkok Homepage: http://leventerkok.github.com/sbv/ Bug-reports: http://github.com/LeventErkok/sbv/issues Maintainer: Levent Erkok (erkokl@gmail.com) Build-Type: Simple Cabal-Version: >= 1.14 Data-Files: SBVUnitTest/GoldFiles/*.gold Extra-Source-Files: INSTALL, README.md, COPYRIGHT, CHANGES.md source-repository head type: git location: git://github.com/LeventErkok/sbv.git Library default-language: Haskell2010 ghc-options : -Wall other-extensions: BangPatterns DefaultSignatures DeriveAnyClass DeriveDataTypeable FlexibleContexts FlexibleInstances FunctionalDependencies GeneralizedNewtypeDeriving MultiParamTypeClasses OverlappingInstances ParallelListComp PatternGuards Rank2Types RankNTypes ScopedTypeVariables TupleSections TypeOperators TypeSynonymInstances Build-Depends : base >= 4.8 && < 5 , base-compat >= 0.6 , ghc , array, async, containers, deepseq, directory, filepath, old-time , pretty, process, mtl, QuickCheck, random, syb, data-binary-ieee754 , crackNum Exposed-modules : Data.SBV , Data.SBV.Bridge.Boolector , Data.SBV.Bridge.CVC4 , Data.SBV.Bridge.MathSAT , Data.SBV.Bridge.Yices , Data.SBV.Bridge.Z3 , Data.SBV.Bridge.ABC , Data.SBV.Dynamic , Data.SBV.Internals , Data.SBV.Examples.BitPrecise.BitTricks , Data.SBV.Examples.BitPrecise.Legato , Data.SBV.Examples.BitPrecise.MergeSort , Data.SBV.Examples.BitPrecise.MultMask , Data.SBV.Examples.BitPrecise.PrefixSum , Data.SBV.Examples.CodeGeneration.AddSub , Data.SBV.Examples.CodeGeneration.CRC_USB5 , Data.SBV.Examples.CodeGeneration.Fibonacci , Data.SBV.Examples.CodeGeneration.GCD , Data.SBV.Examples.CodeGeneration.PopulationCount , Data.SBV.Examples.CodeGeneration.Uninterpreted , Data.SBV.Examples.Crypto.AES , Data.SBV.Examples.Crypto.RC4 , Data.SBV.Examples.Existentials.CRCPolynomial , Data.SBV.Examples.Existentials.Diophantine , Data.SBV.Examples.Misc.Enumerate , Data.SBV.Examples.Misc.Floating , Data.SBV.Examples.Misc.ModelExtract , Data.SBV.Examples.Misc.Auxiliary , Data.SBV.Examples.Misc.NoDiv0 , Data.SBV.Examples.Misc.Word4 , Data.SBV.Examples.Polynomials.Polynomials , Data.SBV.Examples.Puzzles.Birthday , Data.SBV.Examples.Puzzles.Coins , Data.SBV.Examples.Puzzles.Counts , Data.SBV.Examples.Puzzles.DogCatMouse , Data.SBV.Examples.Puzzles.Euler185 , Data.SBV.Examples.Puzzles.Fish , Data.SBV.Examples.Puzzles.MagicSquare , Data.SBV.Examples.Puzzles.NQueens , Data.SBV.Examples.Puzzles.SendMoreMoney , Data.SBV.Examples.Puzzles.Sudoku , Data.SBV.Examples.Puzzles.U2Bridge , Data.SBV.Examples.Uninterpreted.AUF , Data.SBV.Examples.Uninterpreted.Deduce , Data.SBV.Examples.Uninterpreted.Function , Data.SBV.Examples.Uninterpreted.Shannon , Data.SBV.Examples.Uninterpreted.Sort , Data.SBV.Examples.Uninterpreted.UISortAllSat Other-modules : Data.SBV.BitVectors.AlgReals , Data.SBV.BitVectors.Concrete , Data.SBV.BitVectors.Data , Data.SBV.BitVectors.Kind , Data.SBV.BitVectors.Model , Data.SBV.BitVectors.Operations , Data.SBV.BitVectors.PrettyNum , Data.SBV.BitVectors.Floating , Data.SBV.BitVectors.Splittable , Data.SBV.BitVectors.STree , Data.SBV.BitVectors.Symbolic , Data.SBV.Compilers.C , Data.SBV.Compilers.CodeGen , Data.SBV.SMT.SMT , Data.SBV.SMT.SMTLib , Data.SBV.SMT.SMTLib2 , Data.SBV.SMT.SMTLibNames , Data.SBV.Provers.Prover , Data.SBV.Provers.SExpr , Data.SBV.Provers.Boolector , Data.SBV.Provers.CVC4 , Data.SBV.Provers.Yices , Data.SBV.Provers.Z3 , Data.SBV.Provers.MathSAT , Data.SBV.Provers.ABC , Data.SBV.Tools.ExpectedValue , Data.SBV.Tools.GenTest , Data.SBV.Tools.Optimize , Data.SBV.Tools.Polynomial , Data.SBV.Utils.Boolean , Data.SBV.Utils.Numeric , Data.SBV.Utils.TDiff , Data.SBV.Utils.Lib , GHC.SrcLoc.Compat , GHC.Stack.Compat Executable SBVUnitTests default-language: Haskell2010 ghc-options : -Wall other-extensions: DeriveAnyClass Rank2Types RankNTypes ScopedTypeVariables TupleSections Build-depends : base >= 4.8 && < 5 , HUnit, directory, filepath, process, syb, sbv, data-binary-ieee754 Hs-Source-Dirs : SBVUnitTest main-is : SBVUnitTest.hs Other-modules : SBVUnitTestBuildTime , SBVTest , SBVTestCollection , Examples.Arrays.Memory , Examples.Basics.BasicTests , Examples.Basics.Higher , Examples.Basics.Index , Examples.Basics.ProofTests , Examples.Basics.QRem , Examples.CRC.CCITT , Examples.CRC.CCITT_Unidir , Examples.CRC.GenPoly , Examples.CRC.Parity , Examples.CRC.USB5 , Examples.Puzzles.PowerSet , Examples.Puzzles.Temperature , Examples.Uninterpreted.Uninterpreted , TestSuite.Arrays.Memory , TestSuite.Basics.ArithNoSolver , TestSuite.Basics.ArithSolver , TestSuite.Basics.BasicTests , TestSuite.Basics.Higher , TestSuite.Basics.Index , TestSuite.Basics.IteTest , TestSuite.Basics.ProofTests , TestSuite.Basics.QRem , TestSuite.BitPrecise.BitTricks , TestSuite.BitPrecise.Legato , TestSuite.BitPrecise.MergeSort , TestSuite.BitPrecise.PrefixSum , TestSuite.CodeGeneration.AddSub , TestSuite.CodeGeneration.CgTests , TestSuite.CodeGeneration.CRC_USB5 , TestSuite.CodeGeneration.Fibonacci , TestSuite.CodeGeneration.Floats , TestSuite.CodeGeneration.GCD , TestSuite.CodeGeneration.PopulationCount , TestSuite.CodeGeneration.Uninterpreted , TestSuite.Crypto.AES , TestSuite.Crypto.RC4 , TestSuite.Existentials.CRCPolynomial , TestSuite.CRC.CCITT , TestSuite.CRC.CCITT_Unidir , TestSuite.CRC.GenPoly , TestSuite.CRC.Parity , TestSuite.CRC.USB5 , TestSuite.Puzzles.Coins , TestSuite.Polynomials.Polynomials , TestSuite.Puzzles.Counts , TestSuite.Puzzles.DogCatMouse , TestSuite.Puzzles.Euler185 , TestSuite.Puzzles.MagicSquare , TestSuite.Puzzles.NQueens , TestSuite.Puzzles.PowerSet , TestSuite.Puzzles.Sudoku , TestSuite.Puzzles.U2Bridge , TestSuite.Puzzles.Temperature , TestSuite.Uninterpreted.AUF , TestSuite.Uninterpreted.Function , TestSuite.Uninterpreted.Uninterpreted , TestSuite.Uninterpreted.Sort , TestSuite.Uninterpreted.Axioms Test-Suite SBVBasicTests type : exitcode-stdio-1.0 default-language: Haskell2010 ghc-options : -Wall -with-rtsopts=-K64m Build-depends : base >= 4.8 && < 5 , HUnit, directory, filepath, syb, sbv, data-binary-ieee754 Hs-Source-Dirs : SBVUnitTest main-is : SBVBasicTests.hs Other-modules : SBVBasicTests , SBVTestCollection sbv-5.12/Setup.hs0000644000000000000000000000071412725411266012065 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Main -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Setup module for the sbv library ----------------------------------------------------------------------------- {-# OPTIONS_GHC -Wall #-} module Main(main) where import Distribution.Simple main :: IO () main = defaultMain sbv-5.12/Data/0000755000000000000000000000000012725411265011277 5ustar0000000000000000sbv-5.12/Data/SBV.hs0000644000000000000000000010720112725411265012266 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- (The sbv library is hosted at . -- Comments, bug reports, and patches are always welcome.) -- -- SBV: SMT Based Verification -- -- Express properties about Haskell programs and automatically prove -- them using SMT solvers. -- -- >>> prove $ \x -> x `shiftL` 2 .== 4 * (x :: SWord8) -- Q.E.D. -- -- >>> prove $ \x -> x `shiftL` 2 .== 2 * (x :: SWord8) -- Falsifiable. Counter-example: -- s0 = 32 :: Word8 -- -- The function 'prove' has the following type: -- -- @ -- 'prove' :: 'Provable' a => a -> 'IO' 'ThmResult' -- @ -- -- The class 'Provable' comes with instances for n-ary predicates, for arbitrary n. -- The predicates are just regular Haskell functions over symbolic types listed below. -- Functions for checking satisfiability ('sat' and 'allSat') are also -- provided. -- -- The sbv library introduces the following symbolic types: -- -- * 'SBool': Symbolic Booleans (bits). -- -- * 'SWord8', 'SWord16', 'SWord32', 'SWord64': Symbolic Words (unsigned). -- -- * 'SInt8', 'SInt16', 'SInt32', 'SInt64': Symbolic Ints (signed). -- -- * 'SInteger': Unbounded signed integers. -- -- * 'SReal': Algebraic-real numbers -- -- * 'SFloat': IEEE-754 single-precision floating point values -- -- * 'SDouble': IEEE-754 double-precision floating point values -- -- * 'SArray', 'SFunArray': Flat arrays of symbolic values. -- -- * Symbolic polynomials over GF(2^n), polynomial arithmetic, and CRCs. -- -- * Uninterpreted constants and functions over symbolic values, with user -- defined SMT-Lib axioms. -- -- * Uninterpreted sorts, and proofs over such sorts, potentially with axioms. -- -- The user can construct ordinary Haskell programs using these types, which behave -- very similar to their concrete counterparts. In particular these types belong to the -- standard classes 'Num', 'Bits', custom versions of 'Eq' ('EqSymbolic') -- and 'Ord' ('OrdSymbolic'), along with several other custom classes for simplifying -- programming with symbolic values. The framework takes full advantage of Haskell's type -- inference to avoid many common mistakes. -- -- Furthermore, predicates (i.e., functions that return 'SBool') built out of -- these types can also be: -- -- * proven correct via an external SMT solver (the 'prove' function) -- -- * checked for satisfiability (the 'sat', 'allSat' functions) -- -- * used in synthesis (the `sat` function with existentials) -- -- * quick-checked -- -- If a predicate is not valid, 'prove' will return a counterexample: An -- assignment to inputs such that the predicate fails. The 'sat' function will -- return a satisfying assignment, if there is one. The 'allSat' function returns -- all satisfying assignments, lazily. -- -- The sbv library uses third-party SMT solvers via the standard SMT-Lib interface: -- -- -- The SBV library is designed to work with any SMT-Lib compliant SMT-solver. -- Currently, we support the following SMT-Solvers out-of-the box: -- -- * ABC from University of Berkeley: -- -- * CVC4 from New York University and University of Iowa: -- -- * Boolector from Johannes Kepler University: -- -- * MathSAT from Fondazione Bruno Kessler and DISI-University of Trento: -- -- * Yices from SRI: -- -- * Z3 from Microsoft: -- -- SBV also allows calling these solvers in parallel, either getting results from multiple solvers -- or returning the fastest one. (See 'proveWithAll', 'proveWithAny', etc.) -- -- Support for other compliant solvers can be added relatively easily, please -- get in touch if there is a solver you'd like to see included. --------------------------------------------------------------------------------- {-# LANGUAGE FlexibleInstances #-} module Data.SBV ( -- * Programming with symbolic values -- $progIntro -- ** Symbolic types -- *** Symbolic bit SBool -- *** Unsigned symbolic bit-vectors , SWord8, SWord16, SWord32, SWord64 -- *** Signed symbolic bit-vectors , SInt8, SInt16, SInt32, SInt64 -- *** Signed unbounded integers -- $unboundedLimitations , SInteger -- *** IEEE-floating point numbers -- $floatingPoints , SFloat, SDouble, IEEEFloating(..), IEEEFloatConvertable(..), RoundingMode(..), SRoundingMode, nan, infinity, sNaN, sInfinity -- **** Rounding modes , sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, sRoundTowardZero, sRNE, sRNA, sRTP, sRTN, sRTZ -- **** Bit-pattern conversions , sFloatAsSWord32, sWord32AsSFloat, sDoubleAsSWord64, sWord64AsSDouble, blastSFloat, blastSDouble -- *** Signed algebraic reals -- $algReals , SReal, AlgReal, sIntegerToSReal -- ** Creating a symbolic variable -- $createSym , sBool, sWord8, sWord16, sWord32, sWord64, sInt8, sInt16, sInt32, sInt64, sInteger, sReal, sFloat, sDouble -- ** Creating a list of symbolic variables -- $createSyms , sBools, sWord8s, sWord16s, sWord32s, sWord64s, sInt8s, sInt16s, sInt32s, sInt64s, sIntegers, sReals, sFloats, sDoubles -- *** Abstract SBV type , SBV -- *** Arrays of symbolic values , SymArray(..), SArray, SFunArray, mkSFunArray -- *** Full binary trees , STree, readSTree, writeSTree, mkSTree -- ** Operations on symbolic values -- *** Word level , sTestBit, sExtractBits, sPopCount, sShiftLeft, sShiftRight, sRotateLeft, sRotateRight, sSignedShiftArithRight, sFromIntegral, setBitTo, oneIf , lsb, msb, label -- *** Predicates , allEqual, allDifferent, inRange, sElem -- *** Addition and Multiplication with high-bits , fullAdder, fullMultiplier -- *** Exponentiation , (.^) -- *** Blasting/Unblasting , blastBE, blastLE, FromBits(..) -- *** Splitting, joining, and extending , Splittable(..) -- ** Polynomial arithmetic and CRCs , Polynomial(..), crcBV, crc -- ** Conditionals: Mergeable values , Mergeable(..), ite, iteLazy -- ** Symbolic equality , EqSymbolic(..) -- ** Symbolic ordering , OrdSymbolic(..) -- ** Symbolic integral numbers , SIntegral -- ** Division , SDivisible(..) -- ** The Boolean class , Boolean(..) -- *** Generalizations of boolean operations , bAnd, bOr, bAny, bAll -- ** Pretty-printing and reading numbers in Hex & Binary , PrettyNum(..), readBin -- * Checking satisfiability in path conditions , isSatisfiableInCurrentPath -- * Uninterpreted sorts, constants, and functions -- $uninterpreted , Uninterpreted(..), addAxiom -- * Enumerations -- $enumerations -- * Properties, proofs, satisfiability, and safety -- $proveIntro -- ** Predicates , Predicate, Provable(..), Equality(..) -- ** Proving properties , prove, proveWith, isTheorem, isTheoremWith -- ** Checking satisfiability , sat, satWith, isSatisfiable, isSatisfiableWith -- ** Checking safety -- $safeIntro , sAssert, safe, safeWith, isSafe, SExecutable(..) -- ** Finding all satisfying assignments , allSat, allSatWith -- ** Satisfying a sequence of boolean conditions , solve -- ** Adding constraints -- $constrainIntro , constrain, pConstrain -- ** Checking constraint vacuity , isVacuous, isVacuousWith -- ** Quick-checking , sbvQuickCheck -- * Proving properties using multiple solvers -- $multiIntro , proveWithAll, proveWithAny, satWithAll, satWithAny -- * Optimization -- $optimizeIntro , minimize, maximize, optimize , minimizeWith, maximizeWith, optimizeWith -- * Computing expected values , expectedValue, expectedValueWith -- * Model extraction -- $modelExtraction -- ** Inspecting proof results -- $resultTypes , ThmResult(..), SatResult(..), SafeResult(..), AllSatResult(..), SMTResult(..) -- ** Programmable model extraction -- $programmableExtraction , SatModel(..), Modelable(..), displayModels, extractModels , getModelDictionaries, getModelValues, getModelUninterpretedValues -- * SMT Interface: Configurations and solvers , SMTConfig(..), SMTLibVersion(..), SMTLibLogic(..), Logic(..), OptimizeOpts(..), Solver(..), SMTSolver(..), boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, sbvCurrentSolver, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers -- * Symbolic computations , Symbolic, output, SymWord(..) -- * Getting SMT-Lib output (for offline analysis) , compileToSMTLib, generateSMTBenchmarks -- * Test case generation , genTest, getTestValues, TestVectors, TestStyle(..), renderTest, CW(..), HasKind(..), Kind(..), cwToBool -- * Code generation from symbolic programs -- $cCodeGeneration , SBVCodeGen -- ** Setting code-generation options , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile -- ** Designating inputs , cgInput, cgInputArr -- ** Designating outputs , cgOutput, cgOutputArr -- ** Designating return values , cgReturn, cgReturnArr -- ** Code generation with uninterpreted functions , cgAddPrototype, cgAddDecl, cgAddLDFlags, cgIgnoreSAssert -- ** Code generation with 'SInteger' and 'SReal' types -- $unboundedCGen , cgIntegerSize, cgSRealType, CgSRealType(..) -- ** Compilation to C , compileToC, compileToCLib -- * Module exports -- $moduleExportIntro , module Data.Bits , module Data.Word , module Data.Int , module Data.Ratio ) where import Control.Monad (filterM) import Control.Concurrent.Async (async, waitAny, waitAnyCancel) import System.IO.Unsafe (unsafeInterleaveIO) -- only used safely! import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model import Data.SBV.BitVectors.Floating import Data.SBV.BitVectors.PrettyNum import Data.SBV.BitVectors.Splittable import Data.SBV.BitVectors.STree import Data.SBV.Compilers.C import Data.SBV.Compilers.CodeGen import Data.SBV.Provers.Prover import Data.SBV.Tools.GenTest import Data.SBV.Tools.ExpectedValue import Data.SBV.Tools.Optimize import Data.SBV.Tools.Polynomial import Data.SBV.Utils.Boolean import Data.Bits import Data.Int import Data.Ratio import Data.Word -- | The currently active solver, obtained by importing "Data.SBV". -- To have other solvers /current/, import one of the bridge -- modules "Data.SBV.Bridge.ABC", "Data.SBV.Bridge.Boolector", "Data.SBV.Bridge.CVC4", -- "Data.SBV.Bridge.Yices", or "Data.SBV.Bridge.Z3" directly. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = z3 -- | Form the symbolic conjunction of a given list of boolean conditions. Useful in expressing -- problems with constraints, like the following: -- -- @ -- do [x, y, z] <- sIntegers [\"x\", \"y\", \"z\"] -- solve [x .> 5, y + z .< x] -- @ solve :: [SBool] -> Symbolic SBool solve = return . bAnd -- | Check whether the given solver is installed and is ready to go. This call does a -- simple call to the solver to ensure all is well. sbvCheckSolverInstallation :: SMTConfig -> IO Bool sbvCheckSolverInstallation cfg = do ThmResult r <- proveWith cfg $ \x -> (x+x) .== ((x*2) :: SWord8) case r of Unsatisfiable _ -> return True _ -> return False -- | The default configs corresponding to supported SMT solvers defaultSolverConfig :: Solver -> SMTConfig defaultSolverConfig Z3 = z3 defaultSolverConfig Yices = yices defaultSolverConfig Boolector = boolector defaultSolverConfig CVC4 = cvc4 defaultSolverConfig MathSAT = mathSAT defaultSolverConfig ABC = abc -- | Return the known available solver configs, installed on your machine. sbvAvailableSolvers :: IO [SMTConfig] sbvAvailableSolvers = filterM sbvCheckSolverInstallation (map defaultSolverConfig [minBound .. maxBound]) sbvWithAny :: [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO (Solver, b) sbvWithAny [] _ _ = error "SBV.withAny: No solvers given!" sbvWithAny solvers what a = snd `fmap` (mapM try solvers >>= waitAnyCancel) where try s = async $ what s a >>= \r -> return (name (solver s), r) sbvWithAll :: [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO [(Solver, b)] sbvWithAll solvers what a = mapM try solvers >>= (unsafeInterleaveIO . go) where try s = async $ what s a >>= \r -> return (name (solver s), r) go [] = return [] go as = do (d, r) <- waitAny as -- The following filter works because the Eq instance on Async -- checks the thread-id; so we know that we're removing the -- correct solver from the list. This also allows for -- running the same-solver (with different options), since -- they will get different thread-ids. rs <- unsafeInterleaveIO $ go (filter (/= d) as) return (r : rs) -- | Prove a property with multiple solvers, running them in separate threads. The -- results will be returned in the order produced. proveWithAll :: Provable a => [SMTConfig] -> a -> IO [(Solver, ThmResult)] proveWithAll = (`sbvWithAll` proveWith) -- | Prove a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed. proveWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, ThmResult) proveWithAny = (`sbvWithAny` proveWith) -- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. The -- results will be returned in the order produced. satWithAll :: Provable a => [SMTConfig] -> a -> IO [(Solver, SatResult)] satWithAll = (`sbvWithAll` satWith) -- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. Only -- the result of the first one to finish will be returned, remaining threads will be killed. satWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, SatResult) satWithAny = (`sbvWithAny` satWith) -- | Equality as a proof method. Allows for -- very concise construction of equivalence proofs, which is very typical in -- bit-precise proofs. infix 4 === class Equality a where (===) :: a -> a -> IO ThmResult instance {-# OVERLAPPABLE #-} (SymWord a, EqSymbolic z) => Equality (SBV a -> z) where k === l = prove $ \a -> k a .== l a instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, EqSymbolic z) => Equality (SBV a -> SBV b -> z) where k === l = prove $ \a b -> k a b .== l a b instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, EqSymbolic z) => Equality ((SBV a, SBV b) -> z) where k === l = prove $ \a b -> k (a, b) .== l (a, b) instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> z) where k === l = prove $ \a b c -> k a b c .== l a b c instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c) -> z) where k === l = prove $ \a b c -> k (a, b, c) .== l (a, b, c) instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> z) where k === l = prove $ \a b c d -> k a b c d .== l a b c d instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d) -> z) where k === l = prove $ \a b c d -> k (a, b, c, d) .== l (a, b, c, d) instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) where k === l = prove $ \a b c d e -> k a b c d e .== l a b c d e instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e) -> z) where k === l = prove $ \a b c d e -> k (a, b, c, d, e) .== l (a, b, c, d, e) instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> z) where k === l = prove $ \a b c d e f -> k a b c d e f .== l a b c d e f instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> z) where k === l = prove $ \a b c d e f -> k (a, b, c, d, e, f) .== l (a, b, c, d, e, f) instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> SBV g -> z) where k === l = prove $ \a b c d e f g -> k a b c d e f g .== l a b c d e f g instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> z) where k === l = prove $ \a b c d e f g -> k (a, b, c, d, e, f, g) .== l (a, b, c, d, e, f, g) -- Haddock section documentation {- $progIntro The SBV library is really two things: * A framework for writing symbolic programs in Haskell, i.e., programs operating on symbolic values along with the usual concrete counterparts. * A framework for proving properties of such programs using SMT solvers. The programming goal of SBV is to provide a /seamless/ experience, i.e., let people program in the usual Haskell style without distractions of symbolic coding. While Haskell helps in some aspects (the 'Num' and 'Bits' classes simplify coding), it makes life harder in others. For instance, @if-then-else@ only takes 'Bool' as a test in Haskell, and comparisons ('>' etc.) only return 'Bool's. Clearly we would like these values to be symbolic (i.e., 'SBool'), thus stopping us from using some native Haskell constructs. When symbolic versions of operators are needed, they are typically obtained by prepending a dot, for instance '==' becomes '.=='. Care has been taken to make the transition painless. In particular, any Haskell program you build out of symbolic components is fully concretely executable within Haskell, without the need for any custom interpreters. (They are truly Haskell programs, not AST's built out of pieces of syntax.) This provides for an integrated feel of the system, one of the original design goals for SBV. -} {- $proveIntro The SBV library provides a "push-button" verification system via automated SMT solving. The design goal is to let SMT solvers be used without any knowledge of how SMT solvers work or how different logics operate. The details are hidden behind the SBV framework, providing Haskell programmers with a clean API that is unencumbered by the details of individual solvers. To that end, we use the SMT-Lib standard () to communicate with arbitrary SMT solvers. -} {- $multiIntro On a multi-core machine, it might be desirable to try a given property using multiple SMT solvers, using parallel threads. Even with machines with single-cores, threading can be helpful if you want to try out multiple-solvers but do not know which one would work the best for the problem at hand ahead of time. The functions in this section allow proving/satisfiability-checking with multiple backends at the same time. Each function comes in two variants, one that returns the results from all solvers, the other that returns the fastest one. The @All@ variants, (i.e., 'proveWithAll', 'satWithAll') run all solvers and return all the results. SBV internally makes sure that the result is lazily generated; so, the order of solvers given does not matter. In other words, the order of results will follow the order of the solvers as they finish, not as given by the user. These variants are useful when you want to make sure multiple-solvers agree (or disagree!) on a given problem. The @Any@ variants, (i.e., 'proveWithAny', 'satWithAny') will run all the solvers in parallel, and return the results of the first one finishing. The other threads will then be killed. These variants are useful when you do not care if the solvers produce the same result, but rather want to get the solution as quickly as possible, taking advantage of modern many-core machines. Note that the function 'sbvAvailableSolvers' will return all the installed solvers, which can be used as the first argument to all these functions, if you simply want to try all available solvers on a machine. -} {- $safeIntro The 'sAssert' function allows users to introduce invariants to make sure certain properties hold at all times. This is another mechanism to provide further documentation/contract info into SBV code. The functions 'safe' and 'safeWith' can be used to statically discharge these proof assumptions. If a violation is found, SBV will print a model showing which inputs lead to the invariant being violated. Here's a simple example. Let's assume we have a function that does subtraction, and requires its first argument to be larger than the second: >>> let sub x y = sAssert Nothing "sub: x >= y must hold!" (x .>= y) (x - y) Clearly, this function is not safe, as there's nothing that stops us from passing it a larger second argument. We can use 'safe' to statically see if such a violation is possible before we use this function elsewhere. >>> safe (sub :: SInt8 -> SInt8 -> SInt8) [sub: x >= y must hold!: Violated. Model: s0 = -128 :: Int8 s1 = -127 :: Int8] What happens if we make sure to arrange for this invariant? Consider this version: >>> let safeSub x y = ite (x .>= y) (sub x y) 0 Clearly, 'safeSub' must be safe. And indeed, SBV can prove that: >>> safe (safeSub :: SInt8 -> SInt8 -> SInt8) [sub: x >= y must hold!: No violations detected] Note how we used 'sub' and 'safeSub' polymorphically. We only need to monomorphise our types when a proof attempt is done, as we did in the 'safe' calls. If required, the user can pass a 'CallStack' through the first argument to 'sAssert', which will be used by SBV to print a diagnostic info to pinpoint the failure. Also see "Data.SBV.Examples.Misc.NoDiv0" for the classic div-by-zero example. -} {- $optimizeIntro Symbolic optimization. A call of the form: @minimize Quantified cost n valid@ returns @Just xs@, such that: * @xs@ has precisely @n@ elements * @valid xs@ holds * @cost xs@ is minimal. That is, for all sequences @ys@ that satisfy the first two criteria above, @cost xs .<= cost ys@ holds. If there is no such sequence, then 'minimize' will return 'Nothing'. The function 'maximize' is similar, except the comparator is '.>='. So the value returned has the largest cost (or value, in that case). The function 'optimize' allows the user to give a custom comparison function. The 'OptimizeOpts' argument controls how the optimization is done. If 'Quantified' is used, then the SBV optimization engine satisfies the following predicate: @exists xs. forall ys. valid xs && (valid ys \`implies\` (cost xs \`cmp\` cost ys))@ Note that this may cause efficiency problems as it involves alternating quantifiers. If 'OptimizeOpts' is set to 'Iterative' 'True', then SBV will programmatically search for an optimal solution, by repeatedly calling the solver appropriately. (The boolean argument controls whether progress reports are given. Use 'False' for quiet operation.) === Quantified vs Iterative Note that the quantified and iterative versions are two different optimization approaches and may not necessarily yield the same results. In particular, the quantified version can tell us no such solution exists if there is no global optimum value, while the iterative version might simply loop forever for such a problem. To wit, consider the example: @ maximize Quantified head 1 (const true :: [SInteger] -> SBool) @ which asks for the largest `SInteger` value. The SMT solver will happily answer back saying there is no such value with the 'Quantified' call, but the 'Iterative' variant will simply loop forever as it would search through an infinite chain of ascending 'SInteger' values. In practice, however, the iterative version is usually the more effective choice since alternating quantifiers are hard to deal with for many SMT-solvers and thus will likely result in an @unknown@ result. While the 'Iterative' variant can loop for a long time, one can simply use the boolean flag 'True' and see how the search is progressing. -} {- $modelExtraction The default 'Show' instances for prover calls provide all the counter-example information in a human-readable form and should be sufficient for most casual uses of sbv. However, tools built on top of sbv will inevitably need to look into the constructed models more deeply, programmatically extracting their results and performing actions based on them. The API provided in this section aims at simplifying this task. -} {- $resultTypes 'ThmResult', 'SatResult', and 'AllSatResult' are simple newtype wrappers over 'SMTResult'. Their main purpose is so that we can provide custom 'Show' instances to print results accordingly. -} {- $programmableExtraction While default 'Show' instances are sufficient for most use cases, it is sometimes desirable (especially for library construction) that the SMT-models are reinterpreted in terms of domain types. Programmable extraction allows getting arbitrarily typed models out of SMT models. -} {- $cCodeGeneration The SBV library can generate straight-line executable code in C. (While other target languages are certainly possible, currently only C is supported.) The generated code will perform no run-time memory-allocations, (no calls to @malloc@), so its memory usage can be predicted ahead of time. Also, the functions will execute precisely the same instructions in all calls, so they have predictable timing properties as well. The generated code has no loops or jumps, and is typically quite fast. While the generated code can be large due to complete unrolling, these characteristics make them suitable for use in hard real-time systems, as well as in traditional computing. -} {- $unboundedCGen The types 'SInteger' and '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 'SInteger', and rounding for 'SReal', so there is an implicit loss of precision. If the user does /not/ specify these mappings, then SBV will refuse to compile programs that involve these types. -} {- $moduleExportIntro The SBV library exports the following modules wholesale, as user programs will have to import these modules to make any sensible use of the SBV functionality. -} {- $createSym These functions simplify declaring symbolic variables of various types. Strictly speaking, they are just synonyms for 'free' (specialized at the given type), but they might be easier to use. -} {- $createSyms These functions simplify declaring a sequence symbolic variables of various types. Strictly speaking, they are just synonyms for 'mapM' 'free' (specialized at the given type), but they might be easier to use. -} {- $unboundedLimitations The SBV library supports unbounded signed integers with the type 'SInteger', which are not subject to overflow/underflow as it is the case with the bounded types, such as 'SWord8', 'SInt16', etc. However, some bit-vector based operations are /not/ supported for the 'SInteger' type while in the verification mode. That is, you can use these operations on 'SInteger' values during normal programming/simulation. but the SMT translation will not support these operations since there corresponding operations are not supported in SMT-Lib. Note that this should rarely be a problem in practice, as these operations are mostly meaningful on fixed-size bit-vectors. The operations that are restricted to bounded word/int sizes are: * Rotations and shifts: 'rotateL', 'rotateR', 'shiftL', 'shiftR' * Bitwise logical ops: '.&.', '.|.', 'xor', 'complement' * Extraction and concatenation: 'split', '#', and 'extend' (see the 'Splittable' class) Usual arithmetic ('+', '-', '*', 'sQuotRem', 'sQuot', 'sRem', 'sDivMod', 'sDiv', 'sMod') and logical operations ('.<', '.<=', '.>', '.>=', '.==', './=') operations are supported for 'SInteger' fully, both in programming and verification modes. -} {- $algReals Algebraic reals are roots of single-variable polynomials with rational coefficients. (See .) Note that algebraic reals are infinite precision numbers, but they do not cover all /real/ numbers. (In particular, they cannot represent transcendentals.) Some irrational numbers are algebraic (such as @sqrt 2@), while others are not (such as pi and e). SBV can deal with real numbers just fine, since the theory of reals is decidable. (See .) In addition, by leveraging backend solver capabilities, SBV can also represent and solve non-linear equations involving real-variables. (For instance, the Z3 SMT solver, supports polynomial constraints on reals starting with v4.0.) -} {- $floatingPoints Floating point numbers are defined by the IEEE-754 standard; and correspond to Haskell's 'Float' and 'Double' types. For SMT support with floating-point numbers, see the paper by Rummer and Wahl: . -} {- $constrainIntro A constraint is a means for restricting the input domain of a formula. Here's a simple example: @ do x <- 'exists' \"x\" y <- 'exists' \"y\" 'constrain' $ x .> y 'constrain' $ x + y .>= 12 'constrain' $ y .>= 3 ... @ The first constraint requires @x@ to be larger than @y@. The scond one says that sum of @x@ and @y@ must be at least @12@, and the final one says that @y@ to be at least @3@. Constraints provide an easy way to assert additional properties on the input domain, right at the point of the introduction of variables. Note that the proper reading of a constraint depends on the context: * In a 'sat' (or 'allSat') call: The constraint added is asserted conjunctively. That is, the resulting satisfying model (if any) will always satisfy all the constraints given. * In a 'prove' call: In this case, the constraint acts as an implication. The property is proved under the assumption that the constraint holds. In other words, the constraint says that we only care about the input space that satisfies the constraint. * In a 'quickCheck' call: The constraint acts as a filter for 'quickCheck'; if the constraint does not hold, then the input value is considered to be irrelevant and is skipped. Note that this is similar to 'prove', but is stronger: We do not accept a test case to be valid just because the constraints fail on them, although semantically the implication does hold. We simply skip that test case as a /bad/ test vector. * In a 'genTest' call: Similar to 'quickCheck' and 'prove': If a constraint does not hold, the input value is ignored and is not included in the test set. A good use case (in fact the motivating use case) for 'constrain' is attaching a constraint to a 'forall' or 'exists' variable at the time of its creation. Also, the conjunctive semantics for 'sat' and the implicative semantics for 'prove' simplify programming by choosing the correct interpretation automatically. However, one should be aware of the semantic difference. For instance, in the presence of constraints, formulas that are /provable/ are not necessarily /satisfiable/. To wit, consider: @ do x <- 'exists' \"x\" 'constrain' $ x .< x return $ x .< (x :: 'SWord8') @ This predicate is unsatisfiable since no element of 'SWord8' is less than itself. But it's (vacuously) true, since it excludes the entire domain of values, thus making the proof trivial. Hence, this predicate is provable, but is not satisfiable. To make sure the given constraints are not vacuous, the functions 'isVacuous' (and 'isVacuousWith') can be used. Also note that this semantics imply that test case generation ('genTest') and quick-check can take arbitrarily long in the presence of constraints, if the random input values generated rarely satisfy the constraints. (As an extreme case, consider @'constrain' 'false'@.) A probabilistic constraint (see 'pConstrain') attaches a probability threshold for the constraint to be considered. For instance: @ 'pConstrain' 0.8 c @ will make sure that the condition @c@ is satisfied 80% of the time (and correspondingly, falsified 20% of the time), in expectation. This variant is useful for 'genTest' and 'quickCheck' functions, where we want to filter the test cases according to some probability distribution, to make sure that the test-vectors are drawn from interesting subsets of the input space. For instance, if we were to generate 100 test cases with the above constraint, we'd expect about 80 of them to satisfy the condition @c@, while about 20 of them will fail it. The following properties hold: @ 'constrain' = 'pConstrain' 1 'pConstrain' t c = 'pConstrain' (1-t) (not c) @ Note that while 'constrain' can be used freely, 'pConstrain' is only allowed in the contexts of 'genTest' or 'quickCheck'. Calls to 'pConstrain' in a prove/sat call will be rejected as SBV does not deal with probabilistic constraints when it comes to satisfiability and proofs. Also, both 'constrain' and 'pConstrain' calls during code-generation will also be rejected, for similar reasons. -} {- $uninterpreted Users can introduce new uninterpreted sorts simply by defining a data-type in Haskell and registering it as such. The following example demonstrates: @ data B = B () deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel) @ (Note that you'll also need to use the language pragmas @DeriveDataTypeable@, @DeriveAnyClass@, and import @Data.Generics@ for the above to work.) This is all it takes to introduce 'B' as an uninterpreted sort in SBV, which makes the type @SBV B@ automagically become available as the type of symbolic values that ranges over 'B' values. Note that the @()@ argument is important to distinguish it from enumerations. Uninterpreted functions over both uninterpreted and regular sorts can be declared using the facilities introduced by the 'Uninterpreted' class. -} {- $enumerations If the uninterpreted sort definition takes the form of an enumeration (i.e., a simple data type with all nullary constructors), then SBV will actually translate that as just such a data-type to SMT-Lib, and will use the constructors as the inhabitants of the said sort. A simple example is: @ data X = A | B | C deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel) @ Now, the user can define @ type SX = SBV X @ and treat @SX@ as a regular symbolic type ranging over the values @A@, @B@, and @C@. Such values can be compared for equality, and with the usual other comparison operators, such as @.==@, @./=@, @.>@, @.>=@, @<@, and @<=@. Note that in this latter case the type is no longer uninterpreted, but is properly represented as a simple enumeration of the said elements. A simple query would look like: @ allSat $ \x -> x .== (x :: SX) @ which would list all three elements of this domain as satisfying solutions. @ Solution #1: s0 = A :: X Solution #2: s0 = B :: X Solution #3: s0 = C :: X Found 3 different solutions. @ Note that the result is properly typed as @X@ elements; these are not mere strings. So, in a 'getModel' scenario, the user can recover actual elements of the domain and program further with those values as usual. -} {-# ANN module ("HLint: ignore Use import/export shortcut" :: String) #-} sbv-5.12/Data/SBV/0000755000000000000000000000000012725411265011731 5ustar0000000000000000sbv-5.12/Data/SBV/Dynamic.hs0000644000000000000000000002264312725411265013660 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Dynamic -- Copyright : (c) Brian Huffman -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Dynamically typed low-level API to the SBV library, for users who -- want to generate symbolic values at run-time. Note that with this -- API it is possible to create terms that are not type correct; use -- at your own risk! --------------------------------------------------------------------------------- module Data.SBV.Dynamic ( -- * Programming with symbolic values -- ** Symbolic types -- *** Abstract symbolic value type SVal , HasKind(..), Kind(..), CW(..), CWVal(..), cwToBool -- *** Arrays of symbolic values , SArr , readSArr, resetSArr, writeSArr, mergeSArr, newSArr, eqSArr -- ** Creating a symbolic variable , Symbolic , Quantifier(..) , svMkSymVar -- ** Operations on symbolic values -- *** Boolean literals , svTrue, svFalse, svBool, svAsBool -- *** Integer literals , svInteger, svAsInteger -- *** Float literals , svFloat, svDouble -- ** Algrebraic reals (only from rationals) , svReal, svNumerator, svDenominator -- *** Symbolic equality , svEqual, svNotEqual -- *** Constructing concrete lists , svEnumFromThenTo -- *** Symbolic ordering , svLessThan, svGreaterThan, svLessEq, svGreaterEq -- *** Arithmetic operations , svPlus, svTimes, svMinus, svUNeg, svAbs , svDivide, svQuot, svRem, svExp , svAddConstant, svIncrement, svDecrement -- *** Logical operations , svAnd, svOr, svXOr, svNot , svShl, svShr, svRol, svRor -- *** Splitting, joining, and extending , svExtract, svJoin -- *** Sign-casting , svSign, svUnsign -- *** Indexed lookups , svSelect -- *** Word-level operations , svToWord1, svFromWord1, svTestBit, svSetBit , svShiftLeft, svShiftRight , svRotateLeft, svRotateRight , svWordFromBE, svWordFromLE , svBlastLE, svBlastBE -- ** Conditionals: Mergeable values , svIte, svLazyIte, svSymbolicMerge , svIsSatisfiableInCurrentPath -- * Uninterpreted sorts, constants, and functions , svUninterpreted -- * Properties, proofs, and satisfiability -- ** Proving properties , proveWith -- ** Checking satisfiability , satWith, allSatWith -- ** Checking safety , safeWith -- * Proving properties using multiple solvers , proveWithAll, proveWithAny, satWithAll, satWithAny -- * Quick-check , svQuickCheck -- * Model extraction -- ** Inspecting proof results , ThmResult(..), SatResult(..), SafeResult(..), AllSatResult(..), SMTResult(..) -- ** Programmable model extraction , genParse, getModel, getModelDictionary -- * SMT Interface: Configurations and solvers , SMTConfig(..), SMTLibVersion(..), SMTLibLogic(..), Logic(..), OptimizeOpts(..), Solver(..), SMTSolver(..), boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, sbvCurrentSolver, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers -- * Symbolic computations , outputSVal -- * Getting SMT-Lib output (for offline analysis) , compileToSMTLib, generateSMTBenchmarks -- * Code generation from symbolic programs , SBVCodeGen -- ** Setting code-generation options , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile -- ** Designating inputs , svCgInput, svCgInputArr -- ** Designating outputs , svCgOutput, svCgOutputArr -- ** Designating return values , svCgReturn, svCgReturnArr -- ** Code generation with uninterpreted functions , cgAddPrototype, cgAddDecl, cgAddLDFlags, cgIgnoreSAssert -- ** Code generation with 'SInteger' and 'SReal' types , cgIntegerSize, cgSRealType, CgSRealType(..) -- ** Compilation to C , compileToC, compileToCLib ) where import Data.Map (Map) import Data.SBV.BitVectors.Kind import Data.SBV.BitVectors.Concrete import Data.SBV.BitVectors.Symbolic import Data.SBV.BitVectors.Operations import Data.SBV.Compilers.CodeGen ( SBVCodeGen , svCgInput, svCgInputArr , svCgOutput, svCgOutputArr , svCgReturn, svCgReturnArr , cgPerformRTCs, cgSetDriverValues, cgGenerateDriver, cgGenerateMakefile , cgAddPrototype, cgAddDecl, cgAddLDFlags, cgIgnoreSAssert , cgIntegerSize, cgSRealType, CgSRealType(..) ) import Data.SBV.Compilers.C (compileToC, compileToCLib) import Data.SBV.Provers.Prover (boolector, cvc4, yices, z3, mathSAT, abc, defaultSMTCfg) import Data.SBV.SMT.SMT (ThmResult(..), SatResult(..), SafeResult(..), AllSatResult(..), genParse) import Data.SBV.Tools.Optimize (OptimizeOpts(..)) import Data.SBV (sbvCurrentSolver, sbvCheckSolverInstallation, defaultSolverConfig, sbvAvailableSolvers) import qualified Data.SBV as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny) import qualified Data.SBV.BitVectors.Data as SBV (SBV(..)) import qualified Data.SBV.BitVectors.Model as SBV (isSatisfiableInCurrentPath, sbvQuickCheck) import qualified Data.SBV.Provers.Prover as SBV (proveWith, satWith, safeWith, allSatWith, compileToSMTLib, generateSMTBenchmarks) import qualified Data.SBV.SMT.SMT as SBV (Modelable(getModel, getModelDictionary)) -- | Reduce a condition (i.e., try to concretize it) under the given path svIsSatisfiableInCurrentPath :: SVal -> Symbolic Bool svIsSatisfiableInCurrentPath = SBV.isSatisfiableInCurrentPath . toSBool -- | Dynamic variant of quick-check svQuickCheck :: Symbolic SVal -> IO Bool svQuickCheck = SBV.sbvQuickCheck . fmap toSBool toSBool :: SVal -> SBV.SBool toSBool = SBV.SBV -- | Compiles to SMT-Lib and returns the resulting program as a string. Useful for saving -- the result to a file for off-line analysis, for instance if you have an SMT solver that's not natively -- supported out-of-the box by the SBV library. It takes two arguments: -- -- * version: The SMTLib-version to produce. Note that we currently only support SMTLib2. -- -- * isSat : If 'True', will translate it as a SAT query, i.e., in the positive. If 'False', will -- translate as a PROVE query, i.e., it will negate the result. (In this case, the check-sat -- call to the SMT solver will produce UNSAT if the input is a theorem, as usual.) compileToSMTLib :: SMTLibVersion -- ^ If True, output SMT-Lib2, otherwise SMT-Lib1 -> Bool -- ^ If True, translate directly, otherwise negate the goal. (Use True for SAT queries, False for PROVE queries.) -> Symbolic SVal -> IO String compileToSMTLib version isSat s = SBV.compileToSMTLib version isSat (fmap toSBool s) -- | Create both SMT-Lib1 and SMT-Lib2 benchmarks. The first argument is the basename of the file, -- SMT-Lib1 version will be written with suffix ".smt1" and SMT-Lib2 version will be written with -- suffix ".smt2". The 'Bool' argument controls whether this is a SAT instance, i.e., translate the query -- directly, or a PROVE instance, i.e., translate the negated query. (See the second boolean argument to -- 'compileToSMTLib' for details.) generateSMTBenchmarks :: Bool -> FilePath -> Symbolic SVal -> IO () generateSMTBenchmarks isSat f s = SBV.generateSMTBenchmarks isSat f (fmap toSBool s) -- | Proves the predicate using the given SMT-solver proveWith :: SMTConfig -> Symbolic SVal -> IO ThmResult proveWith cfg s = SBV.proveWith cfg (fmap toSBool s) -- | Find a satisfying assignment using the given SMT-solver satWith :: SMTConfig -> Symbolic SVal -> IO SatResult satWith cfg s = SBV.satWith cfg (fmap toSBool s) -- | Check safety using the given SMT-solver safeWith :: SMTConfig -> Symbolic SVal -> IO [SafeResult] safeWith cfg s = SBV.safeWith cfg (fmap toSBool s) -- | Find all satisfying assignments using the given SMT-solver allSatWith :: SMTConfig -> Symbolic SVal -> IO AllSatResult allSatWith cfg s = SBV.allSatWith cfg (fmap toSBool s) -- | Prove a property with multiple solvers, running them in separate threads. The -- results will be returned in the order produced. proveWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, ThmResult)] proveWithAll cfgs s = SBV.proveWithAll cfgs (fmap toSBool s) -- | Prove a property with multiple solvers, running them in separate -- threads. Only the result of the first one to finish will be -- returned, remaining threads will be killed. proveWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, ThmResult) proveWithAny cfgs s = SBV.proveWithAny cfgs (fmap toSBool s) -- | Find a satisfying assignment to a property with multiple solvers, -- running them in separate threads. The results will be returned in -- the order produced. satWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, SatResult)] satWithAll cfgs s = SBV.satWithAll cfgs (fmap toSBool s) -- | Find a satisfying assignment to a property with multiple solvers, -- running them in separate threads. Only the result of the first one -- to finish will be returned, remaining threads will be killed. satWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, SatResult) satWithAny cfgs s = SBV.satWithAny cfgs (fmap toSBool s) -- | Extract a model, the result is a tuple where the first argument (if True) -- indicates whether the model was "probable". (i.e., if the solver returned unknown.) getModel :: SMTResult -> Either String (Bool, [CW]) getModel = SBV.getModel -- | Extract a model dictionary. Extract a dictionary mapping the variables to -- their respective values as returned by the SMT solver. Also see `getModelDictionaries`. getModelDictionary :: SMTResult -> Map String CW getModelDictionary = SBV.getModelDictionary sbv-5.12/Data/SBV/Internals.hs0000644000000000000000000000445512725411265014234 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Internals -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Low level functions to access the SBV infrastructure, for developers who -- want to build further tools on top of SBV. End-users of the library -- should not need to use this module. --------------------------------------------------------------------------------- module Data.SBV.Internals ( -- * Running symbolic programs /manually/ Result(..), SBVRunMode(..), Symbolic, runSymbolic, runSymbolic' -- * Other internal structures useful for low-level programming , SBV(..), slet, CW(..), Kind(..), HasKind(..), CWVal(..), AlgReal(..), Quantifier(..), mkConstCW, genVar, genVar_ , liftQRem, liftDMod, symbolicMergeWithKind , cache, sbvToSW, newExpr, normCW, SBVExpr(..), Op(..) , SBVType(..), newUninterpreted, forceSWArg -- * Operations useful for instantiating SBV type classes , genLiteral, genFromCW, genMkSymVar, checkAndConvert, genParse, showModel, SMTModel(..), smtLibReservedNames -- * Polynomial operations that operate on bit-vectors , ites, mdp, addPoly -- * Compilation to C , compileToC', compileToCLib', CgPgmBundle(..), CgPgmKind(..) -- * Various math utilities around floats , module Data.SBV.Utils.Numeric ) where import Data.SBV.BitVectors.Data ( Result(..), Symbolic, SBVRunMode(..), runSymbolic, runSymbolic', SBV(..), CW(..), Kind(..), HasKind(..), CWVal(..) , AlgReal(..), Quantifier(..), mkConstCW, cache, sbvToSW, newExpr, normCW, SBVExpr(..), Op(..), SBVType(..) , newUninterpreted, forceSWArg, SMTModel(..)) import Data.SBV.BitVectors.Model (genVar, genVar_, slet, liftQRem, liftDMod, symbolicMergeWithKind, genLiteral, genFromCW, genMkSymVar) import Data.SBV.BitVectors.Splittable (checkAndConvert) import Data.SBV.Compilers.C (compileToC', compileToCLib') import Data.SBV.Compilers.CodeGen (CgPgmBundle(..), CgPgmKind(..)) import Data.SBV.SMT.SMT (genParse, showModel) import Data.SBV.SMT.SMTLibNames (smtLibReservedNames) import Data.SBV.Tools.Polynomial (ites, mdp, addPoly) import Data.SBV.Utils.Numeric sbv-5.12/Data/SBV/BitVectors/0000755000000000000000000000000012725411266014016 5ustar0000000000000000sbv-5.12/Data/SBV/BitVectors/AlgReals.hs0000644000000000000000000002705312725411266016053 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.AlgReals -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Algrebraic reals in Haskell. ----------------------------------------------------------------------------- {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeSynonymInstances #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.SBV.BitVectors.AlgReals (AlgReal(..), mkPolyReal, algRealToSMTLib2, algRealToHaskell, mergeAlgReals, isExactRational, algRealStructuralEqual, algRealStructuralCompare) where import Data.List (sortBy, isPrefixOf, partition) import Data.Ratio ((%), numerator, denominator) import Data.Function (on) import System.Random import Test.QuickCheck (Arbitrary(..)) -- | Algebraic reals. Note that the representation is left abstract. We represent -- rational results explicitly, while the roots-of-polynomials are represented -- implicitly by their defining equation data AlgReal = AlgRational Bool Rational -- bool says it's exact (i.e., SMT-solver did not return it with ? at the end.) | AlgPolyRoot (Integer, Polynomial) -- which root (Maybe String) -- approximate decimal representation with given precision, if available -- | Check wheter a given argument is an exact rational isExactRational :: AlgReal -> Bool isExactRational (AlgRational True _) = True isExactRational _ = False -- | A univariate polynomial, represented simply as a -- coefficient list. For instance, "5x^3 + 2x - 5" is -- represented as [(5, 3), (2, 1), (-5, 0)] newtype Polynomial = Polynomial [(Integer, Integer)] deriving (Eq, Ord) -- | Construct a poly-root real with a given approximate value (either as a decimal, or polynomial-root) mkPolyReal :: Either (Bool, String) (Integer, [(Integer, Integer)]) -> AlgReal mkPolyReal (Left (exact, str)) = case (str, break (== '.') str) of ("", (_, _)) -> AlgRational exact 0 (_, (x, '.':y)) -> AlgRational exact (read (x++y) % (10 ^ length y)) (_, (x, _)) -> AlgRational exact (read x % 1) mkPolyReal (Right (k, coeffs)) = AlgPolyRoot (k, Polynomial (normalize coeffs)) Nothing where normalize :: [(Integer, Integer)] -> [(Integer, Integer)] normalize = merge . sortBy (flip compare `on` snd) merge [] = [] merge [x] = [x] merge ((a, b):r@((c, d):xs)) | b == d = merge ((a+c, b):xs) | True = (a, b) : merge r instance Show Polynomial where show (Polynomial xs) = chkEmpty (join (concat [term p | p@(_, x) <- xs, x /= 0])) ++ " = " ++ show c where c = -1 * head ([k | (k, 0) <- xs] ++ [0]) term ( 0, _) = [] term ( 1, 1) = [ "x"] term ( 1, p) = [ "x^" ++ show p] term (-1, 1) = ["-x"] term (-1, p) = ["-x^" ++ show p] term (k, 1) = [show k ++ "x"] term (k, p) = [show k ++ "x^" ++ show p] join [] = "" join (k:ks) = k ++ s ++ join ks where s = case ks of [] -> "" (y:_) | "-" `isPrefixOf` y -> "" | "+" `isPrefixOf` y -> "" | True -> "+" chkEmpty s = if null s then "0" else s instance Show AlgReal where show (AlgRational exact a) = showRat exact a show (AlgPolyRoot (i, p) mbApprox) = "root(" ++ show i ++ ", " ++ show p ++ ")" ++ maybe "" app mbApprox where app v | last v == '?' = " = " ++ init v ++ "..." | True = " = " ++ v -- lift unary op through an exact rational, otherwise bail lift1 :: String -> (Rational -> Rational) -> AlgReal -> AlgReal lift1 _ o (AlgRational e a) = AlgRational e (o a) lift1 nm _ a = error $ "AlgReal." ++ nm ++ ": unsupported argument: " ++ show a -- lift binary op through exact rationals, otherwise bail lift2 :: String -> (Rational -> Rational -> Rational) -> AlgReal -> AlgReal -> AlgReal lift2 _ o (AlgRational True a) (AlgRational True b) = AlgRational True (a `o` b) lift2 nm _ a b = error $ "AlgReal." ++ nm ++ ": unsupported arguments: " ++ show (a, b) -- The idea in the instances below is that we will fully support operations -- on "AlgRational" AlgReals, but leave everything else undefined. When we are -- on the Haskell side, the AlgReal's are *not* reachable. They only represent -- return values from SMT solvers, which we should *not* need to manipulate. instance Eq AlgReal where AlgRational True a == AlgRational True b = a == b a == b = error $ "AlgReal.==: unsupported arguments: " ++ show (a, b) instance Ord AlgReal where AlgRational True a `compare` AlgRational True b = a `compare` b a `compare` b = error $ "AlgReal.compare: unsupported arguments: " ++ show (a, b) -- | Structural equality for AlgReal; used when constants are Map keys algRealStructuralEqual :: AlgReal -> AlgReal -> Bool AlgRational a b `algRealStructuralEqual` AlgRational c d = (a, b) == (c, d) AlgPolyRoot a b `algRealStructuralEqual` AlgPolyRoot c d = (a, b) == (c, d) _ `algRealStructuralEqual` _ = False -- | Structural comparisons for AlgReal; used when constants are Map keys algRealStructuralCompare :: AlgReal -> AlgReal -> Ordering AlgRational a b `algRealStructuralCompare` AlgRational c d = (a, b) `compare` (c, d) AlgRational _ _ `algRealStructuralCompare` AlgPolyRoot _ _ = LT AlgPolyRoot _ _ `algRealStructuralCompare` AlgRational _ _ = GT AlgPolyRoot a b `algRealStructuralCompare` AlgPolyRoot c d = (a, b) `compare` (c, d) instance Num AlgReal where (+) = lift2 "+" (+) (*) = lift2 "*" (*) (-) = lift2 "-" (-) negate = lift1 "negate" negate abs = lift1 "abs" abs signum = lift1 "signum" signum fromInteger = AlgRational True . fromInteger -- | NB: Following the other types we have, we require `a/0` to be `0` for all a. instance Fractional AlgReal where (AlgRational True _) / (AlgRational True b) | b == 0 = 0 a / b = lift2 "/" (/) a b fromRational = AlgRational True instance Real AlgReal where toRational (AlgRational True v) = v toRational x = error $ "AlgReal.toRational: Argument cannot be represented as a rational value: " ++ algRealToHaskell x instance Random Rational where random g = let (a, g') = random g (b, g'') = random g' in (a % b, g'') -- this may not be quite kosher, but will do for our purposes (test-generation, mainly) randomR (l, h) g = let (ln, ld) = (numerator l, denominator l) (hn, hd) = (numerator h, denominator h) (a, g') = randomR (ln*hd, hn*ld) g in (a % (ld * hd), g') instance Random AlgReal where random g = let (a, g') = random g in (AlgRational True a, g') randomR (AlgRational True l, AlgRational True h) g = let (a, g') = randomR (l, h) g in (AlgRational True a, g') randomR lh _ = error $ "AlgReal.randomR: unsupported bounds: " ++ show lh -- | Render an 'AlgReal' as an SMTLib2 value. Only supports rationals for the time being. algRealToSMTLib2 :: AlgReal -> String algRealToSMTLib2 (AlgRational True r) | m == 0 = "0.0" | m < 0 = "(- (/ " ++ show (abs m) ++ ".0 " ++ show n ++ ".0))" | True = "(/ " ++ show m ++ ".0 " ++ show n ++ ".0)" where (m, n) = (numerator r, denominator r) algRealToSMTLib2 r@(AlgRational False _) = error $ "SBV: Unexpected inexact rational to be converted to SMTLib2: " ++ show r algRealToSMTLib2 (AlgPolyRoot (i, Polynomial xs) _) = "(root-obj (+ " ++ unwords (concatMap term xs) ++ ") " ++ show i ++ ")" where term (0, _) = [] term (k, 0) = [coeff k] term (1, 1) = ["x"] term (1, p) = ["(^ x " ++ show p ++ ")"] term (k, 1) = ["(* " ++ coeff k ++ " x)"] term (k, p) = ["(* " ++ coeff k ++ " (^ x " ++ show p ++ "))"] coeff n | n < 0 = "(- " ++ show (abs n) ++ ")" | True = show n -- | Render an 'AlgReal' as a Haskell value. Only supports rationals, since there is no corresponding -- standard Haskell type that can represent root-of-polynomial variety. algRealToHaskell :: AlgReal -> String algRealToHaskell (AlgRational True r) = "((" ++ show r ++ ") :: Rational)" algRealToHaskell r = error $ "SBV.algRealToHaskell: Unsupported argument: " ++ show r -- Try to show a rational precisely if we can, with finite number of -- digits. Otherwise, show it as a rational value. showRat :: Bool -> Rational -> String showRat exact r = p $ case f25 (denominator r) [] of Nothing -> show r -- bail out, not precisely representable with finite digits Just (noOfZeros, num) -> let present = length num in neg $ case noOfZeros `compare` present of LT -> let (b, a) = splitAt (present - noOfZeros) num in b ++ "." ++ if null a then "0" else a EQ -> "0." ++ num GT -> "0." ++ replicate (noOfZeros - present) '0' ++ num where p = if exact then id else (++ "...") neg = if r < 0 then ('-':) else id -- factor a number in 2's and 5's if possible -- If so, it'll return the number of digits after the zero -- to reach the next power of 10, and the numerator value scaled -- appropriately and shown as a string f25 :: Integer -> [Integer] -> Maybe (Int, String) f25 1 sofar = let (ts, fs) = partition (== 2) sofar [lts, lfs] = map length [ts, fs] noOfZeros = lts `max` lfs in Just (noOfZeros, show (abs (numerator r) * factor ts fs)) f25 v sofar = let (q2, r2) = v `quotRem` 2 (q5, r5) = v `quotRem` 5 in case (r2, r5) of (0, _) -> f25 q2 (2 : sofar) (_, 0) -> f25 q5 (5 : sofar) _ -> Nothing -- compute the next power of 10 we need to get to factor [] fs = product [2 | _ <- fs] factor ts [] = product [5 | _ <- ts] factor (_:ts) (_:fs) = factor ts fs -- | Merge the representation of two algebraic reals, one assumed to be -- in polynomial form, the other in decimal. Arguments can be the same -- kind, so long as they are both rationals and equivalent; if not there -- must be one that is precise. It's an error to pass anything -- else to this function! (Used in reconstructing SMT counter-example values with reals). mergeAlgReals :: String -> AlgReal -> AlgReal -> AlgReal mergeAlgReals _ f@(AlgRational exact r) (AlgPolyRoot kp Nothing) | exact = f | True = AlgPolyRoot kp (Just (showRat False r)) mergeAlgReals _ (AlgPolyRoot kp Nothing) f@(AlgRational exact r) | exact = f | True = AlgPolyRoot kp (Just (showRat False r)) mergeAlgReals _ f@(AlgRational e1 r1) s@(AlgRational e2 r2) | (e1, r1) == (e2, r2) = f | e1 = f | e2 = s mergeAlgReals m _ _ = error m -- Quickcheck instance instance Arbitrary AlgReal where arbitrary = AlgRational True `fmap` arbitrary sbv-5.12/Data/SBV/BitVectors/Concrete.hs0000644000000000000000000002217112725411266016117 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Concrete -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Operations on concrete values ----------------------------------------------------------------------------- module Data.SBV.BitVectors.Concrete ( module Data.SBV.BitVectors.Concrete ) where import Data.Bits import System.Random (randomIO, randomRIO) import Data.SBV.BitVectors.Kind import Data.SBV.BitVectors.AlgReals -- | A constant value data CWVal = CWAlgReal AlgReal -- ^ algebraic real | CWInteger Integer -- ^ bit-vector/unbounded integer | CWFloat Float -- ^ float | CWDouble Double -- ^ double | CWUserSort (Maybe Int, String) -- ^ value of an uninterpreted/user kind. The Maybe Int shows index position for enumerations -- | Eq instance for CWVal. Note that we cannot simply derive Eq/Ord, since CWAlgReal doesn't have proper -- instances for these when values are infinitely precise reals. However, we do -- need a structural eq/ord for Map indexes; so define custom ones here: instance Eq CWVal where CWAlgReal a == CWAlgReal b = a `algRealStructuralEqual` b CWInteger a == CWInteger b = a == b CWUserSort a == CWUserSort b = a == b CWFloat a == CWFloat b = a == b CWDouble a == CWDouble b = a == b _ == _ = False -- | Ord instance for CWVal. Same comments as the 'Eq' instance why this cannot be derived. instance Ord CWVal where CWAlgReal a `compare` CWAlgReal b = a `algRealStructuralCompare` b CWAlgReal _ `compare` CWInteger _ = LT CWAlgReal _ `compare` CWFloat _ = LT CWAlgReal _ `compare` CWDouble _ = LT CWAlgReal _ `compare` CWUserSort _ = LT CWInteger _ `compare` CWAlgReal _ = GT CWInteger a `compare` CWInteger b = a `compare` b CWInteger _ `compare` CWFloat _ = LT CWInteger _ `compare` CWDouble _ = LT CWInteger _ `compare` CWUserSort _ = LT CWFloat _ `compare` CWAlgReal _ = GT CWFloat _ `compare` CWInteger _ = GT CWFloat a `compare` CWFloat b = a `compare` b CWFloat _ `compare` CWDouble _ = LT CWFloat _ `compare` CWUserSort _ = LT CWDouble _ `compare` CWAlgReal _ = GT CWDouble _ `compare` CWInteger _ = GT CWDouble _ `compare` CWFloat _ = GT CWDouble a `compare` CWDouble b = a `compare` b CWDouble _ `compare` CWUserSort _ = LT CWUserSort _ `compare` CWAlgReal _ = GT CWUserSort _ `compare` CWInteger _ = GT CWUserSort _ `compare` CWFloat _ = GT CWUserSort _ `compare` CWDouble _ = GT CWUserSort a `compare` CWUserSort b = a `compare` b -- | 'CW' represents a concrete word of a fixed size: -- Endianness is mostly irrelevant (see the 'FromBits' class). -- For signed words, the most significant digit is considered to be the sign. data CW = CW { _cwKind :: !Kind , cwVal :: !CWVal } deriving (Eq, Ord) -- | 'Kind' instance for CW instance HasKind CW where kindOf (CW k _) = k -- | Are two CW's of the same type? cwSameType :: CW -> CW -> Bool cwSameType x y = kindOf x == kindOf y -- | Convert a CW to a Haskell boolean (NB. Assumes input is well-kinded) cwToBool :: CW -> Bool cwToBool x = cwVal x /= CWInteger 0 -- | Normalize a CW. Essentially performs modular arithmetic to make sure the -- value can fit in the given bit-size. Note that this is rather tricky for -- negative values, due to asymmetry. (i.e., an 8-bit negative number represents -- values in the range -128 to 127; thus we have to be careful on the negative side.) normCW :: CW -> CW normCW c@(CW (KBounded signed sz) (CWInteger v)) = c { cwVal = CWInteger norm } where norm | sz == 0 = 0 | signed = let rg = 2 ^ (sz - 1) in case divMod v rg of (a, b) | even a -> b (_, b) -> b - rg | True = v `mod` (2 ^ sz) normCW c@(CW KBool (CWInteger v)) = c { cwVal = CWInteger (v .&. 1) } normCW c = c -- | Constant False as a CW. We represent it using the integer value 0. falseCW :: CW falseCW = CW KBool (CWInteger 0) -- | Constant True as a CW. We represent it using the integer value 1. trueCW :: CW trueCW = CW KBool (CWInteger 1) -- | Lift a unary function thruough a CW liftCW :: (AlgReal -> b) -> (Integer -> b) -> (Float -> b) -> (Double -> b) -> ((Maybe Int, String) -> b) -> CW -> b liftCW f _ _ _ _ (CW _ (CWAlgReal v)) = f v liftCW _ f _ _ _ (CW _ (CWInteger v)) = f v liftCW _ _ f _ _ (CW _ (CWFloat v)) = f v liftCW _ _ _ f _ (CW _ (CWDouble v)) = f v liftCW _ _ _ _ f (CW _ (CWUserSort v)) = f v -- | Lift a binary function through a CW liftCW2 :: (AlgReal -> AlgReal -> b) -> (Integer -> Integer -> b) -> (Float -> Float -> b) -> (Double -> Double -> b) -> ((Maybe Int, String) -> (Maybe Int, String) -> b) -> CW -> CW -> b liftCW2 r i f d u x y = case (cwVal x, cwVal y) of (CWAlgReal a, CWAlgReal b) -> r a b (CWInteger a, CWInteger b) -> i a b (CWFloat a, CWFloat b) -> f a b (CWDouble a, CWDouble b) -> d a b (CWUserSort a, CWUserSort b) -> u a b _ -> error $ "SBV.liftCW2: impossible, incompatible args received: " ++ show (x, y) -- | Map a unary function through a CW. mapCW :: (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> ((Maybe Int, String) -> (Maybe Int, String)) -> CW -> CW mapCW r i f d u x = normCW $ CW (kindOf x) $ case cwVal x of CWAlgReal a -> CWAlgReal (r a) CWInteger a -> CWInteger (i a) CWFloat a -> CWFloat (f a) CWDouble a -> CWDouble (d a) CWUserSort a -> CWUserSort (u a) -- | Map a binary function through a CW. mapCW2 :: (AlgReal -> AlgReal -> AlgReal) -> (Integer -> Integer -> Integer) -> (Float -> Float -> Float) -> (Double -> Double -> Double) -> ((Maybe Int, String) -> (Maybe Int, String) -> (Maybe Int, String)) -> CW -> CW -> CW mapCW2 r i f d u x y = case (cwSameType x y, cwVal x, cwVal y) of (True, CWAlgReal a, CWAlgReal b) -> normCW $ CW (kindOf x) (CWAlgReal (r a b)) (True, CWInteger a, CWInteger b) -> normCW $ CW (kindOf x) (CWInteger (i a b)) (True, CWFloat a, CWFloat b) -> normCW $ CW (kindOf x) (CWFloat (f a b)) (True, CWDouble a, CWDouble b) -> normCW $ CW (kindOf x) (CWDouble (d a b)) (True, CWUserSort a, CWUserSort b) -> normCW $ CW (kindOf x) (CWUserSort (u a b)) _ -> error $ "SBV.mapCW2: impossible, incompatible args received: " ++ show (x, y) -- | Show instance for 'CW'. instance Show CW where show = showCW True -- | Show a CW, with kind info if bool is True showCW :: Bool -> CW -> String showCW shk w | isBoolean w = show (cwToBool w) ++ (if shk then " :: Bool" else "") showCW shk w = liftCW show show show show snd w ++ kInfo where kInfo | shk = " :: " ++ shKind (kindOf w) | True = "" shKind k@KUserSort {} = show k shKind k | ('S':sk) <- show k = sk shKind k = show k -- | Create a constant word from an integral. mkConstCW :: Integral a => Kind -> a -> CW mkConstCW KBool a = normCW $ CW KBool (CWInteger (toInteger a)) mkConstCW k@KBounded{} a = normCW $ CW k (CWInteger (toInteger a)) mkConstCW KUnbounded a = normCW $ CW KUnbounded (CWInteger (toInteger a)) mkConstCW KReal a = normCW $ CW KReal (CWAlgReal (fromInteger (toInteger a))) mkConstCW KFloat a = normCW $ CW KFloat (CWFloat (fromInteger (toInteger a))) mkConstCW KDouble a = normCW $ CW KDouble (CWDouble (fromInteger (toInteger a))) mkConstCW (KUserSort s _) a = error $ "Unexpected call to mkConstCW with uninterpreted kind: " ++ s ++ " with value: " ++ show (toInteger a) -- | Generate a random constant value ('CWVal') of the correct kind. randomCWVal :: Kind -> IO CWVal randomCWVal k = case k of KBool -> fmap CWInteger (randomRIO (0,1)) KBounded s w -> fmap CWInteger (randomRIO (bounds s w)) KUnbounded -> fmap CWInteger randomIO KReal -> fmap CWAlgReal randomIO KFloat -> fmap CWFloat randomIO KDouble -> fmap CWDouble randomIO KUserSort s _ -> error $ "Unexpected call to randomCWVal with uninterpreted kind: " ++ s where bounds :: Bool -> Int -> (Integer, Integer) bounds False w = (0, 2^w - 1) bounds True w = (-x, x-1) where x = 2^(w-1) -- | Generate a random constant value ('CW') of the correct kind. randomCW :: Kind -> IO CW randomCW k = fmap (CW k) (randomCWVal k) sbv-5.12/Data/SBV/BitVectors/Data.hs0000644000000000000000000005470312725411266015234 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Data -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Internal data-structures for the sbv library ----------------------------------------------------------------------------- {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE NamedFieldPuns #-} module Data.SBV.BitVectors.Data ( SBool, SWord8, SWord16, SWord32, SWord64 , SInt8, SInt16, SInt32, SInt64, SInteger, SReal, SFloat, SDouble , nan, infinity, sNaN, sInfinity, RoundingMode(..), SRoundingMode , sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, sRoundTowardZero , sRNE, sRNA, sRTP, sRTN, sRTZ , SymWord(..) , CW(..), CWVal(..), AlgReal(..), cwSameType, cwToBool , mkConstCW ,liftCW2, mapCW, mapCW2 , SW(..), trueSW, falseSW, trueCW, falseCW, normCW , SVal(..) , SBV(..), NodeId(..), mkSymSBV , ArrayContext(..), ArrayInfo, SymArray(..), SFunArray(..), mkSFunArray, SArray(..) , sbvToSW, sbvToSymSW, forceSWArg , SBVExpr(..), newExpr , cache, Cached, uncache, uncacheAI, HasKind(..) , Op(..), FPOp(..), NamedSymVar, getTableIndex , SBVPgm(..), Symbolic, SExecutable(..), runSymbolic, runSymbolic', State, getPathCondition, extendPathCondition , inProofMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..) , Logic(..), SMTLibLogic(..) , addConstraint, internalVariable, internalConstraint, isCodeGenMode , SBVType(..), newUninterpreted, addAxiom , Quantifier(..), needsExistentials , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension, smtLibReservedNames , SolverCapabilities(..) , extractSymbolicSimulationState , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), getSBranchRunConfig , declNewSArray, declNewSFunArray ) where import Control.DeepSeq (NFData(..)) import Control.Monad.Reader (ask) import Control.Monad.Trans (liftIO) import Data.Int (Int8, Int16, Int32, Int64) import Data.Word (Word8, Word16, Word32, Word64) import Data.List (elemIndex, intercalate) import Data.Maybe (fromMaybe) import qualified Data.Generics as G (Data(..)) import System.Random import Data.SBV.BitVectors.AlgReals import Data.SBV.Utils.Lib import Data.SBV.BitVectors.Kind import Data.SBV.BitVectors.Concrete import Data.SBV.BitVectors.Symbolic import Data.SBV.SMT.SMTLibNames import Prelude () import Prelude.Compat -- | Get the current path condition getPathCondition :: State -> SBool getPathCondition st = SBV (getSValPathCondition st) -- | Extend the path condition with the given test value. extendPathCondition :: State -> (SBool -> SBool) -> State extendPathCondition st f = extendSValPathCondition st (unSBV . f . SBV) -- | The "Symbolic" value. The parameter 'a' is phantom, but is -- extremely important in keeping the user interface strongly typed. newtype SBV a = SBV { unSBV :: SVal } -- | A symbolic boolean/bit type SBool = SBV Bool -- | 8-bit unsigned symbolic value type SWord8 = SBV Word8 -- | 16-bit unsigned symbolic value type SWord16 = SBV Word16 -- | 32-bit unsigned symbolic value type SWord32 = SBV Word32 -- | 64-bit unsigned symbolic value type SWord64 = SBV Word64 -- | 8-bit signed symbolic value, 2's complement representation type SInt8 = SBV Int8 -- | 16-bit signed symbolic value, 2's complement representation type SInt16 = SBV Int16 -- | 32-bit signed symbolic value, 2's complement representation type SInt32 = SBV Int32 -- | 64-bit signed symbolic value, 2's complement representation type SInt64 = SBV Int64 -- | Infinite precision signed symbolic value type SInteger = SBV Integer -- | Infinite precision symbolic algebraic real value type SReal = SBV AlgReal -- | IEEE-754 single-precision floating point numbers type SFloat = SBV Float -- | IEEE-754 double-precision floating point numbers type SDouble = SBV Double -- | Not-A-Number for 'Double' and 'Float'. Surprisingly, Haskell -- Prelude doesn't have this value defined, so we provide it here. nan :: Floating a => a nan = 0/0 -- | Infinity for 'Double' and 'Float'. Surprisingly, Haskell -- Prelude doesn't have this value defined, so we provide it here. infinity :: Floating a => a infinity = 1/0 -- | Symbolic variant of Not-A-Number. This value will inhabit both -- 'SDouble' and 'SFloat'. sNaN :: (Floating a, SymWord a) => SBV a sNaN = literal nan -- | Symbolic variant of infinity. This value will inhabit both -- 'SDouble' and 'SFloat'. sInfinity :: (Floating a, SymWord a) => SBV a sInfinity = literal infinity -- | 'RoundingMode' can be used symbolically instance SymWord RoundingMode -- | The symbolic variant of 'RoundingMode' type SRoundingMode = SBV RoundingMode -- | Symbolic variant of 'RoundNearestTiesToEven' sRoundNearestTiesToEven :: SRoundingMode sRoundNearestTiesToEven = literal RoundNearestTiesToEven -- | Symbolic variant of 'RoundNearestTiesToAway' sRoundNearestTiesToAway :: SRoundingMode sRoundNearestTiesToAway = literal RoundNearestTiesToAway -- | Symbolic variant of 'RoundNearestPositive' sRoundTowardPositive :: SRoundingMode sRoundTowardPositive = literal RoundTowardPositive -- | Symbolic variant of 'RoundTowardNegative' sRoundTowardNegative :: SRoundingMode sRoundTowardNegative = literal RoundTowardNegative -- | Symbolic variant of 'RoundTowardZero' sRoundTowardZero :: SRoundingMode sRoundTowardZero = literal RoundTowardZero -- | Alias for 'sRoundNearestTiesToEven' sRNE :: SRoundingMode sRNE = sRoundNearestTiesToEven -- | Alias for 'sRoundNearestTiesToAway' sRNA :: SRoundingMode sRNA = sRoundNearestTiesToAway -- | Alias for 'sRoundTowardPositive' sRTP :: SRoundingMode sRTP = sRoundTowardPositive -- | Alias for 'sRoundTowardNegative' sRTN :: SRoundingMode sRTN = sRoundTowardNegative -- | Alias for 'sRoundTowardZero' sRTZ :: SRoundingMode sRTZ = sRoundTowardZero -- Not particularly "desirable", but will do if needed instance Show (SBV a) where show (SBV sv) = show sv -- Equality constraint on SBV values. Not desirable since we can't really compare two -- symbolic values, but will do. instance Eq (SBV a) where SBV a == SBV b = a == b SBV a /= SBV b = a /= b instance HasKind (SBV a) where kindOf (SBV (SVal k _)) = k -- | Convert a symbolic value to a symbolic-word sbvToSW :: State -> SBV a -> IO SW sbvToSW st (SBV s) = svToSW st s ------------------------------------------------------------------------- -- * Symbolic Computations ------------------------------------------------------------------------- -- | Create a symbolic variable. mkSymSBV :: forall a. Maybe Quantifier -> Kind -> Maybe String -> Symbolic (SBV a) mkSymSBV mbQ k mbNm = fmap SBV (svMkSymVar mbQ k mbNm) -- | Convert a symbolic value to an SW, inside the Symbolic monad sbvToSymSW :: SBV a -> Symbolic SW sbvToSymSW sbv = do st <- ask liftIO $ sbvToSW st sbv -- | A class representing what can be returned from a symbolic computation. class Outputtable a where -- | Mark an interim result as an output. Useful when constructing Symbolic programs -- that return multiple values, or when the result is programmatically computed. output :: a -> Symbolic a instance Outputtable (SBV a) where output i = do outputSVal (unSBV i) return i instance Outputtable a => Outputtable [a] where output = mapM output instance Outputtable () where output = return instance (Outputtable a, Outputtable b) => Outputtable (a, b) where output = mlift2 (,) output output instance (Outputtable a, Outputtable b, Outputtable c) => Outputtable (a, b, c) where output = mlift3 (,,) output output output instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d) => Outputtable (a, b, c, d) where output = mlift4 (,,,) output output output output instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e) => Outputtable (a, b, c, d, e) where output = mlift5 (,,,,) output output output output output instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f) => Outputtable (a, b, c, d, e, f) where output = mlift6 (,,,,,) output output output output output output instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g) => Outputtable (a, b, c, d, e, f, g) where output = mlift7 (,,,,,,) output output output output output output output instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g, Outputtable h) => Outputtable (a, b, c, d, e, f, g, h) where output = mlift8 (,,,,,,,) output output output output output output output output ------------------------------------------------------------------------------- -- * Symbolic Words ------------------------------------------------------------------------------- -- | A 'SymWord' is a potential symbolic bitvector that can be created instances of -- to be fed to a symbolic program. Note that these methods are typically not needed -- in casual uses with 'prove', 'sat', 'allSat' etc, as default instances automatically -- provide the necessary bits. class (HasKind a, Ord a) => SymWord a where -- | Create a user named input (universal) forall :: String -> Symbolic (SBV a) -- | Create an automatically named input forall_ :: Symbolic (SBV a) -- | Get a bunch of new words mkForallVars :: Int -> Symbolic [SBV a] -- | Create an existential variable exists :: String -> Symbolic (SBV a) -- | Create an automatically named existential variable exists_ :: Symbolic (SBV a) -- | Create a bunch of existentials mkExistVars :: Int -> Symbolic [SBV a] -- | Create a free variable, universal in a proof, existential in sat free :: String -> Symbolic (SBV a) -- | Create an unnamed free variable, universal in proof, existential in sat free_ :: Symbolic (SBV a) -- | Create a bunch of free vars mkFreeVars :: Int -> Symbolic [SBV a] -- | Similar to free; Just a more convenient name symbolic :: String -> Symbolic (SBV a) -- | Similar to mkFreeVars; but automatically gives names based on the strings symbolics :: [String] -> Symbolic [SBV a] -- | Turn a literal constant to symbolic literal :: a -> SBV a -- | Extract a literal, if the value is concrete unliteral :: SBV a -> Maybe a -- | Extract a literal, from a CW representation fromCW :: CW -> a -- | Is the symbolic word concrete? isConcrete :: SBV a -> Bool -- | Is the symbolic word really symbolic? isSymbolic :: SBV a -> Bool -- | Does it concretely satisfy the given predicate? isConcretely :: SBV a -> (a -> Bool) -> Bool -- | One stop allocator mkSymWord :: Maybe Quantifier -> Maybe String -> Symbolic (SBV a) -- minimal complete definition:: Nothing. -- Giving no instances is ok when defining an uninterpreted/enumerated sort, but otherwise you really -- want to define: literal, fromCW, mkSymWord forall = mkSymWord (Just ALL) . Just forall_ = mkSymWord (Just ALL) Nothing exists = mkSymWord (Just EX) . Just exists_ = mkSymWord (Just EX) Nothing free = mkSymWord Nothing . Just free_ = mkSymWord Nothing Nothing mkForallVars n = mapM (const forall_) [1 .. n] mkExistVars n = mapM (const exists_) [1 .. n] mkFreeVars n = mapM (const free_) [1 .. n] symbolic = free symbolics = mapM symbolic unliteral (SBV (SVal _ (Left c))) = Just $ fromCW c unliteral _ = Nothing isConcrete (SBV (SVal _ (Left _))) = True isConcrete _ = False isSymbolic = not . isConcrete isConcretely s p | Just i <- unliteral s = p i | True = False default literal :: Show a => a -> SBV a literal x = let k@(KUserSort _ conts) = kindOf x sx = show x mbIdx = case conts of Right xs -> sx `elemIndex` xs _ -> Nothing in SBV $ SVal k (Left (CW k (CWUserSort (mbIdx, sx)))) default fromCW :: Read a => CW -> a fromCW (CW _ (CWUserSort (_, s))) = read s fromCW cw = error $ "Cannot convert CW " ++ show cw ++ " to kind " ++ show (kindOf (undefined :: a)) default mkSymWord :: (Read a, G.Data a) => Maybe Quantifier -> Maybe String -> Symbolic (SBV a) mkSymWord mbQ mbNm = SBV <$> mkSValUserSort k mbQ mbNm where k = constructUKind (undefined :: a) instance (Random a, SymWord a) => Random (SBV a) where randomR (l, h) g = case (unliteral l, unliteral h) of (Just lb, Just hb) -> let (v, g') = randomR (lb, hb) g in (literal (v :: a), g') _ -> error "SBV.Random: Cannot generate random values with symbolic bounds" random g = let (v, g') = random g in (literal (v :: a) , g') --------------------------------------------------------------------------------- -- * Symbolic Arrays --------------------------------------------------------------------------------- -- | Flat arrays of symbolic values -- An @array a b@ is an array indexed by the type @'SBV' a@, with elements of type @'SBV' b@ -- If an initial value is not provided in 'newArray_' and 'newArray' methods, then the elements -- are left unspecified, i.e., the solver is free to choose any value. This is the right thing -- to do if arrays are used as inputs to functions to be verified, typically. -- -- While it's certainly possible for user to create instances of 'SymArray', the -- 'SArray' and 'SFunArray' instances already provided should cover most use cases -- in practice. (There are some differences between these models, however, see the corresponding -- declaration.) -- -- -- Minimal complete definition: All methods are required, no defaults. class SymArray array where -- | Create a new array, with an optional initial value newArray_ :: (HasKind a, HasKind b) => Maybe (SBV b) -> Symbolic (array a b) -- | Create a named new array, with an optional initial value newArray :: (HasKind a, HasKind b) => String -> Maybe (SBV b) -> Symbolic (array a b) -- | Read the array element at @a@ readArray :: array a b -> SBV a -> SBV b -- | Reset all the elements of the array to the value @b@ resetArray :: SymWord b => array a b -> SBV b -> array a b -- | Update the element at @a@ to be @b@ writeArray :: SymWord b => array a b -> SBV a -> SBV b -> array a b -- | Merge two given arrays on the symbolic condition -- Intuitively: @mergeArrays cond a b = if cond then a else b@. -- Merging pushes the if-then-else choice down on to elements mergeArrays :: SymWord b => SBV Bool -> array a b -> array a b -> array a b -- | Arrays implemented in terms of SMT-arrays: -- -- * Maps directly to SMT-lib arrays -- -- * Reading from an unintialized value is OK and yields an unspecified result -- -- * Can check for equality of these arrays -- -- * Cannot quick-check theorems using @SArray@ values -- -- * Typically slower as it heavily relies on SMT-solving for the array theory -- newtype SArray a b = SArray { unSArray :: SArr } instance (HasKind a, HasKind b) => Show (SArray a b) where show SArray{} = "SArray<" ++ showType (undefined :: a) ++ ":" ++ showType (undefined :: b) ++ ">" instance SymArray SArray where newArray_ = declNewSArray (\t -> "array_" ++ show t) newArray n = declNewSArray (const n) readArray (SArray arr) (SBV a) = SBV (readSArr arr a) resetArray (SArray arr) (SBV b) = SArray (resetSArr arr b) writeArray (SArray arr) (SBV a) (SBV b) = SArray (writeSArr arr a b) mergeArrays (SBV t) (SArray a) (SArray b) = SArray (mergeSArr t a b) -- | Declare a new symbolic array, with a potential initial value declNewSArray :: forall a b. (HasKind a, HasKind b) => (Int -> String) -> Maybe (SBV b) -> Symbolic (SArray a b) declNewSArray mkNm mbInit = do let aknd = kindOf (undefined :: a) bknd = kindOf (undefined :: b) arr <- newSArr (aknd, bknd) mkNm (fmap unSBV mbInit) return (SArray arr) -- | Declare a new functional symbolic array, with a potential initial value. Note that a read from an uninitialized cell will result in an error. declNewSFunArray :: forall a b. (HasKind a, HasKind b) => Maybe (SBV b) -> Symbolic (SFunArray a b) declNewSFunArray mbiVal = return $ SFunArray $ const $ fromMaybe (error "Reading from an uninitialized array entry") mbiVal -- | Arrays implemented internally as functions -- -- * Internally handled by the library and not mapped to SMT-Lib -- -- * Reading an uninitialized value is considered an error (will throw exception) -- -- * Cannot check for equality (internally represented as functions) -- -- * Can quick-check -- -- * Typically faster as it gets compiled away during translation -- data SFunArray a b = SFunArray (SBV a -> SBV b) instance (HasKind a, HasKind b) => Show (SFunArray a b) where show (SFunArray _) = "SFunArray<" ++ showType (undefined :: a) ++ ":" ++ showType (undefined :: b) ++ ">" -- | Lift a function to an array. Useful for creating arrays in a pure context. (Otherwise use `newArray`.) mkSFunArray :: (SBV a -> SBV b) -> SFunArray a b mkSFunArray = SFunArray -- | Add a constraint with a given probability addConstraint :: Maybe Double -> SBool -> SBool -> Symbolic () addConstraint mt (SBV c) (SBV c') = addSValConstraint mt c c' instance NFData (SBV a) where rnf (SBV x) = rnf x `seq` () -- | Symbolically executable program fragments. This class is mainly used for 'safe' calls, and is sufficently populated internally to cover most use -- cases. Users can extend it as they wish to allow 'safe' checks for SBV programs that return/take types that are user-defined. class SExecutable a where sName_ :: a -> Symbolic () sName :: [String] -> a -> Symbolic () instance NFData a => SExecutable (Symbolic a) where sName_ a = a >>= \r -> rnf r `seq` return () sName [] = sName_ sName xs = error $ "SBV.SExecutable.sName: Extra unmapped name(s): " ++ intercalate ", " xs instance SExecutable (SBV a) where sName_ v = sName_ (output v) sName xs v = sName xs (output v) -- Unit output instance SExecutable () where sName_ () = sName_ (output ()) sName xs () = sName xs (output ()) -- List output instance SExecutable [SBV a] where sName_ vs = sName_ (output vs) sName xs vs = sName xs (output vs) -- 2 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b) => SExecutable (SBV a, SBV b) where sName_ (a, b) = sName_ (output a >> output b) sName _ = sName_ -- 3 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c) => SExecutable (SBV a, SBV b, SBV c) where sName_ (a, b, c) = sName_ (output a >> output b >> output c) sName _ = sName_ -- 4 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d) => SExecutable (SBV a, SBV b, SBV c, SBV d) where sName_ (a, b, c, d) = sName_ (output a >> output b >> output c >> output c >> output d) sName _ = sName_ -- 5 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e) where sName_ (a, b, c, d, e) = sName_ (output a >> output b >> output c >> output d >> output e) sName _ = sName_ -- 6 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) where sName_ (a, b, c, d, e, f) = sName_ (output a >> output b >> output c >> output d >> output e >> output f) sName _ = sName_ -- 7 Tuple output instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f, NFData g, SymWord g) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) where sName_ (a, b, c, d, e, f, g) = sName_ (output a >> output b >> output c >> output d >> output e >> output f >> output g) sName _ = sName_ -- Functions instance (SymWord a, SExecutable p) => SExecutable (SBV a -> p) where sName_ k = forall_ >>= \a -> sName_ $ k a sName (s:ss) k = forall s >>= \a -> sName ss $ k a sName [] k = sName_ k -- 2 Tuple input instance (SymWord a, SymWord b, SExecutable p) => SExecutable ((SBV a, SBV b) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b -> k (a, b) sName (s:ss) k = forall s >>= \a -> sName ss $ \b -> k (a, b) sName [] k = sName_ k -- 3 Tuple input instance (SymWord a, SymWord b, SymWord c, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b c -> k (a, b, c) sName (s:ss) k = forall s >>= \a -> sName ss $ \b c -> k (a, b, c) sName [] k = sName_ k -- 4 Tuple input instance (SymWord a, SymWord b, SymWord c, SymWord d, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b c d -> k (a, b, c, d) sName (s:ss) k = forall s >>= \a -> sName ss $ \b c d -> k (a, b, c, d) sName [] k = sName_ k -- 5 Tuple input instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b c d e -> k (a, b, c, d, e) sName (s:ss) k = forall s >>= \a -> sName ss $ \b c d e -> k (a, b, c, d, e) sName [] k = sName_ k -- 6 Tuple input instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b c d e f -> k (a, b, c, d, e, f) sName (s:ss) k = forall s >>= \a -> sName ss $ \b c d e f -> k (a, b, c, d, e, f) sName [] k = sName_ k -- 7 Tuple input instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where sName_ k = forall_ >>= \a -> sName_ $ \b c d e f g -> k (a, b, c, d, e, f, g) sName (s:ss) k = forall s >>= \a -> sName ss $ \b c d e f g -> k (a, b, c, d, e, f, g) sName [] k = sName_ k sbv-5.12/Data/SBV/BitVectors/Floating.hs0000644000000000000000000005430512725411266016124 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Floating -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Implementation of floating-point operations mapping to SMT-Lib2 floats ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.BitVectors.Floating ( IEEEFloating(..), IEEEFloatConvertable(..) , sFloatAsSWord32, sDoubleAsSWord64, sWord32AsSFloat, sWord64AsSDouble , blastSFloat, blastSDouble ) where import Control.Monad (join) import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord) import Data.Int (Int8, Int16, Int32, Int64) import Data.Word (Word8, Word16, Word32, Word64) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model import Data.SBV.BitVectors.AlgReals (isExactRational) import Data.SBV.Utils.Boolean import Data.SBV.Utils.Numeric -- | A class of floating-point (IEEE754) operations, some of -- which behave differently based on rounding modes. Note that unless -- the rounding mode is concretely RoundNearestTiesToEven, we will -- not concretely evaluate these, but rather pass down to the SMT solver. class (SymWord a, RealFloat a) => IEEEFloating a where -- | Compute the floating point absolute value. fpAbs :: SBV a -> SBV a -- | Compute the unary negation. Note that @0 - x@ is not equivalent to @-x@ for floating-point, since @-0@ and @0@ are different. fpNeg :: SBV a -> SBV a -- | Add two floating point values, using the given rounding mode fpAdd :: SRoundingMode -> SBV a -> SBV a -> SBV a -- | Subtract two floating point values, using the given rounding mode fpSub :: SRoundingMode -> SBV a -> SBV a -> SBV a -- | Multiply two floating point values, using the given rounding mode fpMul :: SRoundingMode -> SBV a -> SBV a -> SBV a -- | Divide two floating point values, using the given rounding mode fpDiv :: SRoundingMode -> SBV a -> SBV a -> SBV a -- | Fused-multiply-add three floating point values, using the given rounding mode. @fpFMA x y z = x*y+z@ but with only -- one rounding done for the whole operation; not two. Note that we will never concretely evaluate this function since -- Haskell lacks an FMA implementation. fpFMA :: SRoundingMode -> SBV a -> SBV a -> SBV a -> SBV a -- | Compute the square-root of a float, using the given rounding mode fpSqrt :: SRoundingMode -> SBV a -> SBV a -- | Compute the remainder: @x - y * n@, where @n@ is the truncated integer nearest to x/y. The rounding mode -- is implicitly assumed to be @RoundNearestTiesToEven@. fpRem :: SBV a -> SBV a -> SBV a -- | Round to the nearest integral value, using the given rounding mode. fpRoundToIntegral :: SRoundingMode -> SBV a -> SBV a -- | Compute the minimum of two floats, respects @infinity@ and @NaN@ values fpMin :: SBV a -> SBV a -> SBV a -- | Compute the maximum of two floats, respects @infinity@ and @NaN@ values fpMax :: SBV a -> SBV a -> SBV a -- | Are the two given floats exactly the same. That is, @NaN@ will compare equal to itself, @+0@ will /not/ compare -- equal to @-0@ etc. This is the object level equality, as opposed to the semantic equality. (For the latter, just use '.=='.) fpIsEqualObject :: SBV a -> SBV a -> SBool -- | Is the floating-point number a normal value. (i.e., not denormalized.) fpIsNormal :: SBV a -> SBool -- | Is the floating-point number a subnormal value. (Also known as denormal.) fpIsSubnormal :: SBV a -> SBool -- | Is the floating-point number 0? (Note that both +0 and -0 will satisfy this predicate.) fpIsZero :: SBV a -> SBool -- | Is the floating-point number infinity? (Note that both +oo and -oo will satisfy this predicate.) fpIsInfinite :: SBV a -> SBool -- | Is the floating-point number a NaN value? fpIsNaN :: SBV a -> SBool -- | Is the floating-point number negative? Note that -0 satisfies this predicate but +0 does not. fpIsNegative :: SBV a -> SBool -- | Is the floating-point number positive? Note that +0 satisfies this predicate but -0 does not. fpIsPositive :: SBV a -> SBool -- | Is the floating point number -0? fpIsNegativeZero :: SBV a -> SBool -- | Is the floating point number +0? fpIsPositiveZero :: SBV a -> SBool -- | Is the floating-point number a regular floating point, i.e., not NaN, nor +oo, nor -oo. Normals or denormals are allowed. fpIsPoint :: SBV a -> SBool -- Default definitions. Minimal complete definition: None! All should be taken care by defaults -- Note that we never evaluate FMA concretely, as there's no fma operator in Haskell fpAbs = lift1 FP_Abs (Just abs) Nothing fpNeg = lift1 FP_Neg (Just negate) Nothing fpAdd = lift2 FP_Add (Just (+)) . Just fpSub = lift2 FP_Sub (Just (-)) . Just fpMul = lift2 FP_Mul (Just (*)) . Just fpDiv = lift2 FP_Div (Just (/)) . Just fpFMA = lift3 FP_FMA Nothing . Just fpSqrt = lift1 FP_Sqrt (Just sqrt) . Just fpRem = lift2 FP_Rem (Just fpRemH) Nothing fpRoundToIntegral = lift1 FP_RoundToIntegral (Just fpRoundToIntegralH) . Just fpMin = liftMM FP_Min (Just fpMinH) Nothing fpMax = liftMM FP_Max (Just fpMaxH) Nothing fpIsEqualObject = lift2B FP_ObjEqual (Just fpIsEqualObjectH) Nothing fpIsNormal = lift1B FP_IsNormal fpIsNormalizedH fpIsSubnormal = lift1B FP_IsSubnormal isDenormalized fpIsZero = lift1B FP_IsZero (== 0) fpIsInfinite = lift1B FP_IsInfinite isInfinite fpIsNaN = lift1B FP_IsNaN isNaN fpIsNegative = lift1B FP_IsNegative (\x -> x < 0 || isNegativeZero x) fpIsPositive = lift1B FP_IsPositive (\x -> x >= 0 && not (isNegativeZero x)) fpIsNegativeZero x = fpIsZero x &&& fpIsNegative x fpIsPositiveZero x = fpIsZero x &&& fpIsPositive x fpIsPoint x = bnot (fpIsNaN x ||| fpIsInfinite x) -- | SFloat instance instance IEEEFloating Float -- | SDouble instance instance IEEEFloating Double -- | Capture convertability from/to FloatingPoint representations -- NB. 'fromSFloat' and 'fromSDouble' are underspecified when given -- when given a @NaN@, @+oo@, or @-oo@ value that cannot be represented -- in the target domain. For these inputs, we define the result to be +0, arbitrarily. class IEEEFloatConvertable a where fromSFloat :: SRoundingMode -> SFloat -> SBV a toSFloat :: SRoundingMode -> SBV a -> SFloat fromSDouble :: SRoundingMode -> SDouble -> SBV a toSDouble :: SRoundingMode -> SBV a -> SDouble -- | A generic converter that will work for most of our instances. (But not all!) genericFPConverter :: forall a r. (SymWord a, HasKind r, SymWord r, Num r) => Maybe (a -> Bool) -> Maybe (SBV a -> SBool) -> (a -> r) -> SRoundingMode -> SBV a -> SBV r genericFPConverter mbConcreteOK mbSymbolicOK converter rm f | Just w <- unliteral f, Just RoundNearestTiesToEven <- unliteral rm, check w = literal $ converter w | Just symCheck <- mbSymbolicOK = ite (symCheck f) result (literal 0) | True = result where result = SBV (SVal kTo (Right (cache y))) check w = maybe True ($ w) mbConcreteOK kFrom = kindOf f kTo = kindOf (undefined :: r) y st = do msw <- sbvToSW st rm xsw <- sbvToSW st f newExpr st kTo (SBVApp (IEEEFP (FP_Cast kFrom kTo msw)) [xsw]) -- | Check that a given float is a point ptCheck :: IEEEFloating a => Maybe (SBV a -> SBool) ptCheck = Just fpIsPoint instance IEEEFloatConvertable Int8 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Int16 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Int32 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Int64 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Word8 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Word16 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Word32 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Word64 where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) instance IEEEFloatConvertable Float where fromSFloat _ f = f toSFloat _ f = f fromSDouble = genericFPConverter Nothing Nothing fp2fp toSDouble = genericFPConverter Nothing Nothing fp2fp instance IEEEFloatConvertable Double where fromSFloat = genericFPConverter Nothing Nothing fp2fp toSFloat = genericFPConverter Nothing Nothing fp2fp fromSDouble _ d = d toSDouble _ d = d instance IEEEFloatConvertable Integer where fromSFloat = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Float -> Integer)) toSFloat = genericFPConverter Nothing Nothing (fromRational . fromIntegral) fromSDouble = genericFPConverter Nothing ptCheck (fromIntegral . (fpRound0 :: Double -> Integer)) toSDouble = genericFPConverter Nothing Nothing (fromRational . fromIntegral) -- For AlgReal; be careful to only process exact rationals concretely instance IEEEFloatConvertable AlgReal where fromSFloat = genericFPConverter Nothing ptCheck (fromRational . fpRatio0) toSFloat = genericFPConverter (Just isExactRational) Nothing (fromRational . toRational) fromSDouble = genericFPConverter Nothing ptCheck (fromRational . fpRatio0) toSDouble = genericFPConverter (Just isExactRational) Nothing (fromRational . toRational) -- | Concretely evaluate one arg function, if rounding mode is RoundNearestTiesToEven and we have enough concrete data concEval1 :: SymWord a => Maybe (a -> a) -> Maybe SRoundingMode -> SBV a -> Maybe (SBV a) concEval1 mbOp mbRm a = do op <- mbOp v <- unliteral a case join (unliteral `fmap` mbRm) of Nothing -> (Just . literal) (op v) Just RoundNearestTiesToEven -> (Just . literal) (op v) _ -> Nothing -- | Concretely evaluate two arg function, if rounding mode is RoundNearestTiesToEven and we have enough concrete data concEval2 :: SymWord a => Maybe (a -> a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a -> Maybe (SBV a) concEval2 mbOp mbRm a b = do op <- mbOp v1 <- unliteral a v2 <- unliteral b case join (unliteral `fmap` mbRm) of Nothing -> (Just . literal) (v1 `op` v2) Just RoundNearestTiesToEven -> (Just . literal) (v1 `op` v2) _ -> Nothing -- | Concretely evaluate a bool producing two arg function, if rounding mode is RoundNearestTiesToEven and we have enough concrete data concEval2B :: SymWord a => Maybe (a -> a -> Bool) -> Maybe SRoundingMode -> SBV a -> SBV a -> Maybe SBool concEval2B mbOp mbRm a b = do op <- mbOp v1 <- unliteral a v2 <- unliteral b case join (unliteral `fmap` mbRm) of Nothing -> (Just . literal) (v1 `op` v2) Just RoundNearestTiesToEven -> (Just . literal) (v1 `op` v2) _ -> Nothing -- | Concretely evaluate two arg function, if rounding mode is RoundNearestTiesToEven and we have enough concrete data concEval3 :: SymWord a => Maybe (a -> a -> a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a -> SBV a -> Maybe (SBV a) concEval3 mbOp mbRm a b c = do op <- mbOp v1 <- unliteral a v2 <- unliteral b v3 <- unliteral c case join (unliteral `fmap` mbRm) of Nothing -> (Just . literal) (op v1 v2 v3) Just RoundNearestTiesToEven -> (Just . literal) (op v1 v2 v3) _ -> Nothing -- | Add the converted rounding mode if given as an argument addRM :: State -> Maybe SRoundingMode -> [SW] -> IO [SW] addRM _ Nothing as = return as addRM st (Just rm) as = do swm <- sbvToSW st rm return (swm : as) -- | Lift a 1 arg FP-op lift1 :: SymWord a => FPOp -> Maybe (a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a lift1 w mbOp mbRm a | Just cv <- concEval1 mbOp mbRm a = cv | True = SBV $ SVal k $ Right $ cache r where k = kindOf a r st = do swa <- sbvToSW st a args <- addRM st mbRm [swa] newExpr st k (SBVApp (IEEEFP w) args) -- | Lift an FP predicate lift1B :: SymWord a => FPOp -> (a -> Bool) -> SBV a -> SBool lift1B w f a | Just v <- unliteral a = literal $ f v | True = SBV $ SVal KBool $ Right $ cache r where r st = do swa <- sbvToSW st a newExpr st KBool (SBVApp (IEEEFP w) [swa]) -- | Lift a 2 arg FP-op lift2 :: SymWord a => FPOp -> Maybe (a -> a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a -> SBV a lift2 w mbOp mbRm a b | Just cv <- concEval2 mbOp mbRm a b = cv | True = SBV $ SVal k $ Right $ cache r where k = kindOf a r st = do swa <- sbvToSW st a swb <- sbvToSW st b args <- addRM st mbRm [swa, swb] newExpr st k (SBVApp (IEEEFP w) args) -- | Lift min/max: Note that we protect against constant folding if args are alternating sign 0's, since -- SMTLib is deliberately nondeterministic in this case liftMM :: (SymWord a, RealFloat a) => FPOp -> Maybe (a -> a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a -> SBV a liftMM w mbOp mbRm a b | Just v1 <- unliteral a , Just v2 <- unliteral b , not ((isN0 v1 && isP0 v2) || (isP0 v1 && isN0 v2)) -- If not +0/-0 or -0/+0 , Just cv <- concEval2 mbOp mbRm a b = cv | True = SBV $ SVal k $ Right $ cache r where isN0 = isNegativeZero isP0 x = x == 0 && not (isN0 x) k = kindOf a r st = do swa <- sbvToSW st a swb <- sbvToSW st b args <- addRM st mbRm [swa, swb] newExpr st k (SBVApp (IEEEFP w) args) -- | Lift a 2 arg FP-op, producing bool lift2B :: SymWord a => FPOp -> Maybe (a -> a -> Bool) -> Maybe SRoundingMode -> SBV a -> SBV a -> SBool lift2B w mbOp mbRm a b | Just cv <- concEval2B mbOp mbRm a b = cv | True = SBV $ SVal KBool $ Right $ cache r where r st = do swa <- sbvToSW st a swb <- sbvToSW st b args <- addRM st mbRm [swa, swb] newExpr st KBool (SBVApp (IEEEFP w) args) -- | Lift a 3 arg FP-op lift3 :: SymWord a => FPOp -> Maybe (a -> a -> a -> a) -> Maybe SRoundingMode -> SBV a -> SBV a -> SBV a -> SBV a lift3 w mbOp mbRm a b c | Just cv <- concEval3 mbOp mbRm a b c = cv | True = SBV $ SVal k $ Right $ cache r where k = kindOf a r st = do swa <- sbvToSW st a swb <- sbvToSW st b swc <- sbvToSW st c args <- addRM st mbRm [swa, swb, swc] newExpr st k (SBVApp (IEEEFP w) args) -- | Convert an 'SFloat' to an 'SWord32', preserving the bit-correspondence. Note that since the -- representation for @NaN@s are not unique, this function will return a symbolic value when given a -- concrete @NaN@. -- -- Implementation note: Since there's no corresponding function in SMTLib for conversion to -- bit-representation due to partiality, we use a translation trick by allocating a new word variable, -- converting it to float, and requiring it to be equivalent to the input. In code-generation mode, we simply map -- it to a simple conversion. sFloatAsSWord32 :: SFloat -> SWord32 sFloatAsSWord32 fVal | Just f <- unliteral fVal, not (isNaN f) = literal (DB.floatToWord f) | True = SBV (SVal w32 (Right (cache y))) where w32 = KBounded False 32 y st | isCodeGenMode st = do f <- sbvToSW st fVal newExpr st w32 (SBVApp (IEEEFP (FP_Reinterpret KFloat w32)) [f]) | True = do n <- internalVariable st w32 ysw <- newExpr st KFloat (SBVApp (IEEEFP (FP_Reinterpret w32 KFloat)) [n]) internalConstraint st $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KFloat (Right (cache (\_ -> return ysw)))) return n -- | Convert an 'SDouble' to an 'SWord64', preserving the bit-correspondence. Note that since the -- representation for @NaN@s are not unique, this function will return a symbolic value when given a -- concrete @NaN@. -- -- See the implementation note for 'sFloatAsSWord32', as it applies here as well. sDoubleAsSWord64 :: SDouble -> SWord64 sDoubleAsSWord64 fVal | Just f <- unliteral fVal, not (isNaN f) = literal (DB.doubleToWord f) | True = SBV (SVal w64 (Right (cache y))) where w64 = KBounded False 64 y st | isCodeGenMode st = do f <- sbvToSW st fVal newExpr st w64 (SBVApp (IEEEFP (FP_Reinterpret KDouble w64)) [f]) | True = do n <- internalVariable st w64 ysw <- newExpr st KDouble (SBVApp (IEEEFP (FP_Reinterpret w64 KDouble)) [n]) internalConstraint st $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KDouble (Right (cache (\_ -> return ysw)))) return n -- | Extract the sign\/exponent\/mantissa of a single-precision float. The output will have -- 8 bits in the second argument for exponent, and 23 in the third for the mantissa. blastSFloat :: SFloat -> (SBool, [SBool], [SBool]) blastSFloat = extract . sFloatAsSWord32 where extract x = (sTestBit x 31, sExtractBits x [30, 29 .. 23], sExtractBits x [22, 21 .. 0]) -- | Extract the sign\/exponent\/mantissa of a single-precision float. The output will have -- 11 bits in the second argument for exponent, and 52 in the third for the mantissa. blastSDouble :: SDouble -> (SBool, [SBool], [SBool]) blastSDouble = extract . sDoubleAsSWord64 where extract x = (sTestBit x 63, sExtractBits x [62, 61 .. 52], sExtractBits x [51, 50 .. 0]) -- | Reinterpret the bits in a 32-bit word as a single-precision floating point number sWord32AsSFloat :: SWord32 -> SFloat sWord32AsSFloat fVal | Just f <- unliteral fVal = literal $ DB.wordToFloat f | True = SBV (SVal KFloat (Right (cache y))) where y st = do xsw <- sbvToSW st fVal newExpr st KFloat (SBVApp (IEEEFP (FP_Reinterpret (kindOf fVal) KFloat)) [xsw]) -- | Reinterpret the bits in a 32-bit word as a single-precision floating point number sWord64AsSDouble :: SWord64 -> SDouble sWord64AsSDouble dVal | Just d <- unliteral dVal = literal $ DB.wordToDouble d | True = SBV (SVal KDouble (Right (cache y))) where y st = do xsw <- sbvToSW st dVal newExpr st KDouble (SBVApp (IEEEFP (FP_Reinterpret (kindOf dVal) KDouble)) [xsw]) {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/Data/SBV/BitVectors/Kind.hs0000644000000000000000000001466012725411266015246 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Kind -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Internal data-structures for the sbv library ----------------------------------------------------------------------------- {-# LANGUAGE DefaultSignatures #-} {-# LANGUAGE ScopedTypeVariables #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.SBV.BitVectors.Kind (Kind(..), HasKind(..), constructUKind) where import qualified Data.Generics as G (Data(..), DataType, dataTypeName, dataTypeOf, tyconUQname, dataTypeConstrs, constrFields) import Data.Int import Data.Word import Data.SBV.BitVectors.AlgReals -- | Kind of symbolic value data Kind = KBool | KBounded Bool Int | KUnbounded | KReal | KUserSort String (Either String [String]) | KFloat | KDouble -- | Helper for Eq/Ord instances below kindRank :: Kind -> Either Int (Either (Bool, Int) String) kindRank KBool = Left 0 kindRank (KBounded b i) = Right (Left (b, i)) kindRank KUnbounded = Left 1 kindRank KReal = Left 2 kindRank (KUserSort s _) = Right (Right s) kindRank KFloat = Left 3 kindRank KDouble = Left 4 -- | We want to equate user-sorts only by name instance Eq Kind where k1 == k2 = kindRank k1 == kindRank k2 -- | We want to order user-sorts only by name instance Ord Kind where k1 `compare` k2 = kindRank k1 `compare` kindRank k2 instance Show Kind where show KBool = "SBool" show (KBounded False n) = "SWord" ++ show n show (KBounded True n) = "SInt" ++ show n show KUnbounded = "SInteger" show KReal = "SReal" show (KUserSort s _) = s show KFloat = "SFloat" show KDouble = "SDouble" instance Eq G.DataType where a == b = G.tyconUQname (G.dataTypeName a) == G.tyconUQname (G.dataTypeName b) instance Ord G.DataType where a `compare` b = G.tyconUQname (G.dataTypeName a) `compare` G.tyconUQname (G.dataTypeName b) -- | Does this kind represent a signed quantity? kindHasSign :: Kind -> Bool kindHasSign k = case k of KBool -> False KBounded b _ -> b KUnbounded -> True KReal -> True KFloat -> True KDouble -> True KUserSort{} -> False -- | Construct an uninterpreted/enumerated kind from a piece of data; we distinguish simple enumerations as those -- are mapped to proper SMT-Lib2 data-types; while others go completely uninterpreted constructUKind :: forall a. (Read a, G.Data a) => a -> Kind constructUKind a = KUserSort sortName mbEnumFields where dataType = G.dataTypeOf a sortName = G.tyconUQname . G.dataTypeName $ dataType constrs = G.dataTypeConstrs dataType isEnumeration = not (null constrs) && all (null . G.constrFields) constrs mbEnumFields | isEnumeration = check constrs [] | True = Left $ sortName ++ "is not a finite non-empty enumeration" check [] sofar = Right $ reverse sofar check (c:cs) sofar = case checkConstr c of Nothing -> check cs (show c : sofar) Just s -> Left $ sortName ++ "." ++ show c ++ ": " ++ s checkConstr c = case (reads (show c) :: [(a, String)]) of ((_, "") : _) -> Nothing _ -> Just "not a nullary constructor" -- | A class for capturing values that have a sign and a size (finite or infinite) -- minimal complete definition: kindOf. This class can be automatically derived -- for data-types that have a 'Data' instance; this is useful for creating uninterpreted -- sorts. class HasKind a where kindOf :: a -> Kind hasSign :: a -> Bool intSizeOf :: a -> Int isBoolean :: a -> Bool isBounded :: a -> Bool -- NB. This really means word/int; i.e., Real/Float will test False isReal :: a -> Bool isFloat :: a -> Bool isDouble :: a -> Bool isInteger :: a -> Bool isUninterpreted :: a -> Bool showType :: a -> String -- defaults hasSign x = kindHasSign (kindOf x) intSizeOf x = case kindOf x of KBool -> error "SBV.HasKind.intSizeOf((S)Bool)" KBounded _ s -> s KUnbounded -> error "SBV.HasKind.intSizeOf((S)Integer)" KReal -> error "SBV.HasKind.intSizeOf((S)Real)" KFloat -> error "SBV.HasKind.intSizeOf((S)Float)" KDouble -> error "SBV.HasKind.intSizeOf((S)Double)" KUserSort s _ -> error $ "SBV.HasKind.intSizeOf: Uninterpreted sort: " ++ s isBoolean x | KBool{} <- kindOf x = True | True = False isBounded x | KBounded{} <- kindOf x = True | True = False isReal x | KReal{} <- kindOf x = True | True = False isFloat x | KFloat{} <- kindOf x = True | True = False isDouble x | KDouble{} <- kindOf x = True | True = False isInteger x | KUnbounded{} <- kindOf x = True | True = False isUninterpreted x | KUserSort{} <- kindOf x = True | True = False showType = show . kindOf -- default signature for uninterpreted/enumerated kinds default kindOf :: (Read a, G.Data a) => a -> Kind kindOf = constructUKind instance HasKind Bool where kindOf _ = KBool instance HasKind Int8 where kindOf _ = KBounded True 8 instance HasKind Word8 where kindOf _ = KBounded False 8 instance HasKind Int16 where kindOf _ = KBounded True 16 instance HasKind Word16 where kindOf _ = KBounded False 16 instance HasKind Int32 where kindOf _ = KBounded True 32 instance HasKind Word32 where kindOf _ = KBounded False 32 instance HasKind Int64 where kindOf _ = KBounded True 64 instance HasKind Word64 where kindOf _ = KBounded False 64 instance HasKind Integer where kindOf _ = KUnbounded instance HasKind AlgReal where kindOf _ = KReal instance HasKind Float where kindOf _ = KFloat instance HasKind Double where kindOf _ = KDouble instance HasKind Kind where kindOf = id sbv-5.12/Data/SBV/BitVectors/Model.hs0000644000000000000000000023204112725411266015414 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Model -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Instance declarations for our symbolic world ----------------------------------------------------------------------------- {-# OPTIONS_GHC -fno-warn-orphans #-} {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE DefaultSignatures #-} module Data.SBV.BitVectors.Model ( Mergeable(..), EqSymbolic(..), OrdSymbolic(..), SDivisible(..), Uninterpreted(..), SIntegral , ite, iteLazy, sTestBit, sExtractBits, sPopCount, setBitTo, sFromIntegral , sShiftLeft, sShiftRight, sRotateLeft, sRotateRight, sSignedShiftArithRight, (.^) , allEqual, allDifferent, inRange, sElem, oneIf, blastBE, blastLE, fullAdder, fullMultiplier , lsb, msb, genVar, genVar_, forall, forall_, exists, exists_ , constrain, pConstrain, sBool, sBools, sWord8, sWord8s, sWord16, sWord16s, sWord32 , sWord32s, sWord64, sWord64s, sInt8, sInt8s, sInt16, sInt16s, sInt32, sInt32s, sInt64 , sInt64s, sInteger, sIntegers, sReal, sReals, sFloat, sFloats, sDouble, sDoubles, slet , sIntegerToSReal, label , sAssert , liftQRem, liftDMod, symbolicMergeWithKind , genLiteral, genFromCW, genMkSymVar , isSatisfiableInCurrentPath , sbvQuickCheck ) where import Control.Monad (when, unless) import Control.Monad.Reader (ask) import Control.Monad.Trans (liftIO) import GHC.Generics (U1(..), M1(..), (:*:)(..), K1(..)) import qualified GHC.Generics as G import GHC.Stack.Compat import Data.Array (Array, Ix, listArray, elems, bounds, rangeSize) import Data.Bits (Bits(..)) import Data.Int (Int8, Int16, Int32, Int64) import Data.List (genericLength, genericIndex, genericTake, unzip4, unzip5, unzip6, unzip7, intercalate) import Data.Maybe (fromMaybe) import Data.Word (Word8, Word16, Word32, Word64) import Test.QuickCheck (Testable(..), Arbitrary(..)) import qualified Test.QuickCheck.Test as QC (isSuccess) import qualified Test.QuickCheck as QC (quickCheckResult, counterexample) import qualified Test.QuickCheck.Monadic as QC (monadicIO, run, assert, pre, monitor) import System.Random import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data import Data.SBV.Utils.Boolean import Data.SBV.Provers.Prover (isVacuous, prove, defaultSMTCfg, internalSATCheck) import Data.SBV.SMT.SMT (ThmResult, SatResult(..), showModel) import Data.SBV.BitVectors.Symbolic import Data.SBV.BitVectors.Operations -- | Newer versions of GHC (Starting with 7.8 I think), distinguishes between FiniteBits and Bits classes. -- We should really use FiniteBitSize for SBV which would make things better. In the interim, just work -- around pesky warnings.. ghcBitSize :: Bits a => a -> Int ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x) mkSymOpSC :: (SW -> SW -> Maybe SW) -> Op -> State -> Kind -> SW -> SW -> IO SW mkSymOpSC shortCut op st k a b = maybe (newExpr st k (SBVApp op [a, b])) return (shortCut a b) mkSymOp :: Op -> State -> Kind -> SW -> SW -> IO SW mkSymOp = mkSymOpSC (const (const Nothing)) -- Symbolic-Word class instances -- | Generate a finite symbolic bitvector, named genVar :: Maybe Quantifier -> Kind -> String -> Symbolic (SBV a) genVar q k = mkSymSBV q k . Just -- | Generate a finite symbolic bitvector, unnamed genVar_ :: Maybe Quantifier -> Kind -> Symbolic (SBV a) genVar_ q k = mkSymSBV q k Nothing -- | Generate a finite constant bitvector genLiteral :: Integral a => Kind -> a -> SBV b genLiteral k = SBV . SVal k . Left . mkConstCW k -- | Convert a constant to an integral value genFromCW :: Integral a => CW -> a genFromCW (CW _ (CWInteger x)) = fromInteger x genFromCW c = error $ "genFromCW: Unsupported non-integral value: " ++ show c -- | Generically make a symbolic var genMkSymVar :: Kind -> Maybe Quantifier -> Maybe String -> Symbolic (SBV a) genMkSymVar k mbq Nothing = genVar_ mbq k genMkSymVar k mbq (Just s) = genVar mbq k s -- | Base type of () allows simple construction for uninterpreted types. instance SymWord () instance HasKind () instance SymWord Bool where mkSymWord = genMkSymVar KBool literal x = SBV (svBool x) fromCW = cwToBool instance SymWord Word8 where mkSymWord = genMkSymVar (KBounded False 8) literal = genLiteral (KBounded False 8) fromCW = genFromCW instance SymWord Int8 where mkSymWord = genMkSymVar (KBounded True 8) literal = genLiteral (KBounded True 8) fromCW = genFromCW instance SymWord Word16 where mkSymWord = genMkSymVar (KBounded False 16) literal = genLiteral (KBounded False 16) fromCW = genFromCW instance SymWord Int16 where mkSymWord = genMkSymVar (KBounded True 16) literal = genLiteral (KBounded True 16) fromCW = genFromCW instance SymWord Word32 where mkSymWord = genMkSymVar (KBounded False 32) literal = genLiteral (KBounded False 32) fromCW = genFromCW instance SymWord Int32 where mkSymWord = genMkSymVar (KBounded True 32) literal = genLiteral (KBounded True 32) fromCW = genFromCW instance SymWord Word64 where mkSymWord = genMkSymVar (KBounded False 64) literal = genLiteral (KBounded False 64) fromCW = genFromCW instance SymWord Int64 where mkSymWord = genMkSymVar (KBounded True 64) literal = genLiteral (KBounded True 64) fromCW = genFromCW instance SymWord Integer where mkSymWord = genMkSymVar KUnbounded literal = SBV . SVal KUnbounded . Left . mkConstCW KUnbounded fromCW = genFromCW instance SymWord AlgReal where mkSymWord = genMkSymVar KReal literal = SBV . SVal KReal . Left . CW KReal . CWAlgReal fromCW (CW _ (CWAlgReal a)) = a fromCW c = error $ "SymWord.AlgReal: Unexpected non-real value: " ++ show c -- AlgReal needs its own definition of isConcretely -- to make sure we avoid using unimplementable Haskell functions isConcretely (SBV (SVal KReal (Left (CW KReal (CWAlgReal v))))) p | isExactRational v = p v isConcretely _ _ = False instance SymWord Float where mkSymWord = genMkSymVar KFloat literal = SBV . SVal KFloat . Left . CW KFloat . CWFloat fromCW (CW _ (CWFloat a)) = a fromCW c = error $ "SymWord.Float: Unexpected non-float value: " ++ show c -- For Float, we conservatively return 'False' for isConcretely. The reason is that -- this function is used for optimizations when only one of the argument is concrete, -- and in the presence of NaN's it would be incorrect to do any optimization isConcretely _ _ = False instance SymWord Double where mkSymWord = genMkSymVar KDouble literal = SBV . SVal KDouble . Left . CW KDouble . CWDouble fromCW (CW _ (CWDouble a)) = a fromCW c = error $ "SymWord.Double: Unexpected non-double value: " ++ show c -- For Double, we conservatively return 'False' for isConcretely. The reason is that -- this function is used for optimizations when only one of the argument is concrete, -- and in the presence of NaN's it would be incorrect to do any optimization isConcretely _ _ = False ------------------------------------------------------------------------------------ -- * Smart constructors for creating symbolic values. These are not strictly -- necessary, as they are mere aliases for 'symbolic' and 'symbolics', but -- they nonetheless make programming easier. ------------------------------------------------------------------------------------ -- | Declare an 'SBool' sBool :: String -> Symbolic SBool sBool = symbolic -- | Declare a list of 'SBool's sBools :: [String] -> Symbolic [SBool] sBools = symbolics -- | Declare an 'SWord8' sWord8 :: String -> Symbolic SWord8 sWord8 = symbolic -- | Declare a list of 'SWord8's sWord8s :: [String] -> Symbolic [SWord8] sWord8s = symbolics -- | Declare an 'SWord16' sWord16 :: String -> Symbolic SWord16 sWord16 = symbolic -- | Declare a list of 'SWord16's sWord16s :: [String] -> Symbolic [SWord16] sWord16s = symbolics -- | Declare an 'SWord32' sWord32 :: String -> Symbolic SWord32 sWord32 = symbolic -- | Declare a list of 'SWord32's sWord32s :: [String] -> Symbolic [SWord32] sWord32s = symbolics -- | Declare an 'SWord64' sWord64 :: String -> Symbolic SWord64 sWord64 = symbolic -- | Declare a list of 'SWord64's sWord64s :: [String] -> Symbolic [SWord64] sWord64s = symbolics -- | Declare an 'SInt8' sInt8 :: String -> Symbolic SInt8 sInt8 = symbolic -- | Declare a list of 'SInt8's sInt8s :: [String] -> Symbolic [SInt8] sInt8s = symbolics -- | Declare an 'SInt16' sInt16 :: String -> Symbolic SInt16 sInt16 = symbolic -- | Declare a list of 'SInt16's sInt16s :: [String] -> Symbolic [SInt16] sInt16s = symbolics -- | Declare an 'SInt32' sInt32 :: String -> Symbolic SInt32 sInt32 = symbolic -- | Declare a list of 'SInt32's sInt32s :: [String] -> Symbolic [SInt32] sInt32s = symbolics -- | Declare an 'SInt64' sInt64 :: String -> Symbolic SInt64 sInt64 = symbolic -- | Declare a list of 'SInt64's sInt64s :: [String] -> Symbolic [SInt64] sInt64s = symbolics -- | Declare an 'SInteger' sInteger:: String -> Symbolic SInteger sInteger = symbolic -- | Declare a list of 'SInteger's sIntegers :: [String] -> Symbolic [SInteger] sIntegers = symbolics -- | Declare an 'SReal' sReal:: String -> Symbolic SReal sReal = symbolic -- | Declare a list of 'SReal's sReals :: [String] -> Symbolic [SReal] sReals = symbolics -- | Declare an 'SFloat' sFloat :: String -> Symbolic SFloat sFloat = symbolic -- | Declare a list of 'SFloat's sFloats :: [String] -> Symbolic [SFloat] sFloats = symbolics -- | Declare an 'SDouble' sDouble :: String -> Symbolic SDouble sDouble = symbolic -- | Declare a list of 'SDouble's sDoubles :: [String] -> Symbolic [SDouble] sDoubles = symbolics -- | Promote an SInteger to an SReal sIntegerToSReal :: SInteger -> SReal sIntegerToSReal x | Just i <- unliteral x = literal $ fromInteger i | True = SBV (SVal KReal (Right (cache y))) where y st = do xsw <- sbvToSW st x newExpr st KReal (SBVApp (IntCast KUnbounded KReal) [xsw]) -- | label: Label the result of an expression. This is essentially a no-op, but useful as it generates a comment in the generated C/SMT-Lib code. -- Note that if the argument is a constant, then the label is dropped completely, per the usual constant folding strategy. label :: SymWord a => String -> SBV a -> SBV a label m x | Just _ <- unliteral x = x | True = SBV $ SVal k $ Right $ cache r where k = kindOf x r st = do xsw <- sbvToSW st x newExpr st k (SBVApp (Label m) [xsw]) -- | Symbolic Equality. Note that we can't use Haskell's 'Eq' class since Haskell insists on returning Bool -- Comparing symbolic values will necessarily return a symbolic value. -- -- Minimal complete definition: '.==' infix 4 .==, ./= class EqSymbolic a where (.==), (./=) :: a -> a -> SBool -- minimal complete definition: .== x ./= y = bnot (x .== y) -- | Symbolic Comparisons. Similar to 'Eq', we cannot implement Haskell's 'Ord' class -- since there is no way to return an 'Ordering' value from a symbolic comparison. -- Furthermore, 'OrdSymbolic' requires 'Mergeable' to implement if-then-else, for the -- benefit of implementing symbolic versions of 'max' and 'min' functions. -- -- Minimal complete definition: '.<' infix 4 .<, .<=, .>, .>= class (Mergeable a, EqSymbolic a) => OrdSymbolic a where (.<), (.<=), (.>), (.>=) :: a -> a -> SBool smin, smax :: a -> a -> a -- minimal complete definition: .< a .<= b = a .< b ||| a .== b a .> b = b .< a a .>= b = b .<= a a `smin` b = ite (a .<= b) a b a `smax` b = ite (a .<= b) b a {- We can't have a generic instance of the form: instance Eq a => EqSymbolic a where x .== y = if x == y then true else false even if we're willing to allow Flexible/undecidable instances.. This is because if we allow this it would imply EqSymbolic (SBV a); since (SBV a) has to be Eq as it must be a Num. But this wouldn't be the right choice obviously; as the Eq instance is bogus for SBV for natural reasons.. -} instance EqSymbolic (SBV a) where SBV x .== SBV y = SBV (svEqual x y) SBV x ./= SBV y = SBV (svNotEqual x y) instance SymWord a => OrdSymbolic (SBV a) where SBV x .< SBV y = SBV (svLessThan x y) SBV x .<= SBV y = SBV (svLessEq x y) SBV x .> SBV y = SBV (svGreaterThan x y) SBV x .>= SBV y = SBV (svGreaterEq x y) -- Bool instance EqSymbolic Bool where x .== y = if x == y then true else false -- Lists instance EqSymbolic a => EqSymbolic [a] where [] .== [] = true (x:xs) .== (y:ys) = x .== y &&& xs .== ys _ .== _ = false instance OrdSymbolic a => OrdSymbolic [a] where [] .< [] = false [] .< _ = true _ .< [] = false (x:xs) .< (y:ys) = x .< y ||| (x .== y &&& xs .< ys) -- Maybe instance EqSymbolic a => EqSymbolic (Maybe a) where Nothing .== Nothing = true Just a .== Just b = a .== b _ .== _ = false instance (OrdSymbolic a) => OrdSymbolic (Maybe a) where Nothing .< Nothing = false Nothing .< _ = true Just _ .< Nothing = false Just a .< Just b = a .< b -- Either instance (EqSymbolic a, EqSymbolic b) => EqSymbolic (Either a b) where Left a .== Left b = a .== b Right a .== Right b = a .== b _ .== _ = false instance (OrdSymbolic a, OrdSymbolic b) => OrdSymbolic (Either a b) where Left a .< Left b = a .< b Left _ .< Right _ = true Right _ .< Left _ = false Right a .< Right b = a .< b -- 2-Tuple instance (EqSymbolic a, EqSymbolic b) => EqSymbolic (a, b) where (a0, b0) .== (a1, b1) = a0 .== a1 &&& b0 .== b1 instance (OrdSymbolic a, OrdSymbolic b) => OrdSymbolic (a, b) where (a0, b0) .< (a1, b1) = a0 .< a1 ||| (a0 .== a1 &&& b0 .< b1) -- 3-Tuple instance (EqSymbolic a, EqSymbolic b, EqSymbolic c) => EqSymbolic (a, b, c) where (a0, b0, c0) .== (a1, b1, c1) = (a0, b0) .== (a1, b1) &&& c0 .== c1 instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c) => OrdSymbolic (a, b, c) where (a0, b0, c0) .< (a1, b1, c1) = (a0, b0) .< (a1, b1) ||| ((a0, b0) .== (a1, b1) &&& c0 .< c1) -- 4-Tuple instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d) => EqSymbolic (a, b, c, d) where (a0, b0, c0, d0) .== (a1, b1, c1, d1) = (a0, b0, c0) .== (a1, b1, c1) &&& d0 .== d1 instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d) => OrdSymbolic (a, b, c, d) where (a0, b0, c0, d0) .< (a1, b1, c1, d1) = (a0, b0, c0) .< (a1, b1, c1) ||| ((a0, b0, c0) .== (a1, b1, c1) &&& d0 .< d1) -- 5-Tuple instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e) => EqSymbolic (a, b, c, d, e) where (a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) = (a0, b0, c0, d0) .== (a1, b1, c1, d1) &&& e0 .== e1 instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e) => OrdSymbolic (a, b, c, d, e) where (a0, b0, c0, d0, e0) .< (a1, b1, c1, d1, e1) = (a0, b0, c0, d0) .< (a1, b1, c1, d1) ||| ((a0, b0, c0, d0) .== (a1, b1, c1, d1) &&& e0 .< e1) -- 6-Tuple instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f) => EqSymbolic (a, b, c, d, e, f) where (a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) = (a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) &&& f0 .== f1 instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e, OrdSymbolic f) => OrdSymbolic (a, b, c, d, e, f) where (a0, b0, c0, d0, e0, f0) .< (a1, b1, c1, d1, e1, f1) = (a0, b0, c0, d0, e0) .< (a1, b1, c1, d1, e1) ||| ((a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) &&& f0 .< f1) -- 7-Tuple instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f, EqSymbolic g) => EqSymbolic (a, b, c, d, e, f, g) where (a0, b0, c0, d0, e0, f0, g0) .== (a1, b1, c1, d1, e1, f1, g1) = (a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) &&& g0 .== g1 instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e, OrdSymbolic f, OrdSymbolic g) => OrdSymbolic (a, b, c, d, e, f, g) where (a0, b0, c0, d0, e0, f0, g0) .< (a1, b1, c1, d1, e1, f1, g1) = (a0, b0, c0, d0, e0, f0) .< (a1, b1, c1, d1, e1, f1) ||| ((a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) &&& g0 .< g1) -- | Symbolic Numbers. This is a simple class that simply incorporates all number like -- base types together, simplifying writing polymorphic type-signatures that work for all -- symbolic numbers, such as 'SWord8', 'SInt8' etc. For instance, we can write a generic -- list-minimum function as follows: -- -- @ -- mm :: SIntegral a => [SBV a] -> SBV a -- mm = foldr1 (\a b -> ite (a .<= b) a b) -- @ -- -- It is similar to the standard 'Integral' class, except ranging over symbolic instances. class (SymWord a, Num a, Bits a) => SIntegral a -- 'SIntegral' Instances, including all possible variants except 'Bool', since booleans -- are not numbers. instance SIntegral Word8 instance SIntegral Word16 instance SIntegral Word32 instance SIntegral Word64 instance SIntegral Int8 instance SIntegral Int16 instance SIntegral Int32 instance SIntegral Int64 instance SIntegral Integer -- Boolean combinators instance Boolean SBool where true = literal True false = literal False bnot (SBV b) = SBV (svNot b) SBV a &&& SBV b = SBV (svAnd a b) SBV a ||| SBV b = SBV (svOr a b) SBV a <+> SBV b = SBV (svXOr a b) -- | Returns (symbolic) true if all the elements of the given list are different. allDifferent :: EqSymbolic a => [a] -> SBool allDifferent [] = true allDifferent (x:xs) = bAll (x ./=) xs &&& allDifferent xs -- | Returns (symbolic) true if all the elements of the given list are the same. allEqual :: EqSymbolic a => [a] -> SBool allEqual [] = true allEqual (x:xs) = bAll (x .==) xs -- | Returns (symbolic) true if the argument is in range inRange :: OrdSymbolic a => a -> (a, a) -> SBool inRange x (y, z) = x .>= y &&& x .<= z -- | Symbolic membership test sElem :: EqSymbolic a => a -> [a] -> SBool sElem x xs = bAny (.== x) xs -- | Returns 1 if the boolean is true, otherwise 0. oneIf :: (Num a, SymWord a) => SBool -> SBV a oneIf t = ite t 1 0 -- | Predicate for optimizing word operations like (+) and (*). isConcreteZero :: SBV a -> Bool isConcreteZero (SBV (SVal _ (Left (CW _ (CWInteger n))))) = n == 0 isConcreteZero (SBV (SVal KReal (Left (CW KReal (CWAlgReal v))))) = isExactRational v && v == 0 isConcreteZero _ = False -- | Predicate for optimizing word operations like (+) and (*). isConcreteOne :: SBV a -> Bool isConcreteOne (SBV (SVal _ (Left (CW _ (CWInteger 1))))) = True isConcreteOne (SBV (SVal KReal (Left (CW KReal (CWAlgReal v))))) = isExactRational v && v == 1 isConcreteOne _ = False -- Num instance for symbolic words. instance (Ord a, Num a, SymWord a) => Num (SBV a) where fromInteger = literal . fromIntegral SBV x + SBV y = SBV (svPlus x y) SBV x * SBV y = SBV (svTimes x y) SBV x - SBV y = SBV (svMinus x y) -- Abs is problematic for floating point, due to -0; case, so we carefully shuttle it down -- to the solver to avoid the can of worms. (Alternative would be to do an if-then-else here.) abs (SBV x) = SBV (svAbs x) signum a -- NB. The following "carefully" tests the number for == 0, as Float/Double's NaN and +/-0 -- cases would cause trouble with explicit equality tests. | hasSign a = ite (a .> z) i $ ite (a .< z) (negate i) a | True = ite (a .> z) i a where z = genLiteral (kindOf a) (0::Integer) i = genLiteral (kindOf a) (1::Integer) -- negate is tricky because on double/float -0 is different than 0; so we cannot -- just rely on the default definition; which would be 0-0, which is not -0! negate (SBV x) = SBV (svUNeg x) -- | Symbolic exponentiation using bit blasting and repeated squaring. -- -- N.B. The exponent must be unsigned. Signed exponents will be rejected. (.^) :: (Mergeable b, Num b, SIntegral e) => b -> SBV e -> b b .^ e | isSigned e = error "(.^): exponentiation only works with unsigned exponents" | True = product $ zipWith (\use n -> ite use n 1) (blastLE e) (iterate (\x -> x*x) b) instance (SymWord a, Fractional a) => Fractional (SBV a) where fromRational = literal . fromRational SBV x / sy@(SBV y) | div0 = ite (sy .== 0) 0 res | True = res where res = SBV (svDivide x y) -- Identify those kinds where we have a div-0 equals 0 exception div0 = case kindOf sy of KFloat -> False KDouble -> False KReal -> True -- Following two cases should not happen since these types should *not* be instances of Fractional k@KBounded{} -> error $ "Unexpected Fractional case for: " ++ show k k@KUnbounded -> error $ "Unexpected Fractional case for: " ++ show k k@KBool -> error $ "Unexpected Fractional case for: " ++ show k k@KUserSort{} -> error $ "Unexpected Fractional case for: " ++ show k -- | Define Floating instance on SBV's; only for base types that are already floating; i.e., SFloat and SDouble -- Note that most of the fields are "undefined" for symbolic values, we add methods as they are supported by SMTLib. -- Currently, the only symbolicly available function in this class is sqrt. instance (SymWord a, Fractional a, Floating a) => Floating (SBV a) where pi = literal pi exp = lift1FNS "exp" exp log = lift1FNS "log" log sqrt = lift1F FP_Sqrt sqrt sin = lift1FNS "sin" sin cos = lift1FNS "cos" cos tan = lift1FNS "tan" tan asin = lift1FNS "asin" asin acos = lift1FNS "acos" acos atan = lift1FNS "atan" atan sinh = lift1FNS "sinh" sinh cosh = lift1FNS "cosh" cosh tanh = lift1FNS "tanh" tanh asinh = lift1FNS "asinh" asinh acosh = lift1FNS "acosh" acosh atanh = lift1FNS "atanh" atanh (**) = lift2FNS "**" (**) logBase = lift2FNS "logBase" logBase -- | Lift a 1 arg FP-op, using sRNE default lift1F :: SymWord a => FPOp -> (a -> a) -> SBV a -> SBV a lift1F w op a | Just v <- unliteral a = literal $ op v | True = SBV $ SVal k $ Right $ cache r where k = kindOf a r st = do swa <- sbvToSW st a swm <- sbvToSW st sRNE newExpr st k (SBVApp (IEEEFP w) [swm, swa]) -- | Lift a float/double unary function, only over constants lift1FNS :: (SymWord a, Floating a) => String -> (a -> a) -> SBV a -> SBV a lift1FNS nm f sv | Just v <- unliteral sv = literal $ f v | True = error $ "SBV." ++ nm ++ ": not supported for symbolic values of type " ++ show (kindOf sv) -- | Lift a float/double binary function, only over constants lift2FNS :: (SymWord a, Floating a) => String -> (a -> a -> a) -> SBV a -> SBV a -> SBV a lift2FNS nm f sv1 sv2 | Just v1 <- unliteral sv1 , Just v2 <- unliteral sv2 = literal $ f v1 v2 | True = error $ "SBV." ++ nm ++ ": not supported for symbolic values of type " ++ show (kindOf sv1) -- NB. In the optimizations below, use of -1 is valid as -- -1 has all bits set to True for both signed and unsigned values instance (Num a, Bits a, SymWord a) => Bits (SBV a) where SBV x .&. SBV y = SBV (svAnd x y) SBV x .|. SBV y = SBV (svOr x y) SBV x `xor` SBV y = SBV (svXOr x y) complement (SBV x) = SBV (svNot x) bitSize x = intSizeOf x bitSizeMaybe x = Just $ intSizeOf x isSigned x = hasSign x bit i = 1 `shiftL` i setBit x i = x .|. genLiteral (kindOf x) (bit i :: Integer) clearBit x i = x .&. genLiteral (kindOf x) (complement (bit i) :: Integer) complementBit x i = x `xor` genLiteral (kindOf x) (bit i :: Integer) shiftL (SBV x) i = SBV (svShl x i) shiftR (SBV x) i = SBV (svShr x i) rotateL (SBV x) i = SBV (svRol x i) rotateR (SBV x) i = SBV (svRor x i) -- NB. testBit is *not* implementable on non-concrete symbolic words x `testBit` i | SBV (SVal _ (Left (CW _ (CWInteger n)))) <- x = testBit n i | True = error $ "SBV.testBit: Called on symbolic value: " ++ show x ++ ". Use sTestBit instead." -- NB. popCount is *not* implementable on non-concrete symbolic words popCount x | SBV (SVal _ (Left (CW (KBounded _ w) (CWInteger n)))) <- x = popCount (n .&. (bit w - 1)) | True = error $ "SBV.popCount: Called on symbolic value: " ++ show x ++ ". Use sPopCount instead." -- | Replacement for 'testBit'. Since 'testBit' requires a 'Bool' to be returned, -- we cannot implement it for symbolic words. Index 0 is the least-significant bit. sTestBit :: SBV a -> Int -> SBool sTestBit (SBV x) i = SBV (svTestBit x i) -- | Variant of 'sTestBit', where we want to extract multiple bit positions. sExtractBits :: SBV a -> [Int] -> [SBool] sExtractBits x = map (sTestBit x) -- | Replacement for 'popCount'. Since 'popCount' returns an 'Int', we cannot implement -- it for symbolic words. Here, we return an 'SWord8', which can overflow when used on -- quantities that have more than 255 bits. Currently, that's only the 'SInteger' type -- that SBV supports, all other types are safe. Even with 'SInteger', this will only -- overflow if there are at least 256-bits set in the number, and the smallest such -- number is 2^256-1, which is a pretty darn big number to worry about for practical -- purposes. In any case, we do not support 'sPopCount' for unbounded symbolic integers, -- as the only possible implementation wouldn't symbolically terminate. So the only overflow -- issue is with really-really large concrete 'SInteger' values. sPopCount :: (Num a, Bits a, SymWord a) => SBV a -> SWord8 sPopCount x | isReal x = error "SBV.sPopCount: Called on a real value" -- can't really happen due to types, but being overcautious | isConcrete x = go 0 x | not (isBounded x) = error "SBV.sPopCount: Called on an infinite precision symbolic value" | True = sum [ite b 1 0 | b <- blastLE x] where -- concrete case go !c 0 = c go !c w = go (c+1) (w .&. (w-1)) -- | Generalization of 'setBit' based on a symbolic boolean. Note that 'setBit' and -- 'clearBit' are still available on Symbolic words, this operation comes handy when -- the condition to set/clear happens to be symbolic. setBitTo :: (Num a, Bits a, SymWord a) => SBV a -> Int -> SBool -> SBV a setBitTo x i b = ite b (setBit x i) (clearBit x i) -- | Conversion between integral-symbolic values, akin to Haskell's fromIntegral sFromIntegral :: forall a b. (Integral a, HasKind a, Num a, Bits a, SymWord a, HasKind b, Num b, Bits b, SymWord b) => SBV a -> SBV b sFromIntegral x | isReal x = error "SBV.sFromIntegral: Called on a real value" -- can't really happen due to types, but being overcautious | Just v <- unliteral x = literal (fromIntegral v) | True = result where result = SBV (SVal kTo (Right (cache y))) kFrom = kindOf x kTo = kindOf (undefined :: b) y st = do xsw <- sbvToSW st x newExpr st kTo (SBVApp (IntCast kFrom kTo) [xsw]) -- | Generalization of 'shiftL', when the shift-amount is symbolic. Since Haskell's -- 'shiftL' only takes an 'Int' as the shift amount, it cannot be used when we have -- a symbolic amount to shift with. The first argument should be a bounded quantity. sShiftLeft :: (SIntegral a, SIntegral b) => SBV a -> SBV b -> SBV a sShiftLeft x i | not (isBounded x) = error "SBV.sShiftRight: Shifted amount should be a bounded quantity!" | True = ite (i .< 0) (select [x `shiftR` k | k <- [0 .. ghcBitSize x - 1]] z (-i)) (select [x `shiftL` k | k <- [0 .. ghcBitSize x - 1]] z i ) where z = genLiteral (kindOf x) (0::Integer) -- | Generalization of 'shiftR', when the shift-amount is symbolic. Since Haskell's -- 'shiftR' only takes an 'Int' as the shift amount, it cannot be used when we have -- a symbolic amount to shift with. The first argument should be a bounded quantity. -- -- NB. If the shiftee is signed, then this is an arithmetic shift; otherwise it's logical, -- following the usual Haskell convention. See 'sSignedShiftArithRight' for a variant -- that explicitly uses the msb as the sign bit, even for unsigned underlying types. sShiftRight :: (SIntegral a, SIntegral b) => SBV a -> SBV b -> SBV a sShiftRight x i | not (isBounded x) = error "SBV.sShiftRight: Shifted amount should be a bounded quantity!" | True = ite (i .< 0) (select [x `shiftL` k | k <- [0 .. ghcBitSize x - 1]] z (-i)) (select [x `shiftR` k | k <- [0 .. ghcBitSize x - 1]] z i ) where z = genLiteral (kindOf x) (0::Integer) -- | Arithmetic shift-right with a symbolic unsigned shift amount. This is equivalent -- to 'sShiftRight' when the argument is signed. However, if the argument is unsigned, -- then it explicitly treats its msb as a sign-bit, and uses it as the bit that -- gets shifted in. Useful when using the underlying unsigned bit representation to implement -- custom signed operations. Note that there is no direct Haskell analogue of this function. sSignedShiftArithRight:: (SIntegral a, SIntegral b) => SBV a -> SBV b -> SBV a sSignedShiftArithRight x i | isSigned i = error "sSignedShiftArithRight: shift amount should be unsigned" | isSigned x = sShiftRight x i | True = ite (msb x) (complement (sShiftRight (complement x) i)) (sShiftRight x i) -- | Generalization of 'rotateL', when the shift-amount is symbolic. Since Haskell's -- 'rotateL' only takes an 'Int' as the shift amount, it cannot be used when we have -- a symbolic amount to shift with. The first argument should be a bounded quantity. sRotateLeft :: (SIntegral a, SIntegral b, SDivisible (SBV b)) => SBV a -> SBV b -> SBV a sRotateLeft x i | not (isBounded x) = sShiftLeft x i | isBounded i && bit si <= toInteger sx -- wrap-around not possible = ite (i .< 0) (select [x `rotateR` k | k <- [0 .. bit si - 1]] z (-i)) (select [x `rotateL` k | k <- [0 .. bit si - 1]] z i ) | True = ite (i .< 0) (select [x `rotateR` k | k <- [0 .. sx - 1]] z ((-i) `sRem` n)) (select [x `rotateL` k | k <- [0 .. sx - 1]] z ( i `sRem` n)) where sx = ghcBitSize x si = ghcBitSize i z = genLiteral (kindOf x) (0::Integer) n = genLiteral (kindOf i) (toInteger sx) -- | Generalization of 'rotateR', when the shift-amount is symbolic. Since Haskell's -- 'rotateR' only takes an 'Int' as the shift amount, it cannot be used when we have -- a symbolic amount to shift with. The first argument should be a bounded quantity. sRotateRight :: (SIntegral a, SIntegral b, SDivisible (SBV b)) => SBV a -> SBV b -> SBV a sRotateRight x i | not (isBounded x) = sShiftRight x i | isBounded i && bit si <= toInteger sx -- wrap-around not possible = ite (i .< 0) (select [x `rotateL` k | k <- [0 .. bit si - 1]] z (-i)) (select [x `rotateR` k | k <- [0 .. bit si - 1]] z i) | True = ite (i .< 0) (select [x `rotateL` k | k <- [0 .. sx - 1]] z ((-i) `sRem` n)) (select [x `rotateR` k | k <- [0 .. sx - 1]] z ( i `sRem` n)) where sx = ghcBitSize x si = ghcBitSize i z = genLiteral (kindOf x) (0::Integer) n = genLiteral (kindOf i) (toInteger sx) -- | Full adder. Returns the carry-out from the addition. -- -- N.B. Only works for unsigned types. Signed arguments will be rejected. fullAdder :: SIntegral a => SBV a -> SBV a -> (SBool, SBV a) fullAdder a b | isSigned a = error "fullAdder: only works on unsigned numbers" | True = (a .> s ||| b .> s, s) where s = a + b -- | Full multiplier: Returns both the high-order and the low-order bits in a tuple, -- thus fully accounting for the overflow. -- -- N.B. Only works for unsigned types. Signed arguments will be rejected. -- -- N.B. The higher-order bits are determined using a simple shift-add multiplier, -- thus involving bit-blasting. It'd be naive to expect SMT solvers to deal efficiently -- with properties involving this function, at least with the current state of the art. fullMultiplier :: SIntegral a => SBV a -> SBV a -> (SBV a, SBV a) fullMultiplier a b | isSigned a = error "fullMultiplier: only works on unsigned numbers" | True = (go (ghcBitSize a) 0 a, a*b) where go 0 p _ = p go n p x = let (c, p') = ite (lsb x) (fullAdder p b) (false, p) (o, p'') = shiftIn c p' (_, x') = shiftIn o x in go (n-1) p'' x' shiftIn k v = (lsb v, mask .|. (v `shiftR` 1)) where mask = ite k (bit (ghcBitSize v - 1)) 0 -- | Little-endian blasting of a word into its bits. Also see the 'FromBits' class. blastLE :: (Num a, Bits a, SymWord a) => SBV a -> [SBool] blastLE x | isReal x = error "SBV.blastLE: Called on a real value" | not (isBounded x) = error "SBV.blastLE: Called on an infinite precision value" | True = map (sTestBit x) [0 .. intSizeOf x - 1] -- | Big-endian blasting of a word into its bits. Also see the 'FromBits' class. blastBE :: (Num a, Bits a, SymWord a) => SBV a -> [SBool] blastBE = reverse . blastLE -- | Least significant bit of a word, always stored at index 0. lsb :: SBV a -> SBool lsb x = sTestBit x 0 -- | Most significant bit of a word, always stored at the last position. msb :: (Num a, Bits a, SymWord a) => SBV a -> SBool msb x | isReal x = error "SBV.msb: Called on a real value" | not (isBounded x) = error "SBV.msb: Called on an infinite precision value" | True = sTestBit x (intSizeOf x - 1) -- Enum instance. These instances are suitable for use with concrete values, -- and will be less useful for symbolic values around. Note that `fromEnum` requires -- a concrete argument for obvious reasons. Other variants (succ, pred, [x..]) etc are similarly -- limited. While symbolic variants can be defined for many of these, they will just diverge -- as final sizes cannot be determined statically. instance (Show a, Bounded a, Integral a, Num a, SymWord a) => Enum (SBV a) where succ x | v == (maxBound :: a) = error $ "Enum.succ{" ++ showType x ++ "}: tried to take `succ' of maxBound" | True = fromIntegral $ v + 1 where v = enumCvt "succ" x pred x | v == (minBound :: a) = error $ "Enum.pred{" ++ showType x ++ "}: tried to take `pred' of minBound" | True = fromIntegral $ v - 1 where v = enumCvt "pred" x toEnum x | xi < fromIntegral (minBound :: a) || xi > fromIntegral (maxBound :: a) = error $ "Enum.toEnum{" ++ showType r ++ "}: " ++ show x ++ " is out-of-bounds " ++ show (minBound :: a, maxBound :: a) | True = r where xi :: Integer xi = fromIntegral x r :: SBV a r = fromIntegral x fromEnum x | r < fromIntegral (minBound :: Int) || r > fromIntegral (maxBound :: Int) = error $ "Enum.fromEnum{" ++ showType x ++ "}: value " ++ show r ++ " is outside of Int's bounds " ++ show (minBound :: Int, maxBound :: Int) | True = fromIntegral r where r :: Integer r = enumCvt "fromEnum" x enumFrom x = map fromIntegral [xi .. fromIntegral (maxBound :: a)] where xi :: Integer xi = enumCvt "enumFrom" x enumFromThen x y | yi >= xi = map fromIntegral [xi, yi .. fromIntegral (maxBound :: a)] | True = map fromIntegral [xi, yi .. fromIntegral (minBound :: a)] where xi, yi :: Integer xi = enumCvt "enumFromThen.x" x yi = enumCvt "enumFromThen.y" y enumFromThenTo x y z = map fromIntegral [xi, yi .. zi] where xi, yi, zi :: Integer xi = enumCvt "enumFromThenTo.x" x yi = enumCvt "enumFromThenTo.y" y zi = enumCvt "enumFromThenTo.z" z -- | Helper function for use in enum operations enumCvt :: (SymWord a, Integral a, Num b) => String -> SBV a -> b enumCvt w x = case unliteral x of Nothing -> error $ "Enum." ++ w ++ "{" ++ showType x ++ "}: Called on symbolic value " ++ show x Just v -> fromIntegral v -- | The 'SDivisible' class captures the essence of division. -- Unfortunately we cannot use Haskell's 'Integral' class since the 'Real' -- and 'Enum' superclasses are not implementable for symbolic bit-vectors. -- However, 'quotRem' and 'divMod' makes perfect sense, and the 'SDivisible' class captures -- this operation. One issue is how division by 0 behaves. The verification -- technology requires total functions, and there are several design choices -- here. We follow Isabelle/HOL approach of assigning the value 0 for division -- by 0. Therefore, we impose the following pair of laws: -- -- @ -- x `sQuotRem` 0 = (0, x) -- x `sDivMod` 0 = (0, x) -- @ -- -- Note that our instances implement this law even when @x@ is @0@ itself. -- -- NB. 'quot' truncates toward zero, while 'div' truncates toward negative infinity. -- -- Minimal complete definition: 'sQuotRem', 'sDivMod' class SDivisible a where sQuotRem :: a -> a -> (a, a) sDivMod :: a -> a -> (a, a) sQuot :: a -> a -> a sRem :: a -> a -> a sDiv :: a -> a -> a sMod :: a -> a -> a x `sQuot` y = fst $ x `sQuotRem` y x `sRem` y = snd $ x `sQuotRem` y x `sDiv` y = fst $ x `sDivMod` y x `sMod` y = snd $ x `sDivMod` y instance SDivisible Word64 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Int64 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Word32 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Int32 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Word16 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Int16 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Word8 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Int8 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible Integer where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y instance SDivisible CW where sQuotRem a b | CWInteger x <- cwVal a, CWInteger y <- cwVal b = let (r1, r2) = sQuotRem x y in (normCW a{ cwVal = CWInteger r1 }, normCW b{ cwVal = CWInteger r2 }) sQuotRem a b = error $ "SBV.sQuotRem: impossible, unexpected args received: " ++ show (a, b) sDivMod a b | CWInteger x <- cwVal a, CWInteger y <- cwVal b = let (r1, r2) = sDivMod x y in (normCW a { cwVal = CWInteger r1 }, normCW b { cwVal = CWInteger r2 }) sDivMod a b = error $ "SBV.sDivMod: impossible, unexpected args received: " ++ show (a, b) instance SDivisible SWord64 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SInt64 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SWord32 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SInt32 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SWord16 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SInt16 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SWord8 where sQuotRem = liftQRem sDivMod = liftDMod instance SDivisible SInt8 where sQuotRem = liftQRem sDivMod = liftDMod -- | Lift 'QRem' to symbolic words. Division by 0 is defined s.t. @x/0 = 0@; which -- holds even when @x@ is @0@ itself. liftQRem :: SymWord a => SBV a -> SBV a -> (SBV a, SBV a) liftQRem x y | isConcreteZero x = (x, x) | isConcreteOne y = (x, z) {------------------------------- - N.B. The seemingly innocuous variant when y == -1 only holds if the type is signed; - and also is problematic around the minBound.. So, we refrain from that optimization | isConcreteOnes y = (-x, z) --------------------------------} | True = ite (y .== z) (z, x) (qr x y) where qr (SBV (SVal sgnsz (Left a))) (SBV (SVal _ (Left b))) = let (q, r) = sQuotRem a b in (SBV (SVal sgnsz (Left q)), SBV (SVal sgnsz (Left r))) qr a@(SBV (SVal sgnsz _)) b = (SBV (SVal sgnsz (Right (cache (mk Quot)))), SBV (SVal sgnsz (Right (cache (mk Rem))))) where mk o st = do sw1 <- sbvToSW st a sw2 <- sbvToSW st b mkSymOp o st sgnsz sw1 sw2 z = genLiteral (kindOf x) (0::Integer) -- | Lift 'DMod' to symbolic words. Division by 0 is defined s.t. @x/0 = 0@; which -- holds even when @x@ is @0@ itself. Essentially, this is conversion from quotRem -- (truncate to 0) to divMod (truncate towards negative infinity) liftDMod :: (SymWord a, Num a, SDivisible (SBV a)) => SBV a -> SBV a -> (SBV a, SBV a) liftDMod x y | isConcreteZero x = (x, x) | isConcreteOne y = (x, z) {------------------------------- - N.B. The seemingly innocuous variant when y == -1 only holds if the type is signed; - and also is problematic around the minBound.. So, we refrain from that optimization | isConcreteOnes y = (-x, z) --------------------------------} | True = ite (y .== z) (z, x) $ ite (signum r .== negate (signum y)) (q-i, r+y) qr where qr@(q, r) = x `sQuotRem` y z = genLiteral (kindOf x) (0::Integer) i = genLiteral (kindOf x) (1::Integer) -- SInteger instance for quotRem/divMod are tricky! -- SMT-Lib only has Euclidean operations, but Haskell -- uses "truncate to 0" for quotRem, and "truncate to negative infinity" for divMod. -- So, we cannot just use the above liftings directly. instance SDivisible SInteger where sDivMod = liftDMod sQuotRem x y | not (isSymbolic x || isSymbolic y) = liftQRem x y | True = ite (y .== 0) (0, x) (qE+i, rE-i*y) where (qE, rE) = liftQRem x y -- for integers, this is euclidean due to SMTLib semantics i = ite (x .>= 0 ||| rE .== 0) 0 $ ite (y .> 0) 1 (-1) -- Quickcheck interface -- The Arbitrary instance for SFunArray returns an array initialized -- to an arbitrary element instance (SymWord b, Arbitrary b) => Arbitrary (SFunArray a b) where arbitrary = arbitrary >>= \r -> return $ SFunArray (const r) instance (SymWord a, Arbitrary a) => Arbitrary (SBV a) where arbitrary = literal `fmap` arbitrary -- | Symbolic conditionals are modeled by the 'Mergeable' class, describing -- how to merge the results of an if-then-else call with a symbolic test. SBV -- provides all basic types as instances of this class, so users only need -- to declare instances for custom data-types of their programs as needed. -- -- A 'Mergeable' instance may be automatically derived for a custom data-type -- with a single constructor where the type of each field is an instance of -- 'Mergeable', such as a record of symbolic values. Users only need to add -- 'G.Generic' and 'Mergeable' to the @deriving@ clause for the data-type. See -- 'Data.SBV.Examples.Puzzles.U2Bridge.Status' for an example and an -- illustration of what the instance would look like if written by hand. -- -- The function 'select' is a total-indexing function out of a list of choices -- with a default value, simulating array/list indexing. It's an n-way generalization -- of the 'ite' function. -- -- Minimal complete definition: None, if the type is instance of 'Generic'. Otherwise -- 'symbolicMerge'. Note that most types subject to merging are likely to be -- trivial instances of 'Generic'. class Mergeable a where -- | Merge two values based on the condition. The first argument states -- whether we force the then-and-else branches before the merging, at the -- word level. This is an efficiency concern; one that we'd rather not -- make but unfortunately necessary for getting symbolic simulation -- working efficiently. symbolicMerge :: Bool -> SBool -> a -> a -> a -- | Total indexing operation. @select xs default index@ is intuitively -- the same as @xs !! index@, except it evaluates to @default@ if @index@ -- underflows/overflows. select :: (SymWord b, Num b) => [a] -> a -> SBV b -> a -- NB. Earlier implementation of select used the binary-search trick -- on the index to chop down the search space. While that is a good trick -- in general, it doesn't work for SBV since we do not have any notion of -- "concrete" subwords: If an index is symbolic, then all its bits are -- symbolic as well. So, the binary search only pays off only if the indexed -- list is really humongous, which is not very common in general. (Also, -- for the case when the list is bit-vectors, we use SMT tables anyhow.) select xs err ind | isReal ind = bad "real" | isFloat ind = bad "float" | isDouble ind = bad "double" | hasSign ind = ite (ind .< 0) err (walk xs ind err) | True = walk xs ind err where bad w = error $ "SBV.select: unsupported " ++ w ++ " valued select/index expression" walk [] _ acc = acc walk (e:es) i acc = walk es (i-1) (ite (i .== 0) e acc) -- Default implementation for 'symbolicMerge' if the type is 'Generic' default symbolicMerge :: (G.Generic a, GMergeable (G.Rep a)) => Bool -> SBool -> a -> a -> a symbolicMerge = symbolicMergeDefault -- | If-then-else. This is by definition 'symbolicMerge' with both -- branches forced. This is typically the desired behavior, but also -- see 'iteLazy' should you need more laziness. ite :: Mergeable a => SBool -> a -> a -> a ite t a b | Just r <- unliteral t = if r then a else b | True = symbolicMerge True t a b -- | A Lazy version of ite, which does not force its arguments. This might -- cause issues for symbolic simulation with large thunks around, so use with -- care. iteLazy :: Mergeable a => SBool -> a -> a -> a iteLazy t a b | Just r <- unliteral t = if r then a else b | True = symbolicMerge False t a b -- | Symbolic assert. Check that the given boolean condition is always true in the given path. The -- optional first argument can be used to provide call-stack info via GHC's location facilities. sAssert :: Maybe CallStack -> String -> SBool -> SBV a -> SBV a sAssert cs msg cond x = SBV $ SVal k $ Right $ cache r where k = kindOf x r st = do xsw <- sbvToSW st x let pc = getPathCondition st -- We're checking if there are any cases where the path-condition holds, but not the condition -- Any violations of this, should be signaled, i.e., whenever the following formula is satisfiable mustNeverHappen = pc &&& bnot cond cnd <- sbvToSW st mustNeverHappen addAssertion st cs msg cnd return xsw -- | Merge two symbolic values, at kind @k@, possibly @force@'ing the branches to make -- sure they do not evaluate to the same result. This should only be used for internal purposes; -- as default definitions provided should suffice in many cases. (i.e., End users should -- only need to define 'symbolicMerge' when needed; which should be rare to start with.) symbolicMergeWithKind :: Kind -> Bool -> SBool -> SBV a -> SBV a -> SBV a symbolicMergeWithKind k force (SBV t) (SBV a) (SBV b) = SBV (svSymbolicMerge k force t a b) instance SymWord a => Mergeable (SBV a) where symbolicMerge force t x y -- Carefully use the kindOf instance to avoid strictness issues. | force = symbolicMergeWithKind (kindOf x) True t x y | True = symbolicMergeWithKind (kindOf (undefined :: a)) False t x y -- Custom version of select that translates to SMT-Lib tables at the base type of words select xs err ind | SBV (SVal _ (Left c)) <- ind = case cwVal c of CWInteger i -> if i < 0 || i >= genericLength xs then err else xs `genericIndex` i _ -> error $ "SBV.select: unsupported " ++ show (kindOf ind) ++ " valued select/index expression" select xsOrig err ind = xs `seq` SBV (SVal kElt (Right (cache r))) where kInd = kindOf ind kElt = kindOf err -- Based on the index size, we need to limit the elements. For instance if the index is 8 bits, but there -- are 257 elements, that last element will never be used and we can chop it of.. xs = case kindOf ind of KBounded False i -> genericTake ((2::Integer) ^ (fromIntegral i :: Integer)) xsOrig KBounded True i -> genericTake ((2::Integer) ^ (fromIntegral (i-1) :: Integer)) xsOrig KUnbounded -> xsOrig _ -> error $ "SBV.select: unsupported " ++ show (kindOf ind) ++ " valued select/index expression" r st = do sws <- mapM (sbvToSW st) xs swe <- sbvToSW st err if all (== swe) sws -- off-chance that all elts are the same. Note that this also correctly covers the case when list is empty. then return swe else do idx <- getTableIndex st kInd kElt sws swi <- sbvToSW st ind let len = length xs -- NB. No need to worry here that the index might be < 0; as the SMTLib translation takes care of that automatically newExpr st kElt (SBVApp (LkUp (idx, kInd, kElt, len) swi swe) []) -- Unit instance Mergeable () where symbolicMerge _ _ _ _ = () select _ _ _ = () -- Mergeable instances for List/Maybe/Either/Array are useful, but can -- throw exceptions if there is no structural matching of the results -- It's a question whether we should really keep them.. -- Lists instance Mergeable a => Mergeable [a] where symbolicMerge f t xs ys | lxs == lys = zipWith (symbolicMerge f t) xs ys | True = error $ "SBV.Mergeable.List: No least-upper-bound for lists of differing size " ++ show (lxs, lys) where (lxs, lys) = (length xs, length ys) -- Maybe instance Mergeable a => Mergeable (Maybe a) where symbolicMerge _ _ Nothing Nothing = Nothing symbolicMerge f t (Just a) (Just b) = Just $ symbolicMerge f t a b symbolicMerge _ _ a b = error $ "SBV.Mergeable.Maybe: No least-upper-bound for " ++ show (k a, k b) where k Nothing = "Nothing" k _ = "Just" -- Either instance (Mergeable a, Mergeable b) => Mergeable (Either a b) where symbolicMerge f t (Left a) (Left b) = Left $ symbolicMerge f t a b symbolicMerge f t (Right a) (Right b) = Right $ symbolicMerge f t a b symbolicMerge _ _ a b = error $ "SBV.Mergeable.Either: No least-upper-bound for " ++ show (k a, k b) where k (Left _) = "Left" k (Right _) = "Right" -- Arrays instance (Ix a, Mergeable b) => Mergeable (Array a b) where symbolicMerge f t a b | ba == bb = listArray ba (zipWith (symbolicMerge f t) (elems a) (elems b)) | True = error $ "SBV.Mergeable.Array: No least-upper-bound for rangeSizes" ++ show (k ba, k bb) where [ba, bb] = map bounds [a, b] k = rangeSize -- Functions instance Mergeable b => Mergeable (a -> b) where symbolicMerge f t g h x = symbolicMerge f t (g x) (h x) {- Following definition, while correct, is utterly inefficient. Since the application is delayed, this hangs on to the inner list and all the impending merges, even when ind is concrete. Thus, it's much better to simply use the default definition for the function case. -} -- select xs err ind = \x -> select (map ($ x) xs) (err x) ind -- 2-Tuple instance (Mergeable a, Mergeable b) => Mergeable (a, b) where symbolicMerge f t (i0, i1) (j0, j1) = (i i0 j0, i i1 j1) where i a b = symbolicMerge f t a b select xs (err1, err2) ind = (select as err1 ind, select bs err2 ind) where (as, bs) = unzip xs -- 3-Tuple instance (Mergeable a, Mergeable b, Mergeable c) => Mergeable (a, b, c) where symbolicMerge f t (i0, i1, i2) (j0, j1, j2) = (i i0 j0, i i1 j1, i i2 j2) where i a b = symbolicMerge f t a b select xs (err1, err2, err3) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind) where (as, bs, cs) = unzip3 xs -- 4-Tuple instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d) => Mergeable (a, b, c, d) where symbolicMerge f t (i0, i1, i2, i3) (j0, j1, j2, j3) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3) where i a b = symbolicMerge f t a b select xs (err1, err2, err3, err4) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind) where (as, bs, cs, ds) = unzip4 xs -- 5-Tuple instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e) => Mergeable (a, b, c, d, e) where symbolicMerge f t (i0, i1, i2, i3, i4) (j0, j1, j2, j3, j4) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4) where i a b = symbolicMerge f t a b select xs (err1, err2, err3, err4, err5) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind) where (as, bs, cs, ds, es) = unzip5 xs -- 6-Tuple instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e, Mergeable f) => Mergeable (a, b, c, d, e, f) where symbolicMerge f t (i0, i1, i2, i3, i4, i5) (j0, j1, j2, j3, j4, j5) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4, i i5 j5) where i a b = symbolicMerge f t a b select xs (err1, err2, err3, err4, err5, err6) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind, select fs err6 ind) where (as, bs, cs, ds, es, fs) = unzip6 xs -- 7-Tuple instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e, Mergeable f, Mergeable g) => Mergeable (a, b, c, d, e, f, g) where symbolicMerge f t (i0, i1, i2, i3, i4, i5, i6) (j0, j1, j2, j3, j4, j5, j6) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4, i i5 j5, i i6 j6) where i a b = symbolicMerge f t a b select xs (err1, err2, err3, err4, err5, err6, err7) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind, select fs err6 ind, select gs err7 ind) where (as, bs, cs, ds, es, fs, gs) = unzip7 xs -- Arbitrary product types, using GHC.Generics -- -- NB: Because of the way GHC.Generics works, the implementation of -- symbolicMerge' is recursive. The derived instance for @data T a = T a a a a@ -- resembles that for (a, (a, (a, a))), not the flat 4-tuple (a, a, a, a). This -- difference should have no effect in practice. Note also that, unlike the -- hand-rolled tuple instances, the generic instance does not provide a custom -- 'select' implementation, and so does not benefit from the SMT-table -- implementation in the 'SBV a' instance. -- | Not exported. Symbolic merge using the generic representation provided by -- 'G.Generics'. symbolicMergeDefault :: (G.Generic a, GMergeable (G.Rep a)) => Bool -> SBool -> a -> a -> a symbolicMergeDefault force t x y = G.to $ symbolicMerge' force t (G.from x) (G.from y) -- | Not exported. Used only in 'symbolicMergeDefault'. Instances are provided for -- the generic representations of product types where each element is Mergeable. class GMergeable f where symbolicMerge' :: Bool -> SBool -> f a -> f a -> f a instance GMergeable U1 where symbolicMerge' _ _ _ _ = U1 instance (Mergeable c) => GMergeable (K1 i c) where symbolicMerge' force t (K1 x) (K1 y) = K1 $ symbolicMerge force t x y instance (GMergeable f) => GMergeable (M1 i c f) where symbolicMerge' force t (M1 x) (M1 y) = M1 $ symbolicMerge' force t x y instance (GMergeable f, GMergeable g) => GMergeable (f :*: g) where symbolicMerge' force t (x1 :*: y1) (x2 :*: y2) = symbolicMerge' force t x1 x2 :*: symbolicMerge' force t y1 y2 -- Bounded instances instance (SymWord a, Bounded a) => Bounded (SBV a) where minBound = literal minBound maxBound = literal maxBound -- Arrays -- SArrays are both "EqSymbolic" and "Mergeable" instance EqSymbolic (SArray a b) where (SArray a) .== (SArray b) = SBV (eqSArr a b) -- When merging arrays; we'll ignore the force argument. This is arguably -- the right thing to do as we've too many things and likely we want to keep it efficient. instance SymWord b => Mergeable (SArray a b) where symbolicMerge _ = mergeArrays -- SFunArrays are only "Mergeable". Although a brute -- force equality can be defined, any non-toy instance -- will suffer from efficiency issues; so we don't define it instance SymArray SFunArray where newArray _ = newArray_ -- the name is irrelevant in this case newArray_ mbiVal = declNewSFunArray mbiVal readArray (SFunArray f) = f resetArray (SFunArray _) a = SFunArray $ const a writeArray (SFunArray f) a b = SFunArray (\a' -> ite (a .== a') b (f a')) mergeArrays t (SFunArray g) (SFunArray h) = SFunArray (\x -> ite t (g x) (h x)) -- When merging arrays; we'll ignore the force argument. This is arguably -- the right thing to do as we've too many things and likely we want to keep it efficient. instance SymWord b => Mergeable (SFunArray a b) where symbolicMerge _ = mergeArrays -- | Uninterpreted constants and functions. An uninterpreted constant is -- a value that is indexed by its name. The only property the prover assumes -- about these values are that they are equivalent to themselves; i.e., (for -- functions) they return the same results when applied to same arguments. -- We support uninterpreted-functions as a general means of black-box'ing -- operations that are /irrelevant/ for the purposes of the proof; i.e., when -- the proofs can be performed without any knowledge about the function itself. -- -- Minimal complete definition: 'sbvUninterpret'. However, most instances in -- practice are already provided by SBV, so end-users should not need to define their -- own instances. class Uninterpreted a where -- | Uninterpret a value, receiving an object that can be used instead. Use this version -- when you do not need to add an axiom about this value. uninterpret :: String -> a -- | Uninterpret a value, only for the purposes of code-generation. For execution -- and verification the value is used as is. For code-generation, the alternate -- definition is used. This is useful when we want to take advantage of native -- libraries on the target languages. cgUninterpret :: String -> [String] -> a -> a -- | Most generalized form of uninterpretation, this function should not be needed -- by end-user-code, but is rather useful for the library development. sbvUninterpret :: Maybe ([String], a) -> String -> a -- minimal complete definition: 'sbvUninterpret' uninterpret = sbvUninterpret Nothing cgUninterpret nm code v = sbvUninterpret (Just (code, v)) nm -- Plain constants instance HasKind a => Uninterpreted (SBV a) where sbvUninterpret mbCgData nm | Just (_, v) <- mbCgData = v | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st v | True = do newUninterpreted st nm (SBVType [ka]) (fst `fmap` mbCgData) newExpr st ka $ SBVApp (Uninterpreted nm) [] -- Functions of one argument instance (SymWord b, HasKind a) => Uninterpreted (SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 | Just (_, v) <- mbCgData, isConcrete arg0 = v arg0 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0) | True = do newUninterpreted st nm (SBVType [kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 mapM_ forceSWArg [sw0] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0] -- Functions of two arguments instance (SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1 = v arg0 arg1 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1) | True = do newUninterpreted st nm (SBVType [kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 mapM_ forceSWArg [sw0, sw1] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1] -- Functions of three arguments instance (SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV d -> SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 arg2 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1, isConcrete arg2 = v arg0 arg1 arg2 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) kd = kindOf (undefined :: d) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2) | True = do newUninterpreted st nm (SBVType [kd, kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 sw2 <- sbvToSW st arg2 mapM_ forceSWArg [sw0, sw1, sw2] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2] -- Functions of four arguments instance (SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 arg2 arg3 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3 = v arg0 arg1 arg2 arg3 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) kd = kindOf (undefined :: d) ke = kindOf (undefined :: e) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3) | True = do newUninterpreted st nm (SBVType [ke, kd, kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 sw2 <- sbvToSW st arg2 sw3 <- sbvToSW st arg3 mapM_ forceSWArg [sw0, sw1, sw2, sw3] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3] -- Functions of five arguments instance (SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 arg2 arg3 arg4 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4 = v arg0 arg1 arg2 arg3 arg4 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) kd = kindOf (undefined :: d) ke = kindOf (undefined :: e) kf = kindOf (undefined :: f) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4) | True = do newUninterpreted st nm (SBVType [kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 sw2 <- sbvToSW st arg2 sw3 <- sbvToSW st arg3 sw4 <- sbvToSW st arg4 mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4] -- Functions of six arguments instance (SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 arg2 arg3 arg4 arg5 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5 = v arg0 arg1 arg2 arg3 arg4 arg5 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) kd = kindOf (undefined :: d) ke = kindOf (undefined :: e) kf = kindOf (undefined :: f) kg = kindOf (undefined :: g) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5) | True = do newUninterpreted st nm (SBVType [kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 sw2 <- sbvToSW st arg2 sw3 <- sbvToSW st arg3 sw4 <- sbvToSW st arg4 sw5 <- sbvToSW st arg5 mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5] -- Functions of seven arguments instance (SymWord h, SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where sbvUninterpret mbCgData nm = f where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 | Just (_, v) <- mbCgData, isConcrete arg0, isConcrete arg1, isConcrete arg2, isConcrete arg3, isConcrete arg4, isConcrete arg5, isConcrete arg6 = v arg0 arg1 arg2 arg3 arg4 arg5 arg6 | True = SBV $ SVal ka $ Right $ cache result where ka = kindOf (undefined :: a) kb = kindOf (undefined :: b) kc = kindOf (undefined :: c) kd = kindOf (undefined :: d) ke = kindOf (undefined :: e) kf = kindOf (undefined :: f) kg = kindOf (undefined :: g) kh = kindOf (undefined :: h) result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6) | True = do newUninterpreted st nm (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData) sw0 <- sbvToSW st arg0 sw1 <- sbvToSW st arg1 sw2 <- sbvToSW st arg2 sw3 <- sbvToSW st arg3 sw4 <- sbvToSW st arg4 sw5 <- sbvToSW st arg5 sw6 <- sbvToSW st arg6 mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6] newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6] -- Uncurried functions of two arguments instance (SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc2 `fmap` mbCgData) nm in uncurry f where uc2 (cs, fn) = (cs, curry fn) -- Uncurried functions of three arguments instance (SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV d, SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc3 `fmap` mbCgData) nm in \(arg0, arg1, arg2) -> f arg0 arg1 arg2 where uc3 (cs, fn) = (cs, \a b c -> fn (a, b, c)) -- Uncurried functions of four arguments instance (SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV e, SBV d, SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc4 `fmap` mbCgData) nm in \(arg0, arg1, arg2, arg3) -> f arg0 arg1 arg2 arg3 where uc4 (cs, fn) = (cs, \a b c d -> fn (a, b, c, d)) -- Uncurried functions of five arguments instance (SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc5 `fmap` mbCgData) nm in \(arg0, arg1, arg2, arg3, arg4) -> f arg0 arg1 arg2 arg3 arg4 where uc5 (cs, fn) = (cs, \a b c d e -> fn (a, b, c, d, e)) -- Uncurried functions of six arguments instance (SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc6 `fmap` mbCgData) nm in \(arg0, arg1, arg2, arg3, arg4, arg5) -> f arg0 arg1 arg2 arg3 arg4 arg5 where uc6 (cs, fn) = (cs, \a b c d e f -> fn (a, b, c, d, e, f)) -- Uncurried functions of seven arguments instance (SymWord h, SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc7 `fmap` mbCgData) nm in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6 where uc7 (cs, fn) = (cs, \a b c d e f g -> fn (a, b, c, d, e, f, g)) -- | Adding arbitrary constraints. When adding constraints, one has to be careful about -- making sure they are not inconsistent. The function 'isVacuous' can be use for this purpose. -- Here is an example. Consider the following predicate: -- -- >>> let pred = do { x <- forall "x"; constrain $ x .< x; return $ x .>= (5 :: SWord8) } -- -- This predicate asserts that all 8-bit values are larger than 5, subject to the constraint that the -- values considered satisfy @x .< x@, i.e., they are less than themselves. Since there are no values that -- satisfy this constraint, the proof will pass vacuously: -- -- >>> prove pred -- Q.E.D. -- -- We can use 'isVacuous' to make sure to see that the pass was vacuous: -- -- >>> isVacuous pred -- True -- -- While the above example is trivial, things can get complicated if there are multiple constraints with -- non-straightforward relations; so if constraints are used one should make sure to check the predicate -- is not vacuously true. Here's an example that is not vacuous: -- -- >>> let pred' = do { x <- forall "x"; constrain $ x .> 6; return $ x .>= (5 :: SWord8) } -- -- This time the proof passes as expected: -- -- >>> prove pred' -- Q.E.D. -- -- And the proof is not vacuous: -- -- >>> isVacuous pred' -- False constrain :: SBool -> Symbolic () constrain c = addConstraint Nothing c (bnot c) -- | Adding a probabilistic constraint. The 'Double' argument is the probability -- threshold. Probabilistic constraints are useful for 'genTest' and 'quickCheck' -- calls where we restrict our attention to /interesting/ parts of the input domain. pConstrain :: Double -> SBool -> Symbolic () pConstrain t c = addConstraint (Just t) c (bnot c) -- Quickcheck interface on symbolic-booleans.. instance Testable SBool where property (SBV (SVal _ (Left b))) = property (cwToBool b) property s = error $ "Cannot quick-check in the presence of uninterpreted constants! (" ++ show s ++ ")" instance Testable (Symbolic SBool) where property prop = QC.monadicIO $ do (cond, r, tvals) <- QC.run (newStdGen >>= test) QC.pre cond unless (r || null tvals) $ QC.monitor (QC.counterexample (complain tvals)) QC.assert r where test g = do (r, Result{resTraces=tvals, resConsts=cs, resConstraints=cstrs, resUIConsts=unints}) <- runSymbolic' (Concrete g) prop let cval = fromMaybe (error "Cannot quick-check in the presence of uninterpeted constants!") . (`lookup` cs) cond = all (cwToBool . cval) cstrs case map fst unints of [] -> case unliteral r of Nothing -> noQC [show r] Just b -> return (cond, b, tvals) us -> noQC us complain qcInfo = showModel defaultSMTCfg (SMTModel qcInfo) noQC us = error $ "Cannot quick-check in the presence of uninterpreted constants: " ++ intercalate ", " us -- | Quick check an SBV property. Note that a regular 'quickCheck' call will work just as -- well. Use this variant if you want to receive the boolean result. sbvQuickCheck :: Symbolic SBool -> IO Bool sbvQuickCheck prop = QC.isSuccess `fmap` QC.quickCheckResult prop -- Quickcheck interface on dynamically-typed values. A run-time check -- ensures that the value has boolean type. instance Testable (Symbolic SVal) where property m = property $ do s <- m when (kindOf s /= KBool) $ error "Cannot quickcheck non-boolean value" return (SBV s :: SBool) -- | Explicit sharing combinator. The SBV library has internal caching/hash-consing mechanisms -- built in, based on Andy Gill's type-safe obervable sharing technique (see: ). -- However, there might be times where being explicit on the sharing can help, especially in experimental code. The 'slet' combinator -- ensures that its first argument is computed once and passed on to its continuation, explicitly indicating the intent of sharing. Most -- use cases of the SBV library should simply use Haskell's @let@ construct for this purpose. slet :: forall a b. (HasKind a, HasKind b) => SBV a -> (SBV a -> SBV b) -> SBV b slet x f = SBV $ SVal k $ Right $ cache r where k = kindOf (undefined :: b) r st = do xsw <- sbvToSW st x let xsbv = SBV $ SVal (kindOf x) (Right (cache (const (return xsw)))) res = f xsbv sbvToSW st res -- | Check if a boolean condition is satisfiable in the current state. This function can be useful in contexts where an -- interpreter implemented on top of SBV needs to decide if a particular stae (represented by the boolean) is reachable -- in the current if-then-else paths implied by the 'ite' calls. isSatisfiableInCurrentPath :: SBool -> Symbolic Bool isSatisfiableInCurrentPath cond = do st <- ask let cfg = fromMaybe defaultSMTCfg (getSBranchRunConfig st) msg = when (verbose cfg) . putStrLn . ("** " ++) pc = getPathCondition st check <- liftIO $ internalSATCheck cfg (pc &&& cond) st "isSatisfiableInCurrentPath: Checking satisfiability" let res = case check of SatResult Satisfiable{} -> True SatResult (Unsatisfiable _) -> False _ -> error $ "isSatisfiableInCurrentPath: Unexpected external result: " ++ show check res `seq` liftIO $ msg $ "isSatisfiableInCurrentPath: Conclusion: " ++ if res then "Satisfiable" else "Unsatisfiable" return res -- We use 'isVacuous' and 'prove' only for the "test" section in this file, and GHC complains about that. So, this shuts it up. __unused :: a __unused = error "__unused" (isVacuous :: SBool -> IO Bool) (prove :: SBool -> IO ThmResult) {-# ANN module ("HLint: ignore Reduce duplication" :: String)#-} {-# ANN module ("HLint: ignore Eta reduce" :: String) #-} sbv-5.12/Data/SBV/BitVectors/Operations.hs0000644000000000000000000011104312725411266016475 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Operations -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Constructors and basic operations on symbolic values ----------------------------------------------------------------------------- {-# LANGUAGE BangPatterns #-} module Data.SBV.BitVectors.Operations ( -- ** Basic constructors svTrue, svFalse, svBool , svInteger, svFloat, svDouble, svReal, svEnumFromThenTo -- ** Basic destructors , svAsBool, svAsInteger, svNumerator, svDenominator -- ** Basic operations , svPlus, svTimes, svMinus, svUNeg, svAbs , svDivide, svQuot, svRem , svEqual, svNotEqual , svLessThan, svGreaterThan, svLessEq, svGreaterEq , svAnd, svOr, svXOr, svNot , svShl, svShr, svRol, svRor , svExtract, svJoin , svUninterpreted , svIte, svLazyIte, svSymbolicMerge , svSelect , svSign, svUnsign, svSetBit, svWordFromBE, svWordFromLE , svExp -- ** Derived operations , svToWord1, svFromWord1, svTestBit , svShiftLeft, svShiftRight , svRotateLeft, svRotateRight , svBlastLE, svBlastBE , svAddConstant, svIncrement, svDecrement ) where import Data.Bits (Bits(..)) import Data.List (genericIndex, genericLength, genericTake) import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Kind import Data.SBV.BitVectors.Concrete import Data.SBV.BitVectors.Symbolic import Data.Ratio -------------------------------------------------------------------------------- -- Basic constructors -- | Boolean True. svTrue :: SVal svTrue = SVal KBool (Left trueCW) -- | Boolean False. svFalse :: SVal svFalse = SVal KBool (Left falseCW) -- | Convert from a Boolean. svBool :: Bool -> SVal svBool b = if b then svTrue else svFalse -- | Convert from an Integer. svInteger :: Kind -> Integer -> SVal svInteger k n = SVal k (Left (mkConstCW k n)) -- | Convert from a Float svFloat :: Float -> SVal svFloat f = SVal KFloat (Left (CW KFloat (CWFloat f))) -- | Convert from a Float svDouble :: Double -> SVal svDouble d = SVal KDouble (Left (CW KDouble (CWDouble d))) -- | Convert from a Rational svReal :: Rational -> SVal svReal d = SVal KReal (Left (CW KReal (CWAlgReal (fromRational d)))) -------------------------------------------------------------------------------- -- Basic destructors -- | Extract a bool, by properly interpreting the integer stored. svAsBool :: SVal -> Maybe Bool svAsBool (SVal _ (Left cw)) = Just (cwToBool cw) svAsBool _ = Nothing -- | Extract an integer from a concrete value. svAsInteger :: SVal -> Maybe Integer svAsInteger (SVal _ (Left (CW _ (CWInteger n)))) = Just n svAsInteger _ = Nothing -- | Grab the numerator of an SReal, if available svNumerator :: SVal -> Maybe Integer svNumerator (SVal KReal (Left (CW KReal (CWAlgReal (AlgRational True r))))) = Just $ numerator r svNumerator _ = Nothing -- | Grab the denominator of an SReal, if available svDenominator :: SVal -> Maybe Integer svDenominator (SVal KReal (Left (CW KReal (CWAlgReal (AlgRational True r))))) = Just $ denominator r svDenominator _ = Nothing ------------------------------------------------------------------------------------- -- | Constructing [x, y, .. z] and [x .. y]. Only works when all arguments are concrete and integral and the result is guaranteed finite -- Note that the it isn't "obviously" clear why the following works; after all we're doing the construction over Integer's and mapping -- it back to other types such as SIntN/SWordN. The reason is that the values we receive are guaranteed to be in their domains; and thus -- the lifting to Integers preserves the bounds; and then going back is just fine. So, things like @[1, 5 .. 200] :: [SInt8]@ work just -- fine (end evaluate to empty list), since we see @[1, 5 .. -56]@ in the @Integer@ domain. Also note the explicit check for @s /= f@ -- below to make sure we don't stutter and produce an infinite list. svEnumFromThenTo :: SVal -> Maybe SVal -> SVal -> Maybe [SVal] svEnumFromThenTo bf mbs bt | Just bs <- mbs, Just f <- svAsInteger bf, Just s <- svAsInteger bs, Just t <- svAsInteger bt, s /= f = Just $ map (svInteger (kindOf bf)) [f, s .. t] | Nothing <- mbs, Just f <- svAsInteger bf, Just t <- svAsInteger bt = Just $ map (svInteger (kindOf bf)) [f .. t] | True = Nothing ------------------------------------------------------------------------------------- -- Basic operations -- | Addition. svPlus :: SVal -> SVal -> SVal svPlus x y | isConcreteZero x = y | isConcreteZero y = x | True = liftSym2 (mkSymOp Plus) rationalCheck (+) (+) (+) (+) x y -- | Multiplication. svTimes :: SVal -> SVal -> SVal svTimes x y | isConcreteZero x = x | isConcreteZero y = y | isConcreteOne x = y | isConcreteOne y = x | True = liftSym2 (mkSymOp Times) rationalCheck (*) (*) (*) (*) x y -- | Subtraction. svMinus :: SVal -> SVal -> SVal svMinus x y | isConcreteZero y = x | True = liftSym2 (mkSymOp Minus) rationalCheck (-) (-) (-) (-) x y -- | Unary minus. svUNeg :: SVal -> SVal svUNeg = liftSym1 (mkSymOp1 UNeg) negate negate negate negate -- | Absolute value. svAbs :: SVal -> SVal svAbs = liftSym1 (mkSymOp1 Abs) abs abs abs abs -- | Division. svDivide :: SVal -> SVal -> SVal svDivide = liftSym2 (mkSymOp Quot) rationalCheck (/) die (/) (/) where -- should never happen die = error "impossible: integer valued data found in Fractional instance" -- | Exponentiation. svExp :: SVal -> SVal -> SVal svExp b e | hasSign (kindOf e) = error "svExp: exponentiation only works with unsigned exponents" | True = prod $ zipWith (\use n -> svIte use n one) (svBlastLE e) (iterate (\x -> svTimes x x) b) where prod = foldr svTimes one one = svInteger (kindOf b) 1 -- | Bit-blast: Little-endian. Assumes the input is a bit-vector. svBlastLE :: SVal -> [SVal] svBlastLE x = map (svTestBit x) [0 .. intSizeOf x - 1] -- | Set a given bit at index svSetBit :: SVal -> Int -> SVal svSetBit x i = x `svXOr` svInteger (kindOf x) (bit i :: Integer) -- | Bit-blast: Big-endian. Assumes the input is a bit-vector. svBlastBE :: SVal -> [SVal] svBlastBE = reverse . svBlastLE -- | Un-bit-blast from big-endian representation to a word of the right size. -- The input is assumed to be unsigned. svWordFromLE :: [SVal] -> SVal svWordFromLE bs = go zero 0 bs where zero = svInteger (KBounded False (length bs)) 0 go !acc _ [] = acc go !acc !i (x:xs) = go (svIte x (svSetBit acc i) acc) (i+1) xs -- | Un-bit-blast from little-endian representation to a word of the right size. -- The input is assumed to be unsigned. svWordFromBE :: [SVal] -> SVal svWordFromBE = svWordFromLE . reverse -- | Add a constant value: svAddConstant :: Integral a => SVal -> a -> SVal svAddConstant x i = x `svPlus` svInteger (kindOf x) (fromIntegral i) -- | Increment: svIncrement :: SVal -> SVal svIncrement x = svAddConstant x (1::Integer) -- | Decrement: svDecrement :: SVal -> SVal svDecrement x = svAddConstant x (-1 :: Integer) -- | Quotient: Overloaded operation whose meaning depends on the kind at which -- it is used: For unbounded integers, it corresponds to the SMT-Lib -- "div" operator ("Euclidean" division, which always has a -- non-negative remainder). For unsigned bitvectors, it is "bvudiv"; -- and for signed bitvectors it is "bvsdiv", which rounds toward zero. -- All operations have unspecified semantics in case @y = 0@. svQuot :: SVal -> SVal -> SVal svQuot x y | isConcreteZero x = x | isConcreteOne y = x | True = liftSym2 (mkSymOp Quot) nonzeroCheck (noReal "quot") quot' (noFloat "quot") (noDouble "quot") x y where quot' a b | kindOf x == KUnbounded = div a (abs b) * signum b | otherwise = quot a b -- | Remainder: Overloaded operation whose meaning depends on the kind at which -- it is used: For unbounded integers, it corresponds to the SMT-Lib -- "mod" operator (always non-negative). For unsigned bitvectors, it -- is "bvurem"; and for signed bitvectors it is "bvsrem", which rounds -- toward zero (sign of remainder matches that of @x@). All operations -- have unspecified semantics in case @y = 0@. svRem :: SVal -> SVal -> SVal svRem x y | isConcreteZero x = x | isConcreteOne y = svInteger (kindOf x) 0 | True = liftSym2 (mkSymOp Rem) nonzeroCheck (noReal "rem") rem' (noFloat "rem") (noDouble "rem") x y where rem' a b | kindOf x == KUnbounded = mod a (abs b) | otherwise = rem a b -- | Optimize away x == true and x /= false to x; otherwise just do eqOpt eqOptBool :: Op -> SW -> SW -> SW -> Maybe SW eqOptBool op w x y | k == KBool && op == Equal && x == trueSW = Just y -- true .== y --> y | k == KBool && op == Equal && y == trueSW = Just x -- x .== true --> x | k == KBool && op == NotEqual && x == falseSW = Just y -- false ./= y --> y | k == KBool && op == NotEqual && y == falseSW = Just x -- x ./= false --> x | True = eqOpt w x y -- fallback where k = swKind x -- | Equality. svEqual :: SVal -> SVal -> SVal svEqual = liftSym2B (mkSymOpSC (eqOptBool Equal trueSW) Equal) rationalCheck (==) (==) (==) (==) (==) -- | Inequality. svNotEqual :: SVal -> SVal -> SVal svNotEqual = liftSym2B (mkSymOpSC (eqOptBool NotEqual falseSW) NotEqual) rationalCheck (/=) (/=) (/=) (/=) (/=) -- | Less than. svLessThan :: SVal -> SVal -> SVal svLessThan x y | isConcreteMax x = svFalse | isConcreteMin y = svFalse | True = liftSym2B (mkSymOpSC (eqOpt falseSW) LessThan) rationalCheck (<) (<) (<) (<) (uiLift "<" (<)) x y -- | Greater than. svGreaterThan :: SVal -> SVal -> SVal svGreaterThan x y | isConcreteMin x = svFalse | isConcreteMax y = svFalse | True = liftSym2B (mkSymOpSC (eqOpt falseSW) GreaterThan) rationalCheck (>) (>) (>) (>) (uiLift ">" (>)) x y -- | Less than or equal to. svLessEq :: SVal -> SVal -> SVal svLessEq x y | isConcreteMin x = svTrue | isConcreteMax y = svTrue | True = liftSym2B (mkSymOpSC (eqOpt trueSW) LessEq) rationalCheck (<=) (<=) (<=) (<=) (uiLift "<=" (<=)) x y -- | Greater than or equal to. svGreaterEq :: SVal -> SVal -> SVal svGreaterEq x y | isConcreteMax x = svTrue | isConcreteMin y = svTrue | True = liftSym2B (mkSymOpSC (eqOpt trueSW) GreaterEq) rationalCheck (>=) (>=) (>=) (>=) (uiLift ">=" (>=)) x y -- | Bitwise and. svAnd :: SVal -> SVal -> SVal svAnd x y | isConcreteZero x = x | isConcreteOnes x = y | isConcreteZero y = y | isConcreteOnes y = x | True = liftSym2 (mkSymOpSC opt And) (const (const True)) (noReal ".&.") (.&.) (noFloat ".&.") (noDouble ".&.") x y where opt a b | a == falseSW || b == falseSW = Just falseSW | a == trueSW = Just b | b == trueSW = Just a | True = Nothing -- | Bitwise or. svOr :: SVal -> SVal -> SVal svOr x y | isConcreteZero x = y | isConcreteOnes x = x | isConcreteZero y = x | isConcreteOnes y = y | True = liftSym2 (mkSymOpSC opt Or) (const (const True)) (noReal ".|.") (.|.) (noFloat ".|.") (noDouble ".|.") x y where opt a b | a == trueSW || b == trueSW = Just trueSW | a == falseSW = Just b | b == falseSW = Just a | True = Nothing -- | Bitwise xor. svXOr :: SVal -> SVal -> SVal svXOr x y | isConcreteZero x = y | isConcreteOnes x = svNot y | isConcreteZero y = x | isConcreteOnes y = svNot x | True = liftSym2 (mkSymOpSC opt XOr) (const (const True)) (noReal "xor") xor (noFloat "xor") (noDouble "xor") x y where opt a b | a == b && swKind a == KBool = Just falseSW | a == falseSW = Just b | b == falseSW = Just a | True = Nothing -- | Bitwise complement. svNot :: SVal -> SVal svNot = liftSym1 (mkSymOp1SC opt Not) (noRealUnary "complement") complement (noFloatUnary "complement") (noDoubleUnary "complement") where opt a | a == falseSW = Just trueSW | a == trueSW = Just falseSW | True = Nothing -- | Shift left by a constant amount. Translates to the "bvshl" -- operation in SMT-Lib. svShl :: SVal -> Int -> SVal svShl x i | i < 0 = svShr x (-i) | i == 0 = x | True = liftSym1 (mkSymOp1 (Shl i)) (noRealUnary "shiftL") (`shiftL` i) (noFloatUnary "shiftL") (noDoubleUnary "shiftL") x -- | Shift right by a constant amount. Translates to either "bvlshr" -- (logical shift right) or "bvashr" (arithmetic shift right) in -- SMT-Lib, depending on whether @x@ is a signed bitvector. svShr :: SVal -> Int -> SVal svShr x i | i < 0 = svShl x (-i) | i == 0 = x | True = liftSym1 (mkSymOp1 (Shr i)) (noRealUnary "shiftR") (`shiftR` i) (noFloatUnary "shiftR") (noDoubleUnary "shiftR") x -- | Rotate-left, by a constant svRol :: SVal -> Int -> SVal svRol x i | i < 0 = svRor x (-i) | i == 0 = x | True = case kindOf x of KBounded _ sz -> liftSym1 (mkSymOp1 (Rol (i `mod` sz))) (noRealUnary "rotateL") (rot True sz i) (noFloatUnary "rotateL") (noDoubleUnary "rotateL") x _ -> svShl x i -- for unbounded Integers, rotateL is the same as shiftL in Haskell -- | Rotate-right, by a constant svRor :: SVal -> Int -> SVal svRor x i | i < 0 = svRol x (-i) | i == 0 = x | True = case kindOf x of KBounded _ sz -> liftSym1 (mkSymOp1 (Ror (i `mod` sz))) (noRealUnary "rotateR") (rot False sz i) (noFloatUnary "rotateR") (noDoubleUnary "rotateR") x _ -> svShr x i -- for unbounded integers, rotateR is the same as shiftR in Haskell -- | Generic rotation. Since the underlying representation is just Integers, rotations has to be -- careful on the bit-size. rot :: Bool -> Int -> Int -> Integer -> Integer rot toLeft sz amt x | sz < 2 = x | True = norm x y' `shiftL` y .|. norm (x `shiftR` y') y where (y, y') | toLeft = (amt `mod` sz, sz - y) | True = (sz - y', amt `mod` sz) norm v s = v .&. ((1 `shiftL` s) - 1) -- | Extract bit-sequences. svExtract :: Int -> Int -> SVal -> SVal svExtract i j x@(SVal (KBounded s _) _) | i < j = SVal k (Left (CW k (CWInteger 0))) | SVal _ (Left (CW _ (CWInteger v))) <- x = SVal k (Left (normCW (CW k (CWInteger (v `shiftR` j))))) | True = SVal k (Right (cache y)) where k = KBounded s (i - j + 1) y st = do sw <- svToSW st x newExpr st k (SBVApp (Extract i j) [sw]) svExtract _ _ _ = error "extract: non-bitvector type" -- | Join two words, by concataneting svJoin :: SVal -> SVal -> SVal svJoin x@(SVal (KBounded s i) a) y@(SVal (KBounded _ j) b) | i == 0 = y | j == 0 = x | Left (CW _ (CWInteger m)) <- a, Left (CW _ (CWInteger n)) <- b = SVal k (Left (CW k (CWInteger (m `shiftL` j .|. n)))) | True = SVal k (Right (cache z)) where k = KBounded s (i + j) z st = do xsw <- svToSW st x ysw <- svToSW st y newExpr st k (SBVApp Join [xsw, ysw]) svJoin _ _ = error "svJoin: non-bitvector type" -- | Uninterpreted constants and functions. An uninterpreted constant is -- a value that is indexed by its name. The only property the prover assumes -- about these values are that they are equivalent to themselves; i.e., (for -- functions) they return the same results when applied to same arguments. -- We support uninterpreted-functions as a general means of black-box'ing -- operations that are /irrelevant/ for the purposes of the proof; i.e., when -- the proofs can be performed without any knowledge about the function itself. svUninterpreted :: Kind -> String -> Maybe [String] -> [SVal] -> SVal svUninterpreted k nm code args = SVal k $ Right $ cache result where result st = do let ty = SBVType (map kindOf args ++ [k]) newUninterpreted st nm ty code sws <- mapM (svToSW st) args mapM_ forceSWArg sws newExpr st k $ SBVApp (Uninterpreted nm) sws -- | If-then-else. This one will force branches. svIte :: SVal -> SVal -> SVal -> SVal svIte t a b = svSymbolicMerge (kindOf a) True t a b -- | Lazy If-then-else. This one will delay forcing the branches unless it's really necessary. svLazyIte :: Kind -> SVal -> SVal -> SVal -> SVal svLazyIte k t a b = svSymbolicMerge k False t a b -- | Merge two symbolic values, at kind @k@, possibly @force@'ing the branches to make -- sure they do not evaluate to the same result. svSymbolicMerge :: Kind -> Bool -> SVal -> SVal -> SVal -> SVal svSymbolicMerge k force t a b | Just r <- svAsBool t = if r then a else b | force, rationalSBVCheck a b, areConcretelyEqual a b = a | True = SVal k $ Right $ cache c where c st = do swt <- svToSW st t case () of () | swt == trueSW -> svToSW st a -- these two cases should never be needed as we expect symbolicMerge to be () | swt == falseSW -> svToSW st b -- called with symbolic tests, but just in case.. () -> do {- It is tempting to record the choice of the test expression here as we branch down to the 'then' and 'else' branches. That is, when we evaluate 'a', we can make use of the fact that the test expression is True, and similarly we can use the fact that it is False when b is evaluated. In certain cases this can cut down on symbolic simulation significantly, for instance if repetitive decisions are made in a recursive loop. Unfortunately, the implementation of this idea is quite tricky, due to our sharing based implementation. As the 'then' branch is evaluated, we will create many expressions that are likely going to be "reused" when the 'else' branch is executed. But, it would be *dead wrong* to share those values, as they were "cached" under the incorrect assumptions. To wit, consider the following: foo x y = ite (y .== 0) k (k+1) where k = ite (y .== 0) x (x+1) When we reduce the 'then' branch of the first ite, we'd record the assumption that y is 0. But while reducing the 'then' branch, we'd like to share 'k', which would evaluate (correctly) to 'x' under the given assumption. When we backtrack and evaluate the 'else' branch of the first ite, we'd see 'k' is needed again, and we'd look it up from our sharing map to find (incorrectly) that its value is 'x', which was stored there under the assumption that y was 0, which no longer holds. Clearly, this is unsound. A sound implementation would have to precisely track which assumptions were active at the time expressions get shared. That is, in the above example, we should record that the value of 'k' was cached under the assumption that 'y' is 0. While sound, this approach unfortunately leads to significant loss of valid sharing when the value itself had nothing to do with the assumption itself. To wit, consider: foo x y = ite (y .== 0) k (k+1) where k = x+5 If we tracked the assumptions, we would recompute 'k' twice, since the branch assumptions would differ. Clearly, there is no need to re-compute 'k' in this case since its value is independent of y. Note that the whole SBV performance story is based on agressive sharing, and losing that would have other significant ramifications. The "proper" solution would be to track, with each shared computation, precisely which assumptions it actually *depends* on, rather than blindly recording all the assumptions present at that time. SBV's symbolic simulation engine clearly has all the info needed to do this properly, but the implementation is not straightforward at all. For each subexpression, we would need to chase down its dependencies transitively, which can require a lot of scanning of the generated program causing major slow-down; thus potentially defeating the whole purpose of sharing in the first place. Design choice: Keep it simple, and simply do not track the assumption at all. This will maximize sharing, at the cost of evaluating unreachable branches. I think the simplicity is more important at this point than efficiency. Also note that the user can avoid most such issues by properly combining if-then-else's with common conditions together. That is, the first program above should be written like this: foo x y = ite (y .== 0) x (x+2) In general, the following transformations should be done whenever possible: ite e1 (ite e1 e2 e3) e4 --> ite e1 e2 e4 ite e1 e2 (ite e1 e3 e4) --> ite e1 e2 e4 This is in accordance with the general rule-of-thumb stating conditionals should be avoided as much as possible. However, we might prefer the following: ite e1 (f e2 e4) (f e3 e5) --> f (ite e1 e2 e3) (ite e1 e4 e5) especially if this expression happens to be inside 'f's body itself (i.e., when f is recursive), since it reduces the number of recursive calls. Clearly, programming with symbolic simulation in mind is another kind of beast alltogether. -} let sta = st `extendSValPathCondition` svAnd t let stb = st `extendSValPathCondition` svAnd (svNot t) swa <- svToSW sta a -- evaluate 'then' branch swb <- svToSW stb b -- evaluate 'else' branch case () of -- merge: () | swa == swb -> return swa () | swa == trueSW && swb == falseSW -> return swt () | swa == falseSW && swb == trueSW -> newExpr st k (SBVApp Not [swt]) () -> newExpr st k (SBVApp Ite [swt, swa, swb]) -- | Total indexing operation. @svSelect xs default index@ is -- intuitively the same as @xs !! index@, except it evaluates to -- @default@ if @index@ overflows. Translates to SMT-Lib tables. svSelect :: [SVal] -> SVal -> SVal -> SVal svSelect xs err ind | SVal _ (Left c) <- ind = case cwVal c of CWInteger i -> if i < 0 || i >= genericLength xs then err else xs `genericIndex` i _ -> error $ "SBV.select: unsupported " ++ show (kindOf ind) ++ " valued select/index expression" svSelect xsOrig err ind = xs `seq` SVal kElt (Right (cache r)) where kInd = kindOf ind kElt = kindOf err -- Based on the index size, we need to limit the elements. For -- instance if the index is 8 bits, but there are 257 elements, -- that last element will never be used and we can chop it off. xs = case kInd of KBounded False i -> genericTake ((2::Integer) ^ i) xsOrig KBounded True i -> genericTake ((2::Integer) ^ (i-1)) xsOrig KUnbounded -> xsOrig _ -> error $ "SBV.select: unsupported " ++ show kInd ++ " valued select/index expression" r st = do sws <- mapM (svToSW st) xs swe <- svToSW st err if all (== swe) sws -- off-chance that all elts are the same then return swe else do idx <- getTableIndex st kInd kElt sws swi <- svToSW st ind let len = length xs -- NB. No need to worry here that the index -- might be < 0; as the SMTLib translation -- takes care of that automatically newExpr st kElt (SBVApp (LkUp (idx, kInd, kElt, len) swi swe) []) svChangeSign :: Bool -> SVal -> SVal svChangeSign s x | Just n <- svAsInteger x = svInteger k n | True = SVal k (Right (cache y)) where k = KBounded s (intSizeOf x) y st = do xsw <- svToSW st x newExpr st k (SBVApp (Extract (intSizeOf x - 1) 0) [xsw]) -- | Convert a symbolic bitvector from unsigned to signed. svSign :: SVal -> SVal svSign = svChangeSign True -- | Convert a symbolic bitvector from signed to unsigned. svUnsign :: SVal -> SVal svUnsign = svChangeSign False -------------------------------------------------------------------------------- -- Derived operations -- | Convert an SVal from kind Bool to an unsigned bitvector of size 1. svToWord1 :: SVal -> SVal svToWord1 b = svSymbolicMerge k True b (svInteger k 1) (svInteger k 0) where k = KBounded False 1 -- | Convert an SVal from a bitvector of size 1 (signed or unsigned) to kind Bool. svFromWord1 :: SVal -> SVal svFromWord1 x = svNotEqual x (svInteger k 0) where k = kindOf x -- | Test the value of a bit. Note that we do an extract here -- as opposed to masking and checking against zero, as we found -- extraction to be much faster with large bit-vectors. svTestBit :: SVal -> Int -> SVal svTestBit x i | i < intSizeOf x = svFromWord1 (svExtract i i x) | True = svFalse -- | Generalization of 'svShl', where the shift-amount is symbolic. -- The first argument should be a bounded quantity. svShiftLeft :: SVal -> SVal -> SVal svShiftLeft x i | not (isBounded x) = error "SBV.svShiftLeft: Shifted amount should be a bounded quantity!" | True = svIte (svLessThan i zi) (svSelect [svShr x k | k <- [0 .. intSizeOf x - 1]] z (svUNeg i)) (svSelect [svShl x k | k <- [0 .. intSizeOf x - 1]] z i) where z = svInteger (kindOf x) 0 zi = svInteger (kindOf i) 0 -- | Generalization of 'svShr', where the shift-amount is symbolic. -- The first argument should be a bounded quantity. -- -- NB. If the shiftee is signed, then this is an arithmetic shift; -- otherwise it's logical. svShiftRight :: SVal -> SVal -> SVal svShiftRight x i | not (isBounded x) = error "SBV.svShiftLeft: Shifted amount should be a bounded quantity!" | True = svIte (svLessThan i zi) (svSelect [svShl x k | k <- [0 .. intSizeOf x - 1]] z (svUNeg i)) (svSelect [svShr x k | k <- [0 .. intSizeOf x - 1]] z i) where z = svInteger (kindOf x) 0 zi = svInteger (kindOf i) 0 -- | Generalization of 'svRol', where the rotation amount is symbolic. -- The first argument should be a bounded quantity. svRotateLeft :: SVal -> SVal -> SVal svRotateLeft x i | not (isBounded x) = svShiftLeft x i | isBounded i && bit si <= toInteger sx -- wrap-around not possible = svIte (svLessThan i zi) (svSelect [x `svRor` k | k <- [0 .. bit si - 1]] z (svUNeg i)) (svSelect [x `svRol` k | k <- [0 .. bit si - 1]] z i) | True = svIte (svLessThan i zi) (svSelect [x `svRor` k | k <- [0 .. sx - 1]] z (svUNeg i `svRem` n)) (svSelect [x `svRol` k | k <- [0 .. sx - 1]] z ( i `svRem` n)) where sx = intSizeOf x si = intSizeOf i z = svInteger (kindOf x) 0 zi = svInteger (kindOf i) 0 n = svInteger (kindOf i) (toInteger sx) -- | Generalization of 'svRor', where the rotation amount is symbolic. -- The first argument should be a bounded quantity. svRotateRight :: SVal -> SVal -> SVal svRotateRight x i | not (isBounded x) = svShiftRight x i | isBounded i && bit si <= toInteger sx -- wrap-around not possible = svIte (svLessThan i zi) (svSelect [x `svRol` k | k <- [0 .. bit si - 1]] z (svUNeg i)) (svSelect [x `svRor` k | k <- [0 .. bit si - 1]] z i) | True = svIte (svLessThan i zi) (svSelect [x `svRol` k | k <- [0 .. sx - 1]] z (svUNeg i `svRem` n)) (svSelect [x `svRor` k | k <- [0 .. sx - 1]] z ( i `svRem` n)) where sx = intSizeOf x si = intSizeOf i z = svInteger (kindOf x) 0 zi = svInteger (kindOf i) 0 n = svInteger (kindOf i) (toInteger sx) -------------------------------------------------------------------------------- -- Utility functions noUnint :: (Maybe Int, String) -> a noUnint x = error $ "Unexpected operation called on uninterpreted/enumerated value: " ++ show x noUnint2 :: (Maybe Int, String) -> (Maybe Int, String) -> a noUnint2 x y = error $ "Unexpected binary operation called on uninterpreted/enumerated values: " ++ show (x, y) liftSym1 :: (State -> Kind -> SW -> IO SW) -> (AlgReal -> AlgReal) -> (Integer -> Integer) -> (Float -> Float) -> (Double -> Double) -> SVal -> SVal liftSym1 _ opCR opCI opCF opCD (SVal k (Left a)) = SVal k $ Left $ mapCW opCR opCI opCF opCD noUnint a liftSym1 opS _ _ _ _ a@(SVal k _) = SVal k $ Right $ cache c where c st = do swa <- svToSW st a opS st k swa liftSW2 :: (State -> Kind -> SW -> SW -> IO SW) -> Kind -> SVal -> SVal -> Cached SW liftSW2 opS k a b = cache c where c st = do sw1 <- svToSW st a sw2 <- svToSW st b opS st k sw1 sw2 liftSym2 :: (State -> Kind -> SW -> SW -> IO SW) -> (CW -> CW -> Bool) -> (AlgReal -> AlgReal -> AlgReal) -> (Integer -> Integer -> Integer) -> (Float -> Float -> Float) -> (Double -> Double -> Double) -> SVal -> SVal -> SVal liftSym2 _ okCW opCR opCI opCF opCD (SVal k (Left a)) (SVal _ (Left b)) | okCW a b = SVal k $ Left $ mapCW2 opCR opCI opCF opCD noUnint2 a b liftSym2 opS _ _ _ _ _ a@(SVal k _) b = SVal k $ Right $ liftSW2 opS k a b liftSym2B :: (State -> Kind -> SW -> SW -> IO SW) -> (CW -> CW -> Bool) -> (AlgReal -> AlgReal -> Bool) -> (Integer -> Integer -> Bool) -> (Float -> Float -> Bool) -> (Double -> Double -> Bool) -> ((Maybe Int, String) -> (Maybe Int, String) -> Bool) -> SVal -> SVal -> SVal liftSym2B _ okCW opCR opCI opCF opCD opUI (SVal _ (Left a)) (SVal _ (Left b)) | okCW a b = svBool (liftCW2 opCR opCI opCF opCD opUI a b) liftSym2B opS _ _ _ _ _ _ a b = SVal KBool $ Right $ liftSW2 opS KBool a b mkSymOpSC :: (SW -> SW -> Maybe SW) -> Op -> State -> Kind -> SW -> SW -> IO SW mkSymOpSC shortCut op st k a b = maybe (newExpr st k (SBVApp op [a, b])) return (shortCut a b) mkSymOp :: Op -> State -> Kind -> SW -> SW -> IO SW mkSymOp = mkSymOpSC (const (const Nothing)) mkSymOp1SC :: (SW -> Maybe SW) -> Op -> State -> Kind -> SW -> IO SW mkSymOp1SC shortCut op st k a = maybe (newExpr st k (SBVApp op [a])) return (shortCut a) mkSymOp1 :: Op -> State -> Kind -> SW -> IO SW mkSymOp1 = mkSymOp1SC (const Nothing) -- | eqOpt says the references are to the same SW, thus we can optimize. Note that -- we explicitly disallow KFloat/KDouble here. Why? Because it's *NOT* true that -- NaN == NaN, NaN >= NaN, and so-forth. So, we have to make sure we don't optimize -- floats and doubles, in case the argument turns out to be NaN. eqOpt :: SW -> SW -> SW -> Maybe SW eqOpt w x y = case swKind x of KFloat -> Nothing KDouble -> Nothing _ -> if x == y then Just w else Nothing -- For uninterpreted/enumerated values, we carefully lift through the constructor index for comparisons: uiLift :: String -> (Int -> Int -> Bool) -> (Maybe Int, String) -> (Maybe Int, String) -> Bool uiLift _ cmp (Just i, _) (Just j, _) = i `cmp` j uiLift w _ a b = error $ "Data.SBV.BitVectors.Model: Impossible happened while trying to lift " ++ w ++ " over " ++ show (a, b) -- | Predicate for optimizing word operations like (+) and (*). isConcreteZero :: SVal -> Bool isConcreteZero (SVal _ (Left (CW _ (CWInteger n)))) = n == 0 isConcreteZero (SVal KReal (Left (CW KReal (CWAlgReal v)))) = isExactRational v && v == 0 isConcreteZero _ = False -- | Predicate for optimizing word operations like (+) and (*). isConcreteOne :: SVal -> Bool isConcreteOne (SVal _ (Left (CW _ (CWInteger 1)))) = True isConcreteOne (SVal KReal (Left (CW KReal (CWAlgReal v)))) = isExactRational v && v == 1 isConcreteOne _ = False -- | Predicate for optimizing bitwise operations. isConcreteOnes :: SVal -> Bool isConcreteOnes (SVal _ (Left (CW (KBounded b w) (CWInteger n)))) = n == if b then -1 else bit w - 1 isConcreteOnes (SVal _ (Left (CW KUnbounded (CWInteger n)))) = n == -1 isConcreteOnes (SVal _ (Left (CW KBool (CWInteger n)))) = n == 1 isConcreteOnes _ = False -- | Predicate for optimizing comparisons. isConcreteMax :: SVal -> Bool isConcreteMax (SVal _ (Left (CW (KBounded False w) (CWInteger n)))) = n == bit w - 1 isConcreteMax (SVal _ (Left (CW (KBounded True w) (CWInteger n)))) = n == bit (w - 1) - 1 isConcreteMax (SVal _ (Left (CW KBool (CWInteger n)))) = n == 1 isConcreteMax _ = False -- | Predicate for optimizing comparisons. isConcreteMin :: SVal -> Bool isConcreteMin (SVal _ (Left (CW (KBounded False _) (CWInteger n)))) = n == 0 isConcreteMin (SVal _ (Left (CW (KBounded True w) (CWInteger n)))) = n == - bit (w - 1) isConcreteMin (SVal _ (Left (CW KBool (CWInteger n)))) = n == 0 isConcreteMin _ = False -- | Predicate for optimizing conditionals. areConcretelyEqual :: SVal -> SVal -> Bool areConcretelyEqual (SVal _ (Left a)) (SVal _ (Left b)) = a == b areConcretelyEqual _ _ = False -- | Most operations on concrete rationals require a compatibility check to avoid faulting -- on algebraic reals. rationalCheck :: CW -> CW -> Bool rationalCheck a b = case (cwVal a, cwVal b) of (CWAlgReal x, CWAlgReal y) -> isExactRational x && isExactRational y _ -> True -- | Quot/Rem operations require a nonzero check on the divisor. -- nonzeroCheck :: CW -> CW -> Bool nonzeroCheck _ b = cwVal b /= CWInteger 0 -- | Same as rationalCheck, except for SBV's rationalSBVCheck :: SVal -> SVal -> Bool rationalSBVCheck (SVal KReal (Left a)) (SVal KReal (Left b)) = rationalCheck a b rationalSBVCheck _ _ = True noReal :: String -> AlgReal -> AlgReal -> AlgReal noReal o a b = error $ "SBV.AlgReal." ++ o ++ ": Unexpected arguments: " ++ show (a, b) noFloat :: String -> Float -> Float -> Float noFloat o a b = error $ "SBV.Float." ++ o ++ ": Unexpected arguments: " ++ show (a, b) noDouble :: String -> Double -> Double -> Double noDouble o a b = error $ "SBV.Double." ++ o ++ ": Unexpected arguments: " ++ show (a, b) noRealUnary :: String -> AlgReal -> AlgReal noRealUnary o a = error $ "SBV.AlgReal." ++ o ++ ": Unexpected argument: " ++ show a noFloatUnary :: String -> Float -> Float noFloatUnary o a = error $ "SBV.Float." ++ o ++ ": Unexpected argument: " ++ show a noDoubleUnary :: String -> Double -> Double noDoubleUnary o a = error $ "SBV.Double." ++ o ++ ": Unexpected argument: " ++ show a {-# ANN svIte ("HLint: ignore Eta reduce" :: String) #-} {-# ANN svLazyIte ("HLint: ignore Eta reduce" :: String) #-} {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/Data/SBV/BitVectors/PrettyNum.hs0000644000000000000000000003410012725411266016317 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.PrettyNum -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Number representations in hex/bin ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeSynonymInstances #-} module Data.SBV.BitVectors.PrettyNum ( PrettyNum(..), readBin, shex, shexI, sbin, sbinI , showCFloat, showCDouble, showHFloat, showHDouble , showSMTFloat, showSMTDouble, smtRoundingMode, cwToSMTLib, mkSkolemZero ) where import Data.Char (ord, intToDigit) import Data.Int (Int8, Int16, Int32, Int64) import Data.List (isPrefixOf) import Data.Maybe (fromJust, fromMaybe, listToMaybe) import Data.Ratio (numerator, denominator) import Data.Word (Word8, Word16, Word32, Word64) import Numeric (showIntAtBase, showHex, readInt) import Data.Numbers.CrackNum (floatToFP, doubleToFP) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.AlgReals (algRealToSMTLib2) -- | PrettyNum class captures printing of numbers in hex and binary formats; also supporting negative numbers. -- -- Minimal complete definition: 'hexS' and 'binS' class PrettyNum a where -- | Show a number in hexadecimal (starting with @0x@ and type.) hexS :: a -> String -- | Show a number in binary (starting with @0b@ and type.) binS :: a -> String -- | Show a number in hex, without prefix, or types. hex :: a -> String -- | Show a number in bin, without prefix, or types. bin :: a -> String -- Why not default methods? Because defaults need "Integral a" but Bool is not.. instance PrettyNum Bool where {hexS = show; binS = show; hex = show; bin = show} instance PrettyNum Word8 where {hexS = shex True True (False,8) ; binS = sbin True True (False,8) ; hex = shex False False (False,8) ; bin = sbin False False (False,8) ;} instance PrettyNum Int8 where {hexS = shex True True (True,8) ; binS = sbin True True (True,8) ; hex = shex False False (True,8) ; bin = sbin False False (True,8) ;} instance PrettyNum Word16 where {hexS = shex True True (False,16); binS = sbin True True (False,16); hex = shex False False (False,16); bin = sbin False False (False,16);} instance PrettyNum Int16 where {hexS = shex True True (True,16); binS = sbin True True (True,16) ; hex = shex False False (True,16); bin = sbin False False (True,16) ;} instance PrettyNum Word32 where {hexS = shex True True (False,32); binS = sbin True True (False,32); hex = shex False False (False,32); bin = sbin False False (False,32);} instance PrettyNum Int32 where {hexS = shex True True (True,32); binS = sbin True True (True,32) ; hex = shex False False (True,32); bin = sbin False False (True,32) ;} instance PrettyNum Word64 where {hexS = shex True True (False,64); binS = sbin True True (False,64); hex = shex False False (False,64); bin = sbin False False (False,64);} instance PrettyNum Int64 where {hexS = shex True True (True,64); binS = sbin True True (True,64) ; hex = shex False False (True,64); bin = sbin False False (True,64) ;} instance PrettyNum Integer where {hexS = shexI True True; binS = sbinI True True; hex = shexI False False; bin = sbinI False False;} instance PrettyNum CW where hexS cw | isUninterpreted cw = show cw ++ " :: " ++ show (kindOf cw) | isBoolean cw = hexS (cwToBool cw) ++ " :: Bool" | isFloat cw = let CWFloat f = cwVal cw in show f ++ " :: Float\n" ++ show (floatToFP f) | isDouble cw = let CWDouble d = cwVal cw in show d ++ " :: Double\n" ++ show (doubleToFP d) | isReal cw = let CWAlgReal w = cwVal cw in show w ++ " :: Real" | not (isBounded cw) = let CWInteger w = cwVal cw in shexI True True w | True = let CWInteger w = cwVal cw in shex True True (hasSign cw, intSizeOf cw) w binS cw | isUninterpreted cw = show cw ++ " :: " ++ show (kindOf cw) | isBoolean cw = binS (cwToBool cw) ++ " :: Bool" | isFloat cw = let CWFloat f = cwVal cw in show f ++ " :: Float\n" ++ show (floatToFP f) | isDouble cw = let CWDouble d = cwVal cw in show d ++ " :: Double\n" ++ show (doubleToFP d) | isReal cw = let CWAlgReal w = cwVal cw in show w ++ " :: Real" | not (isBounded cw) = let CWInteger w = cwVal cw in sbinI True True w | True = let CWInteger w = cwVal cw in sbin True True (hasSign cw, intSizeOf cw) w hex cw | isUninterpreted cw = show cw | isBoolean cw = hexS (cwToBool cw) ++ " :: Bool" | isFloat cw = let CWFloat f = cwVal cw in show f | isDouble cw = let CWDouble d = cwVal cw in show d | isReal cw = let CWAlgReal w = cwVal cw in show w | not (isBounded cw) = let CWInteger w = cwVal cw in shexI False False w | True = let CWInteger w = cwVal cw in shex False False (hasSign cw, intSizeOf cw) w bin cw | isUninterpreted cw = show cw | isBoolean cw = binS (cwToBool cw) ++ " :: Bool" | isFloat cw = let CWFloat f = cwVal cw in show f | isDouble cw = let CWDouble d = cwVal cw in show d | isReal cw = let CWAlgReal w = cwVal cw in show w | not (isBounded cw) = let CWInteger w = cwVal cw in sbinI False False w | True = let CWInteger w = cwVal cw in sbin False False (hasSign cw, intSizeOf cw) w instance (SymWord a, PrettyNum a) => PrettyNum (SBV a) where hexS s = maybe (show s) (hexS :: a -> String) $ unliteral s binS s = maybe (show s) (binS :: a -> String) $ unliteral s hex s = maybe (show s) (hex :: a -> String) $ unliteral s bin s = maybe (show s) (bin :: a -> String) $ unliteral s -- | Show as a hexadecimal value. First bool controls whether type info is printed -- while the second boolean controls wether 0x prefix is printed. The tuple is -- the signedness and the bit-length of the input. The length of the string -- will /not/ depend on the value, but rather the bit-length. shex :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String shex shType shPre (signed, size) a | a < 0 = "-" ++ pre ++ pad l (s16 (abs (fromIntegral a :: Integer))) ++ t | True = pre ++ pad l (s16 a) ++ t where t | shType = " :: " ++ (if signed then "Int" else "Word") ++ show size | True = "" pre | shPre = "0x" | True = "" l = (size + 3) `div` 4 -- | Show as a hexadecimal value, integer version. Almost the same as shex above -- except we don't have a bit-length so the length of the string will depend -- on the actual value. shexI :: Bool -> Bool -> Integer -> String shexI shType shPre a | a < 0 = "-" ++ pre ++ s16 (abs a) ++ t | True = pre ++ s16 a ++ t where t | shType = " :: Integer" | True = "" pre | shPre = "0x" | True = "" -- | Similar to 'shex'; except in binary. sbin :: (Show a, Integral a) => Bool -> Bool -> (Bool, Int) -> a -> String sbin shType shPre (signed,size) a | a < 0 = "-" ++ pre ++ pad size (s2 (abs (fromIntegral a :: Integer))) ++ t | True = pre ++ pad size (s2 a) ++ t where t | shType = " :: " ++ (if signed then "Int" else "Word") ++ show size | True = "" pre | shPre = "0b" | True = "" -- | Similar to 'shexI'; except in binary. sbinI :: Bool -> Bool -> Integer -> String sbinI shType shPre a | a < 0 = "-" ++ pre ++ s2 (abs a) ++ t | True = pre ++ s2 a ++ t where t | shType = " :: Integer" | True = "" pre | shPre = "0b" | True = "" -- | Pad a string to a given length. If the string is longer, then we don't drop anything. pad :: Int -> String -> String pad l s = replicate (l - length s) '0' ++ s -- | Binary printer s2 :: (Show a, Integral a) => a -> String s2 v = showIntAtBase 2 dig v "" where dig = fromJust . flip lookup [(0, '0'), (1, '1')] -- | Hex printer s16 :: (Show a, Integral a) => a -> String s16 v = showHex v "" -- | A more convenient interface for reading binary numbers, also supports negative numbers readBin :: Num a => String -> a readBin ('-':s) = -(readBin s) readBin s = case readInt 2 isDigit cvt s' of [(a, "")] -> a _ -> error $ "SBV.readBin: Cannot read a binary number from: " ++ show s where cvt c = ord c - ord '0' isDigit = (`elem` "01") s' | "0b" `isPrefixOf` s = drop 2 s | True = s -- | A version of show for floats that generates correct C literals for nan/infinite. NB. Requires "math.h" to be included. showCFloat :: Float -> String showCFloat f | isNaN f = "((float) NAN)" | isInfinite f, f < 0 = "((float) (-INFINITY))" | isInfinite f = "((float) INFINITY)" | True = show f ++ "F" -- | A version of show for doubles that generates correct C literals for nan/infinite. NB. Requires "math.h" to be included. showCDouble :: Double -> String showCDouble f | isNaN f = "((double) NAN)" | isInfinite f, f < 0 = "((double) (-INFINITY))" | isInfinite f = "((double) INFINITY)" | True = show f -- | A version of show for floats that generates correct Haskell literals for nan/infinite showHFloat :: Float -> String showHFloat f | isNaN f = "((0/0) :: Float)" | isInfinite f, f < 0 = "((-1/0) :: Float)" | isInfinite f = "((1/0) :: Float)" | True = show f -- | A version of show for doubles that generates correct Haskell literals for nan/infinite showHDouble :: Double -> String showHDouble d | isNaN d = "((0/0) :: Double)" | isInfinite d, d < 0 = "((-1/0) :: Double)" | isInfinite d = "((1/0) :: Double)" | True = show d -- | A version of show for floats that generates correct SMTLib literals using the rounding mode showSMTFloat :: RoundingMode -> Float -> String showSMTFloat rm f | isNaN f = as "NaN" | isInfinite f, f < 0 = as "-oo" | isInfinite f = as "+oo" | isNegativeZero f = as "-zero" | f == 0 = as "+zero" | True = "((_ to_fp 8 24) " ++ smtRoundingMode rm ++ " " ++ toSMTLibRational (toRational f) ++ ")" where as s = "(_ " ++ s ++ " 8 24)" -- | A version of show for doubles that generates correct SMTLib literals using the rounding mode showSMTDouble :: RoundingMode -> Double -> String showSMTDouble rm d | isNaN d = as "NaN" | isInfinite d, d < 0 = as "-oo" | isInfinite d = as "+oo" | isNegativeZero d = as "-zero" | d == 0 = as "+zero" | True = "((_ to_fp 11 53) " ++ smtRoundingMode rm ++ " " ++ toSMTLibRational (toRational d) ++ ")" where as s = "(_ " ++ s ++ " 11 53)" -- | Show a rational in SMTLib format toSMTLibRational :: Rational -> String toSMTLibRational r | n < 0 = "(- (/ " ++ show (abs n) ++ " " ++ show d ++ "))" | True = "(/ " ++ show n ++ " " ++ show d ++ ")" where n = numerator r d = denominator r -- | Convert a rounding mode to the format SMT-Lib2 understands. smtRoundingMode :: RoundingMode -> String smtRoundingMode RoundNearestTiesToEven = "roundNearestTiesToEven" smtRoundingMode RoundNearestTiesToAway = "roundNearestTiesToAway" smtRoundingMode RoundTowardPositive = "roundTowardPositive" smtRoundingMode RoundTowardNegative = "roundTowardNegative" smtRoundingMode RoundTowardZero = "roundTowardZero" -- | Convert a CW to an SMTLib2 compliant value cwToSMTLib :: RoundingMode -> CW -> String cwToSMTLib rm x | isBoolean x, CWInteger w <- cwVal x = if w == 0 then "false" else "true" | isUninterpreted x, CWUserSort (_, s) <- cwVal x = roundModeConvert s | isReal x, CWAlgReal r <- cwVal x = algRealToSMTLib2 r | isFloat x, CWFloat f <- cwVal x = showSMTFloat rm f | isDouble x, CWDouble d <- cwVal x = showSMTDouble rm d | not (isBounded x), CWInteger w <- cwVal x = if w >= 0 then show w else "(- " ++ show (abs w) ++ ")" | not (hasSign x) , CWInteger w <- cwVal x = smtLibHex (intSizeOf x) w -- signed numbers (with 2's complement representation) is problematic -- since there's no way to put a bvneg over a positive number to get minBound.. -- Hence, we punt and use binary notation in that particular case | hasSign x , CWInteger w <- cwVal x = if w == negate (2 ^ intSizeOf x) then mkMinBound (intSizeOf x) else negIf (w < 0) $ smtLibHex (intSizeOf x) (abs w) | True = error $ "SBV.cvtCW: Impossible happened: Kind/Value disagreement on: " ++ show (kindOf x, x) where roundModeConvert s = fromMaybe s (listToMaybe [smtRoundingMode m | m <- [minBound .. maxBound] :: [RoundingMode], show m == s]) -- Carefully code hex numbers, SMTLib is picky about lengths of hex constants. For the time -- being, SBV only supports sizes that are multiples of 4, but the below code is more robust -- in case of future extensions to support arbitrary sizes. smtLibHex :: Int -> Integer -> String smtLibHex 1 v = "#b" ++ show v smtLibHex sz v | sz `mod` 4 == 0 = "#x" ++ pad (sz `div` 4) (showHex v "") | True = "#b" ++ pad sz (showBin v "") where showBin = showIntAtBase 2 intToDigit negIf :: Bool -> String -> String negIf True a = "(bvneg " ++ a ++ ")" negIf False a = a -- anamoly at the 2's complement min value! Have to use binary notation here -- as there is no positive value we can provide to make the bvneg work.. (see above) mkMinBound :: Int -> String mkMinBound i = "#b1" ++ replicate (i-1) '0' -- | Create a skolem 0 for the kind mkSkolemZero :: RoundingMode -> Kind -> String mkSkolemZero _ (KUserSort _ (Right (f:_))) = f mkSkolemZero _ (KUserSort s _) = error $ "SBV.mkSkolemZero: Unexpected uninterpreted sort: " ++ s mkSkolemZero rm k = cwToSMTLib rm (mkConstCW k (0::Integer)) sbv-5.12/Data/SBV/BitVectors/Splittable.hs0000644000000000000000000001024012725411266016452 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Splittable -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Implementation of bit-vector concatanetation and splits ----------------------------------------------------------------------------- {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE BangPatterns #-} module Data.SBV.BitVectors.Splittable (Splittable(..), FromBits(..), checkAndConvert) where import Data.Bits (Bits(..)) import Data.Word (Word8, Word16, Word32, Word64) import Data.SBV.BitVectors.Operations import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model infixr 5 # -- | Splitting an @a@ into two @b@'s and joining back. -- Intuitively, @a@ is a larger bit-size word than @b@, typically double. -- The 'extend' operation captures embedding of a @b@ value into an @a@ -- without changing its semantic value. -- -- Minimal complete definition: All, no defaults. class Splittable a b | b -> a where split :: a -> (b, b) (#) :: b -> b -> a extend :: b -> a genSplit :: (Integral a, Num b) => Int -> a -> (b, b) genSplit ss x = (fromIntegral ((ix `shiftR` ss) .&. mask), fromIntegral (ix .&. mask)) where ix = toInteger x mask = 2 ^ ss - 1 genJoin :: (Integral b, Num a) => Int -> b -> b -> a genJoin ss x y = fromIntegral ((ix `shiftL` ss) .|. iy) where ix = toInteger x iy = toInteger y -- concrete instances instance Splittable Word64 Word32 where split = genSplit 32 (#) = genJoin 32 extend b = 0 # b instance Splittable Word32 Word16 where split = genSplit 16 (#) = genJoin 16 extend b = 0 # b instance Splittable Word16 Word8 where split = genSplit 8 (#) = genJoin 8 extend b = 0 # b -- symbolic instances instance Splittable SWord64 SWord32 where split (SBV x) = (SBV (svExtract 63 32 x), SBV (svExtract 31 0 x)) SBV a # SBV b = SBV (svJoin a b) extend b = 0 # b instance Splittable SWord32 SWord16 where split (SBV x) = (SBV (svExtract 31 16 x), SBV (svExtract 15 0 x)) SBV a # SBV b = SBV (svJoin a b) extend b = 0 # b instance Splittable SWord16 SWord8 where split (SBV x) = (SBV (svExtract 15 8 x), SBV (svExtract 7 0 x)) SBV a # SBV b = SBV (svJoin a b) extend b = 0 # b -- | Unblasting a value from symbolic-bits. The bits can be given little-endian -- or big-endian. For a signed number in little-endian, we assume the very last bit -- is the sign digit. This is a bit awkward, but it is more consistent with the "reverse" view of -- little-big-endian representations -- -- Minimal complete definition: 'fromBitsLE' class FromBits a where fromBitsLE, fromBitsBE :: [SBool] -> a fromBitsBE = fromBitsLE . reverse -- | Construct a symbolic word from its bits given in little-endian fromBinLE :: (Num a, Bits a, SymWord a) => [SBool] -> SBV a fromBinLE = go 0 0 where go !acc _ [] = acc go !acc !i (x:xs) = go (ite x (setBit acc i) acc) (i+1) xs -- | Perform a sanity check that we should receive precisely the same -- number of bits as required by the resulting type. The input is little-endian checkAndConvert :: (Num a, Bits a, SymWord a) => Int -> [SBool] -> SBV a checkAndConvert sz xs | sz /= l = error $ "SBV.fromBits.SWord" ++ ssz ++ ": Expected " ++ ssz ++ " elements, got: " ++ show l | True = fromBinLE xs where l = length xs ssz = show sz instance FromBits SBool where fromBitsLE [x] = x fromBitsLE xs = error $ "SBV.fromBits.SBool: Expected 1 element, got: " ++ show (length xs) instance FromBits SWord8 where fromBitsLE = checkAndConvert 8 instance FromBits SInt8 where fromBitsLE = checkAndConvert 8 instance FromBits SWord16 where fromBitsLE = checkAndConvert 16 instance FromBits SInt16 where fromBitsLE = checkAndConvert 16 instance FromBits SWord32 where fromBitsLE = checkAndConvert 32 instance FromBits SInt32 where fromBitsLE = checkAndConvert 32 instance FromBits SWord64 where fromBitsLE = checkAndConvert 64 instance FromBits SInt64 where fromBitsLE = checkAndConvert 64 sbv-5.12/Data/SBV/BitVectors/STree.hs0000644000000000000000000000701512725411266015377 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.STree -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Implementation of full-binary symbolic trees, providing logarithmic -- time access to elements. Both reads and writes are supported. ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} module Data.SBV.BitVectors.STree (STree, readSTree, writeSTree, mkSTree) where import Data.Bits (Bits(..)) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model -- | A symbolic tree containing values of type e, indexed by -- elements of type i. Note that these are full-trees, and their -- their shapes remain constant. There is no API provided that -- can change the shape of the tree. These structures are useful -- when dealing with data-structures that are indexed with symbolic -- values where access time is important. 'STree' structures provide -- logarithmic time reads and writes. type STree i e = STreeInternal (SBV i) (SBV e) -- Internal representation, not exposed to the user data STreeInternal i e = SLeaf e -- NB. parameter 'i' is phantom | SBin (STreeInternal i e) (STreeInternal i e) deriving Show instance (SymWord e, Mergeable (SBV e)) => Mergeable (STree i e) where symbolicMerge f b (SLeaf i) (SLeaf j) = SLeaf (symbolicMerge f b i j) symbolicMerge f b (SBin l r) (SBin l' r') = SBin (symbolicMerge f b l l') (symbolicMerge f b r r') symbolicMerge _ _ _ _ = error "SBV.STree.symbolicMerge: Impossible happened while merging states" -- | Reading a value. We bit-blast the index and descend down the full tree -- according to bit-values. readSTree :: (Num i, Bits i, SymWord i, SymWord e) => STree i e -> SBV i -> SBV e readSTree s i = walk (blastBE i) s where walk [] (SLeaf v) = v walk (b:bs) (SBin l r) = ite b (walk bs r) (walk bs l) walk _ _ = error $ "SBV.STree.readSTree: Impossible happened while reading: " ++ show i -- | Writing a value, similar to how reads are done. The important thing is that the tree -- representation keeps updates to a minimum. writeSTree :: (Mergeable (SBV e), Num i, Bits i, SymWord i, SymWord e) => STree i e -> SBV i -> SBV e -> STree i e writeSTree s i j = walk (blastBE i) s where walk [] _ = SLeaf j walk (b:bs) (SBin l r) = SBin (ite b l (walk bs l)) (ite b (walk bs r) r) walk _ _ = error $ "SBV.STree.writeSTree: Impossible happened while reading: " ++ show i -- | Construct the fully balanced initial tree using the given values. mkSTree :: forall i e. HasKind i => [SBV e] -> STree i e mkSTree ivals | isReal (undefined :: i) = error "SBV.STree.mkSTree: Cannot build a real-valued sized tree" | not (isBounded (undefined :: i)) = error "SBV.STree.mkSTree: Cannot build an infinitely large tree" | reqd /= given = error $ "SBV.STree.mkSTree: Required " ++ show reqd ++ " elements, received: " ++ show given | True = go ivals where reqd = 2 ^ intSizeOf (undefined :: i) given = length ivals go [] = error "SBV.STree.mkSTree: Impossible happened, ran out of elements" go [l] = SLeaf l go ns = let (l, r) = splitAt (length ns `div` 2) ns in SBin (go l) (go r) sbv-5.12/Data/SBV/BitVectors/Symbolic.hs0000644000000000000000000015357412725411266016152 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Symbolic -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Symbolic values ----------------------------------------------------------------------------- {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE TypeSynonymInstances #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.SBV.BitVectors.Symbolic ( NodeId(..) , SW(..), swKind, trueSW, falseSW , Op(..), FPOp(..) , Quantifier(..), needsExistentials , RoundingMode(..) , SBVType(..), newUninterpreted, addAxiom , SVal(..) , svMkSymVar , ArrayContext(..), ArrayInfo , svToSW, svToSymSW, forceSWArg , SBVExpr(..), newExpr, isCodeGenMode , Cached, cache, uncache , ArrayIndex, uncacheAI , NamedSymVar , getSValPathCondition, extendSValPathCondition , getTableIndex , SBVPgm(..), Symbolic, runSymbolic, runSymbolic', State , inProofMode, SBVRunMode(..), Result(..) , Logic(..), SMTLibLogic(..) , addAssertion, addSValConstraint, internalConstraint, internalVariable , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension , SolverCapabilities(..) , extractSymbolicSimulationState , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), SMTEngine, getSBranchRunConfig , outputSVal , mkSValUserSort , SArr(..), readSArr, resetSArr, writeSArr, mergeSArr, newSArr, eqSArr ) where import Control.DeepSeq (NFData(..)) import Control.Monad (when, unless) import Control.Monad.Reader (MonadReader, ReaderT, ask, runReaderT) import Control.Monad.Trans (MonadIO, liftIO) import Data.Char (isAlpha, isAlphaNum, toLower) import Data.IORef (IORef, newIORef, modifyIORef, readIORef, writeIORef) import Data.List (intercalate, sortBy) import Data.Maybe (isJust, fromJust, fromMaybe) import GHC.Stack.Compat import qualified Data.Generics as G (Data(..)) import qualified Data.IntMap as IMap (IntMap, empty, size, toAscList, lookup, insert, insertWith) import qualified Data.Map as Map (Map, empty, toList, size, insert, lookup) import qualified Data.Set as Set (Set, empty, toList, insert) import qualified Data.Foldable as F (toList) import qualified Data.Sequence as S (Seq, empty, (|>)) import System.Mem.StableName import System.Random import Data.SBV.BitVectors.Kind import Data.SBV.BitVectors.Concrete import Data.SBV.SMT.SMTLibNames import Prelude () import Prelude.Compat -- | A symbolic node id newtype NodeId = NodeId Int deriving (Eq, Ord) -- | A symbolic word, tracking it's signedness and size. data SW = SW Kind NodeId deriving (Eq, Ord) instance HasKind SW where kindOf (SW k _) = k instance Show SW where show (SW _ (NodeId n)) | n < 0 = "s_" ++ show (abs n) | True = 's' : show n -- | Kind of a symbolic word. swKind :: SW -> Kind swKind (SW k _) = k -- | Forcing an argument; this is a necessary evil to make sure all the arguments -- to an uninterpreted function and sBranch test conditions are evaluated before called; -- the semantics of uinterpreted functions is necessarily strict; deviating from Haskell's forceSWArg :: SW -> IO () forceSWArg (SW k n) = k `seq` n `seq` return () -- | Constant False as a SW. Note that this value always occupies slot -2. falseSW :: SW falseSW = SW KBool $ NodeId (-2) -- | Constant False as a SW. Note that this value always occupies slot -1. trueSW :: SW trueSW = SW KBool $ NodeId (-1) -- | Symbolic operations data Op = Plus | Times | Minus | UNeg | Abs | Quot | Rem | Equal | NotEqual | LessThan | GreaterThan | LessEq | GreaterEq | Ite | And | Or | XOr | Not | Shl Int | Shr Int | Rol Int | Ror Int | Extract Int Int -- Extract i j: extract bits i to j. Least significant bit is 0 (big-endian) | Join -- Concat two words to form a bigger one, in the order given | LkUp (Int, Kind, Kind, Int) !SW !SW -- (table-index, arg-type, res-type, length of the table) index out-of-bounds-value | ArrEq Int Int -- Array equality | ArrRead Int | IntCast Kind Kind | Uninterpreted String | Label String -- Essentially no-op; useful for code generation to emit comments. | IEEEFP FPOp -- Floating-point ops, categorized separately deriving (Eq, Ord) -- | Floating point operations data FPOp = FP_Cast Kind Kind SW -- From-Kind, To-Kind, RoundingMode. This is "value" conversion | FP_Reinterpret Kind Kind -- From-Kind, To-Kind. This is bit-reinterpretation using IEEE-754 interchange format | FP_Abs | FP_Neg | FP_Add | FP_Sub | FP_Mul | FP_Div | FP_FMA | FP_Sqrt | FP_Rem | FP_RoundToIntegral | FP_Min | FP_Max | FP_ObjEqual | FP_IsNormal | FP_IsSubnormal | FP_IsZero | FP_IsInfinite | FP_IsNaN | FP_IsNegative | FP_IsPositive deriving (Eq, Ord) -- | Note that the show instance maps to the SMTLib names. We need to make sure -- this mapping stays correct through SMTLib changes. The only exception -- is FP_Cast; where we handle different source/origins explicitly later on. instance Show FPOp where show (FP_Cast f t r) = "(FP_Cast: " ++ show f ++ " -> " ++ show t ++ "using RM [" ++ show r ++ "])" show (FP_Reinterpret f t) = case (f, t) of (KBounded False 32, KFloat) -> "(_ to_fp 8 24)" (KBounded False 64, KDouble) -> "(_ to_fp 11 53)" _ -> error $ "SBV.FP_Reinterpret: Unexpected conversion: " ++ show f ++ " to " ++ show t show FP_Abs = "fp.abs" show FP_Neg = "fp.neg" show FP_Add = "fp.add" show FP_Sub = "fp.sub" show FP_Mul = "fp.mul" show FP_Div = "fp.div" show FP_FMA = "fp.fma" show FP_Sqrt = "fp.sqrt" show FP_Rem = "fp.rem" show FP_RoundToIntegral = "fp.roundToIntegral" show FP_Min = "fp.min" show FP_Max = "fp.max" show FP_ObjEqual = "=" show FP_IsNormal = "fp.isNormal" show FP_IsSubnormal = "fp.isSubnormal" show FP_IsZero = "fp.isZero" show FP_IsInfinite = "fp.isInfinite" show FP_IsNaN = "fp.isNaN" show FP_IsNegative = "fp.isNegative" show FP_IsPositive = "fp.isPositive" -- | Show instance for 'Op'. Note that this is largely for debugging purposes, not used -- for being read by any tool. instance Show Op where show (Shl i) = "<<" ++ show i show (Shr i) = ">>" ++ show i show (Rol i) = "<<<" ++ show i show (Ror i) = ">>>" ++ show i show (Extract i j) = "choose [" ++ show i ++ ":" ++ show j ++ "]" show (LkUp (ti, at, rt, l) i e) = "lookup(" ++ tinfo ++ ", " ++ show i ++ ", " ++ show e ++ ")" where tinfo = "table" ++ show ti ++ "(" ++ show at ++ " -> " ++ show rt ++ ", " ++ show l ++ ")" show (ArrEq i j) = "array_" ++ show i ++ " == array_" ++ show j show (ArrRead i) = "select array_" ++ show i show (IntCast fr to) = "cast_" ++ show fr ++ "_" ++ show to show (Uninterpreted i) = "[uninterpreted] " ++ i show (Label s) = "[label] " ++ s show (IEEEFP w) = show w show op | Just s <- op `lookup` syms = s | True = error "impossible happened; can't find op!" where syms = [ (Plus, "+"), (Times, "*"), (Minus, "-"), (UNeg, "-"), (Abs, "abs") , (Quot, "quot") , (Rem, "rem") , (Equal, "=="), (NotEqual, "/=") , (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=") , (Ite, "if_then_else") , (And, "&"), (Or, "|"), (XOr, "^"), (Not, "~") , (Join, "#") ] -- | Quantifiers: forall or exists. Note that we allow -- arbitrary nestings. data Quantifier = ALL | EX deriving Eq -- | Are there any existential quantifiers? needsExistentials :: [Quantifier] -> Bool needsExistentials = (EX `elem`) -- | A simple type for SBV computations, used mainly for uninterpreted constants. -- We keep track of the signedness/size of the arguments. A non-function will -- have just one entry in the list. newtype SBVType = SBVType [Kind] deriving (Eq, Ord) instance Show SBVType where show (SBVType []) = error "SBV: internal error, empty SBVType" show (SBVType xs) = intercalate " -> " $ map show xs -- | A symbolic expression data SBVExpr = SBVApp !Op ![SW] deriving (Eq, Ord) -- | To improve hash-consing, take advantage of commutative operators by -- reordering their arguments. reorder :: SBVExpr -> SBVExpr reorder s = case s of SBVApp op [a, b] | isCommutative op && a > b -> SBVApp op [b, a] _ -> s where isCommutative :: Op -> Bool isCommutative o = o `elem` [Plus, Times, Equal, NotEqual, And, Or, XOr] -- | Show instance for 'SBVExpr'. Again, only for debugging purposes. instance Show SBVExpr where show (SBVApp Ite [t, a, b]) = unwords ["if", show t, "then", show a, "else", show b] show (SBVApp (Shl i) [a]) = unwords [show a, "<<", show i] show (SBVApp (Shr i) [a]) = unwords [show a, ">>", show i] show (SBVApp (Rol i) [a]) = unwords [show a, "<<<", show i] show (SBVApp (Ror i) [a]) = unwords [show a, ">>>", show i] show (SBVApp op [a, b]) = unwords [show a, show op, show b] show (SBVApp op args) = unwords (show op : map show args) -- | A program is a sequence of assignments newtype SBVPgm = SBVPgm {pgmAssignments :: S.Seq (SW, SBVExpr)} -- | 'NamedSymVar' pairs symbolic words and user given/automatically generated names type NamedSymVar = (SW, String) -- | Result of running a symbolic computation data Result = Result { reskinds :: Set.Set Kind -- ^ kinds used in the program , resTraces :: [(String, CW)] -- ^ quick-check counter-example information (if any) , resUISegs :: [(String, [String])] -- ^ uninterpeted code segments , resInputs :: [(Quantifier, NamedSymVar)] -- ^ inputs (possibly existential) , resConsts :: [(SW, CW)] -- ^ constants , resTables :: [((Int, Kind, Kind), [SW])] -- ^ tables (automatically constructed) (tableno, index-type, result-type) elts , resArrays :: [(Int, ArrayInfo)] -- ^ arrays (user specified) , resUIConsts :: [(String, SBVType)] -- ^ uninterpreted constants , resAxioms :: [(String, [String])] -- ^ axioms , resAsgns :: SBVPgm -- ^ assignments , resConstraints :: [SW] -- ^ additional constraints (boolean) , resAssertions :: [(String, Maybe CallStack, SW)] -- ^ assertions , resOutputs :: [SW] -- ^ outputs } -- | Show instance for 'Result'. Only for debugging purposes. instance Show Result where show (Result _ _ _ _ cs _ _ [] [] _ [] _ [r]) | Just c <- r `lookup` cs = show c show (Result kinds _ cgs is cs ts as uis axs xs cstrs asserts os) = intercalate "\n" $ (if null usorts then [] else "SORTS" : map (" " ++) usorts) ++ ["INPUTS"] ++ map shn is ++ ["CONSTANTS"] ++ map shc cs ++ ["TABLES"] ++ map sht ts ++ ["ARRAYS"] ++ map sha as ++ ["UNINTERPRETED CONSTANTS"] ++ map shui uis ++ ["USER GIVEN CODE SEGMENTS"] ++ concatMap shcg cgs ++ ["AXIOMS"] ++ map shax axs ++ ["DEFINE"] ++ map (\(s, e) -> " " ++ shs s ++ " = " ++ show e) (F.toList (pgmAssignments xs)) ++ ["CONSTRAINTS"] ++ map ((" " ++) . show) cstrs ++ ["ASSERTIONS"] ++ map ((" "++) . shAssert) asserts ++ ["OUTPUTS"] ++ map ((" " ++) . show) os where usorts = [sh s t | KUserSort s t <- Set.toList kinds] where sh s (Left _) = s sh s (Right es) = s ++ " (" ++ intercalate ", " es ++ ")" shs sw = show sw ++ " :: " ++ show (swKind sw) sht ((i, at, rt), es) = " Table " ++ show i ++ " : " ++ show at ++ "->" ++ show rt ++ " = " ++ show es shc (sw, cw) = " " ++ show sw ++ " = " ++ show cw shcg (s, ss) = ("Variable: " ++ s) : map (" " ++) ss shn (q, (sw, nm)) = " " ++ ni ++ " :: " ++ show (swKind sw) ++ ex ++ alias where ni = show sw ex | q == ALL = "" | True = ", existential" alias | ni == nm = "" | True = ", aliasing " ++ show nm sha (i, (nm, (ai, bi), ctx)) = " " ++ ni ++ " :: " ++ show ai ++ " -> " ++ show bi ++ alias ++ "\n Context: " ++ show ctx where ni = "array_" ++ show i alias | ni == nm = "" | True = ", aliasing " ++ show nm shui (nm, t) = " [uninterpreted] " ++ nm ++ " :: " ++ show t shax (nm, ss) = " -- user defined axiom: " ++ nm ++ "\n " ++ intercalate "\n " ss shAssert (nm, stk, p) = " -- assertion: " ++ nm ++ " " ++ maybe "[No location]" #if MIN_VERSION_base(4,9,0) prettyCallStack #else showCallStack #endif stk ++ ": " ++ show p -- | The context of a symbolic array as created data ArrayContext = ArrayFree (Maybe SW) -- ^ A new array, with potential initializer for each cell | ArrayReset Int SW -- ^ An array created from another array by fixing each element to another value | ArrayMutate Int SW SW -- ^ An array created by mutating another array at a given cell | ArrayMerge SW Int Int -- ^ An array created by symbolically merging two other arrays instance Show ArrayContext where show (ArrayFree Nothing) = " initialized with random elements" show (ArrayFree (Just s)) = " initialized with " ++ show s ++ " :: " ++ show (swKind s) show (ArrayReset i s) = " reset array_" ++ show i ++ " with " ++ show s ++ " :: " ++ show (swKind s) show (ArrayMutate i a b) = " cloned from array_" ++ show i ++ " with " ++ show a ++ " :: " ++ show (swKind a) ++ " |-> " ++ show b ++ " :: " ++ show (swKind b) show (ArrayMerge s i j) = " merged arrays " ++ show i ++ " and " ++ show j ++ " on condition " ++ show s -- | Expression map, used for hash-consing type ExprMap = Map.Map SBVExpr SW -- | Constants are stored in a map, for hash-consing. The bool is needed to tell -0 from +0, sigh type CnstMap = Map.Map (Bool, CW) SW -- | Kinds used in the program; used for determining the final SMT-Lib logic to pick type KindSet = Set.Set Kind -- | Tables generated during a symbolic run type TableMap = Map.Map (Kind, Kind, [SW]) Int -- | Representation for symbolic arrays type ArrayInfo = (String, (Kind, Kind), ArrayContext) -- | Arrays generated during a symbolic run type ArrayMap = IMap.IntMap ArrayInfo -- | Uninterpreted-constants generated during a symbolic run type UIMap = Map.Map String SBVType -- | Code-segments for Uninterpreted-constants, as given by the user type CgMap = Map.Map String [String] -- | Cached values, implementing sharing type Cache a = IMap.IntMap [(StableName (State -> IO a), a)] -- | Different means of running a symbolic piece of code data SBVRunMode = Proof (Bool, SMTConfig) -- ^ Fully Symbolic, proof mode. | CodeGen -- ^ Code generation mode. | Concrete StdGen -- ^ Concrete simulation mode. The StdGen is for the pConstrain acceptance in cross runs. -- | Is this a concrete run? (i.e., quick-check or test-generation like) isConcreteMode :: State -> Bool isConcreteMode State{runMode} = case runMode of Concrete{} -> True Proof{} -> False CodeGen -> False -- | Is this a CodeGen run? (i.e., generating code) isCodeGenMode :: State -> Bool isCodeGenMode State{runMode} = case runMode of Concrete{} -> False Proof{} -> False CodeGen -> True -- | The state of the symbolic interpreter data State = State { runMode :: SBVRunMode , pathCond :: SVal -- ^ kind KBool , rStdGen :: IORef StdGen , rCInfo :: IORef [(String, CW)] , rctr :: IORef Int , rUsedKinds :: IORef KindSet , rinps :: IORef [(Quantifier, NamedSymVar)] , rConstraints :: IORef [SW] , routs :: IORef [SW] , rtblMap :: IORef TableMap , spgm :: IORef SBVPgm , rconstMap :: IORef CnstMap , rexprMap :: IORef ExprMap , rArrayMap :: IORef ArrayMap , rUIMap :: IORef UIMap , rCgMap :: IORef CgMap , raxioms :: IORef [(String, [String])] , rAsserts :: IORef [(String, Maybe CallStack, SW)] , rSWCache :: IORef (Cache SW) , rAICache :: IORef (Cache Int) } -- | Get the current path condition getSValPathCondition :: State -> SVal getSValPathCondition = pathCond -- | Extend the path condition with the given test value. extendSValPathCondition :: State -> (SVal -> SVal) -> State extendSValPathCondition st f = st{pathCond = f (pathCond st)} -- | Are we running in proof mode? inProofMode :: State -> Bool inProofMode s = case runMode s of Proof{} -> True CodeGen -> False Concrete{} -> False -- | If in proof mode, get the underlying configuration (used for 'sBranch') getSBranchRunConfig :: State -> Maybe SMTConfig getSBranchRunConfig st = case runMode st of Proof (_, s) -> Just s _ -> Nothing -- | The "Symbolic" value. Either a constant (@Left@) or a symbolic -- value (@Right Cached@). Note that caching is essential for making -- sure sharing is preserved. data SVal = SVal !Kind !(Either CW (Cached SW)) instance HasKind SVal where kindOf (SVal k _) = k -- | Show instance for 'SVal'. Not particularly "desirable", but will do if needed -- NB. We do not show the type info on constant KBool values, since there's no -- implicit "fromBoolean" applied to Booleans in Haskell; and thus a statement -- of the form "True :: SBool" is just meaningless. (There should be a fromBoolean!) instance Show SVal where show (SVal KBool (Left c)) = showCW False c show (SVal k (Left c)) = showCW False c ++ " :: " ++ show k show (SVal k (Right _)) = " :: " ++ show k -- | Equality constraint on SBV values. Not desirable since we can't really compare two -- symbolic values, but will do. instance Eq SVal where SVal _ (Left a) == SVal _ (Left b) = a == b a == b = error $ "Comparing symbolic bit-vectors; Use (.==) instead. Received: " ++ show (a, b) SVal _ (Left a) /= SVal _ (Left b) = a /= b a /= b = error $ "Comparing symbolic bit-vectors; Use (./=) instead. Received: " ++ show (a, b) -- | Increment the variable counter incCtr :: State -> IO Int incCtr s = do ctr <- readIORef (rctr s) let i = ctr + 1 i `seq` writeIORef (rctr s) i return ctr -- | Generate a random value, for quick-check and test-gen purposes throwDice :: State -> IO Double throwDice st = do g <- readIORef (rStdGen st) let (r, g') = randomR (0, 1) g writeIORef (rStdGen st) g' return r -- | Create a new uninterpreted symbol, possibly with user given code newUninterpreted :: State -> String -> SBVType -> Maybe [String] -> IO () newUninterpreted st nm t mbCode | null nm || not enclosed && (not (isAlpha (head nm)) || not (all validChar (tail nm))) = error $ "Bad uninterpreted constant name: " ++ show nm ++ ". Must be a valid identifier." | True = do uiMap <- readIORef (rUIMap st) case nm `Map.lookup` uiMap of Just t' -> when (t /= t') $ error $ "Uninterpreted constant " ++ show nm ++ " used at incompatible types\n" ++ " Current type : " ++ show t ++ "\n" ++ " Previously used at: " ++ show t' Nothing -> do modifyIORef (rUIMap st) (Map.insert nm t) when (isJust mbCode) $ modifyIORef (rCgMap st) (Map.insert nm (fromJust mbCode)) where validChar x = isAlphaNum x || x `elem` "_" enclosed = head nm == '|' && last nm == '|' && length nm > 2 && not (any (`elem` "|\\") (tail (init nm))) -- | Add a new sAssert based constraint addAssertion :: State -> Maybe CallStack -> String -> SW -> IO () addAssertion st cs msg cond = modifyIORef (rAsserts st) ((msg, cs, cond):) -- | Create an internal variable, which acts as an input but isn't visible to the user. -- Such variables are existentially quantified in a SAT context, and universally quantified -- in a proof context. internalVariable :: State -> Kind -> IO SW internalVariable st k = do (sw, nm) <- newSW st k let q = case runMode st of Proof (True, _) -> EX _ -> ALL modifyIORef (rinps st) ((q, (sw, "__internal_sbv_" ++ nm)):) return sw {-# INLINE internalVariable #-} -- | Create a new SW newSW :: State -> Kind -> IO (SW, String) newSW st k = do ctr <- incCtr st let sw = SW k (NodeId ctr) registerKind st k return (sw, 's' : show ctr) {-# INLINE newSW #-} -- | Register a new kind with the system, used for uninterpreted sorts registerKind :: State -> Kind -> IO () registerKind st k | KUserSort sortName _ <- k, map toLower sortName `elem` smtLibReservedNames = error $ "SBV: " ++ show sortName ++ " is a reserved sort; please use a different name." | True = modifyIORef (rUsedKinds st) (Set.insert k) -- | Create a new constant; hash-cons as necessary -- NB. For each constant, we also store weather it's negative-0 or not, -- as otherwise +0 == -0 and thus we'd confuse those entries. That's a -- bummer as we incur an extra boolean for this rare case, but it's simple -- and hopefully we don't generate a ton of constants in general. newConst :: State -> CW -> IO SW newConst st c = do constMap <- readIORef (rconstMap st) let key = (isNeg0 (cwVal c), c) case key `Map.lookup` constMap of Just sw -> return sw Nothing -> do let k = kindOf c (sw, _) <- newSW st k modifyIORef (rconstMap st) (Map.insert key sw) return sw where isNeg0 (CWFloat f) = isNegativeZero f isNeg0 (CWDouble d) = isNegativeZero d isNeg0 _ = False {-# INLINE newConst #-} -- | Create a new table; hash-cons as necessary getTableIndex :: State -> Kind -> Kind -> [SW] -> IO Int getTableIndex st at rt elts = do let key = (at, rt, elts) tblMap <- readIORef (rtblMap st) case key `Map.lookup` tblMap of Just i -> return i _ -> do let i = Map.size tblMap modifyIORef (rtblMap st) (Map.insert key i) return i -- | Create a new expression; hash-cons as necessary newExpr :: State -> Kind -> SBVExpr -> IO SW newExpr st k app = do let e = reorder app exprMap <- readIORef (rexprMap st) case e `Map.lookup` exprMap of Just sw -> return sw Nothing -> do (sw, _) <- newSW st k modifyIORef (spgm st) (\(SBVPgm xs) -> SBVPgm (xs S.|> (sw, e))) modifyIORef (rexprMap st) (Map.insert e sw) return sw {-# INLINE newExpr #-} -- | Convert a symbolic value to a symbolic-word svToSW :: State -> SVal -> IO SW svToSW st (SVal _ (Left c)) = newConst st c svToSW st (SVal _ (Right f)) = uncache f st -- | Convert a symbolic value to an SW, inside the Symbolic monad svToSymSW :: SVal -> Symbolic SW svToSymSW sbv = do st <- ask liftIO $ svToSW st sbv ------------------------------------------------------------------------- -- * Symbolic Computations ------------------------------------------------------------------------- -- | A Symbolic computation. Represented by a reader monad carrying the -- state of the computation, layered on top of IO for creating unique -- references to hold onto intermediate results. newtype Symbolic a = Symbolic (ReaderT State IO a) deriving (Applicative, Functor, Monad, MonadIO, MonadReader State) -- | Create a symbolic value, based on the quantifier we have. If an -- explicit quantifier is given, we just use that. If not, then we -- pick existential for SAT calls and universal for everything else. -- @randomCW@ is used for generating random values for this variable -- when used for 'quickCheck' purposes. svMkSymVar :: Maybe Quantifier -> Kind -> Maybe String -> Symbolic SVal svMkSymVar mbQ k mbNm = do st <- ask let q = case (mbQ, runMode st) of (Just x, _) -> x -- user given, just take it (Nothing, Concrete{}) -> ALL -- concrete simulation, pick universal (Nothing, Proof (True, _)) -> EX -- sat mode, pick existential (Nothing, Proof (False, _)) -> ALL -- proof mode, pick universal (Nothing, CodeGen) -> ALL -- code generation, pick universal case runMode st of Concrete _ | q == EX -> case mbNm of Nothing -> error $ "Cannot quick-check in the presence of existential variables, type: " ++ show k Just nm -> error $ "Cannot quick-check in the presence of existential variable " ++ nm ++ " :: " ++ show k Concrete _ -> do cw <- liftIO (randomCW k) liftIO $ modifyIORef (rCInfo st) ((fromMaybe "_" mbNm, cw):) return (SVal k (Left cw)) _ -> do (sw, internalName) <- liftIO $ newSW st k let nm = fromMaybe internalName mbNm liftIO $ modifyIORef (rinps st) ((q, (sw, nm)):) return $ SVal k $ Right $ cache (const (return sw)) -- | Create a properly quantified variable of a user defined sort. Only valid -- in proof contexts. mkSValUserSort :: Kind -> Maybe Quantifier -> Maybe String -> Symbolic SVal mkSValUserSort k mbQ mbNm = do st <- ask let (KUserSort sortName _) = k liftIO $ registerKind st k let q = case (mbQ, runMode st) of (Just x, _) -> x (Nothing, Proof (True, _)) -> EX (Nothing, Proof (False, _)) -> ALL (Nothing, CodeGen) -> error $ "SBV: Uninterpreted sort " ++ sortName ++ " can not be used in code-generation mode." (Nothing, Concrete{}) -> error $ "SBV: Uninterpreted sort " ++ sortName ++ " can not be used in concrete simulation mode." ctr <- liftIO $ incCtr st let sw = SW k (NodeId ctr) nm = fromMaybe ('s':show ctr) mbNm liftIO $ modifyIORef (rinps st) ((q, (sw, nm)):) return $ SVal k $ Right $ cache (const (return sw)) -- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere -- string, use for commenting purposes. The second argument is intended to hold the multiple-lines -- of the axiom text as expressed in SMT-Lib notation. Note that we perform no checks on the axiom -- itself, to see whether it's actually well-formed or is sensical by any means. -- A separate formalization of SMT-Lib would be very useful here. addAxiom :: String -> [String] -> Symbolic () addAxiom nm ax = do st <- ask liftIO $ modifyIORef (raxioms st) ((nm, ax) :) -- | Run a symbolic computation in Proof mode and return a 'Result'. The boolean -- argument indicates if this is a sat instance or not. runSymbolic :: (Bool, SMTConfig) -> Symbolic a -> IO Result runSymbolic m c = snd `fmap` runSymbolic' (Proof m) c -- | Run a symbolic computation, and return a extra value paired up with the 'Result' runSymbolic' :: SBVRunMode -> Symbolic a -> IO (a, Result) runSymbolic' currentRunMode (Symbolic c) = do ctr <- newIORef (-2) -- start from -2; False and True will always occupy the first two elements cInfo <- newIORef [] pgm <- newIORef (SBVPgm S.empty) emap <- newIORef Map.empty cmap <- newIORef Map.empty inps <- newIORef [] outs <- newIORef [] tables <- newIORef Map.empty arrays <- newIORef IMap.empty uis <- newIORef Map.empty cgs <- newIORef Map.empty axioms <- newIORef [] swCache <- newIORef IMap.empty aiCache <- newIORef IMap.empty usedKinds <- newIORef Set.empty cstrs <- newIORef [] asserts <- newIORef [] rGen <- case currentRunMode of Concrete g -> newIORef g _ -> newStdGen >>= newIORef let st = State { runMode = currentRunMode , pathCond = SVal KBool (Left trueCW) , rStdGen = rGen , rCInfo = cInfo , rctr = ctr , rUsedKinds = usedKinds , rinps = inps , routs = outs , rtblMap = tables , spgm = pgm , rconstMap = cmap , rArrayMap = arrays , rexprMap = emap , rUIMap = uis , rCgMap = cgs , raxioms = axioms , rSWCache = swCache , rAICache = aiCache , rConstraints = cstrs , rAsserts = asserts } _ <- newConst st falseCW -- s(-2) == falseSW _ <- newConst st trueCW -- s(-1) == trueSW r <- runReaderT c st res <- extractSymbolicSimulationState st return (r, res) -- | Grab the program from a running symbolic simulation state. This is useful for internal purposes, for -- instance when implementing 'sBranch'. extractSymbolicSimulationState :: State -> IO Result extractSymbolicSimulationState st@State{ spgm=pgm, rinps=inps, routs=outs, rtblMap=tables, rArrayMap=arrays, rUIMap=uis, raxioms=axioms , rAsserts=asserts, rUsedKinds=usedKinds, rCgMap=cgs, rCInfo=cInfo, rConstraints=cstrs} = do SBVPgm rpgm <- readIORef pgm inpsO <- reverse `fmap` readIORef inps outsO <- reverse `fmap` readIORef outs let swap (a, b) = (b, a) swapc ((_, a), b) = (b, a) cmp (a, _) (b, _) = a `compare` b arrange (i, (at, rt, es)) = ((i, at, rt), es) cnsts <- (sortBy cmp . map swapc . Map.toList) `fmap` readIORef (rconstMap st) tbls <- (map arrange . sortBy cmp . map swap . Map.toList) `fmap` readIORef tables arrs <- IMap.toAscList `fmap` readIORef arrays unint <- Map.toList `fmap` readIORef uis axs <- reverse `fmap` readIORef axioms knds <- readIORef usedKinds cgMap <- Map.toList `fmap` readIORef cgs traceVals <- reverse `fmap` readIORef cInfo extraCstrs <- reverse `fmap` readIORef cstrs assertions <- reverse `fmap` readIORef asserts return $ Result knds traceVals cgMap inpsO cnsts tbls arrs unint axs (SBVPgm rpgm) extraCstrs assertions outsO -- | Handling constraints imposeConstraint :: SVal -> Symbolic () imposeConstraint c = do st <- ask case runMode st of CodeGen -> error "SBV: constraints are not allowed in code-generation" _ -> liftIO $ internalConstraint st c -- | Require a boolean condition to be true in the state. Only used for internal purposes. internalConstraint :: State -> SVal -> IO () internalConstraint st b = do v <- svToSW st b modifyIORef (rConstraints st) (v:) -- | Add a constraint with a given probability addSValConstraint :: Maybe Double -> SVal -> SVal -> Symbolic () addSValConstraint Nothing c _ = imposeConstraint c addSValConstraint (Just t) c c' | t < 0 || t > 1 = error $ "SBV: pConstrain: Invalid probability threshold: " ++ show t ++ ", must be in [0, 1]." | True = do st <- ask unless (isConcreteMode st) $ error "SBV: pConstrain only allowed in 'genTest' or 'quickCheck' contexts." case () of () | t > 0 && t < 1 -> liftIO (throwDice st) >>= \d -> imposeConstraint (if d <= t then c else c') | t > 0 -> imposeConstraint c | True -> imposeConstraint c' -- | Mark an interim result as an output. Useful when constructing Symbolic programs -- that return multiple values, or when the result is programmatically computed. outputSVal :: SVal -> Symbolic () outputSVal (SVal _ (Left c)) = do st <- ask sw <- liftIO $ newConst st c liftIO $ modifyIORef (routs st) (sw:) outputSVal (SVal _ (Right f)) = do st <- ask sw <- liftIO $ uncache f st liftIO $ modifyIORef (routs st) (sw:) --------------------------------------------------------------------------------- -- * Symbolic Arrays --------------------------------------------------------------------------------- -- | Arrays implemented in terms of SMT-arrays: -- -- * Maps directly to SMT-lib arrays -- -- * Reading from an unintialized value is OK and yields an unspecified result -- -- * Can check for equality of these arrays -- -- * Cannot quick-check theorems using @SArr@ values -- -- * Typically slower as it heavily relies on SMT-solving for the array theory -- data SArr = SArr (Kind, Kind) (Cached ArrayIndex) -- | Read the array element at @a@ readSArr :: SArr -> SVal -> SVal readSArr (SArr (_, bk) f) a = SVal bk $ Right $ cache r where r st = do arr <- uncacheAI f st i <- svToSW st a newExpr st bk (SBVApp (ArrRead arr) [i]) -- | Reset all the elements of the array to the value @b@ resetSArr :: SArr -> SVal -> SArr resetSArr (SArr ainfo f) b = SArr ainfo $ cache g where g st = do amap <- readIORef (rArrayMap st) val <- svToSW st b i <- uncacheAI f st let j = IMap.size amap j `seq` modifyIORef (rArrayMap st) (IMap.insert j ("array_" ++ show j, ainfo, ArrayReset i val)) return j -- | Update the element at @a@ to be @b@ writeSArr :: SArr -> SVal -> SVal -> SArr writeSArr (SArr ainfo f) a b = SArr ainfo $ cache g where g st = do arr <- uncacheAI f st addr <- svToSW st a val <- svToSW st b amap <- readIORef (rArrayMap st) let j = IMap.size amap j `seq` modifyIORef (rArrayMap st) (IMap.insert j ("array_" ++ show j, ainfo, ArrayMutate arr addr val)) return j -- | Merge two given arrays on the symbolic condition -- Intuitively: @mergeArrays cond a b = if cond then a else b@. -- Merging pushes the if-then-else choice down on to elements mergeSArr :: SVal -> SArr -> SArr -> SArr mergeSArr t (SArr ainfo a) (SArr _ b) = SArr ainfo $ cache h where h st = do ai <- uncacheAI a st bi <- uncacheAI b st ts <- svToSW st t amap <- readIORef (rArrayMap st) let k = IMap.size amap k `seq` modifyIORef (rArrayMap st) (IMap.insert k ("array_" ++ show k, ainfo, ArrayMerge ts ai bi)) return k -- | Create a named new array, with an optional initial value newSArr :: (Kind, Kind) -> (Int -> String) -> Maybe SVal -> Symbolic SArr newSArr ainfo mkNm mbInit = do st <- ask amap <- liftIO $ readIORef $ rArrayMap st let i = IMap.size amap nm = mkNm i actx <- liftIO $ case mbInit of Nothing -> return $ ArrayFree Nothing Just ival -> svToSW st ival >>= \sw -> return $ ArrayFree (Just sw) liftIO $ modifyIORef (rArrayMap st) (IMap.insert i (nm, ainfo, actx)) return $ SArr ainfo $ cache $ const $ return i -- | Compare two arrays for equality eqSArr :: SArr -> SArr -> SVal eqSArr (SArr _ a) (SArr _ b) = SVal KBool $ Right $ cache c where c st = do ai <- uncacheAI a st bi <- uncacheAI b st newExpr st KBool (SBVApp (ArrEq ai bi) []) --------------------------------------------------------------------------------- -- * Cached values --------------------------------------------------------------------------------- -- | We implement a peculiar caching mechanism, applicable to the use case in -- implementation of SBV's. Whenever we do a state based computation, we do -- not want to keep on evaluating it in the then-current state. That will -- produce essentially a semantically equivalent value. Thus, we want to run -- it only once, and reuse that result, capturing the sharing at the Haskell -- level. This is similar to the "type-safe observable sharing" work, but also -- takes into the account of how symbolic simulation executes. -- -- See Andy Gill's type-safe obervable sharing trick for the inspiration behind -- this technique: -- -- Note that this is *not* a general memo utility! newtype Cached a = Cached (State -> IO a) -- | Cache a state-based computation cache :: (State -> IO a) -> Cached a cache = Cached -- | Uncache a previously cached computation uncache :: Cached SW -> State -> IO SW uncache = uncacheGen rSWCache -- | An array index is simple an int value type ArrayIndex = Int -- | Uncache, retrieving array indexes uncacheAI :: Cached ArrayIndex -> State -> IO ArrayIndex uncacheAI = uncacheGen rAICache -- | Generic uncaching. Note that this is entirely safe, since we do it in the IO monad. uncacheGen :: (State -> IORef (Cache a)) -> Cached a -> State -> IO a uncacheGen getCache (Cached f) st = do let rCache = getCache st stored <- readIORef rCache sn <- f `seq` makeStableName f let h = hashStableName sn case maybe Nothing (sn `lookup`) (h `IMap.lookup` stored) of Just r -> return r Nothing -> do r <- f st r `seq` modifyIORef rCache (IMap.insertWith (++) h [(sn, r)]) return r -- | Representation of SMTLib Program versions. As of June 2015, we're dropping support -- for SMTLib1, and supporting SMTLib2 only. We keep this data-type around in case -- SMTLib3 comes along and we want to support 2 and 3 simultaneously. data SMTLibVersion = SMTLib2 deriving (Bounded, Enum, Eq, Show) -- | The extension associated with the version smtLibVersionExtension :: SMTLibVersion -> String smtLibVersionExtension SMTLib2 = "smt2" -- | Representation of an SMT-Lib program. In between pre and post goes the refuted models data SMTLibPgm = SMTLibPgm SMTLibVersion ( [(String, SW)] -- alias table , [String] -- pre: declarations. , [String]) -- post: formula instance NFData SMTLibVersion where rnf a = a `seq` () instance NFData SMTLibPgm where rnf (SMTLibPgm v (t, d, p)) = rnf v `seq` rnf t `seq` rnf d `seq` rnf p `seq` () instance Show SMTLibPgm where show (SMTLibPgm _ (_, pre, post)) = intercalate "\n" $ pre ++ post -- Other Technicalities.. instance NFData CW where rnf (CW x y) = x `seq` y `seq` () #if MIN_VERSION_base(4,9,0) #else -- Can't really force this, but not a big deal instance NFData CallStack where rnf _ = () #endif instance NFData Result where rnf (Result kindInfo qcInfo cgs inps consts tbls arrs uis axs pgm cstr asserts outs) = rnf kindInfo `seq` rnf qcInfo `seq` rnf cgs `seq` rnf inps `seq` rnf consts `seq` rnf tbls `seq` rnf arrs `seq` rnf uis `seq` rnf axs `seq` rnf pgm `seq` rnf cstr `seq` rnf asserts `seq` rnf outs instance NFData Kind where rnf a = seq a () instance NFData ArrayContext where rnf a = seq a () instance NFData SW where rnf a = seq a () instance NFData SBVExpr where rnf a = seq a () instance NFData Quantifier where rnf a = seq a () instance NFData SBVType where rnf a = seq a () instance NFData SBVPgm where rnf a = seq a () instance NFData (Cached a) where rnf (Cached f) = f `seq` () instance NFData SVal where rnf (SVal x y) = rnf x `seq` rnf y `seq` () instance NFData SMTResult where rnf (Unsatisfiable _) = () rnf (Satisfiable _ xs) = rnf xs `seq` () rnf (Unknown _ xs) = rnf xs `seq` () rnf (ProofError _ xs) = rnf xs `seq` () rnf (TimeOut _) = () instance NFData SMTModel where rnf (SMTModel assocs) = rnf assocs `seq` () instance NFData SMTScript where rnf (SMTScript b m) = rnf b `seq` rnf m `seq` () -- | SMT-Lib logics. If left unspecified SBV will pick the logic based on what it determines is needed. However, the -- user can override this choice using the 'useLogic' parameter to the configuration. This is especially handy if -- one is experimenting with custom logics that might be supported on new solvers. See -- for the official list. data SMTLibLogic = AUFLIA -- ^ Formulas over the theory of linear integer arithmetic and arrays extended with free sort and function symbols but restricted to arrays with integer indices and values | AUFLIRA -- ^ Linear formulas with free sort and function symbols over one- and two-dimentional arrays of integer index and real value | AUFNIRA -- ^ Formulas with free function and predicate symbols over a theory of arrays of arrays of integer index and real value | LRA -- ^ Linear formulas in linear real arithmetic | QF_ABV -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays | QF_AUFBV -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with free sort and function symbols | QF_AUFLIA -- ^ Quantifier-free linear formulas over the theory of integer arrays extended with free sort and function symbols | QF_AX -- ^ Quantifier-free formulas over the theory of arrays with extensionality | QF_BV -- ^ Quantifier-free formulas over the theory of fixed-size bitvectors | QF_IDL -- ^ Difference Logic over the integers. Boolean combinations of inequations of the form x - y < b where x and y are integer variables and b is an integer constant | QF_LIA -- ^ Unquantified linear integer arithmetic. In essence, Boolean combinations of inequations between linear polynomials over integer variables | QF_LRA -- ^ Unquantified linear real arithmetic. In essence, Boolean combinations of inequations between linear polynomials over real variables. | QF_NIA -- ^ Quantifier-free integer arithmetic. | QF_NRA -- ^ Quantifier-free real arithmetic. | QF_RDL -- ^ Difference Logic over the reals. In essence, Boolean combinations of inequations of the form x - y < b where x and y are real variables and b is a rational constant. | QF_UF -- ^ Unquantified formulas built over a signature of uninterpreted (i.e., free) sort and function symbols. | QF_UFBV -- ^ Unquantified formulas over bitvectors with uninterpreted sort function and symbols. | QF_UFIDL -- ^ Difference Logic over the integers (in essence) but with uninterpreted sort and function symbols. | QF_UFLIA -- ^ Unquantified linear integer arithmetic with uninterpreted sort and function symbols. | QF_UFLRA -- ^ Unquantified linear real arithmetic with uninterpreted sort and function symbols. | QF_UFNRA -- ^ Unquantified non-linear real arithmetic with uninterpreted sort and function symbols. | UFLRA -- ^ Linear real arithmetic with uninterpreted sort and function symbols. | UFNIA -- ^ Non-linear integer arithmetic with uninterpreted sort and function symbols. | QF_FPBV -- ^ Quantifier-free formulas over the theory of floating point numbers, arrays, and bit-vectors | QF_FP -- ^ Quantifier-free formulas over the theory of floating point numbers deriving Show -- | Chosen logic for the solver data Logic = PredefinedLogic SMTLibLogic -- ^ Use one of the logics as defined by the standard | CustomLogic String -- ^ Use this name for the logic instance Show Logic where show (PredefinedLogic l) = show l show (CustomLogic s) = s -- | Translation tricks needed for specific capabilities afforded by each solver data SolverCapabilities = SolverCapabilities { capSolverName :: String -- ^ Name of the solver , mbDefaultLogic :: Bool -> Maybe String -- ^ set-logic string to use in case not automatically determined (if any). If Bool is True, then reals are present. , supportsMacros :: Bool -- ^ Does the solver understand SMT-Lib2 macros? , supportsProduceModels :: Bool -- ^ Does the solver understand produce-models option setting , supportsQuantifiers :: Bool -- ^ Does the solver understand SMT-Lib2 style quantifiers? , supportsUninterpretedSorts :: Bool -- ^ Does the solver understand SMT-Lib2 style uninterpreted-sorts , supportsUnboundedInts :: Bool -- ^ Does the solver support unbounded integers? , supportsReals :: Bool -- ^ Does the solver support reals? , supportsFloats :: Bool -- ^ Does the solver support single-precision floating point numbers? , supportsDoubles :: Bool -- ^ Does the solver support double-precision floating point numbers? } -- | Rounding mode to be used for the IEEE floating-point operations. -- Note that Haskell's default is 'RoundNearestTiesToEven'. If you use -- a different rounding mode, then the counter-examples you get may not -- match what you observe in Haskell. data RoundingMode = RoundNearestTiesToEven -- ^ Round to nearest representable floating point value. -- If precisely at half-way, pick the even number. -- (In this context, /even/ means the lowest-order bit is zero.) | RoundNearestTiesToAway -- ^ Round to nearest representable floating point value. -- If precisely at half-way, pick the number further away from 0. -- (That is, for positive values, pick the greater; for negative values, pick the smaller.) | RoundTowardPositive -- ^ Round towards positive infinity. (Also known as rounding-up or ceiling.) | RoundTowardNegative -- ^ Round towards negative infinity. (Also known as rounding-down or floor.) | RoundTowardZero -- ^ Round towards zero. (Also known as truncation.) deriving (Eq, Ord, Show, Read, G.Data, Bounded, Enum) -- | 'RoundingMode' kind instance HasKind RoundingMode -- | Solver configuration. See also 'z3', 'yices', 'cvc4', 'boolector', 'mathSAT', etc. which are instantiations of this type for those solvers, with -- reasonable defaults. In particular, custom configuration can be created by varying those values. (Such as @z3{verbose=True}@.) -- -- Most fields are self explanatory. The notion of precision for printing algebraic reals stems from the fact that such values does -- not necessarily have finite decimal representations, and hence we have to stop printing at some depth. It is important to -- emphasize that such values always have infinite precision internally. The issue is merely with how we print such an infinite -- precision value on the screen. The field 'printRealPrec' controls the printing precision, by specifying the number of digits after -- the decimal point. The default value is 16, but it can be set to any positive integer. -- -- When printing, SBV will add the suffix @...@ at the and of a real-value, if the given bound is not sufficient to represent the real-value -- exactly. Otherwise, the number will be written out in standard decimal notation. Note that SBV will always print the whole value if it -- is precise (i.e., if it fits in a finite number of digits), regardless of the precision limit. The limit only applies if the representation -- of the real value is not finite, i.e., if it is not rational. -- -- The 'printBase' field can be used to print numbers in base 2, 10, or 16. If base 2 or 16 is used, then floating-point values will -- be printed in their internal memory-layout format as well, which can come in handy for bit-precise analysis. data SMTConfig = SMTConfig { verbose :: Bool -- ^ Debug mode , timing :: Bool -- ^ Print timing information on how long different phases took (construction, solving, etc.) , sBranchTimeOut :: Maybe Int -- ^ How much time to give to the solver for each call of 'sBranch' check. (In seconds. Default: No limit.) , timeOut :: Maybe Int -- ^ How much time to give to the solver. (In seconds. Default: No limit.) , printBase :: Int -- ^ Print integral literals in this base (2, 10, and 16 are supported.) , printRealPrec :: Int -- ^ Print algebraic real values with this precision. (SReal, default: 16) , solverTweaks :: [String] -- ^ Additional lines of script to give to the solver (user specified) , satCmd :: String -- ^ Usually "(check-sat)". However, users might tweak it based on solver characteristics. , isNonModelVar :: String -> Bool -- ^ When constructing a model, ignore variables whose name satisfy this predicate. (Default: (const False), i.e., don't ignore anything) , smtFile :: Maybe FilePath -- ^ If Just, the generated SMT script will be put in this file (for debugging purposes mostly) , smtLibVersion :: SMTLibVersion -- ^ What version of SMT-lib we use for the tool , solver :: SMTSolver -- ^ The actual SMT solver. , roundingMode :: RoundingMode -- ^ Rounding mode to use for floating-point conversions , useLogic :: Maybe Logic -- ^ If Nothing, pick automatically. Otherwise, either use the given one, or use the custom string. } instance Show SMTConfig where show = show . solver -- | A model, as returned by a solver data SMTModel = SMTModel { modelAssocs :: [(String, CW)] -- ^ Mapping of symbolic values to constants. } deriving Show -- | The result of an SMT solver call. Each constructor is tagged with -- the 'SMTConfig' that created it so that further tools can inspect it -- and build layers of results, if needed. For ordinary uses of the library, -- this type should not be needed, instead use the accessor functions on -- it. (Custom Show instances and model extractors.) data SMTResult = Unsatisfiable SMTConfig -- ^ Unsatisfiable | Satisfiable SMTConfig SMTModel -- ^ Satisfiable with model | Unknown SMTConfig SMTModel -- ^ Prover returned unknown, with a potential (possibly bogus) model | ProofError SMTConfig [String] -- ^ Prover errored out | TimeOut SMTConfig -- ^ Computation timed out (see the 'timeout' combinator) -- | A script, to be passed to the solver. data SMTScript = SMTScript { scriptBody :: String -- ^ Initial feed , scriptModel :: Maybe String -- ^ Optional continuation script, if the result is sat } -- | An SMT engine type SMTEngine = SMTConfig -> Bool -> [(Quantifier, NamedSymVar)] -> [Either SW (SW, [SW])] -> String -> IO SMTResult -- | Solvers that SBV is aware of data Solver = Z3 | Yices | Boolector | CVC4 | MathSAT | ABC deriving (Show, Enum, Bounded) -- | An SMT solver data SMTSolver = SMTSolver { name :: Solver -- ^ The solver in use , executable :: String -- ^ The path to its executable , options :: [String] -- ^ Options to provide to the solver , engine :: SMTEngine -- ^ The solver engine, responsible for interpreting solver output , capabilities :: SolverCapabilities -- ^ Various capabilities of the solver } instance Show SMTSolver where show = show . name {-# ANN type FPOp ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/Data/SBV/Bridge/0000755000000000000000000000000012725411265013125 5ustar0000000000000000sbv-5.12/Data/SBV/Bridge/ABC.hs0000644000000000000000000001165212725411265014053 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.ABC -- Copyright : (c) Adam Foltzer -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the ABC verification and synthesis tool. Import this -- module if you want to use ABC as your backend solver. Also see: -- -- - "Data.SBV.Bridge.Boolector" -- -- - "Data.SBV.Bridge.CVC4" -- -- - "Data.SBV.Bridge.MathSAT" -- -- - "Data.SBV.Bridge.Yices" -- -- - "Data.SBV.Bridge.Z3" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.ABC ( -- * ABC specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to abc. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = abc -- | Prove theorems, using ABC prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using ABC sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using ABC safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using ABC allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using ABC isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using ABC isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using ABC isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using ABC optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using ABC minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using ABC maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Bridge/Boolector.hs0000644000000000000000000001233612725411265015416 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.Boolector -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the Boolector SMT solver. Import this module if you want to use the -- Boolector SMT prover as your backend solver. Also see: -- -- - "Data.SBV.Bridge.ABC" -- -- - "Data.SBV.Bridge.CVC4" -- -- - "Data.SBV.Bridge.MathSAT" -- -- - "Data.SBV.Bridge.Yices" -- -- - "Data.SBV.Bridge.Z3" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.Boolector ( -- * Boolector specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize -- * Non-Boolector specific SBV interface -- $moduleExportIntro , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to Boolector. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = boolector -- | Prove theorems, using the Boolector SMT solver prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using the Boolector SMT solver sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using the Boolector SMT solver safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using the Boolector SMT solver allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Boolector SMT solver isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using the Boolector SMT solver isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Boolector SMT solver isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using the Boolector SMT solver optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using the Boolector SMT solver minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using the Boolector SMT solver maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Bridge/CVC4.hs0000644000000000000000000001221112725411265014155 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.CVC4 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the CVC4 SMT solver. Import this module if you want to use the -- CVC4 SMT prover as your backend solver. Also see: -- -- - "Data.SBV.Bridge.ABC" -- -- - "Data.SBV.Bridge.Boolector" -- -- - "Data.SBV.Bridge.MathSAT" -- -- - "Data.SBV.Bridge.Yices" -- -- - "Data.SBV.Bridge.Z3" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.CVC4 ( -- * CVC4 specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize -- * Non-CVC4 specific SBV interface -- $moduleExportIntro , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to cvc4. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = cvc4 -- | Prove theorems, using the CVC4 SMT solver prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using the CVC4 SMT solver sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using the CVC4 SMT solver safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using the CVC4 SMT solver allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the CVC4 SMT solver isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using the CVC4 SMT solver isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using the CVC4 SMT solver isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using the CVC4 SMT solver optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using the CVC4 SMT solver minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using the CVC4 SMT solver maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Bridge/MathSAT.hs0000644000000000000000000001227412725411265014730 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.MathSAT -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the MathSAT SMT solver. Import this module if you want to use the -- MathSAT SMT prover as your backend solver. Also see: -- -- - "Data.SBV.Bridge.ABC" -- -- - "Data.SBV.Bridge.Boolector" -- -- - "Data.SBV.Bridge.CVC4" -- -- - "Data.SBV.Bridge.Yices" -- -- - "Data.SBV.Bridge.Z3" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.MathSAT ( -- * MathSAT specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize -- * Non-MathSAT specific SBV interface -- $moduleExportIntro , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to MathSAT. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = mathSAT -- | Prove theorems, using the MathSAT SMT solver prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using the MathSAT SMT solver sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using the MathSAT SMT solver safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using the MathSAT SMT solver allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the MathSAT SMT solver isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using the MathSAT SMT solver isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using the MathSAT SMT solver isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using the MathSAT SMT solver optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using the MathSAT SMT solver minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using the MathSAT SMT solver maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Bridge/Yices.hs0000644000000000000000000001223212725411265014535 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.Yices -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the Yices SMT solver. Import this module if you want to use the -- Yices SMT prover as your backend solver. Also see: -- -- - "Data.SBV.Bridge.ABC" -- -- - "Data.SBV.Bridge.Boolector" -- -- - "Data.SBV.Bridge.CVC4" -- -- - "Data.SBV.Bridge.MathSAT" -- -- - "Data.SBV.Bridge.Z3" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.Yices ( -- * Yices specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize -- * Non-Yices specific SBV interface -- $moduleExportIntro , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to yices. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = yices -- | Prove theorems, using the Yices SMT solver prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using the Yices SMT solver sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using the Yices SMT solver safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using the Yices SMT solver allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Yices SMT solver isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using the Yices SMT solver isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Yices SMT solver isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using the Yices SMT solver optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using the Yices SMT solver minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using the Yices SMT solver maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Bridge/Z3.hs0000644000000000000000000001214712725411265013762 0ustar0000000000000000--------------------------------------------------------------------------------- -- | -- Module : Data.SBV.Bridge.Z3 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Interface to the Z3 SMT solver. Import this module if you want to use the -- Z3 SMT prover as your backend solver. Also see: -- -- - "Data.SBV.Bridge.ABC" -- -- - "Data.SBV.Bridge.Boolector" -- -- - "Data.SBV.Bridge.CVC4" -- -- - "Data.SBV.Bridge.MathSAT" -- -- - "Data.SBV.Bridge.Yices" -- --------------------------------------------------------------------------------- module Data.SBV.Bridge.Z3 ( -- * Z3 specific interface sbvCurrentSolver -- ** Proving, checking satisfiability , prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable -- ** Optimization routines , optimize, minimize, maximize -- * Non-Z3 specific SBV interface -- $moduleExportIntro , module Data.SBV ) where import Data.SBV hiding (prove, sat, safe, allSat, isVacuous, isTheorem, isSatisfiable, optimize, minimize, maximize, sbvCurrentSolver) -- | Current solver instance, pointing to z3. sbvCurrentSolver :: SMTConfig sbvCurrentSolver = z3 -- | Prove theorems, using the Z3 SMT solver prove :: Provable a => a -- ^ Property to check -> IO ThmResult -- ^ Response from the SMT solver, containing the counter-example if found prove = proveWith sbvCurrentSolver -- | Find satisfying solutions, using the Z3 SMT solver sat :: Provable a => a -- ^ Property to check -> IO SatResult -- ^ Response of the SMT Solver, containing the model if found sat = satWith sbvCurrentSolver -- | Check all 'sAssert' calls are safe, using the Z3 SMT solver safe :: SExecutable a => a -- ^ Program containing sAssert calls -> IO [SafeResult] safe = safeWith sbvCurrentSolver -- | Find all satisfying solutions, using the Z3 SMT solver allSat :: Provable a => a -- ^ Property to check -> IO AllSatResult -- ^ List of all satisfying models allSat = allSatWith sbvCurrentSolver -- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Z3 SMT solver isVacuous :: Provable a => a -- ^ Property to check -> IO Bool -- ^ True if the constraints are unsatisifiable isVacuous = isVacuousWith sbvCurrentSolver -- | Check if the statement is a theorem, with an optional time-out in seconds, using the Z3 SMT solver isTheorem :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expires isTheorem = isTheoremWith sbvCurrentSolver -- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Z3 SMT solver isSatisfiable :: Provable a => Maybe Int -- ^ Optional time-out, specify in seconds -> a -- ^ Property to check -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers isSatisfiable = isSatisfiableWith sbvCurrentSolver -- | Optimize cost functions, using the Z3 SMT solver optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> (SBV c -> SBV c -> SBool) -- ^ Betterness check: This is the comparison predicate for optimization -> ([SBV a] -> SBV c) -- ^ Cost function -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution optimize = optimizeWith sbvCurrentSolver -- | Minimize cost functions, using the Z3 SMT solver minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to minimize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution minimize = minimizeWith sbvCurrentSolver -- | Maximize cost functions, using the Z3 SMT solver maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -- ^ Parameters to optimization (Iterative, Quantified, etc.) -> ([SBV a] -> SBV c) -- ^ Cost function to maximize -> Int -- ^ Number of inputs -> ([SBV a] -> SBool) -- ^ Validity function -> IO (Maybe [a]) -- ^ Returns Nothing if there is no valid solution, otherwise an optimal solution maximize = maximizeWith sbvCurrentSolver {- $moduleExportIntro The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module. -} sbv-5.12/Data/SBV/Compilers/0000755000000000000000000000000012725411266013667 5ustar0000000000000000sbv-5.12/Data/SBV/Compilers/C.hs0000644000000000000000000014471312725411266014417 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Compilers.C -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Compilation of symbolic programs to C ----------------------------------------------------------------------------- {-# LANGUAGE CPP #-} {-# LANGUAGE PatternGuards #-} module Data.SBV.Compilers.C(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 System.FilePath (takeBaseName, replaceExtension) import System.Random import Text.PrettyPrint.HughesPJ import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.PrettyNum (shex, showCFloat, showCDouble) import Data.SBV.Compilers.CodeGen import GHC.Stack.Compat #if !MIN_VERSION_base(4,9,0) import GHC.SrcLoc.Compat #endif --------------------------------------------------------------------------- -- * API --------------------------------------------------------------------------- -- | Given a symbolic computation, render it as an equivalent collection of files -- that make up a C program: -- -- * The first argument is the directory name under which the files will be saved. To save -- files in the current directory pass @'Just' \".\"@. Use 'Nothing' for printing to stdout. -- -- * The second argument is the name of the C function to generate. -- -- * The final argument is the function to be compiled. -- -- Compilation will also generate a @Makefile@, a header file, and a driver (test) program, etc. compileToC :: Maybe FilePath -> String -> SBVCodeGen () -> IO () compileToC mbDirName nm f = compileToC' nm f >>= renderCgPgmBundle mbDirName -- | Lower level version of 'compileToC', producing a 'CgPgmBundle' compileToC' :: String -> SBVCodeGen () -> IO CgPgmBundle compileToC' nm f = do rands <- randoms `fmap` 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 ())] -> IO () compileToCLib mbDirName libName comps = compileToCLib' libName comps >>= renderCgPgmBundle mbDirName -- | Lower level version of 'compileToCLib', producing a 'CgPgmBundle' compileToCLib' :: String -> [(String, SBVCodeGen ())] -> IO CgPgmBundle compileToCLib' libName comps = mergeToLib libName `fmap` mapM (uncurry compileToC') comps --------------------------------------------------------------------------- -- * Implementation --------------------------------------------------------------------------- -- token for the target language data SBVToC = SBVToC instance CgTarget SBVToC where targetName _ = "C" translate _ = cgen -- Unexpected input, or things we will probably never support die :: String -> a die msg = error $ "SBV->C: Unexpected: " ++ msg -- Unsupported features, or features TBD tbd :: String -> a tbd msg = error $ "SBV->C: Not yet supported: " ++ msg cgen :: 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 = 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 = 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 SW -> Doc pprCFunHeader fn ins outs mbRet = retType <+> text fn <> parens (fsep (punctuate comma (map mkParam ins ++ map mkPParam outs))) where retType = case mbRet of Nothing -> text "void" Just sw -> pprCWord False sw mkParam, mkPParam :: (String, CgVal) -> Doc mkParam (n, CgAtomic sw) = pprCWord True sw <+> text n mkParam (_, CgArray []) = die "mkParam: CgArray with no elements!" mkParam (n, CgArray (sw:_)) = pprCWord True sw <+> text "*" <> text n mkPParam (n, CgAtomic sw) = pprCWord False sw <+> text "*" <> text n mkPParam (_, CgArray []) = die "mPkParam: CgArray with no elements!" mkPParam (n, CgArray (sw:_)) = pprCWord False sw <+> text "*" <> text n -- | Renders as "const SWord8 s0", etc. the first parameter is the width of the typefield declSW :: Int -> SW -> Doc declSW w sw = text "const" <+> pad (showCType sw) <+> text (show sw) where pad s = text $ s ++ replicate (w - length s) ' ' -- | Return the proper declaration and the result as a pair. No consts declSWNoConst :: Int -> SW -> (Doc, Doc) declSWNoConst w sw = (text " " <+> pad (showCType sw), text (show sw)) where pad s = text $ s ++ replicate (w - length s) ' ' -- | Renders as "s0", etc, or the corresponding constant showSW :: CgConfig -> [(SW, CW)] -> SW -> Doc showSW cfg consts sw | sw == falseSW = text "false" | sw == trueSW = text "true" | Just cw <- sw `lookup` consts = mkConst cfg cw | True = text $ show sw -- | 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. 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 -> SW -> Doc specifier cfg sw = case kindOf sw of 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 KUserSort s _ -> die $ "uninterpreted sort: " ++ s where spec :: (Bool, Int) -> Doc spec (False, 1) = text "%d" spec (False, 8) = 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 "%.6g" -- float.h: __FLT_DIG__ specF CgDouble = text "%.15g" -- float.h: __DBL_DIG__ 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 -> CW -> Doc mkConst cfg (CW KReal (CWAlgReal (AlgRational _ r))) = double (fromRational r :: Double) <> sRealSuffix (fromJust (cgReal cfg)) where sRealSuffix CgFloat = text "F" sRealSuffix CgDouble = empty sRealSuffix CgLongDouble = text "L" mkConst cfg (CW KUnbounded (CWInteger i)) = showSizedConst i (True, fromJust (cgInteger cfg)) mkConst _ (CW (KBounded sg sz) (CWInteger i)) = showSizedConst i (sg, sz) mkConst _ (CW KBool (CWInteger i)) = showSizedConst i (False, 1) mkConst _ (CW KFloat (CWFloat f)) = text $ showCFloat f mkConst _ (CW KDouble (CWDouble d)) = text $ showCDouble d mkConst _ cw = die $ "mkConst: " ++ show cw showSizedConst :: Integer -> (Bool, Int) -> Doc showSizedConst i (False, 1) = text (if i == 0 then "false" else "true") showSizedConst i (False, 8) = integer i showSizedConst i (True, 8) = integer i showSizedConst i t@(False, 16) = text (shex False True t i) <> text "U" showSizedConst i t@(True, 16) = text (shex False True t i) showSizedConst i t@(False, 32) = text (shex False True t i) <> text "UL" showSizedConst i t@(True, 32) = text (shex False True t i) <> text "L" showSizedConst i t@(False, 64) = text (shex False True t i) <> text "ULL" showSizedConst i t@(True, 64) = text (shex False True t i) <> text "LL" showSizedConst i (True, 1) = die $ "Signed 1-bit value " ++ show 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 <> 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?=" <> text (unwords ldFlags)) , (True, text "") , (ifdr, text "all:" <+> nmd) , (ifdr, text "") , (True, nmo <> text (": " ++ ppSameLine (hsep [nmc, nmh]))) , (True, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") , (True, text "") , (ifdr, nmdo <> text ":" <+> nmdc) , (ifdr, text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@") , (ifdr, text "") , (ifdr, nmd <> 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 <> text ".h" nmc = nm <> text ".c" nmo = nm <> text ".o" nmdc = nmd <> text ".c" nmdo = nmd <> 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 <> 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 (<> semi) sigs) $$ text "" $$ protos $$ text "#endif /*" <+> tag <+> text "*/" $$ text "" where nm = text fn tag = text "__" <> nm <> 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 SW -> [Doc] genDriver cfg randVals fn inps outs mbRet = [pre, header, body, post] where pre = text "/* Example driver program for" <+> nm <> text ". */" $$ text "/* Automatically generated by SBV. Edit as you see fit! */" $$ text "" $$ text "#include " header = text "#include" <+> doubleQuotes (nm <> text ".h") $$ text "" $$ text "int main(void)" $$ text "{" body = text "" $$ nest 2 ( vcat (map mkInp pairedInputs) $$ vcat (map mkOut outs) $$ sepIf (not (null [() | (_, _, CgArray{}) <- pairedInputs]) || not (null outs)) $$ call $$ text "" $$ (case mbRet of Just sw -> text "printf" <> parens (printQuotes (fcall <+> text "=" <+> specifier cfg sw <> text "\\n") <> comma <+> resultVar) <> semi Nothing -> text "printf" <> parens (printQuotes (fcall <+> text "->\\n")) <> semi) $$ vcat (map display outs) ) post = text "" $+$ nest 2 (text "return 0" <> semi) $$ text "}" $$ text "" nm = text fn pairedInputs = matchRands (map abs randVals) inps matchRands _ [] = [] matchRands [] _ = die "Run out of driver values!" matchRands (r:rs) ((n, CgAtomic sw) : cs) = ([mkRVal sw r], n, CgAtomic sw) : matchRands rs cs matchRands _ ((n, CgArray []) : _ ) = die $ "Unsupported empty array input " ++ show n matchRands rs ((n, a@(CgArray sws@(sw:_))) : cs) | length frs /= l = die "Run out of driver values!" | True = (map (mkRVal sw) frs, n, a) : matchRands srs cs where l = length sws (frs, srs) = splitAt l rs mkRVal sw r = mkConst cfg $ mkConstCW (kindOf sw) 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@(sw:_)) = pprCWord True sw <+> text n <> brackets (int (length sws)) <+> text "= {" $$ nest 4 (fsep (punctuate comma (align vs))) $$ text "};" $$ text "" $$ text "printf" <> parens (printQuotes (text "Contents of input array" <+> text n <> text ":\\n")) <> semi $$ display (n, CgArray sws) $$ text "" mkOut (v, CgAtomic sw) = pprCWord False sw <+> text v <> semi mkOut (v, CgArray []) = die $ "Unsupported empty array value for " ++ show v mkOut (v, CgArray sws@(sw:_)) = pprCWord False sw <+> text v <> brackets (int (length sws)) <> semi resultVar = text "__result" call = case mbRet of Nothing -> fcall <> semi Just sw -> pprCWord True sw <+> resultVar <+> text "=" <+> fcall <> semi fcall = nm <> parens (fsep (punctuate comma (map mkCVal pairedInputs ++ map mkOVal outs))) mkCVal ([v], _, CgAtomic{}) = v mkCVal (vs, n, CgAtomic{}) = die $ "Unexpected driver value computed for " ++ show n ++ render (hcat vs) mkCVal (_, n, CgArray{}) = text n mkOVal (n, CgAtomic{}) = text "&" <> text n mkOVal (n, CgArray{}) = text n display (n, CgAtomic sw) = text "printf" <> parens (printQuotes (text " " <+> text n <+> text "=" <+> specifier cfg sw <> text "\\n") <> comma <+> text n) <> semi display (n, CgArray []) = die $ "Unsupported empty array value for " ++ show n display (n, CgArray sws@(sw:_)) = text "int" <+> nctr <> semi $$ text "for(" <> nctr <+> text "= 0;" <+> nctr <+> text "<" <+> int (length sws) <+> text "; ++" <> nctr <> text ")" $$ nest 2 (text "printf" <> parens (printQuotes (text " " <+> entrySpec <+> text "=" <+> spec <> text "\\n") <> comma <+> nctr <+> comma <> entry) <> semi) where nctr = text n <> text "_ctr" entry = text n <> text "[" <> nctr <> text "]" entrySpec = text n <> text "[%d]" spec = specifier cfg sw -- | Generate the C program genCProg :: CgConfig -> String -> Doc -> Result -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SW -> Doc -> [Doc] genCProg cfg fn proto (Result kindInfo _tvals cgs ins preConsts tbls arrs _ _ (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." | 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 usorts) = error $ "SBV->C: Cannot compile functions with uninterpreted sorts: " ++ intercalate ", " usorts | not (null cstrs) = tbd "Explicit constraints" | not (null arrs) = tbd "User specified arrays" | needsExistentials (map fst ins) = error "SBV->C: Cannot compile functions with existentially quantified variables." | True = [pre, header, post] where asserts | cgIgnoreAsserts cfg = [] | True = origAsserts usorts = [s | KUserSort s _ <- Set.toList kindInfo, s /= "RoundingMode"] -- No support for any sorts other than RoundingMode! pre = text "/* File:" <+> doubleQuotes (nm <> text ".c") <> text ". Automatically generated by SBV. Do not edit! */" $$ text "" header = text "#include" <+> doubleQuotes (nm <> text ".h") 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) (zip (repeat True) outVars)) $$ maybe empty mkRet mbRet ) $$ text "}" $$ text "" nm = text fn assignments = F.toList asgns codeSeg (fnm, ls) = text "/* User specified custom code for" <+> doubleQuotes (text fnm) <+> text "*/" $$ vcat (map text ls) $$ text "" typeWidth = getMax 0 $ [len (kindOf s) | (s, _) <- assignments] ++ [len (kindOf s) | (_, (s, _)) <- ins] where len KReal{} = 5 len KFloat{} = 6 -- SFloat len KDouble{} = 7 -- SDouble 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 (KUserSort s _) = die $ "Uninterpreted sort: " ++ 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 = (falseSW, falseCW) : (trueSW, trueCW) : 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 sw) = sw `Set.member` usedVariables isAlive (_, _) = True genIO :: Bool -> (Bool, (String, CgVal)) -> [Doc] genIO True (alive, (cNm, CgAtomic sw)) = [declSW typeWidth sw <+> text "=" <+> text cNm <> semi | alive] genIO False (alive, (cNm, CgAtomic sw)) = [text "*" <> text cNm <+> text "=" <+> showSW cfg consts sw <> semi | alive] genIO isInp (_, (cNm, CgArray sws)) = zipWith genElt sws [(0::Int)..] where genElt sw i | isInp = declSW typeWidth sw <+> text "=" <+> text entry <> semi | True = text entry <+> text "=" <+> showSW cfg consts sw <> semi where entry = cNm ++ "[" ++ show i ++ "]" mkRet sw = text "return" <+> showSW cfg consts sw <> semi genTbl :: ((Int, Kind, Kind), [SW]) -> (Int, Doc) genTbl ((i, _, k), elts) = (location, static <+> text "const" <+> text (show k) <+> text ("table" ++ show i) <> text "[] = {" $$ nest 4 (fsep (punctuate comma (align (map (showSW cfg consts) elts)))) $$ text "};") where static = if location == -1 then text "static" else empty location = maximum (-1 : map getNodeId elts) getNodeId s@(SW _ (NodeId n)) | isConst s = -1 | True = n genAsgn :: (SW, SBVExpr) -> (Int, Doc) genAsgn (sw, n) = (getNodeId sw, ppExpr cfg consts n (declSW typeWidth sw) (declSWNoConst typeWidth sw) <> 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, sw) = (getNodeId sw, doc) where doc = text "/* ASSERTION:" <+> text msg $$ maybe empty (vcat . map text) (locInfo (getCallStack `fmap` cs)) $$ text " */" $$ text "if" <> parens (showSW cfg consts sw) $$ 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 handleIEEE :: FPOp -> [(SW, CW)] -> [(SW, Doc)] -> Doc -> Doc handleIEEE w consts as var = cvt w where same f = (f, f) named fnm dnm f = (f fnm, f dnm) castToUnsigned f to = parens (text "!isnan" <> parens a <+> text "&&" <+> text "signbit" <> parens a) <+> text "?" <+> cvt1 <+> text ":" <+> cvt2 where [a] = map snd fpArgs absA = text (if f == KFloat then "fabsf" else "fabs") <> parens a cvt1 = parens (text "-" <+> parens (parens (text (show to)) <+> absA)) cvt2 = parens (parens (text (show to)) <+> a) cvt (FP_Cast f to m) = case checkRM (m `lookup` consts) of Nothing -> if f `elem` [KFloat, KDouble] && not (hasSign to) then castToUnsigned f to else cast $ \[a] -> parens (text (show to)) <+> a Just (Left msg) -> die msg Just (Right msg) -> tbd msg 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 "&" <> var arhs = text "&" <> a in text "memcpy" <> parens (fsep (punctuate comma [alhs, arhs, text sz])) cvt FP_Abs = dispatch $ named "fabsf" "fabs" $ \nm _ [a] -> text nm <> parens a cvt FP_Neg = dispatch $ same $ \_ [a] -> text "-" <> 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 <> parens (fsep (punctuate comma [a, b, c])) cvt FP_Sqrt = dispatch $ named "sqrtf" "sqrt" $ \nm _ [a] -> text nm <> parens a cvt FP_Rem = dispatch $ named "fmodf" "fmod" $ \nm _ [a, b] -> text nm <> parens (fsep (punctuate comma [a, b])) cvt FP_RoundToIntegral = dispatch $ named "rintf" "rint" $ \nm _ [a] -> text nm <> parens a cvt FP_Min = dispatch $ named "fminf" "fmin" $ \nm k [a, b] -> wrapMinMax k a b (text nm <> parens (fsep (punctuate comma [a, b]))) cvt FP_Max = dispatch $ named "fmaxf" "fmax" $ \nm k [a, b] -> wrapMinMax k a b (text nm <> parens (fsep (punctuate comma [a, b]))) cvt FP_ObjEqual = let mkIte x y z = x <+> text "?" <+> y <+> text ":" <+> z chkNaN x = text "isnan" <> parens x signbit x = text "signbit" <> 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" <> parens a cvt FP_IsSubnormal = dispatch $ same $ \_ [a] -> text "FP_SUBNORMAL == fpclassify" <> parens a cvt FP_IsZero = dispatch $ same $ \_ [a] -> text "FP_ZERO == fpclassify" <> parens a cvt FP_IsInfinite = dispatch $ same $ \_ [a] -> text "isinf" <> parens a cvt FP_IsNaN = dispatch $ same $ \_ [a] -> text "isnan" <> parens a cvt FP_IsNegative = dispatch $ same $ \_ [a] -> text "!isnan" <> parens a <+> text "&&" <+> text "signbit" <> parens a cvt FP_IsPositive = dispatch $ same $ \_ [a] -> text "!isnan" <> parens a <+> text "&&" <+> text "!signbit" <> parens a -- grab the rounding-mode, if present, and make sure it's RoundNearestTiesToEven. Otherwise skip. fpArgs = case as of [] -> [] ((m, _):args) -> case kindOf m of KUserSort "RoundingMode" _ -> case checkRM (m `lookup` consts) of Nothing -> args Just (Left msg) -> die msg Just (Right msg) -> tbd msg _ -> 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@(CW (KUserSort "RoundingMode" _) v)) = case v of CWUserSort (_, "RoundNearestTiesToEven") -> Nothing CWUserSort (_, 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 "?" <+> zero <+> text ":" <+> s where zero = text $ if k == KFloat then showCFloat 0 else showCDouble 0 cond = parens (text "FP_ZERO == fpclassify" <> parens a) -- a is zero <+> text "&&" <+> parens (text "FP_ZERO == fpclassify" <> parens b) -- b is zero <+> text "&&" <+> parens (text "signbit" <> parens a <+> text "!=" <+> text "signbit" <> parens b) -- a and b differ in sign ppExpr :: CgConfig -> [(SW, CW)] -> SBVExpr -> Doc -> (Doc, Doc) -> Doc ppExpr cfg consts (SBVApp op opArgs) lhs (typ, var) | doNotAssign op = typ <+> var <> 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 (showSW cfg consts) opArgs) rtc = cgRTC cfg cBinOps = [ (Plus, "+"), (Times, "*"), (Minus, "-") , (Equal, "=="), (NotEqual, "!="), (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=") , (And, "&"), (Or, "|"), (XOr, "^") ] p :: Op -> [Doc] -> Doc p (ArrRead _) _ = tbd "User specified arrays (ArrRead)" p (ArrEq _ _) _ = tbd "User specified arrays (ArrEq)" p (Label s) [a] = a <+> text "/*" <+> text s <+> text "*/" p (IEEEFP w) as = handleIEEE w consts (zip opArgs as) var p (IntCast _ to) [a] = parens (text (show to)) <+> a p (Uninterpreted s) [] = text "/* Uninterpreted constant */" <+> text s p (Uninterpreted s) as = text "/* Uninterpreted function */" <+> text s <> parens (fsep (punctuate comma as)) p (Extract i j) [a] = extract i j (head opArgs) a p Join [a, b] = join (let (s1 : s2 : _) = opArgs in (s1, s2, a, b)) p (Rol i) [a] = rotate True i a (head opArgs) p (Ror i) [a] = rotate False i a (head opArgs) p (Shl i) [a] = shift True i a (head opArgs) p (Shr i) [a] = shift False i a (head opArgs) p Not [a] = case kindOf (head opArgs) of -- be careful about booleans, bitwise complement is not correct for them! KBool -> text "!" <> a _ -> text "~" <> 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 (showSW cfg consts) [ind, def] lkUp = text "table" <> int t <> brackets (showSW 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 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" KUnbounded -> case cgInteger cfg of Nothing -> (True, True) -- won't matter, it'll be rejected later Just i -> (True, canOverflow True i) KUserSort s _ -> die $ "Uninterpreted sort: " ++ 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 (head opArgs) z = mkConst cfg $ mkConstCW k (0::Integer) in protectDiv0 k "/" z a b p Rem [a, b] = protectDiv0 (kindOf (head opArgs)) "%" a a b p UNeg [a] = parens (text "-" <+> a) p Abs [a] = let f = case kindOf (head opArgs) of KFloat -> text "fabsf" KDouble -> text "fabs" _ -> text "abs" in f <> parens a -- for And/Or, translate to boolean versions if on boolean kind p And [a, b] | kindOf (head opArgs) == KBool = a <+> text "&&" <+> b p Or [a, b] | kindOf (head opArgs) == KBool = a <+> text "||" <+> b p o [a, b] | Just co <- lookup o cBinOps = a <+> text co <+> b p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args -- 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 s | i < 0 = shift (not toLeft) (-i) a s | i == 0 = a | True = case kindOf s of KBounded _ sz | i >= sz -> mkConst cfg $ mkConstCW (kindOf s) (0::Integer) KReal -> tbd $ "Shift for real quantity: " ++ show (toLeft, i, s) _ -> a <+> text cop <+> int 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 i a s -- 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 = text "(SBool)" <+> parens (parens (a <+> text ">>" <+> int hi) <+> text "& 1") extract hi lo i a = case (hi, lo, kindOf i) of (63, 32, KBounded False 64) -> text "(SWord32)" <+> parens (a <+> text ">> 32") (31, 0, KBounded False 64) -> text "(SWord32)" <+> a (31, 16, KBounded False 32) -> text "(SWord16)" <+> parens (a <+> text ">> 16") (15, 0, KBounded False 32) -> text "(SWord16)" <+> a (15, 8, KBounded False 16) -> text "(SWord8)" <+> parens (a <+> text ">> 8") ( 7, 0, KBounded False 16) -> text "(SWord8)" <+> a (63, 0, KBounded False 64) -> text "(SInt64)" <+> a (63, 0, KBounded True 64) -> text "(SWord64)" <+> a (31, 0, KBounded False 32) -> text "(SInt32)" <+> a (31, 0, KBounded True 32) -> text "(SWord32)" <+> a (15, 0, KBounded False 16) -> text "(SInt16)" <+> a (15, 0, KBounded True 16) -> text "(SWord16)" <+> a ( 7, 0, KBounded False 8) -> text "(SInt8)" <+> a ( 7, 0, KBounded True 8) -> text "(SWord8)" <+> a ( _, _, k ) -> tbd $ "extract with " ++ show (hi, lo, k, i) -- 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 mergeToLib :: String -> [CgPgmBundle] -> CgPgmBundle mergeToLib libName bundles | length nubKinds /= 1 = error $ "Cannot merge programs with differing SInteger/SReal mappings. Received the following kinds:\n" ++ unlines (map show nubKinds) | True = CgPgmBundle bundleKind $ sources ++ libHeader : [libDriver | anyDriver] ++ [libMake | anyMake] where kinds = [k | CgPgmBundle k _ <- bundles] nubKinds = nub kinds bundleKind = head nubKinds 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))) -- | 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 <> 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?=" <> 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 <> text (": " ++ unwords os)) , (True, text "\t${AR} ${ARFLAGS} $@ $^") , (True, text "") , (ifdr, text libd <> 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 <> text (": " ++ unwords [f, libh]) $$ text "\t${CC} ${CCFLAGS} -c $< -o $@" $$ text "" -- | Create a driver for a library mergeDrivers :: String -> Doc -> [(FilePath, [Doc])] -> [Doc] mergeDrivers libName inc ds = pre : concatMap mkDFun ds ++ [callDrivers (map fst ds)] where pre = text "/* Example driver program for" <+> text libName <> text ". */" $$ text "/* Automatically generated by SBV. Edit as you see fit! */" $$ text "" $$ text "#include " $$ 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\");" {-# ANN module ("HLint: ignore Redundant lambda" :: String) #-} sbv-5.12/Data/SBV/Compilers/CodeGen.hs0000644000000000000000000003742112725411266015536 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Compilers.CodeGen -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Code generation utilities ----------------------------------------------------------------------------- {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Data.SBV.Compilers.CodeGen where import Control.Monad (filterM, replicateM, unless) import Control.Monad.Trans import Control.Monad.State.Lazy (MonadState, StateT(..), modify) import Data.Char (toLower, isSpace) import Data.List (nub, isPrefixOf, intercalate, (\\)) import System.Directory (createDirectory, doesDirectoryExist, doesFileExist) import System.FilePath (()) import Text.PrettyPrint.HughesPJ (Doc, vcat) import qualified Text.PrettyPrint.HughesPJ as P (render) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Symbolic (svToSymSW, svMkSymVar, outputSVal) import Prelude () import Prelude.Compat -- | Abstract over code generation for different languages class CgTarget a where targetName :: a -> String translate :: a -> CgConfig -> String -> CgState -> Result -> CgPgmBundle -- | Options for code-generation. data CgConfig = CgConfig { cgRTC :: Bool -- ^ If 'True', perform run-time-checks for index-out-of-bounds or shifting-by-large values etc. , 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 'sAssert' calls } -- | Default options for code generation. The run-time checks are turned-off, and the driver values are completely random. defaultCgConfig :: CgConfig defaultCgConfig = CgConfig { cgRTC = False , cgInteger = Nothing , cgReal = Nothing , cgDriverVals = [] , cgGenDriver = True , cgGenMakefile = True , cgIgnoreAsserts = False } -- | Abstraction of target language values data CgVal = CgAtomic SW | CgArray [SW] -- | Code-generation state data CgState = CgState { cgInputs :: [(String, CgVal)] , cgOutputs :: [(String, CgVal)] , cgReturns :: [CgVal] , cgPrototypes :: [String] -- extra stuff that goes into the header , cgDecls :: [String] -- extra stuff that goes into the top of the file , cgLDFlags :: [String] -- extra options that go to the linker , cgFinalConfig :: CgConfig } -- | Initial configuration for code-generation initCgState :: CgState initCgState = CgState { cgInputs = [] , cgOutputs = [] , cgReturns = [] , cgPrototypes = [] , cgDecls = [] , cgLDFlags = [] , cgFinalConfig = defaultCgConfig } -- | The code-generation monad. Allows for precise layout of input values -- reference parameters (for returning composite values in languages such as C), -- and return values. newtype SBVCodeGen a = SBVCodeGen (StateT CgState Symbolic a) deriving (Applicative, Functor, Monad, MonadIO, MonadState CgState) -- | Reach into symbolic monad from code-generation liftSymbolic :: Symbolic a -> SBVCodeGen a liftSymbolic = SBVCodeGen . lift -- | Reach into symbolic monad and output a value. Returns the corresponding SW cgSBVToSW :: SBV a -> SBVCodeGen SW cgSBVToSW = liftSymbolic . sbvToSymSW -- | Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off. Default: 'False'. cgPerformRTCs :: Bool -> SBVCodeGen () cgPerformRTCs b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRTC = b } }) -- | Sets number of bits to be used for representing the 'SInteger' type in the generated C code. -- The argument must be one of @8@, @16@, @32@, or @64@. Note that this is essentially unsafe as -- the semantics of unbounded Haskell integers becomes reduced to the corresponding bit size, as -- typical in most C implementations. cgIntegerSize :: Int -> SBVCodeGen () cgIntegerSize i | i `notElem` [8, 16, 32, 64] = error $ "SBV.cgIntegerSize: Argument must be one of 8, 16, 32, or 64. Received: " ++ show i | True = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgInteger = Just i }}) -- | Possible mappings for the 'SReal' type when translated to C. Used in conjunction -- with the function 'cgSRealType'. Note that the particular characteristics of the -- mapped types depend on the platform and the compiler used for compiling the generated -- C program. See for details. data CgSRealType = CgFloat -- ^ @float@ | CgDouble -- ^ @double@ | CgLongDouble -- ^ @long double@ deriving Eq -- | 'Show' instance for 'cgSRealType' displays values as they would be used in a C program instance Show CgSRealType where show CgFloat = "float" show CgDouble = "double" show CgLongDouble = "long double" -- | Sets the C type to be used for representing the 'SReal' type in the generated C code. -- 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. cgSRealType :: CgSRealType -> SBVCodeGen () cgSRealType rt = modify (\s -> s {cgFinalConfig = (cgFinalConfig s) { cgReal = Just rt }}) -- | Should we generate a driver program? Default: 'True'. When a library is generated, it will have -- a driver if any of the contituent functions has a driver. (See 'compileToCLib'.) cgGenerateDriver :: Bool -> SBVCodeGen () cgGenerateDriver b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenDriver = b } }) -- | Should we generate a Makefile? Default: 'True'. cgGenerateMakefile :: Bool -> SBVCodeGen () cgGenerateMakefile b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenMakefile = b } }) -- | Sets driver program run time values, useful for generating programs with fixed drivers for testing. Default: None, i.e., use random values. cgSetDriverValues :: [Integer] -> SBVCodeGen () cgSetDriverValues vs = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgDriverVals = vs } }) -- | Ignore assertions (those generated by 'sAssert' calls) in the generated C code cgIgnoreSAssert :: Bool -> SBVCodeGen () cgIgnoreSAssert b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgIgnoreAsserts = b } }) -- | Adds the given lines to the header file generated, useful for generating programs with uninterpreted functions. cgAddPrototype :: [String] -> SBVCodeGen () cgAddPrototype ss = modify (\s -> let old = cgPrototypes s new = if null old then ss else old ++ [""] ++ ss in s { cgPrototypes = new }) -- | Adds the given lines to the program file generated, useful for generating programs with uninterpreted functions. cgAddDecl :: [String] -> SBVCodeGen () cgAddDecl ss = modify (\s -> s { cgDecls = cgDecls s ++ ss }) -- | Adds the given words to the compiler options in the generated Makefile, useful for linking extra stuff in. cgAddLDFlags :: [String] -> SBVCodeGen () cgAddLDFlags ss = modify (\s -> s { cgLDFlags = cgLDFlags s ++ ss }) -- | Creates an atomic input in the generated code. svCgInput :: Kind -> String -> SBVCodeGen SVal svCgInput k nm = do r <- liftSymbolic (svMkSymVar (Just ALL) k Nothing) sw <- liftSymbolic (svToSymSW r) modify (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s }) return r -- | Creates an array input in the generated code. svCgInputArr :: Kind -> Int -> String -> SBVCodeGen [SVal] svCgInputArr k sz nm | sz < 1 = error $ "SBV.cgInputArr: Array inputs must have at least one element, given " ++ show sz ++ " for " ++ show nm | True = do rs <- liftSymbolic $ replicateM sz (svMkSymVar (Just ALL) k Nothing) sws <- liftSymbolic $ mapM svToSymSW rs modify (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s }) return rs -- | Creates an atomic output in the generated code. svCgOutput :: String -> SVal -> SBVCodeGen () svCgOutput nm v = do _ <- liftSymbolic (outputSVal v) sw <- liftSymbolic (svToSymSW v) modify (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s }) -- | Creates an array output in the generated code. svCgOutputArr :: String -> [SVal] -> SBVCodeGen () svCgOutputArr nm vs | sz < 1 = error $ "SBV.cgOutputArr: Array outputs must have at least one element, received " ++ show sz ++ " for " ++ show nm | True = do _ <- liftSymbolic (mapM outputSVal vs) sws <- liftSymbolic (mapM svToSymSW vs) modify (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s }) where sz = length vs -- | Creates a returned (unnamed) value in the generated code. svCgReturn :: SVal -> SBVCodeGen () svCgReturn v = do _ <- liftSymbolic (outputSVal v) sw <- liftSymbolic (svToSymSW v) modify (\s -> s { cgReturns = CgAtomic sw : cgReturns s }) -- | Creates a returned (unnamed) array value in the generated code. svCgReturnArr :: [SVal] -> SBVCodeGen () svCgReturnArr vs | sz < 1 = error $ "SBV.cgReturnArr: Array returns must have at least one element, received " ++ show sz | True = do _ <- liftSymbolic (mapM outputSVal vs) sws <- liftSymbolic (mapM svToSymSW vs) modify (\s -> s { cgReturns = CgArray sws : cgReturns s }) where sz = length vs -- | Creates an atomic input in the generated code. cgInput :: SymWord a => String -> SBVCodeGen (SBV a) cgInput nm = do r <- liftSymbolic forall_ sw <- cgSBVToSW r modify (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s }) return r -- | Creates an array input in the generated code. cgInputArr :: SymWord a => Int -> String -> SBVCodeGen [SBV a] cgInputArr sz nm | sz < 1 = error $ "SBV.cgInputArr: Array inputs must have at least one element, given " ++ show sz ++ " for " ++ show nm | True = do rs <- liftSymbolic $ mapM (const forall_) [1..sz] sws <- mapM cgSBVToSW rs modify (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s }) return rs -- | Creates an atomic output in the generated code. cgOutput :: String -> SBV a -> SBVCodeGen () cgOutput nm v = do _ <- liftSymbolic (output v) sw <- cgSBVToSW v modify (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s }) -- | Creates an array output in the generated code. cgOutputArr :: SymWord a => String -> [SBV a] -> SBVCodeGen () cgOutputArr nm vs | sz < 1 = error $ "SBV.cgOutputArr: Array outputs must have at least one element, received " ++ show sz ++ " for " ++ show nm | True = do _ <- liftSymbolic (mapM output vs) sws <- mapM cgSBVToSW vs modify (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s }) where sz = length vs -- | Creates a returned (unnamed) value in the generated code. cgReturn :: SBV a -> SBVCodeGen () cgReturn v = do _ <- liftSymbolic (output v) sw <- cgSBVToSW v modify (\s -> s { cgReturns = CgAtomic sw : cgReturns s }) -- | Creates a returned (unnamed) array value in the generated code. cgReturnArr :: SymWord a => [SBV a] -> SBVCodeGen () cgReturnArr vs | sz < 1 = error $ "SBV.cgReturnArr: Array returns must have at least one element, received " ++ show sz | True = do _ <- liftSymbolic (mapM output vs) sws <- mapM cgSBVToSW vs modify (\s -> s { cgReturns = CgArray sws : cgReturns s }) where sz = length vs -- | Representation of a collection of generated programs. data CgPgmBundle = CgPgmBundle (Maybe Int, Maybe CgSRealType) [(FilePath, (CgPgmKind, [Doc]))] -- | Different kinds of "files" we can produce. Currently this is quite "C" specific. data CgPgmKind = CgMakefile [String] | CgHeader [Doc] | CgSource | CgDriver -- | Is this a driver program? isCgDriver :: CgPgmKind -> Bool isCgDriver CgDriver = True isCgDriver _ = False -- | Is this a make file? isCgMakefile :: CgPgmKind -> Bool isCgMakefile CgMakefile{} = True isCgMakefile _ = False -- | A simple way to print bundles, mostly for debugging purposes. instance Show CgPgmBundle where show (CgPgmBundle _ fs) = intercalate "\n" $ map showFile fs where showFile :: (FilePath, (CgPgmKind, [Doc])) -> String showFile (f, (_, ds)) = "== BEGIN: " ++ show f ++ " ================\n" ++ render' (vcat ds) ++ "== END: " ++ show f ++ " ==================" -- | Generate code for a symbolic program, returning a Code-gen bundle, i.e., collection -- of makefiles, source code, headers, etc. codeGen :: CgTarget l => l -> CgConfig -> String -> SBVCodeGen () -> IO CgPgmBundle codeGen l cgConfig nm (SBVCodeGen comp) = do (((), st'), res) <- runSymbolic' CodeGen $ runStateT comp initCgState { cgFinalConfig = cgConfig } let st = st' { cgInputs = reverse (cgInputs st') , cgOutputs = reverse (cgOutputs st') } allNamedVars = map fst (cgInputs st ++ cgOutputs st) dupNames = allNamedVars \\ nub allNamedVars unless (null dupNames) $ error $ "SBV.codeGen: " ++ show nm ++ " has following argument names duplicated: " ++ unwords dupNames return $ translate l (cgFinalConfig st) nm st res -- | Render a code-gen bundle to a directory or to stdout renderCgPgmBundle :: Maybe FilePath -> CgPgmBundle -> IO () renderCgPgmBundle Nothing bundle = print bundle renderCgPgmBundle (Just dirName) (CgPgmBundle _ files) = do b <- doesDirectoryExist dirName unless b $ do putStrLn $ "Creating directory " ++ show dirName ++ ".." createDirectory dirName dups <- filterM (\fn -> doesFileExist (dirName fn)) (map fst files) goOn <- case dups of [] -> return True _ -> do putStrLn $ "Code generation would override the following " ++ (if length dups == 1 then "file:" else "files:") mapM_ (\fn -> putStrLn ('\t' : fn)) dups putStr "Continue? [yn] " resp <- getLine return $ map toLower resp `isPrefixOf` "yes" if goOn then do mapM_ renderFile files putStrLn "Done." else putStrLn "Aborting." where renderFile (f, (_, ds)) = do let fn = dirName f putStrLn $ "Generating: " ++ show fn ++ ".." writeFile fn (render' (vcat ds)) -- | An alternative to Pretty's 'render', which might have "leading" white-space in empty lines. This version -- eliminates such whitespace. render' :: Doc -> String render' = unlines . map clean . lines . P.render where clean x | all isSpace x = "" | True = x sbv-5.12/Data/SBV/Examples/0000755000000000000000000000000012725411265013507 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/BitPrecise/0000755000000000000000000000000012725411265015540 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/BitPrecise/BitTricks.hs0000644000000000000000000000465212725411265020001 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.BitPrecise.BitTricks -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Checks the correctness of a few tricks from the large collection found in: -- ----------------------------------------------------------------------------- module Data.SBV.Examples.BitPrecise.BitTricks where import Data.SBV -- | Formalizes fastMinCorrect :: SInt32 -> SInt32 -> SBool fastMinCorrect x y = m .== fm where m = ite (x .< y) x y fm = y `xor` ((x `xor` y) .&. (-(oneIf (x .< y)))); -- | Formalizes fastMaxCorrect :: SInt32 -> SInt32 -> SBool fastMaxCorrect x y = m .== fm where m = ite (x .< y) y x fm = x `xor` ((x `xor` y) .&. (-(oneIf (x .< y)))); -- | Formalizes oppositeSignsCorrect :: SInt32 -> SInt32 -> SBool oppositeSignsCorrect x y = r .== os where r = (x .< 0 &&& y .>= 0) ||| (x .>= 0 &&& y .< 0) os = (x `xor` y) .< 0 -- | Formalizes conditionalSetClearCorrect :: SBool -> SWord32 -> SWord32 -> SBool conditionalSetClearCorrect f m w = r .== r' where r = ite f (w .|. m) (w .&. complement m) r' = w `xor` ((-(oneIf f) `xor` w) .&. m); -- | Formalizes powerOfTwoCorrect :: SWord32 -> SBool powerOfTwoCorrect v = f .== s where f = (v ./= 0) &&& ((v .&. (v-1)) .== 0); powers :: [Word32] powers = map ((2::Word32)^) [(0::Word32) .. 31] s = bAny (v .==) $ map literal powers -- | Collection of queries queries :: IO () queries = let check :: Provable a => String -> a -> IO () check w t = do putStr $ "Proving " ++ show w ++ ": " print =<< prove t in do check "Fast min " fastMinCorrect check "Fast max " fastMaxCorrect check "Opposite signs " oppositeSignsCorrect check "Conditional set/clear" conditionalSetClearCorrect check "PowerOfTwo " powerOfTwoCorrect sbv-5.12/Data/SBV/Examples/BitPrecise/Legato.hs0000644000000000000000000003056712725411265017322 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.BitPrecise.Legato -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- An encoding and correctness proof of Legato's multiplier in Haskell. Bill Legato came -- up with an interesting way to multiply two 8-bit numbers on Mostek, as described here: -- -- -- Here's Legato's algorithm, as coded in Mostek assembly: -- -- @ -- step1 : LDX #8 ; load X immediate with the integer 8 -- step2 : LDA #0 ; load A immediate with the integer 0 -- step3 : LOOP ROR F1 ; rotate F1 right circular through C -- step4 : BCC ZCOEF ; branch to ZCOEF if C = 0 -- step5 : CLC ; set C to 0 -- step6 : ADC F2 ; set A to A+F2+C and C to the carry -- step7 : ZCOEF ROR A ; rotate A right circular through C -- step8 : ROR LOW ; rotate LOW right circular through C -- step9 : DEX ; set X to X-1 -- step10: BNE LOOP ; branch to LOOP if Z = 0 -- @ -- -- This program came to be known as the Legato's challenge in the community, where -- the challenge was to prove that it indeed does perform multiplication. This file -- formalizes the Mostek architecture in Haskell and proves that Legato's algorithm -- is indeed correct. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveAnyClass #-} module Data.SBV.Examples.BitPrecise.Legato where import Data.Array (Array, Ix(..), (!), (//), array) import Data.SBV import GHC.Generics (Generic) ------------------------------------------------------------------ -- * Mostek architecture ------------------------------------------------------------------ -- | The memory is addressed by 32-bit words. type Address = SWord32 -- | We model only two registers of Mostek that is used in the above algorithm, can add more. data Register = RegX | RegA deriving (Eq, Ord, Ix, Bounded, Enum) -- | The carry flag ('FlagC') and the zero flag ('FlagZ') data Flag = FlagC | FlagZ deriving (Eq, Ord, Ix, Bounded, Enum) -- | Mostek was an 8-bit machine. type Value = SWord8 -- | Convenient synonym for symbolic machine bits. type Bit = SBool -- | Register bank type Registers = Array Register Value -- | Flag bank type Flags = Array Flag Bit -- | The memory maps 32-bit words to 8-bit words. (The 'Model' data-type is -- defined later, depending on the verification model used.) type Memory = Model Word32 Word8 -- Model defined later -- | Abstraction of the machine: The CPU consists of memory, registers, and flags. -- Unlike traditional hardware, we assume the program is stored in some other memory area that -- we need not model. (No self modifying programs!) -- -- 'Mostek' is equipped with an automatically derived 'Mergeable' instance -- because each field is 'Mergeable'. data Mostek = Mostek { memory :: Memory , registers :: Registers , flags :: Flags } deriving (Generic, Mergeable) -- | Given a machine state, compute a value out of it type Extract a = Mostek -> a -- | Programs are essentially state transformers (on the machine state) type Program = Mostek -> Mostek ------------------------------------------------------------------ -- * Low-level operations ------------------------------------------------------------------ -- | Get the value of a given register getReg :: Register -> Extract Value getReg r m = registers m ! r -- | Set the value of a given register setReg :: Register -> Value -> Program setReg r v m = m {registers = registers m // [(r, v)]} -- | Get the value of a flag getFlag :: Flag -> Extract Bit getFlag f m = flags m ! f -- | Set the value of a flag setFlag :: Flag -> Bit -> Program setFlag f b m = m {flags = flags m // [(f, b)]} -- | Read memory peek :: Address -> Extract Value peek a m = readArray (memory m) a -- | Write to memory poke :: Address -> Value -> Program poke a v m = m {memory = writeArray (memory m) a v} -- | Checking overflow. In Legato's multipler the @ADC@ instruction -- needs to see if the expression x + y + c overflowed, as checked -- by this function. Note that we verify the correctness of this check -- separately below in `checkOverflowCorrect`. checkOverflow :: SWord8 -> SWord8 -> SBool -> SBool checkOverflow x y c = s .< x ||| s .< y ||| s' .< s where s = x + y s' = s + ite c 1 0 -- | Correctness theorem for our `checkOverflow` implementation. -- -- We have: -- -- >>> checkOverflowCorrect -- Q.E.D. checkOverflowCorrect :: IO ThmResult checkOverflowCorrect = checkOverflow === overflow where -- Reference spec for overflow. We do the addition -- using 16 bits and check that it's larger than 255 overflow :: SWord8 -> SWord8 -> SBool -> SBool overflow x y c = (0 # x) + (0 # y) + ite c 1 0 .> 255 ------------------------------------------------------------------ -- * Instruction set ------------------------------------------------------------------ -- | An instruction is modeled as a 'Program' transformer. We model -- mostek programs in direct continuation passing style. type Instruction = Program -> Program -- | LDX: Set register @X@ to value @v@ ldx :: Value -> Instruction ldx v k = k . setReg RegX v -- | LDA: Set register @A@ to value @v@ lda :: Value -> Instruction lda v k = k . setReg RegA v -- | CLC: Clear the carry flag clc :: Instruction clc k = k . setFlag FlagC false -- | ROR, memory version: Rotate the value at memory location @a@ -- to the right by 1 bit, using the carry flag as a transfer position. -- That is, the final bit of the memory location becomes the new carry -- and the carry moves over to the first bit. This very instruction -- is one of the reasons why Legato's multiplier is quite hard to understand -- and is typically presented as a verification challenge. rorM :: Address -> Instruction rorM a k m = k . setFlag FlagC c' . poke a v' $ m where v = peek a m c = getFlag FlagC m v' = setBitTo (v `rotateR` 1) 7 c c' = sTestBit v 0 -- | ROR, register version: Same as 'rorM', except through register @r@. rorR :: Register -> Instruction rorR r k m = k . setFlag FlagC c' . setReg r v' $ m where v = getReg r m c = getFlag FlagC m v' = setBitTo (v `rotateR` 1) 7 c c' = sTestBit v 0 -- | BCC: branch to label @l@ if the carry flag is false bcc :: Program -> Instruction bcc l k m = ite (c .== false) (l m) (k m) where c = getFlag FlagC m -- | ADC: Increment the value of register @A@ by the value of memory contents -- at address @a@, using the carry-bit as the carry-in for the addition. adc :: Address -> Instruction adc a k m = k . setFlag FlagZ (v' .== 0) . setFlag FlagC c' . setReg RegA v' $ m where v = peek a m ra = getReg RegA m c = getFlag FlagC m v' = v + ra + ite c 1 0 c' = checkOverflow v ra c -- | DEX: Decrement the value of register @X@ dex :: Instruction dex k m = k . setFlag FlagZ (x .== 0) . setReg RegX x $ m where x = getReg RegX m - 1 -- | BNE: Branch if the zero-flag is false bne :: Program -> Instruction bne l k m = ite (z .== false) (l m) (k m) where z = getFlag FlagZ m -- | The 'end' combinator "stops" our program, providing the final continuation -- that does nothing. end :: Program end = id ------------------------------------------------------------------ -- * Legato's algorithm in Haskell/SBV ------------------------------------------------------------------ -- | Parameterized by the addresses of locations of the factors (@F1@ and @F2@), -- the following program multiplies them, storing the low-byte of the result -- in the memory location @lowAddr@, and the high-byte in register @A@. The -- implementation is a direct transliteration of Legato's algorithm given -- at the top, using our notation. legato :: Address -> Address -> Address -> Program legato f1Addr f2Addr lowAddr = start where start = ldx 8 $ lda 0 $ loop loop = rorM f1Addr $ bcc zeroCoef $ clc $ adc f2Addr $ zeroCoef zeroCoef = rorR RegA $ rorM lowAddr $ dex $ bne loop $ end ------------------------------------------------------------------ -- * Verification interface ------------------------------------------------------------------ -- | Given address/value pairs for F1 and F2, and the location of where the low-byte -- of the result should go, @runLegato@ takes an arbitrary machine state @m@ and -- returns the high and low bytes of the multiplication. runLegato :: (Address, Value) -> (Address, Value) -> Address -> Mostek -> (Value, Value) runLegato (f1Addr, f1Val) (f2Addr, f2Val) loAddr m = (getReg RegA mFinal, peek loAddr mFinal) where m0 = poke f1Addr f1Val $ poke f2Addr f2Val m mFinal = legato f1Addr f2Addr loAddr m0 -- | Helper synonym for capturing relevant bits of Mostek type InitVals = ( Value -- Content of Register X , Value -- Content of Register A , Value -- Initial contents of memory , Bit -- Value of FlagC , Bit -- Value of FlagZ ) -- | Create an instance of the Mostek machine, initialized by the memory and the relevant -- values of the registers and the flags initMachine :: Memory -> InitVals -> Mostek initMachine mem (rx, ra, mc, fc, fz) = Mostek { memory = resetArray mem mc , registers = array (minBound, maxBound) [(RegX, rx), (RegA, ra)] , flags = array (minBound, maxBound) [(FlagC, fc), (FlagZ, fz)] } -- | The correctness theorem. For all possible memory configurations, the factors (@x@ and @y@ below), the location -- of the low-byte result and the initial-values of registers and the flags, this function will return True only if -- running Legato's algorithm does indeed compute the product of @x@ and @y@ correctly. legatoIsCorrect :: Memory -> (Address, Value) -> (Address, Value) -> Address -> InitVals -> SBool legatoIsCorrect mem (addrX, x) (addrY, y) addrLow initVals = allDifferent [addrX, addrY, addrLow] -- note the conditional: addresses must be distinct! ==> result .== expected where (hi, lo) = runLegato (addrX, x) (addrY, y) addrLow (initMachine mem initVals) -- NB. perform the comparison over 16 bit values to avoid overflow! -- If Value changes to be something else, modify this accordingly. result, expected :: SWord16 result = 256 * (0 # hi) + (0 # lo) expected = (0 # x) * (0 # y) ------------------------------------------------------------------ -- * Verification ------------------------------------------------------------------ -- | Choose the appropriate array model to be used for modeling the memory. (See 'Memory'.) -- The 'SFunArray' is the function based model. 'SArray' is the SMT-Lib array's based model. type Model = SFunArray -- type Model = SArray -- | The correctness theorem. -- On a decent MacBook Pro, this proof takes about 3 minutes with the 'SFunArray' memory model -- and about 30 minutes with the 'SArray' model, using yices as the SMT solver correctnessTheorem :: IO ThmResult correctnessTheorem = proveWith yices{timing = True} $ forAll ["mem", "addrX", "x", "addrY", "y", "addrLow", "regX", "regA", "memVals", "flagC", "flagZ"] legatoIsCorrect ------------------------------------------------------------------ -- * C Code generation ------------------------------------------------------------------ -- | Generate a C program that implements Legato's algorithm automatically. legatoInC :: IO () legatoInC = compileToC Nothing "runLegato" $ do x <- cgInput "x" y <- cgInput "y" let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, 0, false, false)) cgOutput "hi" hi cgOutput "lo" lo {-# ANN legato ("HLint: ignore Redundant $" :: String) #-} {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/Data/SBV/Examples/BitPrecise/MergeSort.hs0000644000000000000000000001004712725411265020005 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.BitPrecise.MergeSort -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Symbolic implementation of merge-sort and its correctness. ----------------------------------------------------------------------------- module Data.SBV.Examples.BitPrecise.MergeSort where import Data.SBV ----------------------------------------------------------------------------- -- * Implementing Merge-Sort ----------------------------------------------------------------------------- -- | Element type of lists we'd like to sort. For simplicity, we'll just -- use 'SWord8' here, but we can pick any symbolic type. type E = SWord8 -- | Merging two given sorted lists, preserving the order. merge :: [E] -> [E] -> [E] merge [] ys = ys merge xs [] = xs merge xs@(x:xr) ys@(y:yr) = ite (x .< y) (x : merge xr ys) (y : merge xs yr) -- | Simple merge-sort implementation. We simply divide the input list -- in two two halves so long as it has at least two elements, sort -- each half on its own, and then merge. mergeSort :: [E] -> [E] mergeSort [] = [] mergeSort [x] = [x] mergeSort xs = merge (mergeSort th) (mergeSort bh) where (th, bh) = splitAt (length xs `div` 2) xs ----------------------------------------------------------------------------- -- * Proving correctness -- ${props} ----------------------------------------------------------------------------- {- $props There are two main parts to proving that a sorting algorithm is correct: * Prove that the output is non-decreasing * Prove that the output is a permutation of the input -} -- | Check whether a given sequence is non-decreasing. nonDecreasing :: [E] -> SBool nonDecreasing [] = true nonDecreasing [_] = true nonDecreasing (a:b:xs) = a .<= b &&& nonDecreasing (b:xs) -- | Check whether two given sequences are permutations. We simply check that each sequence -- is a subset of the other, when considered as a set. The check is slightly complicated -- for the need to account for possibly duplicated elements. isPermutationOf :: [E] -> [E] -> SBool isPermutationOf as bs = go as (zip bs (repeat true)) &&& go bs (zip as (repeat true)) where go [] _ = true go (x:xs) ys = let (found, ys') = mark x ys in found &&& go xs ys' -- Go and mark off an instance of 'x' in the list, if possible. We keep track -- of unmarked elements by associating a boolean bit. Note that we have to -- keep the lists equal size for the recursive result to merge properly. mark _ [] = (false, []) mark x ((y,v):ys) = ite (v &&& x .== y) (true, (y, bnot v):ys) (let (r, ys') = mark x ys in (r, (y,v):ys')) -- | Asserting correctness of merge-sort for a list of the given size. Note that we can -- only check correctness for fixed-size lists. Also, the proof will get more and more -- complicated for the backend SMT solver as 'n' increases. A value around 5 or 6 should -- be fairly easy to prove. For instance, we have: -- -- >>> correctness 5 -- Q.E.D. correctness :: Int -> IO ThmResult correctness n = prove $ do xs <- mkFreeVars n let ys = mergeSort xs return $ nonDecreasing ys &&& isPermutationOf xs ys ----------------------------------------------------------------------------- -- * Generating C code ----------------------------------------------------------------------------- -- | Generate C code for merge-sorting an array of size 'n'. Again, we're restricted -- to fixed size inputs. While the output is not how one would code merge sort in C -- by hand, it's a faithful rendering of all the operations merge-sort would do as -- described by its Haskell counterpart. codeGen :: Int -> IO () codeGen n = compileToC (Just ("mergeSort" ++ show n)) "mergeSort" $ do xs <- cgInputArr n "xs" cgOutputArr "ys" (mergeSort xs) sbv-5.12/Data/SBV/Examples/BitPrecise/MultMask.hs0000644000000000000000000000377212725411265017642 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.BitPrecise.MultMask -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- An SBV solution to the bit-precise puzzle of shuffling the bits in a -- 64-bit word in a custom order. The idea is to take a 64-bit value: -- -- @1.......2.......3.......4.......5.......6.......7.......8.......@ -- -- And turn it into another 64-bit value, that looks like this: -- -- @12345678........................................................@ -- -- We do not care what happens to the bits that are represented by dots. The -- problem is to do this with one mask and one multiplication. -- -- Apparently this operation has several applications, including in programs -- that play chess of all things. We use SBV to find the appropriate mask and -- the multiplier. -- -- Note that this is an instance of the program synthesis problem, where -- we "fill in the blanks" given a certain skeleton that satisfy a certain -- property, using quantified formulas. ----------------------------------------------------------------------------- module Data.SBV.Examples.BitPrecise.MultMask where import Data.SBV -- | Find the multiplier and the mask as described. We have: -- -- >>> maskAndMult -- Satisfiable. Model: -- mask = 0x8080808080808080 :: Word64 -- mult = 0x0002040810204081 :: Word64 -- -- That is, any 64 bit value masked by the first and multipled by the second -- value above will have its bits at positions @[7,15,23,31,39,47,55,63]@ moved -- to positions @[56,57,58,59,60,61,62,63]@ respectively. maskAndMult :: IO () maskAndMult = print =<< satWith z3{printBase=16} find where find = do mask <- exists "mask" mult <- exists "mult" inp <- forall "inp" let res = (mask .&. inp) * (mult :: SWord64) solve [inp `sExtractBits` [7, 15 .. 63] .== res `sExtractBits` [56 .. 63]] sbv-5.12/Data/SBV/Examples/BitPrecise/PrefixSum.hs0000644000000000000000000001417412725411265020025 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.BitPrecise.PrefixSum -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The PrefixSum algorithm over power-lists and proof of -- the Ladner-Fischer implementation. -- See -- and . ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Examples.BitPrecise.PrefixSum where import Data.SBV import Data.SBV.Internals (runSymbolic) ---------------------------------------------------------------------- -- * Formalizing power-lists ---------------------------------------------------------------------- -- | A poor man's representation of powerlists and -- basic operations on them: . -- We merely represent power-lists by ordinary lists. type PowerList a = [a] -- | The tie operator, concatenation. tiePL :: PowerList a -> PowerList a -> PowerList a tiePL = (++) -- | The zip operator, zips the power-lists of the same size, returns -- a powerlist of double the size. zipPL :: PowerList a -> PowerList a -> PowerList a zipPL [] [] = [] zipPL (x:xs) (y:ys) = x : y : zipPL xs ys zipPL _ _ = error "zipPL: nonsimilar powerlists received" -- | Inverse of zipping. unzipPL :: PowerList a -> (PowerList a, PowerList a) unzipPL = unzip . chunk2 where chunk2 [] = [] chunk2 (x:y:xs) = (x,y) : chunk2 xs chunk2 _ = error "unzipPL: malformed powerlist" ---------------------------------------------------------------------- -- * Reference prefix-sum implementation ---------------------------------------------------------------------- -- | Reference prefix sum (@ps@) is simply Haskell's @scanl1@ function. ps :: (a, a -> a -> a) -> PowerList a -> PowerList a ps (_, f) = scanl1 f ---------------------------------------------------------------------- -- * The Ladner-Fischer parallel version ---------------------------------------------------------------------- -- | The Ladner-Fischer (@lf@) implementation of prefix-sum. See -- or pg. 16 of . lf :: (a, a -> a -> a) -> PowerList a -> PowerList a lf _ [] = error "lf: malformed (empty) powerlist" lf _ [x] = [x] lf (zero, f) pl = zipPL (zipWith f (rsh lfpq) p) lfpq where (p, q) = unzipPL pl pq = zipWith f p q lfpq = lf (zero, f) pq rsh xs = zero : init xs ---------------------------------------------------------------------- -- * Sample proofs for concrete operators ---------------------------------------------------------------------- -- | Correctness theorem, for a powerlist of given size, an associative operator, and its left-unit element. flIsCorrect :: Int -> (forall a. (OrdSymbolic a, Num a, Bits a) => (a, a -> a -> a)) -> Symbolic SBool flIsCorrect n zf = do args :: PowerList SWord32 <- mkForallVars n return $ ps zf args .== lf zf args -- | Proves Ladner-Fischer is equivalent to reference specification for addition. -- @0@ is the left-unit element, and we use a power-list of size @8@. thm1 :: IO ThmResult thm1 = prove $ flIsCorrect 8 (0, (+)) -- | Proves Ladner-Fischer is equivalent to reference specification for the function @max@. -- @0@ is the left-unit element, and we use a power-list of size @16@. thm2 :: IO ThmResult thm2 = prove $ flIsCorrect 16 (0, smax) ---------------------------------------------------------------------- -- * Inspecting symbolic traces ---------------------------------------------------------------------- -- | A symbolic trace can help illustrate the action of Ladner-Fischer. This -- generator produces the actions of Ladner-Fischer for addition, showing how -- the computation proceeds: -- -- >>> ladnerFischerTrace 8 -- INPUTS -- s0 :: SWord8 -- s1 :: SWord8 -- s2 :: SWord8 -- s3 :: SWord8 -- s4 :: SWord8 -- s5 :: SWord8 -- s6 :: SWord8 -- s7 :: SWord8 -- CONSTANTS -- s_2 = False :: Bool -- s_1 = True :: Bool -- TABLES -- ARRAYS -- UNINTERPRETED CONSTANTS -- USER GIVEN CODE SEGMENTS -- AXIOMS -- DEFINE -- s8 :: SWord8 = s0 + s1 -- s9 :: SWord8 = s2 + s8 -- s10 :: SWord8 = s2 + s3 -- s11 :: SWord8 = s8 + s10 -- s12 :: SWord8 = s4 + s11 -- s13 :: SWord8 = s4 + s5 -- s14 :: SWord8 = s11 + s13 -- s15 :: SWord8 = s6 + s14 -- s16 :: SWord8 = s6 + s7 -- s17 :: SWord8 = s13 + s16 -- s18 :: SWord8 = s11 + s17 -- CONSTRAINTS -- ASSERTIONS -- OUTPUTS -- s0 -- s8 -- s9 -- s11 -- s12 -- s14 -- s15 -- s18 ladnerFischerTrace :: Int -> IO () ladnerFischerTrace n = gen >>= print where gen = runSymbolic (True, defaultSMTCfg) $ do args :: [SWord8] <- mkForallVars n mapM_ output $ lf (0, (+)) args -- | Trace generator for the reference spec. It clearly demonstrates that the reference -- implementation fewer operations, but is not parallelizable at all: -- -- >>> scanlTrace 8 -- INPUTS -- s0 :: SWord8 -- s1 :: SWord8 -- s2 :: SWord8 -- s3 :: SWord8 -- s4 :: SWord8 -- s5 :: SWord8 -- s6 :: SWord8 -- s7 :: SWord8 -- CONSTANTS -- s_2 = False :: Bool -- s_1 = True :: Bool -- TABLES -- ARRAYS -- UNINTERPRETED CONSTANTS -- USER GIVEN CODE SEGMENTS -- AXIOMS -- DEFINE -- s8 :: SWord8 = s0 + s1 -- s9 :: SWord8 = s2 + s8 -- s10 :: SWord8 = s3 + s9 -- s11 :: SWord8 = s4 + s10 -- s12 :: SWord8 = s5 + s11 -- s13 :: SWord8 = s6 + s12 -- s14 :: SWord8 = s7 + s13 -- CONSTRAINTS -- ASSERTIONS -- OUTPUTS -- s0 -- s8 -- s9 -- s10 -- s11 -- s12 -- s13 -- s14 -- scanlTrace :: Int -> IO () scanlTrace n = gen >>= print where gen = runSymbolic (True, defaultSMTCfg) $ do args :: [SWord8] <- mkForallVars n mapM_ output $ ps (0, (+)) args {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/Data/SBV/Examples/CodeGeneration/0000755000000000000000000000000012725411265016375 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/CodeGeneration/AddSub.hs0000644000000000000000000000766612725411265020112 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.AddSub -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Simple code generation example. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.AddSub where import Data.SBV -- | Simple function that returns add/sum of args addSub :: SWord8 -> SWord8 -> (SWord8, SWord8) addSub x y = (x+y, x-y) -- | Generate C code for addSub. Here's the output showing the generated C code: -- -- >>> genAddSub -- == BEGIN: "Makefile" ================ -- # Makefile for addSub. Automatically generated by SBV. Do not edit! -- -- # include any user-defined .mk file in the current directory. -- -include *.mk -- -- CC?=gcc -- CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer -- -- all: addSub_driver -- -- addSub.o: addSub.c addSub.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- addSub_driver.o: addSub_driver.c -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- addSub_driver: addSub.o addSub_driver.o -- ${CC} ${CCFLAGS} $^ -o $@ -- -- clean: -- rm -f *.o -- -- veryclean: clean -- rm -f addSub_driver -- == END: "Makefile" ================== -- == BEGIN: "addSub.h" ================ -- /* Header file for addSub. Automatically generated by SBV. Do not edit! */ -- -- #ifndef __addSub__HEADER_INCLUDED__ -- #define __addSub__HEADER_INCLUDED__ -- -- #include -- #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 addSub(const SWord8 x, const SWord8 y, SWord8 *sum, -- SWord8 *dif); -- -- #endif /* __addSub__HEADER_INCLUDED__ */ -- == END: "addSub.h" ================== -- == BEGIN: "addSub_driver.c" ================ -- /* Example driver program for addSub. */ -- /* Automatically generated by SBV. Edit as you see fit! */ -- -- #include -- #include "addSub.h" -- -- int main(void) -- { -- SWord8 sum; -- SWord8 dif; -- -- addSub(132, 241, &sum, &dif); -- -- printf("addSub(132, 241, &sum, &dif) ->\n"); -- printf(" sum = %"PRIu8"\n", sum); -- printf(" dif = %"PRIu8"\n", dif); -- -- return 0; -- } -- == END: "addSub_driver.c" ================== -- == BEGIN: "addSub.c" ================ -- /* File: "addSub.c". Automatically generated by SBV. Do not edit! */ -- -- #include "addSub.h" -- -- void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, -- SWord8 *dif) -- { -- const SWord8 s0 = x; -- const SWord8 s1 = y; -- const SWord8 s2 = s0 + s1; -- const SWord8 s3 = s0 - s1; -- -- *sum = s2; -- *dif = s3; -- } -- == END: "addSub.c" ================== -- 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 cgSetDriverValues [132, 241] let (s, d) = addSub x y cgOutput "sum" s cgOutput "dif" d where -- use Just "dirName" for putting the output to the named directory -- otherwise, it'll go to standard output outDir = Nothing sbv-5.12/Data/SBV/Examples/CodeGeneration/CRC_USB5.hs0000644000000000000000000000677012725411265020150 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.CRC_USB5 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computing the CRC symbolically, using the USB polynomial. We also -- generating C code for it as well. This example demonstrates the -- use of the 'crcBV' function, along with how CRC's can be computed -- mathematically using polynomial division. While the results are the -- same (i.e., proven equivalent, see 'crcGood' below), the internal -- CRC implementation generates much better code, compare 'cg1' vs 'cg2' below. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.CRC_USB5 where import Data.SBV ----------------------------------------------------------------------------- -- * The USB polynomial ----------------------------------------------------------------------------- -- | The USB CRC polynomial: @x^5 + x^2 + 1@. -- Although this polynomial needs just 6 bits to represent (5 if higher -- order bit is implicitly assumed to be set), we'll simply use a 16 bit -- number for its representation to keep things simple for code generation -- purposes. usb5 :: SWord16 usb5 = polynomial [5, 2, 0] ----------------------------------------------------------------------------- -- * Computing CRCs ----------------------------------------------------------------------------- -- | Given an 11 bit message, compute the CRC of it using the USB polynomial, -- which is 5 bits, and then append it to the msg to get a 16-bit word. Again, -- the incoming 11-bits is represented as a 16-bit word, with 5 highest bits -- essentially ignored for input purposes. crcUSB :: SWord16 -> SWord16 crcUSB i = fromBitsBE (ib ++ cb) where ib = drop 5 (blastBE i) -- only the last 11 bits needed pb = drop 11 (blastBE usb5) -- only the last 5 bits needed cb = crcBV 5 ib pb -- | Alternate method for computing the CRC, /mathematically/. We shift -- the number to the left by 5, and then compute the remainder from the -- polynomial division by the USB polynomial. The result is then appended -- to the end of the message. crcUSB' :: SWord16 -> SWord16 crcUSB' i' = i .|. pMod i usb5 where i = i' `shiftL` 5 ----------------------------------------------------------------------------- -- * Correctness ----------------------------------------------------------------------------- -- | Prove that the custom 'crcBV' function is equivalent to the mathematical -- definition of CRC's for 11 bit messages. We have: -- -- >>> crcGood -- Q.E.D. crcGood :: IO ThmResult crcGood = prove $ \i -> crcUSB i .== crcUSB' i ----------------------------------------------------------------------------- -- * Code generation ----------------------------------------------------------------------------- -- | Generate a C function to compute the USB CRC, using the internal CRC -- function. cg1 :: IO () cg1 = compileToC (Just "crcUSB1") "crcUSB1" $ do msg <- cgInput "msg" cgOutput "crc" (crcUSB msg) -- | Generate a C function to compute the USB CRC, using the mathematical -- definition of the CRCs. While this version generates functionally eqivalent -- C code, it's less efficient; it has about 30% more code. So, the above -- version is preferable for code generation purposes. cg2 :: IO () cg2 = compileToC (Just "crcUSB2") "crcUSB2" $ do msg <- cgInput "msg" cgOutput "crc" (crcUSB' msg) sbv-5.12/Data/SBV/Examples/CodeGeneration/Fibonacci.hs0000644000000000000000000002063012725411265020607 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.Fibonacci -- Copyright : (c) Lee Pike, Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computing Fibonacci numbers and generating C code. Inspired by Lee Pike's -- original implementation, modified for inclusion in the package. It illustrates -- symbolic termination issues one can have when working with recursive algorithms -- and how to deal with such, eventually generating good C code. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.Fibonacci where import Data.SBV ----------------------------------------------------------------------------- -- * A naive implementation ----------------------------------------------------------------------------- -- | This is a naive implementation of fibonacci, and will work fine (albeit slow) -- for concrete inputs: -- -- >>> map fib0 [0..6] -- [0 :: SWord64,1 :: SWord64,1 :: SWord64,2 :: SWord64,3 :: SWord64,5 :: SWord64,8 :: SWord64] -- -- However, it is not suitable for doing proofs or generating code, as it is not -- symbolically terminating when it is called with a symbolic value @n@. When we -- recursively call @fib0@ on @n-1@ (or @n-2@), the test against @0@ will always -- explore both branches since the result will be symbolic, hence will not -- terminate. (An integrated theorem prover can establish termination -- after a certain number of unrollings, but this would be quite expensive to -- implement, and would be impractical.) fib0 :: SWord64 -> SWord64 fib0 n = ite (n .== 0 ||| n .== 1) n (fib0 (n-1) + fib0 (n-2)) ----------------------------------------------------------------------------- -- * Using a recursion depth, and accumulating parameters ----------------------------------------------------------------------------- {- $genLookup One way to deal with symbolic termination is to limit the number of recursive calls. In this version, we impose a limit on the index to the function, working correctly upto that limit. If we use a compile-time constant, then SBV's code generator can produce code as the unrolling will eventually stop. -} -- | The recursion-depth limited version of fibonacci. Limiting the maximum number to be 20, we can say: -- -- >>> map (fib1 20) [0..6] -- [0 :: SWord64,1 :: SWord64,1 :: SWord64,2 :: SWord64,3 :: SWord64,5 :: SWord64,8 :: SWord64] -- -- The function will work correctly, so long as the index we query is at most @top@, and otherwise -- will return the value at @top@. Note that we also use accumulating parameters here for efficiency, -- although this is orthogonal to the termination concern. -- -- A note on modular arithmetic: The 64-bit word we use to represent the values will of course -- eventually overflow, beware! Fibonacci is a fast growing function.. fib1 :: SWord64 -> SWord64 -> SWord64 fib1 top n = fib' 0 1 0 where fib' :: SWord64 -> SWord64 -> SWord64 -> SWord64 fib' prev' prev m = ite (m .== top ||| m .== n) -- did we reach recursion depth, or the index we're looking for prev' -- stop and return the result (fib' prev (prev' + prev) (m+1)) -- otherwise recurse -- | We can generate code for 'fib1' using the 'genFib1' action. Note that the -- generated code will grow larger as we pick larger values of @top@, but only linearly, -- thanks to the accumulating parameter trick used by 'fib1'. The following is an excerpt -- from the code generated for the call @genFib1 10@, where the code will work correctly -- for indexes up to 10: -- -- > SWord64 fib1(const SWord64 x) -- > { -- > const SWord64 s0 = x; -- > const SBool s2 = s0 == 0x0000000000000000ULL; -- > const SBool s4 = s0 == 0x0000000000000001ULL; -- > const SBool s6 = s0 == 0x0000000000000002ULL; -- > const SBool s8 = s0 == 0x0000000000000003ULL; -- > const SBool s10 = s0 == 0x0000000000000004ULL; -- > const SBool s12 = s0 == 0x0000000000000005ULL; -- > const SBool s14 = s0 == 0x0000000000000006ULL; -- > const SBool s17 = s0 == 0x0000000000000007ULL; -- > const SBool s19 = s0 == 0x0000000000000008ULL; -- > const SBool s22 = s0 == 0x0000000000000009ULL; -- > const SWord64 s25 = s22 ? 0x0000000000000022ULL : 0x0000000000000037ULL; -- > const SWord64 s26 = s19 ? 0x0000000000000015ULL : s25; -- > const SWord64 s27 = s17 ? 0x000000000000000dULL : s26; -- > const SWord64 s28 = s14 ? 0x0000000000000008ULL : s27; -- > const SWord64 s29 = s12 ? 0x0000000000000005ULL : s28; -- > const SWord64 s30 = s10 ? 0x0000000000000003ULL : s29; -- > const SWord64 s31 = s8 ? 0x0000000000000002ULL : s30; -- > const SWord64 s32 = s6 ? 0x0000000000000001ULL : s31; -- > const SWord64 s33 = s4 ? 0x0000000000000001ULL : s32; -- > const SWord64 s34 = s2 ? 0x0000000000000000ULL : s33; -- > -- > return s34; -- > } genFib1 :: SWord64 -> IO () genFib1 top = compileToC Nothing "fib1" $ do x <- cgInput "x" cgReturn $ fib1 top x ----------------------------------------------------------------------------- -- * Generating a look-up table ----------------------------------------------------------------------------- {- $genLookup While 'fib1' generates good C code, we can do much better by taking advantage of the inherent partial-evaluation capabilities of SBV to generate a look-up table, as follows. -} -- | Compute the fibonacci numbers statically at /code-generation/ time and -- put them in a table, accessed by the 'select' call. fib2 :: SWord64 -> SWord64 -> SWord64 fib2 top = select table 0 where table = map (fib1 top) [0 .. top] -- | Once we have 'fib2', we can generate the C code straightforwardly. Below -- is an excerpt from the code that SBV generates for the call @genFib2 64@. Note -- that this code is a constant-time look-up table implementation of fibonacci, -- with no run-time overhead. The index can be made arbitrarily large, -- naturally. (Note that this function returns @0@ if the index is larger -- than 64, as specified by the call to 'select' with default @0@.) -- -- > SWord64 fibLookup(const SWord64 x) -- > { -- > const SWord64 s0 = x; -- > static const SWord64 table0[] = { -- > 0x0000000000000000ULL, 0x0000000000000001ULL, -- > 0x0000000000000001ULL, 0x0000000000000002ULL, -- > 0x0000000000000003ULL, 0x0000000000000005ULL, -- > 0x0000000000000008ULL, 0x000000000000000dULL, -- > 0x0000000000000015ULL, 0x0000000000000022ULL, -- > 0x0000000000000037ULL, 0x0000000000000059ULL, -- > 0x0000000000000090ULL, 0x00000000000000e9ULL, -- > 0x0000000000000179ULL, 0x0000000000000262ULL, -- > 0x00000000000003dbULL, 0x000000000000063dULL, -- > 0x0000000000000a18ULL, 0x0000000000001055ULL, -- > 0x0000000000001a6dULL, 0x0000000000002ac2ULL, -- > 0x000000000000452fULL, 0x0000000000006ff1ULL, -- > 0x000000000000b520ULL, 0x0000000000012511ULL, -- > 0x000000000001da31ULL, 0x000000000002ff42ULL, -- > 0x000000000004d973ULL, 0x000000000007d8b5ULL, -- > 0x00000000000cb228ULL, 0x0000000000148addULL, -- > 0x0000000000213d05ULL, 0x000000000035c7e2ULL, -- > 0x00000000005704e7ULL, 0x00000000008cccc9ULL, -- > 0x0000000000e3d1b0ULL, 0x0000000001709e79ULL, -- > 0x0000000002547029ULL, 0x0000000003c50ea2ULL, -- > 0x0000000006197ecbULL, 0x0000000009de8d6dULL, -- > 0x000000000ff80c38ULL, 0x0000000019d699a5ULL, -- > 0x0000000029cea5ddULL, 0x0000000043a53f82ULL, -- > 0x000000006d73e55fULL, 0x00000000b11924e1ULL, -- > 0x000000011e8d0a40ULL, 0x00000001cfa62f21ULL, -- > 0x00000002ee333961ULL, 0x00000004bdd96882ULL, -- > 0x00000007ac0ca1e3ULL, 0x0000000c69e60a65ULL, -- > 0x0000001415f2ac48ULL, 0x000000207fd8b6adULL, -- > 0x0000003495cb62f5ULL, 0x0000005515a419a2ULL, -- > 0x00000089ab6f7c97ULL, 0x000000dec1139639ULL, -- > 0x000001686c8312d0ULL, 0x000002472d96a909ULL, -- > 0x000003af9a19bbd9ULL, 0x000005f6c7b064e2ULL, 0x000009a661ca20bbULL -- > }; -- > const SWord64 s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0]; -- > -- > return s65; -- > } genFib2 :: SWord64 -> IO () genFib2 top = compileToC Nothing "fibLookup" $ do cgPerformRTCs True -- protect against potential overflow, our table is not big enough x <- cgInput "x" cgReturn $ fib2 top x sbv-5.12/Data/SBV/Examples/CodeGeneration/GCD.hs0000644000000000000000000001427412725411265017336 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.GCD -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computing GCD symbolically, and generating C code for it. This example -- illustrates symbolic termination related issues when programming with -- SBV, when the termination of a recursive algorithm crucially depends -- on the value of a symbolic variable. The technique we use is to statically -- enforce termination by using a recursion depth counter. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.GCD where import Data.SBV ----------------------------------------------------------------------------- -- * Computing GCD ----------------------------------------------------------------------------- -- | The symbolic GCD algorithm, over two 8-bit numbers. We define @sgcd a 0@ to -- be @a@ for all @a@, which implies @sgcd 0 0 = 0@. Note that this is essentially -- Euclid's algorithm, except with a recursion depth counter. We need the depth -- counter since the algorithm is not /symbolically terminating/, as we don't have -- a means of determining that the second argument (@b@) will eventually reach 0 in a symbolic -- context. Hence we stop after 12 iterations. Why 12? We've empirically determined that this -- algorithm will recurse at most 12 times for arbitrary 8-bit numbers. Of course, this is -- a claim that we shall prove below. sgcd :: SWord8 -> SWord8 -> SWord8 sgcd a b = go a b 12 where go :: SWord8 -> SWord8 -> SWord8 -> SWord8 go x y c = ite (c .== 0 ||| y .== 0) -- stop if y is 0, or if we reach the recursion depth x (go y y' (c-1)) where (_, y') = x `sQuotRem` y ----------------------------------------------------------------------------- -- * Verification ----------------------------------------------------------------------------- {- $VerificationIntro We prove that 'sgcd' does indeed compute the common divisor of the given numbers. Our predicate takes @x@, @y@, and @k@. We show that what 'sgcd' returns is indeed a common divisor, and it is at least as large as any given @k@, provided @k@ is a common divisor as well. -} -- | We have: -- -- >>> prove sgcdIsCorrect -- Q.E.D. sgcdIsCorrect :: SWord8 -> SWord8 -> SWord8 -> SBool sgcdIsCorrect x y k = ite (y .== 0) -- if y is 0 (k' .== x) -- then k' must be x, nothing else to prove by definition (isCommonDivisor k' &&& -- otherwise, k' is a common divisor and (isCommonDivisor k ==> k' .>= k)) -- if k is a common divisor as well, then k' is at least as large as k where k' = sgcd x y isCommonDivisor a = z1 .== 0 &&& z2 .== 0 where (_, z1) = x `sQuotRem` a (_, z2) = y `sQuotRem` a ----------------------------------------------------------------------------- -- * Code generation ----------------------------------------------------------------------------- {- $VerificationIntro Now that we have proof our 'sgcd' implementation is correct, we can go ahead and generate C code for it. -} -- | This call will generate the required C files. The following is the function -- body generated for 'sgcd'. (We are not showing the generated header, @Makefile@, -- and the driver programs for brevity.) Note that the generated function is -- a constant time algorithm for GCD. It is not necessarily fastest, but it will take -- precisely the same amount of time for all values of @x@ and @y@. -- -- > /* File: "sgcd.c". Automatically generated by SBV. Do not edit! */ -- > -- > #include -- > #include -- > #include -- > #include -- > #include -- > #include "sgcd.h" -- > -- > SWord8 sgcd(const SWord8 x, const SWord8 y) -- > { -- > const SWord8 s0 = x; -- > const SWord8 s1 = y; -- > const SBool s3 = s1 == 0; -- > const SWord8 s4 = (s1 == 0) ? s0 : (s0 % s1); -- > const SWord8 s5 = s3 ? s0 : s4; -- > const SBool s6 = 0 == s5; -- > const SWord8 s7 = (s5 == 0) ? s1 : (s1 % s5); -- > const SWord8 s8 = s6 ? s1 : s7; -- > const SBool s9 = 0 == s8; -- > const SWord8 s10 = (s8 == 0) ? s5 : (s5 % s8); -- > const SWord8 s11 = s9 ? s5 : s10; -- > const SBool s12 = 0 == s11; -- > const SWord8 s13 = (s11 == 0) ? s8 : (s8 % s11); -- > const SWord8 s14 = s12 ? s8 : s13; -- > const SBool s15 = 0 == s14; -- > const SWord8 s16 = (s14 == 0) ? s11 : (s11 % s14); -- > const SWord8 s17 = s15 ? s11 : s16; -- > const SBool s18 = 0 == s17; -- > const SWord8 s19 = (s17 == 0) ? s14 : (s14 % s17); -- > const SWord8 s20 = s18 ? s14 : s19; -- > const SBool s21 = 0 == s20; -- > const SWord8 s22 = (s20 == 0) ? s17 : (s17 % s20); -- > const SWord8 s23 = s21 ? s17 : s22; -- > const SBool s24 = 0 == s23; -- > const SWord8 s25 = (s23 == 0) ? s20 : (s20 % s23); -- > const SWord8 s26 = s24 ? s20 : s25; -- > const SBool s27 = 0 == s26; -- > const SWord8 s28 = (s26 == 0) ? s23 : (s23 % s26); -- > const SWord8 s29 = s27 ? s23 : s28; -- > const SBool s30 = 0 == s29; -- > const SWord8 s31 = (s29 == 0) ? s26 : (s26 % s29); -- > const SWord8 s32 = s30 ? s26 : s31; -- > const SBool s33 = 0 == s32; -- > const SWord8 s34 = (s32 == 0) ? s29 : (s29 % s32); -- > const SWord8 s35 = s33 ? s29 : s34; -- > const SBool s36 = 0 == s35; -- > const SWord8 s37 = s36 ? s32 : s35; -- > const SWord8 s38 = s33 ? s29 : s37; -- > const SWord8 s39 = s30 ? s26 : s38; -- > const SWord8 s40 = s27 ? s23 : s39; -- > const SWord8 s41 = s24 ? s20 : s40; -- > const SWord8 s42 = s21 ? s17 : s41; -- > const SWord8 s43 = s18 ? s14 : s42; -- > const SWord8 s44 = s15 ? s11 : s43; -- > const SWord8 s45 = s12 ? s8 : s44; -- > const SWord8 s46 = s9 ? s5 : s45; -- > const SWord8 s47 = s6 ? s1 : s46; -- > const SWord8 s48 = s3 ? s0 : s47; -- > -- > return s48; -- > } genGCDInC :: IO () genGCDInC = compileToC Nothing "sgcd" $ do x <- cgInput "x" y <- cgInput "y" cgReturn $ sgcd x y sbv-5.12/Data/SBV/Examples/CodeGeneration/PopulationCount.hs0000644000000000000000000002064712725411265022105 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.PopulationCount -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computing population-counts (number of set bits) and autimatically -- generating C code. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.PopulationCount where import Data.SBV ----------------------------------------------------------------------------- -- * Reference: Slow but /obviously/ correct ----------------------------------------------------------------------------- -- | Given a 64-bit quantity, the simplest (and obvious) way to count the -- number of bits that are set in it is to simply walk through all the bits -- and add 1 to a running count. This is slow, as it requires 64 iterations, -- but is simple and easy to convince yourself that it is correct. For instance: -- -- >>> popCountSlow 0x0123456789ABCDEF -- 32 :: SWord8 popCountSlow :: SWord64 -> SWord8 popCountSlow inp = go inp 0 0 where go :: SWord64 -> Int -> SWord8 -> SWord8 go _ 64 c = c go x i c = go (x `shiftR` 1) (i+1) (ite (x .&. 1 .== 1) (c+1) c) ----------------------------------------------------------------------------- -- * Faster: Using a look-up table ----------------------------------------------------------------------------- -- | Faster version. This is essentially the same algorithm, except we -- go 8 bits at a time instead of one by one, by using a precomputed table -- of population-count values for each byte. This algorithm /loops/ only -- 8 times, and hence is at least 8 times more efficient. popCountFast :: SWord64 -> SWord8 popCountFast inp = go inp 0 0 where go :: SWord64 -> Int -> SWord8 -> SWord8 go _ 8 c = c go x i c = go (x `shiftR` 8) (i+1) (c + select pop8 0 (x .&. 0xff)) -- | Look-up table, containing population counts for all possible 8-bit -- value, from 0 to 255. Note that we do not \"hard-code\" the values, but -- merely use the slow version to compute them. pop8 :: [SWord8] pop8 = map popCountSlow [0 .. 255] ----------------------------------------------------------------------------- -- * Verification ----------------------------------------------------------------------------- {- $VerificationIntro We prove that `popCountFast` and `popCountSlow` are functionally equivalent. This is essential as we will automatically generate C code from `popCountFast`, and we would like to make sure that the fast version is correct with respect to the slower reference version. -} -- | States the correctness of faster population-count algorithm, with respect -- to the reference slow version. (We use yices here as it's quite fast for -- this problem. Z3 seems to take much longer.) We have: -- -- >>> proveWith yices fastPopCountIsCorrect -- Q.E.D. fastPopCountIsCorrect :: SWord64 -> SBool fastPopCountIsCorrect x = popCountFast x .== popCountSlow x ----------------------------------------------------------------------------- -- * Code generation ----------------------------------------------------------------------------- -- | Not only we can prove that faster version is correct, but we can also automatically -- generate C code to compute population-counts for us. This action will generate all the -- C files that you will need, including a driver program for test purposes. -- -- Below is the generated header file for `popCountFast`: -- -- >>> genPopCountInC -- == BEGIN: "Makefile" ================ -- # Makefile for popCount. Automatically generated by SBV. Do not edit! -- -- # include any user-defined .mk file in the current directory. -- -include *.mk -- -- CC?=gcc -- CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer -- -- all: popCount_driver -- -- popCount.o: popCount.c popCount.h -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- popCount_driver.o: popCount_driver.c -- ${CC} ${CCFLAGS} -c $< -o $@ -- -- popCount_driver: popCount.o popCount_driver.o -- ${CC} ${CCFLAGS} $^ -o $@ -- -- clean: -- rm -f *.o -- -- veryclean: clean -- rm -f popCount_driver -- == END: "Makefile" ================== -- == BEGIN: "popCount.h" ================ -- /* Header file for popCount. Automatically generated by SBV. Do not edit! */ -- -- #ifndef __popCount__HEADER_INCLUDED__ -- #define __popCount__HEADER_INCLUDED__ -- -- #include -- #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: */ -- SWord8 popCount(const SWord64 x); -- -- #endif /* __popCount__HEADER_INCLUDED__ */ -- == END: "popCount.h" ================== -- == BEGIN: "popCount_driver.c" ================ -- /* Example driver program for popCount. */ -- /* Automatically generated by SBV. Edit as you see fit! */ -- -- #include -- #include "popCount.h" -- -- int main(void) -- { -- const SWord8 __result = popCount(0x1b02e143e4f0e0e5ULL); -- -- printf("popCount(0x1b02e143e4f0e0e5ULL) = %"PRIu8"\n", __result); -- -- return 0; -- } -- == END: "popCount_driver.c" ================== -- == BEGIN: "popCount.c" ================ -- /* File: "popCount.c". Automatically generated by SBV. Do not edit! */ -- -- #include "popCount.h" -- -- SWord8 popCount(const SWord64 x) -- { -- const SWord64 s0 = x; -- static const SWord8 table0[] = { -- 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, -- 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, -- 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, -- 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, -- 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, -- 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, -- 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, -- 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, -- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, -- 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, -- 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, -- 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 -- }; -- const SWord64 s11 = s0 & 0x00000000000000ffULL; -- const SWord8 s12 = table0[s11]; -- const SWord64 s13 = s0 >> 8; -- const SWord64 s14 = 0x00000000000000ffULL & s13; -- const SWord8 s15 = table0[s14]; -- const SWord8 s16 = s12 + s15; -- const SWord64 s17 = s13 >> 8; -- const SWord64 s18 = 0x00000000000000ffULL & s17; -- const SWord8 s19 = table0[s18]; -- const SWord8 s20 = s16 + s19; -- const SWord64 s21 = s17 >> 8; -- const SWord64 s22 = 0x00000000000000ffULL & s21; -- const SWord8 s23 = table0[s22]; -- const SWord8 s24 = s20 + s23; -- const SWord64 s25 = s21 >> 8; -- const SWord64 s26 = 0x00000000000000ffULL & s25; -- const SWord8 s27 = table0[s26]; -- const SWord8 s28 = s24 + s27; -- const SWord64 s29 = s25 >> 8; -- const SWord64 s30 = 0x00000000000000ffULL & s29; -- const SWord8 s31 = table0[s30]; -- const SWord8 s32 = s28 + s31; -- const SWord64 s33 = s29 >> 8; -- const SWord64 s34 = 0x00000000000000ffULL & s33; -- const SWord8 s35 = table0[s34]; -- const SWord8 s36 = s32 + s35; -- const SWord64 s37 = s33 >> 8; -- const SWord64 s38 = 0x00000000000000ffULL & s37; -- const SWord8 s39 = table0[s38]; -- const SWord8 s40 = s36 + s39; -- -- return s40; -- } -- == END: "popCount.c" ================== genPopCountInC :: IO () genPopCountInC = compileToC Nothing "popCount" $ do cgSetDriverValues [0x1b02e143e4f0e0e5] -- remove this line to get a random test value x <- cgInput "x" cgReturn $ popCountFast x sbv-5.12/Data/SBV/Examples/CodeGeneration/Uninterpreted.hs0000644000000000000000000000574112725411265021570 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.CodeGeneration.Uninterpreted -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates the use of uninterpreted functions for the purposes of -- code generation. This facility is important when we want to take -- advantage of native libraries in the target platform, or when we'd -- like to hand-generate code for certain functions for various -- purposes, such as efficiency, or reliability. ----------------------------------------------------------------------------- module Data.SBV.Examples.CodeGeneration.Uninterpreted where import Data.Maybe (fromMaybe) import Data.SBV -- | A definition of shiftLeft that can deal with variable length shifts. -- (Note that the ``shiftL`` method from the 'Bits' class requires an 'Int' shift -- amount.) Unfortunately, this'll generate rather clumsy C code due to the -- use of tables etc., so we uninterpret it for code generation purposes -- using the 'cgUninterpret' function. shiftLeft :: SWord32 -> SWord32 -> SWord32 shiftLeft = cgUninterpret "SBV_SHIFTLEFT" cCode hCode where -- the C code we'd like SBV to spit out when generating code. Note that this is -- arbitrary C code. In this case we just used a macro, but it could be a function, -- text that includes files etc. It should essentially bring the name SBV_SHIFTLEFT -- used above into scope when compiled. If no code is needed, one can also just -- provide the empty list for the same effect. Also see 'cgAddDecl', 'cgAddLDFlags', -- and 'cgAddPrototype' functions for further variations. cCode = ["#define SBV_SHIFTLEFT(x, y) ((x) << (y))"] -- the Haskell code we'd like SBV to use when running inside Haskell or when -- translated to SMTLib for verification purposes. This is good old Haskell -- code, as one would typically write. hCode x = select [x * literal (bit b) | b <- [0.. bs x - 1]] (literal 0) bs x = fromMaybe (error "SBV.Example.CodeGeneration.Uninterpreted.shiftLeft: Unexpected non-finite usage!") (bitSizeMaybe x) -- | Test function that uses shiftLeft defined above. When used as a normal Haskell function -- or in verification the definition is fully used, i.e., no uninterpretation happens. To wit, -- we have: -- -- >>> tstShiftLeft 3 4 5 -- 224 :: SWord32 -- -- >>> prove $ \x y -> tstShiftLeft x y 0 .== x + y -- Q.E.D. tstShiftLeft :: SWord32 -> SWord32 -> SWord32 -> SWord32 tstShiftLeft x y z = x `shiftLeft` z + y `shiftLeft` z -- | Generate C code for "tstShiftLeft". In this case, SBV will *use* the user given definition -- verbatim, instead of generating code for it. (Also see the functions 'cgAddDecl', 'cgAddLDFlags', -- and 'cgAddPrototype'.) genCCode :: IO () genCCode = compileToC Nothing "tst" $ do [x, y, z] <- cgInputArr 3 "vs" cgReturn $ tstShiftLeft x y z sbv-5.12/Data/SBV/Examples/Crypto/0000755000000000000000000000000012725411266014770 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Crypto/AES.hs0000644000000000000000000006375512725411265015753 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Crypto.AES -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- An implementation of AES (Advanced Encryption Standard), using SBV. -- For details on AES, see FIPS-197: . -- -- We do a T-box implementation, which leads to good C code as we can take -- advantage of look-up tables. Note that we make virtually no attempt to -- optimize our Haskell code. The concern here is not with getting Haskell running -- fast at all. The idea is to program the T-Box implementation as naturally and clearly -- as possible in Haskell, and have SBV's code-generator generate fast C code automatically. -- Therefore, we merely use ordinary Haskell lists as our data-structures, and do not -- bother with any unboxing or strictness annotations. Thus, we achieve the separation -- of concerns: Correctness via clairty and simplicity and proofs on the Haskell side, -- performance by relying on SBV's code generator. If necessary, the generated code -- can be FFI'd back into Haskell to complete the loop. -- -- All 3 valid key sizes (128, 192, and 256) as required by the FIPS-197 standard -- are supported. ----------------------------------------------------------------------------- {-# LANGUAGE ParallelListComp #-} module Data.SBV.Examples.Crypto.AES where import Data.SBV import Data.List (transpose) ----------------------------------------------------------------------------- -- * Formalizing GF(2^8) ----------------------------------------------------------------------------- -- | An element of the Galois Field 2^8, which are essentially polynomials with -- maximum degree 7. They are conveniently represented as values between 0 and 255. type GF28 = SWord8 -- | Multiplication in GF(2^8). This is simple polynomial multipliation, followed -- by the irreducible polynomial @x^8+x^4+x^3+x^1+1@. We simply use the 'pMult' -- function exported by SBV to do the operation. gf28Mult :: GF28 -> GF28 -> GF28 gf28Mult x y = pMult (x, y, [8, 4, 3, 1, 0]) -- | Exponentiation by a constant in GF(2^8). The implementation uses the usual -- square-and-multiply trick to speed up the computation. gf28Pow :: GF28 -> Int -> GF28 gf28Pow n = pow where sq x = x `gf28Mult` x pow 0 = 1 pow i | odd i = n `gf28Mult` sq (pow (i `shiftR` 1)) | True = sq (pow (i `shiftR` 1)) -- | Computing inverses in GF(2^8). By the mathematical properties of GF(2^8) -- and the particular irreducible polynomial used @x^8+x^5+x^3+x^1+1@, it -- turns out that raising to the 254 power gives us the multiplicative inverse. -- Of course, we can prove this using SBV: -- -- >>> prove $ \x -> x ./= 0 ==> x `gf28Mult` gf28Inverse x .== 1 -- Q.E.D. -- -- Note that we exclude @0@ in our theorem, as it does not have a -- multiplicative inverse. gf28Inverse :: GF28 -> GF28 gf28Inverse x = x `gf28Pow` 254 ----------------------------------------------------------------------------- -- * Implementing AES ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- -- ** Types and basic operations ----------------------------------------------------------------------------- -- | AES state. The state consists of four 32-bit words, each of which is in turn treated -- as four GF28's, i.e., 4 bytes. The T-Box implementation keeps the four-bytes together -- for efficient representation. type State = [SWord32] -- | The key, which can be 128, 192, or 256 bits. Represented as a sequence of 32-bit words. type Key = [SWord32] -- | The key schedule. AES executes in rounds, and it treats first and last round keys slightly -- differently than the middle ones. We reflect that choice by being explicit about it in our type. -- The length of the middle list of keys depends on the key-size, which in turn determines -- the number of rounds. type KS = (Key, [Key], Key) -- | Conversion from 32-bit words to 4 constituent bytes. toBytes :: SWord32 -> [GF28] toBytes x = [x1, x2, x3, x4] where (h, l) = split x (x1, x2) = split h (x3, x4) = split l -- | Conversion from 4 bytes, back to a 32-bit row, inverse of 'toBytes' above. We -- have the following simple theorems stating this relationship formally: -- -- >>> prove $ \a b c d -> toBytes (fromBytes [a, b, c, d]) .== [a, b, c, d] -- Q.E.D. -- -- >>> prove $ \r -> fromBytes (toBytes r) .== r -- Q.E.D. fromBytes :: [GF28] -> SWord32 fromBytes [x1, x2, x3, x4] = (x1 # x2) # (x3 # x4) fromBytes xs = error $ "fromBytes: Unexpected input: " ++ show xs -- | Rotating a state row by a fixed amount to the right. rotR :: [GF28] -> Int -> [GF28] rotR [a, b, c, d] 1 = [d, a, b, c] rotR [a, b, c, d] 2 = [c, d, a, b] rotR [a, b, c, d] 3 = [b, c, d, a] rotR xs i = error $ "rotR: Unexpected input: " ++ show (xs, i) ----------------------------------------------------------------------------- -- ** The key schedule ----------------------------------------------------------------------------- -- | Definition of round-constants, as specified in Section 5.2 of the AES standard. roundConstants :: [GF28] roundConstants = 0 : [ gf28Pow 2 (k-1) | k <- [1 .. ] ] -- | The @InvMixColumns@ transformation, as described in Section 5.3.3 of the standard. Note -- that this transformation is only used explicitly during key-expansion in the T-Box implementation -- of AES. invMixColumns :: State -> State invMixColumns state = map fromBytes $ transpose $ mmult (map toBytes state) where dot f = foldr1 xor . zipWith ($) f mmult n = [map (dot r) n | r <- [ [mE, mB, mD, m9] , [m9, mE, mB, mD] , [mD, m9, mE, mB] , [mB, mD, m9, mE] ]] -- table-lookup versions of gf28Mult with the constants used in invMixColumns mE = select mETable 0 mB = select mBTable 0 mD = select mDTable 0 m9 = select m9Table 0 mETable = map (gf28Mult 0xE) [0..255] mBTable = map (gf28Mult 0xB) [0..255] mDTable = map (gf28Mult 0xD) [0..255] m9Table = map (gf28Mult 0x9) [0..255] -- | Key expansion. Starting with the given key, returns an infinite sequence of -- words, as described by the AES standard, Section 5.2, Figure 11. keyExpansion :: Int -> Key -> [Key] keyExpansion nk key = chop4 keys where keys :: [SWord32] keys = key ++ [nextWord i prev old | i <- [nk ..] | prev <- drop (nk-1) keys | old <- keys] chop4 :: [a] -> [[a]] chop4 xs = let (f, r) = splitAt 4 xs in f : chop4 r nextWord :: Int -> SWord32 -> SWord32 -> SWord32 nextWord i prev old | i `mod` nk == 0 = old `xor` subWordRcon (prev `rotateL` 8) (roundConstants !! (i `div` nk)) | i `mod` nk == 4 && nk > 6 = old `xor` subWordRcon prev 0 | True = old `xor` prev subWordRcon :: SWord32 -> GF28 -> SWord32 subWordRcon w rc = fromBytes [a `xor` rc, b, c, d] where [a, b, c, d] = map sbox $ toBytes w ----------------------------------------------------------------------------- -- ** The S-box transformation ----------------------------------------------------------------------------- -- | The values of the AES S-box table. Note that we describe the S-box programmatically -- using the mathematical construction given in Section 5.1.1 of the standard. However, -- the code-generation will turn this into a mere look-up table, as it is just a -- constant table, all computation being done at \"compile-time\". sboxTable :: [GF28] sboxTable = [xformByte (gf28Inverse b) | b <- [0 .. 255]] where xformByte :: GF28 -> GF28 xformByte b = foldr xor 0x63 [b `rotateR` i | i <- [0, 4, 5, 6, 7]] -- | The sbox transformation. We simply select from the sbox table. Note that we -- are obliged to give a default value (here @0@) to be used if the index is out-of-bounds -- as required by SBV's 'select' function. However, that will never happen since -- the table has all 256 elements in it. sbox :: GF28 -> GF28 sbox = select sboxTable 0 ----------------------------------------------------------------------------- -- ** The inverse S-box transformation ----------------------------------------------------------------------------- -- | The values of the inverse S-box table. Again, the construction is programmatic. unSBoxTable :: [GF28] unSBoxTable = [gf28Inverse (xformByte b) | b <- [0 .. 255]] where xformByte :: GF28 -> GF28 xformByte b = foldr xor 0x05 [b `rotateR` i | i <- [2, 5, 7]] -- | The inverse s-box transformation. unSBox :: GF28 -> GF28 unSBox = select unSBoxTable 0 -- | Prove that the 'sbox' and 'unSBox' are inverses. We have: -- -- >>> prove sboxInverseCorrect -- Q.E.D. -- sboxInverseCorrect :: GF28 -> SBool sboxInverseCorrect x = unSBox (sbox x) .== x &&& sbox (unSBox x) .== x ----------------------------------------------------------------------------- -- ** AddRoundKey transformation ----------------------------------------------------------------------------- -- | Adding the round-key to the current state. We simply exploit the fact -- that addition is just xor in implementing this transformation. addRoundKey :: Key -> State -> State addRoundKey = zipWith xor ----------------------------------------------------------------------------- -- ** Tables for T-Box encryption ----------------------------------------------------------------------------- -- | T-box table generation function for encryption t0Func :: GF28 -> [GF28] t0Func a = [s `gf28Mult` 2, s, s, s `gf28Mult` 3] where s = sbox a -- | First look-up table used in encryption t0 :: GF28 -> SWord32 t0 = select t0Table 0 where t0Table = [fromBytes (t0Func a) | a <- [0..255]] -- | Second look-up table used in encryption t1 :: GF28 -> SWord32 t1 = select t1Table 0 where t1Table = [fromBytes (t0Func a `rotR` 1) | a <- [0..255]] -- | Third look-up table used in encryption t2 :: GF28 -> SWord32 t2 = select t2Table 0 where t2Table = [fromBytes (t0Func a `rotR` 2) | a <- [0..255]] -- | Fourth look-up table used in encryption t3 :: GF28 -> SWord32 t3 = select t3Table 0 where t3Table = [fromBytes (t0Func a `rotR` 3) | a <- [0..255]] ----------------------------------------------------------------------------- -- ** Tables for T-Box decryption ----------------------------------------------------------------------------- -- | T-box table generating function for decryption u0Func :: GF28 -> [GF28] u0Func a = [s `gf28Mult` 0xE, s `gf28Mult` 0x9, s `gf28Mult` 0xD, s `gf28Mult` 0xB] where s = unSBox a -- | First look-up table used in decryption u0 :: GF28 -> SWord32 u0 = select t0Table 0 where t0Table = [fromBytes (u0Func a) | a <- [0..255]] -- | Second look-up table used in decryption u1 :: GF28 -> SWord32 u1 = select t1Table 0 where t1Table = [fromBytes (u0Func a `rotR` 1) | a <- [0..255]] -- | Third look-up table used in decryption u2 :: GF28 -> SWord32 u2 = select t2Table 0 where t2Table = [fromBytes (u0Func a `rotR` 2) | a <- [0..255]] -- | Fourth look-up table used in decryption u3 :: GF28 -> SWord32 u3 = select t3Table 0 where t3Table = [fromBytes (u0Func a `rotR` 3) | a <- [0..255]] ----------------------------------------------------------------------------- -- ** AES rounds ----------------------------------------------------------------------------- -- | Generic round function. Given the function to perform one round, a key-schedule, -- and a starting state, it performs the AES rounds. doRounds :: (Bool -> State -> Key -> State) -> KS -> State -> State doRounds rnd (ikey, rkeys, fkey) sIn = rnd True (last rs) fkey where s0 = ikey `addRoundKey` sIn rs = s0 : [rnd False s k | s <- rs | k <- rkeys ] -- | One encryption round. The first argument indicates whether this is the final round -- or not, in which case the construction is slightly different. aesRound :: Bool -> State -> Key -> State aesRound isFinal s key = d `addRoundKey` key where d = map (f isFinal) [0..3] a = map toBytes s f True j = fromBytes [ sbox (a !! ((j+0) `mod` 4) !! 0) , sbox (a !! ((j+1) `mod` 4) !! 1) , sbox (a !! ((j+2) `mod` 4) !! 2) , sbox (a !! ((j+3) `mod` 4) !! 3) ] f False j = e0 `xor` e1 `xor` e2 `xor` e3 where e0 = t0 (a !! ((j+0) `mod` 4) !! 0) e1 = t1 (a !! ((j+1) `mod` 4) !! 1) e2 = t2 (a !! ((j+2) `mod` 4) !! 2) e3 = t3 (a !! ((j+3) `mod` 4) !! 3) -- | One decryption round. Similar to the encryption round, the first argument -- indicates whether this is the final round or not. aesInvRound :: Bool -> State -> Key -> State aesInvRound isFinal s key = d `addRoundKey` key where d = map (f isFinal) [0..3] a = map toBytes s f True j = fromBytes [ unSBox (a !! ((j+0) `mod` 4) !! 0) , unSBox (a !! ((j+3) `mod` 4) !! 1) , unSBox (a !! ((j+2) `mod` 4) !! 2) , unSBox (a !! ((j+1) `mod` 4) !! 3) ] f False j = e0 `xor` e1 `xor` e2 `xor` e3 where e0 = u0 (a !! ((j+0) `mod` 4) !! 0) e1 = u1 (a !! ((j+3) `mod` 4) !! 1) e2 = u2 (a !! ((j+2) `mod` 4) !! 2) e3 = u3 (a !! ((j+1) `mod` 4) !! 3) ----------------------------------------------------------------------------- -- * AES API ----------------------------------------------------------------------------- -- | Key schedule. Given a 128, 192, or 256 bit key, expand it to get key-schedules -- for encryption and decryption. The key is given as a sequence of 32-bit words. -- (4 elements for 128-bits, 6 for 192, and 8 for 256.) aesKeySchedule :: Key -> (KS, KS) aesKeySchedule key | nk `elem` [4, 6, 8] = (encKS, decKS) | True = error "aesKeySchedule: Invalid key size" where nk = length key nr = nk + 6 encKS@(f, m, l) = (head rKeys, take (nr-1) (tail rKeys), rKeys !! nr) decKS = (l, map invMixColumns (reverse m), f) rKeys = keyExpansion nk key -- | Block encryption. The first argument is the plain-text, which must have -- precisely 4 elements, for a total of 128-bits of input. The second -- argument is the key-schedule to be used, obtained by a call to 'aesKeySchedule'. -- The output will always have 4 32-bit words, which is the cipher-text. aesEncrypt :: [SWord32] -> KS -> [SWord32] aesEncrypt pt encKS | length pt == 4 = doRounds aesRound encKS pt | True = error "aesEncrypt: Invalid plain-text size" -- | Block decryption. The arguments are the same as in 'aesEncrypt', except -- the first argument is the cipher-text and the output is the corresponding -- plain-text. aesDecrypt :: [SWord32] -> KS -> [SWord32] aesDecrypt ct decKS | length ct == 4 = doRounds aesInvRound decKS ct | True = error "aesDecrypt: Invalid cipher-text size" ----------------------------------------------------------------------------- -- * Test vectors ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- -- ** 128-bit enc/dec test ----------------------------------------------------------------------------- -- | 128-bit encryption test, from Appendix C.1 of the AES standard: -- -- >>> map hex t128Enc -- ["69c4e0d8","6a7b0430","d8cdb780","70b4c55a"] -- t128Enc :: [SWord32] t128Enc = aesEncrypt pt ks where pt = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f] (ks, _) = aesKeySchedule key -- | 128-bit decryption test, from Appendix C.1 of the AES standard: -- -- >>> map hex t128Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t128Dec :: [SWord32] t128Dec = aesDecrypt ct ks where ct = [0x69c4e0d8, 0x6a7b0430, 0xd8cdb780, 0x70b4c55a] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f] (_, ks) = aesKeySchedule key ----------------------------------------------------------------------------- -- ** 192-bit enc/dec test ----------------------------------------------------------------------------- -- | 192-bit encryption test, from Appendix C.2 of the AES standard: -- -- >>> map hex t192Enc -- ["dda97ca4","864cdfe0","6eaf70a0","ec0d7191"] -- t192Enc :: [SWord32] t192Enc = aesEncrypt pt ks where pt = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617] (ks, _) = aesKeySchedule key -- | 192-bit decryption test, from Appendix C.2 of the AES standard: -- -- >>> map hex t192Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t192Dec :: [SWord32] t192Dec = aesDecrypt ct ks where ct = [0xdda97ca4, 0x864cdfe0, 0x6eaf70a0, 0xec0d7191] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617] (_, ks) = aesKeySchedule key ----------------------------------------------------------------------------- -- ** 256-bit enc/dec test ----------------------------------------------------------------------------- -- | 256-bit encryption, from Appendix C.3 of the AES standard: -- -- >>> map hex t256Enc -- ["8ea2b7ca","516745bf","eafc4990","4b496089"] -- t256Enc :: [SWord32] t256Enc = aesEncrypt pt ks where pt = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f] (ks, _) = aesKeySchedule key -- | 256-bit decryption, from Appendix C.3 of the AES standard: -- -- >>> map hex t256Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t256Dec :: [SWord32] t256Dec = aesDecrypt ct ks where ct = [0x8ea2b7ca, 0x516745bf, 0xeafc4990, 0x4b496089] key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f] (_, ks) = aesKeySchedule key ----------------------------------------------------------------------------- -- * Verification -- ${verifIntro} ----------------------------------------------------------------------------- {- $verifIntro While SMT based technologies can prove correct many small properties fairly quickly, it would be naive for them to automatically verify that our AES implementation is correct. (By correct, we mean decryption follewed by encryption yielding the same result.) However, we can state this property precisely using SBV, and use quick-check to gain some confidence. -} -- | Correctness theorem for 128-bit AES. Ideally, we would run: -- -- @ -- prove aes128IsCorrect -- @ -- -- to get a proof automatically. Unfortunately, while SBV will successfully generate the proof -- obligation for this theorem and ship it to the SMT solver, it would be naive to expect the SMT-solver -- to finish that proof in any reasonable time with the currently available SMT solving technologies. -- Instead, we can issue: -- -- @ -- quickCheck aes128IsCorrect -- @ -- -- and get some degree of confidence in our code. Similar predicates can be easily constructed for 192, and -- 256 bit cases as well. aes128IsCorrect :: (SWord32, SWord32, SWord32, SWord32) -- ^ plain-text words -> (SWord32, SWord32, SWord32, SWord32) -- ^ key-words -> SBool -- ^ True if round-trip gives us plain-text back aes128IsCorrect (i0, i1, i2, i3) (k0, k1, k2, k3) = pt .== pt' where pt = [i0, i1, i2, i3] key = [k0, k1, k2, k3] (encKS, decKS) = aesKeySchedule key ct = aesEncrypt pt encKS pt' = aesDecrypt ct decKS ----------------------------------------------------------------------------- -- * Code generation -- ${codeGenIntro} ----------------------------------------------------------------------------- {- $codeGenIntro We have emphasized that our T-Box implementation in Haskell was guided by clarity and correctness, not performance. Indeed, our implementation is hardly the fastest AES implementation in Haskell. However, we can use it to automatically generate straight-line C-code that can run fairly fast. For the purposes of illustration, we only show here how to generate code for a 128-bit AES block-encrypt function, that takes 8 32-bit words as an argument. The first 4 are the 128-bit input, and the final four are the 128-bit key. The impact of this is that the generated function would expand the key for each block of encryption, a needless task unless we change the key in every block. In a more serios application, we would instead generate code for both the 'aesKeySchedule' and the 'aesEncrypt' functions, thus reusing the key-schedule over many applications of the encryption call. (Unfortunately doing this is rather cumbersome right now, since Haskell does not support fixed-size lists.) -} -- | Code generation for 128-bit AES encryption. -- -- The following sample from the generated code-lines show how T-Boxes are rendered as C arrays: -- -- @ -- static const SWord32 table1[] = { -- 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, -- 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, -- 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, -- 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, -- ... -- } -- @ -- -- The generated program has 5 tables (one sbox table, and 4-Tboxes), all converted to fast C arrays. Here -- is a sample of the generated straightline C-code: -- -- @ -- const SWord8 s1915 = (SWord8) s1912; -- const SWord8 s1916 = table0[s1915]; -- const SWord16 s1917 = (((SWord16) s1914) << 8) | ((SWord16) s1916); -- const SWord32 s1918 = (((SWord32) s1911) << 16) | ((SWord32) s1917); -- const SWord32 s1919 = s1844 ^ s1918; -- const SWord32 s1920 = s1903 ^ s1919; -- @ -- -- The GNU C-compiler does a fine job of optimizing this straightline code to generate a fairly efficient C implementation. cgAES128BlockEncrypt :: IO () cgAES128BlockEncrypt = compileToC Nothing "aes128BlockEncrypt" $ do pt <- cgInputArr 4 "pt" -- plain-text as an array of 4 Word32's key <- cgInputArr 4 "key" -- key as an array of 4 Word32s -- Use the test values from Appendix C.1 of the AES standard as the driver values cgSetDriverValues $ [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff] ++ [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f] let (encKs, _) = aesKeySchedule key cgOutputArr "ct" $ aesEncrypt pt encKs ----------------------------------------------------------------------------- -- * C-library generation -- ${libraryIntro} ----------------------------------------------------------------------------- {- $libraryIntro The 'cgAES128BlockEncrypt' example shows how to generate code for 128-bit AES encryption. As the generated function performs encryption on a given block, it performs key expansion as necessary. However, this is not quite practical: We would like to expand the key only once, and encrypt the stream of plain-text blocks using the same expanded key (potentially using some crypto-mode), until we decide to change the key. In this section, we show how to use SBV to instead generate a library of functions that can be used in such a scenario. The generated library is a typical @.a@ archive, that can be linked using the C-compiler as usual. -} -- | Components of the AES-128 implementation that the library is generated from aes128LibComponents :: [(String, SBVCodeGen ())] aes128LibComponents = [ ("aes128KeySchedule", keySchedule) , ("aes128BlockEncrypt", enc128) , ("aes128BlockDecrypt", dec128) ] where -- key-schedule keySchedule = do key <- cgInputArr 4 "key" -- key let (encKS, decKS) = aesKeySchedule key cgOutputArr "encKS" (ksToXKey encKS) cgOutputArr "decKS" (ksToXKey decKS) -- encryption enc128 = do pt <- cgInputArr 4 "pt" -- plain-text xkey <- cgInputArr 44 "xkey" -- expanded key, for 128-bit AES, the key-expansion has 44 Word32's cgOutputArr "ct" $ aesEncrypt pt (xkeyToKS xkey) -- decryption dec128 = do pt <- cgInputArr 4 "ct" -- cipher-text xkey <- cgInputArr 44 "xkey" -- expanded key, for 128-bit AES, the key-expansion has 44 Word32's cgOutputArr "pt" $ aesDecrypt pt (xkeyToKS xkey) -- Transforming back and forth from our KS type to a flat array used by the generated C code -- Turn a series of expanded keys to our internal KS type xkeyToKS :: [SWord32] -> KS xkeyToKS xs = (f, m, l) where f = take 4 xs -- first round key m = chop4 (take 36 (drop 4 xs)) -- middle rounds l = drop 40 xs -- last round key -- Turn a KS to a series of expanded key words ksToXKey :: KS -> [SWord32] ksToXKey (f, m, l) = f ++ concat m ++ l -- chunk in fours. (This function must be in some standard library, where?) chop4 :: [a] -> [[a]] chop4 [] = [] chop4 xs = let (f, r) = splitAt 4 xs in f : chop4 r -- | Generate a C library, containing functions for performing 128-bit enc/dec/key-expansion. -- A note on performance: In a very rough speed test, the generated code was able to do -- 6.3 million block encryptions per second on a decent MacBook Pro. On the same machine, OpenSSL -- reports 8.2 million block encryptions per second. So, the generated code is about 25% slower -- as compared to the highly optimized OpenSSL implementation. (Note that the speed test was done -- somewhat simplistically, so these numbers should be considered very rough estimates.) cgAES128Library :: IO () cgAES128Library = compileToCLib Nothing "aes128Lib" aes128LibComponents {-# ANN aesRound ("HLint: ignore Use head" :: String) #-} {-# ANN aesInvRound ("HLint: ignore Use head" :: String) #-} sbv-5.12/Data/SBV/Examples/Crypto/RC4.hs0000644000000000000000000001321712725411266015720 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Crypto.RC4 -- Copyright : (c) Austin Seipp -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- An implementation of RC4 (AKA Rivest Cipher 4 or Alleged RC4/ARC4), -- using SBV. For information on RC4, see: . -- -- We make no effort to optimize the code, and instead focus on a clear -- implementation. In fact, the RC4 algorithm relies on in-place update of -- its state heavily for efficiency, and is therefore unsuitable for a purely -- functional implementation. ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Examples.Crypto.RC4 where import Data.Char (ord, chr) import Data.List (genericIndex) import Data.Maybe (fromJust) import Data.SBV ----------------------------------------------------------------------------- -- * Types ----------------------------------------------------------------------------- -- | RC4 State contains 256 8-bit values. We use the symbolically accessible -- full-binary type 'STree' to represent the state, since RC4 needs -- access to the array via a symbolic index and it's important to minimize access time. type S = STree Word8 Word8 -- | Construct the fully balanced initial tree, where the leaves are simply the numbers @0@ through @255@. initS :: S initS = mkSTree (map literal [0 .. 255]) -- | The key is a stream of 'Word8' values. type Key = [SWord8] -- | Represents the current state of the RC4 stream: it is the @S@ array -- along with the @i@ and @j@ index values used by the PRGA. type RC4 = (S, SWord8, SWord8) ----------------------------------------------------------------------------- -- * The PRGA ----------------------------------------------------------------------------- -- | Swaps two elements in the RC4 array. swap :: SWord8 -> SWord8 -> S -> S swap i j st = writeSTree (writeSTree st i stj) j sti where sti = readSTree st i stj = readSTree st j -- | Implements the PRGA used in RC4. We return the new state and the next key value generated. prga :: RC4 -> (SWord8, RC4) prga (st', i', j') = (readSTree st kInd, (st, i, j)) where i = i' + 1 j = j' + readSTree st' i st = swap i j st' kInd = readSTree st i + readSTree st j ----------------------------------------------------------------------------- -- * Key schedule ----------------------------------------------------------------------------- -- | Constructs the state to be used by the PRGA using the given key. initRC4 :: Key -> S initRC4 key | keyLength < 1 || keyLength > 256 = error $ "RC4 requires a key of length between 1 and 256, received: " ++ show keyLength | True = snd $ foldl mix (0, initS) [0..255] where keyLength = length key mix :: (SWord8, S) -> SWord8 -> (SWord8, S) mix (j', s) i = let j = j' + readSTree s i + genericIndex key (fromJust (unliteral i) `mod` fromIntegral keyLength) in (j, swap i j s) -- | The key-schedule. Note that this function returns an infinite list. keySchedule :: Key -> [SWord8] keySchedule key = genKeys (initRC4 key, 0, 0) where genKeys :: RC4 -> [SWord8] genKeys st = let (k, st') = prga st in k : genKeys st' -- | Generate a key-schedule from a given key-string. keyScheduleString :: String -> [SWord8] keyScheduleString = keySchedule . map (literal . fromIntegral . ord) ----------------------------------------------------------------------------- -- * Encryption and Decryption ----------------------------------------------------------------------------- -- | RC4 encryption. We generate key-words and xor it with the input. The -- following test-vectors are from Wikipedia : -- -- >>> concatMap hex $ encrypt "Key" "Plaintext" -- "bbf316e8d940af0ad3" -- -- >>> concatMap hex $ encrypt "Wiki" "pedia" -- "1021bf0420" -- -- >>> concatMap hex $ encrypt "Secret" "Attack at dawn" -- "45a01f645fc35b383552544b9bf5" encrypt :: String -> String -> [SWord8] encrypt key pt = zipWith xor (keyScheduleString key) (map cvt pt) where cvt = literal . fromIntegral . ord -- | RC4 decryption. Essentially the same as decryption. For the above test vectors we have: -- -- >>> decrypt "Key" [0xbb, 0xf3, 0x16, 0xe8, 0xd9, 0x40, 0xaf, 0x0a, 0xd3] -- "Plaintext" -- -- >>> decrypt "Wiki" [0x10, 0x21, 0xbf, 0x04, 0x20] -- "pedia" -- -- >>> decrypt "Secret" [0x45, 0xa0, 0x1f, 0x64, 0x5f, 0xc3, 0x5b, 0x38, 0x35, 0x52, 0x54, 0x4b, 0x9b, 0xf5] -- "Attack at dawn" decrypt :: String -> [SWord8] -> String decrypt key ct = map cvt $ zipWith xor (keyScheduleString key) ct where cvt = chr . fromIntegral . fromJust . unliteral ----------------------------------------------------------------------------- -- * Verification ----------------------------------------------------------------------------- -- | Prove that round-trip encryption/decryption leaves the plain-text unchanged. -- The theorem is stated parametrically over key and plain-text sizes. The expression -- performs the proof for a 40-bit key (5 bytes) and 40-bit plaintext (again 5 bytes). -- -- Note that this theorem is trivial to prove, since it is essentially establishing -- xor'in the same value twice leaves a word unchanged (i.e., @x `xor` y `xor` y = x@). -- However, the proof takes quite a while to complete, as it gives rise to a fairly -- large symbolic trace. rc4IsCorrect :: IO ThmResult rc4IsCorrect = prove $ do key <- mkForallVars 5 pt <- mkForallVars 5 let ks = keySchedule key ct = zipWith xor ks pt pt' = zipWith xor ks ct return $ pt .== pt' sbv-5.12/Data/SBV/Examples/Existentials/0000755000000000000000000000000012725411266016164 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Existentials/CRCPolynomial.hs0000644000000000000000000001116012725411266021172 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Existentials.CRCPolynomial -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- This program demonstrates the use of the existentials and the QBVF (quantified -- bit-vector solver). We generate CRC polynomials of degree 16 that can be used -- for messages of size 48-bits. The query finds all such polynomials that have hamming -- distance is at least 4. That is, if the CRC can't tell two different 48-bit messages -- apart, then they must differ in at least 4 bits. ----------------------------------------------------------------------------- module Data.SBV.Examples.Existentials.CRCPolynomial where import Data.SBV ----------------------------------------------------------------------------- -- * Modeling 48 bit words ----------------------------------------------------------------------------- -- | SBV doesn't support 48 bit words natively. So, we represent them -- as a tuple, 32 high-bits and 16 low-bits. type SWord48 = (SWord32, SWord16) -- | Compute the 16 bit CRC of a 48 bit message, using the given polynomial crc_48_16 :: SWord48 -> SWord16 -> [SBool] crc_48_16 msg poly = crcBV 16 msgBits polyBits where (hi, lo) = msg msgBits = blastBE hi ++ blastBE lo polyBits = blastBE poly -- | Count the differing bits in the message and the corresponding CRC diffCount :: (SWord48, [SBool]) -> (SWord48, [SBool]) -> SWord8 diffCount ((h1, l1), crc1) ((h2, l2), crc2) = count xorBits where bits1 = blastBE h1 ++ blastBE l1 ++ crc1 bits2 = blastBE h2 ++ blastBE l2 ++ crc2 -- xor will give us a false if bits match, true if they differ xorBits = zipWith (<+>) bits1 bits2 count [] = 0 count (b:bs) = let r = count bs in ite b (1+r) r -- | Given a hamming distance value @hd@, 'crcGood' returns @true@ if -- the 16 bit polynomial can distinguish all messages that has at most -- @hd@ different bits. Note that we express this conversely: If the -- @sent@ and @received@ messages are different, then it must be the -- case that that must differ from each other (including CRCs), in -- more than @hd@ bits. crcGood :: SWord8 -> SWord16 -> SWord48 -> SWord48 -> SBool crcGood hd poly sent received = sent ./= received ==> diffCount (sent, crcSent) (received, crcReceived) .>= hd where crcSent = crc_48_16 sent poly crcReceived = crc_48_16 received poly -- | Generate good CRC polynomials for 48-bit words, given the hamming distance @hd@. genPoly :: SWord8 -> IO () genPoly hd = do res <- allSat $ do -- the polynomial is existentially specified p <- exists "polynomial" -- sent word, universal s <- do sh <- forall "sh" sl <- forall "sl" return (sh, sl) -- received word, universal r <- do rh <- forall "rh" rl <- forall "rl" return (rh, rl) -- assert that the polynomial @p@ is good. Note -- that we also supply the extra information that -- the least significant bit must be set in the -- polynomial, as all CRC polynomials have the "+1" -- term in them set. This simplifies the query. return $ sTestBit p 0 &&& crcGood hd p s r cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " polynomail(s)." where disp :: Int -> (Bool, Word16) -> IO () disp n (_, s) = putStrLn $ "Polynomial #" ++ show n ++ ". x^16 + " ++ showPolynomial False s -- | Find and display all degree 16 polynomials with hamming distance at least 4, for 48 bit messages. -- -- When run, this function prints: -- -- @ -- Polynomial #1. x^16 + x^2 + x + 1 -- Polynomial #2. x^16 + x^15 + x^2 + 1 -- Polynomial #3. x^16 + x^15 + x^2 + x + 1 -- Polynomial #4. x^16 + x^14 + x^10 + 1 -- Polynomial #5. x^16 + x^14 + x^9 + 1 -- ... -- @ -- -- Note that different runs can produce different results, depending on the random -- numbers used by the solver, solver version, etc. (Also, the solver will take some -- time to generate these results. On my machine, the first five polynomials were -- generated in about 5 minutes.) findHD4Polynomials :: IO () findHD4Polynomials = genPoly 4 {-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/Data/SBV/Examples/Existentials/Diophantine.hs0000644000000000000000000001401112725411266020757 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Existentials.Diophantine -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Finding minimal natural number solutions to linear Diophantine equations, -- using explicit quantification. ----------------------------------------------------------------------------- module Data.SBV.Examples.Existentials.Diophantine where import Data.SBV -------------------------------------------------------------------------------------------------- -- * Representing solutions -------------------------------------------------------------------------------------------------- -- | For a homogeneous problem, the solution is any linear combination of the resulting vectors. -- For a non-homogeneous problem, the solution is any linear combination of the vectors in the -- second component plus one of the vectors in the first component. data Solution = Homogeneous [[Integer]] | NonHomogeneous [[Integer]] [[Integer]] deriving Show -------------------------------------------------------------------------------------------------- -- * Solving diophantine equations -------------------------------------------------------------------------------------------------- -- | ldn: Solve a (L)inear (D)iophantine equation, returning minimal solutions over (N)aturals. -- The input is given as a rows of equations, with rhs values separated into a tuple. ldn :: [([Integer], Integer)] -> IO Solution ldn problem = do solution <- basis (map (map literal) m) if homogeneous then return $ Homogeneous solution else do let ones = [xs | (1:xs) <- solution] zeros = [xs | (0:xs) <- solution] return $ NonHomogeneous ones zeros where rhs = map snd problem lhs = map fst problem homogeneous = all (== 0) rhs m | homogeneous = lhs | True = zipWith (\x y -> -x : y) rhs lhs -- | Find the basis solution. By definition, the basis has all non-trivial (i.e., non-0) solutions -- that cannot be written as the sum of two other solutions. We use the mathematically equivalent -- statement that a solution is in the basis if it's least according to the lexicographic -- order using the ordinary less-than relation. (NB. We explicitly tell z3 to use the logic -- AUFLIA for this problem, as the BV solver that is chosen automatically has a performance -- issue. See: .) basis :: [[SInteger]] -> IO [[Integer]] basis m = extractModels `fmap` allSatWith z3{useLogic = Just (PredefinedLogic AUFLIA)} cond where cond = do as <- mkExistVars n bs <- mkForallVars n return $ ok as &&& (ok bs ==> as .== bs ||| bnot (bs `less` as)) n = if null m then 0 else length (head m) ok xs = bAny (.> 0) xs &&& bAll (.>= 0) xs &&& bAnd [sum (zipWith (*) r xs) .== 0 | r <- m] as `less` bs = bAnd (zipWith (.<=) as bs) &&& bOr (zipWith (.<) as bs) -------------------------------------------------------------------------------------------------- -- * Examples -------------------------------------------------------------------------------------------------- -- | Solve the equation: -- -- @2x + y - z = 2@ -- -- We have: -- -- >>> test -- NonHomogeneous [[0,2,0],[1,0,0]] [[0,1,1],[1,0,2]] -- -- which means that the solutions are of the form: -- -- @(1, 0, 0) + k (0, 1, 1) + k' (1, 0, 2) = (1+k', k, k+2k')@ -- -- OR -- -- @(0, 2, 0) + k (0, 1, 1) + k' (1, 0, 2) = (k', 2+k, k+2k')@ -- -- for arbitrary @k@, @k'@. It's easy to see that these are really solutions -- to the equation given. It's harder to see that they cover all possibilities, -- but a moments thought reveals that is indeed the case. test :: IO Solution test = ldn [([2,1,-1], 2)] -- | A puzzle: Five sailors and a monkey escape from a naufrage and reach an island with -- coconuts. Before dawn, they gather a few of them and decide to sleep first and share -- the next day. At night, however, one of them awakes, counts the nuts, makes five parts, -- gives the remaining nut to the monkey, saves his share away, and sleeps. All other -- sailors do the same, one by one. When they all wake up in the morning, they again make 5 shares, -- and give the last remaining nut to the monkey. How many nuts were there at the beginning? -- -- We can model this as a series of diophantine equations: -- -- @ -- x_0 = 5 x_1 + 1 -- 4 x_1 = 5 x_2 + 1 -- 4 x_2 = 5 x_3 + 1 -- 4 x_3 = 5 x_4 + 1 -- 4 x_4 = 5 x_5 + 1 -- 4 x_5 = 5 x_6 + 1 -- @ -- -- We need to solve for x_0, over the naturals. We have: -- -- >>> sailors -- [15621,3124,2499,1999,1599,1279,1023] -- -- That is: -- -- @ -- * There was a total of 15621 coconuts -- * 1st sailor: 15621 = 3124*5+1, leaving 15621-3124-1 = 12496 -- * 2nd sailor: 12496 = 2499*5+1, leaving 12496-2499-1 = 9996 -- * 3rd sailor: 9996 = 1999*5+1, leaving 9996-1999-1 = 7996 -- * 4th sailor: 7996 = 1599*5+1, leaving 7996-1599-1 = 6396 -- * 5th sailor: 6396 = 1279*5+1, leaving 6396-1279-1 = 5116 -- * In the morning, they had: 5116 = 1023*5+1. -- @ -- -- Note that this is the minimum solution, that is, we are guaranteed that there's -- no solution with less number of coconuts. In fact, any member of @[15625*k-4 | k <- [1..]]@ -- is a solution, i.e., so are @31246@, @46871@, @62496@, @78121@, etc. sailors :: IO [Integer] sailors = do NonHomogeneous (xs:_) _ <- ldn [ ([1, -5, 0, 0, 0, 0, 0], 1) , ([0, 4, -5 , 0, 0, 0, 0], 1) , ([0, 0, 4, -5 , 0, 0, 0], 1) , ([0, 0, 0, 4, -5, 0, 0], 1) , ([0, 0, 0, 0, 4, -5, 0], 1) , ([0, 0, 0, 0, 0, 4, -5], 1) ] return xs sbv-5.12/Data/SBV/Examples/Misc/0000755000000000000000000000000012725411266014403 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Misc/Auxiliary.hs0000644000000000000000000000432112725411266016706 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.Auxiliary -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates model construction with auxiliary variables. Sometimes we -- need to introduce a variable in our problem as an existential variable, -- but it's "internal" to the problem and we do not consider it as part of -- the solution. Also, in an `allSat` scenario, we may not care for models -- that only differ in these auxiliaries. SBV allows designating such variables -- as `isNonModelVar` so we can still use them like any other variable, but without -- considering them explicitly in model construction. ----------------------------------------------------------------------------- module Data.SBV.Examples.Misc.Auxiliary where import Data.SBV -- | A simple predicate, based on two variables @x@ and @y@, true when -- @0 <= x <= 1@ and @x - abs y@ is @0@. problem :: Predicate problem = do x <- free "x" y <- free "y" constrain $ x .>= 0 constrain $ x .<= 1 return $ x - abs y .== (0 :: SInteger) -- | Generate all satisfying assignments for our problem. We have: -- -- >>> allModels -- Solution #1: -- x = 0 :: Integer -- y = 0 :: Integer -- Solution #2: -- x = 1 :: Integer -- y = -1 :: Integer -- Solution #3: -- x = 1 :: Integer -- y = 1 :: Integer -- Found 3 different solutions. -- -- Note that solutions @2@ and @3@ share the value @x = 1@, since there are -- multiple values of @y@ that make this particular choice of @x@ satisfy our constraint. allModels :: IO AllSatResult allModels = allSat problem -- | Generate all satisfying assignments, but we first tell SBV that @y@ should not be considered -- as a model problem, i.e., it's auxiliary. We have: -- -- >>> modelsWithYAux -- Solution #1: -- x = 0 :: Integer -- Solution #2: -- x = 1 :: Integer -- Found 2 different solutions. -- -- Note that we now have only two solutions, one for each unique value of @x@ that satisfy our -- constraint. modelsWithYAux :: IO AllSatResult modelsWithYAux = allSatWith z3{isNonModelVar = (`elem` ["y"])} problem sbv-5.12/Data/SBV/Examples/Misc/Enumerate.hs0000644000000000000000000000475512725411266016677 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.Enumerate -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates how enumerations can be translated to their SMT-Lib -- counterparts, without losing any information content. Also see -- "Data.SBV.Examples.Puzzles.U2Bridge" for a more detailed -- example involving enumerations. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Examples.Misc.Enumerate where import Data.SBV import Data.Generics -- | A simple enumerated type, that we'd like to translate to SMT-Lib intact; -- i.e., this type will not be uninterpreted but rather preserved and will -- be just like any other symbolic type SBV provides. Note the automatically -- derived classes we need: 'Eq', 'Ord', 'Data', 'Read', 'Show', 'SymWord', -- 'HasKind', and 'SatModel'. (The last one is only needed if 'getModel' and friends are used.) -- -- Also note that we need to @import Data.Generics@ and have the @LANGUAGE@ -- option @DeriveDataTypeable@ and @DeriveAnyClass@ set. data E = A | B | C deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Give a name to the symbolic variants of 'E', for convenience type SE = SBV E -- | Have the SMT solver enumerate the elements of the domain. We have: -- -- >>> elts -- Solution #1: -- s0 = A :: E -- Solution #2: -- s0 = B :: E -- Solution #3: -- s0 = C :: E -- Found 3 different solutions. elts :: IO AllSatResult elts = allSat $ \(x::SE) -> x .== x -- | Shows that if we require 4 distinct elements of the type 'E', we shall fail; as -- the domain only has three elements. We have: -- -- >>> four -- Unsatisfiable four :: IO SatResult four = sat $ \a b c (d::SE) -> allDifferent [a, b, c, d] -- | Enumerations are automatically ordered, so we can ask for the maximum -- element. Note the use of quantification. We have: -- -- >>> maxE -- Satisfiable. Model: -- maxE = C :: E maxE :: IO SatResult maxE = sat $ do mx <- exists "maxE" e <- forall "e" return $ mx .>= (e::SE) -- | Similarly, we get the minumum element. We have: -- -- >>> minE -- Satisfiable. Model: -- minE = A :: E minE :: IO SatResult minE = sat $ do mx <- exists "minE" e <- forall "e" return $ mx .<= (e::SE) sbv-5.12/Data/SBV/Examples/Misc/Floating.hs0000644000000000000000000001613212725411266016505 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.Floating -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Several examples involving IEEE-754 floating point numbers, i.e., single -- precision 'Float' ('SFloat') and double precision 'Double' ('SDouble') types. -- -- Note that arithmetic with floating point is full of surprises; due to precision -- issues associativity of arithmetic operations typically do not hold. Also, -- the presence of @NaN@ is always something to look out for. ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Examples.Misc.Floating where import Data.SBV ----------------------------------------------------------------------------- -- * FP addition is not associative ----------------------------------------------------------------------------- -- | Prove that floating point addition is not associative. For illustration purposes, -- we will require one of the inputs to be a @NaN@. We have: -- -- >>> prove $ assocPlus (0/0) -- Falsifiable. Counter-example: -- s0 = 0.0 :: Float -- s1 = 0.0 :: Float -- -- Indeed: -- -- >>> let i = 0/0 :: Float -- >>> i + (0.0 + 0.0) -- NaN -- >>> ((i + 0.0) + 0.0) -- NaN -- -- But keep in mind that @NaN@ does not equal itself in the floating point world! We have: -- -- >>> let nan = 0/0 :: Float in nan == nan -- False assocPlus :: SFloat -> SFloat -> SFloat -> SBool assocPlus x y z = x + (y + z) .== (x + y) + z -- | Prove that addition is not associative, even if we ignore @NaN@/@Infinity@ values. -- To do this, we use the predicate 'fpIsPoint', which is true of a floating point -- number ('SFloat' or 'SDouble') if it is neither @NaN@ nor @Infinity@. (That is, it's a -- representable point in the real-number line.) -- -- We have: -- -- >>> assocPlusRegular -- Falsifiable. Counter-example: -- x = 5.5511693e-15 :: Float -- y = -2.2204438e-16 :: Float -- z = -3.1763606e-21 :: Float -- -- Indeed, we have: -- -- >>> ((5.5511693e-15) + ((-2.2204438e-16) + (-3.1763606e-21))) :: Float -- 5.3291218e-15 -- >>> (((5.5511693e-15) + (-2.2204438e-16)) + (-3.1763606e-21)) :: Float -- 5.329122e-15 -- -- Note the difference between two additions! assocPlusRegular :: IO ThmResult assocPlusRegular = prove $ do [x, y, z] <- sFloats ["x", "y", "z"] let lhs = x+(y+z) rhs = (x+y)+z -- make sure we do not overflow at the intermediate points constrain $ fpIsPoint lhs constrain $ fpIsPoint rhs return $ lhs .== rhs ----------------------------------------------------------------------------- -- * FP addition by non-zero can result in no change ----------------------------------------------------------------------------- -- | Demonstrate that @a+b = a@ does not necessarily mean @b@ is @0@ in the floating point world, -- even when we disallow the obvious solution when @a@ and @b@ are @Infinity.@ -- We have: -- -- >>> nonZeroAddition -- Falsifiable. Counter-example: -- a = 5.1705105e-26 :: Float -- b = -3.8518597e-34 :: Float -- -- Indeed, we have: -- -- >>> (5.1705105e-26 + (-3.8518597e-34)) == (5.1705105e-26 :: Float) -- True -- -- But: -- -- >>> -3.8518597e-34 == (0::Float) -- False -- nonZeroAddition :: IO ThmResult nonZeroAddition = prove $ do [a, b] <- sFloats ["a", "b"] constrain $ fpIsPoint a constrain $ fpIsPoint b constrain $ a + b .== a return $ b .== 0 ----------------------------------------------------------------------------- -- * FP multiplicative inverses may not exist ----------------------------------------------------------------------------- -- | This example illustrates that @a * (1/a)@ does not necessarily equal @1@. Again, -- we protect against division by @0@ and @NaN@/@Infinity@. -- -- We have: -- -- >>> multInverse -- Falsifiable. Counter-example: -- a = 8.988465674311586e307 :: Double -- -- Indeed, we have: -- -- >>> let a = 8.988465674311586e307 :: Double -- >>> a * (1/a) -- 1.0000000000000002 multInverse :: IO ThmResult multInverse = prove $ do a <- sDouble "a" constrain $ fpIsPoint a constrain $ fpIsPoint (1/a) return $ a * (1/a) .== 1 ----------------------------------------------------------------------------- -- * Effect of rounding modes ----------------------------------------------------------------------------- -- | One interesting aspect of floating-point is that the chosen rounding-mode -- can effect the results of a computation if the exact result cannot be precisely -- represented. SBV exports the functions 'fpAdd', 'fpSub', 'fpMul', 'fpDiv', 'fpFMA' -- and 'fpSqrt' which allows users to specify the IEEE supported 'RoundingMode' for -- the operation. (Also see the class 'RoundingFloat'.) This example illustrates how SBV -- can be used to find rounding-modes where, for instance, addition can produce different -- results. We have: -- -- >>> roundingAdd -- Satisfiable. Model: -- rm = RoundTowardPositive :: RoundingMode -- x = 1.9531249 :: Float -- y = 6.2499996e-2 :: Float -- -- (Note that depending on your version of Z3, you might get a different result.) -- Unfortunately we can't directly validate this result at the Haskell level, as Haskell only supports -- 'RoundNearestTiesToEven'. We have: -- -- >>> (1.9531249 + 6.2499996e-2) :: Float -- 2.0156248 -- -- While we cannot directly see the result when the mode is 'RoundTowardPositive' in Haskell, we can use -- SBV to provide us with that result thusly: -- -- >>> sat $ \z -> z .== fpAdd sRoundTowardPositive 1.9531249 (6.2499996e-2 :: SFloat) -- Satisfiable. Model: -- s0 = 2.015625 :: Float -- -- We can see why these two resuls are indeed different. But we can see that the 'RoundTowardsPositive' -- (which rounds towards positive-infinity) produces a larger result. Indeed, if we treat these numbers -- as 'Double' values, we get: -- -- >>> (1.9531249 + 6.2499996e-2) :: Double -- 2.015624896 -- -- we see that the "more precise" result is larger than what the 'Float' value is, justifying the -- larger value with 'RoundTowardPositive'. A more detailed study is beyond our current scope, so we'll -- merely -- note that floating point representation and semantics is indeed a thorny -- subject, and point to as -- an excellent guide. roundingAdd :: IO SatResult roundingAdd = sat $ do m :: SRoundingMode <- free "rm" constrain $ m ./= literal RoundNearestTiesToEven x <- sFloat "x" y <- sFloat "y" let lhs = fpAdd m x y let rhs = x + y constrain $ fpIsPoint lhs constrain $ fpIsPoint rhs return $ lhs ./= rhs sbv-5.12/Data/SBV/Examples/Misc/ModelExtract.hs0000644000000000000000000000401412725411266017331 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.ModelExtract -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates use of programmatic model extraction. When programming with -- SBV, we typically use `sat`/`allSat` calls to compute models automatically. -- In more advanced uses, however, the user might want to use programmable -- extraction features to do fancier programming. We demonstrate some of -- these utilities here. ----------------------------------------------------------------------------- module Data.SBV.Examples.Misc.ModelExtract where import Data.SBV -- | A simple function to generate a new integer value, that is not in the -- given set of values. We also require the value to be non-negative outside :: [Integer] -> IO SatResult outside disallow = sat $ do x <- sInteger "x" let notEq i = constrain $ x ./= literal i mapM_ notEq disallow return $ x .>= 0 -- | We now use "outside" repeatedly to generate 10 integers, such that we not only disallow -- previously generated elements, but also any value that differs from previous solutions -- by less than 5. Here, we use the `getModelValue` function. We could have also extracted the dictionary -- via `getModelDictionary` and did fancier programming as well, as necessary. We have: -- -- >>> genVals -- [45,40,35,30,25,20,15,10,5,0] genVals :: IO [Integer] genVals = go [] [] where go _ model | length model >= 10 = return model go disallow model = do res <- outside disallow -- Look up the value of "x" in the generated model -- Note that we simply get an integer here; but any -- SBV known type would be OK as well. case "x" `getModelValue` res of Just c -> go [c-4 .. c+4] (c : model) _ -> return model sbv-5.12/Data/SBV/Examples/Misc/NoDiv0.hs0000644000000000000000000000265312725411266016044 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.NoDiv0 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates SBV's assertion checking facilities ----------------------------------------------------------------------------- {-# LANGUAGE ImplicitParams #-} module Data.SBV.Examples.Misc.NoDiv0 where import Data.SBV import GHC.Stack -- | A simple variant of division, where we explicitly require the -- caller to make sure the divisor is not 0. checkedDiv :: (?loc :: CallStack) => SInt32 -> SInt32 -> SInt32 checkedDiv x y = sAssert (Just ?loc) "Divisor should not be 0" (y ./= 0) (x `sDiv` y) -- | Check whether an arbitrary call to 'checkedDiv' is safe. Clearly, we do not expect -- this to be safe: -- -- >>> test1 -- [Data/SBV/Examples/Misc/NoDiv0.hs:36:14:checkedDiv: Divisor should not be 0: Violated. Model: -- s0 = 0 :: Int32 -- s1 = 0 :: Int32] -- test1 :: IO [SafeResult] test1 = safe checkedDiv -- | Repeat the test, except this time we explicitly protect against the bad case. We have: -- -- >>> test2 -- [Data/SBV/Examples/Misc/NoDiv0.hs:44:41:checkedDiv: Divisor should not be 0: No violations detected] -- test2 :: IO [SafeResult] test2 = safe $ \x y -> ite (y .== 0) 3 (checkedDiv x y) sbv-5.12/Data/SBV/Examples/Misc/Word4.hs0000644000000000000000000001167512725411266015750 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Misc.Enumerate -- Copyright : (c) Brian Huffman -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates how new sizes of word/int types can be defined and -- used with SBV. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} module Data.SBV.Examples.Misc.Word4 where import GHC.Enum (boundedEnumFrom, boundedEnumFromThen, toEnumError, succError, predError) import Data.Bits import Data.Generics (Data, Typeable) import System.Random (Random(..)) import Data.SBV import Data.SBV.Internals -- | Word4 as a newtype. Invariant: @Word4 x@ should satisfy @x < 16@. newtype Word4 = Word4 Word8 deriving (Eq, Ord, Data, Typeable) -- | Smart constructor; simplifies conversion from Word8 word4 :: Word8 -> Word4 word4 x = Word4 (x .&. 0x0f) -- | Show instance instance Show Word4 where show (Word4 x) = show x -- | Read instance. We read as an 8-bit word, and coerce instance Read Word4 where readsPrec p s = [ (word4 x, s') | (x, s') <- readsPrec p s ] -- | Bounded instance; from 0 to 255 instance Bounded Word4 where minBound = Word4 0x00 maxBound = Word4 0x0f -- | Enum instance, trivial definitions. instance Enum Word4 where succ (Word4 x) = if x < 0x0f then Word4 (succ x) else succError "Word4" pred (Word4 x) = if x > 0x00 then Word4 (pred x) else predError "Word4" toEnum i | 0x00 <= i && i <= 0x0f = Word4 (toEnum i) | otherwise = toEnumError "Word4" i (Word4 0x00, Word4 0x0f) fromEnum (Word4 x) = fromEnum x -- Comprehensions enumFrom = boundedEnumFrom enumFromThen = boundedEnumFromThen enumFromTo (Word4 x) (Word4 y) = map Word4 (enumFromTo x y) enumFromThenTo (Word4 x) (Word4 y) (Word4 z) = map Word4 (enumFromThenTo x y z) -- | Num instance, merely lifts underlying 8-bit operation and casts back instance Num Word4 where Word4 x + Word4 y = word4 (x + y) Word4 x * Word4 y = word4 (x * y) Word4 x - Word4 y = word4 (x - y) negate (Word4 x) = word4 (negate x) abs (Word4 x) = Word4 x signum (Word4 x) = Word4 (if x == 0 then 0 else 1) fromInteger n = word4 (fromInteger n) -- | Real instance simply uses the Word8 instance instance Real Word4 where toRational (Word4 x) = toRational x -- | Integral instance, again using Word8 instance and casting. NB. we do -- not need to use the smart constructor here as neither the quotient nor -- the remainder can overflow a Word4. instance Integral Word4 where quotRem (Word4 x) (Word4 y) = (Word4 q, Word4 r) where (q, r) = quotRem x y toInteger (Word4 x) = toInteger x -- | Bits instance instance Bits Word4 where Word4 x .&. Word4 y = Word4 (x .&. y) Word4 x .|. Word4 y = Word4 (x .|. y) Word4 x `xor` Word4 y = Word4 (x `xor` y) complement (Word4 x) = Word4 (x `xor` 0x0f) Word4 x `shift` i = word4 (shift x i) Word4 x `shiftL` i = word4 (shiftL x i) Word4 x `shiftR` i = Word4 (shiftR x i) Word4 x `rotate` i = word4 (x `shiftL` k .|. x `shiftR` (4-k)) where k = i .&. 3 bitSize _ = 4 bitSizeMaybe _ = Just 4 isSigned _ = False testBit (Word4 x) = testBit x bit i = word4 (bit i) popCount (Word4 x) = popCount x -- | Random instance, used in quick-check instance Random Word4 where randomR (Word4 lo, Word4 hi) gen = (Word4 x, gen') where (x, gen') = randomR (lo, hi) gen random gen = (Word4 x, gen') where (x, gen') = randomR (0x00, 0x0f) gen -- | SWord4 type synonym type SWord4 = SBV Word4 -- | SymWord instance, allowing this type to be used in proofs/sat etc. instance SymWord Word4 where mkSymWord = genMkSymVar (KBounded False 4) literal = genLiteral (KBounded False 4) fromCW = genFromCW -- | HasKind instance; simply returning the underlying kind for the type instance HasKind Word4 where kindOf _ = KBounded False 4 -- | SatModel instance, merely uses the generic parsing method. instance SatModel Word4 where parseCWs = genParse (KBounded False 4) -- | SDvisible instance, using 0-extension instance SDivisible Word4 where sQuotRem x 0 = (0, x) sQuotRem x y = x `quotRem` y sDivMod x 0 = (0, x) sDivMod x y = x `divMod` y -- | SDvisible instance, using default methods instance SDivisible SWord4 where sQuotRem = liftQRem sDivMod = liftDMod -- | SIntegral instance, using default methods instance SIntegral Word4 -- | Conversion from bits instance FromBits SWord4 where fromBitsLE = checkAndConvert 4 -- | Joining/splitting to/from Word8 instance Splittable Word8 Word4 where split x = (Word4 (x `shiftR` 4), word4 x) Word4 x # Word4 y = (x `shiftL` 4) .|. y extend (Word4 x) = x sbv-5.12/Data/SBV/Examples/Polynomials/0000755000000000000000000000000012725411266016016 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Polynomials/Polynomials.hs0000644000000000000000000000546312725411266020670 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Polynomials.Polynomials -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Simple usage of polynomials over GF(2^n), using Rijndael's -- finite field: -- -- The functions available are: -- -- [/pMult/] GF(2^n) Multiplication -- -- [/pDiv/] GF(2^n) Division -- -- [/pMod/] GF(2^n) Modulus -- -- [/pDivMod/] GF(2^n) Division/Modulus, packed together -- -- Note that addition in GF(2^n) is simply `xor`, so no custom function is provided. ----------------------------------------------------------------------------- module Data.SBV.Examples.Polynomials.Polynomials where import Data.SBV -- | Helper synonym for representing GF(2^8); which are merely 8-bit unsigned words. Largest -- term in such a polynomial has degree 7. type GF28 = SWord8 -- | Multiplication in Rijndael's field; usual polynomial multiplication followed by reduction -- by the irreducible polynomial. The irreducible used by Rijndael's field is the polynomial -- @x^8 + x^4 + x^3 + x + 1@, which we write by giving it's /exponents/ in SBV. -- See: . -- Note that the irreducible itself is not in GF28! It has a degree of 8. -- -- NB. You can use the 'showPoly' function to print polynomials nicely, as a mathematician would write. gfMult :: GF28 -> GF28 -> GF28 a `gfMult` b = pMult (a, b, [8, 4, 3, 1, 0]) -- | States that the unit polynomial @1@, is the unit element multUnit :: GF28 -> SBool multUnit x = (x `gfMult` unit) .== x where unit = polynomial [0] -- x@0 -- | States that multiplication is commutative multComm :: GF28 -> GF28 -> SBool multComm x y = (x `gfMult` y) .== (y `gfMult` x) -- | States that multiplication is associative, note that associativity -- proofs are notoriously hard for SAT/SMT solvers multAssoc :: GF28 -> GF28 -> GF28 -> SBool multAssoc x y z = ((x `gfMult` y) `gfMult` z) .== (x `gfMult` (y `gfMult` z)) -- | States that the usual multiplication rule holds over GF(2^n) polynomials -- Checks: -- -- @ -- if (a, b) = x `pDivMod` y then x = y `pMult` a + b -- @ -- -- being careful about @y = 0@. When divisor is 0, then quotient is -- defined to be 0 and the remainder is the numerator. -- (Note that addition is simply `xor` in GF(2^8).) polyDivMod :: GF28 -> GF28 -> SBool polyDivMod x y = ite (y .== 0) ((0, x) .== (a, b)) (x .== (y `gfMult` a) `xor` b) where (a, b) = x `pDivMod` y -- | Queries testGF28 :: IO () testGF28 = do print =<< prove multUnit print =<< prove multComm -- print =<< prove multAssoc -- takes too long; see above note.. print =<< prove polyDivMod sbv-5.12/Data/SBV/Examples/Puzzles/0000755000000000000000000000000012725411266015164 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Puzzles/Birthday.hs0000644000000000000000000001353412725411266017274 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Birthday -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- This is a formalization of the Cheryl's birtday problem, which went viral in April 2015. -- (See .) -- -- Here's the puzzle: -- -- @ -- Albert and Bernard just met Cheryl. “When’s your birthday?” Albert asked Cheryl. -- -- Cheryl thought a second and said, “I’m not going to tell you, but I’ll give you some clues.” She wrote down a list of 10 dates: -- -- May 15, May 16, May 19 -- June 17, June 18 -- July 14, July 16 -- August 14, August 15, August 17 -- -- “My birthday is one of these,” she said. -- -- Then Cheryl whispered in Albert’s ear the month — and only the month — of her birthday. To Bernard, she whispered the day, and only the day. -- “Can you figure it out now?” she asked Albert. -- -- Albert: I don’t know when your birthday is, but I know Bernard doesn’t know, either. -- Bernard: I didn’t know originally, but now I do. -- Albert: Well, now I know, too! -- -- When is Cheryl’s birthday? -- @ -- -- NB. Thanks to Amit Goel for suggesting the formalization strategy used in here. ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.Birthday where import Data.SBV ----------------------------------------------------------------------------------------------- -- * Types and values ----------------------------------------------------------------------------------------------- -- | Represent month by 8-bit words; We can also use an uninterpreted type, but numbers work well here. type Month = SWord8 -- | Represent day by 8-bit words; Again, an uninterpreted type would work as well. type Day = SWord8 -- | Months referenced in the problem. may, june, july, august :: SWord8 [may, june, july, august] = [5, 6, 7, 8] ----------------------------------------------------------------------------------------------- -- * Helper predicates ----------------------------------------------------------------------------------------------- -- | Check that a given month/day combo is a possible birth-date. valid :: Month -> Day -> SBool valid month day = (month, day) `sElem` candidates where candidates :: [(Month, Day)] candidates = [ ( may, 15), ( may, 16), ( may, 19) , ( june, 17), ( june, 18) , ( july, 14), ( july, 16) , (august, 14), (august, 15), (august, 17) ] -- | Assert that the given function holds for one of the possible days. existsDay :: (Day -> SBool) -> SBool existsDay f = bAny (f . literal) [14 .. 19] -- | Assert that the given function holds for all of the possible days. forallDay :: (Day -> SBool) -> SBool forallDay f = bAll (f . literal) [14 .. 19] -- | Assert that the given function holds for one of the possible months. existsMonth :: (Month -> SBool) -> SBool existsMonth f = bAny f [may .. august] -- | Assert that the given function holds for all of the possible months. forallMonth :: (Month -> SBool) -> SBool forallMonth f = bAll f [may .. august] ----------------------------------------------------------------------------------------------- -- * The puzzle ----------------------------------------------------------------------------------------------- -- | Encode the conversation as given in the puzzle. -- -- NB. Lee Pike pointed out that not all the constraints are actually necessary! (Private -- communication.) The puzzle still has a unique solution if the statements 'a1' and 'b1' -- (i.e., Albert and Bernard saying they themselves do not know the answer) are removed. -- To experiment you can simply comment out those statements and observe that there still -- is a unique solution. Thanks to Lee for pointing this out! In fact, it is instructive to -- assert the conversation line-by-line, and see how the search-space gets reduced in each -- step. puzzle :: Predicate puzzle = do birthDay <- exists "birthDay" birthMonth <- exists "birthMonth" -- Albert: I do not know let a1 m = existsDay $ \d1 -> existsDay $ \d2 -> d1 ./= d2 &&& valid m d1 &&& valid m d2 -- Albert: I know that Bernard doesn't know let a2 m = forallDay $ \d -> valid m d ==> existsMonth (\m1 -> existsMonth $ \m2 -> m1 ./= m2 &&& valid m1 d &&& valid m2 d) -- Bernard: I did not know let b1 d = existsMonth $ \m1 -> existsMonth $ \m2 -> m1 ./= m2 &&& valid m1 d &&& valid m2 d -- Bernard: But now I know let b2p m d = valid m d &&& a1 m &&& a2 m b2 d = forallMonth $ \m1 -> forallMonth $ \m2 -> (b2p m1 d &&& b2p m2 d) ==> m1 .== m2 -- Albert: Now I know too let a3p m d = valid m d &&& a1 m &&& a2 m &&& b1 d &&& b2 d a3 m = forallDay $ \d1 -> forallDay $ \d2 -> (a3p m d1 &&& a3p m d2) ==> d1 .== d2 -- Assert all the statements made: constrain $ a1 birthMonth constrain $ a2 birthMonth constrain $ b1 birthDay constrain $ b2 birthDay constrain $ a3 birthMonth -- Find a valid birth-day that satisfies the above constraints: return $ valid birthMonth birthDay -- | Find all solutions to the birthday problem. We have: -- -- >>> cheryl -- Solution #1: -- birthDay = 16 :: Word8 -- birthMonth = 7 :: Word8 -- This is the only solution. cheryl :: IO () cheryl = print =<< allSat puzzle sbv-5.12/Data/SBV/Examples/Puzzles/Coins.hs0000644000000000000000000000762512725411266016605 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Coins -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Solves the following puzzle: -- -- @ -- You and a friend pass by a standard coin operated vending machine and you decide to get a candy bar. -- The price is US $0.95, but after checking your pockets you only have a dollar (US $1) and the machine -- only takes coins. You turn to your friend and have this conversation: -- you: Hey, do you have change for a dollar? -- friend: Let's see. I have 6 US coins but, although they add up to a US $1.15, I can't break a dollar. -- you: Huh? Can you make change for half a dollar? -- friend: No. -- you: How about a quarter? -- friend: Nope, and before you ask I cant make change for a dime or nickel either. -- you: Really? and these six coins are all US government coins currently in production? -- friend: Yes. -- you: Well can you just put your coins into the vending machine and buy me a candy bar, and I'll pay you back? -- friend: Sorry, I would like to but I cant with the coins I have. -- What coins are your friend holding? -- @ -- -- To be fair, the problem has no solution /mathematically/. But there is a solution when one takes into account that -- vending machines typically do not take the 50 cent coins! -- ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.Coins where import Data.SBV -- | We will represent coins with 16-bit words (more than enough precision for coins). type Coin = SWord16 -- | Create a coin. The argument Int argument just used for naming the coin. Note that -- we constrain the value to be one of the valid U.S. coin values as we create it. mkCoin :: Int -> Symbolic Coin mkCoin i = do c <- exists $ 'c' : show i constrain $ bAny (.== c) [1, 5, 10, 25, 50, 100] return c -- | Return all combinations of a sequence of values. combinations :: [a] -> [[a]] combinations coins = concat [combs i coins | i <- [1 .. length coins]] where combs 0 _ = [[]] combs _ [] = [] combs k (x:xs) = map (x:) (combs (k-1) xs) ++ combs k xs -- | Constraint 1: Cannot make change for a dollar. c1 :: [Coin] -> SBool c1 xs = sum xs ./= 100 -- | Constraint 2: Cannot make change for half a dollar. c2 :: [Coin] -> SBool c2 xs = sum xs ./= 50 -- | Constraint 3: Cannot make change for a quarter. c3 :: [Coin] -> SBool c3 xs = sum xs ./= 25 -- | Constraint 4: Cannot make change for a dime. c4 :: [Coin] -> SBool c4 xs = sum xs ./= 10 -- | Constraint 5: Cannot make change for a nickel c5 :: [Coin] -> SBool c5 xs = sum xs ./= 5 -- | Constraint 6: Cannot buy the candy either. Here's where we need to have the extra knowledge -- that the vending machines do not take 50 cent coins. c6 :: [Coin] -> SBool c6 xs = sum (map val xs) ./= 95 where val x = ite (x .== 50) 0 x -- | Solve the puzzle. We have: -- -- >>> puzzle -- Satisfiable. Model: -- c1 = 50 :: Word16 -- c2 = 25 :: Word16 -- c3 = 10 :: Word16 -- c4 = 10 :: Word16 -- c5 = 10 :: Word16 -- c6 = 10 :: Word16 -- -- i.e., your friend has 4 dimes, a quarter, and a half dollar. puzzle :: IO SatResult puzzle = sat $ do cs <- mapM mkCoin [1..6] -- Assert each of the constraints for all combinations that has -- at least two coins (to make change) mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]] -- the following constraint is not necessary for solving the puzzle -- however, it makes sure that the solution comes in decreasing value of coins, -- thus allowing the above test to succeed regardless of the solver used. constrain $ bAnd $ zipWith (.>=) cs (tail cs) -- assert that the sum must be 115 cents. return $ sum cs .== 115 sbv-5.12/Data/SBV/Examples/Puzzles/Counts.hs0000644000000000000000000000666312725411266017006 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Counts -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Consider the sentence: -- -- @ -- In this sentence, the number of occurrences of 0 is _, of 1 is _, of 2 is _, -- of 3 is _, of 4 is _, of 5 is _, of 6 is _, of 7 is _, of 8 is _, and of 9 is _. -- @ -- -- The puzzle is to fill the blanks with numbers, such that the sentence -- will be correct. There are precisely two solutions to this puzzle, both of -- which are found by SBV successfully. -- -- References: -- -- * Douglas Hofstadter, Metamagical Themes, pg. 27. -- -- * -- ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.Counts where import Data.SBV -- | We will assume each number can be represented by an 8-bit word, i.e., can be at most 128. type Count = SWord8 -- | Given a number, increment the count array depending on the digits of the number count :: Count -> [Count] -> [Count] count n cnts = ite (n .< 10) (upd n cnts) -- only one digit (ite (n .< 100) (upd d1 (upd d2 cnts)) -- two digits (upd d1 (upd d2 (upd d3 cnts)))) -- three digits where (r1, d1) = n `sQuotRem` 10 (d3, d2) = r1 `sQuotRem` 10 upd d = zipWith inc [0..] where inc i c = ite (i .== d) (c+1) c -- | Encoding of the puzzle. The solution is a sequence of 10 numbers -- for the occurrences of the digits such that if we count each digit, -- we find these numbers. puzzle :: [Count] -> SBool puzzle cnt = cnt .== last css where ones = replicate 10 1 -- all digits occur once to start with css = ones : zipWith count cnt css -- | Finds all two known solutions to this puzzle. We have: -- -- >>> counts -- Solution #1 -- In this sentence, the number of occurrences of 0 is 1, of 1 is 11, of 2 is 2, of 3 is 1, of 4 is 1, of 5 is 1, of 6 is 1, of 7 is 1, of 8 is 1, of 9 is 1. -- Solution #2 -- In this sentence, the number of occurrences of 0 is 1, of 1 is 7, of 2 is 3, of 3 is 2, of 4 is 1, of 5 is 1, of 6 is 1, of 7 is 2, of 8 is 1, of 9 is 1. -- Found: 2 solution(s). counts :: IO () counts = do res <- allSat $ puzzle `fmap` mkExistVars 10 cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " solution(s)." where disp n (_, s) = do putStrLn $ "Solution #" ++ show n dispSolution s dispSolution :: [Word8] -> IO () dispSolution ns = putStrLn soln where soln = "In this sentence, the number of occurrences" ++ " of 0 is " ++ show (ns !! 0) ++ ", of 1 is " ++ show (ns !! 1) ++ ", of 2 is " ++ show (ns !! 2) ++ ", of 3 is " ++ show (ns !! 3) ++ ", of 4 is " ++ show (ns !! 4) ++ ", of 5 is " ++ show (ns !! 5) ++ ", of 6 is " ++ show (ns !! 6) ++ ", of 7 is " ++ show (ns !! 7) ++ ", of 8 is " ++ show (ns !! 8) ++ ", of 9 is " ++ show (ns !! 9) ++ "." {-# ANN counts ("HLint: ignore Use head" :: String) #-} sbv-5.12/Data/SBV/Examples/Puzzles/DogCatMouse.hs0000644000000000000000000000270412725411266017675 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.DogCatMouse -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Puzzle: -- Spend exactly 100 dollars and buy exactly 100 animals. -- Dogs cost 15 dollars, cats cost 1 dollar, and mice cost 25 cents each. -- You have to buy at least one of each. -- How many of each should you buy? ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.DogCatMouse where import Data.SBV -- | Prints the only solution: -- -- >>> puzzle -- Solution #1: -- dog = 3 :: Integer -- cat = 41 :: Integer -- mouse = 56 :: Integer -- This is the only solution. puzzle :: IO AllSatResult puzzle = allSat $ do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"] solve [ dog .>= 1 -- at least one dog , cat .>= 1 -- at least one cat , mouse .>= 1 -- at least one mouse , dog + cat + mouse .== 100 -- buy precisely 100 animals , 15 `per` dog + 1 `per` cat + 0.25 `per` mouse .== 100 -- spend exactly 100 dollars ] where p `per` q = p * sIntegerToSReal q sbv-5.12/Data/SBV/Examples/Puzzles/Euler185.hs0000644000000000000000000000436112725411266017036 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Euler185 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- A solution to Project Euler problem #185: ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.Euler185 where import Data.Char(ord) import Data.SBV -- | The given guesses and the correct digit counts, encoded as a simple list. guesses :: [(String, SWord8)] guesses = [ ("5616185650518293", 2), ("3847439647293047", 1), ("5855462940810587", 3) , ("9742855507068353", 3), ("4296849643607543", 3), ("3174248439465858", 1) , ("4513559094146117", 2), ("7890971548908067", 3), ("8157356344118483", 1) , ("2615250744386899", 2), ("8690095851526254", 3), ("6375711915077050", 1) , ("6913859173121360", 1), ("6442889055042768", 2), ("2321386104303845", 0) , ("2326509471271448", 2), ("5251583379644322", 2), ("1748270476758276", 3) , ("4895722652190306", 1), ("3041631117224635", 3), ("1841236454324589", 3) , ("2659862637316867", 2) ] -- | Encode the problem, note that we check digits are within 0-9 as -- we use 8-bit words to represent them. Otherwise, the constraints are simply -- generated by zipping the alleged solution with each guess, and making sure the -- number of matching digits match what's given in the problem statement. euler185 :: Symbolic SBool euler185 = do soln <- mkExistVars 16 return $ bAll digit soln &&& bAnd (map (genConstr soln) guesses) where genConstr a (b, c) = sum (zipWith eq a b) .== (c :: SWord8) digit x = (x :: SWord8) .>= 0 &&& x .<= 9 eq x y = ite (x .== fromIntegral (ord y - ord '0')) 1 0 -- | Print out the solution nicely. We have: -- -- >>> solveEuler185 -- 4640261571849533 -- Number of solutions: 1 solveEuler185 :: IO () solveEuler185 = do res <- allSat euler185 cnt <- displayModels disp res putStrLn $ "Number of solutions: " ++ show cnt where disp _ (_, ss) = putStrLn $ concatMap show (ss :: [Word8]) sbv-5.12/Data/SBV/Examples/Puzzles/Fish.hs0000644000000000000000000001103712725411266016413 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Fish -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Solves the following logic puzzle: -- -- - The Briton lives in the red house. -- - The Swede keeps dogs as pets. -- - The Dane drinks tea. -- - The green house is left to the white house. -- - The owner of the green house drinks coffee. -- - The person who plays football rears birds. -- - The owner of the yellow house plays baseball. -- - The man living in the center house drinks milk. -- - The Norwegian lives in the first house. -- - The man who plays volleyball lives next to the one who keeps cats. -- - The man who keeps the horse lives next to the one who plays baseball. -- - The owner who plays tennis drinks beer. -- - The German plays hockey. -- - The Norwegian lives next to the blue house. -- - The man who plays volleyball has a neighbor who drinks water. -- -- Who owns the fish? ------------------------------------------------------------------------------ {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Examples.Puzzles.Fish where import Data.Generics import Data.SBV -- | Colors of houses data Color = Red | Green | White | Yellow | Blue deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Nationalities of the occupants data Nationality = Briton | Dane | Swede | Norwegian | German deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Beverage choices data Beverage = Tea | Coffee | Milk | Beer | Water deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Pets they keep data Pet = Dog | Horse | Cat | Bird | Fish deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Sports they engage in data Sport = Football | Baseball | Volleyball | Hockey | Tennis deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | We have: -- -- >>> fishOwner -- German -- -- It's not hard to modify this program to grab the values of all the assignments, i.e., the full -- solution to the puzzle. We leave that as an exercise to the interested reader! fishOwner :: IO () fishOwner = do vs <- getModelValues "fishOwner" `fmap` allSat puzzle case vs of [Just (v::Nationality)] -> print v [] -> error "no solution" _ -> error "no unique solution" where puzzle = do let c = uninterpret "color" n = uninterpret "nationality" b = uninterpret "beverage" p = uninterpret "pet" s = uninterpret "sport" let i `neighbor` j = i .== j+1 ||| j .== i+1 a `is` v = a .== literal v let fact0 = constrain fact1 f = do i <- free_ constrain $ 1 .<= i &&& i .<= (5 :: SInteger) constrain $ f i fact2 f = do i <- free_ j <- free_ constrain $ 1 .<= i &&& i .<= (5 :: SInteger) constrain $ 1 .<= j &&& j .<= 5 constrain $ i ./= j constrain $ f i j fact1 $ \i -> n i `is` Briton &&& c i `is` Red fact1 $ \i -> n i `is` Swede &&& p i `is` Dog fact1 $ \i -> n i `is` Dane &&& b i `is` Tea fact2 $ \i j -> c i `is` Green &&& c j `is` White &&& i .== j-1 fact1 $ \i -> c i `is` Green &&& b i `is` Coffee fact1 $ \i -> s i `is` Football &&& p i `is` Bird fact1 $ \i -> c i `is` Yellow &&& s i `is` Baseball fact0 $ b 3 `is` Milk fact0 $ n 1 `is` Norwegian fact2 $ \i j -> s i `is` Volleyball &&& p j `is` Cat &&& i `neighbor` j fact2 $ \i j -> p i `is` Horse &&& s j `is` Baseball &&& i `neighbor` j fact1 $ \i -> s i `is` Tennis &&& b i `is` Beer fact1 $ \i -> n i `is` German &&& s i `is` Hockey fact2 $ \i j -> n i `is` Norwegian &&& c j `is` Blue &&& i `neighbor` j fact2 $ \i j -> s i `is` Volleyball &&& b j `is` Water &&& i `neighbor` j ownsFish <- free "fishOwner" fact1 $ \i -> n i .== ownsFish &&& p i `is` Fish return (true :: SBool) sbv-5.12/Data/SBV/Examples/Puzzles/MagicSquare.hs0000644000000000000000000000541612725411266017727 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.MagicSquare -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Solves the magic-square puzzle. An NxN magic square is one where all entries -- are filled with numbers from 1 to NxN such that sums of all rows, columns -- and diagonals is the same. ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.MagicSquare where import Data.List (genericLength, transpose) import Data.SBV -- | Use 32-bit words for elements. type Elem = SWord32 -- | A row is a list of elements type Row = [Elem] -- | The puzzle board is a list of rows type Board = [Row] -- | Checks that all elements in a list are within bounds check :: Elem -> Elem -> [Elem] -> SBool check low high = bAll $ \x -> x .>= low &&& x .<= high -- | Get the diagonal of a square matrix diag :: [[a]] -> [a] diag ((a:_):rs) = a : diag (map tail rs) diag _ = [] -- | Test if a given board is a magic square isMagic :: Board -> SBool isMagic rows = bAnd $ fromBool isSquare : allEqual (map sum items) : allDifferent (concat rows) : map chk items where items = d1 : d2 : rows ++ columns n = genericLength rows isSquare = all (\r -> genericLength r == n) rows columns = transpose rows d1 = diag rows d2 = diag (map reverse rows) chk = check (literal 1) (literal (n*n)) -- | Group a list of elements in the sublists of length @i@ chunk :: Int -> [a] -> [[a]] chunk _ [] = [] chunk i xs = let (f, r) = splitAt i xs in f : chunk i r -- | Given @n@, magic @n@ prints all solutions to the @nxn@ magic square problem magic :: Int -> IO () magic n | n < 0 = putStrLn $ "n must be non-negative, received: " ++ show n | True = do putStrLn $ "Finding all " ++ show n ++ "-magic squares.." res <- allSat $ (isMagic . chunk n) `fmap` mkExistVars n2 cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " solution(s)." where n2 = n * n disp i (_, model) | lmod /= n2 = error $ "Impossible! Backend solver returned " ++ show n ++ " values, was expecting: " ++ show lmod | True = do putStrLn $ "Solution #" ++ show i mapM_ printRow board putStrLn $ "Valid Check: " ++ show (isMagic sboard) putStrLn "Done." where lmod = length model board = chunk n model sboard = map (map literal) board sh2 z = let s = show z in if length s < 2 then ' ':s else s printRow r = putStr " " >> mapM_ (\x -> putStr (sh2 x ++ " ")) r >> putStrLn "" sbv-5.12/Data/SBV/Examples/Puzzles/NQueens.hs0000644000000000000000000000376012725411266017104 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.NQueens -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Solves the NQueens puzzle: ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.NQueens where import Data.SBV -- | A solution is a sequence of row-numbers where queens should be placed type Solution = [SWord8] -- | Checks that a given solution of @n@-queens is valid, i.e., no queen -- captures any other. isValid :: Int -> Solution -> SBool isValid n s = bAll rangeFine s &&& allDifferent s &&& bAll checkDiag ijs where rangeFine x = x .>= 1 &&& x .<= fromIntegral n ijs = [(i, j) | i <- [1..n], j <- [i+1..n]] checkDiag (i, j) = diffR ./= diffC where qi = s !! (i-1) qj = s !! (j-1) diffR = ite (qi .>= qj) (qi-qj) (qj-qi) diffC = fromIntegral (j-i) -- | Given @n@, it solves the @n-queens@ puzzle, printing all possible solutions. nQueens :: Int -> IO () nQueens n | n < 0 = putStrLn $ "n must be non-negative, received: " ++ show n | True = do putStrLn $ "Finding all " ++ show n ++ "-queens solutions.." res <- allSat $ isValid n `fmap` mkExistVars n cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " solution(s)." where disp i (_, s) = do putStr $ "Solution #" ++ show i ++ ": " dispSolution s dispSolution :: [Word8] -> IO () dispSolution model | lmod /= n = error $ "Impossible! Backend solver returned " ++ show lmod ++ " values, was expecting: " ++ show n | True = do putStr $ show model putStrLn $ " (Valid: " ++ show (isValid n (map literal model)) ++ ")" where lmod = length model sbv-5.12/Data/SBV/Examples/Puzzles/SendMoreMoney.hs0000644000000000000000000000246512725411266020253 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.SendMoreMoney -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Solves the classic @send + more = money@ puzzle. ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.SendMoreMoney where import Data.SBV -- | Solve the puzzle. We have: -- -- >>> sendMoreMoney -- Solution #1: -- s = 9 :: Integer -- e = 5 :: Integer -- n = 6 :: Integer -- d = 7 :: Integer -- m = 1 :: Integer -- o = 0 :: Integer -- r = 8 :: Integer -- y = 2 :: Integer -- This is the only solution. -- -- That is: -- -- >>> 9567 + 1085 == 10652 -- True sendMoreMoney :: IO AllSatResult sendMoreMoney = allSat $ do ds@[s,e,n,d,m,o,r,y] <- mapM sInteger ["s", "e", "n", "d", "m", "o", "r", "y"] let isDigit x = x .>= 0 &&& x .<= 9 val xs = sum $ zipWith (*) (reverse xs) (iterate (*10) 1) send = val [s,e,n,d] more = val [m,o,r,e] money = val [m,o,n,e,y] constrain $ bAll isDigit ds constrain $ allDifferent ds constrain $ s ./= 0 &&& m ./= 0 solve [send + more .== money] sbv-5.12/Data/SBV/Examples/Puzzles/Sudoku.hs0000644000000000000000000002573112725411266017002 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.Sudoku -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The Sudoku solver, quintessential SMT solver example! ----------------------------------------------------------------------------- module Data.SBV.Examples.Puzzles.Sudoku where import Data.List (transpose) import Data.Maybe (fromJust) import Data.SBV ------------------------------------------------------------------- -- * Modeling Sudoku ------------------------------------------------------------------- -- | A row is a sequence of 8-bit words, too large indeed for representing 1-9, but does not harm type Row = [SWord8] -- | A Sudoku board is a sequence of 9 rows type Board = [Row] -- | Given a series of elements, make sure they are all different -- and they all are numbers between 1 and 9 check :: [SWord8] -> SBool check grp = bAnd $ allDifferent grp : map rangeFine grp where rangeFine x = x .> 0 &&& x .<= 9 -- | Given a full Sudoku board, check that it is valid valid :: Board -> SBool valid rows = bAnd $ literal sizesOK : map check (rows ++ columns ++ squares) where sizesOK = length rows == 9 && all (\r -> length r == 9) rows columns = transpose rows regions = transpose [chunk 3 row | row <- rows] squares = [concat sq | sq <- chunk 3 (concat regions)] chunk :: Int -> [a] -> [[a]] chunk _ [] = [] chunk i xs = let (f, r) = splitAt i xs in f : chunk i r -- | A puzzle is a pair: First is the number of missing elements, second -- is a function that given that many elements returns the final board. type Puzzle = (Int, [SWord8] -> Board) ------------------------------------------------------------------- -- * Solving Sudoku puzzles ------------------------------------------------------------------- -- | Solve a given puzzle and print the results sudoku :: Puzzle -> IO () sudoku p@(i, f) = do putStrLn "Solving the puzzle.." model <- getModel `fmap` sat ((valid . f) `fmap` mkExistVars i) case model of Right sln -> dispSolution p sln Left m -> putStrLn $ "Unsolvable puzzle: " ++ m -- | Helper function to display results nicely, not really needed, but helps presentation dispSolution :: Puzzle -> (Bool, [Word8]) -> IO () dispSolution (i, f) (_, fs) | lmod /= i = error $ "Impossible! Backend solver returned " ++ show lmod ++ " values, was expecting: " ++ show i | True = do putStrLn "Final board:" mapM_ printRow final putStrLn $ "Valid Check: " ++ show (valid final) putStrLn "Done." where lmod = length fs final = f (map literal fs) printRow r = putStr " " >> mapM_ (\x -> putStr (show (fromJust (unliteral x)) ++ " ")) r >> putStrLn "" -- | Find all solutions to a puzzle solveAll :: Puzzle -> IO () solveAll p@(i, f) = do putStrLn "Finding all solutions.." res <- allSat $ (valid . f) `fmap` mkExistVars i cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " solution(s)." where disp n s = do putStrLn $ "Solution #" ++ show n dispSolution p s ------------------------------------------------------------------- -- * Example boards ------------------------------------------------------------------- -- | Find an arbitrary good board puzzle0 :: Puzzle puzzle0 = (81, f) where f [ a1, a2, a3, a4, a5, a6, a7, a8, a9, b1, b2, b3, b4, b5, b6, b7, b8, b9, c1, c2, c3, c4, c5, c6, c7, c8, c9, d1, d2, d3, d4, d5, d6, d7, d8, d9, e1, e2, e3, e4, e5, e6, e7, e8, e9, f1, f2, f3, f4, f5, f6, f7, f8, f9, g1, g2, g3, g4, g5, g6, g7, g8, g9, h1, h2, h3, h4, h5, h6, h7, h8, h9, i1, i2, i3, i4, i5, i6, i7, i8, i9 ] = [ [a1, a2, a3, a4, a5, a6, a7, a8, a9], [b1, b2, b3, b4, b5, b6, b7, b8, b9], [c1, c2, c3, c4, c5, c6, c7, c8, c9], [d1, d2, d3, d4, d5, d6, d7, d8, d9], [e1, e2, e3, e4, e5, e6, e7, e8, e9], [f1, f2, f3, f4, f5, f6, f7, f8, f9], [g1, g2, g3, g4, g5, g6, g7, g8, g9], [h1, h2, h3, h4, h5, h6, h7, h8, h9], [i1, i2, i3, i4, i5, i6, i7, i8, i9] ] f _ = error "puzzle0 needs exactly 81 elements!" -- | A random puzzle, found on the internet.. puzzle1 :: Puzzle puzzle1 = (49, f) where f [ a1, a3, a4, a5, a6, a7, a9, b1, b2, b3, b7, b8, b9, c2, c4, c5, c6, c8, d3, d5, d7, e1, e2, e4, e5, e6, e8, e9, f3, f5, f7, g2, g4, g5, g6, g8, h1, h2, h3, h7, h8, h9, i1, i3, i4, i5, i6, i7, i9 ] = [ [a1, 6, a3, a4, a5, a6, a7, 1, a9], [b1, b2, b3, 6, 5, 1, b7, b8, b9], [ 1, c2, 7, c4, c5, c6, 6, c8, 2], [ 6, 2, d3, 3, d5, 5, d7, 9, 4], [e1, e2, 3, e4, e5, e6, 2, e8, e9], [ 4, 8, f3, 9, f5, 7, f7, 3, 6], [ 9, g2, 6, g4, g5, g6, 4, g8, 8], [h1, h2, h3, 7, 9, 4, h7, h8, h9], [i1, 5, i3, i4, i5, i6, i7, 7, i9] ] f _ = error "puzzle1 needs exactly 49 elements!" -- | Another random puzzle, found on the internet.. puzzle2 :: Puzzle puzzle2 = (55, f) where f [ a2, a4, a5, a6, a7, a9, b1, b2, b4, b7, b8, b9, c1, c3, c4, c5, c6, c7, c8, c9, d2, d3, d4, d8, d9, e1, e3, e5, e7, e9, f1, f2, f6, f7, f8, g1, g2, g3, g4, g5, g6, g7, g9, h1, h2, h3, h6, h8, h9, i1, i3, i4, i5, i6, i8 ] = [ [ 1, a2, 3, a4, a5, a6, a7, 8, a9], [b1, b2, 6, b4, 4, 8, b7, b8, b9], [c1, 4, c3, c4, c5, c6, c7, c8, c9], [ 2, d2, d3, d4, 9, 6, 1, d8, d9], [e1, 9, e3, 8, e5, 1, e7, 4, e9], [f1, f2, 4, 3, 2, f6, f7, f8, 8], [g1, g2, g3, g4, g5, g6, g7, 7, g9], [h1, h2, h3, 1, 5, h6, 4, h8, h9], [i1, 6, i3, i4, i5, i6, 2, i8, 3] ] f _ = error "puzzle2 needs exactly 55 elements!" -- | Another random puzzle, found on the internet.. puzzle3 :: Puzzle puzzle3 = (56, f) where f [ a2, a3, a4, a6, a8, a9, b2, b4, b5, b6, b7, b8, b9, c1, c2, c3, c4, c6, c7, c9, d1, d3, d5, d7, d9, e2, e3, e4, e6, e7, e8, f1, f3, f5, f7, f9, g1, g3, g4, g6, g7, g8, g9, h1, h2, h3, h4, h5, h6, h8, i1, i2, i4, i6, i7, i8 ] = [ [ 6, a2, a3, a4, 1, a6, 5, a8, a9], [ 8, b2, 3, b4, b5, b6, b7, b8, b9], [c1, c2, c3, c4, 6, c6, c7, 2, c9], [d1, 3, d3, 1, d5, 8, d7, 9, d9], [ 1, e2, e3, e4, 9, e6, e7, e8, 4], [f1, 5, f3, 2, f5, 3, f7, 1, f9], [g1, 7, g3, g4, 3, g6, g7, g8, g9], [h1, h2, h3, h4, h5, h6, 3, h8, 6], [i1, i2, 4, i4, 5, i6, i7, i8, 9] ] f _ = error "puzzle3 needs exactly 56 elements!" -- | According to the web, this is the toughest -- sudoku puzzle ever.. It even has a name: Al Escargot: -- puzzle4 :: Puzzle puzzle4 = (58, f) where f [ a2, a3, a4, a5, a7, a9, b1, b3, b4, b6, b7, b8, c1, c2, c5, c6, c8, c9, d1, d2, d5, d6, d8, d9, e1, e3, e4, e6, e7, e8, f2, f3, f4, f5, f7, f8, f9, g2, g3, g4, g5, g6, g7, g9, h1, h3, h4, h5, h6, h7, h8, i1, i2, i4, i5, i6, i8, i9 ] = [ [ 1, a2, a3, a4, a5, 7, a7, 9, a9], [b1, 3, b3, b4, 2, b6, b7, b8, 8], [c1, c2, 9, 6, c5, c6, 5, c8, c9], [d1, d2, 5, 3, d5, d6, 9, d8, d9], [e1, 1, e3, e4, 8, e6, e7, e8, 2], [ 6, f2, f3, f4, f5, 4, f7, f8, f9], [ 3, g2, g3, g4, g5, g6, g7, 1, g9], [h1, 4, h3, h4, h5, h6, h7, h8, 7], [i1, i2, 7, i4, i5, i6, 3, i8, i9] ] f _ = error "puzzle4 needs exactly 58 elements!" -- | This one has been called diabolical, apparently puzzle5 :: Puzzle puzzle5 = (53, f) where f [ a1, a3, a5, a6, a9, b1, b4, b5, b7, b9, c2, c4, c5, c6, c7, c8, c9, d1, d2, d4, d6, d7, d8, e1, e2, e3, e5, e7, e8, e9, f2, f3, f4, f6, f8, f9, g1, g2, g3, g4, g5, g6, g8, h1, h3, h5, h6, h9, i1, i4, i5, i7, i9 ] = [ [a1, 9, a3, 7, a5, a6, 8, 6, a9], [b1, 3, 1, b4, b5, 5, b7, 2, b9], [ 8, c2, 6, c4, c5, c6, c7, c8, c9], [d1, d2, 7, d4, 5, d6, d7, d8, 6], [e1, e2, e3, 3, e5, 7, e7, e8, e9], [ 5, f2, f3, f4, 1, f6, 7, f8, f9], [g1, g2, g3, g4, g5, g6, 1, g8, 9], [h1, 2, h3, 6, h5, h6, 3, 5, h9], [i1, 5, 4, i4, i5, 8, i7, 7, i9] ] f _ = error "puzzle5 needs exactly 53 elements!" -- | The following is nefarious according to -- puzzle6 :: Puzzle puzzle6 = (64, f) where f [ a1, a2, a3, a4, a6, a7, a9, b1, b3, b4, b5, b6, b7, b8, b9, c1, c2, c4, c5, c6, c7, c8, c9, d1, d3, d4, d5, d6, d8, e2, e3, e4, e6, e7, e8, e9, f1, f2, f3, f4, f5, f6, f8, f9, g1, g2, g5, g7, g8, g9, h2, h3, h5, h6, h8, h9, i1, i2, i3, i4, i5, i6, i7, i9 ] = [ [a1, a2, a3, a4, 6, a6, a7, 8, a9], [b1, 2, b3, b4, b5, b6, b7, b8, b9], [c1, c2, 1, c4, c5, c6, c7, c8, c9], [d1, 7, d3, d4, d5, d6, 1, d8, 2], [ 5, e2, e3, e4, 3, e6, e7, e8, e9], [f1, f2, f3, f4, f5, f6, 4, f8, f9], [g1, g2, 4, 2, g5, 1, g7, g8, g9], [ 3, h2, h3, 7, h5, h6, 6, h8, h9], [i1, i2, i3, i4, i5, i6, i7, 5, i9] ] f _ = error "puzzle6 needs exactly 64 elements!" -- | Solve them all, this takes a fraction of a second to run for each case allPuzzles :: IO () allPuzzles = mapM_ sudoku [puzzle0, puzzle1, puzzle2, puzzle3, puzzle4, puzzle5, puzzle6] sbv-5.12/Data/SBV/Examples/Puzzles/U2Bridge.hs0000644000000000000000000002602312725411266017126 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Puzzles.U2Bridge -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The famous U2 bridge crossing puzzle: ----------------------------------------------------------------------------- {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TypeSynonymInstances #-} module Data.SBV.Examples.Puzzles.U2Bridge where import Control.Monad (unless) import Control.Monad.State (State, runState, put, get, modify, evalState) import Data.Generics (Data) import GHC.Generics (Generic) import Data.SBV ------------------------------------------------------------- -- * Modeling the puzzle ------------------------------------------------------------- -- | U2 band members. We want to translate this to SMT-Lib -- as a data-type, and hence the deriving mechanism. data U2Member = Bono | Edge | Adam | Larry deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel) -- | Symbolic shorthand for a 'U2Member' type SU2Member = SBV U2Member -- | Shorthands for symbolic versions of the members bono, edge, adam, larry :: SU2Member [bono, edge, adam, larry] = map literal [Bono, Edge, Adam, Larry] -- | Model time using 32 bits type Time = Word32 -- | Symbolic variant for time type STime = SBV Time -- | Crossing times for each member of the band crossTime :: U2Member -> Time crossTime Bono = 1 crossTime Edge = 2 crossTime Adam = 5 crossTime Larry = 10 -- | The symbolic variant.. The duplication is unfortunate. sCrossTime :: SU2Member -> STime sCrossTime m = ite (m .== bono) (literal (crossTime Bono)) $ ite (m .== edge) (literal (crossTime Edge)) $ ite (m .== adam) (literal (crossTime Adam)) (literal (crossTime Larry)) -- Must be Larry -- | Location of the flash data Location = Here | There deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel) -- | Symbolic variant of 'Location' type SLocation = SBV Location -- | Shorthands for symbolic versions of locations here, there :: SLocation [here, there] = map literal [Here, There] -- | The status of the puzzle after each move -- -- This type is equipped with an automatically derived 'Mergeable' instance -- because each field is 'Mergeable'. A 'Generic' instance must also be derived -- for this to work, and the 'DeriveAnyClass' language extension must be -- enabled. The derived 'Mergeable' instance simply walks down the structure -- field by field and merges each one. An equivalent hand-written 'Mergeable' -- instance is provided in a comment below. data Status = Status { time :: STime -- ^ elapsed time , flash :: SLocation -- ^ location of the flash , lBono :: SLocation -- ^ location of Bono , lEdge :: SLocation -- ^ location of Edge , lAdam :: SLocation -- ^ location of Adam , lLarry :: SLocation -- ^ location of Larry } deriving (Generic, Mergeable) -- The derived Mergeable instance is equivalent to the following: -- -- instance Mergeable Status where -- symbolicMerge f t s1 s2 = Status { time = symbolicMerge f t (time s1) (time s2) -- , flash = symbolicMerge f t (flash s1) (flash s2) -- , lBono = symbolicMerge f t (lBono s1) (lBono s2) -- , lEdge = symbolicMerge f t (lEdge s1) (lEdge s2) -- , lAdam = symbolicMerge f t (lAdam s1) (lAdam s2) -- , lLarry = symbolicMerge f t (lLarry s1) (lLarry s2) -- } -- | Start configuration, time elapsed is 0 and everybody is 'here' start :: Status start = Status { time = 0 , flash = here , lBono = here , lEdge = here , lAdam = here , lLarry = here } -- | A puzzle move is modeled as a state-transformer type Move a = State Status a -- | Mergeable instance for 'Move' simply pushes the merging the data after run of each branch -- starting from the same state. instance Mergeable a => Mergeable (Move a) where symbolicMerge f t a b = do s <- get let (ar, s1) = runState a s (br, s2) = runState b s put $ symbolicMerge f t s1 s2 return $ symbolicMerge f t ar br -- | Read the state via an accessor function peek :: (Status -> a) -> Move a peek f = do s <- get return (f s) -- | Given an arbitrary member, return his location whereIs :: SU2Member -> Move SLocation whereIs p = ite (p .== bono) (peek lBono) $ ite (p .== edge) (peek lEdge) $ ite (p .== adam) (peek lAdam) (peek lLarry) -- | Transferring the flash to the other side xferFlash :: Move () xferFlash = modify $ \s -> s{flash = ite (flash s .== here) there here} -- | Transferring a person to the other side xferPerson :: SU2Member -> Move () xferPerson p = do [lb, le, la, ll] <- mapM peek [lBono, lEdge, lAdam, lLarry] let move l = ite (l .== here) there here lb' = ite (p .== bono) (move lb) lb le' = ite (p .== edge) (move le) le la' = ite (p .== adam) (move la) la ll' = ite (p .== larry) (move ll) ll modify $ \s -> s{lBono = lb', lEdge = le', lAdam = la', lLarry = ll'} -- | Increment the time, when only one person crosses bumpTime1 :: SU2Member -> Move () bumpTime1 p = modify $ \s -> s{time = time s + sCrossTime p} -- | Increment the time, when two people cross together bumpTime2 :: SU2Member -> SU2Member -> Move () bumpTime2 p1 p2 = modify $ \s -> s{time = time s + sCrossTime p1 `smax` sCrossTime p2} -- | Symbolic version of 'when' whenS :: SBool -> Move () -> Move () whenS t a = ite t a (return ()) -- | Move one member, remembering to take the flash move1 :: SU2Member -> Move () move1 p = do f <- peek flash l <- whereIs p -- only do the move if the person and the flash are at the same side whenS (f .== l) $ do bumpTime1 p xferFlash xferPerson p -- | Move two members, again with the flash move2 :: SU2Member -> SU2Member -> Move () move2 p1 p2 = do f <- peek flash l1 <- whereIs p1 l2 <- whereIs p2 -- only do the move if both people and the flash are at the same side whenS (f .== l1 &&& f .== l2) $ do bumpTime2 p1 p2 xferFlash xferPerson p1 xferPerson p2 ------------------------------------------------------------- -- * Actions ------------------------------------------------------------- -- | A move action is a sequence of triples. The first component is symbolically -- True if only one member crosses. (In this case the third element of the triple -- is irrelevant.) If the first component is (symbolically) False, then both members -- move together type Actions = [(SBool, SU2Member, SU2Member)] -- | Run a sequence of given actions. run :: Actions -> Move [Status] run = mapM step where step (b, p1, p2) = ite b (move1 p1) (move2 p1 p2) >> get ------------------------------------------------------------- -- * Recognizing valid solutions ------------------------------------------------------------- -- | Check if a given sequence of actions is valid, i.e., they must all -- cross the bridge according to the rules and in less than 17 seconds isValid :: Actions -> SBool isValid as = time end .<= 17 &&& bAll check as &&& zigZag (cycle [there, here]) (map flash states) &&& bAll (.== there) [lBono end, lEdge end, lAdam end, lLarry end] where check (s, p1, p2) = (bnot s ==> p1 .> p2) -- for two person moves, ensure first person is "larger" &&& (s ==> p2 .== bono) -- for one person moves, ensure second person is always "bono" states = evalState (run as) start end = last states zigZag reqs locs = bAnd $ zipWith (.==) locs reqs ------------------------------------------------------------- -- * Solving the puzzle ------------------------------------------------------------- -- | See if there is a solution that has precisely @n@ steps solveN :: Int -> IO Bool solveN n = do putStrLn $ "Checking for solutions with " ++ show n ++ " move" ++ plu n ++ "." let genAct = do b <- exists_ p1 <- exists_ p2 <- exists_ return (b, p1, p2) res <- allSat $ isValid `fmap` mapM (const genAct) [1..n] cnt <- displayModels disp res if cnt == 0 then return False else do putStrLn $ "Found: " ++ show cnt ++ " solution" ++ plu cnt ++ " with " ++ show n ++ " move" ++ plu n ++ "." return True where plu v = if v == 1 then "" else "s" disp :: Int -> (Bool, [(Bool, U2Member, U2Member)]) -> IO () disp i (_, ss) | lss /= n = error $ "Expected " ++ show n ++ " results; got: " ++ show lss | True = do putStrLn $ "Solution #" ++ show i ++ ": " go False 0 ss return () where lss = length ss go _ t [] = putStrLn $ "Total time: " ++ show t go l t ((True, a, _):rest) = do putStrLn $ sh2 t ++ shL l ++ show a go (not l) (t + crossTime a) rest go l t ((False, a, b):rest) = do putStrLn $ sh2 t ++ shL l ++ show a ++ ", " ++ show b go (not l) (t + crossTime a `max` crossTime b) rest sh2 t = let s = show t in if length s < 2 then ' ' : s else s shL False = " --> " shL True = " <-- " -- | Solve the U2-bridge crossing puzzle, starting by testing solutions with -- increasing number of steps, until we find one. We have: -- -- >>> solveU2 -- Checking for solutions with 1 move. -- Checking for solutions with 2 moves. -- Checking for solutions with 3 moves. -- Checking for solutions with 4 moves. -- Checking for solutions with 5 moves. -- Solution #1: -- 0 --> Edge, Bono -- 2 <-- Bono -- 3 --> Larry, Adam -- 13 <-- Edge -- 15 --> Edge, Bono -- Total time: 17 -- Solution #2: -- 0 --> Edge, Bono -- 2 <-- Edge -- 4 --> Larry, Adam -- 14 <-- Bono -- 15 --> Edge, Bono -- Total time: 17 -- Found: 2 solutions with 5 moves. -- -- Finding all possible solutions to the puzzle. solveU2 :: IO () solveU2 = go 1 where go i = do p <- solveN i unless p $ go (i+1) sbv-5.12/Data/SBV/Examples/Uninterpreted/0000755000000000000000000000000012725411266016340 5ustar0000000000000000sbv-5.12/Data/SBV/Examples/Uninterpreted/AUF.hs0000644000000000000000000000616212725411266017314 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.AUF -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Formalizes and proves the following theorem, about arithmetic, -- uninterpreted functions, and arrays. (For reference, see -- slide number 24): -- -- @ -- x + 2 = y implies f (read (write (a, x, 3), y - 2)) = f (y - x + 1) -- @ -- -- We interpret the types as follows (other interpretations certainly possible): -- -- [/x/] 'SWord32' (32-bit unsigned address) -- -- [/y/] 'SWord32' (32-bit unsigned address) -- -- [/a/] An array, indexed by 32-bit addresses, returning 32-bit unsigned integers -- -- [/f/] An uninterpreted function of type @'SWord32' -> 'SWord64'@ -- -- The function @read@ and @write@ are usual array operations. ----------------------------------------------------------------------------- module Data.SBV.Examples.Uninterpreted.AUF where import Data.SBV -------------------------------------------------------------- -- * Model using functional arrays -------------------------------------------------------------- -- | The array type, takes symbolic 32-bit unsigned indexes -- and stores 32-bit unsigned symbolic values. These are -- functional arrays where reading before writing a cell -- throws an exception. type A = SFunArray Word32 Word32 -- | Uninterpreted function in the theorem f :: SWord32 -> SWord64 f = uninterpret "f" -- | Correctness theorem. We state it for all values of @x@, @y@, and -- the array @a@. We also take an arbitrary initializer for the array. thm1 :: SWord32 -> SWord32 -> A -> SWord32 -> SBool thm1 x y a initVal = lhs ==> rhs where a' = resetArray a initVal -- initialize array lhs = x + 2 .== y rhs = f (readArray (writeArray a' x 3) (y - 2)) .== f (y - x + 1) -- | Prints Q.E.D. when run, as expected -- -- >>> proveThm1 -- Q.E.D. proveThm1 :: IO ThmResult proveThm1 = prove $ do x <- free "x" y <- free "y" a <- newArray "a" Nothing i <- free "initVal" return $ thm1 x y a i -------------------------------------------------------------- -- * Model using SMT arrays -------------------------------------------------------------- -- | This version directly uses SMT-arrays and hence does not need an initializer. -- Reading an element before writing to it returns an arbitrary value. type B = SArray Word32 Word32 -- | Same as 'thm1', except we don't need an initializer with the 'SArray' model. thm2 :: SWord32 -> SWord32 -> B -> SBool thm2 x y a = lhs ==> rhs where lhs = x + 2 .== y rhs = f (readArray (writeArray a x 3) (y - 2)) .== f (y - x + 1) -- | Prints Q.E.D. when run, as expected: -- -- >>> proveThm2 -- Q.E.D. proveThm2 :: IO ThmResult proveThm2 = prove $ do x <- free "x" y <- free "y" a <- newArray "b" Nothing return $ thm2 x y a sbv-5.12/Data/SBV/Examples/Uninterpreted/Deduce.hs0000644000000000000000000000674712725411266020103 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.Deduce -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates uninterpreted sorts and how they can be used for deduction. -- This example is inspired by the discussion at , -- essentially showing how to show the required deduction using SBV. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} module Data.SBV.Examples.Uninterpreted.Deduce where import Data.Generics import Data.SBV -- we will have our own "uninterpreted" functions corresponding -- to not/or/and, so hide their Prelude counterparts. import Prelude hiding (not, or, and) ----------------------------------------------------------------------------- -- * Representing uninterpreted booleans ----------------------------------------------------------------------------- -- | The uninterpreted sort 'B', corresponding to the carrier. -- To prevent SBV from translating it to an enumerated type, we simply attach an unused field data B = B () deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) -- | Handy shortcut for the type of symbolic values over 'B' type SB = SBV B ----------------------------------------------------------------------------- -- * Uninterpreted connectives over 'B' ----------------------------------------------------------------------------- -- | Uninterpreted logical connective 'and' and :: SB -> SB -> SB and = uninterpret "AND" -- | Uninterpreted logical connective 'or' or :: SB -> SB -> SB or = uninterpret "OR" -- | Uninterpreted logical connective 'not' not :: SB -> SB not = uninterpret "NOT" ----------------------------------------------------------------------------- -- * Axioms of the logical system ----------------------------------------------------------------------------- -- | Distributivity of OR over AND, as an axiom in terms of -- the uninterpreted functions we have introduced. Note how -- variables range over the uninterpreted sort 'B'. ax1 :: [String] ax1 = [ "(assert (forall ((p B) (q B) (r B))" , " (= (AND (OR p q) (OR p r))" , " (OR p (AND q r)))))" ] -- | One of De Morgan's laws, again as an axiom in terms -- of our uninterpeted logical connectives. ax2 :: [String] ax2 = [ "(assert (forall ((p B) (q B))" , " (= (NOT (OR p q))" , " (AND (NOT p) (NOT q)))))" ] -- | Double negation axiom, similar to the above. ax3 :: [String] ax3 = ["(assert (forall ((p B)) (= (NOT (NOT p)) p)))"] ----------------------------------------------------------------------------- -- * Demonstrated deduction ----------------------------------------------------------------------------- -- | Proves the equivalence @NOT (p OR (q AND r)) == (NOT p AND NOT q) OR (NOT p AND NOT r)@, -- following from the axioms we have specified above. We have: -- -- >>> test -- Q.E.D. test :: IO ThmResult test = prove $ do addAxiom "OR distributes over AND" ax1 addAxiom "de Morgan" ax2 addAxiom "double negation" ax3 p <- free "p" q <- free "q" r <- free "r" return $ not (p `or` (q `and` r)) .== (not p `and` not q) `or` (not p `and` not r) sbv-5.12/Data/SBV/Examples/Uninterpreted/Function.hs0000644000000000000000000000136712725411266020470 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.Function -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates function counter-examples ----------------------------------------------------------------------------- module Data.SBV.Examples.Uninterpreted.Function where import Data.SBV -- | An uninterpreted function f :: SWord8 -> SWord8 -> SWord16 f = uninterpret "f" -- | Asserts that @f x z == f (y+2) z@ whenever @x == y+2@. Naturally correct: -- -- >>> prove thmGood -- Q.E.D. thmGood :: SWord8 -> SWord8 -> SWord8 -> SBool thmGood x y z = x .== y+2 ==> f x z .== f (y + 2) z sbv-5.12/Data/SBV/Examples/Uninterpreted/Shannon.hs0000644000000000000000000001137712725411266020311 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.Shannon -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Proves (instances of) Shannon's expansion theorem and other relevant -- facts. See: ----------------------------------------------------------------------------- module Data.SBV.Examples.Uninterpreted.Shannon where import Data.SBV ----------------------------------------------------------------------------- -- * Boolean functions ----------------------------------------------------------------------------- -- | A ternary boolean function type Ternary = SBool -> SBool -> SBool -> SBool -- | A binary boolean function type Binary = SBool -> SBool-> SBool ----------------------------------------------------------------------------- -- * Shannon cofactors ----------------------------------------------------------------------------- -- | Positive Shannon cofactor of a boolean function, with -- respect to its first argument pos :: (SBool -> a) -> a pos f = f true -- | Negative Shannon cofactor of a boolean function, with -- respect to its first argument neg :: (SBool -> a) -> a neg f = f false ----------------------------------------------------------------------------- -- * Shannon expansion theorem ----------------------------------------------------------------------------- -- | Shannon's expansion over the first argument of a function. We have: -- -- >>> shannon -- Q.E.D. shannon :: IO ThmResult shannon = prove $ \x y z -> f x y z .== (x &&& pos f y z ||| bnot x &&& neg f y z) where f :: Ternary f = uninterpret "f" -- | Alternative form of Shannon's expansion over the first argument of a function. We have: -- -- >>> shannon2 -- Q.E.D. shannon2 :: IO ThmResult shannon2 = prove $ \x y z -> f x y z .== ((x ||| neg f y z) &&& (bnot x ||| pos f y z)) where f :: Ternary f = uninterpret "f" ----------------------------------------------------------------------------- -- * Derivatives ----------------------------------------------------------------------------- -- | Computing the derivative of a boolean function (boolean difference). -- Defined as exclusive-or of Shannon cofactors with respect to that -- variable. derivative :: Ternary -> Binary derivative f y z = pos f y z <+> neg f y z -- | The no-wiggle theorem: If the derivative of a function with respect to -- a variable is constant False, then that variable does not "wiggle" the -- function; i.e., any changes to it won't affect the result of the function. -- In fact, we have an equivalence: The variable only changes the -- result of the function iff the derivative with respect to it is not False: -- -- >>> noWiggle -- Q.E.D. noWiggle :: IO ThmResult noWiggle = prove $ \y z -> bnot (f' y z) <=> pos f y z .== neg f y z where f :: Ternary f = uninterpret "f" f' = derivative f ----------------------------------------------------------------------------- -- * Universal quantification ----------------------------------------------------------------------------- -- | Universal quantification of a boolean function with respect to a variable. -- Simply defined as the conjunction of the Shannon cofactors. universal :: Ternary -> Binary universal f y z = pos f y z &&& neg f y z -- | Show that universal quantification is really meaningful: That is, if the universal -- quantification with respect to a variable is True, then both cofactors are true for -- those arguments. Of course, this is a trivial theorem if you think about it for a -- moment, or you can just let SBV prove it for you: -- -- >>> univOK -- Q.E.D. univOK :: IO ThmResult univOK = prove $ \y z -> f' y z ==> pos f y z &&& neg f y z where f :: Ternary f = uninterpret "f" f' = universal f ----------------------------------------------------------------------------- -- * Existential quantification ----------------------------------------------------------------------------- -- | Existential quantification of a boolean function with respect to a variable. -- Simply defined as the conjunction of the Shannon cofactors. existential :: Ternary -> Binary existential f y z = pos f y z ||| neg f y z -- | Show that existential quantification is really meaningful: That is, if the existential -- quantification with respect to a variable is True, then one of the cofactors must be true for -- those arguments. Again, this is a trivial theorem if you think about it for a moment, but -- we will just let SBV prove it: -- -- >>> existsOK -- Q.E.D. existsOK :: IO ThmResult existsOK = prove $ \y z -> f' y z ==> pos f y z ||| neg f y z where f :: Ternary f = uninterpret "f" f' = existential f sbv-5.12/Data/SBV/Examples/Uninterpreted/Sort.hs0000644000000000000000000000331012725411266017620 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.Sort -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates uninterpreted sorts, together with axioms. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} module Data.SBV.Examples.Uninterpreted.Sort where import Data.Generics import Data.SBV -- | A new data-type that we expect to use in an uninterpreted fashion -- in the backend SMT solver. Note the custom @deriving@ clause, which -- takes care of most of the boilerplate. The () field is needed so -- SBV will not translate it to an enumerated data-type data Q = Q () deriving (Eq, Ord, Data, Read, Show, SymWord, HasKind) -- | Declare an uninterpreted function that works over Q's f :: SBV Q -> SBV Q f = uninterpret "f" -- | A satisfiable example, stating that there is an element of the domain -- 'Q' such that 'f' returns a different element. Note that this is valid only -- when the domain 'Q' has at least two elements. We have: -- -- >>> t1 -- Satisfiable. Model: -- x = Q!val!0 :: Q t1 :: IO SatResult t1 = sat $ do x <- free "x" return $ f x ./= x -- | This is a variant on the first example, except we also add an axiom -- for the sort, stating that the domain 'Q' has only one element. In this case -- the problem naturally becomes unsat. We have: -- -- >>> t2 -- Unsatisfiable t2 :: IO SatResult t2 = sat $ do x <- free "x" addAxiom "Q" ["(assert (forall ((x Q) (y Q)) (= x y)))"] return $ f x ./= x sbv-5.12/Data/SBV/Examples/Uninterpreted/UISortAllSat.hs0000644000000000000000000000525512725411266021171 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Examples.Uninterpreted.UISortAllSat -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Demonstrates uninterpreted sorts and how all-sat behaves for them. -- Thanks to Eric Seidel for the idea. ----------------------------------------------------------------------------- {-# LANGUAGE DeriveDataTypeable #-} module Data.SBV.Examples.Uninterpreted.UISortAllSat where import Data.Generics import Data.SBV -- | A "list-like" data type, but one we plan to uninterpret at the SMT level. -- The actual shape is really immaterial for us, but could be used as a proxy -- to generate test cases or explore data-space in some other part of a program. -- Note that we neither rely on the shape of this data, nor need the actual -- constructors. data L = Nil | Cons Int L deriving (Eq, Ord, Show, Read, Data) -- | Declare instances to make 'L' a usable uninterpreted sort. First we need the -- 'SymWord' instance, with the default definition sufficing. instance SymWord L -- | Similarly, 'HasKind's default implementation is sufficient. instance HasKind L -- | An uninterpreted "classify" function. Really, we only care about -- the fact that such a function exists, not what it does. classify :: SBV L -> SInteger classify = uninterpret "classify" -- | Formulate a query that essentially asserts a cardinality constraint on -- the uninterpreted sort 'L'. The goal is to say there are precisely 3 -- such things, as it might be the case. We manage this by declaring four -- elements, and asserting that for a free variable of this sort, the -- shape of the data matches one of these three instances. That is, we -- assert that all the instances of the data 'L' can be classified into -- 3 equivalence classes. Then, allSat returns all the possible instances, -- which of course are all uninterpreted. -- -- As expected, we have: -- -- >>> genLs -- Solution #1: -- l = L!val!0 :: L -- l0 = L!val!0 :: L -- l1 = L!val!1 :: L -- l2 = L!val!2 :: L -- Solution #2: -- l = L!val!2 :: L -- l0 = L!val!0 :: L -- l1 = L!val!1 :: L -- l2 = L!val!2 :: L -- Solution #3: -- l = L!val!1 :: L -- l0 = L!val!0 :: L -- l1 = L!val!1 :: L -- l2 = L!val!2 :: L -- Found 3 different solutions. genLs :: IO AllSatResult genLs = allSatWith z3 $ do [l, l0, l1, l2] <- symbolics ["l", "l0", "l1", "l2"] constrain $ classify l0 .== 0 constrain $ classify l1 .== 1 constrain $ classify l2 .== 2 return $ l .== l0 ||| l .== l1 ||| l .== l2 sbv-5.12/Data/SBV/Provers/0000755000000000000000000000000012725411266013372 5ustar0000000000000000sbv-5.12/Data/SBV/Provers/ABC.hs0000644000000000000000000000365112725411266014320 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.ABC -- Copyright : (c) Adam Foltzer -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the ABC verification and synthesis tool ----------------------------------------------------------------------------- module Data.SBV.Provers.ABC(abc) where import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT -- | The description of abc. The default executable is @\"abc\"@, -- which must be in your path. You can use the @SBV_ABC@ environment -- variable to point to the executable on your system. The default -- options are @-S \"%blast; &sweep -C 5000; &syn4; &cec -s -m -C 2000\"@. -- You can use the @SBV_ABC_OPTIONS@ environment variable to override the options. abc :: SMTSolver abc = SMTSolver { name = ABC , executable = "abc" , options = ["-S", "%blast; &sweep -C 5000; &syn4; &cec -s -m -C 2000"] , engine = standardEngine "SBV_ABC" "SBV_ABC_OPTIONS" addTimeOut standardModel , capabilities = SolverCapabilities { capSolverName = "ABC" , mbDefaultLogic = const Nothing , supportsMacros = True , supportsProduceModels = True , supportsQuantifiers = False , supportsUninterpretedSorts = False , supportsUnboundedInts = False , supportsReals = False , supportsFloats = False , supportsDoubles = False } } where addTimeOut _ _ = error "ABC: Timeout values are not supported" sbv-5.12/Data/SBV/Provers/Boolector.hs0000644000000000000000000000403312725411266015656 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.Boolector -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the Boolector SMT solver ----------------------------------------------------------------------------- module Data.SBV.Provers.Boolector(boolector) where import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT -- | The description of the Boolector SMT solver -- The default executable is @\"boolector\"@, which must be in your path. You can use the @SBV_BOOLECTOR@ environment variable to point to the executable on your system. -- The default options are @\"-m --smt2\"@. You can use the @SBV_BOOLECTOR_OPTIONS@ environment variable to override the options. boolector :: SMTSolver boolector = SMTSolver { name = Boolector , executable = "boolector" , options = ["--smt2", "--smt2-model", "--no-exit-codes"] , engine = standardEngine "SBV_BOOLECTOR" "SBV_BOOLECTOR_OPTIONS" addTimeOut standardModel , capabilities = SolverCapabilities { capSolverName = "Boolector" , mbDefaultLogic = const Nothing , supportsMacros = False , supportsProduceModels = True , supportsQuantifiers = False , supportsUninterpretedSorts = False , supportsUnboundedInts = False , supportsReals = False , supportsFloats = False , supportsDoubles = False } } where addTimeOut o i | i < 0 = error $ "Boolector: Timeout value must be non-negative, received: " ++ show i | True = o ++ ["-t=" ++ show i] sbv-5.12/Data/SBV/Provers/CVC4.hs0000644000000000000000000000426412725411266014433 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.CVC4 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the CVC4 SMT solver ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Provers.CVC4(cvc4) where import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT -- | The description of the CVC4 SMT solver -- The default executable is @\"cvc4\"@, which must be in your path. You can use the @SBV_CVC4@ environment variable to point to the executable on your system. -- The default options are @\"--lang smt\"@. You can use the @SBV_CVC4_OPTIONS@ environment variable to override the options. cvc4 :: SMTSolver cvc4 = SMTSolver { name = CVC4 , executable = "cvc4" , options = ["--lang", "smt"] , engine = standardEngine "SBV_CVC4" "SBV_CVC4_OPTIONS" addTimeOut standardModel , capabilities = SolverCapabilities { capSolverName = "CVC4" , mbDefaultLogic = const (Just "ALL_SUPPORTED") -- CVC4 is not happy if we don't set the logic, so fall-back to this if necessary , supportsMacros = True , supportsProduceModels = True , supportsQuantifiers = True , supportsUninterpretedSorts = True , supportsUnboundedInts = True , supportsReals = True -- Not quite the same capability as Z3; but works more or less.. , supportsFloats = False , supportsDoubles = False } } where addTimeOut o i | i < 0 = error $ "CVC4: Timeout value must be non-negative, received: " ++ show i | True = o ++ ["--tlimit=" ++ show i ++ "000"] -- SBV takes seconds, CVC4 wants milli-seconds sbv-5.12/Data/SBV/Provers/MathSAT.hs0000644000000000000000000000370712725411266015176 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.MathSAT -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the MathSAT SMT solver ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Provers.MathSAT(mathSAT) where import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT -- | The description of the MathSAT SMT solver -- The default executable is @\"mathsat\"@, which must be in your path. You can use the @SBV_MATHSAT@ environment variable to point to the executable on your system. -- The default options are @\"-input=smt2\"@. You can use the @SBV_MATHSAT_OPTIONS@ environment variable to override the options. mathSAT :: SMTSolver mathSAT = SMTSolver { name = MathSAT , executable = "mathsat" , options = ["-input=smt2", "-theory.fp.minmax_zero_mode=4"] , engine = standardEngine "SBV_MATHSAT" "SBV_MATHSAT_OPTIONS" addTimeOut standardModel , capabilities = SolverCapabilities { capSolverName = "MathSAT" , mbDefaultLogic = const Nothing , supportsMacros = False , supportsProduceModels = True , supportsQuantifiers = True , supportsUninterpretedSorts = True , supportsUnboundedInts = True , supportsReals = True , supportsFloats = True , supportsDoubles = True } } where addTimeOut _ _ = error "MathSAT: Timeout values are not supported" sbv-5.12/Data/SBV/Provers/Prover.hs0000644000000000000000000007007112725411266015210 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.Prover -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Provable abstraction and the connection to SMT solvers ----------------------------------------------------------------------------- {-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeSynonymInstances #-} module Data.SBV.Provers.Prover ( SMTSolver(..), SMTConfig(..), Predicate, Provable(..) , ThmResult(..), SatResult(..), SafeResult(..), AllSatResult(..), SMTResult(..) , isSatisfiable, isSatisfiableWith, isTheorem, isTheoremWith , prove, proveWith , sat, satWith , safe, safeWith, isSafe , allSat, allSatWith , isVacuous, isVacuousWith , SatModel(..), Modelable(..), displayModels, extractModels , getModelDictionaries, getModelValues, getModelUninterpretedValues , boolector, cvc4, yices, z3, mathSAT, abc, defaultSMTCfg , compileToSMTLib, generateSMTBenchmarks , internalSATCheck ) where import Control.Monad (when, unless) import Data.List (intercalate) import System.FilePath (addExtension, splitExtension) import System.Time (getClockTime) import System.IO.Unsafe (unsafeInterleaveIO) import GHC.Stack.Compat #if !MIN_VERSION_base(4,9,0) import GHC.SrcLoc.Compat #endif import qualified Data.Set as Set (Set, toList) import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT import Data.SBV.SMT.SMTLib import Data.SBV.Utils.TDiff import Control.DeepSeq (rnf) import qualified Data.SBV.Provers.Boolector as Boolector import qualified Data.SBV.Provers.CVC4 as CVC4 import qualified Data.SBV.Provers.Yices as Yices import qualified Data.SBV.Provers.Z3 as Z3 import qualified Data.SBV.Provers.MathSAT as MathSAT import qualified Data.SBV.Provers.ABC as ABC mkConfig :: SMTSolver -> SMTLibVersion -> [String] -> SMTConfig mkConfig s smtVersion tweaks = SMTConfig { verbose = False , timing = False , sBranchTimeOut = Nothing , timeOut = Nothing , printBase = 10 , printRealPrec = 16 , smtFile = Nothing , solver = s , solverTweaks = tweaks , smtLibVersion = smtVersion , satCmd = "(check-sat)" , isNonModelVar = const False -- i.e., everything is a model-variable by default , roundingMode = RoundNearestTiesToEven , useLogic = Nothing } -- | Default configuration for the Boolector SMT solver boolector :: SMTConfig boolector = mkConfig Boolector.boolector SMTLib2 [] -- | Default configuration for the CVC4 SMT Solver. cvc4 :: SMTConfig cvc4 = mkConfig CVC4.cvc4 SMTLib2 [] -- | Default configuration for the Yices SMT Solver. yices :: SMTConfig yices = mkConfig Yices.yices SMTLib2 [] -- | Default configuration for the Z3 SMT solver z3 :: SMTConfig z3 = mkConfig Z3.z3 SMTLib2 ["(set-option :smt.mbqi true) ; use model based quantifier instantiation"] -- | Default configuration for the MathSAT SMT solver mathSAT :: SMTConfig mathSAT = mkConfig MathSAT.mathSAT SMTLib2 [] -- | Default configuration for the ABC synthesis and verification tool. abc :: SMTConfig abc = mkConfig ABC.abc SMTLib2 [] -- | The default solver used by SBV. This is currently set to z3. defaultSMTCfg :: SMTConfig defaultSMTCfg = z3 -- | A predicate is a symbolic program that returns a (symbolic) boolean value. For all intents and -- purposes, it can be treated as an n-ary function from symbolic-values to a boolean. The 'Symbolic' -- monad captures the underlying representation, and can/should be ignored by the users of the library, -- unless you are building further utilities on top of SBV itself. Instead, simply use the 'Predicate' -- type when necessary. type Predicate = Symbolic SBool -- | A type @a@ is provable if we can turn it into a predicate. -- Note that a predicate can be made from a curried function of arbitrary arity, where -- each element is either a symbolic type or up-to a 7-tuple of symbolic-types. So -- predicates can be constructed from almost arbitrary Haskell functions that have arbitrary -- shapes. (See the instance declarations below.) class Provable a where -- | Turns a value into a universally quantified predicate, internally naming the inputs. -- In this case the sbv library will use names of the form @s1, s2@, etc. to name these variables -- Example: -- -- > forAll_ $ \(x::SWord8) y -> x `shiftL` 2 .== y -- -- is a predicate with two arguments, captured using an ordinary Haskell function. Internally, -- @x@ will be named @s0@ and @y@ will be named @s1@. forAll_ :: a -> Predicate -- | Turns a value into a predicate, allowing users to provide names for the inputs. -- If the user does not provide enough number of names for the variables, the remaining ones -- will be internally generated. Note that the names are only used for printing models and has no -- other significance; in particular, we do not check that they are unique. Example: -- -- > forAll ["x", "y"] $ \(x::SWord8) y -> x `shiftL` 2 .== y -- -- This is the same as above, except the variables will be named @x@ and @y@ respectively, -- simplifying the counter-examples when they are printed. forAll :: [String] -> a -> Predicate -- | Turns a value into an existentially quantified predicate. (Indeed, 'exists' would have been -- a better choice here for the name, but alas it's already taken.) forSome_ :: a -> Predicate -- | Version of 'forSome' that allows user defined names forSome :: [String] -> a -> Predicate instance Provable Predicate where forAll_ = id forAll [] = id forAll xs = error $ "SBV.forAll: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs forSome_ = id forSome [] = id forSome xs = error $ "SBV.forSome: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs instance Provable SBool where forAll_ = return forAll _ = return forSome_ = return forSome _ = return {- -- The following works, but it lets us write properties that -- are not useful.. Such as: prove $ \x y -> (x::SInt8) == y -- Running that will throw an exception since Haskell's equality -- is not be supported by symbolic things. (Needs .==). instance Provable Bool where forAll_ x = forAll_ (if x then true else false :: SBool) forAll s x = forAll s (if x then true else false :: SBool) forSome_ x = forSome_ (if x then true else false :: SBool) forSome s x = forSome s (if x then true else false :: SBool) -} -- Functions instance (SymWord a, Provable p) => Provable (SBV a -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ k a forAll (s:ss) k = forall s >>= \a -> forAll ss $ k a forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ k a forSome (s:ss) k = exists s >>= \a -> forSome ss $ k a forSome [] k = forSome_ k -- SFunArrays (memory, functional representation), only supported universally for the time being instance (HasKind a, HasKind b, Provable p) => Provable (SArray a b -> p) where forAll_ k = declNewSArray (\t -> "array_" ++ show t) Nothing >>= \a -> forAll_ $ k a forAll (s:ss) k = declNewSArray (const s) Nothing >>= \a -> forAll ss $ k a forAll [] k = forAll_ k forSome_ _ = error "SBV.forSome: Existential arrays are not currently supported." forSome _ _ = error "SBV.forSome: Existential arrays are not currently supported." -- SArrays (memory, SMT-Lib notion of arrays), only supported universally for the time being instance (HasKind a, HasKind b, Provable p) => Provable (SFunArray a b -> p) where forAll_ k = declNewSFunArray Nothing >>= \a -> forAll_ $ k a forAll (_:ss) k = declNewSFunArray Nothing >>= \a -> forAll ss $ k a forAll [] k = forAll_ k forSome_ _ = error "SBV.forSome: Existential arrays are not currently supported." forSome _ _ = error "SBV.forSome: Existential arrays are not currently supported." -- 2 Tuple instance (SymWord a, SymWord b, Provable p) => Provable ((SBV a, SBV b) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b -> k (a, b) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b -> k (a, b) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b -> k (a, b) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b -> k (a, b) forSome [] k = forSome_ k -- 3 Tuple instance (SymWord a, SymWord b, SymWord c, Provable p) => Provable ((SBV a, SBV b, SBV c) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b c -> k (a, b, c) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b c -> k (a, b, c) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b c -> k (a, b, c) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c -> k (a, b, c) forSome [] k = forSome_ k -- 4 Tuple instance (SymWord a, SymWord b, SymWord c, SymWord d, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b c d -> k (a, b, c, d) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b c d -> k (a, b, c, d) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b c d -> k (a, b, c, d) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d -> k (a, b, c, d) forSome [] k = forSome_ k -- 5 Tuple instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b c d e -> k (a, b, c, d, e) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b c d e -> k (a, b, c, d, e) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b c d e -> k (a, b, c, d, e) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e -> k (a, b, c, d, e) forSome [] k = forSome_ k -- 6 Tuple instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b c d e f -> k (a, b, c, d, e, f) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b c d e f -> k (a, b, c, d, e, f) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b c d e f -> k (a, b, c, d, e, f) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f -> k (a, b, c, d, e, f) forSome [] k = forSome_ k -- 7 Tuple instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where forAll_ k = forall_ >>= \a -> forAll_ $ \b c d e f g -> k (a, b, c, d, e, f, g) forAll (s:ss) k = forall s >>= \a -> forAll ss $ \b c d e f g -> k (a, b, c, d, e, f, g) forAll [] k = forAll_ k forSome_ k = exists_ >>= \a -> forSome_ $ \b c d e f g -> k (a, b, c, d, e, f, g) forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f g -> k (a, b, c, d, e, f, g) forSome [] k = forSome_ k -- | Prove a predicate, equivalent to @'proveWith' 'defaultSMTCfg'@ prove :: Provable a => a -> IO ThmResult prove = proveWith defaultSMTCfg -- | Find a satisfying assignment for a predicate, equivalent to @'satWith' 'defaultSMTCfg'@ sat :: Provable a => a -> IO SatResult sat = satWith defaultSMTCfg -- | Check that all the 'sAssert' calls are safe, equivalent to @'safeWith' 'defaultSMTCfg'@ safe :: SExecutable a => a -> IO [SafeResult] safe = safeWith defaultSMTCfg -- | Return all satisfying assignments for a predicate, equivalent to @'allSatWith' 'defaultSMTCfg'@. -- Satisfying assignments are constructed lazily, so they will be available as returned by the solver -- and on demand. -- -- NB. Uninterpreted constant/function values and counter-examples for array values are ignored for -- the purposes of @'allSat'@. That is, only the satisfying assignments modulo uninterpreted functions and -- array inputs will be returned. This is due to the limitation of not having a robust means of getting a -- function counter-example back from the SMT solver. allSat :: Provable a => a -> IO AllSatResult allSat = allSatWith defaultSMTCfg -- | Check if the given constraints are satisfiable, equivalent to @'isVacuousWith' 'defaultSMTCfg'@. -- See the function 'constrain' for an example use of 'isVacuous'. isVacuous :: Provable a => a -> IO Bool isVacuous = isVacuousWith defaultSMTCfg -- Decision procedures (with optional timeout) -- | Check whether a given property is a theorem, with an optional time out and the given solver. -- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise. isTheoremWith :: Provable a => SMTConfig -> Maybe Int -> a -> IO (Maybe Bool) isTheoremWith cfg mbTo p = do r <- proveWith cfg{timeOut = mbTo} p case r of ThmResult (Unsatisfiable _) -> return $ Just True ThmResult (Satisfiable _ _) -> return $ Just False ThmResult (TimeOut _) -> return Nothing _ -> error $ "SBV.isTheorem: Received:\n" ++ show r -- | Check whether a given property is satisfiable, with an optional time out and the given solver. -- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise. isSatisfiableWith :: Provable a => SMTConfig -> Maybe Int -> a -> IO (Maybe Bool) isSatisfiableWith cfg mbTo p = do r <- satWith cfg{timeOut = mbTo} p case r of SatResult (Satisfiable _ _) -> return $ Just True SatResult (Unsatisfiable _) -> return $ Just False SatResult (TimeOut _) -> return Nothing _ -> error $ "SBV.isSatisfiable: Received: " ++ show r -- | Checks theoremhood within the given optional time limit of @i@ seconds. -- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise. isTheorem :: Provable a => Maybe Int -> a -> IO (Maybe Bool) isTheorem = isTheoremWith defaultSMTCfg -- | Checks satisfiability within the given optional time limit of @i@ seconds. -- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise. isSatisfiable :: Provable a => Maybe Int -> a -> IO (Maybe Bool) isSatisfiable = isSatisfiableWith defaultSMTCfg -- | Compiles to SMT-Lib and returns the resulting program as a string. Useful for saving -- the result to a file for off-line analysis, for instance if you have an SMT solver that's not natively -- supported out-of-the box by the SBV library. It takes two arguments: -- -- * version: The SMTLib-version to produce. Note that we currently only support SMTLib2. -- -- * isSat : If 'True', will translate it as a SAT query, i.e., in the positive. If 'False', will -- translate as a PROVE query, i.e., it will negate the result. (In this case, the check-sat -- call to the SMT solver will produce UNSAT if the input is a theorem, as usual.) compileToSMTLib :: Provable a => SMTLibVersion -- ^ Version of SMTLib to compile to. (Only SMTLib2 supported currently.) -> Bool -- ^ If True, translate directly, otherwise negate the goal. (Use True for SAT queries, False for PROVE queries.) -> a -> IO String compileToSMTLib version isSat a = do t <- getClockTime let comments = ["Created on " ++ show t] cvt = case version of SMTLib2 -> toSMTLib2 (_, _, _, _, smtLibPgm) <- simulate cvt defaultSMTCfg isSat comments a let out = show smtLibPgm return $ out ++ "\n(check-sat)\n" -- | Create SMT-Lib benchmarks, for supported versions of SMTLib. The first argument is the basename of the file. -- The 'Bool' argument controls whether this is a SAT instance, i.e., translate the query -- directly, or a PROVE instance, i.e., translate the negated query. (See the second boolean argument to -- 'compileToSMTLib' for details.) generateSMTBenchmarks :: Provable a => Bool -> FilePath -> a -> IO () generateSMTBenchmarks isSat f a = mapM_ gen [minBound .. maxBound] where gen v = do s <- compileToSMTLib v isSat a let fn = f `addExtension` smtLibVersionExtension v writeFile fn s putStrLn $ "Generated " ++ show v ++ " benchmark " ++ show fn ++ "." -- | Proves the predicate using the given SMT-solver proveWith :: Provable a => SMTConfig -> a -> IO ThmResult proveWith config a = simulate cvt config False [] a >>= callSolver False "Checking Theoremhood.." ThmResult config where cvt = case smtLibVersion config of SMTLib2 -> toSMTLib2 -- | Find a satisfying assignment using the given SMT-solver satWith :: Provable a => SMTConfig -> a -> IO SatResult satWith config a = simulate cvt config True [] a >>= callSolver True "Checking Satisfiability.." SatResult config where cvt = case smtLibVersion config of SMTLib2 -> toSMTLib2 -- | Check if any of the assertions can be violated safeWith :: SExecutable a => SMTConfig -> a -> IO [SafeResult] safeWith cfg a = do res@Result{resAssertions=asserts} <- runSymbolic (True, cfg) $ sName_ a >>= output mapM (verify res) asserts where locInfo (Just ps) = Just $ let loc (f, sl) = concat [srcLocFile sl, ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f] in intercalate ",\n " (map loc ps) locInfo _ = Nothing verify res (msg, cs, cond) = do SatResult result <- runProofOn cvt cfg True [] pgm >>= callSolver True msg SatResult cfg return $ SafeResult (locInfo (getCallStack `fmap` cs), msg, result) where pgm = res { resInputs = [(EX, n) | (_, n) <- resInputs res] -- make everything existential , resOutputs = [cond] } cvt = case smtLibVersion cfg of SMTLib2 -> toSMTLib2 -- | Check if a safe-call was safe or not, turning a 'SafeResult' to a Bool. isSafe :: SafeResult -> Bool isSafe (SafeResult (_, _, result)) = case result of Unsatisfiable{} -> True Satisfiable{} -> False Unknown{} -> False -- conservative ProofError{} -> False -- conservative TimeOut{} -> False -- conservative -- | Determine if the constraints are vacuous using the given SMT-solver isVacuousWith :: Provable a => SMTConfig -> a -> IO Bool isVacuousWith config a = do Result ki tr uic is cs ts as uis ax asgn cstr asserts _ <- runSymbolic (True, config) $ forAll_ a >>= output case cstr of [] -> return False -- no constraints, no need to check _ -> do let is' = [(EX, i) | (_, i) <- is] -- map all quantifiers to "exists" for the constraint check res' = Result ki tr uic is' cs ts as uis ax asgn cstr asserts [trueSW] cvt = case smtLibVersion config of SMTLib2 -> toSMTLib2 SatResult result <- runProofOn cvt config True [] res' >>= callSolver True "Checking Satisfiability.." SatResult config case result of Unsatisfiable{} -> return True -- constraints are unsatisfiable! Satisfiable{} -> return False -- constraints are satisfiable! Unknown{} -> error "SBV: isVacuous: Solver returned unknown!" ProofError _ ls -> error $ "SBV: isVacuous: error encountered:\n" ++ unlines ls TimeOut _ -> error "SBV: isVacuous: time-out." -- | Find all satisfying assignments using the given SMT-solver allSatWith :: Provable a => SMTConfig -> a -> IO AllSatResult allSatWith config p = do let converter = case smtLibVersion config of SMTLib2 -> toSMTLib2 msg "Checking Satisfiability, all solutions.." sbvPgm@(qinps, _, ki, _, _) <- simulate converter config True [] p let usorts = [s | us@(KUserSort s _) <- Set.toList ki, isFree us] where isFree (KUserSort _ (Left _)) = True isFree _ = False unless (null usorts) $ msg $ "SBV.allSat: Uninterpreted sorts present: " ++ unwords usorts ++ "\n SBV will use equivalence classes to generate all-satisfying instances." results <- unsafeInterleaveIO $ go sbvPgm (1::Int) [] -- See if there are any existentials below any universals -- If such is the case, then the solutions are unique upto prefix existentials let w = ALL `elem` map fst qinps return $ AllSatResult (w, results) where msg = when (verbose config) . putStrLn . ("** " ++) go sbvPgm = loop where loop !n nonEqConsts = do curResult <- invoke nonEqConsts n sbvPgm case curResult of Nothing -> return [] Just (SatResult r) -> let cont model = do let modelOnlyAssocs = [v | v@(x, _) <- modelAssocs model, not (isNonModelVar config x)] rest <- unsafeInterleaveIO $ loop (n+1) (modelOnlyAssocs : nonEqConsts) return (r : rest) in case r of Satisfiable _ (SMTModel []) -> return [r] Unknown _ (SMTModel []) -> return [r] ProofError _ _ -> return [r] TimeOut _ -> return [] Unsatisfiable _ -> return [] Satisfiable _ model -> cont model Unknown _ model -> cont model invoke nonEqConsts n (qinps, skolemMap, _, _, smtLibPgm) = do msg $ "Looking for solution " ++ show n case addNonEqConstraints (roundingMode config) qinps nonEqConsts smtLibPgm of Nothing -> -- no new constraints added, stop return Nothing Just finalPgm -> do msg $ "Generated SMTLib program:\n" ++ finalPgm smtAnswer <- engine (solver config) (updateName (n-1) config) True qinps skolemMap finalPgm msg "Done.." return $ Just $ SatResult smtAnswer updateName i cfg = cfg{smtFile = upd `fmap` smtFile cfg} where upd nm = let (b, e) = splitExtension nm in b ++ "_allSat_" ++ show i ++ e type SMTProblem = ( [(Quantifier, NamedSymVar)] -- inputs , [Either SW (SW, [SW])] -- skolem-map , Set.Set Kind -- kinds used , [(String, Maybe CallStack, SW)] -- assertions , SMTLibPgm -- SMTLib representation ) callSolver :: Bool -> String -> (SMTResult -> b) -> SMTConfig -> SMTProblem -> IO b callSolver isSat checkMsg wrap config (qinps, skolemMap, _, _, smtLibPgm) = do let msg = when (verbose config) . putStrLn . ("** " ++) msg checkMsg let finalPgm = intercalate "\n" (pre ++ post) where SMTLibPgm _ (_, pre, post) = smtLibPgm msg $ "Generated SMTLib program:\n" ++ finalPgm smtAnswer <- engine (solver config) config isSat qinps skolemMap finalPgm msg "Done.." return $ wrap smtAnswer simulate :: Provable a => SMTLibConverter -> SMTConfig -> Bool -> [String] -> a -> IO SMTProblem simulate converter config isSat comments predicate = do let msg = when (verbose config) . putStrLn . ("** " ++) isTiming = timing config msg "Starting symbolic simulation.." res <- timeIf isTiming "problem construction" $ runSymbolic (isSat, config) $ (if isSat then forSome_ else forAll_) predicate >>= output msg $ "Generated symbolic trace:\n" ++ show res msg "Translating to SMT-Lib.." runProofOn converter config isSat comments res runProofOn :: SMTLibConverter -> SMTConfig -> Bool -> [String] -> Result -> IO SMTProblem runProofOn converter config isSat comments res = let isTiming = timing config solverCaps = capabilities (solver config) in case res of Result ki _qcInfo _codeSegs is consts tbls arrs uis axs pgm cstrs assertions [o@(SW KBool _)] -> timeIf isTiming "translation" $ let skolemMap = skolemize (if isSat then is else map flipQ is) where flipQ (ALL, x) = (EX, x) flipQ (EX, x) = (ALL, x) skolemize :: [(Quantifier, NamedSymVar)] -> [Either SW (SW, [SW])] skolemize qinps = go qinps ([], []) where go [] (_, sofar) = reverse sofar go ((ALL, (v, _)):rest) (us, sofar) = go rest (v:us, Left v : sofar) go ((EX, (v, _)):rest) (us, sofar) = go rest (us, Right (v, reverse us) : sofar) smtScript = converter (roundingMode config) (useLogic config) solverCaps ki isSat comments is skolemMap consts tbls arrs uis axs pgm cstrs o result = (is, skolemMap, ki, assertions, smtScript) in rnf smtScript `seq` return result Result{resOutputs = os} -> case length os of 0 -> error $ "Impossible happened, unexpected non-outputting result\n" ++ show res 1 -> error $ "Impossible happened, non-boolean output in " ++ show os ++ "\nDetected while generating the trace:\n" ++ show res _ -> error $ "User error: Multiple output values detected: " ++ show os ++ "\nDetected while generating the trace:\n" ++ show res ++ "\n*** Check calls to \"output\", they are typically not needed!" -- | Run an external proof on the given condition to see if it is satisfiable. internalSATCheck :: SMTConfig -> SBool -> State -> String -> IO SatResult internalSATCheck cfg condInPath st msg = do sw <- sbvToSW st condInPath () <- forceSWArg sw Result ki tr uic is cs ts as uis ax asgn cstr assertions _ <- extractSymbolicSimulationState st let -- Construct the corresponding sat-checker for the branch. Note that we need to -- forget about the quantifiers and just use an "exist", as we're looking for a -- point-satisfiability check here; whatever the original program was. pgm = Result ki tr uic [(EX, n) | (_, n) <- is] cs ts as uis ax asgn cstr assertions [sw] cvt = case smtLibVersion cfg of SMTLib2 -> toSMTLib2 runProofOn cvt cfg True [] pgm >>= callSolver True msg SatResult cfg {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/Data/SBV/Provers/SExpr.hs0000644000000000000000000002732012725411266014773 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.SExpr -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Parsing of S-expressions (mainly used for parsing SMT-Lib get-value output) ----------------------------------------------------------------------------- module Data.SBV.Provers.SExpr where import Data.Bits (setBit, testBit) import Data.Word (Word32, Word64) import Data.Char (isDigit, ord) import Data.List (isPrefixOf) import Data.Maybe (fromMaybe, listToMaybe) import Numeric (readInt, readDec, readHex, fromRat) import Data.Binary.IEEE754 (wordToFloat, wordToDouble) import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data (nan, infinity, RoundingMode(..)) -- | ADT S-Expression format, suitable for representing get-model output of SMT-Lib data SExpr = ECon String | ENum (Integer, Maybe Int) -- Second argument is how wide the field was in bits, if known. Useful in FP parsing. | EReal AlgReal | EFloat Float | EDouble Double | EApp [SExpr] deriving Show -- | Parse a string into an SExpr, potentially failing with an error message parseSExpr :: String -> Either String SExpr parseSExpr inp = do (sexp, extras) <- parse inpToks if null extras then return sexp else die "Extra tokens after valid input" where inpToks = let cln "" sofar = sofar cln ('(':r) sofar = cln r (" ( " ++ sofar) cln (')':r) sofar = cln r (" ) " ++ sofar) cln (':':':':r) sofar = cln r (" :: " ++ sofar) cln (c:r) sofar = cln r (c:sofar) in reverse (map reverse (words (cln inp ""))) die w = fail $ "SBV.Provers.SExpr: Failed to parse S-Expr: " ++ w ++ "\n*** Input : <" ++ inp ++ ">" parse [] = die "ran out of tokens" parse ("(":toks) = do (f, r) <- parseApp toks [] f' <- cvt (EApp f) return (f', r) parse (")":_) = die "extra tokens after close paren" parse [tok] = do t <- pTok tok return (t, []) parse _ = die "ill-formed s-expr" parseApp [] _ = die "failed to grab s-expr application" parseApp (")":toks) sofar = return (reverse sofar, toks) parseApp ("(":toks) sofar = do (f, r) <- parse ("(":toks) parseApp r (f : sofar) parseApp (tok:toks) sofar = do t <- pTok tok parseApp toks (t : sofar) pTok "false" = return $ ENum (0, Nothing) pTok "true" = return $ ENum (1, Nothing) pTok ('0':'b':r) = mkNum (Just (length r)) $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r pTok ('b':'v':r) = mkNum Nothing $ readDec (takeWhile (/= '[') r) pTok ('#':'b':r) = mkNum (Just (length r)) $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r pTok ('#':'x':r) = mkNum (Just (4 * length r)) $ readHex r pTok n | not (null n) && isDigit (head n) = if '.' `elem` n then getReal n else mkNum Nothing $ readDec n pTok n = return $ ECon (constantMap n) mkNum l [(n, "")] = return $ ENum (n, l) mkNum _ _ = die "cannot read number" getReal n = return $ EReal $ mkPolyReal (Left (exact, n')) where exact = not ("?" `isPrefixOf` reverse n) n' | exact = n | True = init n -- simplify numbers and root-obj values cvt (EApp [ECon "/", EReal a, EReal b]) = return $ EReal (a / b) cvt (EApp [ECon "/", EReal a, ENum b]) = return $ EReal (a / fromInteger (fst b)) cvt (EApp [ECon "/", ENum a, EReal b]) = return $ EReal (fromInteger (fst a) / b ) cvt (EApp [ECon "/", ENum a, ENum b]) = return $ EReal (fromInteger (fst a) / fromInteger (fst b)) cvt (EApp [ECon "-", EReal a]) = return $ EReal (-a) cvt (EApp [ECon "-", ENum a]) = return $ ENum (-(fst a), snd a) -- bit-vector value as CVC4 prints: (_ bv0 16) for instance cvt (EApp [ECon "_", ENum a, ENum _b]) = return $ ENum a cvt (EApp [ECon "root-obj", EApp (ECon "+":trms), ENum k]) = do ts <- mapM getCoeff trms return $ EReal $ mkPolyReal (Right (fst k, ts)) cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum (11, _), ENum (53, _)]]) = getDouble n cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum ( 8, _), ENum (24, _)]]) = getFloat n cvt (EApp [ECon "as", n, ECon "Float64"]) = getDouble n cvt (EApp [ECon "as", n, ECon "Float32"]) = getFloat n -- NB. Note the lengths on the mantissa for the following two are 23/52; not 24/53! cvt (EApp [ECon "fp", ENum (s, Just 1), ENum ( e, Just 8), ENum (m, Just 23)]) = return $ EFloat $ getTripleFloat s e m cvt (EApp [ECon "fp", ENum (s, Just 1), ENum ( e, Just 11), ENum (m, Just 52)]) = return $ EDouble $ getTripleDouble s e m cvt (EApp [ECon "_", ECon "NaN", ENum ( 8, _), ENum (24, _)]) = return $ EFloat nan cvt (EApp [ECon "_", ECon "NaN", ENum (11, _), ENum (53, _)]) = return $ EDouble nan cvt (EApp [ECon "_", ECon "+oo", ENum ( 8, _), ENum (24, _)]) = return $ EFloat infinity cvt (EApp [ECon "_", ECon "+oo", ENum (11, _), ENum (53, _)]) = return $ EDouble infinity cvt (EApp [ECon "_", ECon "-oo", ENum ( 8, _), ENum (24, _)]) = return $ EFloat (-infinity) cvt (EApp [ECon "_", ECon "-oo", ENum (11, _), ENum (53, _)]) = return $ EDouble (-infinity) cvt (EApp [ECon "_", ECon "+zero", ENum ( 8, _), ENum (24, _)]) = return $ EFloat 0 cvt (EApp [ECon "_", ECon "+zero", ENum (11, _), ENum (53, _)]) = return $ EDouble 0 cvt (EApp [ECon "_", ECon "-zero", ENum ( 8, _), ENum (24, _)]) = return $ EFloat (-0) cvt (EApp [ECon "_", ECon "-zero", ENum (11, _), ENum (53, _)]) = return $ EDouble (-0) cvt x = return x getCoeff (EApp [ECon "*", ENum k, EApp [ECon "^", ECon "x", ENum p]]) = return (fst k, fst p) -- kx^p getCoeff (EApp [ECon "*", ENum k, ECon "x" ] ) = return (fst k, 1) -- kx getCoeff ( EApp [ECon "^", ECon "x", ENum p] ) = return ( 1, fst p) -- x^p getCoeff ( ECon "x" ) = return ( 1, 1) -- x getCoeff ( ENum k ) = return (fst k, 0) -- k getCoeff x = die $ "Cannot parse a root-obj,\nProcessing term: " ++ show x getDouble (ECon s) = case (s, rdFP (dropWhile (== '+') s)) of ("plusInfinity", _ ) -> return $ EDouble infinity ("minusInfinity", _ ) -> return $ EDouble (-infinity) ("oo", _ ) -> return $ EDouble infinity ("-oo", _ ) -> return $ EDouble (-infinity) ("zero", _ ) -> return $ EDouble 0 ("-zero", _ ) -> return $ EDouble (-0) ("NaN", _ ) -> return $ EDouble nan (_, Just v) -> return $ EDouble v _ -> die $ "Cannot parse a double value from: " ++ s getDouble (EApp [_, s, _, _]) = getDouble s getDouble (EReal r) = return $ EDouble $ fromRat $ toRational r getDouble x = die $ "Cannot parse a double value from: " ++ show x getFloat (ECon s) = case (s, rdFP (dropWhile (== '+') s)) of ("plusInfinity", _ ) -> return $ EFloat infinity ("minusInfinity", _ ) -> return $ EFloat (-infinity) ("oo", _ ) -> return $ EFloat infinity ("-oo", _ ) -> return $ EFloat (-infinity) ("zero", _ ) -> return $ EFloat 0 ("-zero", _ ) -> return $ EFloat (-0) ("NaN", _ ) -> return $ EFloat nan (_, Just v) -> return $ EFloat v _ -> die $ "Cannot parse a float value from: " ++ s getFloat (EReal r) = return $ EFloat $ fromRat $ toRational r getFloat (EApp [_, s, _, _]) = getFloat s getFloat x = die $ "Cannot parse a float value from: " ++ show x -- | Parses the Z3 floating point formatted numbers like so: 1.321p5/1.2123e9 etc. rdFP :: (Read a, RealFloat a) => String -> Maybe a rdFP s = case break (`elem` "pe") s of (m, 'p':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * ( 2 ** e') (m, 'e':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * (10 ** e') (m, "") -> rd m _ -> Nothing where rd v = case reads v of [(n, "")] -> Just n _ -> Nothing -- | Convert an (s, e, m) triple to a float value getTripleFloat :: Integer -> Integer -> Integer -> Float getTripleFloat s e m = wordToFloat w32 where sign = [s == 1] expt = [e `testBit` i | i <- [ 7, 6 .. 0]] mantissa = [m `testBit` i | i <- [22, 21 .. 0]] positions = [i | (i, b) <- zip [31, 30 .. 0] (sign ++ expt ++ mantissa), b] w32 = foldr (flip setBit) (0::Word32) positions -- | Convert an (s, e, m) triple to a float value getTripleDouble :: Integer -> Integer -> Integer -> Double getTripleDouble s e m = wordToDouble w64 where sign = [s == 1] expt = [e `testBit` i | i <- [10, 9 .. 0]] mantissa = [m `testBit` i | i <- [51, 50 .. 0]] positions = [i | (i, b) <- zip [63, 62 .. 0] (sign ++ expt ++ mantissa), b] w64 = foldr (flip setBit) (0::Word64) positions -- | Special constants of SMTLib2 and their internal translation. Mainly -- rounding modes for now. constantMap :: String -> String constantMap n = fromMaybe n (listToMaybe [to | (from, to) <- special, n `elem` from]) where special = [ (["RNE", "roundNearestTiesToEven"], show RoundNearestTiesToEven) , (["RNA", "roundNearestTiesToAway"], show RoundNearestTiesToAway) , (["RTP", "roundTowardPositive"], show RoundTowardPositive) , (["RTN", "roundTowardNegative"], show RoundTowardNegative) , (["RTZ", "roundTowardZero"], show RoundTowardZero) ] sbv-5.12/Data/SBV/Provers/Yices.hs0000644000000000000000000000411612725411266015004 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.Yices -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the Yices SMT solver ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Provers.Yices(yices) where import Data.SBV.BitVectors.Data import Data.SBV.SMT.SMT -- | The description of the Yices SMT solver -- The default executable is @\"yices-smt2\"@, which must be in your path. You can use the @SBV_YICES@ environment variable to point to the executable on your system. -- SBV does not pass any arguments to yices. You can use the @SBV_YICES_OPTIONS@ environment variable to override the options. yices :: SMTSolver yices = SMTSolver { name = Yices , executable = "yices-smt2" , options = [] , engine = standardEngine "SBV_YICES" "SBV_YICES_OPTIONS" addTimeOut standardModel , capabilities = SolverCapabilities { capSolverName = "Yices" , mbDefaultLogic = logic , supportsMacros = True , supportsProduceModels = True , supportsQuantifiers = False , supportsUninterpretedSorts = True , supportsUnboundedInts = True , supportsReals = True , supportsFloats = False , supportsDoubles = False } } where addTimeOut _ _ = error "Yices: Timeout values are not supported by Yices" -- Yices doesn't like it if we don't set the logic; so pick one and hope for the best logic hasReals | hasReals = Just "QF_UFLRA" | True = Just "QF_AUFLIA" sbv-5.12/Data/SBV/Provers/Z3.hs0000644000000000000000000001456012725411266014230 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Provers.Z3 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The connection to the Z3 SMT solver ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module Data.SBV.Provers.Z3(z3) where import qualified Control.Exception as C import Data.Char (toLower) import Data.Function (on) import Data.List (sortBy, intercalate, groupBy) import System.Environment (getEnv) import qualified System.Info as S(os) import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.PrettyNum import Data.SBV.SMT.SMT import Data.SBV.SMT.SMTLib import Data.SBV.Utils.Lib (splitArgs) -- Choose the correct prefix character for passing options -- TBD: Is there a more foolproof way of determining this? optionPrefix :: Char optionPrefix | map toLower S.os `elem` ["linux", "darwin"] = '-' | True = '/' -- windows -- | The description of the Z3 SMT solver -- The default executable is @\"z3\"@, which must be in your path. You can use the @SBV_Z3@ environment variable to point to the executable on your system. -- The default options are @\"-in -smt2\"@, which is valid for Z3 4.1. You can use the @SBV_Z3_OPTIONS@ environment variable to override the options. z3 :: SMTSolver z3 = SMTSolver { name = Z3 , executable = "z3" , options = map (optionPrefix:) ["nw", "in", "smt2"] , engine = \cfg isSat qinps skolemMap pgm -> do execName <- getEnv "SBV_Z3" `C.catch` (\(_ :: C.SomeException) -> return (executable (solver cfg))) execOpts <- (splitArgs `fmap` getEnv "SBV_Z3_OPTIONS") `C.catch` (\(_ :: C.SomeException) -> return (options (solver cfg))) let cfg' = cfg { solver = (solver cfg) {executable = execName, options = addTimeOut (timeOut cfg) execOpts} } tweaks = case solverTweaks cfg' of [] -> "" ts -> unlines $ "; --- user given solver tweaks ---" : ts ++ ["; --- end of user given tweaks ---"] dlim = printRealPrec cfg' ppDecLim = "(set-option :pp.decimal_precision " ++ show dlim ++ ")\n" script = SMTScript {scriptBody = tweaks ++ ppDecLim ++ pgm, scriptModel = Just (cont (roundingMode cfg) skolemMap)} standardSolver cfg' script id (ProofError cfg') (interpretSolverOutput cfg' (extractMap isSat qinps)) , capabilities = SolverCapabilities { capSolverName = "Z3" , mbDefaultLogic = const Nothing , supportsMacros = True , supportsProduceModels = True , supportsQuantifiers = True , supportsUninterpretedSorts = True , supportsUnboundedInts = True , supportsReals = True , supportsFloats = True , supportsDoubles = True } } where cont rm skolemMap = intercalate "\n" $ concatMap extract skolemMap where -- In the skolemMap: -- * Left's are universals: i.e., the model should be true for -- any of these. So, we simply "echo 0" for these values. -- * Right's are existentials. If there are no dependencies (empty list), then we can -- simply use get-value to extract it's value. Otherwise, we have to apply it to -- an appropriate number of 0's to get the final value. extract (Left s) = ["(echo \"((" ++ show s ++ " " ++ mkSkolemZero rm (kindOf s) ++ "))\")"] extract (Right (s, [])) = let g = "(get-value (" ++ show s ++ "))" in getVal (kindOf s) g extract (Right (s, ss)) = let g = "(get-value ((" ++ show s ++ concat [' ' : mkSkolemZero rm (kindOf a) | a <- ss] ++ ")))" in getVal (kindOf s) g getVal KReal g = ["(set-option :pp.decimal false) " ++ g, "(set-option :pp.decimal true) " ++ g] getVal _ g = [g] addTimeOut Nothing o = o addTimeOut (Just i) o | i < 0 = error $ "Z3: Timeout value must be non-negative, received: " ++ show i | True = o ++ [optionPrefix : "T:" ++ show i] extractMap :: Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel extractMap isSat qinps solverLines = SMTModel { modelAssocs = map snd $ squashReals $ sortByNodeId $ concatMap (interpretSolverModelLine inps) solverLines } where sortByNodeId :: [(Int, a)] -> [(Int, a)] sortByNodeId = sortBy (compare `on` fst) inps -- for "sat", display the prefix existentials. For completeness, we will drop -- only the trailing foralls. Exception: Don't drop anything if it's all a sequence of foralls | isSat = map snd $ if all (== ALL) (map fst qinps) then qinps else reverse $ dropWhile ((== ALL) . fst) $ reverse qinps -- for "proof", just display the prefix universals | True = map snd $ takeWhile ((== ALL) . fst) qinps squashReals :: [(Int, (String, CW))] -> [(Int, (String, CW))] squashReals = concatMap squash . groupBy ((==) `on` fst) where squash [(i, (n, cw1)), (_, (_, cw2))] = [(i, (n, mergeReals n cw1 cw2))] squash xs = xs mergeReals :: String -> CW -> CW -> CW mergeReals n (CW KReal (CWAlgReal a)) (CW KReal (CWAlgReal b)) = CW KReal (CWAlgReal (mergeAlgReals (bad n a b) a b)) mergeReals n a b = bad n a b bad n a b = error $ "SBV.Z3: Cannot merge reals for variable: " ++ n ++ " received: " ++ show (a, b) sbv-5.12/Data/SBV/SMT/0000755000000000000000000000000012725411266012375 5ustar0000000000000000sbv-5.12/Data/SBV/SMT/SMT.hs0000644000000000000000000007362312725411266013407 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.SMT.SMT -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Abstraction of SMT solvers ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE DefaultSignatures #-} module Data.SBV.SMT.SMT where import qualified Control.Exception as C import Control.Concurrent (newEmptyMVar, takeMVar, putMVar, forkIO) import Control.DeepSeq (NFData(..)) import Control.Monad (when, zipWithM) import Data.Char (isSpace) import Data.Int (Int8, Int16, Int32, Int64) import Data.Function (on) import Data.List (intercalate, isPrefixOf, isInfixOf, sortBy) import Data.Word (Word8, Word16, Word32, Word64) import System.Directory (findExecutable) import System.Environment (getEnv) import System.Exit (ExitCode(..)) import System.IO (hClose, hFlush, hPutStr, hGetContents, hGetLine) import System.Process (runInteractiveProcess, waitForProcess, terminateProcess) import qualified Data.Map as M import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.PrettyNum import Data.SBV.BitVectors.Symbolic (SMTEngine) import Data.SBV.SMT.SMTLib (interpretSolverOutput, interpretSolverModelLine) import Data.SBV.Utils.Lib (joinArgs, splitArgs) import Data.SBV.Utils.TDiff -- | Extract the final configuration from a result resultConfig :: SMTResult -> SMTConfig resultConfig (Unsatisfiable c) = c resultConfig (Satisfiable c _) = c resultConfig (Unknown c _) = c resultConfig (ProofError c _) = c resultConfig (TimeOut c) = c -- | A 'prove' call results in a 'ThmResult' newtype ThmResult = ThmResult SMTResult -- | A 'sat' call results in a 'SatResult' -- The reason for having a separate 'SatResult' is to have a more meaningful 'Show' instance. newtype SatResult = SatResult SMTResult -- | A 'safe' call results in a 'SafeResult' newtype SafeResult = SafeResult (Maybe String, String, SMTResult) -- | An 'allSat' call results in a 'AllSatResult'. The boolean says whether -- we should warn the user about prefix-existentials. newtype AllSatResult = AllSatResult (Bool, [SMTResult]) -- | User friendly way of printing theorem results instance Show ThmResult where show (ThmResult r) = showSMTResult "Q.E.D." "Unknown" "Unknown. Potential counter-example:\n" "Falsifiable" "Falsifiable. Counter-example:\n" r -- | User friendly way of printing satisfiablity results instance Show SatResult where show (SatResult r) = showSMTResult "Unsatisfiable" "Unknown" "Unknown. Potential model:\n" "Satisfiable" "Satisfiable. Model:\n" r -- | User friendly way of printing safety results instance Show SafeResult where show (SafeResult (mbLoc, msg, r)) = showSMTResult (tag "No violations detected") (tag "Unknown") (tag "Unknown. Potential violating model:\n") (tag "Violated") (tag "Violated. Model:\n") r where loc = maybe "" (++ ": ") mbLoc tag s = loc ++ msg ++ ": " ++ s -- | The Show instance of AllSatResults. Note that we have to be careful in being lazy enough -- as the typical use case is to pull results out as they become available. instance Show AllSatResult where show (AllSatResult (e, xs)) = go (0::Int) xs where uniqueWarn | e = " (Unique up to prefix existentials.)" | True = "" go c (s:ss) = let c' = c+1 (ok, o) = sh c' s in c' `seq` if ok then o ++ "\n" ++ go c' ss else o go c [] = case c of 0 -> "No solutions found." 1 -> "This is the only solution." ++ uniqueWarn _ -> "Found " ++ show c ++ " different solutions." ++ uniqueWarn sh i c = (ok, showSMTResult "Unsatisfiable" "Unknown" "Unknown. Potential model:\n" ("Solution #" ++ show i ++ ":\nSatisfiable") ("Solution #" ++ show i ++ ":\n") c) where ok = case c of Satisfiable{} -> True _ -> False -- | Instances of 'SatModel' can be automatically extracted from models returned by the -- solvers. The idea is that the sbv infrastructure provides a stream of 'CW''s (constant-words) -- coming from the solver, and the type @a@ is interpreted based on these constants. Many typical -- instances are already provided, so new instances can be declared with relative ease. -- -- Minimum complete definition: 'parseCWs' class SatModel a where -- | Given a sequence of constant-words, extract one instance of the type @a@, returning -- the remaining elements untouched. If the next element is not what's expected for this -- type you should return 'Nothing' parseCWs :: [CW] -> Maybe (a, [CW]) -- | Given a parsed model instance, transform it using @f@, and return the result. -- The default definition for this method should be sufficient in most use cases. cvtModel :: (a -> Maybe b) -> Maybe (a, [CW]) -> Maybe (b, [CW]) cvtModel f x = x >>= \(a, r) -> f a >>= \b -> return (b, r) default parseCWs :: Read a => [CW] -> Maybe (a, [CW]) parseCWs (CW _ (CWUserSort (_, s)) : r) = Just (read s, r) parseCWs _ = Nothing -- | Parse a signed/sized value from a sequence of CWs genParse :: Integral a => Kind -> [CW] -> Maybe (a, [CW]) genParse k (x@(CW _ (CWInteger i)):r) | kindOf x == k = Just (fromIntegral i, r) genParse _ _ = Nothing -- | Base case for 'SatModel' at unit type. Comes in handy if there are no real variables. instance SatModel () where parseCWs xs = return ((), xs) -- | 'Bool' as extracted from a model instance SatModel Bool where parseCWs xs = do (x, r) <- genParse KBool xs return ((x :: Integer) /= 0, r) -- | 'Word8' as extracted from a model instance SatModel Word8 where parseCWs = genParse (KBounded False 8) -- | 'Int8' as extracted from a model instance SatModel Int8 where parseCWs = genParse (KBounded True 8) -- | 'Word16' as extracted from a model instance SatModel Word16 where parseCWs = genParse (KBounded False 16) -- | 'Int16' as extracted from a model instance SatModel Int16 where parseCWs = genParse (KBounded True 16) -- | 'Word32' as extracted from a model instance SatModel Word32 where parseCWs = genParse (KBounded False 32) -- | 'Int32' as extracted from a model instance SatModel Int32 where parseCWs = genParse (KBounded True 32) -- | 'Word64' as extracted from a model instance SatModel Word64 where parseCWs = genParse (KBounded False 64) -- | 'Int64' as extracted from a model instance SatModel Int64 where parseCWs = genParse (KBounded True 64) -- | 'Integer' as extracted from a model instance SatModel Integer where parseCWs = genParse KUnbounded -- | 'AlgReal' as extracted from a model instance SatModel AlgReal where parseCWs (CW KReal (CWAlgReal i) : r) = Just (i, r) parseCWs _ = Nothing -- | 'Float' as extracted from a model instance SatModel Float where parseCWs (CW KFloat (CWFloat i) : r) = Just (i, r) parseCWs _ = Nothing -- | 'Double' as extracted from a model instance SatModel Double where parseCWs (CW KDouble (CWDouble i) : r) = Just (i, r) parseCWs _ = Nothing -- | 'CW' as extracted from a model; trivial definition instance SatModel CW where parseCWs (cw : r) = Just (cw, r) parseCWs [] = Nothing -- | A rounding mode, extracted from a model. (Default definition suffices) instance SatModel RoundingMode -- | A list of values as extracted from a model. When reading a list, we -- go as long as we can (maximal-munch). Note that this never fails, as -- we can always return the empty list! instance SatModel a => SatModel [a] where parseCWs [] = Just ([], []) parseCWs xs = case parseCWs xs of Just (a, ys) -> case parseCWs ys of Just (as, zs) -> Just (a:as, zs) Nothing -> Just ([], ys) Nothing -> Just ([], xs) -- | Tuples extracted from a model instance (SatModel a, SatModel b) => SatModel (a, b) where parseCWs as = do (a, bs) <- parseCWs as (b, cs) <- parseCWs bs return ((a, b), cs) -- | 3-Tuples extracted from a model instance (SatModel a, SatModel b, SatModel c) => SatModel (a, b, c) where parseCWs as = do (a, bs) <- parseCWs as ((b, c), ds) <- parseCWs bs return ((a, b, c), ds) -- | 4-Tuples extracted from a model instance (SatModel a, SatModel b, SatModel c, SatModel d) => SatModel (a, b, c, d) where parseCWs as = do (a, bs) <- parseCWs as ((b, c, d), es) <- parseCWs bs return ((a, b, c, d), es) -- | 5-Tuples extracted from a model instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e) => SatModel (a, b, c, d, e) where parseCWs as = do (a, bs) <- parseCWs as ((b, c, d, e), fs) <- parseCWs bs return ((a, b, c, d, e), fs) -- | 6-Tuples extracted from a model instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e, SatModel f) => SatModel (a, b, c, d, e, f) where parseCWs as = do (a, bs) <- parseCWs as ((b, c, d, e, f), gs) <- parseCWs bs return ((a, b, c, d, e, f), gs) -- | 7-Tuples extracted from a model instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e, SatModel f, SatModel g) => SatModel (a, b, c, d, e, f, g) where parseCWs as = do (a, bs) <- parseCWs as ((b, c, d, e, f, g), hs) <- parseCWs bs return ((a, b, c, d, e, f, g), hs) -- | Various SMT results that we can extract models out of. class Modelable a where -- | Is there a model? modelExists :: a -> Bool -- | Extract a model, the result is a tuple where the first argument (if True) -- indicates whether the model was "probable". (i.e., if the solver returned unknown.) getModel :: SatModel b => a -> Either String (Bool, b) -- | Extract a model dictionary. Extract a dictionary mapping the variables to -- their respective values as returned by the SMT solver. Also see `getModelDictionaries`. getModelDictionary :: a -> M.Map String CW -- | Extract a model value for a given element. Also see `getModelValues`. getModelValue :: SymWord b => String -> a -> Maybe b getModelValue v r = fromCW `fmap` (v `M.lookup` getModelDictionary r) -- | Extract a representative name for the model value of an uninterpreted kind. -- This is supposed to correspond to the value as computed internally by the -- SMT solver; and is unportable from solver to solver. Also see `getModelUninterpretedValues`. getModelUninterpretedValue :: String -> a -> Maybe String getModelUninterpretedValue v r = case v `M.lookup` getModelDictionary r of Just (CW _ (CWUserSort (_, s))) -> Just s _ -> Nothing -- | A simpler variant of 'getModel' to get a model out without the fuss. extractModel :: SatModel b => a -> Maybe b extractModel a = case getModel a of Right (_, b) -> Just b _ -> Nothing -- | Return all the models from an 'allSat' call, similar to 'extractModel' but -- is suitable for the case of multiple results. extractModels :: SatModel a => AllSatResult -> [a] extractModels (AllSatResult (_, xs)) = [ms | Right (_, ms) <- map getModel xs] -- | Get dictionaries from an all-sat call. Similar to `getModelDictionary`. getModelDictionaries :: AllSatResult -> [M.Map String CW] getModelDictionaries (AllSatResult (_, xs)) = map getModelDictionary xs -- | Extract value of a variable from an all-sat call. Similar to `getModelValue`. getModelValues :: SymWord b => String -> AllSatResult -> [Maybe b] getModelValues s (AllSatResult (_, xs)) = map (s `getModelValue`) xs -- | Extract value of an uninterpreted variable from an all-sat call. Similar to `getModelUninterpretedValue`. getModelUninterpretedValues :: String -> AllSatResult -> [Maybe String] getModelUninterpretedValues s (AllSatResult (_, xs)) = map (s `getModelUninterpretedValue`) xs -- | 'ThmResult' as a generic model provider instance Modelable ThmResult where getModel (ThmResult r) = getModel r modelExists (ThmResult r) = modelExists r getModelDictionary (ThmResult r) = getModelDictionary r -- | 'SatResult' as a generic model provider instance Modelable SatResult where getModel (SatResult r) = getModel r modelExists (SatResult r) = modelExists r getModelDictionary (SatResult r) = getModelDictionary r -- | 'SMTResult' as a generic model provider instance Modelable SMTResult where getModel (Unsatisfiable _) = Left "SBV.getModel: Unsatisfiable result" getModel (Unknown _ m) = Right (True, parseModelOut m) getModel (ProofError _ s) = error $ unlines $ "Backend solver complains: " : s getModel (TimeOut _) = Left "Timeout" getModel (Satisfiable _ m) = Right (False, parseModelOut m) modelExists Satisfiable{} = True modelExists Unknown{} = False -- don't risk it modelExists _ = False getModelDictionary (Unsatisfiable _) = M.empty getModelDictionary (Unknown _ m) = M.fromList (modelAssocs m) getModelDictionary (ProofError _ _) = M.empty getModelDictionary (TimeOut _) = M.empty getModelDictionary (Satisfiable _ m) = M.fromList (modelAssocs m) -- | Extract a model out, will throw error if parsing is unsuccessful parseModelOut :: SatModel a => SMTModel -> a parseModelOut m = case parseCWs [c | (_, c) <- modelAssocs m] of Just (x, []) -> x Just (_, ys) -> error $ "SBV.getModel: Partially constructed model; remaining elements: " ++ show ys Nothing -> error $ "SBV.getModel: Cannot construct a model from: " ++ show m -- | Given an 'allSat' call, we typically want to iterate over it and print the results in sequence. The -- 'displayModels' function automates this task by calling 'disp' on each result, consecutively. The first -- 'Int' argument to 'disp' 'is the current model number. The second argument is a tuple, where the first -- element indicates whether the model is alleged (i.e., if the solver is not sure, returing Unknown) displayModels :: SatModel a => (Int -> (Bool, a) -> IO ()) -> AllSatResult -> IO Int displayModels disp (AllSatResult (_, ms)) = do inds <- zipWithM display [a | Right a <- map (getModel . SatResult) ms] [(1::Int)..] return $ last (0:inds) where display r i = disp i r >> return i -- | Show an SMTResult; generic version showSMTResult :: String -> String -> String -> String -> String -> SMTResult -> String showSMTResult unsatMsg unkMsg unkMsgModel satMsg satMsgModel result = case result of Unsatisfiable _ -> unsatMsg Satisfiable _ (SMTModel []) -> satMsg Satisfiable _ m -> satMsgModel ++ showModel cfg m Unknown _ (SMTModel []) -> unkMsg Unknown _ m -> unkMsgModel ++ showModel cfg m ProofError _ [] -> "*** An error occurred. No additional information available. Try running in verbose mode" ProofError _ ls -> "*** An error occurred.\n" ++ intercalate "\n" (map ("*** " ++) ls) TimeOut _ -> "*** Timeout" where cfg = resultConfig result -- | Show a model in human readable form. Ignore bindings to those variables that start -- with "__internal_sbv_" and also those marked as "nonModelVar" in the config; as these are only for internal purposes showModel :: SMTConfig -> SMTModel -> String showModel cfg model | null allVars = "[There are no variables bound by the model.]" | null relevantVars = "[There are no model-variables bound by the model.]" | True = intercalate "\n" . display . map shM $ relevantVars where allVars = modelAssocs model relevantVars = filter (not . ignore) allVars ignore (s, _) = "__internal_sbv_" `isPrefixOf` s || isNonModelVar cfg s shM (s, v) = let vs = shCW cfg v in ((length s, s), (vlength vs, vs)) display svs = map line svs where line ((_, s), (_, v)) = " " ++ right (nameWidth - length s) s ++ " = " ++ left (valWidth - lTrimRight (valPart v)) v nameWidth = maximum $ 0 : [l | ((l, _), _) <- svs] valWidth = maximum $ 0 : [l | (_, (l, _)) <- svs] right p s = s ++ replicate p ' ' left p s = replicate p ' ' ++ s vlength s = case dropWhile (/= ':') (reverse (takeWhile (/= '\n') s)) of (':':':':r) -> length (dropWhile isSpace r) _ -> length s -- conservative valPart "" = "" valPart (':':':':_) = "" valPart (x:xs) = x : valPart xs lTrimRight = length . dropWhile isSpace . reverse -- | Show a constant value, in the user-specified base shCW :: SMTConfig -> CW -> String shCW = sh . printBase where sh 2 = binS sh 10 = show sh 16 = hexS sh n = \w -> show w ++ " -- Ignoring unsupported printBase " ++ show n ++ ", use 2, 10, or 16." -- | Print uninterpreted function values from models. Very, very crude.. shUI :: (String, [String]) -> [String] shUI (flong, cases) = (" -- uninterpreted: " ++ f) : map shC cases where tf = dropWhile (/= '_') flong f = if null tf then flong else tail tf shC s = " " ++ s -- | Print uninterpreted array values from models. Very, very crude.. shUA :: (String, [String]) -> [String] shUA (f, cases) = (" -- array: " ++ f) : map shC cases where shC s = " " ++ s -- | Helper function to spin off to an SMT solver. pipeProcess :: SMTConfig -> String -> [String] -> SMTScript -> (String -> String) -> IO (Either String [String]) pipeProcess cfg execName opts script cleanErrs = do let nm = show (name (solver cfg)) mbExecPath <- findExecutable execName case mbExecPath of Nothing -> return $ Left $ "Unable to locate executable for " ++ nm ++ "\nExecutable specified: " ++ show execName Just execPath -> do solverResult <- dispatchSolver cfg execPath opts script case solverResult of Left s -> return $ Left s Right (ec, contents, allErrors) -> let errors = dropWhile isSpace (cleanErrs allErrors) in case (null errors, ec) of (True, ExitSuccess) -> return $ Right $ map clean (filter (not . null) (lines contents)) (_, ec') -> let errors' = if null errors then (if null (dropWhile isSpace contents) then "(No error message printed on stderr by the executable.)" else contents) else errors finalEC = case (ec', ec) of (ExitFailure n, _) -> n (_, ExitFailure n) -> n _ -> 0 -- can happen if ExitSuccess but there is output on stderr in return $ Left $ "Failed to complete the call to " ++ nm ++ "\nExecutable : " ++ show execPath ++ "\nOptions : " ++ joinArgs opts ++ "\nExit code : " ++ show finalEC ++ "\nSolver output: " ++ "\n" ++ line ++ "\n" ++ intercalate "\n" (filter (not . null) (lines errors')) ++ "\n" ++ line ++ "\nGiving up.." where clean = reverse . dropWhile isSpace . reverse . dropWhile isSpace line = replicate 78 '=' -- | The standard-model that most SMT solvers should happily work with standardModel :: (Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel, SW -> String -> [String]) standardModel = (standardModelExtractor, standardValueExtractor) -- | Some solvers (Z3) require multiple calls for certain value extractions; as in multi-precision reals. Deal with that here standardValueExtractor :: SW -> String -> [String] standardValueExtractor _ l = [l] -- | A standard post-processor: Reading the lines of solver output and turning it into a model: standardModelExtractor :: Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel standardModelExtractor isSat qinps solverLines = SMTModel { modelAssocs = map snd $ sortByNodeId $ concatMap (interpretSolverModelLine inps) solverLines } where sortByNodeId :: [(Int, a)] -> [(Int, a)] sortByNodeId = sortBy (compare `on` fst) inps -- for "sat", display the prefix existentials. For completeness, we will drop -- only the trailing foralls. Exception: Don't drop anything if it's all a sequence of foralls | isSat = map snd $ if all (== ALL) (map fst qinps) then qinps else reverse $ dropWhile ((== ALL) . fst) $ reverse qinps -- for "proof", just display the prefix universals | True = map snd $ takeWhile ((== ALL) . fst) qinps -- | A standard engine interface. Most solvers follow-suit here in how we "chat" to them.. standardEngine :: String -> String -> ([String] -> Int -> [String]) -> (Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel, SW -> String -> [String]) -> SMTEngine standardEngine envName envOptName addTimeOut (extractMap, extractValue) cfg isSat qinps skolemMap pgm = do execName <- getEnv envName `C.catch` (\(_ :: C.SomeException) -> return (executable (solver cfg))) execOpts <- (splitArgs `fmap` getEnv envOptName) `C.catch` (\(_ :: C.SomeException) -> return (options (solver cfg))) let cfg' = cfg {solver = (solver cfg) {executable = execName, options = maybe execOpts (addTimeOut execOpts) (timeOut cfg)}} tweaks = case solverTweaks cfg' of [] -> "" ts -> unlines $ "; --- user given solver tweaks ---" : ts ++ ["; --- end of user given tweaks ---"] cont rm = intercalate "\n" $ concatMap extract skolemMap where extract (Left s) = extractValue s $ "(echo \"((" ++ show s ++ " " ++ mkSkolemZero rm (kindOf s) ++ "))\")" extract (Right (s, [])) = extractValue s $ "(get-value (" ++ show s ++ "))" extract (Right (s, ss)) = extractValue s $ "(get-value (" ++ show s ++ concat [' ' : mkSkolemZero rm (kindOf a) | a <- ss] ++ "))" script = SMTScript {scriptBody = tweaks ++ pgm, scriptModel = Just (cont (roundingMode cfg))} standardSolver cfg' script id (ProofError cfg') (interpretSolverOutput cfg' (extractMap isSat qinps)) -- | A standard solver interface. If the solver is SMT-Lib compliant, then this function should suffice in -- communicating with it. standardSolver :: SMTConfig -> SMTScript -> (String -> String) -> ([String] -> a) -> ([String] -> a) -> IO a standardSolver config script cleanErrs failure success = do let msg = when (verbose config) . putStrLn . ("** " ++) smtSolver= solver config exec = executable smtSolver opts = options smtSolver isTiming = timing config nmSolver = show (name smtSolver) msg $ "Calling: " ++ show (unwords (exec:[joinArgs opts])) case smtFile config of Nothing -> return () Just f -> do msg $ "Saving the generated script in file: " ++ show f writeFile f (scriptBody script) contents <- timeIf isTiming nmSolver $ pipeProcess config exec opts script cleanErrs msg $ nmSolver ++ " output:\n" ++ either id (intercalate "\n") contents case contents of Left e -> return $ failure (lines e) Right xs -> return $ success (mergeSExpr xs) -- | Wrap the solver call to protect against any exceptions dispatchSolver :: SMTConfig -> FilePath -> [String] -> SMTScript -> IO (Either String (ExitCode, String, String)) dispatchSolver cfg execPath opts script = rnf script `seq` (Right `fmap` runSolver cfg execPath opts script) `C.catch` (\(e::C.SomeException) -> bad (show e)) where bad s = return $ Left $ unlines [ "Failed to start the external solver: " ++ s , "Make sure you can start " ++ show execPath , "from the command line without issues." ] -- | A variant of 'readProcessWithExitCode'; except it knows about continuation strings -- and can speak SMT-Lib2 (just a little). runSolver :: SMTConfig -> FilePath -> [String] -> SMTScript -> IO (ExitCode, String, String) runSolver cfg execPath opts script = do (send, ask, cleanUp, pid) <- do (inh, outh, errh, pid) <- runInteractiveProcess execPath opts Nothing Nothing let send l = hPutStr inh (l ++ "\n") >> hFlush inh recv = hGetLine outh ask l = send l >> recv cleanUp response = do hClose inh outMVar <- newEmptyMVar out <- hGetContents outh _ <- forkIO $ C.evaluate (length out) >> putMVar outMVar () err <- hGetContents errh _ <- forkIO $ C.evaluate (length err) >> putMVar outMVar () takeMVar outMVar takeMVar outMVar hClose outh hClose errh ex <- waitForProcess pid return $ case response of Nothing -> (ex, out, err) Just (r, vals) -> -- if the status is unknown, prepare for the possibility of not having a model -- TBD: This is rather crude and potentially Z3 specific let finalOut = intercalate "\n" (r : vals) notAvail = "model is not available" `isInfixOf` (finalOut ++ out ++ err) in if "unknown" `isPrefixOf` r && notAvail then (ExitSuccess, "unknown" , "") else (ex, finalOut ++ "\n" ++ out, err) return (send, ask, cleanUp, pid) let executeSolver = do mapM_ send (lines (scriptBody script)) response <- case scriptModel script of Nothing -> do send $ satCmd cfg return Nothing Just ls -> do r <- ask $ satCmd cfg vals <- if any (`isPrefixOf` r) ["sat", "unknown"] then do let mls = lines ls when (verbose cfg) $ do putStrLn "** Sending the following model extraction commands:" mapM_ putStrLn mls mapM ask mls else return [] return $ Just (r, vals) cleanUp response executeSolver `C.onException` (terminateProcess pid >> waitForProcess pid) -- | In case the SMT-Lib solver returns a response over multiple lines, compress them so we have -- each S-Expression spanning only a single line. We'll ignore things line parentheses inside quotes -- etc., as it should not be an issue mergeSExpr :: [String] -> [String] mergeSExpr [] = [] mergeSExpr (x:xs) | d == 0 = x : mergeSExpr xs | True = let (f, r) = grab d xs in unwords (x:f) : mergeSExpr r where d = parenDiff x parenDiff :: String -> Int parenDiff = go 0 where go i "" = i go i ('(':cs) = let i'= i+1 in i' `seq` go i' cs go i (')':cs) = let i'= i-1 in i' `seq` go i' cs go i (_ :cs) = go i cs grab i ls | i <= 0 = ([], ls) grab _ [] = ([], []) grab i (l:ls) = let (a, b) = grab (i+parenDiff l) ls in (l:a, b) sbv-5.12/Data/SBV/SMT/SMTLib.hs0000644000000000000000000001740512725411266014032 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.SMT.SMTLib -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Conversion of symbolic programs to SMTLib format ----------------------------------------------------------------------------- module Data.SBV.SMT.SMTLib(SMTLibPgm, SMTLibConverter, toSMTLib2, addNonEqConstraints, interpretSolverOutput, interpretSolverModelLine) where import Data.Char (isDigit) import Data.SBV.BitVectors.Data import Data.SBV.Provers.SExpr import qualified Data.SBV.SMT.SMTLib2 as SMT2 import qualified Data.Set as Set (Set, member, toList) -- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.) type SMTLibConverter = RoundingMode -- ^ User selected rounding mode to be used for floating point arithmetic -> Maybe Logic -- ^ User selected logic to use. If Nothing, pick automatically. -> SolverCapabilities -- ^ Capabilities of the backend solver targeted -> Set.Set Kind -- ^ Kinds used in the problem -> Bool -- ^ is this a sat problem? -> [String] -- ^ extra comments to place on top -> [(Quantifier, NamedSymVar)] -- ^ inputs and aliasing names -> [Either SW (SW, [SW])] -- ^ skolemized inputs -> [(SW, CW)] -- ^ constants -> [((Int, Kind, Kind), [SW])] -- ^ auto-generated tables -> [(Int, ArrayInfo)] -- ^ user specified arrays -> [(String, SBVType)] -- ^ uninterpreted functions/constants -> [(String, [String])] -- ^ user given axioms -> SBVPgm -- ^ assignments -> [SW] -- ^ extra constraints -> SW -- ^ output variable -> SMTLibPgm -- | Convert to SMTLib-2 format toSMTLib2 :: SMTLibConverter toSMTLib2 = cvt SMTLib2 where cvt v roundMode smtLogic solverCaps kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out | KUnbounded `Set.member` kindInfo && not (supportsUnboundedInts solverCaps) = unsupported "unbounded integers" | KReal `Set.member` kindInfo && not (supportsReals solverCaps) = unsupported "algebraic reals" | needsFloats && not (supportsFloats solverCaps) = unsupported "single-precision floating-point numbers" | needsDoubles && not (supportsDoubles solverCaps) = unsupported "double-precision floating-point numbers" | needsQuantifiers && not (supportsQuantifiers solverCaps) = unsupported "quantifiers" | not (null sorts) && not (supportsUninterpretedSorts solverCaps) = unsupported "uninterpreted sorts" | True = SMTLibPgm v (aliasTable, pre, post) where sorts = [s | KUserSort s _ <- Set.toList kindInfo] unsupported w = error $ "SBV: Given problem needs " ++ w ++ ", which is not supported by SBV for the chosen solver: " ++ capSolverName solverCaps aliasTable = map (\(_, (x, y)) -> (y, x)) qinps converter = case v of SMTLib2 -> SMT2.cvt (pre, post) = converter roundMode smtLogic solverCaps kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out needsFloats = KFloat `Set.member` kindInfo needsDoubles = KDouble `Set.member` kindInfo needsQuantifiers | isSat = ALL `elem` quantifiers | True = EX `elem` quantifiers where quantifiers = map fst qinps -- | Add constraints generated from older models, used for querying new models addNonEqConstraints :: RoundingMode -> [(Quantifier, NamedSymVar)] -> [[(String, CW)]] -> SMTLibPgm -> Maybe String addNonEqConstraints rm qinps cs p@(SMTLibPgm SMTLib2 _) = SMT2.addNonEqConstraints rm qinps cs p -- | Interpret solver output based on SMT-Lib standard output responses interpretSolverOutput :: SMTConfig -> ([String] -> SMTModel) -> [String] -> SMTResult interpretSolverOutput cfg _ ("unsat":_) = Unsatisfiable cfg interpretSolverOutput cfg extractMap ("unknown":rest) = Unknown cfg $ extractMap rest interpretSolverOutput cfg extractMap ("sat":rest) = Satisfiable cfg $ extractMap rest interpretSolverOutput cfg _ ("timeout":_) = TimeOut cfg interpretSolverOutput cfg _ ls = ProofError cfg ls -- | Get a counter-example from an SMT-Lib2 like model output line -- This routing is necessarily fragile as SMT solvers tend to print output -- in whatever form they deem convenient for them.. Currently, it's tuned to -- work with Z3 and CVC4; if new solvers are added, we might need to rework -- the logic here. interpretSolverModelLine :: [NamedSymVar] -> String -> [(Int, (String, CW))] interpretSolverModelLine inps line = either err extract (parseSExpr line) where err r = error $ "*** Failed to parse SMT-Lib2 model output from: " ++ "*** " ++ show line ++ "\n" ++ "*** Reason: " ++ r ++ "\n" getInput (ECon v) = isInput v getInput (EApp (ECon v : _)) = isInput v getInput _ = Nothing isInput ('s':v) | all isDigit v = let inpId :: Int inpId = read v in case [(s, nm) | (s@(SW _ (NodeId n)), nm) <- inps, n == inpId] of [] -> Nothing [(s, nm)] -> Just (inpId, s, nm) matches -> error $ "SBV.SMTLib2: Cannot uniquely identify value for " ++ 's':v ++ " in " ++ show matches isInput _ = Nothing getUIIndex (KUserSort _ (Right xs)) i = i `lookup` zip xs [0..] getUIIndex _ _ = Nothing extract (EApp [EApp [v, ENum i]]) | Just (n, s, nm) <- getInput v = [(n, (nm, mkConstCW (kindOf s) (fst i)))] extract (EApp [EApp [v, EReal i]]) | Just (n, s, nm) <- getInput v, isReal s = [(n, (nm, CW KReal (CWAlgReal i)))] extract (EApp [EApp [v, ECon i]]) | Just (n, s, nm) <- getInput v, isUninterpreted s = let k = kindOf s in [(n, (nm, CW k (CWUserSort (getUIIndex k i, i))))] extract (EApp [EApp [v, EDouble i]]) | Just (n, s, nm) <- getInput v, isDouble s = [(n, (nm, CW KDouble (CWDouble i)))] extract (EApp [EApp [v, EFloat i]]) | Just (n, s, nm) <- getInput v, isFloat s = [(n, (nm, CW KFloat (CWFloat i)))] -- weird lambda app that CVC4 seems to throw out.. logic below derived from what I saw CVC4 print, hopefully sufficient extract (EApp (EApp (v : EApp (ECon "LAMBDA" : xs) : _) : _)) | Just{} <- getInput v, not (null xs) = extract (EApp [EApp [v, last xs]]) extract (EApp [EApp (v : r)]) | Just (_, _, nm) <- getInput v = error $ "SBV.SMTLib2: Cannot extract value for " ++ show nm ++ "\n\tInput: " ++ show line ++ "\n\tParse: " ++ show r extract _ = [] {-# ANN interpretSolverModelLine ("HLint: ignore Use elemIndex" :: String) #-} sbv-5.12/Data/SBV/SMT/SMTLib2.hs0000644000000000000000000010537512725411266014120 0ustar0000000000000000---------------------------------------------------------------------------- -- | -- Module : Data.SBV.SMT.SMTLib2 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Conversion of symbolic programs to SMTLib format, Using v2 of the standard ----------------------------------------------------------------------------- {-# LANGUAGE PatternGuards #-} module Data.SBV.SMT.SMTLib2(cvt, addNonEqConstraints) where import Data.Bits (bit) import Data.Function (on) import Data.Ord (comparing) import Data.List (intercalate, partition, groupBy, sortBy) import qualified Data.Foldable as F (toList) import qualified Data.Map as M import qualified Data.IntMap as IM import qualified Data.Set as Set import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.PrettyNum (smtRoundingMode, cwToSMTLib) -- | Add constraints to generate /new/ models. This function is used to query the SMT-solver, while -- disallowing a previous model. addNonEqConstraints :: RoundingMode -> [(Quantifier, NamedSymVar)] -> [[(String, CW)]] -> SMTLibPgm -> Maybe String addNonEqConstraints rm qinps allNonEqConstraints (SMTLibPgm _ (aliasTable, pre, post)) | null allNonEqConstraints = Just $ intercalate "\n" $ pre ++ post | null refutedModel = Nothing | True = Just $ intercalate "\n" $ pre ++ [ "; --- refuted-models ---" ] ++ refutedModel ++ post where refutedModel = concatMap (nonEqs rm . map intName) nonEqConstraints intName (s, c) | Just sw <- s `lookup` aliasTable = (show sw, c) | True = (s, c) -- with existentials, we only add top-level existentials to the refuted-models list nonEqConstraints = filter (not . null) $ map (filter (\(s, _) -> s `elem` topUnivs)) allNonEqConstraints topUnivs = [s | (_, (_, s)) <- takeWhile (\p -> fst p == EX) qinps] nonEqs :: RoundingMode -> [(String, CW)] -> [String] nonEqs rm scs = format $ interp ps ++ disallow (map eqClass uninterpClasses) where isFree (KUserSort _ (Left _)) = True isFree _ = False (ups, ps) = partition (isFree . kindOf . snd) scs format [] = [] format [m] = ["(assert " ++ m ++ ")"] format (m:ms) = ["(assert (or " ++ m] ++ map (" " ++) ms ++ [" ))"] -- Regular (or interpreted) sorts simply get a constraint that we disallow the current assignment interp = map $ nonEq rm -- Determine the equivalence classes of uninterpreted sorts: uninterpClasses = filter (\l -> length l > 1) -- Only need this class if it has at least two members . map (map fst) -- throw away sorts, we only need the names . groupBy ((==) `on` snd) -- make sure they belong to the same sort and have the same value . sortBy (comparing snd) -- sort them according to their sorts first $ ups -- take the uninterpreted sorts -- Uninterpreted sorts get a constraint that says the equivalence classes as determined by the solver are disallowed: eqClass :: [String] -> String eqClass [] = error "SBV.allSat.nonEqs: Impossible happened, disallow received an empty list" eqClass cs = "(= " ++ unwords cs ++ ")" -- Now, take the conjunction of equivalence classes and assert it's negation: disallow = map $ \ec -> "(not " ++ ec ++ ")" nonEq :: RoundingMode -> (String, CW) -> String nonEq rm (s, c) = "(not (= " ++ s ++ " " ++ cvtCW rm c ++ "))" tbd :: String -> a tbd e = error $ "SBV.SMTLib2: Not-yet-supported: " ++ e -- | Translate a problem into an SMTLib2 script cvt :: RoundingMode -- ^ User selected rounding mode to be used for floating point arithmetic -> Maybe Logic -- ^ SMT-Lib logic, if requested by the user -> SolverCapabilities -- ^ capabilities of the current solver -> Set.Set Kind -- ^ kinds used -> Bool -- ^ is this a sat problem? -> [String] -- ^ extra comments to place on top -> [(Quantifier, NamedSymVar)] -- ^ inputs -> [Either SW (SW, [SW])] -- ^ skolemized version inputs -> [(SW, CW)] -- ^ constants -> [((Int, Kind, Kind), [SW])] -- ^ auto-generated tables -> [(Int, ArrayInfo)] -- ^ user specified arrays -> [(String, SBVType)] -- ^ uninterpreted functions/constants -> [(String, [String])] -- ^ user given axioms -> SBVPgm -- ^ assignments -> [SW] -- ^ extra constraints -> SW -- ^ output variable -> ([String], [String]) cvt rm smtLogic solverCaps kindInfo isSat comments inputs skolemInps consts tbls arrs uis axs (SBVPgm asgnsSeq) cstrs out = (pre, []) where -- the logic is an over-approaximation hasInteger = KUnbounded `Set.member` kindInfo hasReal = KReal `Set.member` kindInfo hasFloat = KFloat `Set.member` kindInfo hasDouble = KDouble `Set.member` kindInfo hasBVs = not $ null [() | KBounded{} <- Set.toList kindInfo] usorts = [(s, dt) | KUserSort s dt <- Set.toList kindInfo] hasNonBVArrays = (not . null) [() | (_, (_, (k1, k2), _)) <- arrs, not (isBounded k1 && isBounded k2)] logic | Just l <- smtLogic = ["(set-logic " ++ show l ++ ") ; NB. User specified."] | hasDouble || hasFloat -- NB. We don't check for quantifiers here, we probably should.. = if hasBVs then ["(set-logic QF_FPBV)"] else ["(set-logic QF_FP)"] | hasInteger || hasReal || not (null usorts) || hasNonBVArrays = let why | hasInteger = "has unbounded values" | hasReal = "has algebraic reals" | not (null usorts) = "has user-defined sorts" | hasNonBVArrays = "has non-bitvector arrays" | True = "cannot determine the SMTLib-logic to use" in case mbDefaultLogic solverCaps hasReal of Nothing -> ["; " ++ why ++ ", no logic specified."] Just l -> ["(set-logic " ++ l ++ "); " ++ why ++ ", using solver-default logic."] | True = ["(set-logic " ++ qs ++ as ++ ufs ++ "BV)"] where qs | null foralls && null axs = "QF_" -- axioms are likely to contain quantifiers | True = "" as | null arrs = "" | True = "A" ufs | null uis && null tbls = "" -- we represent tables as UFs | True = "UF" getModels | supportsProduceModels solverCaps = ["(set-option :produce-models true)"] | True = [] pre = ["; Automatically generated by SBV. Do not edit."] ++ map ("; " ++) comments ++ getModels ++ logic ++ [ "; --- uninterpreted sorts ---" ] ++ concatMap declSort usorts ++ [ "; --- literal constants ---" ] ++ concatMap (declConst (supportsMacros solverCaps)) consts ++ [ "; --- skolem constants ---" ] ++ [ "(declare-fun " ++ show s ++ " " ++ swFunType ss s ++ ")" ++ userName s | Right (s, ss) <- skolemInps] ++ [ "; --- constant tables ---" ] ++ concatMap constTable constTables ++ [ "; --- skolemized tables ---" ] ++ map (skolemTable (unwords (map swType foralls))) skolemTables ++ [ "; --- arrays ---" ] ++ concat arrayConstants ++ [ "; --- uninterpreted constants ---" ] ++ concatMap declUI uis ++ [ "; --- user given axioms ---" ] ++ map declAx axs ++ [ "; --- formula ---" ] ++ [if null foralls then "(assert ; no quantifiers" else "(assert (forall (" ++ intercalate "\n " ["(" ++ show s ++ " " ++ swType s ++ ")" | s <- foralls] ++ ")"] ++ map (letAlign . mkLet) asgns ++ map letAlign (if null delayedEqualities then [] else ("(and " ++ deH) : map (align 5) deTs) ++ [ impAlign (letAlign assertOut) ++ replicate noOfCloseParens ')' ] noOfCloseParens = length asgns + (if null foralls then 1 else 2) + (if null delayedEqualities then 0 else 1) (constTables, skolemTables) = ([(t, d) | (t, Left d) <- allTables], [(t, d) | (t, Right d) <- allTables]) allTables = [(t, genTableData rm skolemMap (not (null foralls), forallArgs) (map fst consts) t) | t <- tbls] (arrayConstants, allArrayDelayeds) = unzip $ map (declArray (not (null foralls)) (map fst consts) skolemMap) arrs delayedEqualities@(~(deH:deTs)) = concatMap snd skolemTables ++ concat allArrayDelayeds foralls = [s | Left s <- skolemInps] forallArgs = concatMap ((" " ++) . show) foralls letAlign s | null foralls = " " ++ s | True = " " ++ s impAlign s | null delayedEqualities = s | True = " " ++ s align n s = replicate n ' ' ++ s -- if sat, we assert cstrs /\ out -- if prove, we assert ~(cstrs => out) = cstrs /\ not out assertOut | null cstrs = o | True = "(and " ++ unwords (map mkConj cstrs ++ [o]) ++ ")" where mkConj = cvtSW skolemMap o | isSat = mkConj out | True = "(not " ++ mkConj out ++ ")" skolemMap = M.fromList [(s, ss) | Right (s, ss) <- skolemInps, not (null ss)] tableMap = IM.fromList $ map mkConstTable constTables ++ map mkSkTable skolemTables where mkConstTable (((t, _, _), _), _) = (t, "table" ++ show t) mkSkTable (((t, _, _), _), _) = (t, "table" ++ show t ++ forallArgs) asgns = F.toList asgnsSeq mkLet (s, SBVApp (Label m) [e]) = "(let ((" ++ show s ++ " " ++ cvtSW skolemMap e ++ ")) ; " ++ m mkLet (s, e) = "(let ((" ++ show s ++ " " ++ cvtExp rm skolemMap tableMap e ++ "))" declConst useDefFun (s, c) | useDefFun = ["(define-fun " ++ varT ++ " " ++ cvtCW rm c ++ ")"] | True = [ "(declare-fun " ++ varT ++ ")" , "(assert (= " ++ show s ++ " " ++ cvtCW rm c ++ "))" ] where varT = show s ++ " " ++ swFunType [] s userName s = case s `lookup` map snd inputs of Just u | show s /= u -> " ; tracks user variable " ++ show u _ -> "" -- following sorts are built-in; do not translate them: builtInSort = (`elem` ["RoundingMode"]) declSort (s, _) | builtInSort s = [] declSort (s, Left r ) = ["(declare-sort " ++ s ++ " 0) ; N.B. Uninterpreted: " ++ r] declSort (s, Right fs) = [ "(declare-datatypes () ((" ++ s ++ " " ++ unwords (map (\c -> "(" ++ c ++ ")") fs) ++ ")))" , "(define-fun " ++ s ++ "_constrIndex ((x " ++ s ++ ")) Int" ] ++ [" " ++ body fs (0::Int)] ++ [")"] where body [] _ = "" body [_] i = show i body (c:cs) i = "(ite (= x " ++ c ++ ") " ++ show i ++ " " ++ body cs (i+1) ++ ")" declUI :: (String, SBVType) -> [String] declUI (i, t) = ["(declare-fun " ++ i ++ " " ++ cvtType t ++ ")"] -- NB. We perform no check to as to whether the axiom is meaningful in any way. declAx :: (String, [String]) -> String declAx (nm, ls) = (";; -- user given axiom: " ++ nm ++ "\n") ++ intercalate "\n" ls constTable :: (((Int, Kind, Kind), [SW]), [String]) -> [String] constTable (((i, ak, rk), _elts), is) = decl : map wrap is where t = "table" ++ show i decl = "(declare-fun " ++ t ++ " (" ++ smtType ak ++ ") " ++ smtType rk ++ ")" wrap s = "(assert " ++ s ++ ")" skolemTable :: String -> (((Int, Kind, Kind), [SW]), [String]) -> String skolemTable qsIn (((i, ak, rk), _elts), _) = decl where qs = if null qsIn then "" else qsIn ++ " " t = "table" ++ show i decl = "(declare-fun " ++ t ++ " (" ++ qs ++ smtType ak ++ ") " ++ smtType rk ++ ")" -- Left if all constants, Right if otherwise genTableData :: RoundingMode -> SkolemMap -> (Bool, String) -> [SW] -> ((Int, Kind, Kind), [SW]) -> Either [String] [String] genTableData rm skolemMap (_quantified, args) consts ((i, aknd, _), elts) | null post = Left (map (topLevel . snd) pre) | True = Right (map (nested . snd) (pre ++ post)) where ssw = cvtSW skolemMap (pre, post) = partition fst (zipWith mkElt elts [(0::Int)..]) t = "table" ++ show i mkElt x k = (isReady, (idx, ssw x)) where idx = cvtCW rm (mkConstCW aknd k) isReady = x `elem` consts topLevel (idx, v) = "(= (" ++ t ++ " " ++ idx ++ ") " ++ v ++ ")" nested (idx, v) = "(= (" ++ t ++ args ++ " " ++ idx ++ ") " ++ v ++ ")" -- TODO: We currently do not support non-constant arrays when quantifiers are present, as -- we might have to skolemize those. Implement this properly. -- The difficulty is with the ArrayReset/Mutate/Merge: We have to postpone an init if -- the components are themselves postponed, so this cannot be implemented as a simple map. declArray :: Bool -> [SW] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String]) declArray quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : map wrap pre, map snd post) where topLevel = not quantified || case ctx of ArrayFree Nothing -> True ArrayFree (Just sw) -> sw `elem` consts ArrayReset _ sw -> sw `elem` consts ArrayMutate _ a b -> all (`elem` consts) [a, b] ArrayMerge c _ _ -> c `elem` consts (pre, post) = partition fst ctxInfo nm = "array_" ++ show i ssw sw | topLevel || sw `elem` consts = cvtSW skolemMap sw | True = tbd "Non-constant array initializer in a quantified context" adecl = "(declare-fun " ++ nm ++ " () (Array " ++ smtType aKnd ++ " " ++ smtType bKnd ++ "))" ctxInfo = case ctx of ArrayFree Nothing -> [] ArrayFree (Just sw) -> declA sw ArrayReset _ sw -> declA sw ArrayMutate j a b -> [(all (`elem` consts) [a, b], "(= " ++ nm ++ " (store array_" ++ show j ++ " " ++ ssw a ++ " " ++ ssw b ++ "))")] ArrayMerge t j k -> [(t `elem` consts, "(= " ++ nm ++ " (ite " ++ ssw t ++ " array_" ++ show j ++ " array_" ++ show k ++ "))")] declA sw = let iv = nm ++ "_freeInitializer" in [ (True, "(declare-fun " ++ iv ++ " () " ++ smtType aKnd ++ ")") , (sw `elem` consts, "(= (select " ++ nm ++ " " ++ iv ++ ") " ++ ssw sw ++ ")") ] wrap (False, s) = s wrap (True, s) = "(assert " ++ s ++ ")" swType :: SW -> String swType s = smtType (kindOf s) swFunType :: [SW] -> SW -> String swFunType ss s = "(" ++ unwords (map swType ss) ++ ") " ++ swType s smtType :: Kind -> String smtType KBool = "Bool" smtType (KBounded _ sz) = "(_ BitVec " ++ show sz ++ ")" smtType KUnbounded = "Int" smtType KReal = "Real" smtType KFloat = "(_ FloatingPoint 8 24)" smtType KDouble = "(_ FloatingPoint 11 53)" smtType (KUserSort s _) = s cvtType :: SBVType -> String cvtType (SBVType []) = error "SBV.SMT.SMTLib2.cvtType: internal: received an empty type!" cvtType (SBVType xs) = "(" ++ unwords (map smtType body) ++ ") " ++ smtType ret where (body, ret) = (init xs, last xs) type SkolemMap = M.Map SW [SW] type TableMap = IM.IntMap String cvtSW :: SkolemMap -> SW -> String cvtSW skolemMap s | Just ss <- s `M.lookup` skolemMap = "(" ++ show s ++ concatMap ((" " ++) . show) ss ++ ")" | True = show s cvtCW :: RoundingMode -> CW -> String cvtCW = cwToSMTLib getTable :: TableMap -> Int -> String getTable m i | Just tn <- i `IM.lookup` m = tn | True = error $ "SBV.SMTLib2: Cannot locate table " ++ show i cvtExp :: RoundingMode -> SkolemMap -> TableMap -> SBVExpr -> String cvtExp rm skolemMap tableMap expr@(SBVApp _ arguments) = sh expr where ssw = cvtSW skolemMap bvOp = all isBounded arguments intOp = any isInteger arguments realOp = any isReal arguments doubleOp = any isDouble arguments floatOp = any isFloat arguments boolOp = all isBoolean arguments bad | intOp = error $ "SBV.SMTLib2: Unsupported operation on unbounded integers: " ++ show expr | True = error $ "SBV.SMTLib2: Unsupported operation on real values: " ++ show expr ensureBVOrBool = bvOp || boolOp || bad ensureBV = bvOp || bad addRM s = s ++ " " ++ smtRoundingMode rm lift2 o _ [x, y] = "(" ++ o ++ " " ++ x ++ " " ++ y ++ ")" lift2 o _ sbvs = error $ "SBV.SMTLib2.sh.lift2: Unexpected arguments: " ++ show (o, sbvs) -- lift a binary operation with rounding-mode added; used for floating-point arithmetic lift2WM o fo | doubleOp || floatOp = lift2 (addRM fo) | True = lift2 o lift1FP o fo | doubleOp || floatOp = lift1 fo | True = lift1 o liftAbs sgned args | doubleOp || floatOp = lift1 "fp.abs" sgned args | intOp = lift1 "abs" sgned args | bvOp, sgned = mkAbs (head args) "bvslt" "bvneg" | bvOp = head args | True = mkAbs (head args) "<" "-" where mkAbs x cmp neg = "(ite " ++ ltz ++ " " ++ nx ++ " " ++ x ++ ")" where ltz = "(" ++ cmp ++ " " ++ x ++ " " ++ z ++ ")" nx = "(" ++ neg ++ " " ++ x ++ ")" z = cvtCW rm (mkConstCW (kindOf (head arguments)) (0::Integer)) lift2B bOp vOp | boolOp = lift2 bOp | True = lift2 vOp lift1B bOp vOp | boolOp = lift1 bOp | True = lift1 vOp eqBV = lift2 "=" neqBV = lift2 "distinct" equal sgn sbvs | doubleOp = lift2 "fp.eq" sgn sbvs | floatOp = lift2 "fp.eq" sgn sbvs | True = lift2 "=" sgn sbvs notEqual sgn sbvs | doubleOp = "(not " ++ equal sgn sbvs ++ ")" | floatOp = "(not " ++ equal sgn sbvs ++ ")" | True = lift2 "distinct" sgn sbvs lift2S oU oS sgn = lift2 (if sgn then oS else oU) sgn lift2Cmp o fo | doubleOp || floatOp = lift2 fo | True = lift2 o unintComp o [a, b] | KUserSort s (Right _) <- kindOf (head arguments) = let idx v = "(" ++ s ++ "_constrIndex " ++ " " ++ v ++ ")" in "(" ++ o ++ " " ++ idx a ++ " " ++ idx b ++ ")" unintComp o sbvs = error $ "SBV.SMT.SMTLib2.sh.unintComp: Unexpected arguments: " ++ show (o, sbvs) lift1 o _ [x] = "(" ++ o ++ " " ++ x ++ ")" lift1 o _ sbvs = error $ "SBV.SMT.SMTLib2.sh.lift1: Unexpected arguments: " ++ show (o, sbvs) sh (SBVApp Ite [a, b, c]) = "(ite " ++ ssw a ++ " " ++ ssw b ++ " " ++ ssw c ++ ")" sh (SBVApp (LkUp (t, aKnd, _, l) i e) []) | needsCheck = "(ite " ++ cond ++ ssw e ++ " " ++ lkUp ++ ")" | True = lkUp where needsCheck = case aKnd of KBool -> (2::Integer) > fromIntegral l KBounded _ n -> (2::Integer)^n > fromIntegral l KUnbounded -> True KReal -> error "SBV.SMT.SMTLib2.cvtExp: unexpected real valued index" KFloat -> error "SBV.SMT.SMTLib2.cvtExp: unexpected float valued index" KDouble -> error "SBV.SMT.SMTLib2.cvtExp: unexpected double valued index" KUserSort s _ -> error $ "SBV.SMT.SMTLib2.cvtExp: unexpected uninterpreted valued index: " ++ s lkUp = "(" ++ getTable tableMap t ++ " " ++ ssw i ++ ")" cond | hasSign i = "(or " ++ le0 ++ " " ++ gtl ++ ") " | True = gtl ++ " " (less, leq) = case aKnd of KBool -> error "SBV.SMT.SMTLib2.cvtExp: unexpected boolean valued index" KBounded{} -> if hasSign i then ("bvslt", "bvsle") else ("bvult", "bvule") KUnbounded -> ("<", "<=") KReal -> ("<", "<=") KFloat -> ("fp.lt", "fp.leq") KDouble -> ("fp.lt", "fp.geq") KUserSort s _ -> error $ "SBV.SMT.SMTLib2.cvtExp: unexpected uninterpreted valued index: " ++ s mkCnst = cvtCW rm . mkConstCW (kindOf i) le0 = "(" ++ less ++ " " ++ ssw i ++ " " ++ mkCnst 0 ++ ")" gtl = "(" ++ leq ++ " " ++ mkCnst l ++ " " ++ ssw i ++ ")" sh (SBVApp (IntCast f t) [a]) = handleIntCast f t (ssw a) sh (SBVApp (ArrEq i j) []) = "(= array_" ++ show i ++ " array_" ++ show j ++")" sh (SBVApp (ArrRead i) [a]) = "(select array_" ++ show i ++ " " ++ ssw a ++ ")" sh (SBVApp (Uninterpreted nm) []) = nm sh (SBVApp (Uninterpreted nm) args) = "(" ++ nm ++ " " ++ unwords (map ssw args) ++ ")" sh (SBVApp (Extract i j) [a]) | ensureBV = "((_ extract " ++ show i ++ " " ++ show j ++ ") " ++ ssw a ++ ")" sh (SBVApp (Rol i) [a]) | bvOp = rot ssw "rotate_left" i a | intOp = sh (SBVApp (Shl i) [a]) -- Haskell treats rotateL as shiftL for unbounded values | True = bad sh (SBVApp (Ror i) [a]) | bvOp = rot ssw "rotate_right" i a | intOp = sh (SBVApp (Shr i) [a]) -- Haskell treats rotateR as shiftR for unbounded values | True = bad sh (SBVApp (Shl i) [a]) | bvOp = shft rm ssw "bvshl" "bvshl" i a | i < 0 = sh (SBVApp (Shr (-i)) [a]) -- flip sign/direction | intOp = "(* " ++ ssw a ++ " " ++ show (bit i :: Integer) ++ ")" -- Implement shiftL by multiplication by 2^i | True = bad sh (SBVApp (Shr i) [a]) | bvOp = shft rm ssw "bvlshr" "bvashr" i a | i < 0 = sh (SBVApp (Shl (-i)) [a]) -- flip sign/direction | intOp = "(div " ++ ssw a ++ " " ++ show (bit i :: Integer) ++ ")" -- Implement shiftR by division by 2^i | True = bad sh (SBVApp op args) | Just f <- lookup op smtBVOpTable, ensureBVOrBool = f (any hasSign args) (map ssw args) where -- The first 4 operators below do make sense for Integer's in Haskell, but there's -- no obvious counterpart for them in the SMTLib translation. -- TODO: provide support for these. smtBVOpTable = [ (And, lift2B "and" "bvand") , (Or, lift2B "or" "bvor") , (XOr, lift2B "xor" "bvxor") , (Not, lift1B "not" "bvnot") , (Join, lift2 "concat") ] sh (SBVApp (Label _) [a]) = cvtSW skolemMap a -- This won't be reached; but just in case! sh (SBVApp (IEEEFP (FP_Cast kFrom kTo m)) args) = handleFPCast kFrom kTo (ssw m) (unwords (map ssw args)) sh (SBVApp (IEEEFP w ) args) = "(" ++ show w ++ " " ++ unwords (map ssw args) ++ ")" sh inp@(SBVApp op args) | intOp, Just f <- lookup op smtOpIntTable = f True (map ssw args) | boolOp, Just f <- lookup op boolComps = f (map ssw args) | bvOp, Just f <- lookup op smtOpBVTable = f (any hasSign args) (map ssw args) | realOp, Just f <- lookup op smtOpRealTable = f (any hasSign args) (map ssw args) | floatOp || doubleOp, Just f <- lookup op smtOpFloatDoubleTable = f (any hasSign args) (map ssw args) | Just f <- lookup op uninterpretedTable = f (map ssw args) | True = error $ "SBV.SMT.SMTLib2.cvtExp.sh: impossible happened; can't translate: " ++ show inp where smtOpBVTable = [ (Plus, lift2 "bvadd") , (Minus, lift2 "bvsub") , (Times, lift2 "bvmul") , (UNeg, lift1B "not" "bvneg") , (Abs, liftAbs) , (Quot, lift2S "bvudiv" "bvsdiv") , (Rem, lift2S "bvurem" "bvsrem") , (Equal, eqBV) , (NotEqual, neqBV) , (LessThan, lift2S "bvult" "bvslt") , (GreaterThan, lift2S "bvugt" "bvsgt") , (LessEq, lift2S "bvule" "bvsle") , (GreaterEq, lift2S "bvuge" "bvsge") ] -- Boolean comparisons.. SMTLib's bool type doesn't do comparisons, but Haskell does.. Sigh boolComps = [ (LessThan, blt) , (GreaterThan, blt . swp) , (LessEq, blq) , (GreaterEq, blq . swp) ] where blt [x, y] = "(and (not " ++ x ++ ") " ++ y ++ ")" blt xs = error $ "SBV.SMT.SMTLib2.boolComps.blt: Impossible happened, incorrect arity (expected 2): " ++ show xs blq [x, y] = "(or (not " ++ x ++ ") " ++ y ++ ")" blq xs = error $ "SBV.SMT.SMTLib2.boolComps.blq: Impossible happened, incorrect arity (expected 2): " ++ show xs swp [x, y] = [y, x] swp xs = error $ "SBV.SMT.SMTLib2.boolComps.swp: Impossible happened, incorrect arity (expected 2): " ++ show xs smtOpRealTable = smtIntRealShared ++ [ (Quot, lift2WM "/" "fp.div") ] smtOpIntTable = smtIntRealShared ++ [ (Quot, lift2 "div") , (Rem, lift2 "mod") ] smtOpFloatDoubleTable = smtIntRealShared ++ [(Quot, lift2WM "/" "fp.div")] smtIntRealShared = [ (Plus, lift2WM "+" "fp.add") , (Minus, lift2WM "-" "fp.sub") , (Times, lift2WM "*" "fp.mul") , (UNeg, lift1FP "-" "fp.neg") , (Abs, liftAbs) , (Equal, equal) , (NotEqual, notEqual) , (LessThan, lift2Cmp "<" "fp.lt") , (GreaterThan, lift2Cmp ">" "fp.gt") , (LessEq, lift2Cmp "<=" "fp.leq") , (GreaterEq, lift2Cmp ">=" "fp.geq") ] -- equality and comparisons are the only thing that works on uninterpreted sorts uninterpretedTable = [ (Equal, lift2S "=" "=" True) , (NotEqual, lift2S "distinct" "distinct" True) , (LessThan, unintComp "<") , (GreaterThan, unintComp ">") , (LessEq, unintComp "<=") , (GreaterEq, unintComp ">=") ] ----------------------------------------------------------------------------------------------- -- Casts supported by SMTLib. (From: ) -- ; from another floating point sort -- ((_ to_fp eb sb) RoundingMode (_ FloatingPoint mb nb) (_ FloatingPoint eb sb)) -- -- ; from real -- ((_ to_fp eb sb) RoundingMode Real (_ FloatingPoint eb sb)) -- -- ; from signed machine integer, represented as a 2's complement bit vector -- ((_ to_fp eb sb) RoundingMode (_ BitVec m) (_ FloatingPoint eb sb)) -- -- ; from unsigned machine integer, represented as bit vector -- ((_ to_fp_unsigned eb sb) RoundingMode (_ BitVec m) (_ FloatingPoint eb sb)) -- -- ; to unsigned machine integer, represented as a bit vector -- ((_ fp.to_ubv m) RoundingMode (_ FloatingPoint eb sb) (_ BitVec m)) -- -- ; to signed machine integer, represented as a 2's complement bit vector -- ((_ fp.to_sbv m) RoundingMode (_ FloatingPoint eb sb) (_ BitVec m)) -- -- ; to real -- (fp.to_real (_ FloatingPoint eb sb) Real) ----------------------------------------------------------------------------------------------- handleFPCast :: Kind -> Kind -> String -> String -> String handleFPCast kFrom kTo rm input | kFrom == kTo = input | True = "(" ++ cast kFrom kTo input ++ ")" where addRM a s = s ++ " " ++ rm ++ " " ++ a absRM a s = "ite (fp.isNegative " ++ a ++ ") (" ++ cvt1 ++ ") (" ++ cvt2 ++ ")" where cvt1 = "bvneg (" ++ s ++ " " ++ rm ++ " (fp.abs " ++ a ++ "))" cvt2 = s ++ " " ++ rm ++ " " ++ a -- To go and back from Ints, we detour through reals cast KUnbounded KFloat a = "(_ to_fp 8 24) " ++ rm ++ " (to_real " ++ a ++ ")" cast KUnbounded KDouble a = "(_ to_fp 11 53) " ++ rm ++ " (to_real " ++ a ++ ")" cast KFloat KUnbounded a = "to_int (fp.to_real " ++ a ++ ")" cast KDouble KUnbounded a = "to_int (fp.to_real " ++ a ++ ")" -- To float/double cast (KBounded False _) KFloat a = addRM a "(_ to_fp_unsigned 8 24)" cast (KBounded False _) KDouble a = addRM a "(_ to_fp_unsigned 11 53)" cast (KBounded True _) KFloat a = addRM a "(_ to_fp 8 24)" cast (KBounded True _) KDouble a = addRM a "(_ to_fp 11 53)" cast KReal KFloat a = addRM a "(_ to_fp 8 24)" cast KReal KDouble a = addRM a "(_ to_fp 11 53)" -- Between floats cast KFloat KFloat a = addRM a "(_ to_fp 8 24)" cast KFloat KDouble a = addRM a "(_ to_fp 11 53)" cast KDouble KFloat a = addRM a "(_ to_fp 8 24)" cast KDouble KDouble a = addRM a "(_ to_fp 11 53)" -- From float/double cast KFloat (KBounded False m) a = absRM a $ "(_ fp.to_ubv " ++ show m ++ ")" cast KDouble (KBounded False m) a = absRM a $ "(_ fp.to_ubv " ++ show m ++ ")" cast KFloat (KBounded True m) a = addRM a $ "(_ fp.to_sbv " ++ show m ++ ")" cast KDouble (KBounded True m) a = addRM a $ "(_ fp.to_sbv " ++ show m ++ ")" cast KFloat KReal a = "fp.to_real" ++ " " ++ a cast KDouble KReal a = "fp.to_real" ++ " " ++ a -- Nothing else should come up: cast f d _ = error $ "SBV.SMTLib2: Unexpected FPCast from: " ++ show f ++ " to " ++ show d rot :: (SW -> String) -> String -> Int -> SW -> String rot ssw o c x = "((_ " ++ o ++ " " ++ show c ++ ") " ++ ssw x ++ ")" shft :: RoundingMode -> (SW -> String) -> String -> String -> Int -> SW -> String shft rm ssw oW oS c x = "(" ++ o ++ " " ++ ssw x ++ " " ++ cvtCW rm c' ++ ")" where s = hasSign x c' = mkConstCW (kindOf x) c o = if s then oS else oW -- Various integer casts handleIntCast :: Kind -> Kind -> String -> String handleIntCast kFrom kTo a | kFrom == kTo = a | True = case kFrom of KBounded s m -> case kTo of KBounded _ n -> fromBV (if s then signExtend else zeroExtend) m n KUnbounded -> b2i s m _ -> noCast KUnbounded -> case kTo of KReal -> "(to_real " ++ a ++ ")" KBounded _ n -> i2b n _ -> noCast _ -> noCast where noCast = error $ "SBV.SMTLib2: Unexpected integer cast from: " ++ show kFrom ++ " to " ++ show kTo fromBV upConv m n | n > m = upConv (n - m) | m == n = a | True = extract (n - 1) i2b n = "(let (" ++ reduced ++ ") (let (" ++ defs ++ ") " ++ body ++ "))" where b i = show (bit i :: Integer) reduced = "(__a (mod " ++ a ++ " " ++ b n ++ "))" mkBit 0 = "(__a0 (ite (= (mod __a 2) 0) #b0 #b1))" mkBit i = "(__a" ++ show i ++ " (ite (= (mod (div __a " ++ b i ++ ") 2) 0) #b0 #b1))" defs = unwords (map mkBit [0 .. n - 1]) body = foldr1 (\c r -> "(concat " ++ c ++ " " ++ r ++ ")") ["__a" ++ show i | i <- [n-1, n-2 .. 0]] b2i s m | s = "(- " ++ val ++ " " ++ valIf (2^m) sign ++ ")" | True = val where valIf v b = "(ite (= " ++ b ++ " #b1) " ++ show (v::Integer) ++ " 0)" getBit i = "((_ extract " ++ show i ++ " " ++ show i ++ ") " ++ a ++ ")" bitVal i = valIf (2^i) (getBit i) val = "(+ " ++ unwords (map bitVal [0 .. m-1]) ++ ")" sign = getBit (m-1) signExtend i = "((_ sign_extend " ++ show i ++ ") " ++ a ++ ")" zeroExtend i = "((_ zero_extend " ++ show i ++ ") " ++ a ++ ")" extract i = "((_ extract " ++ show i ++ " 0) " ++ a ++ ")" sbv-5.12/Data/SBV/SMT/SMTLibNames.hs0000644000000000000000000000251112725411266015006 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.SMT.SMTLibNames -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- SMTLib Reserved names ----------------------------------------------------------------------------- module Data.SBV.SMT.SMTLibNames where import Data.Char (toLower) -- | Names reserved by SMTLib. This list is current as of Dec 6 2015; but of course -- there's no guarantee it'll stay that way. smtLibReservedNames :: [String] smtLibReservedNames = map (map toLower) [ "Int", "Real", "List", "Array", "Bool", "FP", "FloatingPoint", "fp", "String" , "!", "_", "as", "BINARY", "DECIMAL", "exists", "HEXADECIMAL", "forall", "let", "NUMERAL", "par", "STRING", "CHAR" , "assert", "check-sat", "check-sat-assuming", "declare-const", "declare-fun", "declare-sort", "define-fun", "define-fun-rec" , "define-sort", "echo", "exit", "get-assertions", "get-assignment", "get-info", "get-model", "get-option", "get-proof", "get-unsat-assumptions" , "get-unsat-core", "get-value", "pop", "push", "reset", "reset-assertions", "set-info", "set-logic", "set-option" ] sbv-5.12/Data/SBV/Tools/0000755000000000000000000000000012725411266013032 5ustar0000000000000000sbv-5.12/Data/SBV/Tools/ExpectedValue.hs0000644000000000000000000001130212725411266016121 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Tools.ExpectedValue -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computing the expected value of a symbolic variable ----------------------------------------------------------------------------- {-# LANGUAGE PatternGuards #-} module Data.SBV.Tools.ExpectedValue (expectedValue, expectedValueWith) where import Control.DeepSeq (rnf) import System.Random (newStdGen, StdGen) import Numeric import Data.SBV.BitVectors.Data -- | Generalized version of 'expectedValue', allowing the user to specify the -- warm-up count and the convergence factor. Maximum iteration count can also -- be specified, at which point convergence won't be sought. The boolean controls verbosity. expectedValueWith :: Outputtable a => Bool -> Int -> Maybe Int -> Double -> Symbolic a -> IO [Double] expectedValueWith chatty warmupCount mbMaxIter epsilon m | warmupCount < 0 || epsilon < 0 = error $ "SBV.expectedValue: warmup count and epsilon both must be non-negative, received: " ++ show (warmupCount, epsilon) | True = warmup warmupCount (repeat 0) >>= go warmupCount where progress s | not chatty = return () | True = putStr $ "\r*** " ++ s warmup :: Int -> [Integer] -> IO [Integer] warmup 0 v = do progress $ "Warmup complete, performed " ++ show warmupCount ++ " rounds.\n" return v warmup n v = do progress $ "Performing warmup, round: " ++ show (warmupCount - n) g <- newStdGen t <- runOnce g let v' = zipWith (+) v t rnf v' `seq` warmup (n-1) v' runOnce :: StdGen -> IO [Integer] runOnce g = do (_, Result _ _ _ _ cs _ _ _ _ _ cstrs _ os) <- runSymbolic' (Concrete g) (m >>= output) let cval o = case o `lookup` cs of Nothing -> error "SBV.expectedValue: Cannot compute expected-values in the presence of uninterpreted constants!" Just cw -> case (kindOf cw, cwVal cw) of (KBool, _) -> if cwToBool cw then 1 else 0 (KBounded{}, CWInteger v) -> v (KUnbounded, CWInteger v) -> v (KReal, _) -> error "Cannot compute expected-values for real valued results." _ -> error $ "SBV.expectedValueWith: Unexpected CW: " ++ show cw if all ((== 1) . cval) cstrs then return $ map cval os else runOnce g -- constraint not satisfied try again with the same set of constraints go :: Int -> [Integer] -> IO [Double] go cases curSums | Just n <- mbMaxIter, n < curRound = do progress "\n" progress "Maximum iteration count reached, stopping.\n" return curEVs | True = do g <- newStdGen t <- runOnce g let newSums = zipWith (+) curSums t newEVs = map ev' newSums diffs = zipWith (\x y -> abs (x - y)) newEVs curEVs if all (< epsilon) diffs then do progress $ "Converges with epsilon " ++ show epsilon ++ " after " ++ show curRound ++ " rounds.\n" return newEVs else do progress $ "Tuning, round: " ++ show curRound ++ " (margin: " ++ showFFloat (Just 6) (maximum (0:diffs)) "" ++ ")" go newCases newSums where curRound = cases - warmupCount newCases = cases + 1 ev, ev' :: Integer -> Double ev x = fromIntegral x / fromIntegral cases ev' x = fromIntegral x / fromIntegral newCases curEVs = map ev curSums -- | Given a symbolic computation that produces a value, compute the -- expected value that value would take if this computation is run -- with its free variables drawn from uniform distributions of its -- respective values, satisfying the given constraints specified by -- 'constrain' and 'pConstrain' calls. This is equivalent to calling -- 'expectedValueWith' the following parameters: verbose, warm-up -- round count of @10000@, no maximum iteration count, and with -- convergence margin @0.0001@. expectedValue :: Outputtable a => Symbolic a -> IO [Double] expectedValue = expectedValueWith True 10000 Nothing 0.0001 sbv-5.12/Data/SBV/Tools/GenTest.hs0000644000000000000000000004032712725411266014745 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Tools.GenTest -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test generation from symbolic programs ----------------------------------------------------------------------------- module Data.SBV.Tools.GenTest (genTest, TestVectors, getTestValues, renderTest, TestStyle(..)) where import Data.Bits (testBit) import Data.Char (isAlpha, toUpper) import Data.Function (on) import Data.List (intercalate, groupBy) import Data.Maybe (fromMaybe) import System.Random import Data.SBV.BitVectors.AlgReals import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.PrettyNum -- | Type of test vectors (abstract) newtype TestVectors = TV [([CW], [CW])] -- | Retrieve the test vectors for further processing. This function -- is useful in cases where 'renderTest' is not sufficient and custom -- output (or further preprocessing) is needed. getTestValues :: TestVectors -> [([CW], [CW])] getTestValues (TV vs) = vs -- | Generate a set of concrete test values from a symbolic program. The output -- can be rendered as test vectors in different languages as necessary. Use the -- function 'output' call to indicate what fields should be in the test result. -- (Also see 'constrain' and 'pConstrain' for filtering acceptable test values.) genTest :: Outputtable a => Int -> Symbolic a -> IO TestVectors genTest n m = gen 0 [] where gen i sofar | i == n = return $ TV $ reverse sofar | True = do g <- newStdGen t <- tc g gen (i+1) (t:sofar) tc g = do (_, Result _ tvals _ _ cs _ _ _ _ _ cstrs _ os) <- runSymbolic' (Concrete g) (m >>= output) let cval = fromMaybe (error "Cannot generate tests in the presence of uninterpeted constants!") . (`lookup` cs) cond = all (cwToBool . cval) cstrs if cond then return (map snd tvals, map cval os) else tc g -- try again, with the same set of constraints -- | Test output style data TestStyle = Haskell String -- ^ As a Haskell value with given name | C String -- ^ As a C array of structs with given name | Forte String Bool ([Int], [Int]) -- ^ As a Forte/Verilog value with given name. -- If the boolean is True then vectors are blasted big-endian, otherwise little-endian -- The indices are the split points on bit-vectors for input and output values -- | Render the test as a Haskell value with the given name @n@. renderTest :: TestStyle -> TestVectors -> String renderTest (Haskell n) (TV vs) = haskell n vs renderTest (C n) (TV vs) = c n vs renderTest (Forte n b ss) (TV vs) = forte n b ss vs haskell :: String -> [([CW], [CW])] -> String haskell vname vs = intercalate "\n" $ [ "-- Automatically generated by SBV. Do not edit!" , "" , "module " ++ modName ++ "(" ++ n ++ ") where" , "" ] ++ imports ++ [ n ++ " :: " ++ getType vs , n ++ " = [ " ++ intercalate ("\n" ++ pad ++ ", ") (map mkLine vs), pad ++ "]" ] where n | null vname = "testVectors" | not (isAlpha (head vname)) = "tv" ++ vname | True = vname imports | null vs = [] | needsInt && needsWord = ["import Data.Int", "import Data.Word", ""] | needsInt = ["import Data.Int", ""] | needsWord = ["import Data.Word", ""] | needsRatio = ["import Data.Ratio"] | True = [] where ((is, os):_) = vs params = is ++ os needsInt = any isSW params needsWord = any isUW params needsRatio = any isR params isR cw = case kindOf cw of KReal -> True _ -> False isSW cw = case kindOf cw of KBounded True _ -> True _ -> False isUW cw = case kindOf cw of KBounded False sz -> sz > 1 _ -> False modName = let (f:r) = n in toUpper f : r pad = replicate (length n + 3) ' ' getType [] = "[a]" getType ((i, o):_) = "[(" ++ mapType typeOf i ++ ", " ++ mapType typeOf o ++ ")]" mkLine (i, o) = "(" ++ mapType valOf i ++ ", " ++ mapType valOf o ++ ")" mapType f cws = mkTuple $ map f $ groupBy ((==) `on` kindOf) cws mkTuple [x] = x mkTuple xs = "(" ++ intercalate ", " xs ++ ")" typeOf [] = "()" typeOf [x] = t x typeOf (x:_) = "[" ++ t x ++ "]" valOf [] = "()" valOf [x] = s x valOf xs = "[" ++ intercalate ", " (map s xs) ++ "]" t cw = case kindOf cw of KBool -> "Bool" KBounded False 8 -> "Word8" KBounded False 16 -> "Word16" KBounded False 32 -> "Word32" KBounded False 64 -> "Word64" KBounded True 8 -> "Int8" KBounded True 16 -> "Int16" KBounded True 32 -> "Int32" KBounded True 64 -> "Int64" KUnbounded -> "Integer" KFloat -> "Float" KDouble -> "Double" KReal -> error $ "SBV.renderTest: Unsupported real valued test value: " ++ show cw KUserSort us _ -> error $ "SBV.renderTest: Unsupported uninterpreted sort: " ++ us _ -> error $ "SBV.renderTest: Unexpected CW: " ++ show cw s cw = case kindOf cw of KBool -> take 5 (show (cwToBool cw) ++ repeat ' ') KBounded sgn sz -> let CWInteger w = cwVal cw in shex False True (sgn, sz) w KUnbounded -> let CWInteger w = cwVal cw in shexI False True w KFloat -> let CWFloat w = cwVal cw in showHFloat w KDouble -> let CWDouble w = cwVal cw in showHDouble w KReal -> let CWAlgReal w = cwVal cw in algRealToHaskell w KUserSort us _ -> error $ "SBV.renderTest: Unsupported uninterpreted sort: " ++ us c :: String -> [([CW], [CW])] -> String c n vs = intercalate "\n" $ [ "/* Automatically generated by SBV. Do not edit! */" , "" , "#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;" , "" , "typedef struct {" , " struct {" ] ++ (if null vs then [] else zipWith (mkField "i") (fst (head vs)) [(0::Int)..]) ++ [ " } input;" , " struct {" ] ++ (if null vs then [] else zipWith (mkField "o") (snd (head vs)) [(0::Int)..]) ++ [ " } output;" , "} " ++ n ++ "TestVector;" , "" , n ++ "TestVector " ++ n ++ "[] = {" ] ++ [" " ++ intercalate "\n , " (map mkLine vs)] ++ [ "};" , "" , "int " ++ n ++ "Length = " ++ show (length vs) ++ ";" , "" , "/* Stub driver showing the test values, replace with code that uses the test vectors. */" , "int main(void)" , "{" , " int i;" , " for(i = 0; i < " ++ n ++ "Length; ++i)" , " {" , " " ++ outLine , " }" , "" , " return 0;" , "}" ] where mkField p cw i = " " ++ t ++ " " ++ p ++ show i ++ ";" where t = case kindOf cw of KBool -> "SBool" KBounded False 8 -> "SWord8" KBounded False 16 -> "SWord16" KBounded False 32 -> "SWord32" KBounded False 64 -> "SWord64" KBounded True 8 -> "SInt8" KBounded True 16 -> "SInt16" KBounded True 32 -> "SInt32" KBounded True 64 -> "SInt64" KFloat -> "SFloat" KDouble -> "SDouble" KUnbounded -> error "SBV.renderTest: Unbounded integers are not supported when generating C test-cases." KReal -> error "SBV.renderTest: Real values are not supported when generating C test-cases." KUserSort us _ -> error $ "SBV.renderTest: Unsupported uninterpreted sort: " ++ us _ -> error $ "SBV.renderTest: Unexpected CW: " ++ show cw mkLine (is, os) = "{{" ++ intercalate ", " (map v is) ++ "}, {" ++ intercalate ", " (map v os) ++ "}}" v cw = case kindOf cw of KBool -> if cwToBool cw then "true " else "false" KBounded sgn sz -> let CWInteger w = cwVal cw in shex False True (sgn, sz) w KUnbounded -> let CWInteger w = cwVal cw in shexI False True w KFloat -> let CWFloat w = cwVal cw in showCFloat w KDouble -> let CWDouble w = cwVal cw in showCDouble w KUserSort us _ -> error $ "SBV.renderTest: Unsupported uninterpreted sort: " ++ us KReal -> error "SBV.renderTest: Real values are not supported when generating C test-cases." outLine | null vs = "printf(\"\");" | True = "printf(\"%*d. " ++ fmtString ++ "\\n\", " ++ show (length (show (length vs - 1))) ++ ", i" ++ concatMap ("\n , " ++ ) (zipWith inp is [(0::Int)..] ++ zipWith out os [(0::Int)..]) ++ ");" where (is, os) = head vs inp cw i = mkBool cw (n ++ "[i].input.i" ++ show i) out cw i = mkBool cw (n ++ "[i].output.o" ++ show i) mkBool cw s = case kindOf cw of KBool -> "(" ++ s ++ " == true) ? \"true \" : \"false\"" _ -> s fmtString = unwords (map fmt is) ++ " -> " ++ unwords (map fmt os) fmt cw = case kindOf cw of KBool -> "%s" KBounded False 8 -> "0x%02\"PRIx8\"" KBounded False 16 -> "0x%04\"PRIx16\"U" KBounded False 32 -> "0x%08\"PRIx32\"UL" KBounded False 64 -> "0x%016\"PRIx64\"ULL" KBounded True 8 -> "%\"PRId8\"" KBounded True 16 -> "%\"PRId16\"" KBounded True 32 -> "%\"PRId32\"L" KBounded True 64 -> "%\"PRId64\"LL" KFloat -> "%f" KDouble -> "%f" KUnbounded -> error "SBV.renderTest: Unsupported unbounded integers for C generation." KReal -> error "SBV.renderTest: Unsupported real valued values for C generation." _ -> error $ "SBV.renderTest: Unexpected CW: " ++ show cw forte :: String -> Bool -> ([Int], [Int]) -> [([CW], [CW])] -> String forte vname bigEndian ss vs = intercalate "\n" $ [ "// Automatically generated by SBV. Do not edit!" , "let " ++ n ++ " =" , " let c s = val [_, r] = str_split s \"'\" in " ++ blaster ] ++ [ " in [ " ++ intercalate "\n , " (map mkLine vs) , " ];" ] where n | null vname = "testVectors" | not (isAlpha (head vname)) = "tv" ++ vname | True = vname blaster | bigEndian = "map (\\s. s == \"1\") (explode (string_tl r))" | True = "rev (map (\\s. s == \"1\") (explode (string_tl r)))" toF True = '1' toF False = '0' blast cw = case kindOf cw of KBool -> [toF (cwToBool cw)] KBounded False 8 -> xlt 8 (cwVal cw) KBounded False 16 -> xlt 16 (cwVal cw) KBounded False 32 -> xlt 32 (cwVal cw) KBounded False 64 -> xlt 64 (cwVal cw) KBounded True 8 -> xlt 8 (cwVal cw) KBounded True 16 -> xlt 16 (cwVal cw) KBounded True 32 -> xlt 32 (cwVal cw) KBounded True 64 -> xlt 64 (cwVal cw) KFloat -> error "SBV.renderTest: Float values are not supported when generating Forte test-cases." KDouble -> error "SBV.renderTest: Double values are not supported when generating Forte test-cases." KReal -> error "SBV.renderTest: Real values are not supported when generating Forte test-cases." KUnbounded -> error "SBV.renderTest: Unbounded integers are not supported when generating Forte test-cases." _ -> error $ "SBV.renderTest: Unexpected CW: " ++ show cw xlt s (CWInteger v) = [toF (testBit v i) | i <- [s-1, s-2 .. 0]] xlt _ (CWFloat r) = error $ "SBV.renderTest.Forte: Unexpected float value: " ++ show r xlt _ (CWDouble r) = error $ "SBV.renderTest.Forte: Unexpected double value: " ++ show r xlt _ (CWAlgReal r) = error $ "SBV.renderTest.Forte: Unexpected real value: " ++ show r xlt _ (CWUserSort r) = error $ "SBV.renderTest.Forte: Unexpected uninterpreted value: " ++ show r mkLine (i, o) = "(" ++ mkTuple (form (fst ss) (concatMap blast i)) ++ ", " ++ mkTuple (form (snd ss) (concatMap blast o)) ++ ")" mkTuple [] = "()" mkTuple [x] = x mkTuple xs = "(" ++ intercalate ", " xs ++ ")" form [] [] = [] form [] bs = error $ "SBV.renderTest: Mismatched index in stream, extra " ++ show (length bs) ++ " bit(s) remain." form (i:is) bs | length bs < i = error $ "SBV.renderTest: Mismatched index in stream, was looking for " ++ show i ++ " bit(s), but only " ++ show i ++ " remains." | i == 1 = let b:r = bs v = if b == '1' then "T" else "F" in v : form is r | True = let (f, r) = splitAt i bs v = "c \"" ++ show i ++ "'b" ++ f ++ "\"" in v : form is r sbv-5.12/Data/SBV/Tools/Optimize.hs0000644000000000000000000001417312725411266015174 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Tools.Optimize -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- SMT based optimization ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeSynonymInstances #-} module Data.SBV.Tools.Optimize (OptimizeOpts(..), optimize, optimizeWith, minimize, minimizeWith, maximize, maximizeWith) where import Data.Maybe (fromJust) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model (OrdSymbolic(..), EqSymbolic(..)) import Data.SBV.Provers.Prover (satWith, defaultSMTCfg) import Data.SBV.SMT.SMT (SatModel, getModel) import Data.SBV.Utils.Boolean -- | Optimizer configuration. Note that iterative and quantified approaches are in general not interchangeable. -- For instance, iterative solutions will loop infinitely when there is no optimal value, but quantified solutions -- can handle such problems. Of course, quantified problems are harder for SMT solvers, naturally. data OptimizeOpts = Iterative Bool -- ^ Iteratively search. if True, it will be reporting progress | Quantified -- ^ Use quantifiers -- | Symbolic optimization. Generalization on 'minimize' and 'maximize' that allows arbitrary -- cost functions and comparisons. optimizeWith :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => SMTConfig -- ^ SMT configuration -> OptimizeOpts -- ^ Optimization options -> (SBV c -> SBV c -> SBool) -- ^ comparator -> ([SBV a] -> SBV c) -- ^ cost function -> Int -- ^ how many elements? -> ([SBV a] -> SBool) -- ^ validity constraint -> IO (Maybe [a]) optimizeWith cfg (Iterative chatty) = iterOptimize chatty cfg optimizeWith cfg Quantified = quantOptimize cfg -- | Variant of 'optimizeWith' using the default solver. See 'optimizeWith' for parameter descriptions. optimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -> (SBV c -> SBV c -> SBool) -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) optimize = optimizeWith defaultSMTCfg -- | Variant of 'maximize' allowing the use of a user specified solver. See 'optimizeWith' for parameter descriptions. maximizeWith :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => SMTConfig -> OptimizeOpts -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) maximizeWith cfg opts = optimizeWith cfg opts (.>=) -- | Maximizes a cost function with respect to a constraint. Examples: -- -- >>> maximize Quantified sum 3 (bAll (.< (10 :: SInteger))) -- Just [9,9,9] maximize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) maximize = maximizeWith defaultSMTCfg -- | Variant of 'minimize' allowing the use of a user specified solver. See 'optimizeWith' for parameter descriptions. minimizeWith :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => SMTConfig -> OptimizeOpts -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) minimizeWith cfg opts = optimizeWith cfg opts (.<=) -- | Minimizes a cost function with respect to a constraint. Examples: -- -- >>> minimize Quantified sum 3 (bAll (.> (10 :: SInteger))) -- Just [11,11,11] minimize :: (SatModel a, SymWord a, Show a, SymWord c, Show c) => OptimizeOpts -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) minimize = minimizeWith defaultSMTCfg -- | Optimization using quantifiers quantOptimize :: (SatModel a, SymWord a) => SMTConfig -> (SBV c -> SBV c -> SBool) -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) quantOptimize cfg cmp cost n valid = do m <- satWith cfg $ do xs <- mkExistVars n ys <- mkForallVars n return $ valid xs &&& (valid ys ==> cost xs `cmp` cost ys) case getModel m of Right (True, _) -> error "SBV: Backend solver reported \"unknown\"" Right (False, a) -> return $ Just a Left _ -> return Nothing -- | Optimization using iteration iterOptimize :: (SatModel a, Show a, SymWord a, Show c, SymWord c) => Bool -> SMTConfig -> (SBV c -> SBV c -> SBool) -> ([SBV a] -> SBV c) -> Int -> ([SBV a] -> SBool) -> IO (Maybe [a]) iterOptimize chatty cfg cmp cost n valid = do msg "Trying to find a satisfying solution." m <- satWith cfg $ valid `fmap` mkExistVars n case getModel m of Left _ -> do msg "No satisfying solutions found." return Nothing Right (True, _) -> error "SBV: Backend solver reported \"unknown\"" Right (False, a) -> do msg $ "First solution found: " ++ show a let c = cost (map literal a) msg $ "Initial value is : " ++ show (fromJust (unliteral c)) msg "Starting iterative search." go (1::Int) a c where msg m | chatty = putStrLn $ "*** " ++ m | True = return () go i curSol curCost = do msg $ "Round " ++ show i ++ " ****************************" m <- satWith cfg $ do xs <- mkExistVars n return $ let c = cost xs in valid xs &&& (c `cmp` curCost &&& c ./= curCost) case getModel m of Left _ -> do msg "The current solution is optimal. Terminating search." return $ Just curSol Right (True, _) -> error "SBV: Backend solver reported \"unknown\"" Right (False, a) -> do msg $ "Solution: " ++ show a let c = cost (map literal a) msg $ "Value : " ++ show (fromJust (unliteral c)) go (i+1) a c sbv-5.12/Data/SBV/Tools/Polynomial.hs0000644000000000000000000002575312725411266015525 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.BitVectors.Polynomials -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Implementation of polynomial arithmetic ----------------------------------------------------------------------------- {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE TypeSynonymInstances #-} module Data.SBV.Tools.Polynomial (Polynomial(..), crc, crcBV, ites, mdp, addPoly) where import Data.Bits (Bits(..)) import Data.List (genericTake) import Data.Maybe (fromJust, fromMaybe) import Data.Word (Word8, Word16, Word32, Word64) import Data.SBV.BitVectors.Data import Data.SBV.BitVectors.Model import Data.SBV.BitVectors.Splittable import Data.SBV.Utils.Boolean -- | Implements polynomial addition, multiplication, division, and modulus operations -- over GF(2^n). NB. Similar to 'sQuotRem', division by @0@ is interpreted as follows: -- -- @x `pDivMod` 0 = (0, x)@ -- -- for all @x@ (including @0@) -- -- Minimal complete definition: 'pMult', 'pDivMod', 'showPolynomial' class (Num a, Bits a) => Polynomial a where -- | Given bit-positions to be set, create a polynomial -- For instance -- -- @polynomial [0, 1, 3] :: SWord8@ -- -- will evaluate to @11@, since it sets the bits @0@, @1@, and @3@. Mathematicans would write this polynomial -- as @x^3 + x + 1@. And in fact, 'showPoly' will show it like that. polynomial :: [Int] -> a -- | Add two polynomials in GF(2^n). pAdd :: a -> a -> a -- | Multiply two polynomials in GF(2^n), and reduce it by the irreducible specified by -- the polynomial as specified by coefficients of the third argument. Note that the third -- argument is specifically left in this form as it is usally in GF(2^(n+1)), which is not available in our -- formalism. (That is, we would need SWord9 for SWord8 multiplication, etc.) Also note that we do not -- support symbolic irreducibles, which is a minor shortcoming. (Most GF's will come with fixed irreducibles, -- so this should not be a problem in practice.) -- -- Passing [] for the third argument will multiply the polynomials and then ignore the higher bits that won't -- fit into the resulting size. pMult :: (a, a, [Int]) -> a -- | Divide two polynomials in GF(2^n), see above note for division by 0. pDiv :: a -> a -> a -- | Compute modulus of two polynomials in GF(2^n), see above note for modulus by 0. pMod :: a -> a -> a -- | Division and modulus packed together. pDivMod :: a -> a -> (a, a) -- | Display a polynomial like a mathematician would (over the monomial @x@), with a type. showPoly :: a -> String -- | Display a polynomial like a mathematician would (over the monomial @x@), the first argument -- controls if the final type is shown as well. showPolynomial :: Bool -> a -> String -- defaults.. Minumum complete definition: pMult, pDivMod, showPolynomial polynomial = foldr (flip setBit) 0 pAdd = xor pDiv x y = fst (pDivMod x y) pMod x y = snd (pDivMod x y) showPoly = showPolynomial False instance Polynomial Word8 where {showPolynomial = sp; pMult = lift polyMult; pDivMod = liftC polyDivMod} instance Polynomial Word16 where {showPolynomial = sp; pMult = lift polyMult; pDivMod = liftC polyDivMod} instance Polynomial Word32 where {showPolynomial = sp; pMult = lift polyMult; pDivMod = liftC polyDivMod} instance Polynomial Word64 where {showPolynomial = sp; pMult = lift polyMult; pDivMod = liftC polyDivMod} instance Polynomial SWord8 where {showPolynomial b = liftS (sp b); pMult = polyMult; pDivMod = polyDivMod} instance Polynomial SWord16 where {showPolynomial b = liftS (sp b); pMult = polyMult; pDivMod = polyDivMod} instance Polynomial SWord32 where {showPolynomial b = liftS (sp b); pMult = polyMult; pDivMod = polyDivMod} instance Polynomial SWord64 where {showPolynomial b = liftS (sp b); pMult = polyMult; pDivMod = polyDivMod} lift :: SymWord a => ((SBV a, SBV a, [Int]) -> SBV a) -> (a, a, [Int]) -> a lift f (x, y, z) = fromJust $ unliteral $ f (literal x, literal y, z) liftC :: SymWord a => (SBV a -> SBV a -> (SBV a, SBV a)) -> a -> a -> (a, a) liftC f x y = let (a, b) = f (literal x) (literal y) in (fromJust (unliteral a), fromJust (unliteral b)) liftS :: SymWord a => (a -> String) -> SBV a -> String liftS f s | Just x <- unliteral s = f x | True = show s -- | Pretty print as a polynomial sp :: Bits a => Bool -> a -> String sp st a | null cs = '0' : t | True = foldr (\x y -> sh x ++ " + " ++ y) (sh (last cs)) (init cs) ++ t where t | st = " :: GF(2^" ++ show n ++ ")" | True = "" n = fromMaybe (error "SBV.Polynomial.sp: Unexpected non-finite usage!") (bitSizeMaybe a) is = [n-1, n-2 .. 0] cs = map fst $ filter snd $ zip is (map (testBit a) is) sh 0 = "1" sh 1 = "x" sh i = "x^" ++ show i -- | Add two polynomials addPoly :: [SBool] -> [SBool] -> [SBool] addPoly xs [] = xs addPoly [] ys = ys addPoly (x:xs) (y:ys) = x <+> y : addPoly xs ys -- | Run down a boolean condition over two lists. Note that this is -- different than zipWith as shorter list is assumed to be filled with -- false at the end (i.e., zero-bits); which nicely pads it when -- considered as an unsigned number in little-endian form. ites :: SBool -> [SBool] -> [SBool] -> [SBool] ites s xs ys | Just t <- unliteral s = if t then xs else ys | True = go xs ys where go [] [] = [] go [] (b:bs) = ite s false b : go [] bs go (a:as) [] = ite s a false : go as [] go (a:as) (b:bs) = ite s a b : go as bs -- | Multiply two polynomials and reduce by the third (concrete) irreducible, given by its coefficients. -- See the remarks for the 'pMult' function for this design choice polyMult :: (Num a, Bits a, SymWord a, FromBits (SBV a)) => (SBV a, SBV a, [Int]) -> SBV a polyMult (x, y, red) | isReal x = error $ "SBV.polyMult: Received a real value: " ++ show x | not (isBounded x) = error $ "SBV.polyMult: Received infinite precision value: " ++ show x | True = fromBitsLE $ genericTake sz $ r ++ repeat false where (_, r) = mdp ms rs ms = genericTake (2*sz) $ mul (blastLE x) (blastLE y) [] ++ repeat false rs = genericTake (2*sz) $ [if i `elem` red then true else false | i <- [0 .. foldr max 0 red] ] ++ repeat false sz = intSizeOf x mul _ [] ps = ps mul as (b:bs) ps = mul (false:as) bs (ites b (as `addPoly` ps) ps) polyDivMod :: (Num a, Bits a, SymWord a, FromBits (SBV a)) => SBV a -> SBV a -> (SBV a, SBV a) polyDivMod x y | isReal x = error $ "SBV.polyDivMod: Received a real value: " ++ show x | not (isBounded x) = error $ "SBV.polyDivMod: Received infinite precision value: " ++ show x | True = ite (y .== 0) (0, x) (adjust d, adjust r) where adjust xs = fromBitsLE $ genericTake sz $ xs ++ repeat false sz = intSizeOf x (d, r) = mdp (blastLE x) (blastLE y) -- conservative over-approximation of the degree degree :: [SBool] -> Int degree xs = walk (length xs - 1) $ reverse xs where walk n [] = n walk n (b:bs) | Just t <- unliteral b = if t then n else walk (n-1) bs | True = n -- over-estimate -- | Compute modulus/remainder of polynomials on bit-vectors. mdp :: [SBool] -> [SBool] -> ([SBool], [SBool]) mdp xs ys = go (length ys - 1) (reverse ys) where degTop = degree xs go _ [] = error "SBV.Polynomial.mdp: Impossible happened; exhausted ys before hitting 0" go n (b:bs) | n == 0 = (reverse qs, rs) | True = let (rqs, rrs) = go (n-1) bs in (ites b (reverse qs) rqs, ites b rs rrs) where degQuot = degTop - n ys' = replicate degQuot false ++ ys (qs, rs) = divx (degQuot+1) degTop xs ys' -- return the element at index i; if not enough elements, return false -- N.B. equivalent to '(xs ++ repeat false) !! i', but more efficient idx :: [SBool] -> Int -> SBool idx [] _ = false idx (x:_) 0 = x idx (_:xs) i = idx xs (i-1) divx :: Int -> Int -> [SBool] -> [SBool] -> ([SBool], [SBool]) divx n _ xs _ | n <= 0 = ([], xs) divx n i xs ys' = (q:qs, rs) where q = xs `idx` i xs' = ites q (xs `addPoly` ys') xs (qs, rs) = divx (n-1) (i-1) xs' (tail ys') -- | Compute CRCs over bit-vectors. The call @crcBV n m p@ computes -- the CRC of the message @m@ with respect to polynomial @p@. The -- inputs are assumed to be blasted big-endian. The number -- @n@ specifies how many bits of CRC is needed. Note that @n@ -- is actually the degree of the polynomial @p@, and thus it seems -- redundant to pass it in. However, in a typical proof context, -- the polynomial can be symbolic, so we cannot compute the degree -- easily. While this can be worked-around by generating code that -- accounts for all possible degrees, the resulting code would -- be unnecessarily big and complicated, and much harder to reason -- with. (Also note that a CRC is just the remainder from the -- polynomial division, but this routine is much faster in practice.) -- -- NB. The @n@th bit of the polynomial @p@ /must/ be set for the CRC -- to be computed correctly. Note that the polynomial argument 'p' will -- not even have this bit present most of the time, as it will typically -- contain bits @0@ through @n-1@ as usual in the CRC literature. The higher -- order @n@th bit is simply assumed to be set, as it does not make -- sense to use a polynomial of a lesser degree. This is usually not a problem -- since CRC polynomials are designed and expressed this way. -- -- NB. The literature on CRC's has many variants on how CRC's are computed. -- We follow the following simple procedure: -- -- * Extend the message 'm' by adding 'n' 0 bits on the right -- -- * Divide the polynomial thus obtained by the 'p' -- -- * The remainder is the CRC value. -- -- There are many variants on final XOR's, reversed polynomials etc., so -- it is essential to double check you use the correct /algorithm/. crcBV :: Int -> [SBool] -> [SBool] -> [SBool] crcBV n m p = take n $ go (replicate n false) (m ++ replicate n false) where mask = drop (length p - n) p go c [] = c go c (b:bs) = go next bs where c' = drop 1 c ++ [b] next = ite (head c) (zipWith (<+>) c' mask) c' -- | Compute CRC's over polynomials, i.e., symbolic words. The first -- 'Int' argument plays the same role as the one in the 'crcBV' function. crc :: (FromBits (SBV a), FromBits (SBV b), Num a, Num b, Bits a, Bits b, SymWord a, SymWord b) => Int -> SBV a -> SBV b -> SBV b crc n m p | isReal m || isReal p = error $ "SBV.crc: Received a real value: " ++ show (m, p) | not (isBounded m) || not (isBounded p) = error $ "SBV.crc: Received an infinite precision value: " ++ show (m, p) | True = fromBitsBE $ replicate (sz - n) false ++ crcBV n (blastBE m) (blastBE p) where sz = intSizeOf p sbv-5.12/Data/SBV/Utils/0000755000000000000000000000000012725411266013032 5ustar0000000000000000sbv-5.12/Data/SBV/Utils/Boolean.hs0000644000000000000000000000422412725411266014747 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Utils.Boolean -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Abstraction of booleans. Unfortunately, Haskell makes Bool's very hard to -- work with, by making it a fixed-data type. This is our workaround ----------------------------------------------------------------------------- module Data.SBV.Utils.Boolean(Boolean(..), bAnd, bOr, bAny, bAll) where infixl 6 <+> -- xor infixr 3 &&&, ~& -- and, nand infixr 2 |||, ~| -- or, nor infixr 1 ==>, <=> -- implies, iff -- | The 'Boolean' class: a generalization of Haskell's 'Bool' type -- Haskell 'Bool' and SBV's 'SBool' are instances of this class, unifying the treatment of boolean values. -- -- Minimal complete definition: 'true', 'bnot', '&&&' -- However, it's advisable to define 'false', and '|||' as well (typically), for clarity. class Boolean b where -- | logical true true :: b -- | logical false false :: b -- | complement bnot :: b -> b -- | and (&&&) :: b -> b -> b -- | or (|||) :: b -> b -> b -- | nand (~&) :: b -> b -> b -- | nor (~|) :: b -> b -> b -- | xor (<+>) :: b -> b -> b -- | implies (==>) :: b -> b -> b -- | equivalence (<=>) :: b -> b -> b -- | cast from Bool fromBool :: Bool -> b -- default definitions false = bnot true a ||| b = bnot (bnot a &&& bnot b) a ~& b = bnot (a &&& b) a ~| b = bnot (a ||| b) a <+> b = (a &&& bnot b) ||| (bnot a &&& b) a <=> b = (a &&& b) ||| (bnot a &&& bnot b) a ==> b = bnot a ||| b fromBool True = true fromBool False = false -- | Generalization of 'and' bAnd :: Boolean b => [b] -> b bAnd = foldr (&&&) true -- | Generalization of 'or' bOr :: Boolean b => [b] -> b bOr = foldr (|||) false -- | Generalization of 'any' bAny :: Boolean b => (a -> b) -> [a] -> b bAny f = bOr . map f -- | Generalization of 'all' bAll :: Boolean b => (a -> b) -> [a] -> b bAll f = bAnd . map f instance Boolean Bool where true = True false = False bnot = not (&&&) = (&&) (|||) = (||) sbv-5.12/Data/SBV/Utils/Lib.hs0000644000000000000000000001171012725411266014074 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Utils.Lib -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Misc helpers ----------------------------------------------------------------------------- module Data.SBV.Utils.Lib (mlift2, mlift3, mlift4, mlift5, mlift6, mlift7, mlift8, joinArgs, splitArgs) where import Data.Char (isSpace) import Data.Maybe (fromJust, isNothing) -- | Monadic lift over 2-tuples mlift2 :: Monad m => (a' -> b' -> r) -> (a -> m a') -> (b -> m b') -> (a, b) -> m r mlift2 k f g (a, b) = f a >>= \a' -> g b >>= \b' -> return $ k a' b' -- | Monadic lift over 3-tuples mlift3 :: Monad m => (a' -> b' -> c' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (a, b, c) -> m r mlift3 k f g h (a, b, c) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> return $ k a' b' c' -- | Monadic lift over 4-tuples mlift4 :: Monad m => (a' -> b' -> c' -> d' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (a, b, c, d) -> m r mlift4 k f g h i (a, b, c, d) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> return $ k a' b' c' d' -- | Monadic lift over 5-tuples mlift5 :: Monad m => (a' -> b' -> c' -> d' -> e' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (a, b, c, d, e) -> m r mlift5 k f g h i j (a, b, c, d, e) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> return $ k a' b' c' d' e' -- | Monadic lift over 6-tuples mlift6 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (a, b, c, d, e, f) -> m r mlift6 k f g h i j l (a, b, c, d, e, y) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> return $ k a' b' c' d' e' y' -- | Monadic lift over 7-tuples mlift7 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> g' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (g -> m g') -> (a, b, c, d, e, f, g) -> m r mlift7 k f g h i j l m (a, b, c, d, e, y, z) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> m z >>= \z' -> return $ k a' b' c' d' e' y' z' -- | Monadic lift over 8-tuples mlift8 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> g' -> h' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (g -> m g') -> (h -> m h') -> (a, b, c, d, e, f, g, h) -> m r mlift8 k f g h i j l m n (a, b, c, d, e, y, z, w) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> m z >>= \z' -> n w >>= \w' -> return $ k a' b' c' d' e' y' z' w' -- Command line argument parsing code courtesy of Neil Mitchell's cmdargs package: see -- -- | Given a sequence of arguments, join them together in a manner that could be used on -- the command line, giving preference to the Windows @cmd@ shell quoting conventions. -- -- For an alternative version, intended for actual running the result in a shell, see "System.Process.showCommandForUser" joinArgs :: [String] -> String joinArgs = unwords . map f where f x = q ++ g x ++ q where hasSpace = any isSpace x q = ['\"' | hasSpace || null x] g ('\\':'\"':xs) = '\\':'\\':'\\':'\"': g xs g "\\" | hasSpace = "\\\\" g ('\"':xs) = '\\':'\"': g xs g (x':xs) = x' : g xs g [] = [] data State = Init -- either I just started, or just emitted something | Norm -- I'm seeing characters | Quot -- I've seen a quote -- | Given a string, split into the available arguments. The inverse of 'joinArgs'. -- Courtesy of the cmdargs package. splitArgs :: String -> [String] splitArgs = join . f Init where -- Nothing is start a new string -- Just x is accumulate onto the existing string join :: [Maybe Char] -> [String] join [] = [] join xs = map fromJust a : join (drop 1 b) where (a,b) = break isNothing xs f Init (x:xs) | isSpace x = f Init xs f Init "\"\"" = [Nothing] f Init "\"" = [Nothing] f Init xs = f Norm xs f m ('\"':'\"':'\"':xs) = Just '\"' : f m xs f m ('\\':'\"':xs) = Just '\"' : f m xs f m ('\\':'\\':'\"':xs) = Just '\\' : f m ('\"':xs) f Norm ('\"':xs) = f Quot xs f Quot ('\"':'\"':xs) = Just '\"' : f Norm xs f Quot ('\"':xs) = f Norm xs f Norm (x:xs) | isSpace x = Nothing : f Init xs f m (x:xs) = Just x : f m xs f _ [] = [] sbv-5.12/Data/SBV/Utils/Numeric.hs0000644000000000000000000001056412725411266014776 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Utils.Numeric -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Various number related utilities ----------------------------------------------------------------------------- module Data.SBV.Utils.Numeric where -- | A variant of round; except defaulting to 0 when fed NaN or Infinity fpRound0 :: (RealFloat a, Integral b) => a -> b fpRound0 x | isNaN x || isInfinite x = 0 | True = round x -- | A variant of toRational; except defaulting to 0 when fed NaN or Infinity fpRatio0 :: (RealFloat a) => a -> Rational fpRatio0 x | isNaN x || isInfinite x = 0 | True = toRational x -- | The SMT-Lib (in particular Z3) implementation for min/max for floats does not agree with -- Haskell's; and also it does not agree with what the hardware does. Sigh.. See: -- -- -- So, we codify here what the Z3 (SMTLib) is implementing for fpMax. -- The discrepancy with Haskell is that the NaN propagation doesn't work in Haskell -- The discrepancy with x86 is that given +0/-0, x86 returns the second argument; SMTLib is non-deterministic fpMaxH :: RealFloat a => a -> a -> a fpMaxH x y | isNaN x = y | isNaN y = x | (isN0 x && isP0 y) || (isN0 y && isP0 x) = error "fpMaxH: Called with alternating-sign 0's. Not supported" | x > y = x | True = y where isN0 = isNegativeZero isP0 a = a == 0 && not (isN0 a) -- | SMTLib compliant definition for 'fpMin'. See the comments for 'fpMax'. fpMinH :: RealFloat a => a -> a -> a fpMinH x y | isNaN x = y | isNaN y = x | (isN0 x && isP0 y) || (isN0 y && isP0 x) = error "fpMinH: Called with alternating-sign 0's. Not supported" | x < y = x | True = y where isN0 = isNegativeZero isP0 a = a == 0 && not (isN0 a) -- | Convert double to float and back. Essentially @fromRational . toRational@ -- except careful on NaN, Infinities, and -0. fp2fp :: (RealFloat a, RealFloat b) => a -> b fp2fp x | isNaN x = 0 / 0 | isInfinite x && x < 0 = -1 / 0 | isInfinite x = 1 / 0 | isNegativeZero x = negate 0 | True = fromRational (toRational x) -- | Compute the "floating-point" remainder function, the float/double value that -- remains from the division of @x@ and @y@. There are strict rules around 0's, Infinities, -- and NaN's as coded below, See , towards the -- end of section 4.c. fpRemH :: RealFloat a => a -> a -> a fpRemH x y | isInfinite x || isNaN x = 0 / 0 | y == 0 || isNaN y = 0 / 0 | isInfinite y = x | True = pSign (x - fromRational (fromInteger d * ry)) where rx, ry, rd :: Rational rx = toRational x ry = toRational y rd = rx / ry d :: Integer d = round rd -- If the result is 0, make sure we preserve the sign of x pSign r | r == 0 = if x < 0 || isNegativeZero x then -0.0 else 0.0 | True = r -- | Convert a float to the nearest integral representable in that type fpRoundToIntegralH :: RealFloat a => a -> a fpRoundToIntegralH x | isNaN x = x | x == 0 = x | isInfinite x = x | i == 0 = if x < 0 || isNegativeZero x then -0.0 else 0.0 | True = fromInteger i where i :: Integer i = round x -- | Check that two floats are the exact same values, i.e., +0/-0 does not -- compare equal, and NaN's compare equal to themselves. fpIsEqualObjectH :: RealFloat a => a -> a -> Bool fpIsEqualObjectH a b | isNaN a = isNaN b | isNegativeZero a = isNegativeZero b | isNegativeZero b = isNegativeZero a | True = a == b -- | Check if a number is "normal." Note that +0/-0 is not considered a normal-number -- and also this is not simply the negation of isDenormalized! fpIsNormalizedH :: RealFloat a => a -> Bool fpIsNormalizedH x = not (isDenormalized x || isInfinite x || isNaN x || x == 0) sbv-5.12/Data/SBV/Utils/TDiff.hs0000644000000000000000000000306112725411266014362 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Data.SBV.Utils.TDiff -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Runs an IO computation printing the time it took to run it ----------------------------------------------------------------------------- module Data.SBV.Utils.TDiff(timeIf) where import Control.DeepSeq (rnf, NFData(..)) import System.Time (TimeDiff(..), normalizeTimeDiff, diffClockTimes, getClockTime) import Numeric (showFFloat) showTDiff :: TimeDiff -> String showTDiff itd = et where td = normalizeTimeDiff itd vals = dropWhile (\(v, _) -> v == 0) (zip [tdYear td, tdMonth td, tdDay td, tdHour td, tdMin td] "YMDhm") sec = ' ' : show (tdSec td) ++ dropWhile (/= '.') pico pico = showFFloat (Just 3) (((10**(-12))::Double) * fromIntegral (tdPicosec td)) "s" et = concatMap (\(v, c) -> ' ':show v ++ [c]) vals ++ sec -- | If selected, runs the computation @m@, and prints the time it took -- to run it. The return type should be an instance of 'NFData' to ensure -- the correct elapsed time is printed. timeIf :: NFData a => Bool -> String -> IO a -> IO a timeIf False _ m = m timeIf True w m = do start <- getClockTime r <- m end <- rnf r `seq` getClockTime let elapsed = diffClockTimes end start putStrLn $ "** Elapsed " ++ w ++ " time:" ++ showTDiff elapsed return r sbv-5.12/GHC/0000755000000000000000000000000012725411265011027 5ustar0000000000000000sbv-5.12/GHC/SrcLoc/0000755000000000000000000000000012725411266012215 5ustar0000000000000000sbv-5.12/GHC/SrcLoc/Compat.hs0000644000000000000000000000035712725411266014001 0ustar0000000000000000{-# LANGUAGE CPP #-} -- | Compatibility shims for the SrcLoc interface across GHC versions module GHC.SrcLoc.Compat (module X) where #if MIN_VERSION_base(4,9,0) import SrcLoc as X hiding (srcLocFile) #else import GHC.SrcLoc as X #endif sbv-5.12/GHC/Stack/0000755000000000000000000000000012725411266012075 5ustar0000000000000000sbv-5.12/GHC/Stack/Compat.hs0000644000000000000000000000023612725411266013655 0ustar0000000000000000{-# LANGUAGE CPP #-} -- | Compatibility shims for the Stack interface across GHC versions module GHC.Stack.Compat (module GHC.Stack) where import GHC.Stack sbv-5.12/SBVUnitTest/0000755000000000000000000000000012725411266012561 5ustar0000000000000000sbv-5.12/SBVUnitTest/SBVBasicTests.hs0000644000000000000000000000645512725411266015546 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Main -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- SBV library basic test suite; i.e., those tests that do not -- require the use of an external SMT solver. ----------------------------------------------------------------------------- -- Nothing needs to be changed in this file, add test cases -- appropriately to SBVUnitTest.hs file, and they will be -- picked up here automagically module Main(main) where import Control.Monad (unless, when) import System.Directory (doesDirectoryExist) import System.Exit (exitWith, exitSuccess, ExitCode(..)) import System.FilePath (()) import System.IO (stderr, hPutStrLn) import Test.HUnit (Test(..), Counts(..), runTestText, PutText(..), showCounts) import Data.Version (showVersion) import SBVTest (SBVTestSuite(..), generateGoldCheck) import Paths_sbv (getDataDir, version) import SBVTestCollection (allTestCases) import SBVUnitTestBuildTime (buildTime) testCollection :: [(String, SBVTestSuite)] testCollection = [(n, s) | (n, False, s) <- allTestCases] main :: IO () main = do putStrLn $ "*** SBVBasicTester, version: " ++ showVersion version ++ ", time stamp: " ++ buildTime d <- getDataDir run $ d "SBVUnitTest" "GoldFiles" checkGoldDir :: FilePath -> IO () checkGoldDir gd = do e <- doesDirectoryExist gd unless e $ do putStrLn "*** Cannot locate gold file repository!" putStrLn "*** Please call with one argument, the directory name of the gold files." putStrLn "*** Cannot run test cases, exiting." exitWith $ ExitFailure 1 run :: FilePath -> IO () run gd = do putStrLn $ "*** Starting SBV basic tests..\n*** Gold files at: " ++ show gd checkGoldDir gd let collections = map (mkTst . snd) testCollection cNames = map fst testCollection putStrLn $ "*** Running " ++ show (length collections) ++ " test categories." runEach 1 (zip cNames collections) where runEach :: Int -> [(String, Test)] -> IO () runEach _ [] = exitSuccess runEach i ((n, tc):tcs) = do putStrLn $ "Starting category: " ++ show n (cts, _) <- runTestText (PutText put ()) tc hPutStrLn stderr $ showCounts cts decide n cts runEach (i+1) tcs mkTst (SBVTestSuite f) = f $ generateGoldCheck gd False put _ _ = return decide :: String -> Counts -> IO () decide cat (Counts c t e f) = do when (c /= t) $ putStrLn $ "*** Not all test cases were tried. (Only tested " ++ show t ++ " of " ++ show c ++ ")" when (e /= 0) $ putStrLn $ "*** " ++ show e ++ " (of " ++ show c ++ ") test cases in error." when (f /= 0) $ putStrLn $ "*** " ++ show f ++ " (of " ++ show c ++ ") test cases failed." if c == t && e == 0 && f == 0 then putStrLn $ "All " ++ show c ++ " test cases in category " ++ show cat ++ " successfully passed." else exitWith $ ExitFailure 2 sbv-5.12/SBVUnitTest/SBVTest.hs0000644000000000000000000000531512725411266014413 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : SBVTest -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Integration with HUnit-based test suite for SBV ----------------------------------------------------------------------------- {-# LANGUAGE RankNTypes #-} module SBVTest( generateGoldCheck, showsAs, ioShowsAs, mkTestSuite, SBVTestSuite(..) , isThm, isSat, runSAT, numberOfModels , module Test.HUnit , module Data.SBV ) where import Data.SBV (SMTConfig(..), Provable(..), isTheorem, isTheoremWith, isSatisfiable, AllSatResult(..), allSat, SymWord(free), SymArray(newArray), defaultSMTCfg) import Data.SBV.Internals (runSymbolic, Symbolic, Result) import Data.Maybe (fromJust) import System.FilePath (()) import Test.HUnit (Test(..), Assertion, assert, (~:), test) -- | A Test-suite, parameterized by the gold-check generator/checker data SBVTestSuite = SBVTestSuite ((forall a. Show a => (IO a -> FilePath -> IO ())) -> Test) -- | Wrap over 'SBVTestSuite', avoids exporting the constructor mkTestSuite :: ((forall a. (Show a) => IO a -> FilePath -> IO ()) -> Test) -> SBVTestSuite mkTestSuite = SBVTestSuite -- | Checks that a particular result shows as @s@ showsAs :: Show a => a -> String -> Assertion showsAs r s = assert $ show r == s -- | Run an IO computation and check that it's result shows as @s@ ioShowsAs :: Show a => IO a -> String -> Assertion ioShowsAs r s = do v <- r assert $ show v == s -- | Create a gold file for the test case generateGoldCheck :: FilePath -> Bool -> (forall a. Show a => IO a -> FilePath -> IO ()) generateGoldCheck goldDir shouldCreate action goldFile | shouldCreate = do v <- action writeFile gf (show v) putStrLn $ "\nCreated Gold File: " ++ show gf assert True | True = do v <- action g <- readFile gf assert $ show v == g where gf = goldDir goldFile -- | Check if a property is a theorem, no timeout isThm :: Provable a => a -> IO Bool isThm p = fromJust `fmap` isTheorem Nothing p -- | Check if a property is satisfiable, no timeout isSat :: Provable a => a -> IO Bool isSat p = fromJust `fmap` isSatisfiable Nothing p -- | Count the number of models numberOfModels :: Provable a => a -> IO Int numberOfModels p = do AllSatResult (_, rs) <- allSat p return $ length rs -- | Symbolicly run a SAT instance using the default config runSAT :: Symbolic a -> IO Result runSAT = runSymbolic (True, defaultSMTCfg) sbv-5.12/SBVUnitTest/SBVTestCollection.hs0000644000000000000000000001455112725411266016431 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Main -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- SBV test collection ----------------------------------------------------------------------------- module SBVTestCollection(allTestCases) where import SBVTest -- To add a new collection of tests, import below and add to allTestCases variable import qualified TestSuite.Arrays.Memory as T01_01(testSuite) import qualified TestSuite.Basics.ArithNoSolver as T02_01(testSuite) import qualified TestSuite.Basics.ArithSolver as T02_02(testSuite) import qualified TestSuite.Basics.BasicTests as T02_03(testSuite) import qualified TestSuite.Basics.Higher as T02_04(testSuite) import qualified TestSuite.Basics.Index as T02_05(testSuite) import qualified TestSuite.Basics.IteTest as T02_06(testSuite) import qualified TestSuite.Basics.ProofTests as T02_07(testSuite) import qualified TestSuite.Basics.QRem as T02_08(testSuite) import qualified TestSuite.BitPrecise.BitTricks as T03_01(testSuite) import qualified TestSuite.BitPrecise.Legato as T03_02(testSuite) import qualified TestSuite.BitPrecise.MergeSort as T03_03(testSuite) import qualified TestSuite.BitPrecise.PrefixSum as T03_04(testSuite) import qualified TestSuite.CRC.CCITT as T04_01(testSuite) import qualified TestSuite.CRC.CCITT_Unidir as T04_02(testSuite) import qualified TestSuite.CRC.GenPoly as T04_03(testSuite) import qualified TestSuite.CRC.Parity as T04_04(testSuite) import qualified TestSuite.CRC.USB5 as T04_05(testSuite) import qualified TestSuite.CodeGeneration.AddSub as T05_01(testSuite) import qualified TestSuite.CodeGeneration.CgTests as T05_02(testSuite) import qualified TestSuite.CodeGeneration.CRC_USB5 as T05_03(testSuite) import qualified TestSuite.CodeGeneration.Fibonacci as T05_04(testSuite) import qualified TestSuite.CodeGeneration.Floats as T05_05(testSuite) import qualified TestSuite.CodeGeneration.GCD as T05_06(testSuite) import qualified TestSuite.CodeGeneration.PopulationCount as T05_07(testSuite) import qualified TestSuite.CodeGeneration.Uninterpreted as T05_08(testSuite) import qualified TestSuite.Crypto.AES as T06_01(testSuite) import qualified TestSuite.Crypto.RC4 as T06_02(testSuite) import qualified TestSuite.Existentials.CRCPolynomial as T07_01(testSuite) import qualified TestSuite.Polynomials.Polynomials as T08_01(testSuite) import qualified TestSuite.Puzzles.Coins as T09_01(testSuite) import qualified TestSuite.Puzzles.Counts as T09_02(testSuite) import qualified TestSuite.Puzzles.DogCatMouse as T09_03(testSuite) import qualified TestSuite.Puzzles.Euler185 as T09_04(testSuite) import qualified TestSuite.Puzzles.MagicSquare as T09_05(testSuite) import qualified TestSuite.Puzzles.NQueens as T09_06(testSuite) import qualified TestSuite.Puzzles.PowerSet as T09_07(testSuite) import qualified TestSuite.Puzzles.Sudoku as T09_08(testSuite) import qualified TestSuite.Puzzles.Temperature as T09_09(testSuite) import qualified TestSuite.Puzzles.U2Bridge as T09_10(testSuite) import qualified TestSuite.Uninterpreted.AUF as T10_01(testSuite) import qualified TestSuite.Uninterpreted.Axioms as T10_02(testSuite) import qualified TestSuite.Uninterpreted.Function as T10_03(testSuite) import qualified TestSuite.Uninterpreted.Sort as T10_04(testSuite) import qualified TestSuite.Uninterpreted.Uninterpreted as T10_05(testSuite) -- Bool says whether we need a real SMT solver to run this test -- Note that it's ok to say True even if an SMT solver is *not* -- needed, but we'd like most things to be targeted False so that -- those tests can be run as part of cabal. allTestCases :: [(String, Bool, SBVTestSuite)] allTestCases = [ ("mem", True, T01_01.testSuite) , ("arithCF", False, T02_01.testSuite) , ("arith", True, T02_02.testSuite) , ("basic", False, T02_03.testSuite) , ("higher", True, T02_04.testSuite) , ("index", True, T02_05.testSuite) , ("ite", True, T02_06.testSuite) , ("proof", True, T02_07.testSuite) , ("qrem", True, T02_08.testSuite) , ("bitTricks", True, T03_01.testSuite) , ("legato", False, T03_02.testSuite) , ("mergeSort", False, T03_03.testSuite) , ("prefixSum", True, T03_04.testSuite) , ("ccitt", False, T04_01.testSuite) , ("ccitt2", True, T04_02.testSuite) , ("genPoly", True, T04_03.testSuite) , ("parity", True, T04_04.testSuite) , ("usb5", True, T04_05.testSuite) , ("addSub", False, T05_01.testSuite) , ("cgtest", False, T05_02.testSuite) , ("cgUSB5", False, T05_03.testSuite) , ("fib", False, T05_04.testSuite) , ("floats", False, T05_05.testSuite) , ("gcd", False, T05_06.testSuite) , ("popCount", False, T05_07.testSuite) , ("cgUninterp", False, T05_08.testSuite) , ("aes", False, T06_01.testSuite) , ("rc4", True, T06_02.testSuite) , ("existPoly", False, T07_01.testSuite) , ("poly", True, T08_01.testSuite) , ("coins", False, T09_01.testSuite) , ("counts", False, T09_02.testSuite) , ("dogCatMouse", True, T09_03.testSuite) , ("euler185", True, T09_04.testSuite) , ("magicSquare", True, T09_05.testSuite) , ("nQueens", True, T09_06.testSuite) , ("powerset", True, T09_07.testSuite) , ("sudoku", True, T09_08.testSuite) , ("temperature", True, T09_09.testSuite) , ("u2bridge", True, T09_10.testSuite) , ("auf1", True, T10_01.testSuite) , ("unint-axms", True, T10_02.testSuite) , ("auf2", True, T10_03.testSuite) , ("unint-sort", True, T10_04.testSuite) , ("unint", True, T10_05.testSuite) ] sbv-5.12/SBVUnitTest/SBVUnitTest.hs0000644000000000000000000001255112725411266015253 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Main -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- SBV library unit-test program ----------------------------------------------------------------------------- module Main(main) where import Control.Monad (unless, when) import Data.Maybe (isJust) import Data.List (isInfixOf) import System.Directory (doesDirectoryExist) import System.Environment (getArgs) import System.Exit (exitWith, exitSuccess, ExitCode(..)) import System.FilePath (()) import Test.HUnit (Test(..), Counts(..), runTestTT) import Data.Version (showVersion) import SBVTest (SBVTestSuite(..), generateGoldCheck) import Paths_sbv (getDataDir, version) import SBVUnitTestBuildTime (buildTime) import SBVTestCollection (allTestCases) main :: IO () main = do putStrLn $ "*** SBVUnitTester, version: " ++ showVersion version ++ ", time stamp: " ++ buildTime tgts <- getArgs case tgts of [x] | x `elem` ["-h", "--help", "-?"] -> do putStrLn "Usage: SBVUnitTests [-c] [-l] [-s] [targets]" -- Not quite right, but sufficient putStrLn " -l: List all tests" putStrLn " -s: Skip constant-folding tests" putStrLn " -c: Create gold-files" putStrLn " -m: Do a wild-card match on targets" putStrLn " -i: Do an inverse wild-card match on targets" putStrLn "If targets are given, run those groups; except with the -m flag which matches test names." ["-l"] -> showTargets -- undocumented really ("-c":ts) -> run (Nothing, ts) False True ["SBVUnitTest/GoldFiles"] ("-s":ts) -> run (Nothing, ts) True False [] ("-m":ts) -> run (Just False, ts) False False [] ("-i":ts) -> run (Just True, ts) False False [] _ -> run (Nothing, tgts) False False [] checkGoldDir :: FilePath -> IO () checkGoldDir gd = do e <- doesDirectoryExist gd unless e $ do putStrLn "*** Cannot locate gold file repository!" putStrLn "*** Please call with one argument, the directory name of the gold files." putStrLn "*** Cannot run test cases, exiting." exitWith $ ExitFailure 1 allTargets :: [String] allTargets = [s | (s, _, _) <- allTestCases] showTargets :: IO () showTargets = do putStrLn "Known test targets are:" mapM_ (putStrLn . ("\t" ++)) allTargets run :: (Maybe Bool, [String]) -> Bool -> Bool -> [String] -> IO () run (mbWCMatch, targets) skipCF shouldCreate [gd] = do mapM_ checkTgt targets putStrLn $ "*** Starting SBV unit tests..\n*** Gold files at: " ++ show gd checkGoldDir gd cts <- runTestTT $ TestList $ concatMap mkTst [c | (tc, needsSolver, c) <- allTestCases, select needsSolver tc] decide shouldCreate cts where mkTst (SBVTestSuite f) = pick $ f (generateGoldCheck gd shouldCreate) where pick :: Test -> [Test] pick tst = case mbWCMatch of Nothing -> [tst] Just inverted -> collect tst where collect (TestCase _) = [] collect (TestList ts) = concatMap collect ts collect t@(TestLabel s _) | all (`isInfixOf` s) targets = [t | not inverted] | True = [t | inverted] wcMode = isJust mbWCMatch select needsSolver tc | not included = False | shouldCreate = True | needsSolver = True | True = not skipCF where included | wcMode = True | True = null targets || tc `elem` targets checkTgt t | wcMode = return () | t `elem` allTargets = return () | True = do putStrLn $ "*** Unknown test target: " ++ show t exitWith $ ExitFailure 1 run targets skipCF shouldCreate [] = getDataDir >>= \d -> run targets skipCF shouldCreate [d "SBVUnitTest" "GoldFiles"] run _ _ _ _ = error "SBVUnitTests.run: impossible happened!" decide :: Bool -> Counts -> IO () decide shouldCreate (Counts c t e f) = do when (c /= t) $ putStrLn $ "*** Not all test cases were tried. (Only tested " ++ show t ++ " of " ++ show c ++ ")" when (e /= 0) $ putStrLn $ "*** " ++ show e ++ " (of " ++ show c ++ ") test cases in error." when (f /= 0) $ putStrLn $ "*** " ++ show f ++ " (of " ++ show c ++ ") test cases failed." if c == t && e == 0 && f == 0 then do putStrLn $ "All " ++ show c ++ " test cases " ++ (if shouldCreate then " executed in gold-file generation mode." else " successfully passed.") exitSuccess else exitWith $ ExitFailure 2 sbv-5.12/SBVUnitTest/SBVUnitTestBuildTime.hs0000644000000000000000000000021412725411266017043 0ustar0000000000000000-- Auto-generated, don't edit module SBVUnitTestBuildTime (buildTime) where buildTime :: String buildTime = "Mon Jun 6 17:13:43 PDT 2016" sbv-5.12/SBVUnitTest/Examples/0000755000000000000000000000000012725411265014336 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/Arrays/0000755000000000000000000000000012725411266015600 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/Arrays/Memory.hs0000644000000000000000000000305712725411266017411 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Arrays.Memory -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Simple memory abstraction and properties ----------------------------------------------------------------------------- module Examples.Arrays.Memory where import Data.SBV type Address = SWord32 type Value = SWord64 type Memory = SArray Word32 Word64 -- | read-after-write: If you write a value and read it back, you'll get it raw :: Address -> Value -> Memory -> SBool raw a v m = readArray (writeArray m a v) a .== v -- | write-after-write: If you write to the same location twice, then the first one is ignored waw :: Address -> Value -> Value -> Memory -> SBool waw a v1 v2 m0 = m2 .== m3 where m1 = writeArray m0 a v1 m2 = writeArray m1 a v2 m3 = writeArray m0 a v2 -- | Two writes to different locations commute, i.e., can be done in any order wcommutesGood :: (Address, Value) -> (Address, Value) -> Memory -> SBool wcommutesGood (a, x) (b, y) m = a ./= b ==> wcommutesBad (a, x) (b, y) m -- | Two writes do not commute if they can be done to the same location wcommutesBad :: (Address, Value) -> (Address, Value) -> Memory -> SBool wcommutesBad (a, x) (b, y) m = writeArray (writeArray m a x) b y .== writeArray (writeArray m b y) a x tests :: IO () tests = do print =<< prove raw print =<< prove waw print =<< prove wcommutesBad print =<< prove wcommutesGood sbv-5.12/SBVUnitTest/Examples/Basics/0000755000000000000000000000000012725411266015543 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/Basics/BasicTests.hs0000644000000000000000000000314112725411266020142 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Basics.BasicTests -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Basic tests of the sbv library ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} module Examples.Basics.BasicTests where import Data.SBV import Data.SBV.Internals import SBVTest test0 :: (forall a. Num a => (a -> a -> a)) -> Word8 test0 f = f (3 :: Word8) 2 test1, test2, test3, test4, test5 :: (forall a. Num a => (a -> a -> a)) -> IO Result test1 f = runSAT $ do let x = literal (3 :: Word8) y = literal (2 :: Word8) output $ f x y test2 f = runSAT $ do let x = literal (3 :: Word8) y :: SWord8 <- forall "y" output $ f x y test3 f = runSAT $ do x :: SWord8 <- forall "x" y :: SWord8 <- forall "y" output $ f x y test4 f = runSAT $ do x :: SWord8 <- forall "x" output $ f x x test5 f = runSAT $ do x :: SWord8 <- forall "x" let r = f x x q :: SWord8 <- forall "q" _ <- output q output r f1, f2, f3, f4, f5 :: Num a => a -> a -> a f1 x y = (x+y)*(x-y) f2 x y = (x*x)-(y*y) f3 x y = (x+y)*(x+y) f4 x y = let z = x + y in z * z f5 x _ = x + 1 {-# ANN f1 "NoHerbie" #-} {-# ANN f2 "NoHerbie" #-} {-# ANN f3 "NoHerbie" #-} sbv-5.12/SBVUnitTest/Examples/Basics/Higher.hs0000644000000000000000000000156312725411266017312 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Basics.Higher -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Testing function equality ----------------------------------------------------------------------------- module Examples.Basics.Higher where import Data.SBV type B = SWord8 f11 :: B -> B f11 x = x f12 :: B -> (B, B) f12 x = (x, x) f21 :: (B, B) -> B f21 (x, y) = x + y f22 :: (B, B) -> (B, B) f22 (x, y) = (x, y) f31 :: B -> B -> B f31 x y = x + y f32 :: B -> B -> (B, B) f32 x y = (x, y) f33 :: B -> B -> B -> (B, B, B) f33 x y z = (x, y, z) t :: IO [ThmResult] t = sequence [ f11 === f11 , f12 === f12 , f21 === f21 , f22 === f22 , f31 === f31 , f32 === f32 , f33 === f33 ] sbv-5.12/SBVUnitTest/Examples/Basics/Index.hs0000644000000000000000000000523312725411266017151 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Basics.Index -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Testing the select function ----------------------------------------------------------------------------- module Examples.Basics.Index where import Data.SBV import SBVTest -- prove that the "select" primitive is working correctly test1 :: Int -> IO Bool test1 n = isThm $ do elts <- mkForallVars n err <- forall_ ind <- forall_ ind2 <- forall_ let r1 = (select :: [SWord8] -> SWord8 -> SInt8 -> SWord8) elts err ind r2 = (select :: [SWord8] -> SWord8 -> SWord8 -> SWord8) elts err ind2 r3 = slowSearch elts err ind r4 = slowSearch elts err ind2 return $ r1 .== r3 &&& r2 .== r4 where slowSearch elts err i = ite (i .< 0) err (go elts i) where go [] _ = err go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1)) test2 :: Int -> IO Bool test2 n = isThm $ do elts1 <- mkForallVars n elts2 <- mkForallVars n let elts = zip elts1 elts2 err1 <- forall_ err2 <- forall_ let err = (err1, err2) ind <- forall_ ind2 <- forall_ let r1 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SInt8 -> (SWord8, SWord8)) elts err ind r2 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SWord8 -> (SWord8, SWord8)) elts err ind2 r3 = slowSearch elts err ind r4 = slowSearch elts err ind2 return $ r1 .== r3 &&& r2 .== r4 where slowSearch elts err i = ite (i .< 0) err (go elts i) where go [] _ = err go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1)) test3 :: Int -> IO Bool test3 n = isThm $ do eltsI <- mkForallVars n let elts = map Left eltsI errI <- forall_ let err = Left errI ind <- forall_ let r1 = (select :: [Either SWord8 SWord8] -> Either SWord8 SWord8 -> SInt8 -> Either SWord8 SWord8) elts err ind r2 = slowSearch elts err ind return $ r1 .== r2 where slowSearch elts err i = ite (i .< 0) err (go elts i) where go [] _ = err go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1)) tests :: IO () tests = do mapM test1 [0..50] >>= print . and mapM test2 [0..50] >>= print . and mapM test3 [0..50] >>= print . and sbv-5.12/SBVUnitTest/Examples/Basics/ProofTests.hs0000644000000000000000000000310112725411266020202 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Basics.ProofTests -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Basic proofs ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ScopedTypeVariables #-} module Examples.Basics.ProofTests where import Data.SBV f1, f2, f3, f4 :: Num a => a -> a -> a f1 x y = (x+y)*(x-y) f2 x y = (x*x)-(y*y) f3 x y = (x+y)*(x+y) f4 x y = x*x + 2*x*y + y*y f1eqf2 :: Predicate f1eqf2 = forAll_ $ \x y -> f1 x y .== f2 x (y :: SWord8) f1eqf3 :: Predicate f1eqf3 = forAll ["x", "y"] $ \x y -> f1 x y .== f3 x (y :: SWord8) f3eqf4 :: Predicate f3eqf4 = forAll_ $ \x y -> f3 x y .== f4 x (y :: SWord8) f1Single :: Predicate f1Single = forAll_ $ \x -> f1 x x .== (0 :: SWord16) queries :: IO () queries = do print =<< prove f1eqf2 -- QED print =<< prove f1eqf3 -- No print =<< prove f3eqf4 -- QED print =<< prove f1Single -- QED print =<< sat (do x <- exists "x" y <- exists "y" return $ f1 x y .== f2 x (y :: SWord8)) -- yes, any output OK print =<< sat (do x <- exists "x" y <- exists "y" return $ f1 x y .== f3 x (y:: SWord8)) -- yes, 0;0 {-# ANN f1 "NoHerbie" #-} {-# ANN f2 "NoHerbie" #-} {-# ANN f3 "NoHerbie" #-} {-# ANN f4 "NoHerbie" #-} sbv-5.12/SBVUnitTest/Examples/Basics/QRem.hs0000644000000000000000000000211312725411266016740 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Basics.QRem -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Testing the sQuotRem and sDivMod ----------------------------------------------------------------------------- module Examples.Basics.QRem where import Data.SBV -- check: if (a, b) = x `quotRem` y then x = y*a + b -- same is also true for divMod -- being careful about y = 0. When divisor is 0, then quotient is -- defined to be 0 and the remainder is the numerator qrem :: (Num a, EqSymbolic a, SDivisible a) => a -> a -> SBool qrem x y = ite (y .== 0) ((0, x) .== (q, r) &&& (0, x) .== (d, m)) (x .== y * q + r &&& x .== y * d + m) where (q, r) = x `sQuotRem` y (d, m) = x `sDivMod` y check :: IO () check = do print =<< prove (qrem :: SWord8 -> SWord8 -> SBool) print =<< prove (qrem :: SInt8 -> SInt8 -> SBool) print =<< prove (qrem :: SInteger -> SInteger -> SBool) sbv-5.12/SBVUnitTest/Examples/CRC/0000755000000000000000000000000012725411266014746 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/CRC/CCITT.hs0000644000000000000000000000445012725411266016153 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.CRC.CCITT -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- CRC checks, hamming distance, etc. ----------------------------------------------------------------------------- module Examples.CRC.CCITT where import Data.SBV -- We don't have native support for 48 bits in Data.SBV -- So, represent as 32 high-bits and 16 low type SWord48 = (SWord32, SWord16) extendData :: SWord48 -> SWord64 extendData (h, l) = h # l # 0 mkFrame :: SWord48 -> SWord64 mkFrame msg@(h, l) = h # l # crc_48_16 msg crc_48_16 :: SWord48 -> SWord16 crc_48_16 msg = res where msg64, divisor :: SWord64 msg64 = extendData msg divisor = polynomial [16, 12, 5, 0] crc64 = pMod msg64 divisor (_, res) = split (snd (split crc64)) diffCount :: SWord64 -> SWord64 -> SWord8 diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y) where count [] = 0 count (b:bs) = let r = count bs in ite b r (1+r) -- Claim: If there is an undetected corruption, it must be at least at 4 bits; i.e. HD is 4 crcGood :: SWord48 -> SWord48 -> SBool crcGood sent received = sent ./= received ==> diffCount frameSent frameReceived .> 3 where frameSent = mkFrame sent frameReceived = mkFrame received -- How come we get way more than 168 (= 2*84) counter-examples for this? hw4has84Inhabitants :: SWord48 -> SWord48 -> SBool hw4has84Inhabitants sent received = fourBitError where frameSent = mkFrame sent frameReceived = mkFrame received fourBitError = diffCount frameSent frameReceived .== 4 hw4 :: IO () hw4 = do res <- allSat hw4has84Inhabitants cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " solution(s)." where disp :: Int -> (Bool, (Word32, Word16, Word32, Word16)) -> IO () disp i (_, (sh, sl, rh, rl)) = do putStrLn $ "Solution #" ++ show i ++ ": " putStrLn $ " Sent : " ++ binS (mkFrame (literal sh, literal sl)) putStrLn $ " Received: " ++ binS (mkFrame (literal rh, literal rl)) {-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/SBVUnitTest/Examples/CRC/CCITT_Unidir.hs0000644000000000000000000000372012725411266017464 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.CRC.CCITT_Unidir -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Similar to CCITT. It shows that the CCITT is still HD 3 -- even if we consider only uni-directional errors ----------------------------------------------------------------------------- module Examples.CRC.CCITT_Unidir where import Data.SBV -- We don't have native support for 48 bits in Data.SBV -- So, represent as 32 high-bits and 16 low type SWord48 = (SWord32, SWord16) extendData :: SWord48 -> SWord64 extendData (h, l) = h # l # 0 mkFrame :: SWord48 -> SWord64 mkFrame msg@(h, l) = h # l # crc_48_16 msg crc_48_16 :: SWord48 -> SWord16 crc_48_16 msg = res where msg64, divisor :: SWord64 msg64 = extendData msg divisor = polynomial [16, 12, 5, 0] crc64 = pMod msg64 divisor (_, res) = split (snd (split crc64)) diffCount :: [SBool] -> [SBool] -> SWord8 diffCount xs ys = count $ zipWith (.==) xs ys where count [] = 0 count (b:bs) = let r = count bs in ite b r (1+r) -- returns true if there's a 0->1 error (1->0 is ok) nonUnidir :: [SBool] -> [SBool] -> SBool nonUnidir [] _ = false nonUnidir _ [] = false nonUnidir (a:as) (b:bs) = (bnot a &&& b) ||| nonUnidir as bs crcUniGood :: SWord8 -> SWord48 -> SWord48 -> SBool crcUniGood hd sent received = sent ./= received ==> nonUnidir frameSent frameReceived ||| diffCount frameSent frameReceived .> hd where frameSent = blastLE $ mkFrame sent frameReceived = blastLE $ mkFrame received -- Provable, i.e., HD is 3 ccitHDis3 :: IO () ccitHDis3 = print =<< prove (crcUniGood 3) -- False; i.e., HD doesn't go to 4 just because we only look at uni-directional errors ccitHDis4 :: IO () ccitHDis4 = print =<< prove (crcUniGood 4) {-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/SBVUnitTest/Examples/CRC/GenPoly.hs0000644000000000000000000000573512725411266016671 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.CRC.GenPoly -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Finds good polynomials for CRC's ----------------------------------------------------------------------------- module Examples.CRC.GenPoly where import Data.SBV -- We don't have native support for 48 bits in Data.SBV -- So, represent as 32 high-bits and 16 low type SWord48 = (SWord32, SWord16) extendData :: SWord48 -> SWord64 extendData (h, l) = h # l # 0 mkFrame :: SWord64 -> SWord48 -> SWord64 mkFrame poly msg@(h, l) = h # l # crc_48_16 msg poly crc_48_16 :: SWord48 -> SWord64 -> SWord16 crc_48_16 msg poly = res where msg64 = extendData msg crc64 = pMod msg64 poly (_, res) = split (snd (split crc64)) diffCount :: SWord64 -> SWord64 -> SWord8 diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y) where count [] = 0 count (b:bs) = let r = count bs in ite b r (1+r) crcGood :: SWord8 -> SWord16 -> SWord48 -> SWord48 -> SBool crcGood hd divisor sent received = sent ./= received ==> diffCount frameSent frameReceived .> hd where frameSent = mkFrame poly sent frameReceived = mkFrame poly received poly = mkPoly divisor mkPoly :: SWord16 -> SWord64 mkPoly d = 0 # 1 # d -- how long do we wait for each poly.. (seconds) waitFor :: Int waitFor = 15 genPoly :: SWord8 -> IO () genPoly hd = do putStrLn $ "*** Looking for polynomials with HD = " ++ show hd (skipped, res) <- go 0 [] [] putStrLn $ "*** Good polynomials with HD = " ++ show hd mapM_ (\(i, s) -> putStrLn (show i ++ ". " ++ showPoly (mkPoly s))) (zip [(1::Integer)..] res) putStrLn $ "*** Skipped the followings, proof exceeded timeout value of " ++ show waitFor mapM_ (\(i, s) -> putStrLn (show i ++ ". " ++ showPoly (mkPoly s))) (zip [(1::Integer)..] skipped) putStrLn "*** Done." where go :: SWord16 -> [SWord16] -> [SWord16] -> IO ([SWord16], [SWord16]) go poly skip acc | poly == maxBound = return (skip, acc) | True = do putStr $ "Testing " ++ showPoly (mkPoly poly) ++ "... " thm <- isTheorem (Just waitFor) $ crcGood hd poly case thm of Nothing -> do putStrLn "Timeout, skipping.." go (poly+1) (poly:skip) acc Just True -> do putStrLn "Good!" go (poly+1) skip (poly:acc) Just False -> do putStrLn "Bad!" go (poly+1) skip acc findHD3Polynomials :: IO () findHD3Polynomials = genPoly 3 {-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/SBVUnitTest/Examples/CRC/Parity.hs0000644000000000000000000000172712725411266016561 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.CRC.Parity -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Parity check as CRC's ----------------------------------------------------------------------------- module Examples.CRC.Parity where import Data.SBV parity :: SWord64 -> SBool parity x = bnot (isOdd cnt) where cnt :: SWord8 cnt = count (blastLE x) isOdd :: SWord8 -> SBool isOdd x = lsb x .== true -- count the true bits count :: [SBool] -> SWord8 count [] = 0 count (x:xs) = let c' = count xs in ite x (1+c') c' -- Example suggested by Lee Pike -- If x and y differ in odd-number of bits, then their parities are flipped parityOK :: SWord64 -> SWord64 -> SBool parityOK x y = isOdd cnt ==> px .== bnot py where cnt = count (zipWith (./=) (blastLE x) (blastLE y)) px = parity x py = parity y sbv-5.12/SBVUnitTest/Examples/CRC/USB5.hs0000644000000000000000000000306212725411266016021 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.CRC.USB5 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- The USB5 CRC implementation ----------------------------------------------------------------------------- module Examples.CRC.USB5 where import Data.SBV newtype SWord11 = S11 SWord16 instance EqSymbolic SWord11 where S11 w .== S11 w' = w .== w' mkSWord11 :: SWord16 -> SWord11 mkSWord11 w = S11 (w .&. 0x07FF) extendData :: SWord11 -> SWord16 extendData (S11 w) = w `shiftL` 5 mkFrame :: SWord11 -> SWord16 mkFrame w = extendData w .|. crc_11_16 w -- crc returns 16 bits, but the first 11 are always 0 crc_11_16 :: SWord11 -> SWord16 crc_11_16 msg = crc16 .&. 0x1F -- just get the last 5 bits where divisor :: SWord16 divisor = polynomial [5, 2, 0] crc16 = pMod (extendData msg) divisor diffCount :: SWord16 -> SWord16 -> SWord8 diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y) where count [] = 0 count (b:bs) = let r = count bs in ite b r (1+r) -- Claim: If there is an undetected corruption, it must be at least at 3 bits usbGood :: SWord16 -> SWord16 -> SBool usbGood sent16 received16 = sent ./= received ==> diffCount frameSent frameReceived .>= 3 where sent = mkSWord11 sent16 received = mkSWord11 received16 frameSent = mkFrame sent frameReceived = mkFrame received {-# ANN crc_11_16 ("HLint: ignore Use camelCase" :: String) #-} sbv-5.12/SBVUnitTest/Examples/Puzzles/0000755000000000000000000000000012725411266016013 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/Puzzles/PowerSet.hs0000644000000000000000000000253712725411266020126 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Puzzles.PowerSet -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Computes the powerset of a givenset ----------------------------------------------------------------------------- module Examples.Puzzles.PowerSet where import Data.SBV genPowerSet :: [SBool] -> SBool -- The following definition reveals an issue in Yices's model generation. The -- seemingly vacuous test of checking true-or-false is necessary -- so that Yices will return a satisfying assignment -- otherwise, it just skips the "unused" inputs.. genPowerSet = bAll isBool where isBool x = x .== true ||| x .== false powerSet :: [Word8] -> IO () powerSet xs = do putStrLn $ "Finding all subsets of " ++ show xs res <- allSat $ genPowerSet `fmap` mkExistVars n cnt <- displayModels disp res putStrLn $ "Found: " ++ show cnt ++ " subset(s)." where n = length xs disp i (_, ss) | length ss /= n = error $ "Expected " ++ show n ++ " results; got: " ++ show (length ss) | True = putStrLn $ "Subset #" ++ show i ++ ": " ++ show (concat (zipWith pick ss xs)) pick True a = [a] pick False _ = [] sbv-5.12/SBVUnitTest/Examples/Puzzles/Temperature.hs0000644000000000000000000000262512725411266020651 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Puzzles.Temperature -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Puzzle: -- What 2 digit fahrenheit/celcius values are reverses of each other? -- Ignoring the fractions in the conversion ----------------------------------------------------------------------------- module Examples.Puzzles.Temperature where import Data.SBV type Temp = SInteger -- convert celcius to fahrenheit, rounding up/down properly -- we have to be careful here to make sure rounding is done properly.. d2f :: Temp -> Temp d2f d = 32 + ite (fr .>= 5) (1+fi) fi where (fi, fr) = (18 * d) `sQuotRem` 10 -- puzzle: What 2 digit fahrenheit/celcius values are reverses of each other? revOf :: Temp -> SBool revOf c = swap (digits c) .== digits (d2f c) where digits x = x `sQuotRem` 10 swap (a, b) = (b, a) puzzle :: IO () puzzle = do res <- allSat $ revOf `fmap` exists_ cnt <- displayModels disp res putStrLn $ "Found " ++ show cnt ++ " solutions." where disp :: Int -> (Bool, Integer) -> IO () disp _ (_, x) = putStrLn $ " " ++ show x ++ "C --> " ++ show (round f :: Integer) ++ "F (exact value: " ++ show f ++ "F)" where f :: Double f = 32 + (9 * fromIntegral x) / 5 sbv-5.12/SBVUnitTest/Examples/Uninterpreted/0000755000000000000000000000000012725411266017167 5ustar0000000000000000sbv-5.12/SBVUnitTest/Examples/Uninterpreted/Uninterpreted.hs0000644000000000000000000000144612725411266022360 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.Uninterpreted.Uninterpreted -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Testing uninterpreted functions ----------------------------------------------------------------------------- module Examples.Uninterpreted.Uninterpreted where import Data.SBV f :: SInt8 -> SWord32 f = uninterpret "f" g :: SInt8 -> SWord16 -> SWord32 g = uninterpret "g" p0 :: SInt8 -> SInt8 -> SBool p0 x y = x .== y ==> f x .== f y -- OK p1 :: SInt8 -> SWord16 -> SWord16 -> SBool p1 x y z = y .== z ==> g x y .== g x z -- OK p2 :: SInt8 -> SWord16 -> SWord16 -> SBool p2 x y z = y .== z ==> g x y .== f x -- Not true sbv-5.12/SBVUnitTest/GoldFiles/0000755000000000000000000000000012725411266014431 5ustar0000000000000000sbv-5.12/SBVUnitTest/GoldFiles/addSub.gold0000644000000000000000000000435212725411266016506 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for addSub. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: addSub_driver addSub.o: addSub.c addSub.h ${CC} ${CCFLAGS} -c $< -o $@ addSub_driver.o: addSub_driver.c ${CC} ${CCFLAGS} -c $< -o $@ addSub_driver: addSub.o addSub_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f addSub_driver == END: "Makefile" ================== == BEGIN: "addSub.h" ================ /* Header file for addSub. Automatically generated by SBV. Do not edit! */ #ifndef __addSub__HEADER_INCLUDED__ #define __addSub__HEADER_INCLUDED__ #include #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 addSub(const SWord8 x, const SWord8 y, SWord8 *sum, SWord8 *dif); #endif /* __addSub__HEADER_INCLUDED__ */ == END: "addSub.h" ================== == BEGIN: "addSub_driver.c" ================ /* Example driver program for addSub. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "addSub.h" int main(void) { SWord8 sum; SWord8 dif; addSub(76, 92, &sum, &dif); printf("addSub(76, 92, &sum, &dif) ->\n"); printf(" sum = %"PRIu8"\n", sum); printf(" dif = %"PRIu8"\n", dif); return 0; } == END: "addSub_driver.c" ================== == BEGIN: "addSub.c" ================ /* File: "addSub.c". Automatically generated by SBV. Do not edit! */ #include "addSub.h" void addSub(const SWord8 x, const SWord8 y, SWord8 *sum, SWord8 *dif) { const SWord8 s0 = x; const SWord8 s1 = y; const SWord8 s2 = s0 + s1; const SWord8 s3 = s0 - s1; *sum = s2; *dif = s3; } == END: "addSub.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/aes128Dec.gold0000644000000000000000000034223012725411266016723 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for aes128Dec. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: aes128Dec_driver aes128Dec.o: aes128Dec.c aes128Dec.h ${CC} ${CCFLAGS} -c $< -o $@ aes128Dec_driver.o: aes128Dec_driver.c ${CC} ${CCFLAGS} -c $< -o $@ aes128Dec_driver: aes128Dec.o aes128Dec_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f aes128Dec_driver == END: "Makefile" ================== == BEGIN: "aes128Dec.h" ================ /* Header file for aes128Dec. Automatically generated by SBV. Do not edit! */ #ifndef __aes128Dec__HEADER_INCLUDED__ #define __aes128Dec__HEADER_INCLUDED__ #include #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[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]); const SWord32 key[4] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array key:\n"); int key_ctr; for(key_ctr = 0; key_ctr < 4 ; ++key_ctr) printf(" key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]); SWord32 ct[4]; aes128Dec(pt, key, ct); printf("aes128Dec(pt, key, ct) ->\n"); int ct_ctr; for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr) printf(" ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); return 0; } == END: "aes128Dec_driver.c" ================== == BEGIN: "aes128Dec.c" ================ /* File: "aes128Dec.c". Automatically generated by SBV. Do not edit! */ #include "aes128Dec.h" void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct) { const SWord32 s0 = pt[0]; const SWord32 s1 = pt[1]; const SWord32 s2 = pt[2]; const SWord32 s3 = pt[3]; const SWord32 s4 = key[0]; const SWord32 s5 = key[1]; const SWord32 s6 = key[2]; const SWord32 s7 = key[3]; static const SWord8 table0[] = { 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125 }; static const SWord32 table1[] = { 0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL, 0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL, 0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL, 0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL, 0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL, 0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL, 0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL, 0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL, 0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL, 0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL, 0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL, 0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL, 0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL, 0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL, 0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL, 0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL, 0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL, 0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL, 0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL, 0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL, 0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL, 0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL, 0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL, 0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL, 0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL, 0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL, 0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL, 0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL, 0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL, 0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL, 0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL, 0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL, 0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL, 0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL, 0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL, 0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL, 0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL, 0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL, 0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL, 0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL, 0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL, 0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL, 0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL, 0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL, 0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL, 0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL, 0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL, 0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL, 0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL, 0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL, 0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL, 0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL, 0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL, 0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL, 0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL, 0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL, 0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL, 0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL, 0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL, 0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL, 0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL, 0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL, 0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL, 0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL }; static const SWord8 table2[] = { 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22 }; static const SWord32 table3[] = { 0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL, 0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL, 0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL, 0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL, 0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL, 0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL, 0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL, 0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL, 0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL, 0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL, 0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL, 0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL, 0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL, 0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL, 0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL, 0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL, 0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL, 0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL, 0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL, 0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL, 0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL, 0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL, 0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL, 0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL, 0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL, 0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL, 0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL, 0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL, 0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL, 0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL, 0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL, 0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL, 0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL, 0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL, 0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL, 0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL, 0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL, 0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL, 0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL, 0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL, 0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL, 0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL, 0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL, 0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL, 0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL, 0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL, 0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL, 0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL, 0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL, 0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL, 0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL, 0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL, 0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL, 0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL, 0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL, 0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL, 0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL, 0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL, 0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL, 0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL, 0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL, 0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL, 0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL, 0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL }; static const SWord32 table4[] = { 0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL, 0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL, 0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL, 0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL, 0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL, 0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL, 0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL, 0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL, 0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL, 0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL, 0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL, 0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL, 0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL, 0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL, 0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL, 0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL, 0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL, 0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL, 0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL, 0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL, 0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL, 0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL, 0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL, 0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL, 0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL, 0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL, 0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL, 0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL, 0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL, 0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL, 0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL, 0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL, 0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL, 0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL, 0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL, 0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL, 0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL, 0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL, 0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL, 0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL, 0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL, 0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL, 0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL, 0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL, 0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL, 0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL, 0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL, 0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL, 0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL, 0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL, 0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL, 0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL, 0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL, 0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL, 0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL, 0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL, 0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL, 0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL, 0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL, 0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL, 0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL, 0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL, 0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL, 0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL }; static const SWord32 table5[] = { 0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL, 0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL, 0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL, 0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL, 0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL, 0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL, 0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL, 0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL, 0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL, 0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL, 0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL, 0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL, 0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL, 0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL, 0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL, 0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL, 0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL, 0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL, 0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL, 0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL, 0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL, 0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL, 0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL, 0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL, 0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL, 0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL, 0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL, 0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL, 0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL, 0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL, 0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL, 0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL, 0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL, 0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL, 0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL, 0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL, 0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL, 0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL, 0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL, 0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL, 0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL, 0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL, 0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL, 0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL, 0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL, 0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL, 0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL, 0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL, 0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL, 0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL, 0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL, 0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL, 0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL, 0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL, 0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL, 0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL, 0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL, 0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL, 0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL, 0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL, 0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL, 0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL, 0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL, 0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL }; static const SWord8 table6[] = { 0, 14, 28, 18, 56, 54, 36, 42, 112, 126, 108, 98, 72, 70, 84, 90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158, 140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255, 241, 171, 165, 183, 185, 147, 157, 143, 129, 59, 53, 39, 41, 3, 13, 31, 17, 75, 69, 87, 89, 115, 125, 111, 97, 173, 163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235, 249, 247, 77, 67, 81, 95, 117, 123, 105, 103, 61, 51, 33, 47, 5, 11, 25, 23, 118, 120, 106, 100, 78, 64, 82, 92, 6, 8, 26, 20, 62, 48, 34, 44, 150, 152, 138, 132, 174, 160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204, 65, 79, 93, 83, 121, 119, 101, 107, 49, 63, 45, 35, 9, 7, 21, 27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195, 233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234, 228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104, 66, 76, 94, 80, 10, 4, 22, 24, 50, 60, 46, 32, 236, 226, 240, 254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182, 12, 2, 16, 30, 52, 58, 40, 38, 124, 114, 96, 110, 68, 74, 88, 86, 55, 57, 43, 37, 15, 1, 19, 29, 71, 73, 91, 85, 127, 113, 99, 109, 215, 217, 203, 197, 239, 225, 243, 253, 167, 169, 187, 181, 159, 145, 131, 141 }; static const SWord8 table7[] = { 0, 11, 22, 29, 44, 39, 58, 49, 88, 83, 78, 69, 116, 127, 98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227, 254, 245, 196, 207, 210, 217, 123, 112, 109, 102, 87, 92, 65, 74, 35, 40, 53, 62, 15, 4, 25, 18, 203, 192, 221, 214, 231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246, 253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137, 148, 159, 70, 77, 80, 91, 106, 97, 124, 119, 30, 21, 8, 3, 50, 57, 36, 47, 141, 134, 155, 144, 161, 170, 183, 188, 213, 222, 195, 200, 249, 242, 239, 228, 61, 54, 43, 32, 17, 26, 7, 12, 101, 110, 115, 120, 73, 66, 95, 84, 247, 252, 225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149, 158, 71, 76, 81, 90, 107, 96, 125, 118, 31, 20, 9, 2, 51, 56, 37, 46, 140, 135, 154, 145, 160, 171, 182, 189, 212, 223, 194, 201, 248, 243, 238, 229, 60, 55, 42, 33, 16, 27, 6, 13, 100, 111, 114, 121, 72, 67, 94, 85, 1, 10, 23, 28, 45, 38, 59, 48, 89, 82, 79, 68, 117, 126, 99, 104, 177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197, 206, 211, 216, 122, 113, 108, 103, 86, 93, 64, 75, 34, 41, 52, 63, 14, 5, 24, 19, 202, 193, 220, 215, 230, 237, 240, 251, 146, 153, 132, 143, 190, 181, 168, 163 }; static const SWord8 table8[] = { 0, 13, 26, 23, 52, 57, 46, 35, 104, 101, 114, 127, 92, 81, 70, 75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181, 162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149, 152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124, 95, 82, 69, 72, 3, 14, 25, 20, 55, 58, 45, 32, 109, 96, 119, 122, 89, 84, 67, 78, 5, 8, 31, 18, 49, 60, 43, 38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207, 194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245, 190, 179, 164, 169, 138, 135, 144, 157, 6, 11, 28, 17, 50, 63, 40, 37, 110, 99, 116, 121, 90, 87, 64, 77, 218, 215, 192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156, 145, 10, 7, 16, 29, 62, 51, 36, 41, 98, 111, 120, 117, 86, 91, 76, 65, 97, 108, 123, 118, 85, 88, 79, 66, 9, 4, 19, 30, 61, 48, 39, 42, 177, 188, 171, 166, 133, 136, 159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173, 160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252, 103, 106, 125, 112, 83, 94, 73, 68, 15, 2, 21, 24, 59, 54, 33, 44, 12, 1, 22, 27, 56, 53, 34, 47, 100, 105, 126, 115, 80, 93, 74, 71, 220, 209, 198, 203, 232, 229, 242, 255, 180, 185, 174, 163, 128, 141, 154, 151 }; static const SWord8 table9[] = { 0, 9, 18, 27, 36, 45, 54, 63, 72, 65, 90, 83, 108, 101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209, 202, 195, 252, 245, 238, 231, 59, 50, 41, 32, 31, 22, 13, 4, 115, 122, 97, 104, 87, 94, 69, 76, 171, 162, 185, 176, 143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118, 127, 100, 109, 82, 91, 64, 73, 62, 55, 44, 37, 26, 19, 8, 1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188, 181, 138, 131, 152, 145, 77, 68, 95, 86, 105, 96, 123, 114, 5, 12, 23, 30, 33, 40, 51, 58, 221, 212, 207, 198, 249, 240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229, 254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146, 155, 124, 117, 110, 103, 88, 81, 74, 67, 52, 61, 38, 47, 16, 25, 2, 11, 215, 222, 197, 204, 243, 250, 225, 232, 159, 150, 141, 132, 187, 178, 169, 160, 71, 78, 85, 92, 99, 106, 113, 120, 15, 6, 29, 20, 43, 34, 57, 48, 154, 147, 136, 129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237, 10, 3, 24, 17, 46, 39, 60, 53, 66, 75, 80, 89, 102, 111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224, 251, 242, 205, 196, 223, 214, 49, 56, 35, 42, 21, 28, 7, 14, 121, 112, 107, 98, 93, 84, 79, 70 }; const SWord32 s520 = (s7 << 8) | (s7 >> 24); const SWord16 s521 = (SWord16) (s520 >> 16); const SWord8 s522 = (SWord8) (s521 >> 8); const SWord8 s523 = table2[s522]; const SWord8 s524 = 1 ^ s523; const SWord8 s525 = (SWord8) s521; const SWord8 s526 = table2[s525]; const SWord16 s527 = (((SWord16) s524) << 8) | ((SWord16) s526); const SWord16 s528 = (SWord16) s520; const SWord8 s529 = (SWord8) (s528 >> 8); const SWord8 s530 = table2[s529]; const SWord8 s531 = (SWord8) s528; const SWord8 s532 = table2[s531]; const SWord16 s533 = (((SWord16) s530) << 8) | ((SWord16) s532); const SWord32 s534 = (((SWord32) s527) << 16) | ((SWord32) s533); const SWord32 s535 = s4 ^ s534; const SWord32 s536 = s5 ^ s535; const SWord32 s537 = s6 ^ s536; const SWord32 s538 = s7 ^ s537; const SWord32 s539 = (s538 << 8) | (s538 >> 24); const SWord16 s540 = (SWord16) (s539 >> 16); const SWord8 s541 = (SWord8) (s540 >> 8); const SWord8 s542 = table2[s541]; const SWord8 s543 = 2 ^ s542; const SWord8 s544 = (SWord8) s540; const SWord8 s545 = table2[s544]; const SWord16 s546 = (((SWord16) s543) << 8) | ((SWord16) s545); const SWord16 s547 = (SWord16) s539; const SWord8 s548 = (SWord8) (s547 >> 8); const SWord8 s549 = table2[s548]; const SWord8 s550 = (SWord8) s547; const SWord8 s551 = table2[s550]; const SWord16 s552 = (((SWord16) s549) << 8) | ((SWord16) s551); const SWord32 s553 = (((SWord32) s546) << 16) | ((SWord32) s552); const SWord32 s554 = s535 ^ s553; const SWord32 s555 = s536 ^ s554; const SWord32 s556 = s537 ^ s555; const SWord32 s557 = s538 ^ s556; const SWord32 s558 = (s557 << 8) | (s557 >> 24); const SWord16 s559 = (SWord16) (s558 >> 16); const SWord8 s560 = (SWord8) (s559 >> 8); const SWord8 s561 = table2[s560]; const SWord8 s562 = 4 ^ s561; const SWord8 s563 = (SWord8) s559; const SWord8 s564 = table2[s563]; const SWord16 s565 = (((SWord16) s562) << 8) | ((SWord16) s564); const SWord16 s566 = (SWord16) s558; const SWord8 s567 = (SWord8) (s566 >> 8); const SWord8 s568 = table2[s567]; const SWord8 s569 = (SWord8) s566; const SWord8 s570 = table2[s569]; const SWord16 s571 = (((SWord16) s568) << 8) | ((SWord16) s570); const SWord32 s572 = (((SWord32) s565) << 16) | ((SWord32) s571); const SWord32 s573 = s554 ^ s572; const SWord32 s574 = s555 ^ s573; const SWord32 s575 = s556 ^ s574; const SWord32 s576 = s557 ^ s575; const SWord32 s577 = (s576 << 8) | (s576 >> 24); const SWord16 s578 = (SWord16) (s577 >> 16); const SWord8 s579 = (SWord8) (s578 >> 8); const SWord8 s580 = table2[s579]; const SWord8 s581 = 8 ^ s580; const SWord8 s582 = (SWord8) s578; const SWord8 s583 = table2[s582]; const SWord16 s584 = (((SWord16) s581) << 8) | ((SWord16) s583); const SWord16 s585 = (SWord16) s577; const SWord8 s586 = (SWord8) (s585 >> 8); const SWord8 s587 = table2[s586]; const SWord8 s588 = (SWord8) s585; const SWord8 s589 = table2[s588]; const SWord16 s590 = (((SWord16) s587) << 8) | ((SWord16) s589); const SWord32 s591 = (((SWord32) s584) << 16) | ((SWord32) s590); const SWord32 s592 = s573 ^ s591; const SWord32 s593 = s574 ^ s592; const SWord32 s594 = s575 ^ s593; const SWord32 s595 = s576 ^ s594; const SWord32 s596 = (s595 << 8) | (s595 >> 24); const SWord16 s597 = (SWord16) (s596 >> 16); const SWord8 s598 = (SWord8) (s597 >> 8); const SWord8 s599 = table2[s598]; const SWord8 s600 = 16 ^ s599; const SWord8 s601 = (SWord8) s597; const SWord8 s602 = table2[s601]; const SWord16 s603 = (((SWord16) s600) << 8) | ((SWord16) s602); const SWord16 s604 = (SWord16) s596; const SWord8 s605 = (SWord8) (s604 >> 8); const SWord8 s606 = table2[s605]; const SWord8 s607 = (SWord8) s604; const SWord8 s608 = table2[s607]; const SWord16 s609 = (((SWord16) s606) << 8) | ((SWord16) s608); const SWord32 s610 = (((SWord32) s603) << 16) | ((SWord32) s609); const SWord32 s611 = s592 ^ s610; const SWord32 s612 = s593 ^ s611; const SWord32 s613 = s594 ^ s612; const SWord32 s614 = s595 ^ s613; const SWord32 s615 = (s614 << 8) | (s614 >> 24); const SWord16 s616 = (SWord16) (s615 >> 16); const SWord8 s617 = (SWord8) (s616 >> 8); const SWord8 s618 = table2[s617]; const SWord8 s619 = 32 ^ s618; const SWord8 s620 = (SWord8) s616; const SWord8 s621 = table2[s620]; const SWord16 s622 = (((SWord16) s619) << 8) | ((SWord16) s621); const SWord16 s623 = (SWord16) s615; const SWord8 s624 = (SWord8) (s623 >> 8); const SWord8 s625 = table2[s624]; const SWord8 s626 = (SWord8) s623; const SWord8 s627 = table2[s626]; const SWord16 s628 = (((SWord16) s625) << 8) | ((SWord16) s627); const SWord32 s629 = (((SWord32) s622) << 16) | ((SWord32) s628); const SWord32 s630 = s611 ^ s629; const SWord32 s631 = s612 ^ s630; const SWord32 s632 = s613 ^ s631; const SWord32 s633 = s614 ^ s632; const SWord32 s634 = (s633 << 8) | (s633 >> 24); const SWord16 s635 = (SWord16) (s634 >> 16); const SWord8 s636 = (SWord8) (s635 >> 8); const SWord8 s637 = table2[s636]; const SWord8 s638 = 64 ^ s637; const SWord8 s639 = (SWord8) s635; const SWord8 s640 = table2[s639]; const SWord16 s641 = (((SWord16) s638) << 8) | ((SWord16) s640); const SWord16 s642 = (SWord16) s634; const SWord8 s643 = (SWord8) (s642 >> 8); const SWord8 s644 = table2[s643]; const SWord8 s645 = (SWord8) s642; const SWord8 s646 = table2[s645]; const SWord16 s647 = (((SWord16) s644) << 8) | ((SWord16) s646); const SWord32 s648 = (((SWord32) s641) << 16) | ((SWord32) s647); const SWord32 s649 = s630 ^ s648; const SWord32 s650 = s631 ^ s649; const SWord32 s651 = s632 ^ s650; const SWord32 s652 = s633 ^ s651; const SWord32 s653 = (s652 << 8) | (s652 >> 24); const SWord16 s654 = (SWord16) (s653 >> 16); const SWord8 s655 = (SWord8) (s654 >> 8); const SWord8 s656 = table2[s655]; const SWord8 s657 = 128 ^ s656; const SWord8 s658 = (SWord8) s654; const SWord8 s659 = table2[s658]; const SWord16 s660 = (((SWord16) s657) << 8) | ((SWord16) s659); const SWord16 s661 = (SWord16) s653; const SWord8 s662 = (SWord8) (s661 >> 8); const SWord8 s663 = table2[s662]; const SWord8 s664 = (SWord8) s661; const SWord8 s665 = table2[s664]; const SWord16 s666 = (((SWord16) s663) << 8) | ((SWord16) s665); const SWord32 s667 = (((SWord32) s660) << 16) | ((SWord32) s666); const SWord32 s668 = s649 ^ s667; const SWord32 s669 = s650 ^ s668; const SWord32 s670 = s651 ^ s669; const SWord32 s671 = s652 ^ s670; const SWord32 s672 = (s671 << 8) | (s671 >> 24); const SWord16 s673 = (SWord16) (s672 >> 16); const SWord8 s674 = (SWord8) (s673 >> 8); const SWord8 s675 = table2[s674]; const SWord8 s676 = 27 ^ s675; const SWord8 s677 = (SWord8) s673; const SWord8 s678 = table2[s677]; const SWord16 s679 = (((SWord16) s676) << 8) | ((SWord16) s678); const SWord16 s680 = (SWord16) s672; const SWord8 s681 = (SWord8) (s680 >> 8); const SWord8 s682 = table2[s681]; const SWord8 s683 = (SWord8) s680; const SWord8 s684 = table2[s683]; const SWord16 s685 = (((SWord16) s682) << 8) | ((SWord16) s684); const SWord32 s686 = (((SWord32) s679) << 16) | ((SWord32) s685); const SWord32 s687 = s668 ^ s686; const SWord32 s688 = s669 ^ s687; const SWord32 s689 = s670 ^ s688; const SWord32 s690 = s671 ^ s689; const SWord32 s691 = (s690 << 8) | (s690 >> 24); const SWord16 s692 = (SWord16) (s691 >> 16); const SWord8 s693 = (SWord8) (s692 >> 8); const SWord8 s694 = table2[s693]; const SWord8 s695 = 54 ^ s694; const SWord8 s696 = (SWord8) s692; const SWord8 s697 = table2[s696]; const SWord16 s698 = (((SWord16) s695) << 8) | ((SWord16) s697); const SWord16 s699 = (SWord16) s691; const SWord8 s700 = (SWord8) (s699 >> 8); const SWord8 s701 = table2[s700]; const SWord8 s702 = (SWord8) s699; const SWord8 s703 = table2[s702]; const SWord16 s704 = (((SWord16) s701) << 8) | ((SWord16) s703); const SWord32 s705 = (((SWord32) s698) << 16) | ((SWord32) s704); const SWord32 s706 = s687 ^ s705; const SWord32 s707 = s0 ^ s706; const SWord16 s708 = (SWord16) (s707 >> 16); const SWord8 s709 = (SWord8) (s708 >> 8); const SWord32 s710 = table1[s709]; const SWord32 s966 = s688 ^ s706; const SWord32 s967 = s689 ^ s966; const SWord32 s968 = s690 ^ s967; const SWord32 s969 = s3 ^ s968; const SWord16 s970 = (SWord16) (s969 >> 16); const SWord8 s971 = (SWord8) s970; const SWord32 s972 = table3[s971]; const SWord32 s973 = s710 ^ s972; const SWord32 s1229 = s2 ^ s967; const SWord16 s1230 = (SWord16) s1229; const SWord8 s1231 = (SWord8) (s1230 >> 8); const SWord32 s1232 = table4[s1231]; const SWord32 s1233 = s973 ^ s1232; const SWord32 s1489 = s1 ^ s966; const SWord16 s1490 = (SWord16) s1489; const SWord8 s1491 = (SWord8) s1490; const SWord32 s1492 = table5[s1491]; const SWord32 s1493 = s1233 ^ s1492; const SWord16 s1494 = (SWord16) (s687 >> 16); const SWord8 s1495 = (SWord8) (s1494 >> 8); const SWord8 s1496 = table6[s1495]; const SWord8 s1497 = (SWord8) s1494; const SWord8 s1498 = table7[s1497]; const SWord16 s1499 = (SWord16) s687; const SWord8 s1500 = (SWord8) (s1499 >> 8); const SWord8 s1501 = table8[s1500]; const SWord8 s1502 = (SWord8) s1499; const SWord8 s1503 = table9[s1502]; const SWord8 s1504 = s1501 ^ s1503; const SWord8 s1505 = s1498 ^ s1504; const SWord8 s1506 = s1496 ^ s1505; const SWord8 s1507 = table9[s1495]; const SWord8 s1508 = table6[s1497]; const SWord8 s1509 = table7[s1500]; const SWord8 s1510 = table8[s1502]; const SWord8 s1511 = s1509 ^ s1510; const SWord8 s1512 = s1508 ^ s1511; const SWord8 s1513 = s1507 ^ s1512; const SWord16 s1514 = (((SWord16) s1506) << 8) | ((SWord16) s1513); const SWord8 s1515 = table8[s1495]; const SWord8 s1516 = table9[s1497]; const SWord8 s1517 = table6[s1500]; const SWord8 s1518 = table7[s1502]; const SWord8 s1519 = s1517 ^ s1518; const SWord8 s1520 = s1516 ^ s1519; const SWord8 s1521 = s1515 ^ s1520; const SWord8 s1522 = table7[s1495]; const SWord8 s1523 = table8[s1497]; const SWord8 s1524 = table9[s1500]; const SWord8 s1525 = table6[s1502]; const SWord8 s1526 = s1524 ^ s1525; const SWord8 s1527 = s1523 ^ s1526; const SWord8 s1528 = s1522 ^ s1527; const SWord16 s1529 = (((SWord16) s1521) << 8) | ((SWord16) s1528); const SWord32 s1530 = (((SWord32) s1514) << 16) | ((SWord32) s1529); const SWord32 s1531 = s1493 ^ s1530; const SWord16 s1532 = (SWord16) (s1531 >> 16); const SWord8 s1533 = (SWord8) (s1532 >> 8); const SWord32 s1534 = table1[s1533]; const SWord8 s1535 = (SWord8) (s970 >> 8); const SWord32 s1536 = table1[s1535]; const SWord16 s1537 = (SWord16) (s1229 >> 16); const SWord8 s1538 = (SWord8) s1537; const SWord32 s1539 = table3[s1538]; const SWord32 s1540 = s1536 ^ s1539; const SWord8 s1541 = (SWord8) (s1490 >> 8); const SWord32 s1542 = table4[s1541]; const SWord32 s1543 = s1540 ^ s1542; const SWord16 s1544 = (SWord16) s707; const SWord8 s1545 = (SWord8) s1544; const SWord32 s1546 = table5[s1545]; const SWord32 s1547 = s1543 ^ s1546; const SWord16 s1548 = (SWord16) (s690 >> 16); const SWord8 s1549 = (SWord8) (s1548 >> 8); const SWord8 s1550 = table6[s1549]; const SWord8 s1551 = (SWord8) s1548; const SWord8 s1552 = table7[s1551]; const SWord16 s1553 = (SWord16) s690; const SWord8 s1554 = (SWord8) (s1553 >> 8); const SWord8 s1555 = table8[s1554]; const SWord8 s1556 = (SWord8) s1553; const SWord8 s1557 = table9[s1556]; const SWord8 s1558 = s1555 ^ s1557; const SWord8 s1559 = s1552 ^ s1558; const SWord8 s1560 = s1550 ^ s1559; const SWord8 s1561 = table9[s1549]; const SWord8 s1562 = table6[s1551]; const SWord8 s1563 = table7[s1554]; const SWord8 s1564 = table8[s1556]; const SWord8 s1565 = s1563 ^ s1564; const SWord8 s1566 = s1562 ^ s1565; const SWord8 s1567 = s1561 ^ s1566; const SWord16 s1568 = (((SWord16) s1560) << 8) | ((SWord16) s1567); const SWord8 s1569 = table8[s1549]; const SWord8 s1570 = table9[s1551]; const SWord8 s1571 = table6[s1554]; const SWord8 s1572 = table7[s1556]; const SWord8 s1573 = s1571 ^ s1572; const SWord8 s1574 = s1570 ^ s1573; const SWord8 s1575 = s1569 ^ s1574; const SWord8 s1576 = table7[s1549]; const SWord8 s1577 = table8[s1551]; const SWord8 s1578 = table9[s1554]; const SWord8 s1579 = table6[s1556]; const SWord8 s1580 = s1578 ^ s1579; const SWord8 s1581 = s1577 ^ s1580; const SWord8 s1582 = s1576 ^ s1581; const SWord16 s1583 = (((SWord16) s1575) << 8) | ((SWord16) s1582); const SWord32 s1584 = (((SWord32) s1568) << 16) | ((SWord32) s1583); const SWord32 s1585 = s1547 ^ s1584; const SWord16 s1586 = (SWord16) (s1585 >> 16); const SWord8 s1587 = (SWord8) s1586; const SWord32 s1588 = table3[s1587]; const SWord32 s1589 = s1534 ^ s1588; const SWord8 s1590 = (SWord8) (s1537 >> 8); const SWord32 s1591 = table1[s1590]; const SWord16 s1592 = (SWord16) (s1489 >> 16); const SWord8 s1593 = (SWord8) s1592; const SWord32 s1594 = table3[s1593]; const SWord32 s1595 = s1591 ^ s1594; const SWord8 s1596 = (SWord8) (s1544 >> 8); const SWord32 s1597 = table4[s1596]; const SWord32 s1598 = s1595 ^ s1597; const SWord16 s1599 = (SWord16) s969; const SWord8 s1600 = (SWord8) s1599; const SWord32 s1601 = table5[s1600]; const SWord32 s1602 = s1598 ^ s1601; const SWord16 s1603 = (SWord16) (s689 >> 16); const SWord8 s1604 = (SWord8) (s1603 >> 8); const SWord8 s1605 = table6[s1604]; const SWord8 s1606 = (SWord8) s1603; const SWord8 s1607 = table7[s1606]; const SWord16 s1608 = (SWord16) s689; const SWord8 s1609 = (SWord8) (s1608 >> 8); const SWord8 s1610 = table8[s1609]; const SWord8 s1611 = (SWord8) s1608; const SWord8 s1612 = table9[s1611]; const SWord8 s1613 = s1610 ^ s1612; const SWord8 s1614 = s1607 ^ s1613; const SWord8 s1615 = s1605 ^ s1614; const SWord8 s1616 = table9[s1604]; const SWord8 s1617 = table6[s1606]; const SWord8 s1618 = table7[s1609]; const SWord8 s1619 = table8[s1611]; const SWord8 s1620 = s1618 ^ s1619; const SWord8 s1621 = s1617 ^ s1620; const SWord8 s1622 = s1616 ^ s1621; const SWord16 s1623 = (((SWord16) s1615) << 8) | ((SWord16) s1622); const SWord8 s1624 = table8[s1604]; const SWord8 s1625 = table9[s1606]; const SWord8 s1626 = table6[s1609]; const SWord8 s1627 = table7[s1611]; const SWord8 s1628 = s1626 ^ s1627; const SWord8 s1629 = s1625 ^ s1628; const SWord8 s1630 = s1624 ^ s1629; const SWord8 s1631 = table7[s1604]; const SWord8 s1632 = table8[s1606]; const SWord8 s1633 = table9[s1609]; const SWord8 s1634 = table6[s1611]; const SWord8 s1635 = s1633 ^ s1634; const SWord8 s1636 = s1632 ^ s1635; const SWord8 s1637 = s1631 ^ s1636; const SWord16 s1638 = (((SWord16) s1630) << 8) | ((SWord16) s1637); const SWord32 s1639 = (((SWord32) s1623) << 16) | ((SWord32) s1638); const SWord32 s1640 = s1602 ^ s1639; const SWord16 s1641 = (SWord16) s1640; const SWord8 s1642 = (SWord8) (s1641 >> 8); const SWord32 s1643 = table4[s1642]; const SWord32 s1644 = s1589 ^ s1643; const SWord8 s1645 = (SWord8) (s1592 >> 8); const SWord32 s1646 = table1[s1645]; const SWord8 s1647 = (SWord8) s708; const SWord32 s1648 = table3[s1647]; const SWord32 s1649 = s1646 ^ s1648; const SWord8 s1650 = (SWord8) (s1599 >> 8); const SWord32 s1651 = table4[s1650]; const SWord32 s1652 = s1649 ^ s1651; const SWord8 s1653 = (SWord8) s1230; const SWord32 s1654 = table5[s1653]; const SWord32 s1655 = s1652 ^ s1654; const SWord16 s1656 = (SWord16) (s688 >> 16); const SWord8 s1657 = (SWord8) (s1656 >> 8); const SWord8 s1658 = table6[s1657]; const SWord8 s1659 = (SWord8) s1656; const SWord8 s1660 = table7[s1659]; const SWord16 s1661 = (SWord16) s688; const SWord8 s1662 = (SWord8) (s1661 >> 8); const SWord8 s1663 = table8[s1662]; const SWord8 s1664 = (SWord8) s1661; const SWord8 s1665 = table9[s1664]; const SWord8 s1666 = s1663 ^ s1665; const SWord8 s1667 = s1660 ^ s1666; const SWord8 s1668 = s1658 ^ s1667; const SWord8 s1669 = table9[s1657]; const SWord8 s1670 = table6[s1659]; const SWord8 s1671 = table7[s1662]; const SWord8 s1672 = table8[s1664]; const SWord8 s1673 = s1671 ^ s1672; const SWord8 s1674 = s1670 ^ s1673; const SWord8 s1675 = s1669 ^ s1674; const SWord16 s1676 = (((SWord16) s1668) << 8) | ((SWord16) s1675); const SWord8 s1677 = table8[s1657]; const SWord8 s1678 = table9[s1659]; const SWord8 s1679 = table6[s1662]; const SWord8 s1680 = table7[s1664]; const SWord8 s1681 = s1679 ^ s1680; const SWord8 s1682 = s1678 ^ s1681; const SWord8 s1683 = s1677 ^ s1682; const SWord8 s1684 = table7[s1657]; const SWord8 s1685 = table8[s1659]; const SWord8 s1686 = table9[s1662]; const SWord8 s1687 = table6[s1664]; const SWord8 s1688 = s1686 ^ s1687; const SWord8 s1689 = s1685 ^ s1688; const SWord8 s1690 = s1684 ^ s1689; const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690); const SWord32 s1692 = (((SWord32) s1676) << 16) | ((SWord32) s1691); const SWord32 s1693 = s1655 ^ s1692; const SWord16 s1694 = (SWord16) s1693; const SWord8 s1695 = (SWord8) s1694; const SWord32 s1696 = table5[s1695]; const SWord32 s1697 = s1644 ^ s1696; const SWord16 s1698 = (SWord16) (s668 >> 16); const SWord8 s1699 = (SWord8) (s1698 >> 8); const SWord8 s1700 = table6[s1699]; const SWord8 s1701 = (SWord8) s1698; const SWord8 s1702 = table7[s1701]; const SWord16 s1703 = (SWord16) s668; const SWord8 s1704 = (SWord8) (s1703 >> 8); const SWord8 s1705 = table8[s1704]; const SWord8 s1706 = (SWord8) s1703; const SWord8 s1707 = table9[s1706]; const SWord8 s1708 = s1705 ^ s1707; const SWord8 s1709 = s1702 ^ s1708; const SWord8 s1710 = s1700 ^ s1709; const SWord8 s1711 = table9[s1699]; const SWord8 s1712 = table6[s1701]; const SWord8 s1713 = table7[s1704]; const SWord8 s1714 = table8[s1706]; const SWord8 s1715 = s1713 ^ s1714; const SWord8 s1716 = s1712 ^ s1715; const SWord8 s1717 = s1711 ^ s1716; const SWord16 s1718 = (((SWord16) s1710) << 8) | ((SWord16) s1717); const SWord8 s1719 = table8[s1699]; const SWord8 s1720 = table9[s1701]; const SWord8 s1721 = table6[s1704]; const SWord8 s1722 = table7[s1706]; const SWord8 s1723 = s1721 ^ s1722; const SWord8 s1724 = s1720 ^ s1723; const SWord8 s1725 = s1719 ^ s1724; const SWord8 s1726 = table7[s1699]; const SWord8 s1727 = table8[s1701]; const SWord8 s1728 = table9[s1704]; const SWord8 s1729 = table6[s1706]; const SWord8 s1730 = s1728 ^ s1729; const SWord8 s1731 = s1727 ^ s1730; const SWord8 s1732 = s1726 ^ s1731; const SWord16 s1733 = (((SWord16) s1725) << 8) | ((SWord16) s1732); const SWord32 s1734 = (((SWord32) s1718) << 16) | ((SWord32) s1733); const SWord32 s1735 = s1697 ^ s1734; const SWord16 s1736 = (SWord16) (s1735 >> 16); const SWord8 s1737 = (SWord8) (s1736 >> 8); const SWord32 s1738 = table1[s1737]; const SWord8 s1739 = (SWord8) (s1586 >> 8); const SWord32 s1740 = table1[s1739]; const SWord16 s1741 = (SWord16) (s1640 >> 16); const SWord8 s1742 = (SWord8) s1741; const SWord32 s1743 = table3[s1742]; const SWord32 s1744 = s1740 ^ s1743; const SWord8 s1745 = (SWord8) (s1694 >> 8); const SWord32 s1746 = table4[s1745]; const SWord32 s1747 = s1744 ^ s1746; const SWord16 s1748 = (SWord16) s1531; const SWord8 s1749 = (SWord8) s1748; const SWord32 s1750 = table5[s1749]; const SWord32 s1751 = s1747 ^ s1750; const SWord16 s1752 = (SWord16) (s671 >> 16); const SWord8 s1753 = (SWord8) (s1752 >> 8); const SWord8 s1754 = table6[s1753]; const SWord8 s1755 = (SWord8) s1752; const SWord8 s1756 = table7[s1755]; const SWord16 s1757 = (SWord16) s671; const SWord8 s1758 = (SWord8) (s1757 >> 8); const SWord8 s1759 = table8[s1758]; const SWord8 s1760 = (SWord8) s1757; const SWord8 s1761 = table9[s1760]; const SWord8 s1762 = s1759 ^ s1761; const SWord8 s1763 = s1756 ^ s1762; const SWord8 s1764 = s1754 ^ s1763; const SWord8 s1765 = table9[s1753]; const SWord8 s1766 = table6[s1755]; const SWord8 s1767 = table7[s1758]; const SWord8 s1768 = table8[s1760]; const SWord8 s1769 = s1767 ^ s1768; const SWord8 s1770 = s1766 ^ s1769; const SWord8 s1771 = s1765 ^ s1770; const SWord16 s1772 = (((SWord16) s1764) << 8) | ((SWord16) s1771); const SWord8 s1773 = table8[s1753]; const SWord8 s1774 = table9[s1755]; const SWord8 s1775 = table6[s1758]; const SWord8 s1776 = table7[s1760]; const SWord8 s1777 = s1775 ^ s1776; const SWord8 s1778 = s1774 ^ s1777; const SWord8 s1779 = s1773 ^ s1778; const SWord8 s1780 = table7[s1753]; const SWord8 s1781 = table8[s1755]; const SWord8 s1782 = table9[s1758]; const SWord8 s1783 = table6[s1760]; const SWord8 s1784 = s1782 ^ s1783; const SWord8 s1785 = s1781 ^ s1784; const SWord8 s1786 = s1780 ^ s1785; const SWord16 s1787 = (((SWord16) s1779) << 8) | ((SWord16) s1786); const SWord32 s1788 = (((SWord32) s1772) << 16) | ((SWord32) s1787); const SWord32 s1789 = s1751 ^ s1788; const SWord16 s1790 = (SWord16) (s1789 >> 16); const SWord8 s1791 = (SWord8) s1790; const SWord32 s1792 = table3[s1791]; const SWord32 s1793 = s1738 ^ s1792; const SWord8 s1794 = (SWord8) (s1741 >> 8); const SWord32 s1795 = table1[s1794]; const SWord16 s1796 = (SWord16) (s1693 >> 16); const SWord8 s1797 = (SWord8) s1796; const SWord32 s1798 = table3[s1797]; const SWord32 s1799 = s1795 ^ s1798; const SWord8 s1800 = (SWord8) (s1748 >> 8); const SWord32 s1801 = table4[s1800]; const SWord32 s1802 = s1799 ^ s1801; const SWord16 s1803 = (SWord16) s1585; const SWord8 s1804 = (SWord8) s1803; const SWord32 s1805 = table5[s1804]; const SWord32 s1806 = s1802 ^ s1805; const SWord16 s1807 = (SWord16) (s670 >> 16); const SWord8 s1808 = (SWord8) (s1807 >> 8); const SWord8 s1809 = table6[s1808]; const SWord8 s1810 = (SWord8) s1807; const SWord8 s1811 = table7[s1810]; const SWord16 s1812 = (SWord16) s670; const SWord8 s1813 = (SWord8) (s1812 >> 8); const SWord8 s1814 = table8[s1813]; const SWord8 s1815 = (SWord8) s1812; const SWord8 s1816 = table9[s1815]; const SWord8 s1817 = s1814 ^ s1816; const SWord8 s1818 = s1811 ^ s1817; const SWord8 s1819 = s1809 ^ s1818; const SWord8 s1820 = table9[s1808]; const SWord8 s1821 = table6[s1810]; const SWord8 s1822 = table7[s1813]; const SWord8 s1823 = table8[s1815]; const SWord8 s1824 = s1822 ^ s1823; const SWord8 s1825 = s1821 ^ s1824; const SWord8 s1826 = s1820 ^ s1825; const SWord16 s1827 = (((SWord16) s1819) << 8) | ((SWord16) s1826); const SWord8 s1828 = table8[s1808]; const SWord8 s1829 = table9[s1810]; const SWord8 s1830 = table6[s1813]; const SWord8 s1831 = table7[s1815]; const SWord8 s1832 = s1830 ^ s1831; const SWord8 s1833 = s1829 ^ s1832; const SWord8 s1834 = s1828 ^ s1833; const SWord8 s1835 = table7[s1808]; const SWord8 s1836 = table8[s1810]; const SWord8 s1837 = table9[s1813]; const SWord8 s1838 = table6[s1815]; const SWord8 s1839 = s1837 ^ s1838; const SWord8 s1840 = s1836 ^ s1839; const SWord8 s1841 = s1835 ^ s1840; const SWord16 s1842 = (((SWord16) s1834) << 8) | ((SWord16) s1841); const SWord32 s1843 = (((SWord32) s1827) << 16) | ((SWord32) s1842); const SWord32 s1844 = s1806 ^ s1843; const SWord16 s1845 = (SWord16) s1844; const SWord8 s1846 = (SWord8) (s1845 >> 8); const SWord32 s1847 = table4[s1846]; const SWord32 s1848 = s1793 ^ s1847; const SWord8 s1849 = (SWord8) (s1796 >> 8); const SWord32 s1850 = table1[s1849]; const SWord8 s1851 = (SWord8) s1532; const SWord32 s1852 = table3[s1851]; const SWord32 s1853 = s1850 ^ s1852; const SWord8 s1854 = (SWord8) (s1803 >> 8); const SWord32 s1855 = table4[s1854]; const SWord32 s1856 = s1853 ^ s1855; const SWord8 s1857 = (SWord8) s1641; const SWord32 s1858 = table5[s1857]; const SWord32 s1859 = s1856 ^ s1858; const SWord16 s1860 = (SWord16) (s669 >> 16); const SWord8 s1861 = (SWord8) (s1860 >> 8); const SWord8 s1862 = table6[s1861]; const SWord8 s1863 = (SWord8) s1860; const SWord8 s1864 = table7[s1863]; const SWord16 s1865 = (SWord16) s669; const SWord8 s1866 = (SWord8) (s1865 >> 8); const SWord8 s1867 = table8[s1866]; const SWord8 s1868 = (SWord8) s1865; const SWord8 s1869 = table9[s1868]; const SWord8 s1870 = s1867 ^ s1869; const SWord8 s1871 = s1864 ^ s1870; const SWord8 s1872 = s1862 ^ s1871; const SWord8 s1873 = table9[s1861]; const SWord8 s1874 = table6[s1863]; const SWord8 s1875 = table7[s1866]; const SWord8 s1876 = table8[s1868]; const SWord8 s1877 = s1875 ^ s1876; const SWord8 s1878 = s1874 ^ s1877; const SWord8 s1879 = s1873 ^ s1878; const SWord16 s1880 = (((SWord16) s1872) << 8) | ((SWord16) s1879); const SWord8 s1881 = table8[s1861]; const SWord8 s1882 = table9[s1863]; const SWord8 s1883 = table6[s1866]; const SWord8 s1884 = table7[s1868]; const SWord8 s1885 = s1883 ^ s1884; const SWord8 s1886 = s1882 ^ s1885; const SWord8 s1887 = s1881 ^ s1886; const SWord8 s1888 = table7[s1861]; const SWord8 s1889 = table8[s1863]; const SWord8 s1890 = table9[s1866]; const SWord8 s1891 = table6[s1868]; const SWord8 s1892 = s1890 ^ s1891; const SWord8 s1893 = s1889 ^ s1892; const SWord8 s1894 = s1888 ^ s1893; const SWord16 s1895 = (((SWord16) s1887) << 8) | ((SWord16) s1894); const SWord32 s1896 = (((SWord32) s1880) << 16) | ((SWord32) s1895); const SWord32 s1897 = s1859 ^ s1896; const SWord16 s1898 = (SWord16) s1897; const SWord8 s1899 = (SWord8) s1898; const SWord32 s1900 = table5[s1899]; const SWord32 s1901 = s1848 ^ s1900; const SWord16 s1902 = (SWord16) (s649 >> 16); const SWord8 s1903 = (SWord8) (s1902 >> 8); const SWord8 s1904 = table6[s1903]; const SWord8 s1905 = (SWord8) s1902; const SWord8 s1906 = table7[s1905]; const SWord16 s1907 = (SWord16) s649; const SWord8 s1908 = (SWord8) (s1907 >> 8); const SWord8 s1909 = table8[s1908]; const SWord8 s1910 = (SWord8) s1907; const SWord8 s1911 = table9[s1910]; const SWord8 s1912 = s1909 ^ s1911; const SWord8 s1913 = s1906 ^ s1912; const SWord8 s1914 = s1904 ^ s1913; const SWord8 s1915 = table9[s1903]; const SWord8 s1916 = table6[s1905]; const SWord8 s1917 = table7[s1908]; const SWord8 s1918 = table8[s1910]; const SWord8 s1919 = s1917 ^ s1918; const SWord8 s1920 = s1916 ^ s1919; const SWord8 s1921 = s1915 ^ s1920; const SWord16 s1922 = (((SWord16) s1914) << 8) | ((SWord16) s1921); const SWord8 s1923 = table8[s1903]; const SWord8 s1924 = table9[s1905]; const SWord8 s1925 = table6[s1908]; const SWord8 s1926 = table7[s1910]; const SWord8 s1927 = s1925 ^ s1926; const SWord8 s1928 = s1924 ^ s1927; const SWord8 s1929 = s1923 ^ s1928; const SWord8 s1930 = table7[s1903]; const SWord8 s1931 = table8[s1905]; const SWord8 s1932 = table9[s1908]; const SWord8 s1933 = table6[s1910]; const SWord8 s1934 = s1932 ^ s1933; const SWord8 s1935 = s1931 ^ s1934; const SWord8 s1936 = s1930 ^ s1935; const SWord16 s1937 = (((SWord16) s1929) << 8) | ((SWord16) s1936); const SWord32 s1938 = (((SWord32) s1922) << 16) | ((SWord32) s1937); const SWord32 s1939 = s1901 ^ s1938; const SWord16 s1940 = (SWord16) (s1939 >> 16); const SWord8 s1941 = (SWord8) (s1940 >> 8); const SWord32 s1942 = table1[s1941]; const SWord8 s1943 = (SWord8) (s1790 >> 8); const SWord32 s1944 = table1[s1943]; const SWord16 s1945 = (SWord16) (s1844 >> 16); const SWord8 s1946 = (SWord8) s1945; const SWord32 s1947 = table3[s1946]; const SWord32 s1948 = s1944 ^ s1947; const SWord8 s1949 = (SWord8) (s1898 >> 8); const SWord32 s1950 = table4[s1949]; const SWord32 s1951 = s1948 ^ s1950; const SWord16 s1952 = (SWord16) s1735; const SWord8 s1953 = (SWord8) s1952; const SWord32 s1954 = table5[s1953]; const SWord32 s1955 = s1951 ^ s1954; const SWord16 s1956 = (SWord16) (s652 >> 16); const SWord8 s1957 = (SWord8) (s1956 >> 8); const SWord8 s1958 = table6[s1957]; const SWord8 s1959 = (SWord8) s1956; const SWord8 s1960 = table7[s1959]; const SWord16 s1961 = (SWord16) s652; const SWord8 s1962 = (SWord8) (s1961 >> 8); const SWord8 s1963 = table8[s1962]; const SWord8 s1964 = (SWord8) s1961; const SWord8 s1965 = table9[s1964]; const SWord8 s1966 = s1963 ^ s1965; const SWord8 s1967 = s1960 ^ s1966; const SWord8 s1968 = s1958 ^ s1967; const SWord8 s1969 = table9[s1957]; const SWord8 s1970 = table6[s1959]; const SWord8 s1971 = table7[s1962]; const SWord8 s1972 = table8[s1964]; const SWord8 s1973 = s1971 ^ s1972; const SWord8 s1974 = s1970 ^ s1973; const SWord8 s1975 = s1969 ^ s1974; const SWord16 s1976 = (((SWord16) s1968) << 8) | ((SWord16) s1975); const SWord8 s1977 = table8[s1957]; const SWord8 s1978 = table9[s1959]; const SWord8 s1979 = table6[s1962]; const SWord8 s1980 = table7[s1964]; const SWord8 s1981 = s1979 ^ s1980; const SWord8 s1982 = s1978 ^ s1981; const SWord8 s1983 = s1977 ^ s1982; const SWord8 s1984 = table7[s1957]; const SWord8 s1985 = table8[s1959]; const SWord8 s1986 = table9[s1962]; const SWord8 s1987 = table6[s1964]; const SWord8 s1988 = s1986 ^ s1987; const SWord8 s1989 = s1985 ^ s1988; const SWord8 s1990 = s1984 ^ s1989; const SWord16 s1991 = (((SWord16) s1983) << 8) | ((SWord16) s1990); const SWord32 s1992 = (((SWord32) s1976) << 16) | ((SWord32) s1991); const SWord32 s1993 = s1955 ^ s1992; const SWord16 s1994 = (SWord16) (s1993 >> 16); const SWord8 s1995 = (SWord8) s1994; const SWord32 s1996 = table3[s1995]; const SWord32 s1997 = s1942 ^ s1996; const SWord8 s1998 = (SWord8) (s1945 >> 8); const SWord32 s1999 = table1[s1998]; const SWord16 s2000 = (SWord16) (s1897 >> 16); const SWord8 s2001 = (SWord8) s2000; const SWord32 s2002 = table3[s2001]; const SWord32 s2003 = s1999 ^ s2002; const SWord8 s2004 = (SWord8) (s1952 >> 8); const SWord32 s2005 = table4[s2004]; const SWord32 s2006 = s2003 ^ s2005; const SWord16 s2007 = (SWord16) s1789; const SWord8 s2008 = (SWord8) s2007; const SWord32 s2009 = table5[s2008]; const SWord32 s2010 = s2006 ^ s2009; const SWord16 s2011 = (SWord16) (s651 >> 16); const SWord8 s2012 = (SWord8) (s2011 >> 8); const SWord8 s2013 = table6[s2012]; const SWord8 s2014 = (SWord8) s2011; const SWord8 s2015 = table7[s2014]; const SWord16 s2016 = (SWord16) s651; const SWord8 s2017 = (SWord8) (s2016 >> 8); const SWord8 s2018 = table8[s2017]; const SWord8 s2019 = (SWord8) s2016; const SWord8 s2020 = table9[s2019]; const SWord8 s2021 = s2018 ^ s2020; const SWord8 s2022 = s2015 ^ s2021; const SWord8 s2023 = s2013 ^ s2022; const SWord8 s2024 = table9[s2012]; const SWord8 s2025 = table6[s2014]; const SWord8 s2026 = table7[s2017]; const SWord8 s2027 = table8[s2019]; const SWord8 s2028 = s2026 ^ s2027; const SWord8 s2029 = s2025 ^ s2028; const SWord8 s2030 = s2024 ^ s2029; const SWord16 s2031 = (((SWord16) s2023) << 8) | ((SWord16) s2030); const SWord8 s2032 = table8[s2012]; const SWord8 s2033 = table9[s2014]; const SWord8 s2034 = table6[s2017]; const SWord8 s2035 = table7[s2019]; const SWord8 s2036 = s2034 ^ s2035; const SWord8 s2037 = s2033 ^ s2036; const SWord8 s2038 = s2032 ^ s2037; const SWord8 s2039 = table7[s2012]; const SWord8 s2040 = table8[s2014]; const SWord8 s2041 = table9[s2017]; const SWord8 s2042 = table6[s2019]; const SWord8 s2043 = s2041 ^ s2042; const SWord8 s2044 = s2040 ^ s2043; const SWord8 s2045 = s2039 ^ s2044; const SWord16 s2046 = (((SWord16) s2038) << 8) | ((SWord16) s2045); const SWord32 s2047 = (((SWord32) s2031) << 16) | ((SWord32) s2046); const SWord32 s2048 = s2010 ^ s2047; const SWord16 s2049 = (SWord16) s2048; const SWord8 s2050 = (SWord8) (s2049 >> 8); const SWord32 s2051 = table4[s2050]; const SWord32 s2052 = s1997 ^ s2051; const SWord8 s2053 = (SWord8) (s2000 >> 8); const SWord32 s2054 = table1[s2053]; const SWord8 s2055 = (SWord8) s1736; const SWord32 s2056 = table3[s2055]; const SWord32 s2057 = s2054 ^ s2056; const SWord8 s2058 = (SWord8) (s2007 >> 8); const SWord32 s2059 = table4[s2058]; const SWord32 s2060 = s2057 ^ s2059; const SWord8 s2061 = (SWord8) s1845; const SWord32 s2062 = table5[s2061]; const SWord32 s2063 = s2060 ^ s2062; const SWord16 s2064 = (SWord16) (s650 >> 16); const SWord8 s2065 = (SWord8) (s2064 >> 8); const SWord8 s2066 = table6[s2065]; const SWord8 s2067 = (SWord8) s2064; const SWord8 s2068 = table7[s2067]; const SWord16 s2069 = (SWord16) s650; const SWord8 s2070 = (SWord8) (s2069 >> 8); const SWord8 s2071 = table8[s2070]; const SWord8 s2072 = (SWord8) s2069; const SWord8 s2073 = table9[s2072]; const SWord8 s2074 = s2071 ^ s2073; const SWord8 s2075 = s2068 ^ s2074; const SWord8 s2076 = s2066 ^ s2075; const SWord8 s2077 = table9[s2065]; const SWord8 s2078 = table6[s2067]; const SWord8 s2079 = table7[s2070]; const SWord8 s2080 = table8[s2072]; const SWord8 s2081 = s2079 ^ s2080; const SWord8 s2082 = s2078 ^ s2081; const SWord8 s2083 = s2077 ^ s2082; const SWord16 s2084 = (((SWord16) s2076) << 8) | ((SWord16) s2083); const SWord8 s2085 = table8[s2065]; const SWord8 s2086 = table9[s2067]; const SWord8 s2087 = table6[s2070]; const SWord8 s2088 = table7[s2072]; const SWord8 s2089 = s2087 ^ s2088; const SWord8 s2090 = s2086 ^ s2089; const SWord8 s2091 = s2085 ^ s2090; const SWord8 s2092 = table7[s2065]; const SWord8 s2093 = table8[s2067]; const SWord8 s2094 = table9[s2070]; const SWord8 s2095 = table6[s2072]; const SWord8 s2096 = s2094 ^ s2095; const SWord8 s2097 = s2093 ^ s2096; const SWord8 s2098 = s2092 ^ s2097; const SWord16 s2099 = (((SWord16) s2091) << 8) | ((SWord16) s2098); const SWord32 s2100 = (((SWord32) s2084) << 16) | ((SWord32) s2099); const SWord32 s2101 = s2063 ^ s2100; const SWord16 s2102 = (SWord16) s2101; const SWord8 s2103 = (SWord8) s2102; const SWord32 s2104 = table5[s2103]; const SWord32 s2105 = s2052 ^ s2104; const SWord16 s2106 = (SWord16) (s630 >> 16); const SWord8 s2107 = (SWord8) (s2106 >> 8); const SWord8 s2108 = table6[s2107]; const SWord8 s2109 = (SWord8) s2106; const SWord8 s2110 = table7[s2109]; const SWord16 s2111 = (SWord16) s630; const SWord8 s2112 = (SWord8) (s2111 >> 8); const SWord8 s2113 = table8[s2112]; const SWord8 s2114 = (SWord8) s2111; const SWord8 s2115 = table9[s2114]; const SWord8 s2116 = s2113 ^ s2115; const SWord8 s2117 = s2110 ^ s2116; const SWord8 s2118 = s2108 ^ s2117; const SWord8 s2119 = table9[s2107]; const SWord8 s2120 = table6[s2109]; const SWord8 s2121 = table7[s2112]; const SWord8 s2122 = table8[s2114]; const SWord8 s2123 = s2121 ^ s2122; const SWord8 s2124 = s2120 ^ s2123; const SWord8 s2125 = s2119 ^ s2124; const SWord16 s2126 = (((SWord16) s2118) << 8) | ((SWord16) s2125); const SWord8 s2127 = table8[s2107]; const SWord8 s2128 = table9[s2109]; const SWord8 s2129 = table6[s2112]; const SWord8 s2130 = table7[s2114]; const SWord8 s2131 = s2129 ^ s2130; const SWord8 s2132 = s2128 ^ s2131; const SWord8 s2133 = s2127 ^ s2132; const SWord8 s2134 = table7[s2107]; const SWord8 s2135 = table8[s2109]; const SWord8 s2136 = table9[s2112]; const SWord8 s2137 = table6[s2114]; const SWord8 s2138 = s2136 ^ s2137; const SWord8 s2139 = s2135 ^ s2138; const SWord8 s2140 = s2134 ^ s2139; const SWord16 s2141 = (((SWord16) s2133) << 8) | ((SWord16) s2140); const SWord32 s2142 = (((SWord32) s2126) << 16) | ((SWord32) s2141); const SWord32 s2143 = s2105 ^ s2142; const SWord16 s2144 = (SWord16) (s2143 >> 16); const SWord8 s2145 = (SWord8) (s2144 >> 8); const SWord32 s2146 = table1[s2145]; const SWord8 s2147 = (SWord8) (s1994 >> 8); const SWord32 s2148 = table1[s2147]; const SWord16 s2149 = (SWord16) (s2048 >> 16); const SWord8 s2150 = (SWord8) s2149; const SWord32 s2151 = table3[s2150]; const SWord32 s2152 = s2148 ^ s2151; const SWord8 s2153 = (SWord8) (s2102 >> 8); const SWord32 s2154 = table4[s2153]; const SWord32 s2155 = s2152 ^ s2154; const SWord16 s2156 = (SWord16) s1939; const SWord8 s2157 = (SWord8) s2156; const SWord32 s2158 = table5[s2157]; const SWord32 s2159 = s2155 ^ s2158; const SWord16 s2160 = (SWord16) (s633 >> 16); const SWord8 s2161 = (SWord8) (s2160 >> 8); const SWord8 s2162 = table6[s2161]; const SWord8 s2163 = (SWord8) s2160; const SWord8 s2164 = table7[s2163]; const SWord16 s2165 = (SWord16) s633; const SWord8 s2166 = (SWord8) (s2165 >> 8); const SWord8 s2167 = table8[s2166]; const SWord8 s2168 = (SWord8) s2165; const SWord8 s2169 = table9[s2168]; const SWord8 s2170 = s2167 ^ s2169; const SWord8 s2171 = s2164 ^ s2170; const SWord8 s2172 = s2162 ^ s2171; const SWord8 s2173 = table9[s2161]; const SWord8 s2174 = table6[s2163]; const SWord8 s2175 = table7[s2166]; const SWord8 s2176 = table8[s2168]; const SWord8 s2177 = s2175 ^ s2176; const SWord8 s2178 = s2174 ^ s2177; const SWord8 s2179 = s2173 ^ s2178; const SWord16 s2180 = (((SWord16) s2172) << 8) | ((SWord16) s2179); const SWord8 s2181 = table8[s2161]; const SWord8 s2182 = table9[s2163]; const SWord8 s2183 = table6[s2166]; const SWord8 s2184 = table7[s2168]; const SWord8 s2185 = s2183 ^ s2184; const SWord8 s2186 = s2182 ^ s2185; const SWord8 s2187 = s2181 ^ s2186; const SWord8 s2188 = table7[s2161]; const SWord8 s2189 = table8[s2163]; const SWord8 s2190 = table9[s2166]; const SWord8 s2191 = table6[s2168]; const SWord8 s2192 = s2190 ^ s2191; const SWord8 s2193 = s2189 ^ s2192; const SWord8 s2194 = s2188 ^ s2193; const SWord16 s2195 = (((SWord16) s2187) << 8) | ((SWord16) s2194); const SWord32 s2196 = (((SWord32) s2180) << 16) | ((SWord32) s2195); const SWord32 s2197 = s2159 ^ s2196; const SWord16 s2198 = (SWord16) (s2197 >> 16); const SWord8 s2199 = (SWord8) s2198; const SWord32 s2200 = table3[s2199]; const SWord32 s2201 = s2146 ^ s2200; const SWord8 s2202 = (SWord8) (s2149 >> 8); const SWord32 s2203 = table1[s2202]; const SWord16 s2204 = (SWord16) (s2101 >> 16); const SWord8 s2205 = (SWord8) s2204; const SWord32 s2206 = table3[s2205]; const SWord32 s2207 = s2203 ^ s2206; const SWord8 s2208 = (SWord8) (s2156 >> 8); const SWord32 s2209 = table4[s2208]; const SWord32 s2210 = s2207 ^ s2209; const SWord16 s2211 = (SWord16) s1993; const SWord8 s2212 = (SWord8) s2211; const SWord32 s2213 = table5[s2212]; const SWord32 s2214 = s2210 ^ s2213; const SWord16 s2215 = (SWord16) (s632 >> 16); const SWord8 s2216 = (SWord8) (s2215 >> 8); const SWord8 s2217 = table6[s2216]; const SWord8 s2218 = (SWord8) s2215; const SWord8 s2219 = table7[s2218]; const SWord16 s2220 = (SWord16) s632; const SWord8 s2221 = (SWord8) (s2220 >> 8); const SWord8 s2222 = table8[s2221]; const SWord8 s2223 = (SWord8) s2220; const SWord8 s2224 = table9[s2223]; const SWord8 s2225 = s2222 ^ s2224; const SWord8 s2226 = s2219 ^ s2225; const SWord8 s2227 = s2217 ^ s2226; const SWord8 s2228 = table9[s2216]; const SWord8 s2229 = table6[s2218]; const SWord8 s2230 = table7[s2221]; const SWord8 s2231 = table8[s2223]; const SWord8 s2232 = s2230 ^ s2231; const SWord8 s2233 = s2229 ^ s2232; const SWord8 s2234 = s2228 ^ s2233; const SWord16 s2235 = (((SWord16) s2227) << 8) | ((SWord16) s2234); const SWord8 s2236 = table8[s2216]; const SWord8 s2237 = table9[s2218]; const SWord8 s2238 = table6[s2221]; const SWord8 s2239 = table7[s2223]; const SWord8 s2240 = s2238 ^ s2239; const SWord8 s2241 = s2237 ^ s2240; const SWord8 s2242 = s2236 ^ s2241; const SWord8 s2243 = table7[s2216]; const SWord8 s2244 = table8[s2218]; const SWord8 s2245 = table9[s2221]; const SWord8 s2246 = table6[s2223]; const SWord8 s2247 = s2245 ^ s2246; const SWord8 s2248 = s2244 ^ s2247; const SWord8 s2249 = s2243 ^ s2248; const SWord16 s2250 = (((SWord16) s2242) << 8) | ((SWord16) s2249); const SWord32 s2251 = (((SWord32) s2235) << 16) | ((SWord32) s2250); const SWord32 s2252 = s2214 ^ s2251; const SWord16 s2253 = (SWord16) s2252; const SWord8 s2254 = (SWord8) (s2253 >> 8); const SWord32 s2255 = table4[s2254]; const SWord32 s2256 = s2201 ^ s2255; const SWord8 s2257 = (SWord8) (s2204 >> 8); const SWord32 s2258 = table1[s2257]; const SWord8 s2259 = (SWord8) s1940; const SWord32 s2260 = table3[s2259]; const SWord32 s2261 = s2258 ^ s2260; const SWord8 s2262 = (SWord8) (s2211 >> 8); const SWord32 s2263 = table4[s2262]; const SWord32 s2264 = s2261 ^ s2263; const SWord8 s2265 = (SWord8) s2049; const SWord32 s2266 = table5[s2265]; const SWord32 s2267 = s2264 ^ s2266; const SWord16 s2268 = (SWord16) (s631 >> 16); const SWord8 s2269 = (SWord8) (s2268 >> 8); const SWord8 s2270 = table6[s2269]; const SWord8 s2271 = (SWord8) s2268; const SWord8 s2272 = table7[s2271]; const SWord16 s2273 = (SWord16) s631; const SWord8 s2274 = (SWord8) (s2273 >> 8); const SWord8 s2275 = table8[s2274]; const SWord8 s2276 = (SWord8) s2273; const SWord8 s2277 = table9[s2276]; const SWord8 s2278 = s2275 ^ s2277; const SWord8 s2279 = s2272 ^ s2278; const SWord8 s2280 = s2270 ^ s2279; const SWord8 s2281 = table9[s2269]; const SWord8 s2282 = table6[s2271]; const SWord8 s2283 = table7[s2274]; const SWord8 s2284 = table8[s2276]; const SWord8 s2285 = s2283 ^ s2284; const SWord8 s2286 = s2282 ^ s2285; const SWord8 s2287 = s2281 ^ s2286; const SWord16 s2288 = (((SWord16) s2280) << 8) | ((SWord16) s2287); const SWord8 s2289 = table8[s2269]; const SWord8 s2290 = table9[s2271]; const SWord8 s2291 = table6[s2274]; const SWord8 s2292 = table7[s2276]; const SWord8 s2293 = s2291 ^ s2292; const SWord8 s2294 = s2290 ^ s2293; const SWord8 s2295 = s2289 ^ s2294; const SWord8 s2296 = table7[s2269]; const SWord8 s2297 = table8[s2271]; const SWord8 s2298 = table9[s2274]; const SWord8 s2299 = table6[s2276]; const SWord8 s2300 = s2298 ^ s2299; const SWord8 s2301 = s2297 ^ s2300; const SWord8 s2302 = s2296 ^ s2301; const SWord16 s2303 = (((SWord16) s2295) << 8) | ((SWord16) s2302); const SWord32 s2304 = (((SWord32) s2288) << 16) | ((SWord32) s2303); const SWord32 s2305 = s2267 ^ s2304; const SWord16 s2306 = (SWord16) s2305; const SWord8 s2307 = (SWord8) s2306; const SWord32 s2308 = table5[s2307]; const SWord32 s2309 = s2256 ^ s2308; const SWord16 s2310 = (SWord16) (s611 >> 16); const SWord8 s2311 = (SWord8) (s2310 >> 8); const SWord8 s2312 = table6[s2311]; const SWord8 s2313 = (SWord8) s2310; const SWord8 s2314 = table7[s2313]; const SWord16 s2315 = (SWord16) s611; const SWord8 s2316 = (SWord8) (s2315 >> 8); const SWord8 s2317 = table8[s2316]; const SWord8 s2318 = (SWord8) s2315; const SWord8 s2319 = table9[s2318]; const SWord8 s2320 = s2317 ^ s2319; const SWord8 s2321 = s2314 ^ s2320; const SWord8 s2322 = s2312 ^ s2321; const SWord8 s2323 = table9[s2311]; const SWord8 s2324 = table6[s2313]; const SWord8 s2325 = table7[s2316]; const SWord8 s2326 = table8[s2318]; const SWord8 s2327 = s2325 ^ s2326; const SWord8 s2328 = s2324 ^ s2327; const SWord8 s2329 = s2323 ^ s2328; const SWord16 s2330 = (((SWord16) s2322) << 8) | ((SWord16) s2329); const SWord8 s2331 = table8[s2311]; const SWord8 s2332 = table9[s2313]; const SWord8 s2333 = table6[s2316]; const SWord8 s2334 = table7[s2318]; const SWord8 s2335 = s2333 ^ s2334; const SWord8 s2336 = s2332 ^ s2335; const SWord8 s2337 = s2331 ^ s2336; const SWord8 s2338 = table7[s2311]; const SWord8 s2339 = table8[s2313]; const SWord8 s2340 = table9[s2316]; const SWord8 s2341 = table6[s2318]; const SWord8 s2342 = s2340 ^ s2341; const SWord8 s2343 = s2339 ^ s2342; const SWord8 s2344 = s2338 ^ s2343; const SWord16 s2345 = (((SWord16) s2337) << 8) | ((SWord16) s2344); const SWord32 s2346 = (((SWord32) s2330) << 16) | ((SWord32) s2345); const SWord32 s2347 = s2309 ^ s2346; const SWord16 s2348 = (SWord16) (s2347 >> 16); const SWord8 s2349 = (SWord8) (s2348 >> 8); const SWord32 s2350 = table1[s2349]; const SWord8 s2351 = (SWord8) (s2198 >> 8); const SWord32 s2352 = table1[s2351]; const SWord16 s2353 = (SWord16) (s2252 >> 16); const SWord8 s2354 = (SWord8) s2353; const SWord32 s2355 = table3[s2354]; const SWord32 s2356 = s2352 ^ s2355; const SWord8 s2357 = (SWord8) (s2306 >> 8); const SWord32 s2358 = table4[s2357]; const SWord32 s2359 = s2356 ^ s2358; const SWord16 s2360 = (SWord16) s2143; const SWord8 s2361 = (SWord8) s2360; const SWord32 s2362 = table5[s2361]; const SWord32 s2363 = s2359 ^ s2362; const SWord16 s2364 = (SWord16) (s614 >> 16); const SWord8 s2365 = (SWord8) (s2364 >> 8); const SWord8 s2366 = table6[s2365]; const SWord8 s2367 = (SWord8) s2364; const SWord8 s2368 = table7[s2367]; const SWord16 s2369 = (SWord16) s614; const SWord8 s2370 = (SWord8) (s2369 >> 8); const SWord8 s2371 = table8[s2370]; const SWord8 s2372 = (SWord8) s2369; const SWord8 s2373 = table9[s2372]; const SWord8 s2374 = s2371 ^ s2373; const SWord8 s2375 = s2368 ^ s2374; const SWord8 s2376 = s2366 ^ s2375; const SWord8 s2377 = table9[s2365]; const SWord8 s2378 = table6[s2367]; const SWord8 s2379 = table7[s2370]; const SWord8 s2380 = table8[s2372]; const SWord8 s2381 = s2379 ^ s2380; const SWord8 s2382 = s2378 ^ s2381; const SWord8 s2383 = s2377 ^ s2382; const SWord16 s2384 = (((SWord16) s2376) << 8) | ((SWord16) s2383); const SWord8 s2385 = table8[s2365]; const SWord8 s2386 = table9[s2367]; const SWord8 s2387 = table6[s2370]; const SWord8 s2388 = table7[s2372]; const SWord8 s2389 = s2387 ^ s2388; const SWord8 s2390 = s2386 ^ s2389; const SWord8 s2391 = s2385 ^ s2390; const SWord8 s2392 = table7[s2365]; const SWord8 s2393 = table8[s2367]; const SWord8 s2394 = table9[s2370]; const SWord8 s2395 = table6[s2372]; const SWord8 s2396 = s2394 ^ s2395; const SWord8 s2397 = s2393 ^ s2396; const SWord8 s2398 = s2392 ^ s2397; const SWord16 s2399 = (((SWord16) s2391) << 8) | ((SWord16) s2398); const SWord32 s2400 = (((SWord32) s2384) << 16) | ((SWord32) s2399); const SWord32 s2401 = s2363 ^ s2400; const SWord16 s2402 = (SWord16) (s2401 >> 16); const SWord8 s2403 = (SWord8) s2402; const SWord32 s2404 = table3[s2403]; const SWord32 s2405 = s2350 ^ s2404; const SWord8 s2406 = (SWord8) (s2353 >> 8); const SWord32 s2407 = table1[s2406]; const SWord16 s2408 = (SWord16) (s2305 >> 16); const SWord8 s2409 = (SWord8) s2408; const SWord32 s2410 = table3[s2409]; const SWord32 s2411 = s2407 ^ s2410; const SWord8 s2412 = (SWord8) (s2360 >> 8); const SWord32 s2413 = table4[s2412]; const SWord32 s2414 = s2411 ^ s2413; const SWord16 s2415 = (SWord16) s2197; const SWord8 s2416 = (SWord8) s2415; const SWord32 s2417 = table5[s2416]; const SWord32 s2418 = s2414 ^ s2417; const SWord16 s2419 = (SWord16) (s613 >> 16); const SWord8 s2420 = (SWord8) (s2419 >> 8); const SWord8 s2421 = table6[s2420]; const SWord8 s2422 = (SWord8) s2419; const SWord8 s2423 = table7[s2422]; const SWord16 s2424 = (SWord16) s613; const SWord8 s2425 = (SWord8) (s2424 >> 8); const SWord8 s2426 = table8[s2425]; const SWord8 s2427 = (SWord8) s2424; const SWord8 s2428 = table9[s2427]; const SWord8 s2429 = s2426 ^ s2428; const SWord8 s2430 = s2423 ^ s2429; const SWord8 s2431 = s2421 ^ s2430; const SWord8 s2432 = table9[s2420]; const SWord8 s2433 = table6[s2422]; const SWord8 s2434 = table7[s2425]; const SWord8 s2435 = table8[s2427]; const SWord8 s2436 = s2434 ^ s2435; const SWord8 s2437 = s2433 ^ s2436; const SWord8 s2438 = s2432 ^ s2437; const SWord16 s2439 = (((SWord16) s2431) << 8) | ((SWord16) s2438); const SWord8 s2440 = table8[s2420]; const SWord8 s2441 = table9[s2422]; const SWord8 s2442 = table6[s2425]; const SWord8 s2443 = table7[s2427]; const SWord8 s2444 = s2442 ^ s2443; const SWord8 s2445 = s2441 ^ s2444; const SWord8 s2446 = s2440 ^ s2445; const SWord8 s2447 = table7[s2420]; const SWord8 s2448 = table8[s2422]; const SWord8 s2449 = table9[s2425]; const SWord8 s2450 = table6[s2427]; const SWord8 s2451 = s2449 ^ s2450; const SWord8 s2452 = s2448 ^ s2451; const SWord8 s2453 = s2447 ^ s2452; const SWord16 s2454 = (((SWord16) s2446) << 8) | ((SWord16) s2453); const SWord32 s2455 = (((SWord32) s2439) << 16) | ((SWord32) s2454); const SWord32 s2456 = s2418 ^ s2455; const SWord16 s2457 = (SWord16) s2456; const SWord8 s2458 = (SWord8) (s2457 >> 8); const SWord32 s2459 = table4[s2458]; const SWord32 s2460 = s2405 ^ s2459; const SWord8 s2461 = (SWord8) (s2408 >> 8); const SWord32 s2462 = table1[s2461]; const SWord8 s2463 = (SWord8) s2144; const SWord32 s2464 = table3[s2463]; const SWord32 s2465 = s2462 ^ s2464; const SWord8 s2466 = (SWord8) (s2415 >> 8); const SWord32 s2467 = table4[s2466]; const SWord32 s2468 = s2465 ^ s2467; const SWord8 s2469 = (SWord8) s2253; const SWord32 s2470 = table5[s2469]; const SWord32 s2471 = s2468 ^ s2470; const SWord16 s2472 = (SWord16) (s612 >> 16); const SWord8 s2473 = (SWord8) (s2472 >> 8); const SWord8 s2474 = table6[s2473]; const SWord8 s2475 = (SWord8) s2472; const SWord8 s2476 = table7[s2475]; const SWord16 s2477 = (SWord16) s612; const SWord8 s2478 = (SWord8) (s2477 >> 8); const SWord8 s2479 = table8[s2478]; const SWord8 s2480 = (SWord8) s2477; const SWord8 s2481 = table9[s2480]; const SWord8 s2482 = s2479 ^ s2481; const SWord8 s2483 = s2476 ^ s2482; const SWord8 s2484 = s2474 ^ s2483; const SWord8 s2485 = table9[s2473]; const SWord8 s2486 = table6[s2475]; const SWord8 s2487 = table7[s2478]; const SWord8 s2488 = table8[s2480]; const SWord8 s2489 = s2487 ^ s2488; const SWord8 s2490 = s2486 ^ s2489; const SWord8 s2491 = s2485 ^ s2490; const SWord16 s2492 = (((SWord16) s2484) << 8) | ((SWord16) s2491); const SWord8 s2493 = table8[s2473]; const SWord8 s2494 = table9[s2475]; const SWord8 s2495 = table6[s2478]; const SWord8 s2496 = table7[s2480]; const SWord8 s2497 = s2495 ^ s2496; const SWord8 s2498 = s2494 ^ s2497; const SWord8 s2499 = s2493 ^ s2498; const SWord8 s2500 = table7[s2473]; const SWord8 s2501 = table8[s2475]; const SWord8 s2502 = table9[s2478]; const SWord8 s2503 = table6[s2480]; const SWord8 s2504 = s2502 ^ s2503; const SWord8 s2505 = s2501 ^ s2504; const SWord8 s2506 = s2500 ^ s2505; const SWord16 s2507 = (((SWord16) s2499) << 8) | ((SWord16) s2506); const SWord32 s2508 = (((SWord32) s2492) << 16) | ((SWord32) s2507); const SWord32 s2509 = s2471 ^ s2508; const SWord16 s2510 = (SWord16) s2509; const SWord8 s2511 = (SWord8) s2510; const SWord32 s2512 = table5[s2511]; const SWord32 s2513 = s2460 ^ s2512; const SWord16 s2514 = (SWord16) (s592 >> 16); const SWord8 s2515 = (SWord8) (s2514 >> 8); const SWord8 s2516 = table6[s2515]; const SWord8 s2517 = (SWord8) s2514; const SWord8 s2518 = table7[s2517]; const SWord16 s2519 = (SWord16) s592; const SWord8 s2520 = (SWord8) (s2519 >> 8); const SWord8 s2521 = table8[s2520]; const SWord8 s2522 = (SWord8) s2519; const SWord8 s2523 = table9[s2522]; const SWord8 s2524 = s2521 ^ s2523; const SWord8 s2525 = s2518 ^ s2524; const SWord8 s2526 = s2516 ^ s2525; const SWord8 s2527 = table9[s2515]; const SWord8 s2528 = table6[s2517]; const SWord8 s2529 = table7[s2520]; const SWord8 s2530 = table8[s2522]; const SWord8 s2531 = s2529 ^ s2530; const SWord8 s2532 = s2528 ^ s2531; const SWord8 s2533 = s2527 ^ s2532; const SWord16 s2534 = (((SWord16) s2526) << 8) | ((SWord16) s2533); const SWord8 s2535 = table8[s2515]; const SWord8 s2536 = table9[s2517]; const SWord8 s2537 = table6[s2520]; const SWord8 s2538 = table7[s2522]; const SWord8 s2539 = s2537 ^ s2538; const SWord8 s2540 = s2536 ^ s2539; const SWord8 s2541 = s2535 ^ s2540; const SWord8 s2542 = table7[s2515]; const SWord8 s2543 = table8[s2517]; const SWord8 s2544 = table9[s2520]; const SWord8 s2545 = table6[s2522]; const SWord8 s2546 = s2544 ^ s2545; const SWord8 s2547 = s2543 ^ s2546; const SWord8 s2548 = s2542 ^ s2547; const SWord16 s2549 = (((SWord16) s2541) << 8) | ((SWord16) s2548); const SWord32 s2550 = (((SWord32) s2534) << 16) | ((SWord32) s2549); const SWord32 s2551 = s2513 ^ s2550; const SWord16 s2552 = (SWord16) (s2551 >> 16); const SWord8 s2553 = (SWord8) (s2552 >> 8); const SWord32 s2554 = table1[s2553]; const SWord8 s2555 = (SWord8) (s2402 >> 8); const SWord32 s2556 = table1[s2555]; const SWord16 s2557 = (SWord16) (s2456 >> 16); const SWord8 s2558 = (SWord8) s2557; const SWord32 s2559 = table3[s2558]; const SWord32 s2560 = s2556 ^ s2559; const SWord8 s2561 = (SWord8) (s2510 >> 8); const SWord32 s2562 = table4[s2561]; const SWord32 s2563 = s2560 ^ s2562; const SWord16 s2564 = (SWord16) s2347; const SWord8 s2565 = (SWord8) s2564; const SWord32 s2566 = table5[s2565]; const SWord32 s2567 = s2563 ^ s2566; const SWord16 s2568 = (SWord16) (s595 >> 16); const SWord8 s2569 = (SWord8) (s2568 >> 8); const SWord8 s2570 = table6[s2569]; const SWord8 s2571 = (SWord8) s2568; const SWord8 s2572 = table7[s2571]; const SWord16 s2573 = (SWord16) s595; const SWord8 s2574 = (SWord8) (s2573 >> 8); const SWord8 s2575 = table8[s2574]; const SWord8 s2576 = (SWord8) s2573; const SWord8 s2577 = table9[s2576]; const SWord8 s2578 = s2575 ^ s2577; const SWord8 s2579 = s2572 ^ s2578; const SWord8 s2580 = s2570 ^ s2579; const SWord8 s2581 = table9[s2569]; const SWord8 s2582 = table6[s2571]; const SWord8 s2583 = table7[s2574]; const SWord8 s2584 = table8[s2576]; const SWord8 s2585 = s2583 ^ s2584; const SWord8 s2586 = s2582 ^ s2585; const SWord8 s2587 = s2581 ^ s2586; const SWord16 s2588 = (((SWord16) s2580) << 8) | ((SWord16) s2587); const SWord8 s2589 = table8[s2569]; const SWord8 s2590 = table9[s2571]; const SWord8 s2591 = table6[s2574]; const SWord8 s2592 = table7[s2576]; const SWord8 s2593 = s2591 ^ s2592; const SWord8 s2594 = s2590 ^ s2593; const SWord8 s2595 = s2589 ^ s2594; const SWord8 s2596 = table7[s2569]; const SWord8 s2597 = table8[s2571]; const SWord8 s2598 = table9[s2574]; const SWord8 s2599 = table6[s2576]; const SWord8 s2600 = s2598 ^ s2599; const SWord8 s2601 = s2597 ^ s2600; const SWord8 s2602 = s2596 ^ s2601; const SWord16 s2603 = (((SWord16) s2595) << 8) | ((SWord16) s2602); const SWord32 s2604 = (((SWord32) s2588) << 16) | ((SWord32) s2603); const SWord32 s2605 = s2567 ^ s2604; const SWord16 s2606 = (SWord16) (s2605 >> 16); const SWord8 s2607 = (SWord8) s2606; const SWord32 s2608 = table3[s2607]; const SWord32 s2609 = s2554 ^ s2608; const SWord8 s2610 = (SWord8) (s2557 >> 8); const SWord32 s2611 = table1[s2610]; const SWord16 s2612 = (SWord16) (s2509 >> 16); const SWord8 s2613 = (SWord8) s2612; const SWord32 s2614 = table3[s2613]; const SWord32 s2615 = s2611 ^ s2614; const SWord8 s2616 = (SWord8) (s2564 >> 8); const SWord32 s2617 = table4[s2616]; const SWord32 s2618 = s2615 ^ s2617; const SWord16 s2619 = (SWord16) s2401; const SWord8 s2620 = (SWord8) s2619; const SWord32 s2621 = table5[s2620]; const SWord32 s2622 = s2618 ^ s2621; const SWord16 s2623 = (SWord16) (s594 >> 16); const SWord8 s2624 = (SWord8) (s2623 >> 8); const SWord8 s2625 = table6[s2624]; const SWord8 s2626 = (SWord8) s2623; const SWord8 s2627 = table7[s2626]; const SWord16 s2628 = (SWord16) s594; const SWord8 s2629 = (SWord8) (s2628 >> 8); const SWord8 s2630 = table8[s2629]; const SWord8 s2631 = (SWord8) s2628; const SWord8 s2632 = table9[s2631]; const SWord8 s2633 = s2630 ^ s2632; const SWord8 s2634 = s2627 ^ s2633; const SWord8 s2635 = s2625 ^ s2634; const SWord8 s2636 = table9[s2624]; const SWord8 s2637 = table6[s2626]; const SWord8 s2638 = table7[s2629]; const SWord8 s2639 = table8[s2631]; const SWord8 s2640 = s2638 ^ s2639; const SWord8 s2641 = s2637 ^ s2640; const SWord8 s2642 = s2636 ^ s2641; const SWord16 s2643 = (((SWord16) s2635) << 8) | ((SWord16) s2642); const SWord8 s2644 = table8[s2624]; const SWord8 s2645 = table9[s2626]; const SWord8 s2646 = table6[s2629]; const SWord8 s2647 = table7[s2631]; const SWord8 s2648 = s2646 ^ s2647; const SWord8 s2649 = s2645 ^ s2648; const SWord8 s2650 = s2644 ^ s2649; const SWord8 s2651 = table7[s2624]; const SWord8 s2652 = table8[s2626]; const SWord8 s2653 = table9[s2629]; const SWord8 s2654 = table6[s2631]; const SWord8 s2655 = s2653 ^ s2654; const SWord8 s2656 = s2652 ^ s2655; const SWord8 s2657 = s2651 ^ s2656; const SWord16 s2658 = (((SWord16) s2650) << 8) | ((SWord16) s2657); const SWord32 s2659 = (((SWord32) s2643) << 16) | ((SWord32) s2658); const SWord32 s2660 = s2622 ^ s2659; const SWord16 s2661 = (SWord16) s2660; const SWord8 s2662 = (SWord8) (s2661 >> 8); const SWord32 s2663 = table4[s2662]; const SWord32 s2664 = s2609 ^ s2663; const SWord8 s2665 = (SWord8) (s2612 >> 8); const SWord32 s2666 = table1[s2665]; const SWord8 s2667 = (SWord8) s2348; const SWord32 s2668 = table3[s2667]; const SWord32 s2669 = s2666 ^ s2668; const SWord8 s2670 = (SWord8) (s2619 >> 8); const SWord32 s2671 = table4[s2670]; const SWord32 s2672 = s2669 ^ s2671; const SWord8 s2673 = (SWord8) s2457; const SWord32 s2674 = table5[s2673]; const SWord32 s2675 = s2672 ^ s2674; const SWord16 s2676 = (SWord16) (s593 >> 16); const SWord8 s2677 = (SWord8) (s2676 >> 8); const SWord8 s2678 = table6[s2677]; const SWord8 s2679 = (SWord8) s2676; const SWord8 s2680 = table7[s2679]; const SWord16 s2681 = (SWord16) s593; const SWord8 s2682 = (SWord8) (s2681 >> 8); const SWord8 s2683 = table8[s2682]; const SWord8 s2684 = (SWord8) s2681; const SWord8 s2685 = table9[s2684]; const SWord8 s2686 = s2683 ^ s2685; const SWord8 s2687 = s2680 ^ s2686; const SWord8 s2688 = s2678 ^ s2687; const SWord8 s2689 = table9[s2677]; const SWord8 s2690 = table6[s2679]; const SWord8 s2691 = table7[s2682]; const SWord8 s2692 = table8[s2684]; const SWord8 s2693 = s2691 ^ s2692; const SWord8 s2694 = s2690 ^ s2693; const SWord8 s2695 = s2689 ^ s2694; const SWord16 s2696 = (((SWord16) s2688) << 8) | ((SWord16) s2695); const SWord8 s2697 = table8[s2677]; const SWord8 s2698 = table9[s2679]; const SWord8 s2699 = table6[s2682]; const SWord8 s2700 = table7[s2684]; const SWord8 s2701 = s2699 ^ s2700; const SWord8 s2702 = s2698 ^ s2701; const SWord8 s2703 = s2697 ^ s2702; const SWord8 s2704 = table7[s2677]; const SWord8 s2705 = table8[s2679]; const SWord8 s2706 = table9[s2682]; const SWord8 s2707 = table6[s2684]; const SWord8 s2708 = s2706 ^ s2707; const SWord8 s2709 = s2705 ^ s2708; const SWord8 s2710 = s2704 ^ s2709; const SWord16 s2711 = (((SWord16) s2703) << 8) | ((SWord16) s2710); const SWord32 s2712 = (((SWord32) s2696) << 16) | ((SWord32) s2711); const SWord32 s2713 = s2675 ^ s2712; const SWord16 s2714 = (SWord16) s2713; const SWord8 s2715 = (SWord8) s2714; const SWord32 s2716 = table5[s2715]; const SWord32 s2717 = s2664 ^ s2716; const SWord16 s2718 = (SWord16) (s573 >> 16); const SWord8 s2719 = (SWord8) (s2718 >> 8); const SWord8 s2720 = table6[s2719]; const SWord8 s2721 = (SWord8) s2718; const SWord8 s2722 = table7[s2721]; const SWord16 s2723 = (SWord16) s573; const SWord8 s2724 = (SWord8) (s2723 >> 8); const SWord8 s2725 = table8[s2724]; const SWord8 s2726 = (SWord8) s2723; const SWord8 s2727 = table9[s2726]; const SWord8 s2728 = s2725 ^ s2727; const SWord8 s2729 = s2722 ^ s2728; const SWord8 s2730 = s2720 ^ s2729; const SWord8 s2731 = table9[s2719]; const SWord8 s2732 = table6[s2721]; const SWord8 s2733 = table7[s2724]; const SWord8 s2734 = table8[s2726]; const SWord8 s2735 = s2733 ^ s2734; const SWord8 s2736 = s2732 ^ s2735; const SWord8 s2737 = s2731 ^ s2736; const SWord16 s2738 = (((SWord16) s2730) << 8) | ((SWord16) s2737); const SWord8 s2739 = table8[s2719]; const SWord8 s2740 = table9[s2721]; const SWord8 s2741 = table6[s2724]; const SWord8 s2742 = table7[s2726]; const SWord8 s2743 = s2741 ^ s2742; const SWord8 s2744 = s2740 ^ s2743; const SWord8 s2745 = s2739 ^ s2744; const SWord8 s2746 = table7[s2719]; const SWord8 s2747 = table8[s2721]; const SWord8 s2748 = table9[s2724]; const SWord8 s2749 = table6[s2726]; const SWord8 s2750 = s2748 ^ s2749; const SWord8 s2751 = s2747 ^ s2750; const SWord8 s2752 = s2746 ^ s2751; const SWord16 s2753 = (((SWord16) s2745) << 8) | ((SWord16) s2752); const SWord32 s2754 = (((SWord32) s2738) << 16) | ((SWord32) s2753); const SWord32 s2755 = s2717 ^ s2754; const SWord16 s2756 = (SWord16) (s2755 >> 16); const SWord8 s2757 = (SWord8) (s2756 >> 8); const SWord32 s2758 = table1[s2757]; const SWord8 s2759 = (SWord8) (s2606 >> 8); const SWord32 s2760 = table1[s2759]; const SWord16 s2761 = (SWord16) (s2660 >> 16); const SWord8 s2762 = (SWord8) s2761; const SWord32 s2763 = table3[s2762]; const SWord32 s2764 = s2760 ^ s2763; const SWord8 s2765 = (SWord8) (s2714 >> 8); const SWord32 s2766 = table4[s2765]; const SWord32 s2767 = s2764 ^ s2766; const SWord16 s2768 = (SWord16) s2551; const SWord8 s2769 = (SWord8) s2768; const SWord32 s2770 = table5[s2769]; const SWord32 s2771 = s2767 ^ s2770; const SWord16 s2772 = (SWord16) (s576 >> 16); const SWord8 s2773 = (SWord8) (s2772 >> 8); const SWord8 s2774 = table6[s2773]; const SWord8 s2775 = (SWord8) s2772; const SWord8 s2776 = table7[s2775]; const SWord16 s2777 = (SWord16) s576; const SWord8 s2778 = (SWord8) (s2777 >> 8); const SWord8 s2779 = table8[s2778]; const SWord8 s2780 = (SWord8) s2777; const SWord8 s2781 = table9[s2780]; const SWord8 s2782 = s2779 ^ s2781; const SWord8 s2783 = s2776 ^ s2782; const SWord8 s2784 = s2774 ^ s2783; const SWord8 s2785 = table9[s2773]; const SWord8 s2786 = table6[s2775]; const SWord8 s2787 = table7[s2778]; const SWord8 s2788 = table8[s2780]; const SWord8 s2789 = s2787 ^ s2788; const SWord8 s2790 = s2786 ^ s2789; const SWord8 s2791 = s2785 ^ s2790; const SWord16 s2792 = (((SWord16) s2784) << 8) | ((SWord16) s2791); const SWord8 s2793 = table8[s2773]; const SWord8 s2794 = table9[s2775]; const SWord8 s2795 = table6[s2778]; const SWord8 s2796 = table7[s2780]; const SWord8 s2797 = s2795 ^ s2796; const SWord8 s2798 = s2794 ^ s2797; const SWord8 s2799 = s2793 ^ s2798; const SWord8 s2800 = table7[s2773]; const SWord8 s2801 = table8[s2775]; const SWord8 s2802 = table9[s2778]; const SWord8 s2803 = table6[s2780]; const SWord8 s2804 = s2802 ^ s2803; const SWord8 s2805 = s2801 ^ s2804; const SWord8 s2806 = s2800 ^ s2805; const SWord16 s2807 = (((SWord16) s2799) << 8) | ((SWord16) s2806); const SWord32 s2808 = (((SWord32) s2792) << 16) | ((SWord32) s2807); const SWord32 s2809 = s2771 ^ s2808; const SWord16 s2810 = (SWord16) (s2809 >> 16); const SWord8 s2811 = (SWord8) s2810; const SWord32 s2812 = table3[s2811]; const SWord32 s2813 = s2758 ^ s2812; const SWord8 s2814 = (SWord8) (s2761 >> 8); const SWord32 s2815 = table1[s2814]; const SWord16 s2816 = (SWord16) (s2713 >> 16); const SWord8 s2817 = (SWord8) s2816; const SWord32 s2818 = table3[s2817]; const SWord32 s2819 = s2815 ^ s2818; const SWord8 s2820 = (SWord8) (s2768 >> 8); const SWord32 s2821 = table4[s2820]; const SWord32 s2822 = s2819 ^ s2821; const SWord16 s2823 = (SWord16) s2605; const SWord8 s2824 = (SWord8) s2823; const SWord32 s2825 = table5[s2824]; const SWord32 s2826 = s2822 ^ s2825; const SWord16 s2827 = (SWord16) (s575 >> 16); const SWord8 s2828 = (SWord8) (s2827 >> 8); const SWord8 s2829 = table6[s2828]; const SWord8 s2830 = (SWord8) s2827; const SWord8 s2831 = table7[s2830]; const SWord16 s2832 = (SWord16) s575; const SWord8 s2833 = (SWord8) (s2832 >> 8); const SWord8 s2834 = table8[s2833]; const SWord8 s2835 = (SWord8) s2832; const SWord8 s2836 = table9[s2835]; const SWord8 s2837 = s2834 ^ s2836; const SWord8 s2838 = s2831 ^ s2837; const SWord8 s2839 = s2829 ^ s2838; const SWord8 s2840 = table9[s2828]; const SWord8 s2841 = table6[s2830]; const SWord8 s2842 = table7[s2833]; const SWord8 s2843 = table8[s2835]; const SWord8 s2844 = s2842 ^ s2843; const SWord8 s2845 = s2841 ^ s2844; const SWord8 s2846 = s2840 ^ s2845; const SWord16 s2847 = (((SWord16) s2839) << 8) | ((SWord16) s2846); const SWord8 s2848 = table8[s2828]; const SWord8 s2849 = table9[s2830]; const SWord8 s2850 = table6[s2833]; const SWord8 s2851 = table7[s2835]; const SWord8 s2852 = s2850 ^ s2851; const SWord8 s2853 = s2849 ^ s2852; const SWord8 s2854 = s2848 ^ s2853; const SWord8 s2855 = table7[s2828]; const SWord8 s2856 = table8[s2830]; const SWord8 s2857 = table9[s2833]; const SWord8 s2858 = table6[s2835]; const SWord8 s2859 = s2857 ^ s2858; const SWord8 s2860 = s2856 ^ s2859; const SWord8 s2861 = s2855 ^ s2860; const SWord16 s2862 = (((SWord16) s2854) << 8) | ((SWord16) s2861); const SWord32 s2863 = (((SWord32) s2847) << 16) | ((SWord32) s2862); const SWord32 s2864 = s2826 ^ s2863; const SWord16 s2865 = (SWord16) s2864; const SWord8 s2866 = (SWord8) (s2865 >> 8); const SWord32 s2867 = table4[s2866]; const SWord32 s2868 = s2813 ^ s2867; const SWord8 s2869 = (SWord8) (s2816 >> 8); const SWord32 s2870 = table1[s2869]; const SWord8 s2871 = (SWord8) s2552; const SWord32 s2872 = table3[s2871]; const SWord32 s2873 = s2870 ^ s2872; const SWord8 s2874 = (SWord8) (s2823 >> 8); const SWord32 s2875 = table4[s2874]; const SWord32 s2876 = s2873 ^ s2875; const SWord8 s2877 = (SWord8) s2661; const SWord32 s2878 = table5[s2877]; const SWord32 s2879 = s2876 ^ s2878; const SWord16 s2880 = (SWord16) (s574 >> 16); const SWord8 s2881 = (SWord8) (s2880 >> 8); const SWord8 s2882 = table6[s2881]; const SWord8 s2883 = (SWord8) s2880; const SWord8 s2884 = table7[s2883]; const SWord16 s2885 = (SWord16) s574; const SWord8 s2886 = (SWord8) (s2885 >> 8); const SWord8 s2887 = table8[s2886]; const SWord8 s2888 = (SWord8) s2885; const SWord8 s2889 = table9[s2888]; const SWord8 s2890 = s2887 ^ s2889; const SWord8 s2891 = s2884 ^ s2890; const SWord8 s2892 = s2882 ^ s2891; const SWord8 s2893 = table9[s2881]; const SWord8 s2894 = table6[s2883]; const SWord8 s2895 = table7[s2886]; const SWord8 s2896 = table8[s2888]; const SWord8 s2897 = s2895 ^ s2896; const SWord8 s2898 = s2894 ^ s2897; const SWord8 s2899 = s2893 ^ s2898; const SWord16 s2900 = (((SWord16) s2892) << 8) | ((SWord16) s2899); const SWord8 s2901 = table8[s2881]; const SWord8 s2902 = table9[s2883]; const SWord8 s2903 = table6[s2886]; const SWord8 s2904 = table7[s2888]; const SWord8 s2905 = s2903 ^ s2904; const SWord8 s2906 = s2902 ^ s2905; const SWord8 s2907 = s2901 ^ s2906; const SWord8 s2908 = table7[s2881]; const SWord8 s2909 = table8[s2883]; const SWord8 s2910 = table9[s2886]; const SWord8 s2911 = table6[s2888]; const SWord8 s2912 = s2910 ^ s2911; const SWord8 s2913 = s2909 ^ s2912; const SWord8 s2914 = s2908 ^ s2913; const SWord16 s2915 = (((SWord16) s2907) << 8) | ((SWord16) s2914); const SWord32 s2916 = (((SWord32) s2900) << 16) | ((SWord32) s2915); const SWord32 s2917 = s2879 ^ s2916; const SWord16 s2918 = (SWord16) s2917; const SWord8 s2919 = (SWord8) s2918; const SWord32 s2920 = table5[s2919]; const SWord32 s2921 = s2868 ^ s2920; const SWord16 s2922 = (SWord16) (s554 >> 16); const SWord8 s2923 = (SWord8) (s2922 >> 8); const SWord8 s2924 = table6[s2923]; const SWord8 s2925 = (SWord8) s2922; const SWord8 s2926 = table7[s2925]; const SWord16 s2927 = (SWord16) s554; const SWord8 s2928 = (SWord8) (s2927 >> 8); const SWord8 s2929 = table8[s2928]; const SWord8 s2930 = (SWord8) s2927; const SWord8 s2931 = table9[s2930]; const SWord8 s2932 = s2929 ^ s2931; const SWord8 s2933 = s2926 ^ s2932; const SWord8 s2934 = s2924 ^ s2933; const SWord8 s2935 = table9[s2923]; const SWord8 s2936 = table6[s2925]; const SWord8 s2937 = table7[s2928]; const SWord8 s2938 = table8[s2930]; const SWord8 s2939 = s2937 ^ s2938; const SWord8 s2940 = s2936 ^ s2939; const SWord8 s2941 = s2935 ^ s2940; const SWord16 s2942 = (((SWord16) s2934) << 8) | ((SWord16) s2941); const SWord8 s2943 = table8[s2923]; const SWord8 s2944 = table9[s2925]; const SWord8 s2945 = table6[s2928]; const SWord8 s2946 = table7[s2930]; const SWord8 s2947 = s2945 ^ s2946; const SWord8 s2948 = s2944 ^ s2947; const SWord8 s2949 = s2943 ^ s2948; const SWord8 s2950 = table7[s2923]; const SWord8 s2951 = table8[s2925]; const SWord8 s2952 = table9[s2928]; const SWord8 s2953 = table6[s2930]; const SWord8 s2954 = s2952 ^ s2953; const SWord8 s2955 = s2951 ^ s2954; const SWord8 s2956 = s2950 ^ s2955; const SWord16 s2957 = (((SWord16) s2949) << 8) | ((SWord16) s2956); const SWord32 s2958 = (((SWord32) s2942) << 16) | ((SWord32) s2957); const SWord32 s2959 = s2921 ^ s2958; const SWord16 s2960 = (SWord16) (s2959 >> 16); const SWord8 s2961 = (SWord8) (s2960 >> 8); const SWord32 s2962 = table1[s2961]; const SWord8 s2963 = (SWord8) (s2810 >> 8); const SWord32 s2964 = table1[s2963]; const SWord16 s2965 = (SWord16) (s2864 >> 16); const SWord8 s2966 = (SWord8) s2965; const SWord32 s2967 = table3[s2966]; const SWord32 s2968 = s2964 ^ s2967; const SWord8 s2969 = (SWord8) (s2918 >> 8); const SWord32 s2970 = table4[s2969]; const SWord32 s2971 = s2968 ^ s2970; const SWord16 s2972 = (SWord16) s2755; const SWord8 s2973 = (SWord8) s2972; const SWord32 s2974 = table5[s2973]; const SWord32 s2975 = s2971 ^ s2974; const SWord16 s2976 = (SWord16) (s557 >> 16); const SWord8 s2977 = (SWord8) (s2976 >> 8); const SWord8 s2978 = table6[s2977]; const SWord8 s2979 = (SWord8) s2976; const SWord8 s2980 = table7[s2979]; const SWord16 s2981 = (SWord16) s557; const SWord8 s2982 = (SWord8) (s2981 >> 8); const SWord8 s2983 = table8[s2982]; const SWord8 s2984 = (SWord8) s2981; const SWord8 s2985 = table9[s2984]; const SWord8 s2986 = s2983 ^ s2985; const SWord8 s2987 = s2980 ^ s2986; const SWord8 s2988 = s2978 ^ s2987; const SWord8 s2989 = table9[s2977]; const SWord8 s2990 = table6[s2979]; const SWord8 s2991 = table7[s2982]; const SWord8 s2992 = table8[s2984]; const SWord8 s2993 = s2991 ^ s2992; const SWord8 s2994 = s2990 ^ s2993; const SWord8 s2995 = s2989 ^ s2994; const SWord16 s2996 = (((SWord16) s2988) << 8) | ((SWord16) s2995); const SWord8 s2997 = table8[s2977]; const SWord8 s2998 = table9[s2979]; const SWord8 s2999 = table6[s2982]; const SWord8 s3000 = table7[s2984]; const SWord8 s3001 = s2999 ^ s3000; const SWord8 s3002 = s2998 ^ s3001; const SWord8 s3003 = s2997 ^ s3002; const SWord8 s3004 = table7[s2977]; const SWord8 s3005 = table8[s2979]; const SWord8 s3006 = table9[s2982]; const SWord8 s3007 = table6[s2984]; const SWord8 s3008 = s3006 ^ s3007; const SWord8 s3009 = s3005 ^ s3008; const SWord8 s3010 = s3004 ^ s3009; const SWord16 s3011 = (((SWord16) s3003) << 8) | ((SWord16) s3010); const SWord32 s3012 = (((SWord32) s2996) << 16) | ((SWord32) s3011); const SWord32 s3013 = s2975 ^ s3012; const SWord16 s3014 = (SWord16) (s3013 >> 16); const SWord8 s3015 = (SWord8) s3014; const SWord32 s3016 = table3[s3015]; const SWord32 s3017 = s2962 ^ s3016; const SWord8 s3018 = (SWord8) (s2965 >> 8); const SWord32 s3019 = table1[s3018]; const SWord16 s3020 = (SWord16) (s2917 >> 16); const SWord8 s3021 = (SWord8) s3020; const SWord32 s3022 = table3[s3021]; const SWord32 s3023 = s3019 ^ s3022; const SWord8 s3024 = (SWord8) (s2972 >> 8); const SWord32 s3025 = table4[s3024]; const SWord32 s3026 = s3023 ^ s3025; const SWord16 s3027 = (SWord16) s2809; const SWord8 s3028 = (SWord8) s3027; const SWord32 s3029 = table5[s3028]; const SWord32 s3030 = s3026 ^ s3029; const SWord16 s3031 = (SWord16) (s556 >> 16); const SWord8 s3032 = (SWord8) (s3031 >> 8); const SWord8 s3033 = table6[s3032]; const SWord8 s3034 = (SWord8) s3031; const SWord8 s3035 = table7[s3034]; const SWord16 s3036 = (SWord16) s556; const SWord8 s3037 = (SWord8) (s3036 >> 8); const SWord8 s3038 = table8[s3037]; const SWord8 s3039 = (SWord8) s3036; const SWord8 s3040 = table9[s3039]; const SWord8 s3041 = s3038 ^ s3040; const SWord8 s3042 = s3035 ^ s3041; const SWord8 s3043 = s3033 ^ s3042; const SWord8 s3044 = table9[s3032]; const SWord8 s3045 = table6[s3034]; const SWord8 s3046 = table7[s3037]; const SWord8 s3047 = table8[s3039]; const SWord8 s3048 = s3046 ^ s3047; const SWord8 s3049 = s3045 ^ s3048; const SWord8 s3050 = s3044 ^ s3049; const SWord16 s3051 = (((SWord16) s3043) << 8) | ((SWord16) s3050); const SWord8 s3052 = table8[s3032]; const SWord8 s3053 = table9[s3034]; const SWord8 s3054 = table6[s3037]; const SWord8 s3055 = table7[s3039]; const SWord8 s3056 = s3054 ^ s3055; const SWord8 s3057 = s3053 ^ s3056; const SWord8 s3058 = s3052 ^ s3057; const SWord8 s3059 = table7[s3032]; const SWord8 s3060 = table8[s3034]; const SWord8 s3061 = table9[s3037]; const SWord8 s3062 = table6[s3039]; const SWord8 s3063 = s3061 ^ s3062; const SWord8 s3064 = s3060 ^ s3063; const SWord8 s3065 = s3059 ^ s3064; const SWord16 s3066 = (((SWord16) s3058) << 8) | ((SWord16) s3065); const SWord32 s3067 = (((SWord32) s3051) << 16) | ((SWord32) s3066); const SWord32 s3068 = s3030 ^ s3067; const SWord16 s3069 = (SWord16) s3068; const SWord8 s3070 = (SWord8) (s3069 >> 8); const SWord32 s3071 = table4[s3070]; const SWord32 s3072 = s3017 ^ s3071; const SWord8 s3073 = (SWord8) (s3020 >> 8); const SWord32 s3074 = table1[s3073]; const SWord8 s3075 = (SWord8) s2756; const SWord32 s3076 = table3[s3075]; const SWord32 s3077 = s3074 ^ s3076; const SWord8 s3078 = (SWord8) (s3027 >> 8); const SWord32 s3079 = table4[s3078]; const SWord32 s3080 = s3077 ^ s3079; const SWord8 s3081 = (SWord8) s2865; const SWord32 s3082 = table5[s3081]; const SWord32 s3083 = s3080 ^ s3082; const SWord16 s3084 = (SWord16) (s555 >> 16); const SWord8 s3085 = (SWord8) (s3084 >> 8); const SWord8 s3086 = table6[s3085]; const SWord8 s3087 = (SWord8) s3084; const SWord8 s3088 = table7[s3087]; const SWord16 s3089 = (SWord16) s555; const SWord8 s3090 = (SWord8) (s3089 >> 8); const SWord8 s3091 = table8[s3090]; const SWord8 s3092 = (SWord8) s3089; const SWord8 s3093 = table9[s3092]; const SWord8 s3094 = s3091 ^ s3093; const SWord8 s3095 = s3088 ^ s3094; const SWord8 s3096 = s3086 ^ s3095; const SWord8 s3097 = table9[s3085]; const SWord8 s3098 = table6[s3087]; const SWord8 s3099 = table7[s3090]; const SWord8 s3100 = table8[s3092]; const SWord8 s3101 = s3099 ^ s3100; const SWord8 s3102 = s3098 ^ s3101; const SWord8 s3103 = s3097 ^ s3102; const SWord16 s3104 = (((SWord16) s3096) << 8) | ((SWord16) s3103); const SWord8 s3105 = table8[s3085]; const SWord8 s3106 = table9[s3087]; const SWord8 s3107 = table6[s3090]; const SWord8 s3108 = table7[s3092]; const SWord8 s3109 = s3107 ^ s3108; const SWord8 s3110 = s3106 ^ s3109; const SWord8 s3111 = s3105 ^ s3110; const SWord8 s3112 = table7[s3085]; const SWord8 s3113 = table8[s3087]; const SWord8 s3114 = table9[s3090]; const SWord8 s3115 = table6[s3092]; const SWord8 s3116 = s3114 ^ s3115; const SWord8 s3117 = s3113 ^ s3116; const SWord8 s3118 = s3112 ^ s3117; const SWord16 s3119 = (((SWord16) s3111) << 8) | ((SWord16) s3118); const SWord32 s3120 = (((SWord32) s3104) << 16) | ((SWord32) s3119); const SWord32 s3121 = s3083 ^ s3120; const SWord16 s3122 = (SWord16) s3121; const SWord8 s3123 = (SWord8) s3122; const SWord32 s3124 = table5[s3123]; const SWord32 s3125 = s3072 ^ s3124; const SWord16 s3126 = (SWord16) (s535 >> 16); const SWord8 s3127 = (SWord8) (s3126 >> 8); const SWord8 s3128 = table6[s3127]; const SWord8 s3129 = (SWord8) s3126; const SWord8 s3130 = table7[s3129]; const SWord16 s3131 = (SWord16) s535; const SWord8 s3132 = (SWord8) (s3131 >> 8); const SWord8 s3133 = table8[s3132]; const SWord8 s3134 = (SWord8) s3131; const SWord8 s3135 = table9[s3134]; const SWord8 s3136 = s3133 ^ s3135; const SWord8 s3137 = s3130 ^ s3136; const SWord8 s3138 = s3128 ^ s3137; const SWord8 s3139 = table9[s3127]; const SWord8 s3140 = table6[s3129]; const SWord8 s3141 = table7[s3132]; const SWord8 s3142 = table8[s3134]; const SWord8 s3143 = s3141 ^ s3142; const SWord8 s3144 = s3140 ^ s3143; const SWord8 s3145 = s3139 ^ s3144; const SWord16 s3146 = (((SWord16) s3138) << 8) | ((SWord16) s3145); const SWord8 s3147 = table8[s3127]; const SWord8 s3148 = table9[s3129]; const SWord8 s3149 = table6[s3132]; const SWord8 s3150 = table7[s3134]; const SWord8 s3151 = s3149 ^ s3150; const SWord8 s3152 = s3148 ^ s3151; const SWord8 s3153 = s3147 ^ s3152; const SWord8 s3154 = table7[s3127]; const SWord8 s3155 = table8[s3129]; const SWord8 s3156 = table9[s3132]; const SWord8 s3157 = table6[s3134]; const SWord8 s3158 = s3156 ^ s3157; const SWord8 s3159 = s3155 ^ s3158; const SWord8 s3160 = s3154 ^ s3159; const SWord16 s3161 = (((SWord16) s3153) << 8) | ((SWord16) s3160); const SWord32 s3162 = (((SWord32) s3146) << 16) | ((SWord32) s3161); const SWord32 s3163 = s3125 ^ s3162; const SWord16 s3164 = (SWord16) (s3163 >> 16); const SWord8 s3165 = (SWord8) (s3164 >> 8); const SWord8 s3166 = table0[s3165]; const SWord8 s3167 = (SWord8) (s3014 >> 8); const SWord32 s3168 = table1[s3167]; const SWord16 s3169 = (SWord16) (s3068 >> 16); const SWord8 s3170 = (SWord8) s3169; const SWord32 s3171 = table3[s3170]; const SWord32 s3172 = s3168 ^ s3171; const SWord8 s3173 = (SWord8) (s3122 >> 8); const SWord32 s3174 = table4[s3173]; const SWord32 s3175 = s3172 ^ s3174; const SWord16 s3176 = (SWord16) s2959; const SWord8 s3177 = (SWord8) s3176; const SWord32 s3178 = table5[s3177]; const SWord32 s3179 = s3175 ^ s3178; const SWord16 s3180 = (SWord16) (s538 >> 16); const SWord8 s3181 = (SWord8) (s3180 >> 8); const SWord8 s3182 = table6[s3181]; const SWord8 s3183 = (SWord8) s3180; const SWord8 s3184 = table7[s3183]; const SWord16 s3185 = (SWord16) s538; const SWord8 s3186 = (SWord8) (s3185 >> 8); const SWord8 s3187 = table8[s3186]; const SWord8 s3188 = (SWord8) s3185; const SWord8 s3189 = table9[s3188]; const SWord8 s3190 = s3187 ^ s3189; const SWord8 s3191 = s3184 ^ s3190; const SWord8 s3192 = s3182 ^ s3191; const SWord8 s3193 = table9[s3181]; const SWord8 s3194 = table6[s3183]; const SWord8 s3195 = table7[s3186]; const SWord8 s3196 = table8[s3188]; const SWord8 s3197 = s3195 ^ s3196; const SWord8 s3198 = s3194 ^ s3197; const SWord8 s3199 = s3193 ^ s3198; const SWord16 s3200 = (((SWord16) s3192) << 8) | ((SWord16) s3199); const SWord8 s3201 = table8[s3181]; const SWord8 s3202 = table9[s3183]; const SWord8 s3203 = table6[s3186]; const SWord8 s3204 = table7[s3188]; const SWord8 s3205 = s3203 ^ s3204; const SWord8 s3206 = s3202 ^ s3205; const SWord8 s3207 = s3201 ^ s3206; const SWord8 s3208 = table7[s3181]; const SWord8 s3209 = table8[s3183]; const SWord8 s3210 = table9[s3186]; const SWord8 s3211 = table6[s3188]; const SWord8 s3212 = s3210 ^ s3211; const SWord8 s3213 = s3209 ^ s3212; const SWord8 s3214 = s3208 ^ s3213; const SWord16 s3215 = (((SWord16) s3207) << 8) | ((SWord16) s3214); const SWord32 s3216 = (((SWord32) s3200) << 16) | ((SWord32) s3215); const SWord32 s3217 = s3179 ^ s3216; const SWord16 s3218 = (SWord16) (s3217 >> 16); const SWord8 s3219 = (SWord8) s3218; const SWord8 s3220 = table0[s3219]; const SWord16 s3221 = (((SWord16) s3166) << 8) | ((SWord16) s3220); const SWord8 s3222 = (SWord8) (s3169 >> 8); const SWord32 s3223 = table1[s3222]; const SWord16 s3224 = (SWord16) (s3121 >> 16); const SWord8 s3225 = (SWord8) s3224; const SWord32 s3226 = table3[s3225]; const SWord32 s3227 = s3223 ^ s3226; const SWord8 s3228 = (SWord8) (s3176 >> 8); const SWord32 s3229 = table4[s3228]; const SWord32 s3230 = s3227 ^ s3229; const SWord16 s3231 = (SWord16) s3013; const SWord8 s3232 = (SWord8) s3231; const SWord32 s3233 = table5[s3232]; const SWord32 s3234 = s3230 ^ s3233; const SWord16 s3235 = (SWord16) (s537 >> 16); const SWord8 s3236 = (SWord8) (s3235 >> 8); const SWord8 s3237 = table6[s3236]; const SWord8 s3238 = (SWord8) s3235; const SWord8 s3239 = table7[s3238]; const SWord16 s3240 = (SWord16) s537; const SWord8 s3241 = (SWord8) (s3240 >> 8); const SWord8 s3242 = table8[s3241]; const SWord8 s3243 = (SWord8) s3240; const SWord8 s3244 = table9[s3243]; const SWord8 s3245 = s3242 ^ s3244; const SWord8 s3246 = s3239 ^ s3245; const SWord8 s3247 = s3237 ^ s3246; const SWord8 s3248 = table9[s3236]; const SWord8 s3249 = table6[s3238]; const SWord8 s3250 = table7[s3241]; const SWord8 s3251 = table8[s3243]; const SWord8 s3252 = s3250 ^ s3251; const SWord8 s3253 = s3249 ^ s3252; const SWord8 s3254 = s3248 ^ s3253; const SWord16 s3255 = (((SWord16) s3247) << 8) | ((SWord16) s3254); const SWord8 s3256 = table8[s3236]; const SWord8 s3257 = table9[s3238]; const SWord8 s3258 = table6[s3241]; const SWord8 s3259 = table7[s3243]; const SWord8 s3260 = s3258 ^ s3259; const SWord8 s3261 = s3257 ^ s3260; const SWord8 s3262 = s3256 ^ s3261; const SWord8 s3263 = table7[s3236]; const SWord8 s3264 = table8[s3238]; const SWord8 s3265 = table9[s3241]; const SWord8 s3266 = table6[s3243]; const SWord8 s3267 = s3265 ^ s3266; const SWord8 s3268 = s3264 ^ s3267; const SWord8 s3269 = s3263 ^ s3268; const SWord16 s3270 = (((SWord16) s3262) << 8) | ((SWord16) s3269); const SWord32 s3271 = (((SWord32) s3255) << 16) | ((SWord32) s3270); const SWord32 s3272 = s3234 ^ s3271; const SWord16 s3273 = (SWord16) s3272; const SWord8 s3274 = (SWord8) (s3273 >> 8); const SWord8 s3275 = table0[s3274]; const SWord8 s3276 = (SWord8) (s3224 >> 8); const SWord32 s3277 = table1[s3276]; const SWord8 s3278 = (SWord8) s2960; const SWord32 s3279 = table3[s3278]; const SWord32 s3280 = s3277 ^ s3279; const SWord8 s3281 = (SWord8) (s3231 >> 8); const SWord32 s3282 = table4[s3281]; const SWord32 s3283 = s3280 ^ s3282; const SWord8 s3284 = (SWord8) s3069; const SWord32 s3285 = table5[s3284]; const SWord32 s3286 = s3283 ^ s3285; const SWord16 s3287 = (SWord16) (s536 >> 16); const SWord8 s3288 = (SWord8) (s3287 >> 8); const SWord8 s3289 = table6[s3288]; const SWord8 s3290 = (SWord8) s3287; const SWord8 s3291 = table7[s3290]; const SWord16 s3292 = (SWord16) s536; const SWord8 s3293 = (SWord8) (s3292 >> 8); const SWord8 s3294 = table8[s3293]; const SWord8 s3295 = (SWord8) s3292; const SWord8 s3296 = table9[s3295]; const SWord8 s3297 = s3294 ^ s3296; const SWord8 s3298 = s3291 ^ s3297; const SWord8 s3299 = s3289 ^ s3298; const SWord8 s3300 = table9[s3288]; const SWord8 s3301 = table6[s3290]; const SWord8 s3302 = table7[s3293]; const SWord8 s3303 = table8[s3295]; const SWord8 s3304 = s3302 ^ s3303; const SWord8 s3305 = s3301 ^ s3304; const SWord8 s3306 = s3300 ^ s3305; const SWord16 s3307 = (((SWord16) s3299) << 8) | ((SWord16) s3306); const SWord8 s3308 = table8[s3288]; const SWord8 s3309 = table9[s3290]; const SWord8 s3310 = table6[s3293]; const SWord8 s3311 = table7[s3295]; const SWord8 s3312 = s3310 ^ s3311; const SWord8 s3313 = s3309 ^ s3312; const SWord8 s3314 = s3308 ^ s3313; const SWord8 s3315 = table7[s3288]; const SWord8 s3316 = table8[s3290]; const SWord8 s3317 = table9[s3293]; const SWord8 s3318 = table6[s3295]; const SWord8 s3319 = s3317 ^ s3318; const SWord8 s3320 = s3316 ^ s3319; const SWord8 s3321 = s3315 ^ s3320; const SWord16 s3322 = (((SWord16) s3314) << 8) | ((SWord16) s3321); const SWord32 s3323 = (((SWord32) s3307) << 16) | ((SWord32) s3322); const SWord32 s3324 = s3286 ^ s3323; const SWord16 s3325 = (SWord16) s3324; const SWord8 s3326 = (SWord8) s3325; const SWord8 s3327 = table0[s3326]; const SWord16 s3328 = (((SWord16) s3275) << 8) | ((SWord16) s3327); const SWord32 s3329 = (((SWord32) s3221) << 16) | ((SWord32) s3328); const SWord32 s3330 = s4 ^ s3329; const SWord16 s3331 = (SWord16) (s3324 >> 16); const SWord8 s3332 = (SWord8) (s3331 >> 8); const SWord8 s3333 = table0[s3332]; const SWord8 s3334 = (SWord8) s3164; const SWord8 s3335 = table0[s3334]; const SWord16 s3336 = (((SWord16) s3333) << 8) | ((SWord16) s3335); const SWord16 s3337 = (SWord16) s3217; const SWord8 s3338 = (SWord8) (s3337 >> 8); const SWord8 s3339 = table0[s3338]; const SWord8 s3340 = (SWord8) s3273; const SWord8 s3341 = table0[s3340]; const SWord16 s3342 = (((SWord16) s3339) << 8) | ((SWord16) s3341); const SWord32 s3343 = (((SWord32) s3336) << 16) | ((SWord32) s3342); const SWord32 s3344 = s5 ^ s3343; const SWord16 s3345 = (SWord16) (s3272 >> 16); const SWord8 s3346 = (SWord8) (s3345 >> 8); const SWord8 s3347 = table0[s3346]; const SWord8 s3348 = (SWord8) s3331; const SWord8 s3349 = table0[s3348]; const SWord16 s3350 = (((SWord16) s3347) << 8) | ((SWord16) s3349); const SWord16 s3351 = (SWord16) s3163; const SWord8 s3352 = (SWord8) (s3351 >> 8); const SWord8 s3353 = table0[s3352]; const SWord8 s3354 = (SWord8) s3337; const SWord8 s3355 = table0[s3354]; const SWord16 s3356 = (((SWord16) s3353) << 8) | ((SWord16) s3355); const SWord32 s3357 = (((SWord32) s3350) << 16) | ((SWord32) s3356); const SWord32 s3358 = s6 ^ s3357; const SWord8 s3359 = (SWord8) (s3218 >> 8); const SWord8 s3360 = table0[s3359]; const SWord8 s3361 = (SWord8) s3345; const SWord8 s3362 = table0[s3361]; const SWord16 s3363 = (((SWord16) s3360) << 8) | ((SWord16) s3362); const SWord8 s3364 = (SWord8) (s3325 >> 8); const SWord8 s3365 = table0[s3364]; const SWord8 s3366 = (SWord8) s3351; const SWord8 s3367 = table0[s3366]; const SWord16 s3368 = (((SWord16) s3365) << 8) | ((SWord16) s3367); const SWord32 s3369 = (((SWord32) s3363) << 16) | ((SWord32) s3368); const SWord32 s3370 = s7 ^ s3369; ct[0] = s3330; ct[1] = s3344; ct[2] = s3358; ct[3] = s3370; } == END: "aes128Dec.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/aes128Enc.gold0000644000000000000000000014706312725411266016744 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for aes128Enc. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: aes128Enc_driver aes128Enc.o: aes128Enc.c aes128Enc.h ${CC} ${CCFLAGS} -c $< -o $@ aes128Enc_driver.o: aes128Enc_driver.c ${CC} ${CCFLAGS} -c $< -o $@ aes128Enc_driver: aes128Enc.o aes128Enc_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f aes128Enc_driver == END: "Makefile" ================== == BEGIN: "aes128Enc.h" ================ /* Header file for aes128Enc. Automatically generated by SBV. Do not edit! */ #ifndef __aes128Enc__HEADER_INCLUDED__ #define __aes128Enc__HEADER_INCLUDED__ #include #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[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]); const SWord32 key[4] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array key:\n"); int key_ctr; for(key_ctr = 0; key_ctr < 4 ; ++key_ctr) printf(" key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]); SWord32 ct[4]; aes128Enc(pt, key, ct); printf("aes128Enc(pt, key, ct) ->\n"); int ct_ctr; for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr) printf(" ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); return 0; } == END: "aes128Enc_driver.c" ================== == BEGIN: "aes128Enc.c" ================ /* File: "aes128Enc.c". Automatically generated by SBV. Do not edit! */ #include "aes128Enc.h" void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct) { const SWord32 s0 = pt[0]; const SWord32 s1 = pt[1]; const SWord32 s2 = pt[2]; const SWord32 s3 = pt[3]; const SWord32 s4 = key[0]; const SWord32 s5 = key[1]; const SWord32 s6 = key[2]; const SWord32 s7 = key[3]; static const SWord8 table0[] = { 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22 }; static const SWord32 table1[] = { 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, 0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL, 0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL, 0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL, 0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL, 0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL, 0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL, 0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL, 0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL, 0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL, 0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL, 0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL, 0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL, 0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL, 0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL, 0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL, 0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL, 0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL, 0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL, 0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL, 0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL, 0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL, 0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL, 0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL, 0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL, 0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL, 0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL, 0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL, 0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL, 0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL, 0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL, 0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL, 0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL, 0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL, 0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL, 0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL, 0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL, 0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL, 0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL, 0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL, 0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL, 0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL, 0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL, 0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL, 0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL, 0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL, 0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL, 0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL, 0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL, 0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL, 0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL, 0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL, 0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL, 0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL, 0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL, 0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL, 0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL, 0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL, 0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL, 0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL, 0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL }; static const SWord32 table2[] = { 0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL, 0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL, 0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL, 0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL, 0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL, 0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL, 0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL, 0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL, 0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL, 0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL, 0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL, 0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL, 0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL, 0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL, 0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL, 0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL, 0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL, 0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL, 0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL, 0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL, 0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL, 0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL, 0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL, 0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL, 0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL, 0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL, 0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL, 0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL, 0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL, 0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL, 0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL, 0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL, 0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL, 0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL, 0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL, 0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL, 0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL, 0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL, 0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL, 0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL, 0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL, 0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL, 0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL, 0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL, 0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL, 0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL, 0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL, 0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL, 0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL, 0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL, 0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL, 0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL, 0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL, 0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL, 0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL, 0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL, 0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL, 0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL, 0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL, 0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL, 0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL, 0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL, 0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL, 0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL }; static const SWord32 table3[] = { 0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL, 0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL, 0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL, 0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL, 0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL, 0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL, 0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL, 0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL, 0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL, 0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL, 0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL, 0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL, 0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL, 0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL, 0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL, 0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL, 0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL, 0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL, 0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL, 0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL, 0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL, 0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL, 0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL, 0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL, 0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL, 0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL, 0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL, 0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL, 0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL, 0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL, 0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL, 0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL, 0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL, 0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL, 0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL, 0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL, 0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL, 0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL, 0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL, 0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL, 0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL, 0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL, 0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL, 0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL, 0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL, 0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL, 0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL, 0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL, 0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL, 0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL, 0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL, 0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL, 0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL, 0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL, 0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL, 0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL, 0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL, 0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL, 0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL, 0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL, 0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL, 0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL, 0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL, 0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL }; static const SWord32 table4[] = { 0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL, 0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL, 0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL, 0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL, 0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL, 0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL, 0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL, 0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL, 0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL, 0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL, 0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL, 0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL, 0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL, 0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL, 0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL, 0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL, 0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL, 0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL, 0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL, 0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL, 0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL, 0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL, 0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL, 0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL, 0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL, 0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL, 0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL, 0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL, 0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL, 0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL, 0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL, 0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL, 0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL, 0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL, 0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL, 0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL, 0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL, 0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL, 0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL, 0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL, 0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL, 0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL, 0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL, 0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL, 0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL, 0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL, 0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL, 0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL, 0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL, 0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL, 0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL, 0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL, 0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL, 0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL, 0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL, 0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL, 0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL, 0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL, 0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL, 0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL, 0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL, 0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL, 0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL, 0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL }; const SWord32 s520 = s0 ^ s4; const SWord16 s521 = (SWord16) (s520 >> 16); const SWord8 s522 = (SWord8) (s521 >> 8); const SWord32 s523 = table1[s522]; const SWord32 s779 = s1 ^ s5; const SWord16 s780 = (SWord16) (s779 >> 16); const SWord8 s781 = (SWord8) s780; const SWord32 s782 = table2[s781]; const SWord32 s783 = s523 ^ s782; const SWord32 s1039 = s2 ^ s6; const SWord16 s1040 = (SWord16) s1039; const SWord8 s1041 = (SWord8) (s1040 >> 8); const SWord32 s1042 = table3[s1041]; const SWord32 s1043 = s783 ^ s1042; const SWord32 s1299 = s3 ^ s7; const SWord16 s1300 = (SWord16) s1299; const SWord8 s1301 = (SWord8) s1300; const SWord32 s1302 = table4[s1301]; const SWord32 s1303 = s1043 ^ s1302; const SWord32 s1304 = (s7 << 8) | (s7 >> 24); const SWord16 s1305 = (SWord16) (s1304 >> 16); const SWord8 s1306 = (SWord8) (s1305 >> 8); const SWord8 s1307 = table0[s1306]; const SWord8 s1308 = 1 ^ s1307; const SWord8 s1309 = (SWord8) s1305; const SWord8 s1310 = table0[s1309]; const SWord16 s1311 = (((SWord16) s1308) << 8) | ((SWord16) s1310); const SWord16 s1312 = (SWord16) s1304; const SWord8 s1313 = (SWord8) (s1312 >> 8); const SWord8 s1314 = table0[s1313]; const SWord8 s1315 = (SWord8) s1312; const SWord8 s1316 = table0[s1315]; const SWord16 s1317 = (((SWord16) s1314) << 8) | ((SWord16) s1316); const SWord32 s1318 = (((SWord32) s1311) << 16) | ((SWord32) s1317); const SWord32 s1319 = s4 ^ s1318; const SWord32 s1320 = s1303 ^ s1319; const SWord16 s1321 = (SWord16) (s1320 >> 16); const SWord8 s1322 = (SWord8) (s1321 >> 8); const SWord32 s1323 = table1[s1322]; const SWord8 s1324 = (SWord8) (s780 >> 8); const SWord32 s1325 = table1[s1324]; const SWord16 s1326 = (SWord16) (s1039 >> 16); const SWord8 s1327 = (SWord8) s1326; const SWord32 s1328 = table2[s1327]; const SWord32 s1329 = s1325 ^ s1328; const SWord8 s1330 = (SWord8) (s1300 >> 8); const SWord32 s1331 = table3[s1330]; const SWord32 s1332 = s1329 ^ s1331; const SWord16 s1333 = (SWord16) s520; const SWord8 s1334 = (SWord8) s1333; const SWord32 s1335 = table4[s1334]; const SWord32 s1336 = s1332 ^ s1335; const SWord32 s1337 = s5 ^ s1319; const SWord32 s1338 = s1336 ^ s1337; const SWord16 s1339 = (SWord16) (s1338 >> 16); const SWord8 s1340 = (SWord8) s1339; const SWord32 s1341 = table2[s1340]; const SWord32 s1342 = s1323 ^ s1341; const SWord8 s1343 = (SWord8) (s1326 >> 8); const SWord32 s1344 = table1[s1343]; const SWord16 s1345 = (SWord16) (s1299 >> 16); const SWord8 s1346 = (SWord8) s1345; const SWord32 s1347 = table2[s1346]; const SWord32 s1348 = s1344 ^ s1347; const SWord8 s1349 = (SWord8) (s1333 >> 8); const SWord32 s1350 = table3[s1349]; const SWord32 s1351 = s1348 ^ s1350; const SWord16 s1352 = (SWord16) s779; const SWord8 s1353 = (SWord8) s1352; const SWord32 s1354 = table4[s1353]; const SWord32 s1355 = s1351 ^ s1354; const SWord32 s1356 = s6 ^ s1337; const SWord32 s1357 = s1355 ^ s1356; const SWord16 s1358 = (SWord16) s1357; const SWord8 s1359 = (SWord8) (s1358 >> 8); const SWord32 s1360 = table3[s1359]; const SWord32 s1361 = s1342 ^ s1360; const SWord8 s1362 = (SWord8) (s1345 >> 8); const SWord32 s1363 = table1[s1362]; const SWord8 s1364 = (SWord8) s521; const SWord32 s1365 = table2[s1364]; const SWord32 s1366 = s1363 ^ s1365; const SWord8 s1367 = (SWord8) (s1352 >> 8); const SWord32 s1368 = table3[s1367]; const SWord32 s1369 = s1366 ^ s1368; const SWord8 s1370 = (SWord8) s1040; const SWord32 s1371 = table4[s1370]; const SWord32 s1372 = s1369 ^ s1371; const SWord32 s1373 = s7 ^ s1356; const SWord32 s1374 = s1372 ^ s1373; const SWord16 s1375 = (SWord16) s1374; const SWord8 s1376 = (SWord8) s1375; const SWord32 s1377 = table4[s1376]; const SWord32 s1378 = s1361 ^ s1377; const SWord32 s1379 = (s1373 << 8) | (s1373 >> 24); const SWord16 s1380 = (SWord16) (s1379 >> 16); const SWord8 s1381 = (SWord8) (s1380 >> 8); const SWord8 s1382 = table0[s1381]; const SWord8 s1383 = 2 ^ s1382; const SWord8 s1384 = (SWord8) s1380; const SWord8 s1385 = table0[s1384]; const SWord16 s1386 = (((SWord16) s1383) << 8) | ((SWord16) s1385); const SWord16 s1387 = (SWord16) s1379; const SWord8 s1388 = (SWord8) (s1387 >> 8); const SWord8 s1389 = table0[s1388]; const SWord8 s1390 = (SWord8) s1387; const SWord8 s1391 = table0[s1390]; const SWord16 s1392 = (((SWord16) s1389) << 8) | ((SWord16) s1391); const SWord32 s1393 = (((SWord32) s1386) << 16) | ((SWord32) s1392); const SWord32 s1394 = s1319 ^ s1393; const SWord32 s1395 = s1378 ^ s1394; const SWord16 s1396 = (SWord16) (s1395 >> 16); const SWord8 s1397 = (SWord8) (s1396 >> 8); const SWord32 s1398 = table1[s1397]; const SWord8 s1399 = (SWord8) (s1339 >> 8); const SWord32 s1400 = table1[s1399]; const SWord16 s1401 = (SWord16) (s1357 >> 16); const SWord8 s1402 = (SWord8) s1401; const SWord32 s1403 = table2[s1402]; const SWord32 s1404 = s1400 ^ s1403; const SWord8 s1405 = (SWord8) (s1375 >> 8); const SWord32 s1406 = table3[s1405]; const SWord32 s1407 = s1404 ^ s1406; const SWord16 s1408 = (SWord16) s1320; const SWord8 s1409 = (SWord8) s1408; const SWord32 s1410 = table4[s1409]; const SWord32 s1411 = s1407 ^ s1410; const SWord32 s1412 = s1337 ^ s1394; const SWord32 s1413 = s1411 ^ s1412; const SWord16 s1414 = (SWord16) (s1413 >> 16); const SWord8 s1415 = (SWord8) s1414; const SWord32 s1416 = table2[s1415]; const SWord32 s1417 = s1398 ^ s1416; const SWord8 s1418 = (SWord8) (s1401 >> 8); const SWord32 s1419 = table1[s1418]; const SWord16 s1420 = (SWord16) (s1374 >> 16); const SWord8 s1421 = (SWord8) s1420; const SWord32 s1422 = table2[s1421]; const SWord32 s1423 = s1419 ^ s1422; const SWord8 s1424 = (SWord8) (s1408 >> 8); const SWord32 s1425 = table3[s1424]; const SWord32 s1426 = s1423 ^ s1425; const SWord16 s1427 = (SWord16) s1338; const SWord8 s1428 = (SWord8) s1427; const SWord32 s1429 = table4[s1428]; const SWord32 s1430 = s1426 ^ s1429; const SWord32 s1431 = s1356 ^ s1412; const SWord32 s1432 = s1430 ^ s1431; const SWord16 s1433 = (SWord16) s1432; const SWord8 s1434 = (SWord8) (s1433 >> 8); const SWord32 s1435 = table3[s1434]; const SWord32 s1436 = s1417 ^ s1435; const SWord8 s1437 = (SWord8) (s1420 >> 8); const SWord32 s1438 = table1[s1437]; const SWord8 s1439 = (SWord8) s1321; const SWord32 s1440 = table2[s1439]; const SWord32 s1441 = s1438 ^ s1440; const SWord8 s1442 = (SWord8) (s1427 >> 8); const SWord32 s1443 = table3[s1442]; const SWord32 s1444 = s1441 ^ s1443; const SWord8 s1445 = (SWord8) s1358; const SWord32 s1446 = table4[s1445]; const SWord32 s1447 = s1444 ^ s1446; const SWord32 s1448 = s1373 ^ s1431; const SWord32 s1449 = s1447 ^ s1448; const SWord16 s1450 = (SWord16) s1449; const SWord8 s1451 = (SWord8) s1450; const SWord32 s1452 = table4[s1451]; const SWord32 s1453 = s1436 ^ s1452; const SWord32 s1454 = (s1448 << 8) | (s1448 >> 24); const SWord16 s1455 = (SWord16) (s1454 >> 16); const SWord8 s1456 = (SWord8) (s1455 >> 8); const SWord8 s1457 = table0[s1456]; const SWord8 s1458 = 4 ^ s1457; const SWord8 s1459 = (SWord8) s1455; const SWord8 s1460 = table0[s1459]; const SWord16 s1461 = (((SWord16) s1458) << 8) | ((SWord16) s1460); const SWord16 s1462 = (SWord16) s1454; const SWord8 s1463 = (SWord8) (s1462 >> 8); const SWord8 s1464 = table0[s1463]; const SWord8 s1465 = (SWord8) s1462; const SWord8 s1466 = table0[s1465]; const SWord16 s1467 = (((SWord16) s1464) << 8) | ((SWord16) s1466); const SWord32 s1468 = (((SWord32) s1461) << 16) | ((SWord32) s1467); const SWord32 s1469 = s1394 ^ s1468; const SWord32 s1470 = s1453 ^ s1469; const SWord16 s1471 = (SWord16) (s1470 >> 16); const SWord8 s1472 = (SWord8) (s1471 >> 8); const SWord32 s1473 = table1[s1472]; const SWord8 s1474 = (SWord8) (s1414 >> 8); const SWord32 s1475 = table1[s1474]; const SWord16 s1476 = (SWord16) (s1432 >> 16); const SWord8 s1477 = (SWord8) s1476; const SWord32 s1478 = table2[s1477]; const SWord32 s1479 = s1475 ^ s1478; const SWord8 s1480 = (SWord8) (s1450 >> 8); const SWord32 s1481 = table3[s1480]; const SWord32 s1482 = s1479 ^ s1481; const SWord16 s1483 = (SWord16) s1395; const SWord8 s1484 = (SWord8) s1483; const SWord32 s1485 = table4[s1484]; const SWord32 s1486 = s1482 ^ s1485; const SWord32 s1487 = s1412 ^ s1469; const SWord32 s1488 = s1486 ^ s1487; const SWord16 s1489 = (SWord16) (s1488 >> 16); const SWord8 s1490 = (SWord8) s1489; const SWord32 s1491 = table2[s1490]; const SWord32 s1492 = s1473 ^ s1491; const SWord8 s1493 = (SWord8) (s1476 >> 8); const SWord32 s1494 = table1[s1493]; const SWord16 s1495 = (SWord16) (s1449 >> 16); const SWord8 s1496 = (SWord8) s1495; const SWord32 s1497 = table2[s1496]; const SWord32 s1498 = s1494 ^ s1497; const SWord8 s1499 = (SWord8) (s1483 >> 8); const SWord32 s1500 = table3[s1499]; const SWord32 s1501 = s1498 ^ s1500; const SWord16 s1502 = (SWord16) s1413; const SWord8 s1503 = (SWord8) s1502; const SWord32 s1504 = table4[s1503]; const SWord32 s1505 = s1501 ^ s1504; const SWord32 s1506 = s1431 ^ s1487; const SWord32 s1507 = s1505 ^ s1506; const SWord16 s1508 = (SWord16) s1507; const SWord8 s1509 = (SWord8) (s1508 >> 8); const SWord32 s1510 = table3[s1509]; const SWord32 s1511 = s1492 ^ s1510; const SWord8 s1512 = (SWord8) (s1495 >> 8); const SWord32 s1513 = table1[s1512]; const SWord8 s1514 = (SWord8) s1396; const SWord32 s1515 = table2[s1514]; const SWord32 s1516 = s1513 ^ s1515; const SWord8 s1517 = (SWord8) (s1502 >> 8); const SWord32 s1518 = table3[s1517]; const SWord32 s1519 = s1516 ^ s1518; const SWord8 s1520 = (SWord8) s1433; const SWord32 s1521 = table4[s1520]; const SWord32 s1522 = s1519 ^ s1521; const SWord32 s1523 = s1448 ^ s1506; const SWord32 s1524 = s1522 ^ s1523; const SWord16 s1525 = (SWord16) s1524; const SWord8 s1526 = (SWord8) s1525; const SWord32 s1527 = table4[s1526]; const SWord32 s1528 = s1511 ^ s1527; const SWord32 s1529 = (s1523 << 8) | (s1523 >> 24); const SWord16 s1530 = (SWord16) (s1529 >> 16); const SWord8 s1531 = (SWord8) (s1530 >> 8); const SWord8 s1532 = table0[s1531]; const SWord8 s1533 = 8 ^ s1532; const SWord8 s1534 = (SWord8) s1530; const SWord8 s1535 = table0[s1534]; const SWord16 s1536 = (((SWord16) s1533) << 8) | ((SWord16) s1535); const SWord16 s1537 = (SWord16) s1529; const SWord8 s1538 = (SWord8) (s1537 >> 8); const SWord8 s1539 = table0[s1538]; const SWord8 s1540 = (SWord8) s1537; const SWord8 s1541 = table0[s1540]; const SWord16 s1542 = (((SWord16) s1539) << 8) | ((SWord16) s1541); const SWord32 s1543 = (((SWord32) s1536) << 16) | ((SWord32) s1542); const SWord32 s1544 = s1469 ^ s1543; const SWord32 s1545 = s1528 ^ s1544; const SWord16 s1546 = (SWord16) (s1545 >> 16); const SWord8 s1547 = (SWord8) (s1546 >> 8); const SWord32 s1548 = table1[s1547]; const SWord8 s1549 = (SWord8) (s1489 >> 8); const SWord32 s1550 = table1[s1549]; const SWord16 s1551 = (SWord16) (s1507 >> 16); const SWord8 s1552 = (SWord8) s1551; const SWord32 s1553 = table2[s1552]; const SWord32 s1554 = s1550 ^ s1553; const SWord8 s1555 = (SWord8) (s1525 >> 8); const SWord32 s1556 = table3[s1555]; const SWord32 s1557 = s1554 ^ s1556; const SWord16 s1558 = (SWord16) s1470; const SWord8 s1559 = (SWord8) s1558; const SWord32 s1560 = table4[s1559]; const SWord32 s1561 = s1557 ^ s1560; const SWord32 s1562 = s1487 ^ s1544; const SWord32 s1563 = s1561 ^ s1562; const SWord16 s1564 = (SWord16) (s1563 >> 16); const SWord8 s1565 = (SWord8) s1564; const SWord32 s1566 = table2[s1565]; const SWord32 s1567 = s1548 ^ s1566; const SWord8 s1568 = (SWord8) (s1551 >> 8); const SWord32 s1569 = table1[s1568]; const SWord16 s1570 = (SWord16) (s1524 >> 16); const SWord8 s1571 = (SWord8) s1570; const SWord32 s1572 = table2[s1571]; const SWord32 s1573 = s1569 ^ s1572; const SWord8 s1574 = (SWord8) (s1558 >> 8); const SWord32 s1575 = table3[s1574]; const SWord32 s1576 = s1573 ^ s1575; const SWord16 s1577 = (SWord16) s1488; const SWord8 s1578 = (SWord8) s1577; const SWord32 s1579 = table4[s1578]; const SWord32 s1580 = s1576 ^ s1579; const SWord32 s1581 = s1506 ^ s1562; const SWord32 s1582 = s1580 ^ s1581; const SWord16 s1583 = (SWord16) s1582; const SWord8 s1584 = (SWord8) (s1583 >> 8); const SWord32 s1585 = table3[s1584]; const SWord32 s1586 = s1567 ^ s1585; const SWord8 s1587 = (SWord8) (s1570 >> 8); const SWord32 s1588 = table1[s1587]; const SWord8 s1589 = (SWord8) s1471; const SWord32 s1590 = table2[s1589]; const SWord32 s1591 = s1588 ^ s1590; const SWord8 s1592 = (SWord8) (s1577 >> 8); const SWord32 s1593 = table3[s1592]; const SWord32 s1594 = s1591 ^ s1593; const SWord8 s1595 = (SWord8) s1508; const SWord32 s1596 = table4[s1595]; const SWord32 s1597 = s1594 ^ s1596; const SWord32 s1598 = s1523 ^ s1581; const SWord32 s1599 = s1597 ^ s1598; const SWord16 s1600 = (SWord16) s1599; const SWord8 s1601 = (SWord8) s1600; const SWord32 s1602 = table4[s1601]; const SWord32 s1603 = s1586 ^ s1602; const SWord32 s1604 = (s1598 << 8) | (s1598 >> 24); const SWord16 s1605 = (SWord16) (s1604 >> 16); const SWord8 s1606 = (SWord8) (s1605 >> 8); const SWord8 s1607 = table0[s1606]; const SWord8 s1608 = 16 ^ s1607; const SWord8 s1609 = (SWord8) s1605; const SWord8 s1610 = table0[s1609]; const SWord16 s1611 = (((SWord16) s1608) << 8) | ((SWord16) s1610); const SWord16 s1612 = (SWord16) s1604; const SWord8 s1613 = (SWord8) (s1612 >> 8); const SWord8 s1614 = table0[s1613]; const SWord8 s1615 = (SWord8) s1612; const SWord8 s1616 = table0[s1615]; const SWord16 s1617 = (((SWord16) s1614) << 8) | ((SWord16) s1616); const SWord32 s1618 = (((SWord32) s1611) << 16) | ((SWord32) s1617); const SWord32 s1619 = s1544 ^ s1618; const SWord32 s1620 = s1603 ^ s1619; const SWord16 s1621 = (SWord16) (s1620 >> 16); const SWord8 s1622 = (SWord8) (s1621 >> 8); const SWord32 s1623 = table1[s1622]; const SWord8 s1624 = (SWord8) (s1564 >> 8); const SWord32 s1625 = table1[s1624]; const SWord16 s1626 = (SWord16) (s1582 >> 16); const SWord8 s1627 = (SWord8) s1626; const SWord32 s1628 = table2[s1627]; const SWord32 s1629 = s1625 ^ s1628; const SWord8 s1630 = (SWord8) (s1600 >> 8); const SWord32 s1631 = table3[s1630]; const SWord32 s1632 = s1629 ^ s1631; const SWord16 s1633 = (SWord16) s1545; const SWord8 s1634 = (SWord8) s1633; const SWord32 s1635 = table4[s1634]; const SWord32 s1636 = s1632 ^ s1635; const SWord32 s1637 = s1562 ^ s1619; const SWord32 s1638 = s1636 ^ s1637; const SWord16 s1639 = (SWord16) (s1638 >> 16); const SWord8 s1640 = (SWord8) s1639; const SWord32 s1641 = table2[s1640]; const SWord32 s1642 = s1623 ^ s1641; const SWord8 s1643 = (SWord8) (s1626 >> 8); const SWord32 s1644 = table1[s1643]; const SWord16 s1645 = (SWord16) (s1599 >> 16); const SWord8 s1646 = (SWord8) s1645; const SWord32 s1647 = table2[s1646]; const SWord32 s1648 = s1644 ^ s1647; const SWord8 s1649 = (SWord8) (s1633 >> 8); const SWord32 s1650 = table3[s1649]; const SWord32 s1651 = s1648 ^ s1650; const SWord16 s1652 = (SWord16) s1563; const SWord8 s1653 = (SWord8) s1652; const SWord32 s1654 = table4[s1653]; const SWord32 s1655 = s1651 ^ s1654; const SWord32 s1656 = s1581 ^ s1637; const SWord32 s1657 = s1655 ^ s1656; const SWord16 s1658 = (SWord16) s1657; const SWord8 s1659 = (SWord8) (s1658 >> 8); const SWord32 s1660 = table3[s1659]; const SWord32 s1661 = s1642 ^ s1660; const SWord8 s1662 = (SWord8) (s1645 >> 8); const SWord32 s1663 = table1[s1662]; const SWord8 s1664 = (SWord8) s1546; const SWord32 s1665 = table2[s1664]; const SWord32 s1666 = s1663 ^ s1665; const SWord8 s1667 = (SWord8) (s1652 >> 8); const SWord32 s1668 = table3[s1667]; const SWord32 s1669 = s1666 ^ s1668; const SWord8 s1670 = (SWord8) s1583; const SWord32 s1671 = table4[s1670]; const SWord32 s1672 = s1669 ^ s1671; const SWord32 s1673 = s1598 ^ s1656; const SWord32 s1674 = s1672 ^ s1673; const SWord16 s1675 = (SWord16) s1674; const SWord8 s1676 = (SWord8) s1675; const SWord32 s1677 = table4[s1676]; const SWord32 s1678 = s1661 ^ s1677; const SWord32 s1679 = (s1673 << 8) | (s1673 >> 24); const SWord16 s1680 = (SWord16) (s1679 >> 16); const SWord8 s1681 = (SWord8) (s1680 >> 8); const SWord8 s1682 = table0[s1681]; const SWord8 s1683 = 32 ^ s1682; const SWord8 s1684 = (SWord8) s1680; const SWord8 s1685 = table0[s1684]; const SWord16 s1686 = (((SWord16) s1683) << 8) | ((SWord16) s1685); const SWord16 s1687 = (SWord16) s1679; const SWord8 s1688 = (SWord8) (s1687 >> 8); const SWord8 s1689 = table0[s1688]; const SWord8 s1690 = (SWord8) s1687; const SWord8 s1691 = table0[s1690]; const SWord16 s1692 = (((SWord16) s1689) << 8) | ((SWord16) s1691); const SWord32 s1693 = (((SWord32) s1686) << 16) | ((SWord32) s1692); const SWord32 s1694 = s1619 ^ s1693; const SWord32 s1695 = s1678 ^ s1694; const SWord16 s1696 = (SWord16) (s1695 >> 16); const SWord8 s1697 = (SWord8) (s1696 >> 8); const SWord32 s1698 = table1[s1697]; const SWord8 s1699 = (SWord8) (s1639 >> 8); const SWord32 s1700 = table1[s1699]; const SWord16 s1701 = (SWord16) (s1657 >> 16); const SWord8 s1702 = (SWord8) s1701; const SWord32 s1703 = table2[s1702]; const SWord32 s1704 = s1700 ^ s1703; const SWord8 s1705 = (SWord8) (s1675 >> 8); const SWord32 s1706 = table3[s1705]; const SWord32 s1707 = s1704 ^ s1706; const SWord16 s1708 = (SWord16) s1620; const SWord8 s1709 = (SWord8) s1708; const SWord32 s1710 = table4[s1709]; const SWord32 s1711 = s1707 ^ s1710; const SWord32 s1712 = s1637 ^ s1694; const SWord32 s1713 = s1711 ^ s1712; const SWord16 s1714 = (SWord16) (s1713 >> 16); const SWord8 s1715 = (SWord8) s1714; const SWord32 s1716 = table2[s1715]; const SWord32 s1717 = s1698 ^ s1716; const SWord8 s1718 = (SWord8) (s1701 >> 8); const SWord32 s1719 = table1[s1718]; const SWord16 s1720 = (SWord16) (s1674 >> 16); const SWord8 s1721 = (SWord8) s1720; const SWord32 s1722 = table2[s1721]; const SWord32 s1723 = s1719 ^ s1722; const SWord8 s1724 = (SWord8) (s1708 >> 8); const SWord32 s1725 = table3[s1724]; const SWord32 s1726 = s1723 ^ s1725; const SWord16 s1727 = (SWord16) s1638; const SWord8 s1728 = (SWord8) s1727; const SWord32 s1729 = table4[s1728]; const SWord32 s1730 = s1726 ^ s1729; const SWord32 s1731 = s1656 ^ s1712; const SWord32 s1732 = s1730 ^ s1731; const SWord16 s1733 = (SWord16) s1732; const SWord8 s1734 = (SWord8) (s1733 >> 8); const SWord32 s1735 = table3[s1734]; const SWord32 s1736 = s1717 ^ s1735; const SWord8 s1737 = (SWord8) (s1720 >> 8); const SWord32 s1738 = table1[s1737]; const SWord8 s1739 = (SWord8) s1621; const SWord32 s1740 = table2[s1739]; const SWord32 s1741 = s1738 ^ s1740; const SWord8 s1742 = (SWord8) (s1727 >> 8); const SWord32 s1743 = table3[s1742]; const SWord32 s1744 = s1741 ^ s1743; const SWord8 s1745 = (SWord8) s1658; const SWord32 s1746 = table4[s1745]; const SWord32 s1747 = s1744 ^ s1746; const SWord32 s1748 = s1673 ^ s1731; const SWord32 s1749 = s1747 ^ s1748; const SWord16 s1750 = (SWord16) s1749; const SWord8 s1751 = (SWord8) s1750; const SWord32 s1752 = table4[s1751]; const SWord32 s1753 = s1736 ^ s1752; const SWord32 s1754 = (s1748 << 8) | (s1748 >> 24); const SWord16 s1755 = (SWord16) (s1754 >> 16); const SWord8 s1756 = (SWord8) (s1755 >> 8); const SWord8 s1757 = table0[s1756]; const SWord8 s1758 = 64 ^ s1757; const SWord8 s1759 = (SWord8) s1755; const SWord8 s1760 = table0[s1759]; const SWord16 s1761 = (((SWord16) s1758) << 8) | ((SWord16) s1760); const SWord16 s1762 = (SWord16) s1754; const SWord8 s1763 = (SWord8) (s1762 >> 8); const SWord8 s1764 = table0[s1763]; const SWord8 s1765 = (SWord8) s1762; const SWord8 s1766 = table0[s1765]; const SWord16 s1767 = (((SWord16) s1764) << 8) | ((SWord16) s1766); const SWord32 s1768 = (((SWord32) s1761) << 16) | ((SWord32) s1767); const SWord32 s1769 = s1694 ^ s1768; const SWord32 s1770 = s1753 ^ s1769; const SWord16 s1771 = (SWord16) (s1770 >> 16); const SWord8 s1772 = (SWord8) (s1771 >> 8); const SWord32 s1773 = table1[s1772]; const SWord8 s1774 = (SWord8) (s1714 >> 8); const SWord32 s1775 = table1[s1774]; const SWord16 s1776 = (SWord16) (s1732 >> 16); const SWord8 s1777 = (SWord8) s1776; const SWord32 s1778 = table2[s1777]; const SWord32 s1779 = s1775 ^ s1778; const SWord8 s1780 = (SWord8) (s1750 >> 8); const SWord32 s1781 = table3[s1780]; const SWord32 s1782 = s1779 ^ s1781; const SWord16 s1783 = (SWord16) s1695; const SWord8 s1784 = (SWord8) s1783; const SWord32 s1785 = table4[s1784]; const SWord32 s1786 = s1782 ^ s1785; const SWord32 s1787 = s1712 ^ s1769; const SWord32 s1788 = s1786 ^ s1787; const SWord16 s1789 = (SWord16) (s1788 >> 16); const SWord8 s1790 = (SWord8) s1789; const SWord32 s1791 = table2[s1790]; const SWord32 s1792 = s1773 ^ s1791; const SWord8 s1793 = (SWord8) (s1776 >> 8); const SWord32 s1794 = table1[s1793]; const SWord16 s1795 = (SWord16) (s1749 >> 16); const SWord8 s1796 = (SWord8) s1795; const SWord32 s1797 = table2[s1796]; const SWord32 s1798 = s1794 ^ s1797; const SWord8 s1799 = (SWord8) (s1783 >> 8); const SWord32 s1800 = table3[s1799]; const SWord32 s1801 = s1798 ^ s1800; const SWord16 s1802 = (SWord16) s1713; const SWord8 s1803 = (SWord8) s1802; const SWord32 s1804 = table4[s1803]; const SWord32 s1805 = s1801 ^ s1804; const SWord32 s1806 = s1731 ^ s1787; const SWord32 s1807 = s1805 ^ s1806; const SWord16 s1808 = (SWord16) s1807; const SWord8 s1809 = (SWord8) (s1808 >> 8); const SWord32 s1810 = table3[s1809]; const SWord32 s1811 = s1792 ^ s1810; const SWord8 s1812 = (SWord8) (s1795 >> 8); const SWord32 s1813 = table1[s1812]; const SWord8 s1814 = (SWord8) s1696; const SWord32 s1815 = table2[s1814]; const SWord32 s1816 = s1813 ^ s1815; const SWord8 s1817 = (SWord8) (s1802 >> 8); const SWord32 s1818 = table3[s1817]; const SWord32 s1819 = s1816 ^ s1818; const SWord8 s1820 = (SWord8) s1733; const SWord32 s1821 = table4[s1820]; const SWord32 s1822 = s1819 ^ s1821; const SWord32 s1823 = s1748 ^ s1806; const SWord32 s1824 = s1822 ^ s1823; const SWord16 s1825 = (SWord16) s1824; const SWord8 s1826 = (SWord8) s1825; const SWord32 s1827 = table4[s1826]; const SWord32 s1828 = s1811 ^ s1827; const SWord32 s1829 = (s1823 << 8) | (s1823 >> 24); const SWord16 s1830 = (SWord16) (s1829 >> 16); const SWord8 s1831 = (SWord8) (s1830 >> 8); const SWord8 s1832 = table0[s1831]; const SWord8 s1833 = 128 ^ s1832; const SWord8 s1834 = (SWord8) s1830; const SWord8 s1835 = table0[s1834]; const SWord16 s1836 = (((SWord16) s1833) << 8) | ((SWord16) s1835); const SWord16 s1837 = (SWord16) s1829; const SWord8 s1838 = (SWord8) (s1837 >> 8); const SWord8 s1839 = table0[s1838]; const SWord8 s1840 = (SWord8) s1837; const SWord8 s1841 = table0[s1840]; const SWord16 s1842 = (((SWord16) s1839) << 8) | ((SWord16) s1841); const SWord32 s1843 = (((SWord32) s1836) << 16) | ((SWord32) s1842); const SWord32 s1844 = s1769 ^ s1843; const SWord32 s1845 = s1828 ^ s1844; const SWord16 s1846 = (SWord16) (s1845 >> 16); const SWord8 s1847 = (SWord8) (s1846 >> 8); const SWord32 s1848 = table1[s1847]; const SWord8 s1849 = (SWord8) (s1789 >> 8); const SWord32 s1850 = table1[s1849]; const SWord16 s1851 = (SWord16) (s1807 >> 16); const SWord8 s1852 = (SWord8) s1851; const SWord32 s1853 = table2[s1852]; const SWord32 s1854 = s1850 ^ s1853; const SWord8 s1855 = (SWord8) (s1825 >> 8); const SWord32 s1856 = table3[s1855]; const SWord32 s1857 = s1854 ^ s1856; const SWord16 s1858 = (SWord16) s1770; const SWord8 s1859 = (SWord8) s1858; const SWord32 s1860 = table4[s1859]; const SWord32 s1861 = s1857 ^ s1860; const SWord32 s1862 = s1787 ^ s1844; const SWord32 s1863 = s1861 ^ s1862; const SWord16 s1864 = (SWord16) (s1863 >> 16); const SWord8 s1865 = (SWord8) s1864; const SWord32 s1866 = table2[s1865]; const SWord32 s1867 = s1848 ^ s1866; const SWord8 s1868 = (SWord8) (s1851 >> 8); const SWord32 s1869 = table1[s1868]; const SWord16 s1870 = (SWord16) (s1824 >> 16); const SWord8 s1871 = (SWord8) s1870; const SWord32 s1872 = table2[s1871]; const SWord32 s1873 = s1869 ^ s1872; const SWord8 s1874 = (SWord8) (s1858 >> 8); const SWord32 s1875 = table3[s1874]; const SWord32 s1876 = s1873 ^ s1875; const SWord16 s1877 = (SWord16) s1788; const SWord8 s1878 = (SWord8) s1877; const SWord32 s1879 = table4[s1878]; const SWord32 s1880 = s1876 ^ s1879; const SWord32 s1881 = s1806 ^ s1862; const SWord32 s1882 = s1880 ^ s1881; const SWord16 s1883 = (SWord16) s1882; const SWord8 s1884 = (SWord8) (s1883 >> 8); const SWord32 s1885 = table3[s1884]; const SWord32 s1886 = s1867 ^ s1885; const SWord8 s1887 = (SWord8) (s1870 >> 8); const SWord32 s1888 = table1[s1887]; const SWord8 s1889 = (SWord8) s1771; const SWord32 s1890 = table2[s1889]; const SWord32 s1891 = s1888 ^ s1890; const SWord8 s1892 = (SWord8) (s1877 >> 8); const SWord32 s1893 = table3[s1892]; const SWord32 s1894 = s1891 ^ s1893; const SWord8 s1895 = (SWord8) s1808; const SWord32 s1896 = table4[s1895]; const SWord32 s1897 = s1894 ^ s1896; const SWord32 s1898 = s1823 ^ s1881; const SWord32 s1899 = s1897 ^ s1898; const SWord16 s1900 = (SWord16) s1899; const SWord8 s1901 = (SWord8) s1900; const SWord32 s1902 = table4[s1901]; const SWord32 s1903 = s1886 ^ s1902; const SWord32 s1904 = (s1898 << 8) | (s1898 >> 24); const SWord16 s1905 = (SWord16) (s1904 >> 16); const SWord8 s1906 = (SWord8) (s1905 >> 8); const SWord8 s1907 = table0[s1906]; const SWord8 s1908 = 27 ^ s1907; const SWord8 s1909 = (SWord8) s1905; const SWord8 s1910 = table0[s1909]; const SWord16 s1911 = (((SWord16) s1908) << 8) | ((SWord16) s1910); const SWord16 s1912 = (SWord16) s1904; const SWord8 s1913 = (SWord8) (s1912 >> 8); const SWord8 s1914 = table0[s1913]; const SWord8 s1915 = (SWord8) s1912; const SWord8 s1916 = table0[s1915]; const SWord16 s1917 = (((SWord16) s1914) << 8) | ((SWord16) s1916); const SWord32 s1918 = (((SWord32) s1911) << 16) | ((SWord32) s1917); const SWord32 s1919 = s1844 ^ s1918; const SWord32 s1920 = s1903 ^ s1919; const SWord16 s1921 = (SWord16) (s1920 >> 16); const SWord8 s1922 = (SWord8) (s1921 >> 8); const SWord8 s1923 = table0[s1922]; const SWord8 s1924 = (SWord8) (s1864 >> 8); const SWord32 s1925 = table1[s1924]; const SWord16 s1926 = (SWord16) (s1882 >> 16); const SWord8 s1927 = (SWord8) s1926; const SWord32 s1928 = table2[s1927]; const SWord32 s1929 = s1925 ^ s1928; const SWord8 s1930 = (SWord8) (s1900 >> 8); const SWord32 s1931 = table3[s1930]; const SWord32 s1932 = s1929 ^ s1931; const SWord16 s1933 = (SWord16) s1845; const SWord8 s1934 = (SWord8) s1933; const SWord32 s1935 = table4[s1934]; const SWord32 s1936 = s1932 ^ s1935; const SWord32 s1937 = s1862 ^ s1919; const SWord32 s1938 = s1936 ^ s1937; const SWord16 s1939 = (SWord16) (s1938 >> 16); const SWord8 s1940 = (SWord8) s1939; const SWord8 s1941 = table0[s1940]; const SWord16 s1942 = (((SWord16) s1923) << 8) | ((SWord16) s1941); const SWord8 s1943 = (SWord8) (s1926 >> 8); const SWord32 s1944 = table1[s1943]; const SWord16 s1945 = (SWord16) (s1899 >> 16); const SWord8 s1946 = (SWord8) s1945; const SWord32 s1947 = table2[s1946]; const SWord32 s1948 = s1944 ^ s1947; const SWord8 s1949 = (SWord8) (s1933 >> 8); const SWord32 s1950 = table3[s1949]; const SWord32 s1951 = s1948 ^ s1950; const SWord16 s1952 = (SWord16) s1863; const SWord8 s1953 = (SWord8) s1952; const SWord32 s1954 = table4[s1953]; const SWord32 s1955 = s1951 ^ s1954; const SWord32 s1956 = s1881 ^ s1937; const SWord32 s1957 = s1955 ^ s1956; const SWord16 s1958 = (SWord16) s1957; const SWord8 s1959 = (SWord8) (s1958 >> 8); const SWord8 s1960 = table0[s1959]; const SWord8 s1961 = (SWord8) (s1945 >> 8); const SWord32 s1962 = table1[s1961]; const SWord8 s1963 = (SWord8) s1846; const SWord32 s1964 = table2[s1963]; const SWord32 s1965 = s1962 ^ s1964; const SWord8 s1966 = (SWord8) (s1952 >> 8); const SWord32 s1967 = table3[s1966]; const SWord32 s1968 = s1965 ^ s1967; const SWord8 s1969 = (SWord8) s1883; const SWord32 s1970 = table4[s1969]; const SWord32 s1971 = s1968 ^ s1970; const SWord32 s1972 = s1898 ^ s1956; const SWord32 s1973 = s1971 ^ s1972; const SWord16 s1974 = (SWord16) s1973; const SWord8 s1975 = (SWord8) s1974; const SWord8 s1976 = table0[s1975]; const SWord16 s1977 = (((SWord16) s1960) << 8) | ((SWord16) s1976); const SWord32 s1978 = (((SWord32) s1942) << 16) | ((SWord32) s1977); const SWord32 s1979 = (s1972 << 8) | (s1972 >> 24); const SWord16 s1980 = (SWord16) (s1979 >> 16); const SWord8 s1981 = (SWord8) (s1980 >> 8); const SWord8 s1982 = table0[s1981]; const SWord8 s1983 = 54 ^ s1982; const SWord8 s1984 = (SWord8) s1980; const SWord8 s1985 = table0[s1984]; const SWord16 s1986 = (((SWord16) s1983) << 8) | ((SWord16) s1985); const SWord16 s1987 = (SWord16) s1979; const SWord8 s1988 = (SWord8) (s1987 >> 8); const SWord8 s1989 = table0[s1988]; const SWord8 s1990 = (SWord8) s1987; const SWord8 s1991 = table0[s1990]; const SWord16 s1992 = (((SWord16) s1989) << 8) | ((SWord16) s1991); const SWord32 s1993 = (((SWord32) s1986) << 16) | ((SWord32) s1992); const SWord32 s1994 = s1919 ^ s1993; const SWord32 s1995 = s1978 ^ s1994; const SWord8 s1996 = (SWord8) (s1939 >> 8); const SWord8 s1997 = table0[s1996]; const SWord16 s1998 = (SWord16) (s1957 >> 16); const SWord8 s1999 = (SWord8) s1998; const SWord8 s2000 = table0[s1999]; const SWord16 s2001 = (((SWord16) s1997) << 8) | ((SWord16) s2000); const SWord8 s2002 = (SWord8) (s1974 >> 8); const SWord8 s2003 = table0[s2002]; const SWord16 s2004 = (SWord16) s1920; const SWord8 s2005 = (SWord8) s2004; const SWord8 s2006 = table0[s2005]; const SWord16 s2007 = (((SWord16) s2003) << 8) | ((SWord16) s2006); const SWord32 s2008 = (((SWord32) s2001) << 16) | ((SWord32) s2007); const SWord32 s2009 = s1937 ^ s1994; const SWord32 s2010 = s2008 ^ s2009; const SWord8 s2011 = (SWord8) (s1998 >> 8); const SWord8 s2012 = table0[s2011]; const SWord16 s2013 = (SWord16) (s1973 >> 16); const SWord8 s2014 = (SWord8) s2013; const SWord8 s2015 = table0[s2014]; const SWord16 s2016 = (((SWord16) s2012) << 8) | ((SWord16) s2015); const SWord8 s2017 = (SWord8) (s2004 >> 8); const SWord8 s2018 = table0[s2017]; const SWord16 s2019 = (SWord16) s1938; const SWord8 s2020 = (SWord8) s2019; const SWord8 s2021 = table0[s2020]; const SWord16 s2022 = (((SWord16) s2018) << 8) | ((SWord16) s2021); const SWord32 s2023 = (((SWord32) s2016) << 16) | ((SWord32) s2022); const SWord32 s2024 = s1956 ^ s2009; const SWord32 s2025 = s2023 ^ s2024; const SWord8 s2026 = (SWord8) (s2013 >> 8); const SWord8 s2027 = table0[s2026]; const SWord8 s2028 = (SWord8) s1921; const SWord8 s2029 = table0[s2028]; const SWord16 s2030 = (((SWord16) s2027) << 8) | ((SWord16) s2029); const SWord8 s2031 = (SWord8) (s2019 >> 8); const SWord8 s2032 = table0[s2031]; const SWord8 s2033 = (SWord8) s1958; const SWord8 s2034 = table0[s2033]; const SWord16 s2035 = (((SWord16) s2032) << 8) | ((SWord16) s2034); const SWord32 s2036 = (((SWord32) s2030) << 16) | ((SWord32) s2035); const SWord32 s2037 = s1972 ^ s2024; const SWord32 s2038 = s2036 ^ s2037; ct[0] = s1995; ct[1] = s2010; ct[2] = s2025; ct[3] = s2038; } == END: "aes128Enc.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/aes128Lib.gold0000644000000000000000000050156012725411266016741 0ustar0000000000000000== BEGIN: "aes128KeySchedule.c" ================ /* File: "aes128KeySchedule.c". Automatically generated by SBV. Do not edit! */ #include "aes128Lib.h" void aes128KeySchedule(const SWord32 *key, SWord32 *encKS, SWord32 *decKS) { const SWord32 s0 = key[0]; const SWord32 s1 = key[1]; const SWord32 s2 = key[2]; const SWord32 s3 = key[3]; static const SWord8 table0[] = { 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22 }; static const SWord8 table1[] = { 0, 14, 28, 18, 56, 54, 36, 42, 112, 126, 108, 98, 72, 70, 84, 90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158, 140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255, 241, 171, 165, 183, 185, 147, 157, 143, 129, 59, 53, 39, 41, 3, 13, 31, 17, 75, 69, 87, 89, 115, 125, 111, 97, 173, 163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235, 249, 247, 77, 67, 81, 95, 117, 123, 105, 103, 61, 51, 33, 47, 5, 11, 25, 23, 118, 120, 106, 100, 78, 64, 82, 92, 6, 8, 26, 20, 62, 48, 34, 44, 150, 152, 138, 132, 174, 160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204, 65, 79, 93, 83, 121, 119, 101, 107, 49, 63, 45, 35, 9, 7, 21, 27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195, 233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234, 228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104, 66, 76, 94, 80, 10, 4, 22, 24, 50, 60, 46, 32, 236, 226, 240, 254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182, 12, 2, 16, 30, 52, 58, 40, 38, 124, 114, 96, 110, 68, 74, 88, 86, 55, 57, 43, 37, 15, 1, 19, 29, 71, 73, 91, 85, 127, 113, 99, 109, 215, 217, 203, 197, 239, 225, 243, 253, 167, 169, 187, 181, 159, 145, 131, 141 }; static const SWord8 table2[] = { 0, 11, 22, 29, 44, 39, 58, 49, 88, 83, 78, 69, 116, 127, 98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227, 254, 245, 196, 207, 210, 217, 123, 112, 109, 102, 87, 92, 65, 74, 35, 40, 53, 62, 15, 4, 25, 18, 203, 192, 221, 214, 231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246, 253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137, 148, 159, 70, 77, 80, 91, 106, 97, 124, 119, 30, 21, 8, 3, 50, 57, 36, 47, 141, 134, 155, 144, 161, 170, 183, 188, 213, 222, 195, 200, 249, 242, 239, 228, 61, 54, 43, 32, 17, 26, 7, 12, 101, 110, 115, 120, 73, 66, 95, 84, 247, 252, 225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149, 158, 71, 76, 81, 90, 107, 96, 125, 118, 31, 20, 9, 2, 51, 56, 37, 46, 140, 135, 154, 145, 160, 171, 182, 189, 212, 223, 194, 201, 248, 243, 238, 229, 60, 55, 42, 33, 16, 27, 6, 13, 100, 111, 114, 121, 72, 67, 94, 85, 1, 10, 23, 28, 45, 38, 59, 48, 89, 82, 79, 68, 117, 126, 99, 104, 177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197, 206, 211, 216, 122, 113, 108, 103, 86, 93, 64, 75, 34, 41, 52, 63, 14, 5, 24, 19, 202, 193, 220, 215, 230, 237, 240, 251, 146, 153, 132, 143, 190, 181, 168, 163 }; static const SWord8 table3[] = { 0, 13, 26, 23, 52, 57, 46, 35, 104, 101, 114, 127, 92, 81, 70, 75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181, 162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149, 152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124, 95, 82, 69, 72, 3, 14, 25, 20, 55, 58, 45, 32, 109, 96, 119, 122, 89, 84, 67, 78, 5, 8, 31, 18, 49, 60, 43, 38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207, 194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245, 190, 179, 164, 169, 138, 135, 144, 157, 6, 11, 28, 17, 50, 63, 40, 37, 110, 99, 116, 121, 90, 87, 64, 77, 218, 215, 192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156, 145, 10, 7, 16, 29, 62, 51, 36, 41, 98, 111, 120, 117, 86, 91, 76, 65, 97, 108, 123, 118, 85, 88, 79, 66, 9, 4, 19, 30, 61, 48, 39, 42, 177, 188, 171, 166, 133, 136, 159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173, 160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252, 103, 106, 125, 112, 83, 94, 73, 68, 15, 2, 21, 24, 59, 54, 33, 44, 12, 1, 22, 27, 56, 53, 34, 47, 100, 105, 126, 115, 80, 93, 74, 71, 220, 209, 198, 203, 232, 229, 242, 255, 180, 185, 174, 163, 128, 141, 154, 151 }; static const SWord8 table4[] = { 0, 9, 18, 27, 36, 45, 54, 63, 72, 65, 90, 83, 108, 101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209, 202, 195, 252, 245, 238, 231, 59, 50, 41, 32, 31, 22, 13, 4, 115, 122, 97, 104, 87, 94, 69, 76, 171, 162, 185, 176, 143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118, 127, 100, 109, 82, 91, 64, 73, 62, 55, 44, 37, 26, 19, 8, 1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188, 181, 138, 131, 152, 145, 77, 68, 95, 86, 105, 96, 123, 114, 5, 12, 23, 30, 33, 40, 51, 58, 221, 212, 207, 198, 249, 240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229, 254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146, 155, 124, 117, 110, 103, 88, 81, 74, 67, 52, 61, 38, 47, 16, 25, 2, 11, 215, 222, 197, 204, 243, 250, 225, 232, 159, 150, 141, 132, 187, 178, 169, 160, 71, 78, 85, 92, 99, 106, 113, 120, 15, 6, 29, 20, 43, 34, 57, 48, 154, 147, 136, 129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237, 10, 3, 24, 17, 46, 39, 60, 53, 66, 75, 80, 89, 102, 111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224, 251, 242, 205, 196, 223, 214, 49, 56, 35, 42, 21, 28, 7, 14, 121, 112, 107, 98, 93, 84, 79, 70 }; const SWord32 s260 = (s3 << 8) | (s3 >> 24); const SWord16 s261 = (SWord16) (s260 >> 16); const SWord8 s262 = (SWord8) (s261 >> 8); const SWord8 s263 = table0[s262]; const SWord8 s264 = 1 ^ s263; const SWord8 s265 = (SWord8) s261; const SWord8 s266 = table0[s265]; const SWord16 s267 = (((SWord16) s264) << 8) | ((SWord16) s266); const SWord16 s268 = (SWord16) s260; const SWord8 s269 = (SWord8) (s268 >> 8); const SWord8 s270 = table0[s269]; const SWord8 s271 = (SWord8) s268; const SWord8 s272 = table0[s271]; const SWord16 s273 = (((SWord16) s270) << 8) | ((SWord16) s272); const SWord32 s274 = (((SWord32) s267) << 16) | ((SWord32) s273); const SWord32 s275 = s0 ^ s274; const SWord32 s276 = s1 ^ s275; const SWord32 s277 = s2 ^ s276; const SWord32 s278 = s3 ^ s277; const SWord32 s279 = (s278 << 8) | (s278 >> 24); const SWord16 s280 = (SWord16) (s279 >> 16); const SWord8 s281 = (SWord8) (s280 >> 8); const SWord8 s282 = table0[s281]; const SWord8 s283 = 2 ^ s282; const SWord8 s284 = (SWord8) s280; const SWord8 s285 = table0[s284]; const SWord16 s286 = (((SWord16) s283) << 8) | ((SWord16) s285); const SWord16 s287 = (SWord16) s279; const SWord8 s288 = (SWord8) (s287 >> 8); const SWord8 s289 = table0[s288]; const SWord8 s290 = (SWord8) s287; const SWord8 s291 = table0[s290]; const SWord16 s292 = (((SWord16) s289) << 8) | ((SWord16) s291); const SWord32 s293 = (((SWord32) s286) << 16) | ((SWord32) s292); const SWord32 s294 = s275 ^ s293; const SWord32 s295 = s276 ^ s294; const SWord32 s296 = s277 ^ s295; const SWord32 s297 = s278 ^ s296; const SWord32 s298 = (s297 << 8) | (s297 >> 24); const SWord16 s299 = (SWord16) (s298 >> 16); const SWord8 s300 = (SWord8) (s299 >> 8); const SWord8 s301 = table0[s300]; const SWord8 s302 = 4 ^ s301; const SWord8 s303 = (SWord8) s299; const SWord8 s304 = table0[s303]; const SWord16 s305 = (((SWord16) s302) << 8) | ((SWord16) s304); const SWord16 s306 = (SWord16) s298; const SWord8 s307 = (SWord8) (s306 >> 8); const SWord8 s308 = table0[s307]; const SWord8 s309 = (SWord8) s306; const SWord8 s310 = table0[s309]; const SWord16 s311 = (((SWord16) s308) << 8) | ((SWord16) s310); const SWord32 s312 = (((SWord32) s305) << 16) | ((SWord32) s311); const SWord32 s313 = s294 ^ s312; const SWord32 s314 = s295 ^ s313; const SWord32 s315 = s296 ^ s314; const SWord32 s316 = s297 ^ s315; const SWord32 s317 = (s316 << 8) | (s316 >> 24); const SWord16 s318 = (SWord16) (s317 >> 16); const SWord8 s319 = (SWord8) (s318 >> 8); const SWord8 s320 = table0[s319]; const SWord8 s321 = 8 ^ s320; const SWord8 s322 = (SWord8) s318; const SWord8 s323 = table0[s322]; const SWord16 s324 = (((SWord16) s321) << 8) | ((SWord16) s323); const SWord16 s325 = (SWord16) s317; const SWord8 s326 = (SWord8) (s325 >> 8); const SWord8 s327 = table0[s326]; const SWord8 s328 = (SWord8) s325; const SWord8 s329 = table0[s328]; const SWord16 s330 = (((SWord16) s327) << 8) | ((SWord16) s329); const SWord32 s331 = (((SWord32) s324) << 16) | ((SWord32) s330); const SWord32 s332 = s313 ^ s331; const SWord32 s333 = s314 ^ s332; const SWord32 s334 = s315 ^ s333; const SWord32 s335 = s316 ^ s334; const SWord32 s336 = (s335 << 8) | (s335 >> 24); const SWord16 s337 = (SWord16) (s336 >> 16); const SWord8 s338 = (SWord8) (s337 >> 8); const SWord8 s339 = table0[s338]; const SWord8 s340 = 16 ^ s339; const SWord8 s341 = (SWord8) s337; const SWord8 s342 = table0[s341]; const SWord16 s343 = (((SWord16) s340) << 8) | ((SWord16) s342); const SWord16 s344 = (SWord16) s336; const SWord8 s345 = (SWord8) (s344 >> 8); const SWord8 s346 = table0[s345]; const SWord8 s347 = (SWord8) s344; const SWord8 s348 = table0[s347]; const SWord16 s349 = (((SWord16) s346) << 8) | ((SWord16) s348); const SWord32 s350 = (((SWord32) s343) << 16) | ((SWord32) s349); const SWord32 s351 = s332 ^ s350; const SWord32 s352 = s333 ^ s351; const SWord32 s353 = s334 ^ s352; const SWord32 s354 = s335 ^ s353; const SWord32 s355 = (s354 << 8) | (s354 >> 24); const SWord16 s356 = (SWord16) (s355 >> 16); const SWord8 s357 = (SWord8) (s356 >> 8); const SWord8 s358 = table0[s357]; const SWord8 s359 = 32 ^ s358; const SWord8 s360 = (SWord8) s356; const SWord8 s361 = table0[s360]; const SWord16 s362 = (((SWord16) s359) << 8) | ((SWord16) s361); const SWord16 s363 = (SWord16) s355; const SWord8 s364 = (SWord8) (s363 >> 8); const SWord8 s365 = table0[s364]; const SWord8 s366 = (SWord8) s363; const SWord8 s367 = table0[s366]; const SWord16 s368 = (((SWord16) s365) << 8) | ((SWord16) s367); const SWord32 s369 = (((SWord32) s362) << 16) | ((SWord32) s368); const SWord32 s370 = s351 ^ s369; const SWord32 s371 = s352 ^ s370; const SWord32 s372 = s353 ^ s371; const SWord32 s373 = s354 ^ s372; const SWord32 s374 = (s373 << 8) | (s373 >> 24); const SWord16 s375 = (SWord16) (s374 >> 16); const SWord8 s376 = (SWord8) (s375 >> 8); const SWord8 s377 = table0[s376]; const SWord8 s378 = 64 ^ s377; const SWord8 s379 = (SWord8) s375; const SWord8 s380 = table0[s379]; const SWord16 s381 = (((SWord16) s378) << 8) | ((SWord16) s380); const SWord16 s382 = (SWord16) s374; const SWord8 s383 = (SWord8) (s382 >> 8); const SWord8 s384 = table0[s383]; const SWord8 s385 = (SWord8) s382; const SWord8 s386 = table0[s385]; const SWord16 s387 = (((SWord16) s384) << 8) | ((SWord16) s386); const SWord32 s388 = (((SWord32) s381) << 16) | ((SWord32) s387); const SWord32 s389 = s370 ^ s388; const SWord32 s390 = s371 ^ s389; const SWord32 s391 = s372 ^ s390; const SWord32 s392 = s373 ^ s391; const SWord32 s393 = (s392 << 8) | (s392 >> 24); const SWord16 s394 = (SWord16) (s393 >> 16); const SWord8 s395 = (SWord8) (s394 >> 8); const SWord8 s396 = table0[s395]; const SWord8 s397 = 128 ^ s396; const SWord8 s398 = (SWord8) s394; const SWord8 s399 = table0[s398]; const SWord16 s400 = (((SWord16) s397) << 8) | ((SWord16) s399); const SWord16 s401 = (SWord16) s393; const SWord8 s402 = (SWord8) (s401 >> 8); const SWord8 s403 = table0[s402]; const SWord8 s404 = (SWord8) s401; const SWord8 s405 = table0[s404]; const SWord16 s406 = (((SWord16) s403) << 8) | ((SWord16) s405); const SWord32 s407 = (((SWord32) s400) << 16) | ((SWord32) s406); const SWord32 s408 = s389 ^ s407; const SWord32 s409 = s390 ^ s408; const SWord32 s410 = s391 ^ s409; const SWord32 s411 = s392 ^ s410; const SWord32 s412 = (s411 << 8) | (s411 >> 24); const SWord16 s413 = (SWord16) (s412 >> 16); const SWord8 s414 = (SWord8) (s413 >> 8); const SWord8 s415 = table0[s414]; const SWord8 s416 = 27 ^ s415; const SWord8 s417 = (SWord8) s413; const SWord8 s418 = table0[s417]; const SWord16 s419 = (((SWord16) s416) << 8) | ((SWord16) s418); const SWord16 s420 = (SWord16) s412; const SWord8 s421 = (SWord8) (s420 >> 8); const SWord8 s422 = table0[s421]; const SWord8 s423 = (SWord8) s420; const SWord8 s424 = table0[s423]; const SWord16 s425 = (((SWord16) s422) << 8) | ((SWord16) s424); const SWord32 s426 = (((SWord32) s419) << 16) | ((SWord32) s425); const SWord32 s427 = s408 ^ s426; const SWord32 s428 = s409 ^ s427; const SWord32 s429 = s410 ^ s428; const SWord32 s430 = s411 ^ s429; const SWord32 s431 = (s430 << 8) | (s430 >> 24); const SWord16 s432 = (SWord16) (s431 >> 16); const SWord8 s433 = (SWord8) (s432 >> 8); const SWord8 s434 = table0[s433]; const SWord8 s435 = 54 ^ s434; const SWord8 s436 = (SWord8) s432; const SWord8 s437 = table0[s436]; const SWord16 s438 = (((SWord16) s435) << 8) | ((SWord16) s437); const SWord16 s439 = (SWord16) s431; const SWord8 s440 = (SWord8) (s439 >> 8); const SWord8 s441 = table0[s440]; const SWord8 s442 = (SWord8) s439; const SWord8 s443 = table0[s442]; const SWord16 s444 = (((SWord16) s441) << 8) | ((SWord16) s443); const SWord32 s445 = (((SWord32) s438) << 16) | ((SWord32) s444); const SWord32 s446 = s427 ^ s445; const SWord32 s447 = s428 ^ s446; const SWord32 s448 = s429 ^ s447; const SWord32 s449 = s430 ^ s448; const SWord16 s450 = (SWord16) (s427 >> 16); const SWord8 s451 = (SWord8) (s450 >> 8); const SWord8 s452 = table1[s451]; const SWord8 s453 = (SWord8) s450; const SWord8 s454 = table2[s453]; const SWord16 s455 = (SWord16) s427; const SWord8 s456 = (SWord8) (s455 >> 8); const SWord8 s457 = table3[s456]; const SWord8 s458 = (SWord8) s455; const SWord8 s459 = table4[s458]; const SWord8 s460 = s457 ^ s459; const SWord8 s461 = s454 ^ s460; const SWord8 s462 = s452 ^ s461; const SWord8 s463 = table4[s451]; const SWord8 s464 = table1[s453]; const SWord8 s465 = table2[s456]; const SWord8 s466 = table3[s458]; const SWord8 s467 = s465 ^ s466; const SWord8 s468 = s464 ^ s467; const SWord8 s469 = s463 ^ s468; const SWord16 s470 = (((SWord16) s462) << 8) | ((SWord16) s469); const SWord8 s471 = table3[s451]; const SWord8 s472 = table4[s453]; const SWord8 s473 = table1[s456]; const SWord8 s474 = table2[s458]; const SWord8 s475 = s473 ^ s474; const SWord8 s476 = s472 ^ s475; const SWord8 s477 = s471 ^ s476; const SWord8 s478 = table2[s451]; const SWord8 s479 = table3[s453]; const SWord8 s480 = table4[s456]; const SWord8 s481 = table1[s458]; const SWord8 s482 = s480 ^ s481; const SWord8 s483 = s479 ^ s482; const SWord8 s484 = s478 ^ s483; const SWord16 s485 = (((SWord16) s477) << 8) | ((SWord16) s484); const SWord32 s486 = (((SWord32) s470) << 16) | ((SWord32) s485); const SWord16 s487 = (SWord16) (s428 >> 16); const SWord8 s488 = (SWord8) (s487 >> 8); const SWord8 s489 = table1[s488]; const SWord8 s490 = (SWord8) s487; const SWord8 s491 = table2[s490]; const SWord16 s492 = (SWord16) s428; const SWord8 s493 = (SWord8) (s492 >> 8); const SWord8 s494 = table3[s493]; const SWord8 s495 = (SWord8) s492; const SWord8 s496 = table4[s495]; const SWord8 s497 = s494 ^ s496; const SWord8 s498 = s491 ^ s497; const SWord8 s499 = s489 ^ s498; const SWord8 s500 = table4[s488]; const SWord8 s501 = table1[s490]; const SWord8 s502 = table2[s493]; const SWord8 s503 = table3[s495]; const SWord8 s504 = s502 ^ s503; const SWord8 s505 = s501 ^ s504; const SWord8 s506 = s500 ^ s505; const SWord16 s507 = (((SWord16) s499) << 8) | ((SWord16) s506); const SWord8 s508 = table3[s488]; const SWord8 s509 = table4[s490]; const SWord8 s510 = table1[s493]; const SWord8 s511 = table2[s495]; const SWord8 s512 = s510 ^ s511; const SWord8 s513 = s509 ^ s512; const SWord8 s514 = s508 ^ s513; const SWord8 s515 = table2[s488]; const SWord8 s516 = table3[s490]; const SWord8 s517 = table4[s493]; const SWord8 s518 = table1[s495]; const SWord8 s519 = s517 ^ s518; const SWord8 s520 = s516 ^ s519; const SWord8 s521 = s515 ^ s520; const SWord16 s522 = (((SWord16) s514) << 8) | ((SWord16) s521); const SWord32 s523 = (((SWord32) s507) << 16) | ((SWord32) s522); const SWord16 s524 = (SWord16) (s429 >> 16); const SWord8 s525 = (SWord8) (s524 >> 8); const SWord8 s526 = table1[s525]; const SWord8 s527 = (SWord8) s524; const SWord8 s528 = table2[s527]; const SWord16 s529 = (SWord16) s429; const SWord8 s530 = (SWord8) (s529 >> 8); const SWord8 s531 = table3[s530]; const SWord8 s532 = (SWord8) s529; const SWord8 s533 = table4[s532]; const SWord8 s534 = s531 ^ s533; const SWord8 s535 = s528 ^ s534; const SWord8 s536 = s526 ^ s535; const SWord8 s537 = table4[s525]; const SWord8 s538 = table1[s527]; const SWord8 s539 = table2[s530]; const SWord8 s540 = table3[s532]; const SWord8 s541 = s539 ^ s540; const SWord8 s542 = s538 ^ s541; const SWord8 s543 = s537 ^ s542; const SWord16 s544 = (((SWord16) s536) << 8) | ((SWord16) s543); const SWord8 s545 = table3[s525]; const SWord8 s546 = table4[s527]; const SWord8 s547 = table1[s530]; const SWord8 s548 = table2[s532]; const SWord8 s549 = s547 ^ s548; const SWord8 s550 = s546 ^ s549; const SWord8 s551 = s545 ^ s550; const SWord8 s552 = table2[s525]; const SWord8 s553 = table3[s527]; const SWord8 s554 = table4[s530]; const SWord8 s555 = table1[s532]; const SWord8 s556 = s554 ^ s555; const SWord8 s557 = s553 ^ s556; const SWord8 s558 = s552 ^ s557; const SWord16 s559 = (((SWord16) s551) << 8) | ((SWord16) s558); const SWord32 s560 = (((SWord32) s544) << 16) | ((SWord32) s559); const SWord16 s561 = (SWord16) (s430 >> 16); const SWord8 s562 = (SWord8) (s561 >> 8); const SWord8 s563 = table1[s562]; const SWord8 s564 = (SWord8) s561; const SWord8 s565 = table2[s564]; const SWord16 s566 = (SWord16) s430; const SWord8 s567 = (SWord8) (s566 >> 8); const SWord8 s568 = table3[s567]; const SWord8 s569 = (SWord8) s566; const SWord8 s570 = table4[s569]; const SWord8 s571 = s568 ^ s570; const SWord8 s572 = s565 ^ s571; const SWord8 s573 = s563 ^ s572; const SWord8 s574 = table4[s562]; const SWord8 s575 = table1[s564]; const SWord8 s576 = table2[s567]; const SWord8 s577 = table3[s569]; const SWord8 s578 = s576 ^ s577; const SWord8 s579 = s575 ^ s578; const SWord8 s580 = s574 ^ s579; const SWord16 s581 = (((SWord16) s573) << 8) | ((SWord16) s580); const SWord8 s582 = table3[s562]; const SWord8 s583 = table4[s564]; const SWord8 s584 = table1[s567]; const SWord8 s585 = table2[s569]; const SWord8 s586 = s584 ^ s585; const SWord8 s587 = s583 ^ s586; const SWord8 s588 = s582 ^ s587; const SWord8 s589 = table2[s562]; const SWord8 s590 = table3[s564]; const SWord8 s591 = table4[s567]; const SWord8 s592 = table1[s569]; const SWord8 s593 = s591 ^ s592; const SWord8 s594 = s590 ^ s593; const SWord8 s595 = s589 ^ s594; const SWord16 s596 = (((SWord16) s588) << 8) | ((SWord16) s595); const SWord32 s597 = (((SWord32) s581) << 16) | ((SWord32) s596); const SWord16 s598 = (SWord16) (s408 >> 16); const SWord8 s599 = (SWord8) (s598 >> 8); const SWord8 s600 = table1[s599]; const SWord8 s601 = (SWord8) s598; const SWord8 s602 = table2[s601]; const SWord16 s603 = (SWord16) s408; const SWord8 s604 = (SWord8) (s603 >> 8); const SWord8 s605 = table3[s604]; const SWord8 s606 = (SWord8) s603; const SWord8 s607 = table4[s606]; const SWord8 s608 = s605 ^ s607; const SWord8 s609 = s602 ^ s608; const SWord8 s610 = s600 ^ s609; const SWord8 s611 = table4[s599]; const SWord8 s612 = table1[s601]; const SWord8 s613 = table2[s604]; const SWord8 s614 = table3[s606]; const SWord8 s615 = s613 ^ s614; const SWord8 s616 = s612 ^ s615; const SWord8 s617 = s611 ^ s616; const SWord16 s618 = (((SWord16) s610) << 8) | ((SWord16) s617); const SWord8 s619 = table3[s599]; const SWord8 s620 = table4[s601]; const SWord8 s621 = table1[s604]; const SWord8 s622 = table2[s606]; const SWord8 s623 = s621 ^ s622; const SWord8 s624 = s620 ^ s623; const SWord8 s625 = s619 ^ s624; const SWord8 s626 = table2[s599]; const SWord8 s627 = table3[s601]; const SWord8 s628 = table4[s604]; const SWord8 s629 = table1[s606]; const SWord8 s630 = s628 ^ s629; const SWord8 s631 = s627 ^ s630; const SWord8 s632 = s626 ^ s631; const SWord16 s633 = (((SWord16) s625) << 8) | ((SWord16) s632); const SWord32 s634 = (((SWord32) s618) << 16) | ((SWord32) s633); const SWord16 s635 = (SWord16) (s409 >> 16); const SWord8 s636 = (SWord8) (s635 >> 8); const SWord8 s637 = table1[s636]; const SWord8 s638 = (SWord8) s635; const SWord8 s639 = table2[s638]; const SWord16 s640 = (SWord16) s409; const SWord8 s641 = (SWord8) (s640 >> 8); const SWord8 s642 = table3[s641]; const SWord8 s643 = (SWord8) s640; const SWord8 s644 = table4[s643]; const SWord8 s645 = s642 ^ s644; const SWord8 s646 = s639 ^ s645; const SWord8 s647 = s637 ^ s646; const SWord8 s648 = table4[s636]; const SWord8 s649 = table1[s638]; const SWord8 s650 = table2[s641]; const SWord8 s651 = table3[s643]; const SWord8 s652 = s650 ^ s651; const SWord8 s653 = s649 ^ s652; const SWord8 s654 = s648 ^ s653; const SWord16 s655 = (((SWord16) s647) << 8) | ((SWord16) s654); const SWord8 s656 = table3[s636]; const SWord8 s657 = table4[s638]; const SWord8 s658 = table1[s641]; const SWord8 s659 = table2[s643]; const SWord8 s660 = s658 ^ s659; const SWord8 s661 = s657 ^ s660; const SWord8 s662 = s656 ^ s661; const SWord8 s663 = table2[s636]; const SWord8 s664 = table3[s638]; const SWord8 s665 = table4[s641]; const SWord8 s666 = table1[s643]; const SWord8 s667 = s665 ^ s666; const SWord8 s668 = s664 ^ s667; const SWord8 s669 = s663 ^ s668; const SWord16 s670 = (((SWord16) s662) << 8) | ((SWord16) s669); const SWord32 s671 = (((SWord32) s655) << 16) | ((SWord32) s670); const SWord16 s672 = (SWord16) (s410 >> 16); const SWord8 s673 = (SWord8) (s672 >> 8); const SWord8 s674 = table1[s673]; const SWord8 s675 = (SWord8) s672; const SWord8 s676 = table2[s675]; const SWord16 s677 = (SWord16) s410; const SWord8 s678 = (SWord8) (s677 >> 8); const SWord8 s679 = table3[s678]; const SWord8 s680 = (SWord8) s677; const SWord8 s681 = table4[s680]; const SWord8 s682 = s679 ^ s681; const SWord8 s683 = s676 ^ s682; const SWord8 s684 = s674 ^ s683; const SWord8 s685 = table4[s673]; const SWord8 s686 = table1[s675]; const SWord8 s687 = table2[s678]; const SWord8 s688 = table3[s680]; const SWord8 s689 = s687 ^ s688; const SWord8 s690 = s686 ^ s689; const SWord8 s691 = s685 ^ s690; const SWord16 s692 = (((SWord16) s684) << 8) | ((SWord16) s691); const SWord8 s693 = table3[s673]; const SWord8 s694 = table4[s675]; const SWord8 s695 = table1[s678]; const SWord8 s696 = table2[s680]; const SWord8 s697 = s695 ^ s696; const SWord8 s698 = s694 ^ s697; const SWord8 s699 = s693 ^ s698; const SWord8 s700 = table2[s673]; const SWord8 s701 = table3[s675]; const SWord8 s702 = table4[s678]; const SWord8 s703 = table1[s680]; const SWord8 s704 = s702 ^ s703; const SWord8 s705 = s701 ^ s704; const SWord8 s706 = s700 ^ s705; const SWord16 s707 = (((SWord16) s699) << 8) | ((SWord16) s706); const SWord32 s708 = (((SWord32) s692) << 16) | ((SWord32) s707); const SWord16 s709 = (SWord16) (s411 >> 16); const SWord8 s710 = (SWord8) (s709 >> 8); const SWord8 s711 = table1[s710]; const SWord8 s712 = (SWord8) s709; const SWord8 s713 = table2[s712]; const SWord16 s714 = (SWord16) s411; const SWord8 s715 = (SWord8) (s714 >> 8); const SWord8 s716 = table3[s715]; const SWord8 s717 = (SWord8) s714; const SWord8 s718 = table4[s717]; const SWord8 s719 = s716 ^ s718; const SWord8 s720 = s713 ^ s719; const SWord8 s721 = s711 ^ s720; const SWord8 s722 = table4[s710]; const SWord8 s723 = table1[s712]; const SWord8 s724 = table2[s715]; const SWord8 s725 = table3[s717]; const SWord8 s726 = s724 ^ s725; const SWord8 s727 = s723 ^ s726; const SWord8 s728 = s722 ^ s727; const SWord16 s729 = (((SWord16) s721) << 8) | ((SWord16) s728); const SWord8 s730 = table3[s710]; const SWord8 s731 = table4[s712]; const SWord8 s732 = table1[s715]; const SWord8 s733 = table2[s717]; const SWord8 s734 = s732 ^ s733; const SWord8 s735 = s731 ^ s734; const SWord8 s736 = s730 ^ s735; const SWord8 s737 = table2[s710]; const SWord8 s738 = table3[s712]; const SWord8 s739 = table4[s715]; const SWord8 s740 = table1[s717]; const SWord8 s741 = s739 ^ s740; const SWord8 s742 = s738 ^ s741; const SWord8 s743 = s737 ^ s742; const SWord16 s744 = (((SWord16) s736) << 8) | ((SWord16) s743); const SWord32 s745 = (((SWord32) s729) << 16) | ((SWord32) s744); const SWord16 s746 = (SWord16) (s389 >> 16); const SWord8 s747 = (SWord8) (s746 >> 8); const SWord8 s748 = table1[s747]; const SWord8 s749 = (SWord8) s746; const SWord8 s750 = table2[s749]; const SWord16 s751 = (SWord16) s389; const SWord8 s752 = (SWord8) (s751 >> 8); const SWord8 s753 = table3[s752]; const SWord8 s754 = (SWord8) s751; const SWord8 s755 = table4[s754]; const SWord8 s756 = s753 ^ s755; const SWord8 s757 = s750 ^ s756; const SWord8 s758 = s748 ^ s757; const SWord8 s759 = table4[s747]; const SWord8 s760 = table1[s749]; const SWord8 s761 = table2[s752]; const SWord8 s762 = table3[s754]; const SWord8 s763 = s761 ^ s762; const SWord8 s764 = s760 ^ s763; const SWord8 s765 = s759 ^ s764; const SWord16 s766 = (((SWord16) s758) << 8) | ((SWord16) s765); const SWord8 s767 = table3[s747]; const SWord8 s768 = table4[s749]; const SWord8 s769 = table1[s752]; const SWord8 s770 = table2[s754]; const SWord8 s771 = s769 ^ s770; const SWord8 s772 = s768 ^ s771; const SWord8 s773 = s767 ^ s772; const SWord8 s774 = table2[s747]; const SWord8 s775 = table3[s749]; const SWord8 s776 = table4[s752]; const SWord8 s777 = table1[s754]; const SWord8 s778 = s776 ^ s777; const SWord8 s779 = s775 ^ s778; const SWord8 s780 = s774 ^ s779; const SWord16 s781 = (((SWord16) s773) << 8) | ((SWord16) s780); const SWord32 s782 = (((SWord32) s766) << 16) | ((SWord32) s781); const SWord16 s783 = (SWord16) (s390 >> 16); const SWord8 s784 = (SWord8) (s783 >> 8); const SWord8 s785 = table1[s784]; const SWord8 s786 = (SWord8) s783; const SWord8 s787 = table2[s786]; const SWord16 s788 = (SWord16) s390; const SWord8 s789 = (SWord8) (s788 >> 8); const SWord8 s790 = table3[s789]; const SWord8 s791 = (SWord8) s788; const SWord8 s792 = table4[s791]; const SWord8 s793 = s790 ^ s792; const SWord8 s794 = s787 ^ s793; const SWord8 s795 = s785 ^ s794; const SWord8 s796 = table4[s784]; const SWord8 s797 = table1[s786]; const SWord8 s798 = table2[s789]; const SWord8 s799 = table3[s791]; const SWord8 s800 = s798 ^ s799; const SWord8 s801 = s797 ^ s800; const SWord8 s802 = s796 ^ s801; const SWord16 s803 = (((SWord16) s795) << 8) | ((SWord16) s802); const SWord8 s804 = table3[s784]; const SWord8 s805 = table4[s786]; const SWord8 s806 = table1[s789]; const SWord8 s807 = table2[s791]; const SWord8 s808 = s806 ^ s807; const SWord8 s809 = s805 ^ s808; const SWord8 s810 = s804 ^ s809; const SWord8 s811 = table2[s784]; const SWord8 s812 = table3[s786]; const SWord8 s813 = table4[s789]; const SWord8 s814 = table1[s791]; const SWord8 s815 = s813 ^ s814; const SWord8 s816 = s812 ^ s815; const SWord8 s817 = s811 ^ s816; const SWord16 s818 = (((SWord16) s810) << 8) | ((SWord16) s817); const SWord32 s819 = (((SWord32) s803) << 16) | ((SWord32) s818); const SWord16 s820 = (SWord16) (s391 >> 16); const SWord8 s821 = (SWord8) (s820 >> 8); const SWord8 s822 = table1[s821]; const SWord8 s823 = (SWord8) s820; const SWord8 s824 = table2[s823]; const SWord16 s825 = (SWord16) s391; const SWord8 s826 = (SWord8) (s825 >> 8); const SWord8 s827 = table3[s826]; const SWord8 s828 = (SWord8) s825; const SWord8 s829 = table4[s828]; const SWord8 s830 = s827 ^ s829; const SWord8 s831 = s824 ^ s830; const SWord8 s832 = s822 ^ s831; const SWord8 s833 = table4[s821]; const SWord8 s834 = table1[s823]; const SWord8 s835 = table2[s826]; const SWord8 s836 = table3[s828]; const SWord8 s837 = s835 ^ s836; const SWord8 s838 = s834 ^ s837; const SWord8 s839 = s833 ^ s838; const SWord16 s840 = (((SWord16) s832) << 8) | ((SWord16) s839); const SWord8 s841 = table3[s821]; const SWord8 s842 = table4[s823]; const SWord8 s843 = table1[s826]; const SWord8 s844 = table2[s828]; const SWord8 s845 = s843 ^ s844; const SWord8 s846 = s842 ^ s845; const SWord8 s847 = s841 ^ s846; const SWord8 s848 = table2[s821]; const SWord8 s849 = table3[s823]; const SWord8 s850 = table4[s826]; const SWord8 s851 = table1[s828]; const SWord8 s852 = s850 ^ s851; const SWord8 s853 = s849 ^ s852; const SWord8 s854 = s848 ^ s853; const SWord16 s855 = (((SWord16) s847) << 8) | ((SWord16) s854); const SWord32 s856 = (((SWord32) s840) << 16) | ((SWord32) s855); const SWord16 s857 = (SWord16) (s392 >> 16); const SWord8 s858 = (SWord8) (s857 >> 8); const SWord8 s859 = table1[s858]; const SWord8 s860 = (SWord8) s857; const SWord8 s861 = table2[s860]; const SWord16 s862 = (SWord16) s392; const SWord8 s863 = (SWord8) (s862 >> 8); const SWord8 s864 = table3[s863]; const SWord8 s865 = (SWord8) s862; const SWord8 s866 = table4[s865]; const SWord8 s867 = s864 ^ s866; const SWord8 s868 = s861 ^ s867; const SWord8 s869 = s859 ^ s868; const SWord8 s870 = table4[s858]; const SWord8 s871 = table1[s860]; const SWord8 s872 = table2[s863]; const SWord8 s873 = table3[s865]; const SWord8 s874 = s872 ^ s873; const SWord8 s875 = s871 ^ s874; const SWord8 s876 = s870 ^ s875; const SWord16 s877 = (((SWord16) s869) << 8) | ((SWord16) s876); const SWord8 s878 = table3[s858]; const SWord8 s879 = table4[s860]; const SWord8 s880 = table1[s863]; const SWord8 s881 = table2[s865]; const SWord8 s882 = s880 ^ s881; const SWord8 s883 = s879 ^ s882; const SWord8 s884 = s878 ^ s883; const SWord8 s885 = table2[s858]; const SWord8 s886 = table3[s860]; const SWord8 s887 = table4[s863]; const SWord8 s888 = table1[s865]; const SWord8 s889 = s887 ^ s888; const SWord8 s890 = s886 ^ s889; const SWord8 s891 = s885 ^ s890; const SWord16 s892 = (((SWord16) s884) << 8) | ((SWord16) s891); const SWord32 s893 = (((SWord32) s877) << 16) | ((SWord32) s892); const SWord16 s894 = (SWord16) (s370 >> 16); const SWord8 s895 = (SWord8) (s894 >> 8); const SWord8 s896 = table1[s895]; const SWord8 s897 = (SWord8) s894; const SWord8 s898 = table2[s897]; const SWord16 s899 = (SWord16) s370; const SWord8 s900 = (SWord8) (s899 >> 8); const SWord8 s901 = table3[s900]; const SWord8 s902 = (SWord8) s899; const SWord8 s903 = table4[s902]; const SWord8 s904 = s901 ^ s903; const SWord8 s905 = s898 ^ s904; const SWord8 s906 = s896 ^ s905; const SWord8 s907 = table4[s895]; const SWord8 s908 = table1[s897]; const SWord8 s909 = table2[s900]; const SWord8 s910 = table3[s902]; const SWord8 s911 = s909 ^ s910; const SWord8 s912 = s908 ^ s911; const SWord8 s913 = s907 ^ s912; const SWord16 s914 = (((SWord16) s906) << 8) | ((SWord16) s913); const SWord8 s915 = table3[s895]; const SWord8 s916 = table4[s897]; const SWord8 s917 = table1[s900]; const SWord8 s918 = table2[s902]; const SWord8 s919 = s917 ^ s918; const SWord8 s920 = s916 ^ s919; const SWord8 s921 = s915 ^ s920; const SWord8 s922 = table2[s895]; const SWord8 s923 = table3[s897]; const SWord8 s924 = table4[s900]; const SWord8 s925 = table1[s902]; const SWord8 s926 = s924 ^ s925; const SWord8 s927 = s923 ^ s926; const SWord8 s928 = s922 ^ s927; const SWord16 s929 = (((SWord16) s921) << 8) | ((SWord16) s928); const SWord32 s930 = (((SWord32) s914) << 16) | ((SWord32) s929); const SWord16 s931 = (SWord16) (s371 >> 16); const SWord8 s932 = (SWord8) (s931 >> 8); const SWord8 s933 = table1[s932]; const SWord8 s934 = (SWord8) s931; const SWord8 s935 = table2[s934]; const SWord16 s936 = (SWord16) s371; const SWord8 s937 = (SWord8) (s936 >> 8); const SWord8 s938 = table3[s937]; const SWord8 s939 = (SWord8) s936; const SWord8 s940 = table4[s939]; const SWord8 s941 = s938 ^ s940; const SWord8 s942 = s935 ^ s941; const SWord8 s943 = s933 ^ s942; const SWord8 s944 = table4[s932]; const SWord8 s945 = table1[s934]; const SWord8 s946 = table2[s937]; const SWord8 s947 = table3[s939]; const SWord8 s948 = s946 ^ s947; const SWord8 s949 = s945 ^ s948; const SWord8 s950 = s944 ^ s949; const SWord16 s951 = (((SWord16) s943) << 8) | ((SWord16) s950); const SWord8 s952 = table3[s932]; const SWord8 s953 = table4[s934]; const SWord8 s954 = table1[s937]; const SWord8 s955 = table2[s939]; const SWord8 s956 = s954 ^ s955; const SWord8 s957 = s953 ^ s956; const SWord8 s958 = s952 ^ s957; const SWord8 s959 = table2[s932]; const SWord8 s960 = table3[s934]; const SWord8 s961 = table4[s937]; const SWord8 s962 = table1[s939]; const SWord8 s963 = s961 ^ s962; const SWord8 s964 = s960 ^ s963; const SWord8 s965 = s959 ^ s964; const SWord16 s966 = (((SWord16) s958) << 8) | ((SWord16) s965); const SWord32 s967 = (((SWord32) s951) << 16) | ((SWord32) s966); const SWord16 s968 = (SWord16) (s372 >> 16); const SWord8 s969 = (SWord8) (s968 >> 8); const SWord8 s970 = table1[s969]; const SWord8 s971 = (SWord8) s968; const SWord8 s972 = table2[s971]; const SWord16 s973 = (SWord16) s372; const SWord8 s974 = (SWord8) (s973 >> 8); const SWord8 s975 = table3[s974]; const SWord8 s976 = (SWord8) s973; const SWord8 s977 = table4[s976]; const SWord8 s978 = s975 ^ s977; const SWord8 s979 = s972 ^ s978; const SWord8 s980 = s970 ^ s979; const SWord8 s981 = table4[s969]; const SWord8 s982 = table1[s971]; const SWord8 s983 = table2[s974]; const SWord8 s984 = table3[s976]; const SWord8 s985 = s983 ^ s984; const SWord8 s986 = s982 ^ s985; const SWord8 s987 = s981 ^ s986; const SWord16 s988 = (((SWord16) s980) << 8) | ((SWord16) s987); const SWord8 s989 = table3[s969]; const SWord8 s990 = table4[s971]; const SWord8 s991 = table1[s974]; const SWord8 s992 = table2[s976]; const SWord8 s993 = s991 ^ s992; const SWord8 s994 = s990 ^ s993; const SWord8 s995 = s989 ^ s994; const SWord8 s996 = table2[s969]; const SWord8 s997 = table3[s971]; const SWord8 s998 = table4[s974]; const SWord8 s999 = table1[s976]; const SWord8 s1000 = s998 ^ s999; const SWord8 s1001 = s997 ^ s1000; const SWord8 s1002 = s996 ^ s1001; const SWord16 s1003 = (((SWord16) s995) << 8) | ((SWord16) s1002); const SWord32 s1004 = (((SWord32) s988) << 16) | ((SWord32) s1003); const SWord16 s1005 = (SWord16) (s373 >> 16); const SWord8 s1006 = (SWord8) (s1005 >> 8); const SWord8 s1007 = table1[s1006]; const SWord8 s1008 = (SWord8) s1005; const SWord8 s1009 = table2[s1008]; const SWord16 s1010 = (SWord16) s373; const SWord8 s1011 = (SWord8) (s1010 >> 8); const SWord8 s1012 = table3[s1011]; const SWord8 s1013 = (SWord8) s1010; const SWord8 s1014 = table4[s1013]; const SWord8 s1015 = s1012 ^ s1014; const SWord8 s1016 = s1009 ^ s1015; const SWord8 s1017 = s1007 ^ s1016; const SWord8 s1018 = table4[s1006]; const SWord8 s1019 = table1[s1008]; const SWord8 s1020 = table2[s1011]; const SWord8 s1021 = table3[s1013]; const SWord8 s1022 = s1020 ^ s1021; const SWord8 s1023 = s1019 ^ s1022; const SWord8 s1024 = s1018 ^ s1023; const SWord16 s1025 = (((SWord16) s1017) << 8) | ((SWord16) s1024); const SWord8 s1026 = table3[s1006]; const SWord8 s1027 = table4[s1008]; const SWord8 s1028 = table1[s1011]; const SWord8 s1029 = table2[s1013]; const SWord8 s1030 = s1028 ^ s1029; const SWord8 s1031 = s1027 ^ s1030; const SWord8 s1032 = s1026 ^ s1031; const SWord8 s1033 = table2[s1006]; const SWord8 s1034 = table3[s1008]; const SWord8 s1035 = table4[s1011]; const SWord8 s1036 = table1[s1013]; const SWord8 s1037 = s1035 ^ s1036; const SWord8 s1038 = s1034 ^ s1037; const SWord8 s1039 = s1033 ^ s1038; const SWord16 s1040 = (((SWord16) s1032) << 8) | ((SWord16) s1039); const SWord32 s1041 = (((SWord32) s1025) << 16) | ((SWord32) s1040); const SWord16 s1042 = (SWord16) (s351 >> 16); const SWord8 s1043 = (SWord8) (s1042 >> 8); const SWord8 s1044 = table1[s1043]; const SWord8 s1045 = (SWord8) s1042; const SWord8 s1046 = table2[s1045]; const SWord16 s1047 = (SWord16) s351; const SWord8 s1048 = (SWord8) (s1047 >> 8); const SWord8 s1049 = table3[s1048]; const SWord8 s1050 = (SWord8) s1047; const SWord8 s1051 = table4[s1050]; const SWord8 s1052 = s1049 ^ s1051; const SWord8 s1053 = s1046 ^ s1052; const SWord8 s1054 = s1044 ^ s1053; const SWord8 s1055 = table4[s1043]; const SWord8 s1056 = table1[s1045]; const SWord8 s1057 = table2[s1048]; const SWord8 s1058 = table3[s1050]; const SWord8 s1059 = s1057 ^ s1058; const SWord8 s1060 = s1056 ^ s1059; const SWord8 s1061 = s1055 ^ s1060; const SWord16 s1062 = (((SWord16) s1054) << 8) | ((SWord16) s1061); const SWord8 s1063 = table3[s1043]; const SWord8 s1064 = table4[s1045]; const SWord8 s1065 = table1[s1048]; const SWord8 s1066 = table2[s1050]; const SWord8 s1067 = s1065 ^ s1066; const SWord8 s1068 = s1064 ^ s1067; const SWord8 s1069 = s1063 ^ s1068; const SWord8 s1070 = table2[s1043]; const SWord8 s1071 = table3[s1045]; const SWord8 s1072 = table4[s1048]; const SWord8 s1073 = table1[s1050]; const SWord8 s1074 = s1072 ^ s1073; const SWord8 s1075 = s1071 ^ s1074; const SWord8 s1076 = s1070 ^ s1075; const SWord16 s1077 = (((SWord16) s1069) << 8) | ((SWord16) s1076); const SWord32 s1078 = (((SWord32) s1062) << 16) | ((SWord32) s1077); const SWord16 s1079 = (SWord16) (s352 >> 16); const SWord8 s1080 = (SWord8) (s1079 >> 8); const SWord8 s1081 = table1[s1080]; const SWord8 s1082 = (SWord8) s1079; const SWord8 s1083 = table2[s1082]; const SWord16 s1084 = (SWord16) s352; const SWord8 s1085 = (SWord8) (s1084 >> 8); const SWord8 s1086 = table3[s1085]; const SWord8 s1087 = (SWord8) s1084; const SWord8 s1088 = table4[s1087]; const SWord8 s1089 = s1086 ^ s1088; const SWord8 s1090 = s1083 ^ s1089; const SWord8 s1091 = s1081 ^ s1090; const SWord8 s1092 = table4[s1080]; const SWord8 s1093 = table1[s1082]; const SWord8 s1094 = table2[s1085]; const SWord8 s1095 = table3[s1087]; const SWord8 s1096 = s1094 ^ s1095; const SWord8 s1097 = s1093 ^ s1096; const SWord8 s1098 = s1092 ^ s1097; const SWord16 s1099 = (((SWord16) s1091) << 8) | ((SWord16) s1098); const SWord8 s1100 = table3[s1080]; const SWord8 s1101 = table4[s1082]; const SWord8 s1102 = table1[s1085]; const SWord8 s1103 = table2[s1087]; const SWord8 s1104 = s1102 ^ s1103; const SWord8 s1105 = s1101 ^ s1104; const SWord8 s1106 = s1100 ^ s1105; const SWord8 s1107 = table2[s1080]; const SWord8 s1108 = table3[s1082]; const SWord8 s1109 = table4[s1085]; const SWord8 s1110 = table1[s1087]; const SWord8 s1111 = s1109 ^ s1110; const SWord8 s1112 = s1108 ^ s1111; const SWord8 s1113 = s1107 ^ s1112; const SWord16 s1114 = (((SWord16) s1106) << 8) | ((SWord16) s1113); const SWord32 s1115 = (((SWord32) s1099) << 16) | ((SWord32) s1114); const SWord16 s1116 = (SWord16) (s353 >> 16); const SWord8 s1117 = (SWord8) (s1116 >> 8); const SWord8 s1118 = table1[s1117]; const SWord8 s1119 = (SWord8) s1116; const SWord8 s1120 = table2[s1119]; const SWord16 s1121 = (SWord16) s353; const SWord8 s1122 = (SWord8) (s1121 >> 8); const SWord8 s1123 = table3[s1122]; const SWord8 s1124 = (SWord8) s1121; const SWord8 s1125 = table4[s1124]; const SWord8 s1126 = s1123 ^ s1125; const SWord8 s1127 = s1120 ^ s1126; const SWord8 s1128 = s1118 ^ s1127; const SWord8 s1129 = table4[s1117]; const SWord8 s1130 = table1[s1119]; const SWord8 s1131 = table2[s1122]; const SWord8 s1132 = table3[s1124]; const SWord8 s1133 = s1131 ^ s1132; const SWord8 s1134 = s1130 ^ s1133; const SWord8 s1135 = s1129 ^ s1134; const SWord16 s1136 = (((SWord16) s1128) << 8) | ((SWord16) s1135); const SWord8 s1137 = table3[s1117]; const SWord8 s1138 = table4[s1119]; const SWord8 s1139 = table1[s1122]; const SWord8 s1140 = table2[s1124]; const SWord8 s1141 = s1139 ^ s1140; const SWord8 s1142 = s1138 ^ s1141; const SWord8 s1143 = s1137 ^ s1142; const SWord8 s1144 = table2[s1117]; const SWord8 s1145 = table3[s1119]; const SWord8 s1146 = table4[s1122]; const SWord8 s1147 = table1[s1124]; const SWord8 s1148 = s1146 ^ s1147; const SWord8 s1149 = s1145 ^ s1148; const SWord8 s1150 = s1144 ^ s1149; const SWord16 s1151 = (((SWord16) s1143) << 8) | ((SWord16) s1150); const SWord32 s1152 = (((SWord32) s1136) << 16) | ((SWord32) s1151); const SWord16 s1153 = (SWord16) (s354 >> 16); const SWord8 s1154 = (SWord8) (s1153 >> 8); const SWord8 s1155 = table1[s1154]; const SWord8 s1156 = (SWord8) s1153; const SWord8 s1157 = table2[s1156]; const SWord16 s1158 = (SWord16) s354; const SWord8 s1159 = (SWord8) (s1158 >> 8); const SWord8 s1160 = table3[s1159]; const SWord8 s1161 = (SWord8) s1158; const SWord8 s1162 = table4[s1161]; const SWord8 s1163 = s1160 ^ s1162; const SWord8 s1164 = s1157 ^ s1163; const SWord8 s1165 = s1155 ^ s1164; const SWord8 s1166 = table4[s1154]; const SWord8 s1167 = table1[s1156]; const SWord8 s1168 = table2[s1159]; const SWord8 s1169 = table3[s1161]; const SWord8 s1170 = s1168 ^ s1169; const SWord8 s1171 = s1167 ^ s1170; const SWord8 s1172 = s1166 ^ s1171; const SWord16 s1173 = (((SWord16) s1165) << 8) | ((SWord16) s1172); const SWord8 s1174 = table3[s1154]; const SWord8 s1175 = table4[s1156]; const SWord8 s1176 = table1[s1159]; const SWord8 s1177 = table2[s1161]; const SWord8 s1178 = s1176 ^ s1177; const SWord8 s1179 = s1175 ^ s1178; const SWord8 s1180 = s1174 ^ s1179; const SWord8 s1181 = table2[s1154]; const SWord8 s1182 = table3[s1156]; const SWord8 s1183 = table4[s1159]; const SWord8 s1184 = table1[s1161]; const SWord8 s1185 = s1183 ^ s1184; const SWord8 s1186 = s1182 ^ s1185; const SWord8 s1187 = s1181 ^ s1186; const SWord16 s1188 = (((SWord16) s1180) << 8) | ((SWord16) s1187); const SWord32 s1189 = (((SWord32) s1173) << 16) | ((SWord32) s1188); const SWord16 s1190 = (SWord16) (s332 >> 16); const SWord8 s1191 = (SWord8) (s1190 >> 8); const SWord8 s1192 = table1[s1191]; const SWord8 s1193 = (SWord8) s1190; const SWord8 s1194 = table2[s1193]; const SWord16 s1195 = (SWord16) s332; const SWord8 s1196 = (SWord8) (s1195 >> 8); const SWord8 s1197 = table3[s1196]; const SWord8 s1198 = (SWord8) s1195; const SWord8 s1199 = table4[s1198]; const SWord8 s1200 = s1197 ^ s1199; const SWord8 s1201 = s1194 ^ s1200; const SWord8 s1202 = s1192 ^ s1201; const SWord8 s1203 = table4[s1191]; const SWord8 s1204 = table1[s1193]; const SWord8 s1205 = table2[s1196]; const SWord8 s1206 = table3[s1198]; const SWord8 s1207 = s1205 ^ s1206; const SWord8 s1208 = s1204 ^ s1207; const SWord8 s1209 = s1203 ^ s1208; const SWord16 s1210 = (((SWord16) s1202) << 8) | ((SWord16) s1209); const SWord8 s1211 = table3[s1191]; const SWord8 s1212 = table4[s1193]; const SWord8 s1213 = table1[s1196]; const SWord8 s1214 = table2[s1198]; const SWord8 s1215 = s1213 ^ s1214; const SWord8 s1216 = s1212 ^ s1215; const SWord8 s1217 = s1211 ^ s1216; const SWord8 s1218 = table2[s1191]; const SWord8 s1219 = table3[s1193]; const SWord8 s1220 = table4[s1196]; const SWord8 s1221 = table1[s1198]; const SWord8 s1222 = s1220 ^ s1221; const SWord8 s1223 = s1219 ^ s1222; const SWord8 s1224 = s1218 ^ s1223; const SWord16 s1225 = (((SWord16) s1217) << 8) | ((SWord16) s1224); const SWord32 s1226 = (((SWord32) s1210) << 16) | ((SWord32) s1225); const SWord16 s1227 = (SWord16) (s333 >> 16); const SWord8 s1228 = (SWord8) (s1227 >> 8); const SWord8 s1229 = table1[s1228]; const SWord8 s1230 = (SWord8) s1227; const SWord8 s1231 = table2[s1230]; const SWord16 s1232 = (SWord16) s333; const SWord8 s1233 = (SWord8) (s1232 >> 8); const SWord8 s1234 = table3[s1233]; const SWord8 s1235 = (SWord8) s1232; const SWord8 s1236 = table4[s1235]; const SWord8 s1237 = s1234 ^ s1236; const SWord8 s1238 = s1231 ^ s1237; const SWord8 s1239 = s1229 ^ s1238; const SWord8 s1240 = table4[s1228]; const SWord8 s1241 = table1[s1230]; const SWord8 s1242 = table2[s1233]; const SWord8 s1243 = table3[s1235]; const SWord8 s1244 = s1242 ^ s1243; const SWord8 s1245 = s1241 ^ s1244; const SWord8 s1246 = s1240 ^ s1245; const SWord16 s1247 = (((SWord16) s1239) << 8) | ((SWord16) s1246); const SWord8 s1248 = table3[s1228]; const SWord8 s1249 = table4[s1230]; const SWord8 s1250 = table1[s1233]; const SWord8 s1251 = table2[s1235]; const SWord8 s1252 = s1250 ^ s1251; const SWord8 s1253 = s1249 ^ s1252; const SWord8 s1254 = s1248 ^ s1253; const SWord8 s1255 = table2[s1228]; const SWord8 s1256 = table3[s1230]; const SWord8 s1257 = table4[s1233]; const SWord8 s1258 = table1[s1235]; const SWord8 s1259 = s1257 ^ s1258; const SWord8 s1260 = s1256 ^ s1259; const SWord8 s1261 = s1255 ^ s1260; const SWord16 s1262 = (((SWord16) s1254) << 8) | ((SWord16) s1261); const SWord32 s1263 = (((SWord32) s1247) << 16) | ((SWord32) s1262); const SWord16 s1264 = (SWord16) (s334 >> 16); const SWord8 s1265 = (SWord8) (s1264 >> 8); const SWord8 s1266 = table1[s1265]; const SWord8 s1267 = (SWord8) s1264; const SWord8 s1268 = table2[s1267]; const SWord16 s1269 = (SWord16) s334; const SWord8 s1270 = (SWord8) (s1269 >> 8); const SWord8 s1271 = table3[s1270]; const SWord8 s1272 = (SWord8) s1269; const SWord8 s1273 = table4[s1272]; const SWord8 s1274 = s1271 ^ s1273; const SWord8 s1275 = s1268 ^ s1274; const SWord8 s1276 = s1266 ^ s1275; const SWord8 s1277 = table4[s1265]; const SWord8 s1278 = table1[s1267]; const SWord8 s1279 = table2[s1270]; const SWord8 s1280 = table3[s1272]; const SWord8 s1281 = s1279 ^ s1280; const SWord8 s1282 = s1278 ^ s1281; const SWord8 s1283 = s1277 ^ s1282; const SWord16 s1284 = (((SWord16) s1276) << 8) | ((SWord16) s1283); const SWord8 s1285 = table3[s1265]; const SWord8 s1286 = table4[s1267]; const SWord8 s1287 = table1[s1270]; const SWord8 s1288 = table2[s1272]; const SWord8 s1289 = s1287 ^ s1288; const SWord8 s1290 = s1286 ^ s1289; const SWord8 s1291 = s1285 ^ s1290; const SWord8 s1292 = table2[s1265]; const SWord8 s1293 = table3[s1267]; const SWord8 s1294 = table4[s1270]; const SWord8 s1295 = table1[s1272]; const SWord8 s1296 = s1294 ^ s1295; const SWord8 s1297 = s1293 ^ s1296; const SWord8 s1298 = s1292 ^ s1297; const SWord16 s1299 = (((SWord16) s1291) << 8) | ((SWord16) s1298); const SWord32 s1300 = (((SWord32) s1284) << 16) | ((SWord32) s1299); const SWord16 s1301 = (SWord16) (s335 >> 16); const SWord8 s1302 = (SWord8) (s1301 >> 8); const SWord8 s1303 = table1[s1302]; const SWord8 s1304 = (SWord8) s1301; const SWord8 s1305 = table2[s1304]; const SWord16 s1306 = (SWord16) s335; const SWord8 s1307 = (SWord8) (s1306 >> 8); const SWord8 s1308 = table3[s1307]; const SWord8 s1309 = (SWord8) s1306; const SWord8 s1310 = table4[s1309]; const SWord8 s1311 = s1308 ^ s1310; const SWord8 s1312 = s1305 ^ s1311; const SWord8 s1313 = s1303 ^ s1312; const SWord8 s1314 = table4[s1302]; const SWord8 s1315 = table1[s1304]; const SWord8 s1316 = table2[s1307]; const SWord8 s1317 = table3[s1309]; const SWord8 s1318 = s1316 ^ s1317; const SWord8 s1319 = s1315 ^ s1318; const SWord8 s1320 = s1314 ^ s1319; const SWord16 s1321 = (((SWord16) s1313) << 8) | ((SWord16) s1320); const SWord8 s1322 = table3[s1302]; const SWord8 s1323 = table4[s1304]; const SWord8 s1324 = table1[s1307]; const SWord8 s1325 = table2[s1309]; const SWord8 s1326 = s1324 ^ s1325; const SWord8 s1327 = s1323 ^ s1326; const SWord8 s1328 = s1322 ^ s1327; const SWord8 s1329 = table2[s1302]; const SWord8 s1330 = table3[s1304]; const SWord8 s1331 = table4[s1307]; const SWord8 s1332 = table1[s1309]; const SWord8 s1333 = s1331 ^ s1332; const SWord8 s1334 = s1330 ^ s1333; const SWord8 s1335 = s1329 ^ s1334; const SWord16 s1336 = (((SWord16) s1328) << 8) | ((SWord16) s1335); const SWord32 s1337 = (((SWord32) s1321) << 16) | ((SWord32) s1336); const SWord16 s1338 = (SWord16) (s313 >> 16); const SWord8 s1339 = (SWord8) (s1338 >> 8); const SWord8 s1340 = table1[s1339]; const SWord8 s1341 = (SWord8) s1338; const SWord8 s1342 = table2[s1341]; const SWord16 s1343 = (SWord16) s313; const SWord8 s1344 = (SWord8) (s1343 >> 8); const SWord8 s1345 = table3[s1344]; const SWord8 s1346 = (SWord8) s1343; const SWord8 s1347 = table4[s1346]; const SWord8 s1348 = s1345 ^ s1347; const SWord8 s1349 = s1342 ^ s1348; const SWord8 s1350 = s1340 ^ s1349; const SWord8 s1351 = table4[s1339]; const SWord8 s1352 = table1[s1341]; const SWord8 s1353 = table2[s1344]; const SWord8 s1354 = table3[s1346]; const SWord8 s1355 = s1353 ^ s1354; const SWord8 s1356 = s1352 ^ s1355; const SWord8 s1357 = s1351 ^ s1356; const SWord16 s1358 = (((SWord16) s1350) << 8) | ((SWord16) s1357); const SWord8 s1359 = table3[s1339]; const SWord8 s1360 = table4[s1341]; const SWord8 s1361 = table1[s1344]; const SWord8 s1362 = table2[s1346]; const SWord8 s1363 = s1361 ^ s1362; const SWord8 s1364 = s1360 ^ s1363; const SWord8 s1365 = s1359 ^ s1364; const SWord8 s1366 = table2[s1339]; const SWord8 s1367 = table3[s1341]; const SWord8 s1368 = table4[s1344]; const SWord8 s1369 = table1[s1346]; const SWord8 s1370 = s1368 ^ s1369; const SWord8 s1371 = s1367 ^ s1370; const SWord8 s1372 = s1366 ^ s1371; const SWord16 s1373 = (((SWord16) s1365) << 8) | ((SWord16) s1372); const SWord32 s1374 = (((SWord32) s1358) << 16) | ((SWord32) s1373); const SWord16 s1375 = (SWord16) (s314 >> 16); const SWord8 s1376 = (SWord8) (s1375 >> 8); const SWord8 s1377 = table1[s1376]; const SWord8 s1378 = (SWord8) s1375; const SWord8 s1379 = table2[s1378]; const SWord16 s1380 = (SWord16) s314; const SWord8 s1381 = (SWord8) (s1380 >> 8); const SWord8 s1382 = table3[s1381]; const SWord8 s1383 = (SWord8) s1380; const SWord8 s1384 = table4[s1383]; const SWord8 s1385 = s1382 ^ s1384; const SWord8 s1386 = s1379 ^ s1385; const SWord8 s1387 = s1377 ^ s1386; const SWord8 s1388 = table4[s1376]; const SWord8 s1389 = table1[s1378]; const SWord8 s1390 = table2[s1381]; const SWord8 s1391 = table3[s1383]; const SWord8 s1392 = s1390 ^ s1391; const SWord8 s1393 = s1389 ^ s1392; const SWord8 s1394 = s1388 ^ s1393; const SWord16 s1395 = (((SWord16) s1387) << 8) | ((SWord16) s1394); const SWord8 s1396 = table3[s1376]; const SWord8 s1397 = table4[s1378]; const SWord8 s1398 = table1[s1381]; const SWord8 s1399 = table2[s1383]; const SWord8 s1400 = s1398 ^ s1399; const SWord8 s1401 = s1397 ^ s1400; const SWord8 s1402 = s1396 ^ s1401; const SWord8 s1403 = table2[s1376]; const SWord8 s1404 = table3[s1378]; const SWord8 s1405 = table4[s1381]; const SWord8 s1406 = table1[s1383]; const SWord8 s1407 = s1405 ^ s1406; const SWord8 s1408 = s1404 ^ s1407; const SWord8 s1409 = s1403 ^ s1408; const SWord16 s1410 = (((SWord16) s1402) << 8) | ((SWord16) s1409); const SWord32 s1411 = (((SWord32) s1395) << 16) | ((SWord32) s1410); const SWord16 s1412 = (SWord16) (s315 >> 16); const SWord8 s1413 = (SWord8) (s1412 >> 8); const SWord8 s1414 = table1[s1413]; const SWord8 s1415 = (SWord8) s1412; const SWord8 s1416 = table2[s1415]; const SWord16 s1417 = (SWord16) s315; const SWord8 s1418 = (SWord8) (s1417 >> 8); const SWord8 s1419 = table3[s1418]; const SWord8 s1420 = (SWord8) s1417; const SWord8 s1421 = table4[s1420]; const SWord8 s1422 = s1419 ^ s1421; const SWord8 s1423 = s1416 ^ s1422; const SWord8 s1424 = s1414 ^ s1423; const SWord8 s1425 = table4[s1413]; const SWord8 s1426 = table1[s1415]; const SWord8 s1427 = table2[s1418]; const SWord8 s1428 = table3[s1420]; const SWord8 s1429 = s1427 ^ s1428; const SWord8 s1430 = s1426 ^ s1429; const SWord8 s1431 = s1425 ^ s1430; const SWord16 s1432 = (((SWord16) s1424) << 8) | ((SWord16) s1431); const SWord8 s1433 = table3[s1413]; const SWord8 s1434 = table4[s1415]; const SWord8 s1435 = table1[s1418]; const SWord8 s1436 = table2[s1420]; const SWord8 s1437 = s1435 ^ s1436; const SWord8 s1438 = s1434 ^ s1437; const SWord8 s1439 = s1433 ^ s1438; const SWord8 s1440 = table2[s1413]; const SWord8 s1441 = table3[s1415]; const SWord8 s1442 = table4[s1418]; const SWord8 s1443 = table1[s1420]; const SWord8 s1444 = s1442 ^ s1443; const SWord8 s1445 = s1441 ^ s1444; const SWord8 s1446 = s1440 ^ s1445; const SWord16 s1447 = (((SWord16) s1439) << 8) | ((SWord16) s1446); const SWord32 s1448 = (((SWord32) s1432) << 16) | ((SWord32) s1447); const SWord16 s1449 = (SWord16) (s316 >> 16); const SWord8 s1450 = (SWord8) (s1449 >> 8); const SWord8 s1451 = table1[s1450]; const SWord8 s1452 = (SWord8) s1449; const SWord8 s1453 = table2[s1452]; const SWord16 s1454 = (SWord16) s316; const SWord8 s1455 = (SWord8) (s1454 >> 8); const SWord8 s1456 = table3[s1455]; const SWord8 s1457 = (SWord8) s1454; const SWord8 s1458 = table4[s1457]; const SWord8 s1459 = s1456 ^ s1458; const SWord8 s1460 = s1453 ^ s1459; const SWord8 s1461 = s1451 ^ s1460; const SWord8 s1462 = table4[s1450]; const SWord8 s1463 = table1[s1452]; const SWord8 s1464 = table2[s1455]; const SWord8 s1465 = table3[s1457]; const SWord8 s1466 = s1464 ^ s1465; const SWord8 s1467 = s1463 ^ s1466; const SWord8 s1468 = s1462 ^ s1467; const SWord16 s1469 = (((SWord16) s1461) << 8) | ((SWord16) s1468); const SWord8 s1470 = table3[s1450]; const SWord8 s1471 = table4[s1452]; const SWord8 s1472 = table1[s1455]; const SWord8 s1473 = table2[s1457]; const SWord8 s1474 = s1472 ^ s1473; const SWord8 s1475 = s1471 ^ s1474; const SWord8 s1476 = s1470 ^ s1475; const SWord8 s1477 = table2[s1450]; const SWord8 s1478 = table3[s1452]; const SWord8 s1479 = table4[s1455]; const SWord8 s1480 = table1[s1457]; const SWord8 s1481 = s1479 ^ s1480; const SWord8 s1482 = s1478 ^ s1481; const SWord8 s1483 = s1477 ^ s1482; const SWord16 s1484 = (((SWord16) s1476) << 8) | ((SWord16) s1483); const SWord32 s1485 = (((SWord32) s1469) << 16) | ((SWord32) s1484); const SWord16 s1486 = (SWord16) (s294 >> 16); const SWord8 s1487 = (SWord8) (s1486 >> 8); const SWord8 s1488 = table1[s1487]; const SWord8 s1489 = (SWord8) s1486; const SWord8 s1490 = table2[s1489]; const SWord16 s1491 = (SWord16) s294; const SWord8 s1492 = (SWord8) (s1491 >> 8); const SWord8 s1493 = table3[s1492]; const SWord8 s1494 = (SWord8) s1491; const SWord8 s1495 = table4[s1494]; const SWord8 s1496 = s1493 ^ s1495; const SWord8 s1497 = s1490 ^ s1496; const SWord8 s1498 = s1488 ^ s1497; const SWord8 s1499 = table4[s1487]; const SWord8 s1500 = table1[s1489]; const SWord8 s1501 = table2[s1492]; const SWord8 s1502 = table3[s1494]; const SWord8 s1503 = s1501 ^ s1502; const SWord8 s1504 = s1500 ^ s1503; const SWord8 s1505 = s1499 ^ s1504; const SWord16 s1506 = (((SWord16) s1498) << 8) | ((SWord16) s1505); const SWord8 s1507 = table3[s1487]; const SWord8 s1508 = table4[s1489]; const SWord8 s1509 = table1[s1492]; const SWord8 s1510 = table2[s1494]; const SWord8 s1511 = s1509 ^ s1510; const SWord8 s1512 = s1508 ^ s1511; const SWord8 s1513 = s1507 ^ s1512; const SWord8 s1514 = table2[s1487]; const SWord8 s1515 = table3[s1489]; const SWord8 s1516 = table4[s1492]; const SWord8 s1517 = table1[s1494]; const SWord8 s1518 = s1516 ^ s1517; const SWord8 s1519 = s1515 ^ s1518; const SWord8 s1520 = s1514 ^ s1519; const SWord16 s1521 = (((SWord16) s1513) << 8) | ((SWord16) s1520); const SWord32 s1522 = (((SWord32) s1506) << 16) | ((SWord32) s1521); const SWord16 s1523 = (SWord16) (s295 >> 16); const SWord8 s1524 = (SWord8) (s1523 >> 8); const SWord8 s1525 = table1[s1524]; const SWord8 s1526 = (SWord8) s1523; const SWord8 s1527 = table2[s1526]; const SWord16 s1528 = (SWord16) s295; const SWord8 s1529 = (SWord8) (s1528 >> 8); const SWord8 s1530 = table3[s1529]; const SWord8 s1531 = (SWord8) s1528; const SWord8 s1532 = table4[s1531]; const SWord8 s1533 = s1530 ^ s1532; const SWord8 s1534 = s1527 ^ s1533; const SWord8 s1535 = s1525 ^ s1534; const SWord8 s1536 = table4[s1524]; const SWord8 s1537 = table1[s1526]; const SWord8 s1538 = table2[s1529]; const SWord8 s1539 = table3[s1531]; const SWord8 s1540 = s1538 ^ s1539; const SWord8 s1541 = s1537 ^ s1540; const SWord8 s1542 = s1536 ^ s1541; const SWord16 s1543 = (((SWord16) s1535) << 8) | ((SWord16) s1542); const SWord8 s1544 = table3[s1524]; const SWord8 s1545 = table4[s1526]; const SWord8 s1546 = table1[s1529]; const SWord8 s1547 = table2[s1531]; const SWord8 s1548 = s1546 ^ s1547; const SWord8 s1549 = s1545 ^ s1548; const SWord8 s1550 = s1544 ^ s1549; const SWord8 s1551 = table2[s1524]; const SWord8 s1552 = table3[s1526]; const SWord8 s1553 = table4[s1529]; const SWord8 s1554 = table1[s1531]; const SWord8 s1555 = s1553 ^ s1554; const SWord8 s1556 = s1552 ^ s1555; const SWord8 s1557 = s1551 ^ s1556; const SWord16 s1558 = (((SWord16) s1550) << 8) | ((SWord16) s1557); const SWord32 s1559 = (((SWord32) s1543) << 16) | ((SWord32) s1558); const SWord16 s1560 = (SWord16) (s296 >> 16); const SWord8 s1561 = (SWord8) (s1560 >> 8); const SWord8 s1562 = table1[s1561]; const SWord8 s1563 = (SWord8) s1560; const SWord8 s1564 = table2[s1563]; const SWord16 s1565 = (SWord16) s296; const SWord8 s1566 = (SWord8) (s1565 >> 8); const SWord8 s1567 = table3[s1566]; const SWord8 s1568 = (SWord8) s1565; const SWord8 s1569 = table4[s1568]; const SWord8 s1570 = s1567 ^ s1569; const SWord8 s1571 = s1564 ^ s1570; const SWord8 s1572 = s1562 ^ s1571; const SWord8 s1573 = table4[s1561]; const SWord8 s1574 = table1[s1563]; const SWord8 s1575 = table2[s1566]; const SWord8 s1576 = table3[s1568]; const SWord8 s1577 = s1575 ^ s1576; const SWord8 s1578 = s1574 ^ s1577; const SWord8 s1579 = s1573 ^ s1578; const SWord16 s1580 = (((SWord16) s1572) << 8) | ((SWord16) s1579); const SWord8 s1581 = table3[s1561]; const SWord8 s1582 = table4[s1563]; const SWord8 s1583 = table1[s1566]; const SWord8 s1584 = table2[s1568]; const SWord8 s1585 = s1583 ^ s1584; const SWord8 s1586 = s1582 ^ s1585; const SWord8 s1587 = s1581 ^ s1586; const SWord8 s1588 = table2[s1561]; const SWord8 s1589 = table3[s1563]; const SWord8 s1590 = table4[s1566]; const SWord8 s1591 = table1[s1568]; const SWord8 s1592 = s1590 ^ s1591; const SWord8 s1593 = s1589 ^ s1592; const SWord8 s1594 = s1588 ^ s1593; const SWord16 s1595 = (((SWord16) s1587) << 8) | ((SWord16) s1594); const SWord32 s1596 = (((SWord32) s1580) << 16) | ((SWord32) s1595); const SWord16 s1597 = (SWord16) (s297 >> 16); const SWord8 s1598 = (SWord8) (s1597 >> 8); const SWord8 s1599 = table1[s1598]; const SWord8 s1600 = (SWord8) s1597; const SWord8 s1601 = table2[s1600]; const SWord16 s1602 = (SWord16) s297; const SWord8 s1603 = (SWord8) (s1602 >> 8); const SWord8 s1604 = table3[s1603]; const SWord8 s1605 = (SWord8) s1602; const SWord8 s1606 = table4[s1605]; const SWord8 s1607 = s1604 ^ s1606; const SWord8 s1608 = s1601 ^ s1607; const SWord8 s1609 = s1599 ^ s1608; const SWord8 s1610 = table4[s1598]; const SWord8 s1611 = table1[s1600]; const SWord8 s1612 = table2[s1603]; const SWord8 s1613 = table3[s1605]; const SWord8 s1614 = s1612 ^ s1613; const SWord8 s1615 = s1611 ^ s1614; const SWord8 s1616 = s1610 ^ s1615; const SWord16 s1617 = (((SWord16) s1609) << 8) | ((SWord16) s1616); const SWord8 s1618 = table3[s1598]; const SWord8 s1619 = table4[s1600]; const SWord8 s1620 = table1[s1603]; const SWord8 s1621 = table2[s1605]; const SWord8 s1622 = s1620 ^ s1621; const SWord8 s1623 = s1619 ^ s1622; const SWord8 s1624 = s1618 ^ s1623; const SWord8 s1625 = table2[s1598]; const SWord8 s1626 = table3[s1600]; const SWord8 s1627 = table4[s1603]; const SWord8 s1628 = table1[s1605]; const SWord8 s1629 = s1627 ^ s1628; const SWord8 s1630 = s1626 ^ s1629; const SWord8 s1631 = s1625 ^ s1630; const SWord16 s1632 = (((SWord16) s1624) << 8) | ((SWord16) s1631); const SWord32 s1633 = (((SWord32) s1617) << 16) | ((SWord32) s1632); const SWord16 s1634 = (SWord16) (s275 >> 16); const SWord8 s1635 = (SWord8) (s1634 >> 8); const SWord8 s1636 = table1[s1635]; const SWord8 s1637 = (SWord8) s1634; const SWord8 s1638 = table2[s1637]; const SWord16 s1639 = (SWord16) s275; const SWord8 s1640 = (SWord8) (s1639 >> 8); const SWord8 s1641 = table3[s1640]; const SWord8 s1642 = (SWord8) s1639; const SWord8 s1643 = table4[s1642]; const SWord8 s1644 = s1641 ^ s1643; const SWord8 s1645 = s1638 ^ s1644; const SWord8 s1646 = s1636 ^ s1645; const SWord8 s1647 = table4[s1635]; const SWord8 s1648 = table1[s1637]; const SWord8 s1649 = table2[s1640]; const SWord8 s1650 = table3[s1642]; const SWord8 s1651 = s1649 ^ s1650; const SWord8 s1652 = s1648 ^ s1651; const SWord8 s1653 = s1647 ^ s1652; const SWord16 s1654 = (((SWord16) s1646) << 8) | ((SWord16) s1653); const SWord8 s1655 = table3[s1635]; const SWord8 s1656 = table4[s1637]; const SWord8 s1657 = table1[s1640]; const SWord8 s1658 = table2[s1642]; const SWord8 s1659 = s1657 ^ s1658; const SWord8 s1660 = s1656 ^ s1659; const SWord8 s1661 = s1655 ^ s1660; const SWord8 s1662 = table2[s1635]; const SWord8 s1663 = table3[s1637]; const SWord8 s1664 = table4[s1640]; const SWord8 s1665 = table1[s1642]; const SWord8 s1666 = s1664 ^ s1665; const SWord8 s1667 = s1663 ^ s1666; const SWord8 s1668 = s1662 ^ s1667; const SWord16 s1669 = (((SWord16) s1661) << 8) | ((SWord16) s1668); const SWord32 s1670 = (((SWord32) s1654) << 16) | ((SWord32) s1669); const SWord16 s1671 = (SWord16) (s276 >> 16); const SWord8 s1672 = (SWord8) (s1671 >> 8); const SWord8 s1673 = table1[s1672]; const SWord8 s1674 = (SWord8) s1671; const SWord8 s1675 = table2[s1674]; const SWord16 s1676 = (SWord16) s276; const SWord8 s1677 = (SWord8) (s1676 >> 8); const SWord8 s1678 = table3[s1677]; const SWord8 s1679 = (SWord8) s1676; const SWord8 s1680 = table4[s1679]; const SWord8 s1681 = s1678 ^ s1680; const SWord8 s1682 = s1675 ^ s1681; const SWord8 s1683 = s1673 ^ s1682; const SWord8 s1684 = table4[s1672]; const SWord8 s1685 = table1[s1674]; const SWord8 s1686 = table2[s1677]; const SWord8 s1687 = table3[s1679]; const SWord8 s1688 = s1686 ^ s1687; const SWord8 s1689 = s1685 ^ s1688; const SWord8 s1690 = s1684 ^ s1689; const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690); const SWord8 s1692 = table3[s1672]; const SWord8 s1693 = table4[s1674]; const SWord8 s1694 = table1[s1677]; const SWord8 s1695 = table2[s1679]; const SWord8 s1696 = s1694 ^ s1695; const SWord8 s1697 = s1693 ^ s1696; const SWord8 s1698 = s1692 ^ s1697; const SWord8 s1699 = table2[s1672]; const SWord8 s1700 = table3[s1674]; const SWord8 s1701 = table4[s1677]; const SWord8 s1702 = table1[s1679]; const SWord8 s1703 = s1701 ^ s1702; const SWord8 s1704 = s1700 ^ s1703; const SWord8 s1705 = s1699 ^ s1704; const SWord16 s1706 = (((SWord16) s1698) << 8) | ((SWord16) s1705); const SWord32 s1707 = (((SWord32) s1691) << 16) | ((SWord32) s1706); const SWord16 s1708 = (SWord16) (s277 >> 16); const SWord8 s1709 = (SWord8) (s1708 >> 8); const SWord8 s1710 = table1[s1709]; const SWord8 s1711 = (SWord8) s1708; const SWord8 s1712 = table2[s1711]; const SWord16 s1713 = (SWord16) s277; const SWord8 s1714 = (SWord8) (s1713 >> 8); const SWord8 s1715 = table3[s1714]; const SWord8 s1716 = (SWord8) s1713; const SWord8 s1717 = table4[s1716]; const SWord8 s1718 = s1715 ^ s1717; const SWord8 s1719 = s1712 ^ s1718; const SWord8 s1720 = s1710 ^ s1719; const SWord8 s1721 = table4[s1709]; const SWord8 s1722 = table1[s1711]; const SWord8 s1723 = table2[s1714]; const SWord8 s1724 = table3[s1716]; const SWord8 s1725 = s1723 ^ s1724; const SWord8 s1726 = s1722 ^ s1725; const SWord8 s1727 = s1721 ^ s1726; const SWord16 s1728 = (((SWord16) s1720) << 8) | ((SWord16) s1727); const SWord8 s1729 = table3[s1709]; const SWord8 s1730 = table4[s1711]; const SWord8 s1731 = table1[s1714]; const SWord8 s1732 = table2[s1716]; const SWord8 s1733 = s1731 ^ s1732; const SWord8 s1734 = s1730 ^ s1733; const SWord8 s1735 = s1729 ^ s1734; const SWord8 s1736 = table2[s1709]; const SWord8 s1737 = table3[s1711]; const SWord8 s1738 = table4[s1714]; const SWord8 s1739 = table1[s1716]; const SWord8 s1740 = s1738 ^ s1739; const SWord8 s1741 = s1737 ^ s1740; const SWord8 s1742 = s1736 ^ s1741; const SWord16 s1743 = (((SWord16) s1735) << 8) | ((SWord16) s1742); const SWord32 s1744 = (((SWord32) s1728) << 16) | ((SWord32) s1743); const SWord16 s1745 = (SWord16) (s278 >> 16); const SWord8 s1746 = (SWord8) (s1745 >> 8); const SWord8 s1747 = table1[s1746]; const SWord8 s1748 = (SWord8) s1745; const SWord8 s1749 = table2[s1748]; const SWord16 s1750 = (SWord16) s278; const SWord8 s1751 = (SWord8) (s1750 >> 8); const SWord8 s1752 = table3[s1751]; const SWord8 s1753 = (SWord8) s1750; const SWord8 s1754 = table4[s1753]; const SWord8 s1755 = s1752 ^ s1754; const SWord8 s1756 = s1749 ^ s1755; const SWord8 s1757 = s1747 ^ s1756; const SWord8 s1758 = table4[s1746]; const SWord8 s1759 = table1[s1748]; const SWord8 s1760 = table2[s1751]; const SWord8 s1761 = table3[s1753]; const SWord8 s1762 = s1760 ^ s1761; const SWord8 s1763 = s1759 ^ s1762; const SWord8 s1764 = s1758 ^ s1763; const SWord16 s1765 = (((SWord16) s1757) << 8) | ((SWord16) s1764); const SWord8 s1766 = table3[s1746]; const SWord8 s1767 = table4[s1748]; const SWord8 s1768 = table1[s1751]; const SWord8 s1769 = table2[s1753]; const SWord8 s1770 = s1768 ^ s1769; const SWord8 s1771 = s1767 ^ s1770; const SWord8 s1772 = s1766 ^ s1771; const SWord8 s1773 = table2[s1746]; const SWord8 s1774 = table3[s1748]; const SWord8 s1775 = table4[s1751]; const SWord8 s1776 = table1[s1753]; const SWord8 s1777 = s1775 ^ s1776; const SWord8 s1778 = s1774 ^ s1777; const SWord8 s1779 = s1773 ^ s1778; const SWord16 s1780 = (((SWord16) s1772) << 8) | ((SWord16) s1779); const SWord32 s1781 = (((SWord32) s1765) << 16) | ((SWord32) s1780); encKS[0] = s0; encKS[1] = s1; encKS[2] = s2; encKS[3] = s3; encKS[4] = s275; encKS[5] = s276; encKS[6] = s277; encKS[7] = s278; encKS[8] = s294; encKS[9] = s295; encKS[10] = s296; encKS[11] = s297; encKS[12] = s313; encKS[13] = s314; encKS[14] = s315; encKS[15] = s316; encKS[16] = s332; encKS[17] = s333; encKS[18] = s334; encKS[19] = s335; encKS[20] = s351; encKS[21] = s352; encKS[22] = s353; encKS[23] = s354; encKS[24] = s370; encKS[25] = s371; encKS[26] = s372; encKS[27] = s373; encKS[28] = s389; encKS[29] = s390; encKS[30] = s391; encKS[31] = s392; encKS[32] = s408; encKS[33] = s409; encKS[34] = s410; encKS[35] = s411; encKS[36] = s427; encKS[37] = s428; encKS[38] = s429; encKS[39] = s430; encKS[40] = s446; encKS[41] = s447; encKS[42] = s448; encKS[43] = s449; decKS[0] = s446; decKS[1] = s447; decKS[2] = s448; decKS[3] = s449; decKS[4] = s486; decKS[5] = s523; decKS[6] = s560; decKS[7] = s597; decKS[8] = s634; decKS[9] = s671; decKS[10] = s708; decKS[11] = s745; decKS[12] = s782; decKS[13] = s819; decKS[14] = s856; decKS[15] = s893; decKS[16] = s930; decKS[17] = s967; decKS[18] = s1004; decKS[19] = s1041; decKS[20] = s1078; decKS[21] = s1115; decKS[22] = s1152; decKS[23] = s1189; decKS[24] = s1226; decKS[25] = s1263; decKS[26] = s1300; decKS[27] = s1337; decKS[28] = s1374; decKS[29] = s1411; decKS[30] = s1448; decKS[31] = s1485; decKS[32] = s1522; decKS[33] = s1559; decKS[34] = s1596; decKS[35] = s1633; decKS[36] = s1670; decKS[37] = s1707; decKS[38] = s1744; decKS[39] = s1781; decKS[40] = s0; decKS[41] = s1; decKS[42] = s2; decKS[43] = s3; } == END: "aes128KeySchedule.c" ================== == BEGIN: "aes128BlockEncrypt.c" ================ /* File: "aes128BlockEncrypt.c". Automatically generated by SBV. Do not edit! */ #include "aes128Lib.h" void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey, SWord32 *ct) { const SWord32 s0 = pt[0]; const SWord32 s1 = pt[1]; const SWord32 s2 = pt[2]; const SWord32 s3 = pt[3]; const SWord32 s4 = xkey[0]; const SWord32 s5 = xkey[1]; const SWord32 s6 = xkey[2]; const SWord32 s7 = xkey[3]; const SWord32 s8 = xkey[4]; const SWord32 s9 = xkey[5]; const SWord32 s10 = xkey[6]; const SWord32 s11 = xkey[7]; const SWord32 s12 = xkey[8]; const SWord32 s13 = xkey[9]; const SWord32 s14 = xkey[10]; const SWord32 s15 = xkey[11]; const SWord32 s16 = xkey[12]; const SWord32 s17 = xkey[13]; const SWord32 s18 = xkey[14]; const SWord32 s19 = xkey[15]; const SWord32 s20 = xkey[16]; const SWord32 s21 = xkey[17]; const SWord32 s22 = xkey[18]; const SWord32 s23 = xkey[19]; const SWord32 s24 = xkey[20]; const SWord32 s25 = xkey[21]; const SWord32 s26 = xkey[22]; const SWord32 s27 = xkey[23]; const SWord32 s28 = xkey[24]; const SWord32 s29 = xkey[25]; const SWord32 s30 = xkey[26]; const SWord32 s31 = xkey[27]; const SWord32 s32 = xkey[28]; const SWord32 s33 = xkey[29]; const SWord32 s34 = xkey[30]; const SWord32 s35 = xkey[31]; const SWord32 s36 = xkey[32]; const SWord32 s37 = xkey[33]; const SWord32 s38 = xkey[34]; const SWord32 s39 = xkey[35]; const SWord32 s40 = xkey[36]; const SWord32 s41 = xkey[37]; const SWord32 s42 = xkey[38]; const SWord32 s43 = xkey[39]; const SWord32 s44 = xkey[40]; const SWord32 s45 = xkey[41]; const SWord32 s46 = xkey[42]; const SWord32 s47 = xkey[43]; static const SWord8 table0[] = { 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22 }; static const SWord32 table1[] = { 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, 0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL, 0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL, 0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL, 0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL, 0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL, 0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL, 0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL, 0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL, 0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL, 0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL, 0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL, 0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL, 0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL, 0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL, 0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL, 0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL, 0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL, 0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL, 0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL, 0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL, 0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL, 0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL, 0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL, 0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL, 0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL, 0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL, 0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL, 0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL, 0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL, 0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL, 0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL, 0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL, 0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL, 0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL, 0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL, 0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL, 0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL, 0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL, 0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL, 0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL, 0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL, 0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL, 0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL, 0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL, 0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL, 0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL, 0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL, 0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL, 0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL, 0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL, 0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL, 0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL, 0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL, 0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL, 0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL, 0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL, 0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL, 0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL, 0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL, 0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL }; static const SWord32 table2[] = { 0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL, 0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL, 0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL, 0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL, 0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL, 0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL, 0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL, 0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL, 0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL, 0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL, 0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL, 0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL, 0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL, 0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL, 0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL, 0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL, 0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL, 0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL, 0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL, 0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL, 0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL, 0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL, 0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL, 0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL, 0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL, 0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL, 0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL, 0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL, 0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL, 0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL, 0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL, 0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL, 0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL, 0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL, 0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL, 0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL, 0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL, 0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL, 0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL, 0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL, 0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL, 0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL, 0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL, 0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL, 0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL, 0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL, 0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL, 0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL, 0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL, 0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL, 0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL, 0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL, 0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL, 0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL, 0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL, 0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL, 0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL, 0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL, 0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL, 0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL, 0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL, 0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL, 0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL, 0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL }; static const SWord32 table3[] = { 0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL, 0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL, 0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL, 0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL, 0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL, 0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL, 0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL, 0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL, 0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL, 0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL, 0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL, 0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL, 0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL, 0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL, 0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL, 0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL, 0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL, 0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL, 0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL, 0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL, 0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL, 0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL, 0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL, 0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL, 0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL, 0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL, 0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL, 0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL, 0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL, 0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL, 0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL, 0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL, 0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL, 0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL, 0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL, 0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL, 0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL, 0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL, 0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL, 0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL, 0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL, 0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL, 0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL, 0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL, 0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL, 0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL, 0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL, 0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL, 0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL, 0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL, 0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL, 0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL, 0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL, 0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL, 0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL, 0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL, 0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL, 0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL, 0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL, 0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL, 0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL, 0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL, 0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL, 0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL }; static const SWord32 table4[] = { 0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL, 0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL, 0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL, 0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL, 0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL, 0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL, 0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL, 0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL, 0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL, 0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL, 0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL, 0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL, 0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL, 0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL, 0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL, 0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL, 0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL, 0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL, 0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL, 0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL, 0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL, 0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL, 0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL, 0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL, 0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL, 0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL, 0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL, 0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL, 0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL, 0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL, 0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL, 0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL, 0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL, 0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL, 0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL, 0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL, 0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL, 0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL, 0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL, 0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL, 0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL, 0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL, 0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL, 0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL, 0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL, 0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL, 0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL, 0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL, 0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL, 0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL, 0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL, 0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL, 0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL, 0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL, 0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL, 0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL, 0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL, 0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL, 0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL, 0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL, 0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL, 0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL, 0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL, 0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL }; const SWord32 s560 = s0 ^ s4; const SWord16 s561 = (SWord16) (s560 >> 16); const SWord8 s562 = (SWord8) (s561 >> 8); const SWord32 s563 = table1[s562]; const SWord32 s819 = s1 ^ s5; const SWord16 s820 = (SWord16) (s819 >> 16); const SWord8 s821 = (SWord8) s820; const SWord32 s822 = table2[s821]; const SWord32 s823 = s563 ^ s822; const SWord32 s1079 = s2 ^ s6; const SWord16 s1080 = (SWord16) s1079; const SWord8 s1081 = (SWord8) (s1080 >> 8); const SWord32 s1082 = table3[s1081]; const SWord32 s1083 = s823 ^ s1082; const SWord32 s1339 = s3 ^ s7; const SWord16 s1340 = (SWord16) s1339; const SWord8 s1341 = (SWord8) s1340; const SWord32 s1342 = table4[s1341]; const SWord32 s1343 = s1083 ^ s1342; const SWord32 s1344 = s8 ^ s1343; const SWord16 s1345 = (SWord16) (s1344 >> 16); const SWord8 s1346 = (SWord8) (s1345 >> 8); const SWord32 s1347 = table1[s1346]; const SWord8 s1348 = (SWord8) (s820 >> 8); const SWord32 s1349 = table1[s1348]; const SWord16 s1350 = (SWord16) (s1079 >> 16); const SWord8 s1351 = (SWord8) s1350; const SWord32 s1352 = table2[s1351]; const SWord32 s1353 = s1349 ^ s1352; const SWord8 s1354 = (SWord8) (s1340 >> 8); const SWord32 s1355 = table3[s1354]; const SWord32 s1356 = s1353 ^ s1355; const SWord16 s1357 = (SWord16) s560; const SWord8 s1358 = (SWord8) s1357; const SWord32 s1359 = table4[s1358]; const SWord32 s1360 = s1356 ^ s1359; const SWord32 s1361 = s9 ^ s1360; const SWord16 s1362 = (SWord16) (s1361 >> 16); const SWord8 s1363 = (SWord8) s1362; const SWord32 s1364 = table2[s1363]; const SWord32 s1365 = s1347 ^ s1364; const SWord8 s1366 = (SWord8) (s1350 >> 8); const SWord32 s1367 = table1[s1366]; const SWord16 s1368 = (SWord16) (s1339 >> 16); const SWord8 s1369 = (SWord8) s1368; const SWord32 s1370 = table2[s1369]; const SWord32 s1371 = s1367 ^ s1370; const SWord8 s1372 = (SWord8) (s1357 >> 8); const SWord32 s1373 = table3[s1372]; const SWord32 s1374 = s1371 ^ s1373; const SWord16 s1375 = (SWord16) s819; const SWord8 s1376 = (SWord8) s1375; const SWord32 s1377 = table4[s1376]; const SWord32 s1378 = s1374 ^ s1377; const SWord32 s1379 = s10 ^ s1378; const SWord16 s1380 = (SWord16) s1379; const SWord8 s1381 = (SWord8) (s1380 >> 8); const SWord32 s1382 = table3[s1381]; const SWord32 s1383 = s1365 ^ s1382; const SWord8 s1384 = (SWord8) (s1368 >> 8); const SWord32 s1385 = table1[s1384]; const SWord8 s1386 = (SWord8) s561; const SWord32 s1387 = table2[s1386]; const SWord32 s1388 = s1385 ^ s1387; const SWord8 s1389 = (SWord8) (s1375 >> 8); const SWord32 s1390 = table3[s1389]; const SWord32 s1391 = s1388 ^ s1390; const SWord8 s1392 = (SWord8) s1080; const SWord32 s1393 = table4[s1392]; const SWord32 s1394 = s1391 ^ s1393; const SWord32 s1395 = s11 ^ s1394; const SWord16 s1396 = (SWord16) s1395; const SWord8 s1397 = (SWord8) s1396; const SWord32 s1398 = table4[s1397]; const SWord32 s1399 = s1383 ^ s1398; const SWord32 s1400 = s12 ^ s1399; const SWord16 s1401 = (SWord16) (s1400 >> 16); const SWord8 s1402 = (SWord8) (s1401 >> 8); const SWord32 s1403 = table1[s1402]; const SWord8 s1404 = (SWord8) (s1362 >> 8); const SWord32 s1405 = table1[s1404]; const SWord16 s1406 = (SWord16) (s1379 >> 16); const SWord8 s1407 = (SWord8) s1406; const SWord32 s1408 = table2[s1407]; const SWord32 s1409 = s1405 ^ s1408; const SWord8 s1410 = (SWord8) (s1396 >> 8); const SWord32 s1411 = table3[s1410]; const SWord32 s1412 = s1409 ^ s1411; const SWord16 s1413 = (SWord16) s1344; const SWord8 s1414 = (SWord8) s1413; const SWord32 s1415 = table4[s1414]; const SWord32 s1416 = s1412 ^ s1415; const SWord32 s1417 = s13 ^ s1416; const SWord16 s1418 = (SWord16) (s1417 >> 16); const SWord8 s1419 = (SWord8) s1418; const SWord32 s1420 = table2[s1419]; const SWord32 s1421 = s1403 ^ s1420; const SWord8 s1422 = (SWord8) (s1406 >> 8); const SWord32 s1423 = table1[s1422]; const SWord16 s1424 = (SWord16) (s1395 >> 16); const SWord8 s1425 = (SWord8) s1424; const SWord32 s1426 = table2[s1425]; const SWord32 s1427 = s1423 ^ s1426; const SWord8 s1428 = (SWord8) (s1413 >> 8); const SWord32 s1429 = table3[s1428]; const SWord32 s1430 = s1427 ^ s1429; const SWord16 s1431 = (SWord16) s1361; const SWord8 s1432 = (SWord8) s1431; const SWord32 s1433 = table4[s1432]; const SWord32 s1434 = s1430 ^ s1433; const SWord32 s1435 = s14 ^ s1434; const SWord16 s1436 = (SWord16) s1435; const SWord8 s1437 = (SWord8) (s1436 >> 8); const SWord32 s1438 = table3[s1437]; const SWord32 s1439 = s1421 ^ s1438; const SWord8 s1440 = (SWord8) (s1424 >> 8); const SWord32 s1441 = table1[s1440]; const SWord8 s1442 = (SWord8) s1345; const SWord32 s1443 = table2[s1442]; const SWord32 s1444 = s1441 ^ s1443; const SWord8 s1445 = (SWord8) (s1431 >> 8); const SWord32 s1446 = table3[s1445]; const SWord32 s1447 = s1444 ^ s1446; const SWord8 s1448 = (SWord8) s1380; const SWord32 s1449 = table4[s1448]; const SWord32 s1450 = s1447 ^ s1449; const SWord32 s1451 = s15 ^ s1450; const SWord16 s1452 = (SWord16) s1451; const SWord8 s1453 = (SWord8) s1452; const SWord32 s1454 = table4[s1453]; const SWord32 s1455 = s1439 ^ s1454; const SWord32 s1456 = s16 ^ s1455; const SWord16 s1457 = (SWord16) (s1456 >> 16); const SWord8 s1458 = (SWord8) (s1457 >> 8); const SWord32 s1459 = table1[s1458]; const SWord8 s1460 = (SWord8) (s1418 >> 8); const SWord32 s1461 = table1[s1460]; const SWord16 s1462 = (SWord16) (s1435 >> 16); const SWord8 s1463 = (SWord8) s1462; const SWord32 s1464 = table2[s1463]; const SWord32 s1465 = s1461 ^ s1464; const SWord8 s1466 = (SWord8) (s1452 >> 8); const SWord32 s1467 = table3[s1466]; const SWord32 s1468 = s1465 ^ s1467; const SWord16 s1469 = (SWord16) s1400; const SWord8 s1470 = (SWord8) s1469; const SWord32 s1471 = table4[s1470]; const SWord32 s1472 = s1468 ^ s1471; const SWord32 s1473 = s17 ^ s1472; const SWord16 s1474 = (SWord16) (s1473 >> 16); const SWord8 s1475 = (SWord8) s1474; const SWord32 s1476 = table2[s1475]; const SWord32 s1477 = s1459 ^ s1476; const SWord8 s1478 = (SWord8) (s1462 >> 8); const SWord32 s1479 = table1[s1478]; const SWord16 s1480 = (SWord16) (s1451 >> 16); const SWord8 s1481 = (SWord8) s1480; const SWord32 s1482 = table2[s1481]; const SWord32 s1483 = s1479 ^ s1482; const SWord8 s1484 = (SWord8) (s1469 >> 8); const SWord32 s1485 = table3[s1484]; const SWord32 s1486 = s1483 ^ s1485; const SWord16 s1487 = (SWord16) s1417; const SWord8 s1488 = (SWord8) s1487; const SWord32 s1489 = table4[s1488]; const SWord32 s1490 = s1486 ^ s1489; const SWord32 s1491 = s18 ^ s1490; const SWord16 s1492 = (SWord16) s1491; const SWord8 s1493 = (SWord8) (s1492 >> 8); const SWord32 s1494 = table3[s1493]; const SWord32 s1495 = s1477 ^ s1494; const SWord8 s1496 = (SWord8) (s1480 >> 8); const SWord32 s1497 = table1[s1496]; const SWord8 s1498 = (SWord8) s1401; const SWord32 s1499 = table2[s1498]; const SWord32 s1500 = s1497 ^ s1499; const SWord8 s1501 = (SWord8) (s1487 >> 8); const SWord32 s1502 = table3[s1501]; const SWord32 s1503 = s1500 ^ s1502; const SWord8 s1504 = (SWord8) s1436; const SWord32 s1505 = table4[s1504]; const SWord32 s1506 = s1503 ^ s1505; const SWord32 s1507 = s19 ^ s1506; const SWord16 s1508 = (SWord16) s1507; const SWord8 s1509 = (SWord8) s1508; const SWord32 s1510 = table4[s1509]; const SWord32 s1511 = s1495 ^ s1510; const SWord32 s1512 = s20 ^ s1511; const SWord16 s1513 = (SWord16) (s1512 >> 16); const SWord8 s1514 = (SWord8) (s1513 >> 8); const SWord32 s1515 = table1[s1514]; const SWord8 s1516 = (SWord8) (s1474 >> 8); const SWord32 s1517 = table1[s1516]; const SWord16 s1518 = (SWord16) (s1491 >> 16); const SWord8 s1519 = (SWord8) s1518; const SWord32 s1520 = table2[s1519]; const SWord32 s1521 = s1517 ^ s1520; const SWord8 s1522 = (SWord8) (s1508 >> 8); const SWord32 s1523 = table3[s1522]; const SWord32 s1524 = s1521 ^ s1523; const SWord16 s1525 = (SWord16) s1456; const SWord8 s1526 = (SWord8) s1525; const SWord32 s1527 = table4[s1526]; const SWord32 s1528 = s1524 ^ s1527; const SWord32 s1529 = s21 ^ s1528; const SWord16 s1530 = (SWord16) (s1529 >> 16); const SWord8 s1531 = (SWord8) s1530; const SWord32 s1532 = table2[s1531]; const SWord32 s1533 = s1515 ^ s1532; const SWord8 s1534 = (SWord8) (s1518 >> 8); const SWord32 s1535 = table1[s1534]; const SWord16 s1536 = (SWord16) (s1507 >> 16); const SWord8 s1537 = (SWord8) s1536; const SWord32 s1538 = table2[s1537]; const SWord32 s1539 = s1535 ^ s1538; const SWord8 s1540 = (SWord8) (s1525 >> 8); const SWord32 s1541 = table3[s1540]; const SWord32 s1542 = s1539 ^ s1541; const SWord16 s1543 = (SWord16) s1473; const SWord8 s1544 = (SWord8) s1543; const SWord32 s1545 = table4[s1544]; const SWord32 s1546 = s1542 ^ s1545; const SWord32 s1547 = s22 ^ s1546; const SWord16 s1548 = (SWord16) s1547; const SWord8 s1549 = (SWord8) (s1548 >> 8); const SWord32 s1550 = table3[s1549]; const SWord32 s1551 = s1533 ^ s1550; const SWord8 s1552 = (SWord8) (s1536 >> 8); const SWord32 s1553 = table1[s1552]; const SWord8 s1554 = (SWord8) s1457; const SWord32 s1555 = table2[s1554]; const SWord32 s1556 = s1553 ^ s1555; const SWord8 s1557 = (SWord8) (s1543 >> 8); const SWord32 s1558 = table3[s1557]; const SWord32 s1559 = s1556 ^ s1558; const SWord8 s1560 = (SWord8) s1492; const SWord32 s1561 = table4[s1560]; const SWord32 s1562 = s1559 ^ s1561; const SWord32 s1563 = s23 ^ s1562; const SWord16 s1564 = (SWord16) s1563; const SWord8 s1565 = (SWord8) s1564; const SWord32 s1566 = table4[s1565]; const SWord32 s1567 = s1551 ^ s1566; const SWord32 s1568 = s24 ^ s1567; const SWord16 s1569 = (SWord16) (s1568 >> 16); const SWord8 s1570 = (SWord8) (s1569 >> 8); const SWord32 s1571 = table1[s1570]; const SWord8 s1572 = (SWord8) (s1530 >> 8); const SWord32 s1573 = table1[s1572]; const SWord16 s1574 = (SWord16) (s1547 >> 16); const SWord8 s1575 = (SWord8) s1574; const SWord32 s1576 = table2[s1575]; const SWord32 s1577 = s1573 ^ s1576; const SWord8 s1578 = (SWord8) (s1564 >> 8); const SWord32 s1579 = table3[s1578]; const SWord32 s1580 = s1577 ^ s1579; const SWord16 s1581 = (SWord16) s1512; const SWord8 s1582 = (SWord8) s1581; const SWord32 s1583 = table4[s1582]; const SWord32 s1584 = s1580 ^ s1583; const SWord32 s1585 = s25 ^ s1584; const SWord16 s1586 = (SWord16) (s1585 >> 16); const SWord8 s1587 = (SWord8) s1586; const SWord32 s1588 = table2[s1587]; const SWord32 s1589 = s1571 ^ s1588; const SWord8 s1590 = (SWord8) (s1574 >> 8); const SWord32 s1591 = table1[s1590]; const SWord16 s1592 = (SWord16) (s1563 >> 16); const SWord8 s1593 = (SWord8) s1592; const SWord32 s1594 = table2[s1593]; const SWord32 s1595 = s1591 ^ s1594; const SWord8 s1596 = (SWord8) (s1581 >> 8); const SWord32 s1597 = table3[s1596]; const SWord32 s1598 = s1595 ^ s1597; const SWord16 s1599 = (SWord16) s1529; const SWord8 s1600 = (SWord8) s1599; const SWord32 s1601 = table4[s1600]; const SWord32 s1602 = s1598 ^ s1601; const SWord32 s1603 = s26 ^ s1602; const SWord16 s1604 = (SWord16) s1603; const SWord8 s1605 = (SWord8) (s1604 >> 8); const SWord32 s1606 = table3[s1605]; const SWord32 s1607 = s1589 ^ s1606; const SWord8 s1608 = (SWord8) (s1592 >> 8); const SWord32 s1609 = table1[s1608]; const SWord8 s1610 = (SWord8) s1513; const SWord32 s1611 = table2[s1610]; const SWord32 s1612 = s1609 ^ s1611; const SWord8 s1613 = (SWord8) (s1599 >> 8); const SWord32 s1614 = table3[s1613]; const SWord32 s1615 = s1612 ^ s1614; const SWord8 s1616 = (SWord8) s1548; const SWord32 s1617 = table4[s1616]; const SWord32 s1618 = s1615 ^ s1617; const SWord32 s1619 = s27 ^ s1618; const SWord16 s1620 = (SWord16) s1619; const SWord8 s1621 = (SWord8) s1620; const SWord32 s1622 = table4[s1621]; const SWord32 s1623 = s1607 ^ s1622; const SWord32 s1624 = s28 ^ s1623; const SWord16 s1625 = (SWord16) (s1624 >> 16); const SWord8 s1626 = (SWord8) (s1625 >> 8); const SWord32 s1627 = table1[s1626]; const SWord8 s1628 = (SWord8) (s1586 >> 8); const SWord32 s1629 = table1[s1628]; const SWord16 s1630 = (SWord16) (s1603 >> 16); const SWord8 s1631 = (SWord8) s1630; const SWord32 s1632 = table2[s1631]; const SWord32 s1633 = s1629 ^ s1632; const SWord8 s1634 = (SWord8) (s1620 >> 8); const SWord32 s1635 = table3[s1634]; const SWord32 s1636 = s1633 ^ s1635; const SWord16 s1637 = (SWord16) s1568; const SWord8 s1638 = (SWord8) s1637; const SWord32 s1639 = table4[s1638]; const SWord32 s1640 = s1636 ^ s1639; const SWord32 s1641 = s29 ^ s1640; const SWord16 s1642 = (SWord16) (s1641 >> 16); const SWord8 s1643 = (SWord8) s1642; const SWord32 s1644 = table2[s1643]; const SWord32 s1645 = s1627 ^ s1644; const SWord8 s1646 = (SWord8) (s1630 >> 8); const SWord32 s1647 = table1[s1646]; const SWord16 s1648 = (SWord16) (s1619 >> 16); const SWord8 s1649 = (SWord8) s1648; const SWord32 s1650 = table2[s1649]; const SWord32 s1651 = s1647 ^ s1650; const SWord8 s1652 = (SWord8) (s1637 >> 8); const SWord32 s1653 = table3[s1652]; const SWord32 s1654 = s1651 ^ s1653; const SWord16 s1655 = (SWord16) s1585; const SWord8 s1656 = (SWord8) s1655; const SWord32 s1657 = table4[s1656]; const SWord32 s1658 = s1654 ^ s1657; const SWord32 s1659 = s30 ^ s1658; const SWord16 s1660 = (SWord16) s1659; const SWord8 s1661 = (SWord8) (s1660 >> 8); const SWord32 s1662 = table3[s1661]; const SWord32 s1663 = s1645 ^ s1662; const SWord8 s1664 = (SWord8) (s1648 >> 8); const SWord32 s1665 = table1[s1664]; const SWord8 s1666 = (SWord8) s1569; const SWord32 s1667 = table2[s1666]; const SWord32 s1668 = s1665 ^ s1667; const SWord8 s1669 = (SWord8) (s1655 >> 8); const SWord32 s1670 = table3[s1669]; const SWord32 s1671 = s1668 ^ s1670; const SWord8 s1672 = (SWord8) s1604; const SWord32 s1673 = table4[s1672]; const SWord32 s1674 = s1671 ^ s1673; const SWord32 s1675 = s31 ^ s1674; const SWord16 s1676 = (SWord16) s1675; const SWord8 s1677 = (SWord8) s1676; const SWord32 s1678 = table4[s1677]; const SWord32 s1679 = s1663 ^ s1678; const SWord32 s1680 = s32 ^ s1679; const SWord16 s1681 = (SWord16) (s1680 >> 16); const SWord8 s1682 = (SWord8) (s1681 >> 8); const SWord32 s1683 = table1[s1682]; const SWord8 s1684 = (SWord8) (s1642 >> 8); const SWord32 s1685 = table1[s1684]; const SWord16 s1686 = (SWord16) (s1659 >> 16); const SWord8 s1687 = (SWord8) s1686; const SWord32 s1688 = table2[s1687]; const SWord32 s1689 = s1685 ^ s1688; const SWord8 s1690 = (SWord8) (s1676 >> 8); const SWord32 s1691 = table3[s1690]; const SWord32 s1692 = s1689 ^ s1691; const SWord16 s1693 = (SWord16) s1624; const SWord8 s1694 = (SWord8) s1693; const SWord32 s1695 = table4[s1694]; const SWord32 s1696 = s1692 ^ s1695; const SWord32 s1697 = s33 ^ s1696; const SWord16 s1698 = (SWord16) (s1697 >> 16); const SWord8 s1699 = (SWord8) s1698; const SWord32 s1700 = table2[s1699]; const SWord32 s1701 = s1683 ^ s1700; const SWord8 s1702 = (SWord8) (s1686 >> 8); const SWord32 s1703 = table1[s1702]; const SWord16 s1704 = (SWord16) (s1675 >> 16); const SWord8 s1705 = (SWord8) s1704; const SWord32 s1706 = table2[s1705]; const SWord32 s1707 = s1703 ^ s1706; const SWord8 s1708 = (SWord8) (s1693 >> 8); const SWord32 s1709 = table3[s1708]; const SWord32 s1710 = s1707 ^ s1709; const SWord16 s1711 = (SWord16) s1641; const SWord8 s1712 = (SWord8) s1711; const SWord32 s1713 = table4[s1712]; const SWord32 s1714 = s1710 ^ s1713; const SWord32 s1715 = s34 ^ s1714; const SWord16 s1716 = (SWord16) s1715; const SWord8 s1717 = (SWord8) (s1716 >> 8); const SWord32 s1718 = table3[s1717]; const SWord32 s1719 = s1701 ^ s1718; const SWord8 s1720 = (SWord8) (s1704 >> 8); const SWord32 s1721 = table1[s1720]; const SWord8 s1722 = (SWord8) s1625; const SWord32 s1723 = table2[s1722]; const SWord32 s1724 = s1721 ^ s1723; const SWord8 s1725 = (SWord8) (s1711 >> 8); const SWord32 s1726 = table3[s1725]; const SWord32 s1727 = s1724 ^ s1726; const SWord8 s1728 = (SWord8) s1660; const SWord32 s1729 = table4[s1728]; const SWord32 s1730 = s1727 ^ s1729; const SWord32 s1731 = s35 ^ s1730; const SWord16 s1732 = (SWord16) s1731; const SWord8 s1733 = (SWord8) s1732; const SWord32 s1734 = table4[s1733]; const SWord32 s1735 = s1719 ^ s1734; const SWord32 s1736 = s36 ^ s1735; const SWord16 s1737 = (SWord16) (s1736 >> 16); const SWord8 s1738 = (SWord8) (s1737 >> 8); const SWord32 s1739 = table1[s1738]; const SWord8 s1740 = (SWord8) (s1698 >> 8); const SWord32 s1741 = table1[s1740]; const SWord16 s1742 = (SWord16) (s1715 >> 16); const SWord8 s1743 = (SWord8) s1742; const SWord32 s1744 = table2[s1743]; const SWord32 s1745 = s1741 ^ s1744; const SWord8 s1746 = (SWord8) (s1732 >> 8); const SWord32 s1747 = table3[s1746]; const SWord32 s1748 = s1745 ^ s1747; const SWord16 s1749 = (SWord16) s1680; const SWord8 s1750 = (SWord8) s1749; const SWord32 s1751 = table4[s1750]; const SWord32 s1752 = s1748 ^ s1751; const SWord32 s1753 = s37 ^ s1752; const SWord16 s1754 = (SWord16) (s1753 >> 16); const SWord8 s1755 = (SWord8) s1754; const SWord32 s1756 = table2[s1755]; const SWord32 s1757 = s1739 ^ s1756; const SWord8 s1758 = (SWord8) (s1742 >> 8); const SWord32 s1759 = table1[s1758]; const SWord16 s1760 = (SWord16) (s1731 >> 16); const SWord8 s1761 = (SWord8) s1760; const SWord32 s1762 = table2[s1761]; const SWord32 s1763 = s1759 ^ s1762; const SWord8 s1764 = (SWord8) (s1749 >> 8); const SWord32 s1765 = table3[s1764]; const SWord32 s1766 = s1763 ^ s1765; const SWord16 s1767 = (SWord16) s1697; const SWord8 s1768 = (SWord8) s1767; const SWord32 s1769 = table4[s1768]; const SWord32 s1770 = s1766 ^ s1769; const SWord32 s1771 = s38 ^ s1770; const SWord16 s1772 = (SWord16) s1771; const SWord8 s1773 = (SWord8) (s1772 >> 8); const SWord32 s1774 = table3[s1773]; const SWord32 s1775 = s1757 ^ s1774; const SWord8 s1776 = (SWord8) (s1760 >> 8); const SWord32 s1777 = table1[s1776]; const SWord8 s1778 = (SWord8) s1681; const SWord32 s1779 = table2[s1778]; const SWord32 s1780 = s1777 ^ s1779; const SWord8 s1781 = (SWord8) (s1767 >> 8); const SWord32 s1782 = table3[s1781]; const SWord32 s1783 = s1780 ^ s1782; const SWord8 s1784 = (SWord8) s1716; const SWord32 s1785 = table4[s1784]; const SWord32 s1786 = s1783 ^ s1785; const SWord32 s1787 = s39 ^ s1786; const SWord16 s1788 = (SWord16) s1787; const SWord8 s1789 = (SWord8) s1788; const SWord32 s1790 = table4[s1789]; const SWord32 s1791 = s1775 ^ s1790; const SWord32 s1792 = s40 ^ s1791; const SWord16 s1793 = (SWord16) (s1792 >> 16); const SWord8 s1794 = (SWord8) (s1793 >> 8); const SWord8 s1795 = table0[s1794]; const SWord8 s1796 = (SWord8) (s1754 >> 8); const SWord32 s1797 = table1[s1796]; const SWord16 s1798 = (SWord16) (s1771 >> 16); const SWord8 s1799 = (SWord8) s1798; const SWord32 s1800 = table2[s1799]; const SWord32 s1801 = s1797 ^ s1800; const SWord8 s1802 = (SWord8) (s1788 >> 8); const SWord32 s1803 = table3[s1802]; const SWord32 s1804 = s1801 ^ s1803; const SWord16 s1805 = (SWord16) s1736; const SWord8 s1806 = (SWord8) s1805; const SWord32 s1807 = table4[s1806]; const SWord32 s1808 = s1804 ^ s1807; const SWord32 s1809 = s41 ^ s1808; const SWord16 s1810 = (SWord16) (s1809 >> 16); const SWord8 s1811 = (SWord8) s1810; const SWord8 s1812 = table0[s1811]; const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812); const SWord8 s1814 = (SWord8) (s1798 >> 8); const SWord32 s1815 = table1[s1814]; const SWord16 s1816 = (SWord16) (s1787 >> 16); const SWord8 s1817 = (SWord8) s1816; const SWord32 s1818 = table2[s1817]; const SWord32 s1819 = s1815 ^ s1818; const SWord8 s1820 = (SWord8) (s1805 >> 8); const SWord32 s1821 = table3[s1820]; const SWord32 s1822 = s1819 ^ s1821; const SWord16 s1823 = (SWord16) s1753; const SWord8 s1824 = (SWord8) s1823; const SWord32 s1825 = table4[s1824]; const SWord32 s1826 = s1822 ^ s1825; const SWord32 s1827 = s42 ^ s1826; const SWord16 s1828 = (SWord16) s1827; const SWord8 s1829 = (SWord8) (s1828 >> 8); const SWord8 s1830 = table0[s1829]; const SWord8 s1831 = (SWord8) (s1816 >> 8); const SWord32 s1832 = table1[s1831]; const SWord8 s1833 = (SWord8) s1737; const SWord32 s1834 = table2[s1833]; const SWord32 s1835 = s1832 ^ s1834; const SWord8 s1836 = (SWord8) (s1823 >> 8); const SWord32 s1837 = table3[s1836]; const SWord32 s1838 = s1835 ^ s1837; const SWord8 s1839 = (SWord8) s1772; const SWord32 s1840 = table4[s1839]; const SWord32 s1841 = s1838 ^ s1840; const SWord32 s1842 = s43 ^ s1841; const SWord16 s1843 = (SWord16) s1842; const SWord8 s1844 = (SWord8) s1843; const SWord8 s1845 = table0[s1844]; const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845); const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846); const SWord32 s1848 = s44 ^ s1847; const SWord8 s1849 = (SWord8) (s1810 >> 8); const SWord8 s1850 = table0[s1849]; const SWord16 s1851 = (SWord16) (s1827 >> 16); const SWord8 s1852 = (SWord8) s1851; const SWord8 s1853 = table0[s1852]; const SWord16 s1854 = (((SWord16) s1850) << 8) | ((SWord16) s1853); const SWord8 s1855 = (SWord8) (s1843 >> 8); const SWord8 s1856 = table0[s1855]; const SWord16 s1857 = (SWord16) s1792; const SWord8 s1858 = (SWord8) s1857; const SWord8 s1859 = table0[s1858]; const SWord16 s1860 = (((SWord16) s1856) << 8) | ((SWord16) s1859); const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860); const SWord32 s1862 = s45 ^ s1861; const SWord8 s1863 = (SWord8) (s1851 >> 8); const SWord8 s1864 = table0[s1863]; const SWord16 s1865 = (SWord16) (s1842 >> 16); const SWord8 s1866 = (SWord8) s1865; const SWord8 s1867 = table0[s1866]; const SWord16 s1868 = (((SWord16) s1864) << 8) | ((SWord16) s1867); const SWord8 s1869 = (SWord8) (s1857 >> 8); const SWord8 s1870 = table0[s1869]; const SWord16 s1871 = (SWord16) s1809; const SWord8 s1872 = (SWord8) s1871; const SWord8 s1873 = table0[s1872]; const SWord16 s1874 = (((SWord16) s1870) << 8) | ((SWord16) s1873); const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874); const SWord32 s1876 = s46 ^ s1875; const SWord8 s1877 = (SWord8) (s1865 >> 8); const SWord8 s1878 = table0[s1877]; const SWord8 s1879 = (SWord8) s1793; const SWord8 s1880 = table0[s1879]; const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880); const SWord8 s1882 = (SWord8) (s1871 >> 8); const SWord8 s1883 = table0[s1882]; const SWord8 s1884 = (SWord8) s1828; const SWord8 s1885 = table0[s1884]; const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885); const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886); const SWord32 s1888 = s47 ^ s1887; ct[0] = s1848; ct[1] = s1862; ct[2] = s1876; ct[3] = s1888; } == END: "aes128BlockEncrypt.c" ================== == BEGIN: "aes128BlockDecrypt.c" ================ /* File: "aes128BlockDecrypt.c". Automatically generated by SBV. Do not edit! */ #include "aes128Lib.h" void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey, SWord32 *pt) { const SWord32 s0 = ct[0]; const SWord32 s1 = ct[1]; const SWord32 s2 = ct[2]; const SWord32 s3 = ct[3]; const SWord32 s4 = xkey[0]; const SWord32 s5 = xkey[1]; const SWord32 s6 = xkey[2]; const SWord32 s7 = xkey[3]; const SWord32 s8 = xkey[4]; const SWord32 s9 = xkey[5]; const SWord32 s10 = xkey[6]; const SWord32 s11 = xkey[7]; const SWord32 s12 = xkey[8]; const SWord32 s13 = xkey[9]; const SWord32 s14 = xkey[10]; const SWord32 s15 = xkey[11]; const SWord32 s16 = xkey[12]; const SWord32 s17 = xkey[13]; const SWord32 s18 = xkey[14]; const SWord32 s19 = xkey[15]; const SWord32 s20 = xkey[16]; const SWord32 s21 = xkey[17]; const SWord32 s22 = xkey[18]; const SWord32 s23 = xkey[19]; const SWord32 s24 = xkey[20]; const SWord32 s25 = xkey[21]; const SWord32 s26 = xkey[22]; const SWord32 s27 = xkey[23]; const SWord32 s28 = xkey[24]; const SWord32 s29 = xkey[25]; const SWord32 s30 = xkey[26]; const SWord32 s31 = xkey[27]; const SWord32 s32 = xkey[28]; const SWord32 s33 = xkey[29]; const SWord32 s34 = xkey[30]; const SWord32 s35 = xkey[31]; const SWord32 s36 = xkey[32]; const SWord32 s37 = xkey[33]; const SWord32 s38 = xkey[34]; const SWord32 s39 = xkey[35]; const SWord32 s40 = xkey[36]; const SWord32 s41 = xkey[37]; const SWord32 s42 = xkey[38]; const SWord32 s43 = xkey[39]; const SWord32 s44 = xkey[40]; const SWord32 s45 = xkey[41]; const SWord32 s46 = xkey[42]; const SWord32 s47 = xkey[43]; static const SWord8 table0[] = { 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125 }; static const SWord32 table1[] = { 0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL, 0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL, 0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL, 0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL, 0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL, 0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL, 0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL, 0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL, 0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL, 0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL, 0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL, 0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL, 0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL, 0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL, 0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL, 0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL, 0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL, 0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL, 0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL, 0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL, 0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL, 0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL, 0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL, 0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL, 0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL, 0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL, 0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL, 0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL, 0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL, 0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL, 0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL, 0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL, 0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL, 0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL, 0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL, 0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL, 0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL, 0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL, 0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL, 0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL, 0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL, 0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL, 0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL, 0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL, 0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL, 0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL, 0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL, 0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL, 0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL, 0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL, 0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL, 0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL, 0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL, 0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL, 0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL, 0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL, 0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL, 0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL, 0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL, 0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL, 0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL, 0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL, 0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL, 0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL }; static const SWord32 table2[] = { 0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL, 0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL, 0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL, 0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL, 0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL, 0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL, 0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL, 0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL, 0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL, 0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL, 0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL, 0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL, 0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL, 0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL, 0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL, 0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL, 0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL, 0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL, 0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL, 0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL, 0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL, 0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL, 0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL, 0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL, 0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL, 0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL, 0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL, 0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL, 0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL, 0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL, 0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL, 0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL, 0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL, 0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL, 0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL, 0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL, 0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL, 0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL, 0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL, 0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL, 0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL, 0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL, 0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL, 0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL, 0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL, 0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL, 0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL, 0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL, 0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL, 0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL, 0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL, 0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL, 0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL, 0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL, 0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL, 0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL, 0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL, 0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL, 0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL, 0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL, 0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL, 0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL, 0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL, 0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL }; static const SWord32 table3[] = { 0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL, 0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL, 0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL, 0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL, 0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL, 0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL, 0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL, 0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL, 0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL, 0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL, 0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL, 0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL, 0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL, 0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL, 0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL, 0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL, 0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL, 0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL, 0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL, 0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL, 0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL, 0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL, 0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL, 0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL, 0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL, 0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL, 0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL, 0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL, 0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL, 0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL, 0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL, 0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL, 0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL, 0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL, 0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL, 0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL, 0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL, 0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL, 0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL, 0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL, 0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL, 0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL, 0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL, 0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL, 0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL, 0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL, 0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL, 0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL, 0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL, 0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL, 0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL, 0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL, 0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL, 0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL, 0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL, 0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL, 0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL, 0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL, 0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL, 0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL, 0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL, 0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL, 0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL, 0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL }; static const SWord32 table4[] = { 0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL, 0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL, 0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL, 0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL, 0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL, 0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL, 0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL, 0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL, 0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL, 0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL, 0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL, 0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL, 0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL, 0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL, 0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL, 0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL, 0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL, 0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL, 0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL, 0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL, 0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL, 0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL, 0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL, 0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL, 0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL, 0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL, 0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL, 0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL, 0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL, 0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL, 0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL, 0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL, 0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL, 0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL, 0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL, 0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL, 0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL, 0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL, 0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL, 0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL, 0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL, 0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL, 0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL, 0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL, 0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL, 0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL, 0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL, 0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL, 0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL, 0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL, 0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL, 0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL, 0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL, 0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL, 0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL, 0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL, 0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL, 0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL, 0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL, 0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL, 0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL, 0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL, 0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL, 0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL }; const SWord32 s560 = s0 ^ s4; const SWord16 s561 = (SWord16) (s560 >> 16); const SWord8 s562 = (SWord8) (s561 >> 8); const SWord32 s563 = table1[s562]; const SWord32 s819 = s3 ^ s7; const SWord16 s820 = (SWord16) (s819 >> 16); const SWord8 s821 = (SWord8) s820; const SWord32 s822 = table2[s821]; const SWord32 s823 = s563 ^ s822; const SWord32 s1079 = s2 ^ s6; const SWord16 s1080 = (SWord16) s1079; const SWord8 s1081 = (SWord8) (s1080 >> 8); const SWord32 s1082 = table3[s1081]; const SWord32 s1083 = s823 ^ s1082; const SWord32 s1339 = s1 ^ s5; const SWord16 s1340 = (SWord16) s1339; const SWord8 s1341 = (SWord8) s1340; const SWord32 s1342 = table4[s1341]; const SWord32 s1343 = s1083 ^ s1342; const SWord32 s1344 = s8 ^ s1343; const SWord16 s1345 = (SWord16) (s1344 >> 16); const SWord8 s1346 = (SWord8) (s1345 >> 8); const SWord32 s1347 = table1[s1346]; const SWord8 s1348 = (SWord8) (s820 >> 8); const SWord32 s1349 = table1[s1348]; const SWord16 s1350 = (SWord16) (s1079 >> 16); const SWord8 s1351 = (SWord8) s1350; const SWord32 s1352 = table2[s1351]; const SWord32 s1353 = s1349 ^ s1352; const SWord8 s1354 = (SWord8) (s1340 >> 8); const SWord32 s1355 = table3[s1354]; const SWord32 s1356 = s1353 ^ s1355; const SWord16 s1357 = (SWord16) s560; const SWord8 s1358 = (SWord8) s1357; const SWord32 s1359 = table4[s1358]; const SWord32 s1360 = s1356 ^ s1359; const SWord32 s1361 = s11 ^ s1360; const SWord16 s1362 = (SWord16) (s1361 >> 16); const SWord8 s1363 = (SWord8) s1362; const SWord32 s1364 = table2[s1363]; const SWord32 s1365 = s1347 ^ s1364; const SWord8 s1366 = (SWord8) (s1350 >> 8); const SWord32 s1367 = table1[s1366]; const SWord16 s1368 = (SWord16) (s1339 >> 16); const SWord8 s1369 = (SWord8) s1368; const SWord32 s1370 = table2[s1369]; const SWord32 s1371 = s1367 ^ s1370; const SWord8 s1372 = (SWord8) (s1357 >> 8); const SWord32 s1373 = table3[s1372]; const SWord32 s1374 = s1371 ^ s1373; const SWord16 s1375 = (SWord16) s819; const SWord8 s1376 = (SWord8) s1375; const SWord32 s1377 = table4[s1376]; const SWord32 s1378 = s1374 ^ s1377; const SWord32 s1379 = s10 ^ s1378; const SWord16 s1380 = (SWord16) s1379; const SWord8 s1381 = (SWord8) (s1380 >> 8); const SWord32 s1382 = table3[s1381]; const SWord32 s1383 = s1365 ^ s1382; const SWord8 s1384 = (SWord8) (s1368 >> 8); const SWord32 s1385 = table1[s1384]; const SWord8 s1386 = (SWord8) s561; const SWord32 s1387 = table2[s1386]; const SWord32 s1388 = s1385 ^ s1387; const SWord8 s1389 = (SWord8) (s1375 >> 8); const SWord32 s1390 = table3[s1389]; const SWord32 s1391 = s1388 ^ s1390; const SWord8 s1392 = (SWord8) s1080; const SWord32 s1393 = table4[s1392]; const SWord32 s1394 = s1391 ^ s1393; const SWord32 s1395 = s9 ^ s1394; const SWord16 s1396 = (SWord16) s1395; const SWord8 s1397 = (SWord8) s1396; const SWord32 s1398 = table4[s1397]; const SWord32 s1399 = s1383 ^ s1398; const SWord32 s1400 = s12 ^ s1399; const SWord16 s1401 = (SWord16) (s1400 >> 16); const SWord8 s1402 = (SWord8) (s1401 >> 8); const SWord32 s1403 = table1[s1402]; const SWord8 s1404 = (SWord8) (s1362 >> 8); const SWord32 s1405 = table1[s1404]; const SWord16 s1406 = (SWord16) (s1379 >> 16); const SWord8 s1407 = (SWord8) s1406; const SWord32 s1408 = table2[s1407]; const SWord32 s1409 = s1405 ^ s1408; const SWord8 s1410 = (SWord8) (s1396 >> 8); const SWord32 s1411 = table3[s1410]; const SWord32 s1412 = s1409 ^ s1411; const SWord16 s1413 = (SWord16) s1344; const SWord8 s1414 = (SWord8) s1413; const SWord32 s1415 = table4[s1414]; const SWord32 s1416 = s1412 ^ s1415; const SWord32 s1417 = s15 ^ s1416; const SWord16 s1418 = (SWord16) (s1417 >> 16); const SWord8 s1419 = (SWord8) s1418; const SWord32 s1420 = table2[s1419]; const SWord32 s1421 = s1403 ^ s1420; const SWord8 s1422 = (SWord8) (s1406 >> 8); const SWord32 s1423 = table1[s1422]; const SWord16 s1424 = (SWord16) (s1395 >> 16); const SWord8 s1425 = (SWord8) s1424; const SWord32 s1426 = table2[s1425]; const SWord32 s1427 = s1423 ^ s1426; const SWord8 s1428 = (SWord8) (s1413 >> 8); const SWord32 s1429 = table3[s1428]; const SWord32 s1430 = s1427 ^ s1429; const SWord16 s1431 = (SWord16) s1361; const SWord8 s1432 = (SWord8) s1431; const SWord32 s1433 = table4[s1432]; const SWord32 s1434 = s1430 ^ s1433; const SWord32 s1435 = s14 ^ s1434; const SWord16 s1436 = (SWord16) s1435; const SWord8 s1437 = (SWord8) (s1436 >> 8); const SWord32 s1438 = table3[s1437]; const SWord32 s1439 = s1421 ^ s1438; const SWord8 s1440 = (SWord8) (s1424 >> 8); const SWord32 s1441 = table1[s1440]; const SWord8 s1442 = (SWord8) s1345; const SWord32 s1443 = table2[s1442]; const SWord32 s1444 = s1441 ^ s1443; const SWord8 s1445 = (SWord8) (s1431 >> 8); const SWord32 s1446 = table3[s1445]; const SWord32 s1447 = s1444 ^ s1446; const SWord8 s1448 = (SWord8) s1380; const SWord32 s1449 = table4[s1448]; const SWord32 s1450 = s1447 ^ s1449; const SWord32 s1451 = s13 ^ s1450; const SWord16 s1452 = (SWord16) s1451; const SWord8 s1453 = (SWord8) s1452; const SWord32 s1454 = table4[s1453]; const SWord32 s1455 = s1439 ^ s1454; const SWord32 s1456 = s16 ^ s1455; const SWord16 s1457 = (SWord16) (s1456 >> 16); const SWord8 s1458 = (SWord8) (s1457 >> 8); const SWord32 s1459 = table1[s1458]; const SWord8 s1460 = (SWord8) (s1418 >> 8); const SWord32 s1461 = table1[s1460]; const SWord16 s1462 = (SWord16) (s1435 >> 16); const SWord8 s1463 = (SWord8) s1462; const SWord32 s1464 = table2[s1463]; const SWord32 s1465 = s1461 ^ s1464; const SWord8 s1466 = (SWord8) (s1452 >> 8); const SWord32 s1467 = table3[s1466]; const SWord32 s1468 = s1465 ^ s1467; const SWord16 s1469 = (SWord16) s1400; const SWord8 s1470 = (SWord8) s1469; const SWord32 s1471 = table4[s1470]; const SWord32 s1472 = s1468 ^ s1471; const SWord32 s1473 = s19 ^ s1472; const SWord16 s1474 = (SWord16) (s1473 >> 16); const SWord8 s1475 = (SWord8) s1474; const SWord32 s1476 = table2[s1475]; const SWord32 s1477 = s1459 ^ s1476; const SWord8 s1478 = (SWord8) (s1462 >> 8); const SWord32 s1479 = table1[s1478]; const SWord16 s1480 = (SWord16) (s1451 >> 16); const SWord8 s1481 = (SWord8) s1480; const SWord32 s1482 = table2[s1481]; const SWord32 s1483 = s1479 ^ s1482; const SWord8 s1484 = (SWord8) (s1469 >> 8); const SWord32 s1485 = table3[s1484]; const SWord32 s1486 = s1483 ^ s1485; const SWord16 s1487 = (SWord16) s1417; const SWord8 s1488 = (SWord8) s1487; const SWord32 s1489 = table4[s1488]; const SWord32 s1490 = s1486 ^ s1489; const SWord32 s1491 = s18 ^ s1490; const SWord16 s1492 = (SWord16) s1491; const SWord8 s1493 = (SWord8) (s1492 >> 8); const SWord32 s1494 = table3[s1493]; const SWord32 s1495 = s1477 ^ s1494; const SWord8 s1496 = (SWord8) (s1480 >> 8); const SWord32 s1497 = table1[s1496]; const SWord8 s1498 = (SWord8) s1401; const SWord32 s1499 = table2[s1498]; const SWord32 s1500 = s1497 ^ s1499; const SWord8 s1501 = (SWord8) (s1487 >> 8); const SWord32 s1502 = table3[s1501]; const SWord32 s1503 = s1500 ^ s1502; const SWord8 s1504 = (SWord8) s1436; const SWord32 s1505 = table4[s1504]; const SWord32 s1506 = s1503 ^ s1505; const SWord32 s1507 = s17 ^ s1506; const SWord16 s1508 = (SWord16) s1507; const SWord8 s1509 = (SWord8) s1508; const SWord32 s1510 = table4[s1509]; const SWord32 s1511 = s1495 ^ s1510; const SWord32 s1512 = s20 ^ s1511; const SWord16 s1513 = (SWord16) (s1512 >> 16); const SWord8 s1514 = (SWord8) (s1513 >> 8); const SWord32 s1515 = table1[s1514]; const SWord8 s1516 = (SWord8) (s1474 >> 8); const SWord32 s1517 = table1[s1516]; const SWord16 s1518 = (SWord16) (s1491 >> 16); const SWord8 s1519 = (SWord8) s1518; const SWord32 s1520 = table2[s1519]; const SWord32 s1521 = s1517 ^ s1520; const SWord8 s1522 = (SWord8) (s1508 >> 8); const SWord32 s1523 = table3[s1522]; const SWord32 s1524 = s1521 ^ s1523; const SWord16 s1525 = (SWord16) s1456; const SWord8 s1526 = (SWord8) s1525; const SWord32 s1527 = table4[s1526]; const SWord32 s1528 = s1524 ^ s1527; const SWord32 s1529 = s23 ^ s1528; const SWord16 s1530 = (SWord16) (s1529 >> 16); const SWord8 s1531 = (SWord8) s1530; const SWord32 s1532 = table2[s1531]; const SWord32 s1533 = s1515 ^ s1532; const SWord8 s1534 = (SWord8) (s1518 >> 8); const SWord32 s1535 = table1[s1534]; const SWord16 s1536 = (SWord16) (s1507 >> 16); const SWord8 s1537 = (SWord8) s1536; const SWord32 s1538 = table2[s1537]; const SWord32 s1539 = s1535 ^ s1538; const SWord8 s1540 = (SWord8) (s1525 >> 8); const SWord32 s1541 = table3[s1540]; const SWord32 s1542 = s1539 ^ s1541; const SWord16 s1543 = (SWord16) s1473; const SWord8 s1544 = (SWord8) s1543; const SWord32 s1545 = table4[s1544]; const SWord32 s1546 = s1542 ^ s1545; const SWord32 s1547 = s22 ^ s1546; const SWord16 s1548 = (SWord16) s1547; const SWord8 s1549 = (SWord8) (s1548 >> 8); const SWord32 s1550 = table3[s1549]; const SWord32 s1551 = s1533 ^ s1550; const SWord8 s1552 = (SWord8) (s1536 >> 8); const SWord32 s1553 = table1[s1552]; const SWord8 s1554 = (SWord8) s1457; const SWord32 s1555 = table2[s1554]; const SWord32 s1556 = s1553 ^ s1555; const SWord8 s1557 = (SWord8) (s1543 >> 8); const SWord32 s1558 = table3[s1557]; const SWord32 s1559 = s1556 ^ s1558; const SWord8 s1560 = (SWord8) s1492; const SWord32 s1561 = table4[s1560]; const SWord32 s1562 = s1559 ^ s1561; const SWord32 s1563 = s21 ^ s1562; const SWord16 s1564 = (SWord16) s1563; const SWord8 s1565 = (SWord8) s1564; const SWord32 s1566 = table4[s1565]; const SWord32 s1567 = s1551 ^ s1566; const SWord32 s1568 = s24 ^ s1567; const SWord16 s1569 = (SWord16) (s1568 >> 16); const SWord8 s1570 = (SWord8) (s1569 >> 8); const SWord32 s1571 = table1[s1570]; const SWord8 s1572 = (SWord8) (s1530 >> 8); const SWord32 s1573 = table1[s1572]; const SWord16 s1574 = (SWord16) (s1547 >> 16); const SWord8 s1575 = (SWord8) s1574; const SWord32 s1576 = table2[s1575]; const SWord32 s1577 = s1573 ^ s1576; const SWord8 s1578 = (SWord8) (s1564 >> 8); const SWord32 s1579 = table3[s1578]; const SWord32 s1580 = s1577 ^ s1579; const SWord16 s1581 = (SWord16) s1512; const SWord8 s1582 = (SWord8) s1581; const SWord32 s1583 = table4[s1582]; const SWord32 s1584 = s1580 ^ s1583; const SWord32 s1585 = s27 ^ s1584; const SWord16 s1586 = (SWord16) (s1585 >> 16); const SWord8 s1587 = (SWord8) s1586; const SWord32 s1588 = table2[s1587]; const SWord32 s1589 = s1571 ^ s1588; const SWord8 s1590 = (SWord8) (s1574 >> 8); const SWord32 s1591 = table1[s1590]; const SWord16 s1592 = (SWord16) (s1563 >> 16); const SWord8 s1593 = (SWord8) s1592; const SWord32 s1594 = table2[s1593]; const SWord32 s1595 = s1591 ^ s1594; const SWord8 s1596 = (SWord8) (s1581 >> 8); const SWord32 s1597 = table3[s1596]; const SWord32 s1598 = s1595 ^ s1597; const SWord16 s1599 = (SWord16) s1529; const SWord8 s1600 = (SWord8) s1599; const SWord32 s1601 = table4[s1600]; const SWord32 s1602 = s1598 ^ s1601; const SWord32 s1603 = s26 ^ s1602; const SWord16 s1604 = (SWord16) s1603; const SWord8 s1605 = (SWord8) (s1604 >> 8); const SWord32 s1606 = table3[s1605]; const SWord32 s1607 = s1589 ^ s1606; const SWord8 s1608 = (SWord8) (s1592 >> 8); const SWord32 s1609 = table1[s1608]; const SWord8 s1610 = (SWord8) s1513; const SWord32 s1611 = table2[s1610]; const SWord32 s1612 = s1609 ^ s1611; const SWord8 s1613 = (SWord8) (s1599 >> 8); const SWord32 s1614 = table3[s1613]; const SWord32 s1615 = s1612 ^ s1614; const SWord8 s1616 = (SWord8) s1548; const SWord32 s1617 = table4[s1616]; const SWord32 s1618 = s1615 ^ s1617; const SWord32 s1619 = s25 ^ s1618; const SWord16 s1620 = (SWord16) s1619; const SWord8 s1621 = (SWord8) s1620; const SWord32 s1622 = table4[s1621]; const SWord32 s1623 = s1607 ^ s1622; const SWord32 s1624 = s28 ^ s1623; const SWord16 s1625 = (SWord16) (s1624 >> 16); const SWord8 s1626 = (SWord8) (s1625 >> 8); const SWord32 s1627 = table1[s1626]; const SWord8 s1628 = (SWord8) (s1586 >> 8); const SWord32 s1629 = table1[s1628]; const SWord16 s1630 = (SWord16) (s1603 >> 16); const SWord8 s1631 = (SWord8) s1630; const SWord32 s1632 = table2[s1631]; const SWord32 s1633 = s1629 ^ s1632; const SWord8 s1634 = (SWord8) (s1620 >> 8); const SWord32 s1635 = table3[s1634]; const SWord32 s1636 = s1633 ^ s1635; const SWord16 s1637 = (SWord16) s1568; const SWord8 s1638 = (SWord8) s1637; const SWord32 s1639 = table4[s1638]; const SWord32 s1640 = s1636 ^ s1639; const SWord32 s1641 = s31 ^ s1640; const SWord16 s1642 = (SWord16) (s1641 >> 16); const SWord8 s1643 = (SWord8) s1642; const SWord32 s1644 = table2[s1643]; const SWord32 s1645 = s1627 ^ s1644; const SWord8 s1646 = (SWord8) (s1630 >> 8); const SWord32 s1647 = table1[s1646]; const SWord16 s1648 = (SWord16) (s1619 >> 16); const SWord8 s1649 = (SWord8) s1648; const SWord32 s1650 = table2[s1649]; const SWord32 s1651 = s1647 ^ s1650; const SWord8 s1652 = (SWord8) (s1637 >> 8); const SWord32 s1653 = table3[s1652]; const SWord32 s1654 = s1651 ^ s1653; const SWord16 s1655 = (SWord16) s1585; const SWord8 s1656 = (SWord8) s1655; const SWord32 s1657 = table4[s1656]; const SWord32 s1658 = s1654 ^ s1657; const SWord32 s1659 = s30 ^ s1658; const SWord16 s1660 = (SWord16) s1659; const SWord8 s1661 = (SWord8) (s1660 >> 8); const SWord32 s1662 = table3[s1661]; const SWord32 s1663 = s1645 ^ s1662; const SWord8 s1664 = (SWord8) (s1648 >> 8); const SWord32 s1665 = table1[s1664]; const SWord8 s1666 = (SWord8) s1569; const SWord32 s1667 = table2[s1666]; const SWord32 s1668 = s1665 ^ s1667; const SWord8 s1669 = (SWord8) (s1655 >> 8); const SWord32 s1670 = table3[s1669]; const SWord32 s1671 = s1668 ^ s1670; const SWord8 s1672 = (SWord8) s1604; const SWord32 s1673 = table4[s1672]; const SWord32 s1674 = s1671 ^ s1673; const SWord32 s1675 = s29 ^ s1674; const SWord16 s1676 = (SWord16) s1675; const SWord8 s1677 = (SWord8) s1676; const SWord32 s1678 = table4[s1677]; const SWord32 s1679 = s1663 ^ s1678; const SWord32 s1680 = s32 ^ s1679; const SWord16 s1681 = (SWord16) (s1680 >> 16); const SWord8 s1682 = (SWord8) (s1681 >> 8); const SWord32 s1683 = table1[s1682]; const SWord8 s1684 = (SWord8) (s1642 >> 8); const SWord32 s1685 = table1[s1684]; const SWord16 s1686 = (SWord16) (s1659 >> 16); const SWord8 s1687 = (SWord8) s1686; const SWord32 s1688 = table2[s1687]; const SWord32 s1689 = s1685 ^ s1688; const SWord8 s1690 = (SWord8) (s1676 >> 8); const SWord32 s1691 = table3[s1690]; const SWord32 s1692 = s1689 ^ s1691; const SWord16 s1693 = (SWord16) s1624; const SWord8 s1694 = (SWord8) s1693; const SWord32 s1695 = table4[s1694]; const SWord32 s1696 = s1692 ^ s1695; const SWord32 s1697 = s35 ^ s1696; const SWord16 s1698 = (SWord16) (s1697 >> 16); const SWord8 s1699 = (SWord8) s1698; const SWord32 s1700 = table2[s1699]; const SWord32 s1701 = s1683 ^ s1700; const SWord8 s1702 = (SWord8) (s1686 >> 8); const SWord32 s1703 = table1[s1702]; const SWord16 s1704 = (SWord16) (s1675 >> 16); const SWord8 s1705 = (SWord8) s1704; const SWord32 s1706 = table2[s1705]; const SWord32 s1707 = s1703 ^ s1706; const SWord8 s1708 = (SWord8) (s1693 >> 8); const SWord32 s1709 = table3[s1708]; const SWord32 s1710 = s1707 ^ s1709; const SWord16 s1711 = (SWord16) s1641; const SWord8 s1712 = (SWord8) s1711; const SWord32 s1713 = table4[s1712]; const SWord32 s1714 = s1710 ^ s1713; const SWord32 s1715 = s34 ^ s1714; const SWord16 s1716 = (SWord16) s1715; const SWord8 s1717 = (SWord8) (s1716 >> 8); const SWord32 s1718 = table3[s1717]; const SWord32 s1719 = s1701 ^ s1718; const SWord8 s1720 = (SWord8) (s1704 >> 8); const SWord32 s1721 = table1[s1720]; const SWord8 s1722 = (SWord8) s1625; const SWord32 s1723 = table2[s1722]; const SWord32 s1724 = s1721 ^ s1723; const SWord8 s1725 = (SWord8) (s1711 >> 8); const SWord32 s1726 = table3[s1725]; const SWord32 s1727 = s1724 ^ s1726; const SWord8 s1728 = (SWord8) s1660; const SWord32 s1729 = table4[s1728]; const SWord32 s1730 = s1727 ^ s1729; const SWord32 s1731 = s33 ^ s1730; const SWord16 s1732 = (SWord16) s1731; const SWord8 s1733 = (SWord8) s1732; const SWord32 s1734 = table4[s1733]; const SWord32 s1735 = s1719 ^ s1734; const SWord32 s1736 = s36 ^ s1735; const SWord16 s1737 = (SWord16) (s1736 >> 16); const SWord8 s1738 = (SWord8) (s1737 >> 8); const SWord32 s1739 = table1[s1738]; const SWord8 s1740 = (SWord8) (s1698 >> 8); const SWord32 s1741 = table1[s1740]; const SWord16 s1742 = (SWord16) (s1715 >> 16); const SWord8 s1743 = (SWord8) s1742; const SWord32 s1744 = table2[s1743]; const SWord32 s1745 = s1741 ^ s1744; const SWord8 s1746 = (SWord8) (s1732 >> 8); const SWord32 s1747 = table3[s1746]; const SWord32 s1748 = s1745 ^ s1747; const SWord16 s1749 = (SWord16) s1680; const SWord8 s1750 = (SWord8) s1749; const SWord32 s1751 = table4[s1750]; const SWord32 s1752 = s1748 ^ s1751; const SWord32 s1753 = s39 ^ s1752; const SWord16 s1754 = (SWord16) (s1753 >> 16); const SWord8 s1755 = (SWord8) s1754; const SWord32 s1756 = table2[s1755]; const SWord32 s1757 = s1739 ^ s1756; const SWord8 s1758 = (SWord8) (s1742 >> 8); const SWord32 s1759 = table1[s1758]; const SWord16 s1760 = (SWord16) (s1731 >> 16); const SWord8 s1761 = (SWord8) s1760; const SWord32 s1762 = table2[s1761]; const SWord32 s1763 = s1759 ^ s1762; const SWord8 s1764 = (SWord8) (s1749 >> 8); const SWord32 s1765 = table3[s1764]; const SWord32 s1766 = s1763 ^ s1765; const SWord16 s1767 = (SWord16) s1697; const SWord8 s1768 = (SWord8) s1767; const SWord32 s1769 = table4[s1768]; const SWord32 s1770 = s1766 ^ s1769; const SWord32 s1771 = s38 ^ s1770; const SWord16 s1772 = (SWord16) s1771; const SWord8 s1773 = (SWord8) (s1772 >> 8); const SWord32 s1774 = table3[s1773]; const SWord32 s1775 = s1757 ^ s1774; const SWord8 s1776 = (SWord8) (s1760 >> 8); const SWord32 s1777 = table1[s1776]; const SWord8 s1778 = (SWord8) s1681; const SWord32 s1779 = table2[s1778]; const SWord32 s1780 = s1777 ^ s1779; const SWord8 s1781 = (SWord8) (s1767 >> 8); const SWord32 s1782 = table3[s1781]; const SWord32 s1783 = s1780 ^ s1782; const SWord8 s1784 = (SWord8) s1716; const SWord32 s1785 = table4[s1784]; const SWord32 s1786 = s1783 ^ s1785; const SWord32 s1787 = s37 ^ s1786; const SWord16 s1788 = (SWord16) s1787; const SWord8 s1789 = (SWord8) s1788; const SWord32 s1790 = table4[s1789]; const SWord32 s1791 = s1775 ^ s1790; const SWord32 s1792 = s40 ^ s1791; const SWord16 s1793 = (SWord16) (s1792 >> 16); const SWord8 s1794 = (SWord8) (s1793 >> 8); const SWord8 s1795 = table0[s1794]; const SWord8 s1796 = (SWord8) (s1754 >> 8); const SWord32 s1797 = table1[s1796]; const SWord16 s1798 = (SWord16) (s1771 >> 16); const SWord8 s1799 = (SWord8) s1798; const SWord32 s1800 = table2[s1799]; const SWord32 s1801 = s1797 ^ s1800; const SWord8 s1802 = (SWord8) (s1788 >> 8); const SWord32 s1803 = table3[s1802]; const SWord32 s1804 = s1801 ^ s1803; const SWord16 s1805 = (SWord16) s1736; const SWord8 s1806 = (SWord8) s1805; const SWord32 s1807 = table4[s1806]; const SWord32 s1808 = s1804 ^ s1807; const SWord32 s1809 = s43 ^ s1808; const SWord16 s1810 = (SWord16) (s1809 >> 16); const SWord8 s1811 = (SWord8) s1810; const SWord8 s1812 = table0[s1811]; const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812); const SWord8 s1814 = (SWord8) (s1798 >> 8); const SWord32 s1815 = table1[s1814]; const SWord16 s1816 = (SWord16) (s1787 >> 16); const SWord8 s1817 = (SWord8) s1816; const SWord32 s1818 = table2[s1817]; const SWord32 s1819 = s1815 ^ s1818; const SWord8 s1820 = (SWord8) (s1805 >> 8); const SWord32 s1821 = table3[s1820]; const SWord32 s1822 = s1819 ^ s1821; const SWord16 s1823 = (SWord16) s1753; const SWord8 s1824 = (SWord8) s1823; const SWord32 s1825 = table4[s1824]; const SWord32 s1826 = s1822 ^ s1825; const SWord32 s1827 = s42 ^ s1826; const SWord16 s1828 = (SWord16) s1827; const SWord8 s1829 = (SWord8) (s1828 >> 8); const SWord8 s1830 = table0[s1829]; const SWord8 s1831 = (SWord8) (s1816 >> 8); const SWord32 s1832 = table1[s1831]; const SWord8 s1833 = (SWord8) s1737; const SWord32 s1834 = table2[s1833]; const SWord32 s1835 = s1832 ^ s1834; const SWord8 s1836 = (SWord8) (s1823 >> 8); const SWord32 s1837 = table3[s1836]; const SWord32 s1838 = s1835 ^ s1837; const SWord8 s1839 = (SWord8) s1772; const SWord32 s1840 = table4[s1839]; const SWord32 s1841 = s1838 ^ s1840; const SWord32 s1842 = s41 ^ s1841; const SWord16 s1843 = (SWord16) s1842; const SWord8 s1844 = (SWord8) s1843; const SWord8 s1845 = table0[s1844]; const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845); const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846); const SWord32 s1848 = s44 ^ s1847; const SWord16 s1849 = (SWord16) (s1842 >> 16); const SWord8 s1850 = (SWord8) (s1849 >> 8); const SWord8 s1851 = table0[s1850]; const SWord8 s1852 = (SWord8) s1793; const SWord8 s1853 = table0[s1852]; const SWord16 s1854 = (((SWord16) s1851) << 8) | ((SWord16) s1853); const SWord16 s1855 = (SWord16) s1809; const SWord8 s1856 = (SWord8) (s1855 >> 8); const SWord8 s1857 = table0[s1856]; const SWord8 s1858 = (SWord8) s1828; const SWord8 s1859 = table0[s1858]; const SWord16 s1860 = (((SWord16) s1857) << 8) | ((SWord16) s1859); const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860); const SWord32 s1862 = s45 ^ s1861; const SWord16 s1863 = (SWord16) (s1827 >> 16); const SWord8 s1864 = (SWord8) (s1863 >> 8); const SWord8 s1865 = table0[s1864]; const SWord8 s1866 = (SWord8) s1849; const SWord8 s1867 = table0[s1866]; const SWord16 s1868 = (((SWord16) s1865) << 8) | ((SWord16) s1867); const SWord16 s1869 = (SWord16) s1792; const SWord8 s1870 = (SWord8) (s1869 >> 8); const SWord8 s1871 = table0[s1870]; const SWord8 s1872 = (SWord8) s1855; const SWord8 s1873 = table0[s1872]; const SWord16 s1874 = (((SWord16) s1871) << 8) | ((SWord16) s1873); const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874); const SWord32 s1876 = s46 ^ s1875; const SWord8 s1877 = (SWord8) (s1810 >> 8); const SWord8 s1878 = table0[s1877]; const SWord8 s1879 = (SWord8) s1863; const SWord8 s1880 = table0[s1879]; const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880); const SWord8 s1882 = (SWord8) (s1843 >> 8); const SWord8 s1883 = table0[s1882]; const SWord8 s1884 = (SWord8) s1869; const SWord8 s1885 = table0[s1884]; const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885); const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886); const SWord32 s1888 = s47 ^ s1887; pt[0] = s1848; pt[1] = s1862; pt[2] = s1876; pt[3] = s1888; } == END: "aes128BlockDecrypt.c" ================== == BEGIN: "aes128Lib.h" ================ /* Header file for aes128Lib. Automatically generated by SBV. Do not edit! */ #ifndef __aes128Lib__HEADER_INCLUDED__ #define __aes128Lib__HEADER_INCLUDED__ #include #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); #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[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]); SWord32 encKS[44]; SWord32 decKS[44]; aes128KeySchedule(key, encKS, decKS); printf("aes128KeySchedule(key, encKS, decKS) ->\n"); int encKS_ctr; for(encKS_ctr = 0; encKS_ctr < 44 ; ++encKS_ctr) printf(" encKS[%d] = 0x%08"PRIx32"UL\n", encKS_ctr ,encKS[encKS_ctr]); int decKS_ctr; for(decKS_ctr = 0; decKS_ctr < 44 ; ++decKS_ctr) printf(" decKS[%d] = 0x%08"PRIx32"UL\n", decKS_ctr ,decKS[decKS_ctr]); } void aes128BlockEncrypt_driver(void) { const SWord32 pt[4] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array pt:\n"); int pt_ctr; for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr) printf(" pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]); const SWord32 xkey[44] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array xkey:\n"); int xkey_ctr; for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr) printf(" xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]); SWord32 ct[4]; aes128BlockEncrypt(pt, xkey, ct); printf("aes128BlockEncrypt(pt, xkey, ct) ->\n"); int ct_ctr; for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr) printf(" ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); } void aes128BlockDecrypt_driver(void) { const SWord32 ct[4] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array ct:\n"); int ct_ctr; for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr) printf(" ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]); const SWord32 xkey[44] = { 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL }; printf("Contents of input array xkey:\n"); int xkey_ctr; for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr) printf(" xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]); SWord32 pt[4]; aes128BlockDecrypt(ct, xkey, pt); printf("aes128BlockDecrypt(ct, xkey, pt) ->\n"); int pt_ctr; for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr) printf(" pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]); } int main(void) { printf("====================================\n"); printf("** Driver run for aes128KeySchedule:\n"); printf("====================================\n"); aes128KeySchedule_driver(); printf("=====================================\n"); printf("** Driver run for aes128BlockEncrypt:\n"); printf("=====================================\n"); aes128BlockEncrypt_driver(); printf("=====================================\n"); printf("** Driver run for aes128BlockDecrypt:\n"); printf("=====================================\n"); aes128BlockDecrypt_driver(); return 0; } == END: "aes128Lib_driver.c" ================== == BEGIN: "Makefile" ================ # Makefile for aes128Lib. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer AR?=ar ARFLAGS?=cr all: aes128Lib.a aes128Lib_driver aes128Lib.a: aes128KeySchedule.o aes128BlockEncrypt.o aes128BlockDecrypt.o ${AR} ${ARFLAGS} $@ $^ aes128Lib_driver: aes128Lib_driver.c aes128Lib.h ${CC} ${CCFLAGS} $< -o $@ aes128Lib.a aes128KeySchedule.o: aes128KeySchedule.c aes128Lib.h ${CC} ${CCFLAGS} -c $< -o $@ aes128BlockEncrypt.o: aes128BlockEncrypt.c aes128Lib.h ${CC} ${CCFLAGS} -c $< -o $@ aes128BlockDecrypt.o: aes128BlockDecrypt.c aes128Lib.h ${CC} ${CCFLAGS} -c $< -o $@ clean: rm -f *.o veryclean: clean rm -f aes128Lib.a aes128Lib_driver == END: "Makefile" ==================sbv-5.12/SBVUnitTest/GoldFiles/auf-1.gold0000644000000000000000000000137412725411266016216 0ustar0000000000000000INPUTS s0 :: SWord32, existential, aliasing "x" s1 :: SWord32, existential, aliasing "y" s2 :: SWord32, existential, aliasing "initVal" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s3 = 2 :: Word32 s9 = 3 :: Word32 s13 = 1 :: Word32 TABLES ARRAYS UNINTERPRETED CONSTANTS [uninterpreted] f :: SWord32 -> SWord64 USER GIVEN CODE SEGMENTS AXIOMS DEFINE s4 :: SWord32 = s0 + s3 s5 :: SBool = s1 == s4 s6 :: SBool = ~ s5 s7 :: SWord32 = s1 - s3 s8 :: SBool = s0 == s7 s10 :: SWord32 = if s8 then s9 else s2 s11 :: SWord64 = [uninterpreted] f s10 s12 :: SWord32 = s1 - s0 s14 :: SWord32 = s12 + s13 s15 :: SWord64 = [uninterpreted] f s14 s16 :: SBool = s11 == s15 s17 :: SBool = s6 | s16 CONSTRAINTS ASSERTIONS OUTPUTS s17sbv-5.12/SBVUnitTest/GoldFiles/basic-1_1.gold0000644000000000000000000000001212725411266016730 0ustar00000000000000005 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-1_2.gold0000644000000000000000000000001212725411266016731 0ustar00000000000000005 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-1_3.gold0000644000000000000000000000001312725411266016733 0ustar000000000000000025 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-1_4.gold0000644000000000000000000000001312725411266016734 0ustar000000000000000025 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-1_5.gold0000644000000000000000000000001212725411266016734 0ustar00000000000000004 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-2_1.gold0000644000000000000000000000044612725411266016744 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 3 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s1 - s0 s4 :: SWord8 = s2 * s3 CONSTRAINTS ASSERTIONS OUTPUTS s4sbv-5.12/SBVUnitTest/GoldFiles/basic-2_2.gold0000644000000000000000000000041512725411266016741 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 9 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 * s0 s3 :: SWord8 = s1 - s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-2_3.gold0000644000000000000000000000041512725411266016742 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 3 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-2_4.gold0000644000000000000000000000041512725411266016743 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 3 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-2_5.gold0000644000000000000000000000001212725411266016735 0ustar00000000000000004 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/basic-3_1.gold0000644000000000000000000000046112725411266016742 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s0 - s1 s4 :: SWord8 = s2 * s3 CONSTRAINTS ASSERTIONS OUTPUTS s4sbv-5.12/SBVUnitTest/GoldFiles/basic-3_2.gold0000644000000000000000000000046112725411266016743 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 * s0 s3 :: SWord8 = s1 * s1 s4 :: SWord8 = s2 - s3 CONSTRAINTS ASSERTIONS OUTPUTS s4sbv-5.12/SBVUnitTest/GoldFiles/basic-3_3.gold0000644000000000000000000000043012725411266016740 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-3_4.gold0000644000000000000000000000043012725411266016741 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-3_5.gold0000644000000000000000000000042112725411266016742 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "y" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s2 = 1 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s3 :: SWord8 = s0 + s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-4_1.gold0000644000000000000000000000042412725411266016742 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s1 :: SWord8 = s0 + s0 s2 :: SWord8 = s0 - s0 s3 :: SWord8 = s1 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s3sbv-5.12/SBVUnitTest/GoldFiles/basic-4_2.gold0000644000000000000000000000037312725411266016746 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s1 :: SWord8 = s0 * s0 s2 :: SWord8 = s1 - s1 CONSTRAINTS ASSERTIONS OUTPUTS s2sbv-5.12/SBVUnitTest/GoldFiles/basic-4_3.gold0000644000000000000000000000037312725411266016747 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s1 :: SWord8 = s0 + s0 s2 :: SWord8 = s1 * s1 CONSTRAINTS ASSERTIONS OUTPUTS s2sbv-5.12/SBVUnitTest/GoldFiles/basic-4_4.gold0000644000000000000000000000037312725411266016750 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s1 :: SWord8 = s0 + s0 s2 :: SWord8 = s1 * s1 CONSTRAINTS ASSERTIONS OUTPUTS s2sbv-5.12/SBVUnitTest/GoldFiles/basic-4_5.gold0000644000000000000000000000036412725411266016751 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 1 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s1 CONSTRAINTS ASSERTIONS OUTPUTS s2sbv-5.12/SBVUnitTest/GoldFiles/basic-5_1.gold0000644000000000000000000000046612725411266016751 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "q" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s0 s3 :: SWord8 = s0 - s0 s4 :: SWord8 = s2 * s3 CONSTRAINTS ASSERTIONS OUTPUTS s1 s4sbv-5.12/SBVUnitTest/GoldFiles/basic-5_2.gold0000644000000000000000000000043512725411266016746 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "q" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 * s0 s3 :: SWord8 = s2 - s2 CONSTRAINTS ASSERTIONS OUTPUTS s1 s3sbv-5.12/SBVUnitTest/GoldFiles/basic-5_3.gold0000644000000000000000000000043512725411266016747 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "q" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s0 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s1 s3sbv-5.12/SBVUnitTest/GoldFiles/basic-5_4.gold0000644000000000000000000000043512725411266016750 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "q" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SWord8 = s0 + s0 s3 :: SWord8 = s2 * s2 CONSTRAINTS ASSERTIONS OUTPUTS s1 s3sbv-5.12/SBVUnitTest/GoldFiles/basic-5_5.gold0000644000000000000000000000042612725411266016751 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" s1 :: SWord8, aliasing "q" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s2 = 1 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s3 :: SWord8 = s0 + s2 CONSTRAINTS ASSERTIONS OUTPUTS s1 s3sbv-5.12/SBVUnitTest/GoldFiles/ccitt.gold0000644000000000000000000020156712725411266016421 0ustar0000000000000000INPUTS s0 :: SWord32 s1 :: SWord16 s2 :: SWord32 s3 :: SWord16 CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s13 = 0 :: Word1 s1686 = 0 :: Word8 s1687 = 1 :: Word8 s1815 = 3 :: Word8 s9 = 0 :: Word16 s525 = 1 :: Word64 s526 = 0 :: Word64 s528 = 2 :: Word64 s531 = 4 :: Word64 s534 = 8 :: Word64 s537 = 16 :: Word64 s540 = 32 :: Word64 s543 = 64 :: Word64 s546 = 128 :: Word64 s549 = 256 :: Word64 s552 = 512 :: Word64 s555 = 1024 :: Word64 s558 = 2048 :: Word64 s561 = 4096 :: Word64 s564 = 8192 :: Word64 s567 = 16384 :: Word64 s570 = 32768 :: Word64 s573 = 65536 :: Word64 s576 = 131072 :: Word64 s579 = 262144 :: Word64 s582 = 524288 :: Word64 s585 = 1048576 :: Word64 s588 = 2097152 :: Word64 s591 = 4194304 :: Word64 s594 = 8388608 :: Word64 s597 = 16777216 :: Word64 s600 = 33554432 :: Word64 s603 = 67108864 :: Word64 s606 = 134217728 :: Word64 s609 = 268435456 :: Word64 s612 = 536870912 :: Word64 s615 = 1073741824 :: Word64 s618 = 2147483648 :: Word64 s621 = 4294967296 :: Word64 s624 = 8589934592 :: Word64 s627 = 17179869184 :: Word64 s630 = 34359738368 :: Word64 s633 = 68719476736 :: Word64 s636 = 137438953472 :: Word64 s639 = 274877906944 :: Word64 s642 = 549755813888 :: Word64 s645 = 1099511627776 :: Word64 s648 = 2199023255552 :: Word64 s651 = 4398046511104 :: Word64 s654 = 8796093022208 :: Word64 s657 = 17592186044416 :: Word64 s660 = 35184372088832 :: Word64 s663 = 70368744177664 :: Word64 s666 = 140737488355328 :: Word64 s669 = 281474976710656 :: Word64 s672 = 562949953421312 :: Word64 s675 = 1125899906842624 :: Word64 s678 = 2251799813685248 :: Word64 s681 = 4503599627370496 :: Word64 s684 = 9007199254740992 :: Word64 s687 = 18014398509481984 :: Word64 s690 = 36028797018963968 :: Word64 s693 = 72057594037927936 :: Word64 s696 = 144115188075855872 :: Word64 s699 = 288230376151711744 :: Word64 s702 = 576460752303423488 :: Word64 s705 = 1152921504606846976 :: Word64 s708 = 2305843009213693952 :: Word64 s711 = 4611686018427387904 :: Word64 s714 = 9223372036854775808 :: Word64 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s4 :: SBool = s0 == s2 s5 :: SBool = s1 == s3 s6 :: SBool = s4 & s5 s7 :: SBool = ~ s6 s8 :: SBool = ~ s7 s10 :: SWord32 = s1 # s9 s11 :: SWord64 = s0 # s10 s12 :: SWord1 = choose [63:63] s11 s14 :: SBool = s12 /= s13 s15 :: SWord1 = choose [62:62] s11 s16 :: SBool = s13 /= s15 s17 :: SWord1 = choose [61:61] s11 s18 :: SBool = s13 /= s17 s19 :: SWord1 = choose [60:60] s11 s20 :: SBool = s13 /= s19 s21 :: SWord1 = choose [59:59] s11 s22 :: SBool = s13 /= s21 s23 :: SBool = ~ s22 s24 :: SBool = if s14 then s23 else s22 s25 :: SWord1 = choose [58:58] s11 s26 :: SBool = s13 /= s25 s27 :: SBool = ~ s26 s28 :: SBool = if s16 then s27 else s26 s29 :: SWord1 = choose [57:57] s11 s30 :: SBool = s13 /= s29 s31 :: SBool = ~ s30 s32 :: SBool = if s18 then s31 else s30 s33 :: SWord1 = choose [56:56] s11 s34 :: SBool = s13 /= s33 s35 :: SBool = ~ s34 s36 :: SBool = if s20 then s35 else s34 s37 :: SWord1 = choose [55:55] s11 s38 :: SBool = s13 /= s37 s39 :: SBool = ~ s38 s40 :: SBool = if s24 then s39 else s38 s41 :: SWord1 = choose [54:54] s11 s42 :: SBool = s13 /= s41 s43 :: SBool = ~ s42 s44 :: SBool = if s28 then s43 else s42 s45 :: SWord1 = choose [53:53] s11 s46 :: SBool = s13 /= s45 s47 :: SBool = ~ s46 s48 :: SBool = if s32 then s47 else s46 s49 :: SWord1 = choose [52:52] s11 s50 :: SBool = s13 /= s49 s51 :: SBool = ~ s50 s52 :: SBool = if s14 then s51 else s50 s53 :: SBool = ~ s52 s54 :: SBool = if s36 then s53 else s52 s55 :: SWord1 = choose [51:51] s11 s56 :: SBool = s13 /= s55 s57 :: SBool = ~ s56 s58 :: SBool = if s16 then s57 else s56 s59 :: SBool = ~ s58 s60 :: SBool = if s40 then s59 else s58 s61 :: SWord1 = choose [50:50] s11 s62 :: SBool = s13 /= s61 s63 :: SBool = ~ s62 s64 :: SBool = if s18 then s63 else s62 s65 :: SBool = ~ s64 s66 :: SBool = if s44 then s65 else s64 s67 :: SWord1 = choose [49:49] s11 s68 :: SBool = s13 /= s67 s69 :: SBool = ~ s68 s70 :: SBool = if s20 then s69 else s68 s71 :: SBool = ~ s70 s72 :: SBool = if s48 then s71 else s70 s73 :: SWord1 = choose [48:48] s11 s74 :: SBool = s13 /= s73 s75 :: SBool = ~ s74 s76 :: SBool = if s24 then s75 else s74 s77 :: SBool = ~ s76 s78 :: SBool = if s54 then s77 else s76 s79 :: SWord1 = choose [47:47] s11 s80 :: SBool = s13 /= s79 s81 :: SBool = ~ s80 s82 :: SBool = if s14 then s81 else s80 s83 :: SBool = ~ s82 s84 :: SBool = if s28 then s83 else s82 s85 :: SBool = ~ s84 s86 :: SBool = if s60 then s85 else s84 s87 :: SWord1 = choose [46:46] s11 s88 :: SBool = s13 /= s87 s89 :: SBool = ~ s88 s90 :: SBool = if s16 then s89 else s88 s91 :: SBool = ~ s90 s92 :: SBool = if s32 then s91 else s90 s93 :: SBool = ~ s92 s94 :: SBool = if s66 then s93 else s92 s95 :: SWord1 = choose [45:45] s11 s96 :: SBool = s13 /= s95 s97 :: SBool = ~ s96 s98 :: SBool = if s18 then s97 else s96 s99 :: SBool = ~ s98 s100 :: SBool = if s36 then s99 else s98 s101 :: SBool = ~ s100 s102 :: SBool = if s72 then s101 else s100 s103 :: SWord1 = choose [44:44] s11 s104 :: SBool = s13 /= s103 s105 :: SBool = ~ s104 s106 :: SBool = if s20 then s105 else s104 s107 :: SBool = ~ s106 s108 :: SBool = if s40 then s107 else s106 s109 :: SBool = ~ s108 s110 :: SBool = if s78 then s109 else s108 s111 :: SWord1 = choose [43:43] s11 s112 :: SBool = s13 /= s111 s113 :: SBool = ~ s112 s114 :: SBool = if s24 then s113 else s112 s115 :: SBool = ~ s114 s116 :: SBool = if s44 then s115 else s114 s117 :: SBool = ~ s116 s118 :: SBool = if s86 then s117 else s116 s119 :: SWord1 = choose [42:42] s11 s120 :: SBool = s13 /= s119 s121 :: SBool = ~ s120 s122 :: SBool = if s28 then s121 else s120 s123 :: SBool = ~ s122 s124 :: SBool = if s48 then s123 else s122 s125 :: SBool = ~ s124 s126 :: SBool = if s94 then s125 else s124 s127 :: SWord1 = choose [41:41] s11 s128 :: SBool = s13 /= s127 s129 :: SBool = ~ s128 s130 :: SBool = if s32 then s129 else s128 s131 :: SBool = ~ s130 s132 :: SBool = if s54 then s131 else s130 s133 :: SBool = ~ s132 s134 :: SBool = if s102 then s133 else s132 s135 :: SWord1 = choose [40:40] s11 s136 :: SBool = s13 /= s135 s137 :: SBool = ~ s136 s138 :: SBool = if s36 then s137 else s136 s139 :: SBool = ~ s138 s140 :: SBool = if s60 then s139 else s138 s141 :: SBool = ~ s140 s142 :: SBool = if s110 then s141 else s140 s143 :: SWord1 = choose [39:39] s11 s144 :: SBool = s13 /= s143 s145 :: SBool = ~ s144 s146 :: SBool = if s40 then s145 else s144 s147 :: SBool = ~ s146 s148 :: SBool = if s66 then s147 else s146 s149 :: SBool = ~ s148 s150 :: SBool = if s118 then s149 else s148 s151 :: SWord1 = choose [38:38] s11 s152 :: SBool = s13 /= s151 s153 :: SBool = ~ s152 s154 :: SBool = if s44 then s153 else s152 s155 :: SBool = ~ s154 s156 :: SBool = if s72 then s155 else s154 s157 :: SBool = ~ s156 s158 :: SBool = if s126 then s157 else s156 s159 :: SWord1 = choose [37:37] s11 s160 :: SBool = s13 /= s159 s161 :: SBool = ~ s160 s162 :: SBool = if s48 then s161 else s160 s163 :: SBool = ~ s162 s164 :: SBool = if s78 then s163 else s162 s165 :: SBool = ~ s164 s166 :: SBool = if s134 then s165 else s164 s167 :: SWord1 = choose [36:36] s11 s168 :: SBool = s13 /= s167 s169 :: SBool = ~ s168 s170 :: SBool = if s54 then s169 else s168 s171 :: SBool = ~ s170 s172 :: SBool = if s86 then s171 else s170 s173 :: SBool = ~ s172 s174 :: SBool = if s142 then s173 else s172 s175 :: SWord1 = choose [35:35] s11 s176 :: SBool = s13 /= s175 s177 :: SBool = ~ s176 s178 :: SBool = if s60 then s177 else s176 s179 :: SBool = ~ s178 s180 :: SBool = if s94 then s179 else s178 s181 :: SBool = ~ s180 s182 :: SBool = if s150 then s181 else s180 s183 :: SWord1 = choose [34:34] s11 s184 :: SBool = s13 /= s183 s185 :: SBool = ~ s184 s186 :: SBool = if s66 then s185 else s184 s187 :: SBool = ~ s186 s188 :: SBool = if s102 then s187 else s186 s189 :: SBool = ~ s188 s190 :: SBool = if s158 then s189 else s188 s191 :: SWord1 = choose [33:33] s11 s192 :: SBool = s13 /= s191 s193 :: SBool = ~ s192 s194 :: SBool = if s72 then s193 else s192 s195 :: SBool = ~ s194 s196 :: SBool = if s110 then s195 else s194 s197 :: SBool = ~ s196 s198 :: SBool = if s166 then s197 else s196 s199 :: SWord1 = choose [32:32] s11 s200 :: SBool = s13 /= s199 s201 :: SBool = ~ s200 s202 :: SBool = if s78 then s201 else s200 s203 :: SBool = ~ s202 s204 :: SBool = if s118 then s203 else s202 s205 :: SBool = ~ s204 s206 :: SBool = if s174 then s205 else s204 s207 :: SWord1 = choose [31:31] s11 s208 :: SBool = s13 /= s207 s209 :: SBool = ~ s208 s210 :: SBool = if s86 then s209 else s208 s211 :: SBool = ~ s210 s212 :: SBool = if s126 then s211 else s210 s213 :: SBool = ~ s212 s214 :: SBool = if s182 then s213 else s212 s215 :: SWord1 = choose [30:30] s11 s216 :: SBool = s13 /= s215 s217 :: SBool = ~ s216 s218 :: SBool = if s94 then s217 else s216 s219 :: SBool = ~ s218 s220 :: SBool = if s134 then s219 else s218 s221 :: SBool = ~ s220 s222 :: SBool = if s190 then s221 else s220 s223 :: SWord1 = choose [29:29] s11 s224 :: SBool = s13 /= s223 s225 :: SBool = ~ s224 s226 :: SBool = if s102 then s225 else s224 s227 :: SBool = ~ s226 s228 :: SBool = if s142 then s227 else s226 s229 :: SBool = ~ s228 s230 :: SBool = if s198 then s229 else s228 s231 :: SWord1 = choose [28:28] s11 s232 :: SBool = s13 /= s231 s233 :: SBool = ~ s232 s234 :: SBool = if s110 then s233 else s232 s235 :: SBool = ~ s234 s236 :: SBool = if s150 then s235 else s234 s237 :: SBool = ~ s236 s238 :: SBool = if s206 then s237 else s236 s239 :: SWord1 = choose [27:27] s11 s240 :: SBool = s13 /= s239 s241 :: SBool = ~ s240 s242 :: SBool = if s118 then s241 else s240 s243 :: SBool = ~ s242 s244 :: SBool = if s158 then s243 else s242 s245 :: SBool = ~ s244 s246 :: SBool = if s214 then s245 else s244 s247 :: SWord1 = choose [26:26] s11 s248 :: SBool = s13 /= s247 s249 :: SBool = ~ s248 s250 :: SBool = if s126 then s249 else s248 s251 :: SBool = ~ s250 s252 :: SBool = if s166 then s251 else s250 s253 :: SBool = ~ s252 s254 :: SBool = if s222 then s253 else s252 s255 :: SWord1 = choose [25:25] s11 s256 :: SBool = s13 /= s255 s257 :: SBool = ~ s256 s258 :: SBool = if s134 then s257 else s256 s259 :: SBool = ~ s258 s260 :: SBool = if s174 then s259 else s258 s261 :: SBool = ~ s260 s262 :: SBool = if s230 then s261 else s260 s263 :: SWord1 = choose [24:24] s11 s264 :: SBool = s13 /= s263 s265 :: SBool = ~ s264 s266 :: SBool = if s142 then s265 else s264 s267 :: SBool = ~ s266 s268 :: SBool = if s182 then s267 else s266 s269 :: SBool = ~ s268 s270 :: SBool = if s238 then s269 else s268 s271 :: SWord1 = choose [23:23] s11 s272 :: SBool = s13 /= s271 s273 :: SBool = ~ s272 s274 :: SBool = if s150 then s273 else s272 s275 :: SBool = ~ s274 s276 :: SBool = if s190 then s275 else s274 s277 :: SBool = ~ s276 s278 :: SBool = if s246 then s277 else s276 s279 :: SWord1 = choose [22:22] s11 s280 :: SBool = s13 /= s279 s281 :: SBool = ~ s280 s282 :: SBool = if s158 then s281 else s280 s283 :: SBool = ~ s282 s284 :: SBool = if s198 then s283 else s282 s285 :: SBool = ~ s284 s286 :: SBool = if s254 then s285 else s284 s287 :: SWord1 = choose [21:21] s11 s288 :: SBool = s13 /= s287 s289 :: SBool = ~ s288 s290 :: SBool = if s166 then s289 else s288 s291 :: SBool = ~ s290 s292 :: SBool = if s206 then s291 else s290 s293 :: SBool = ~ s292 s294 :: SBool = if s262 then s293 else s292 s295 :: SWord1 = choose [20:20] s11 s296 :: SBool = s13 /= s295 s297 :: SBool = ~ s296 s298 :: SBool = if s174 then s297 else s296 s299 :: SBool = ~ s298 s300 :: SBool = if s214 then s299 else s298 s301 :: SBool = ~ s300 s302 :: SBool = if s270 then s301 else s300 s303 :: SWord1 = choose [19:19] s11 s304 :: SBool = s13 /= s303 s305 :: SBool = ~ s304 s306 :: SBool = if s182 then s305 else s304 s307 :: SBool = ~ s306 s308 :: SBool = if s222 then s307 else s306 s309 :: SBool = ~ s308 s310 :: SBool = if s278 then s309 else s308 s311 :: SWord1 = choose [18:18] s11 s312 :: SBool = s13 /= s311 s313 :: SBool = ~ s312 s314 :: SBool = if s190 then s313 else s312 s315 :: SBool = ~ s314 s316 :: SBool = if s230 then s315 else s314 s317 :: SBool = ~ s316 s318 :: SBool = if s286 then s317 else s316 s319 :: SWord1 = choose [17:17] s11 s320 :: SBool = s13 /= s319 s321 :: SBool = ~ s320 s322 :: SBool = if s198 then s321 else s320 s323 :: SBool = ~ s322 s324 :: SBool = if s238 then s323 else s322 s325 :: SBool = ~ s324 s326 :: SBool = if s294 then s325 else s324 s327 :: SWord1 = choose [16:16] s11 s328 :: SBool = s13 /= s327 s329 :: SBool = ~ s328 s330 :: SBool = if s206 then s329 else s328 s331 :: SBool = ~ s330 s332 :: SBool = if s246 then s331 else s330 s333 :: SBool = ~ s332 s334 :: SBool = if s302 then s333 else s332 s335 :: SBool = ~ s14 s336 :: SBool = if s14 then s335 else s14 s337 :: SBool = ~ s16 s338 :: SBool = if s16 then s337 else s16 s339 :: SBool = ~ s18 s340 :: SBool = if s18 then s339 else s18 s341 :: SBool = ~ s20 s342 :: SBool = if s20 then s341 else s20 s343 :: SBool = ~ s24 s344 :: SBool = if s24 then s343 else s24 s345 :: SBool = ~ s28 s346 :: SBool = if s28 then s345 else s28 s347 :: SBool = ~ s32 s348 :: SBool = if s32 then s347 else s32 s349 :: SBool = ~ s36 s350 :: SBool = if s36 then s349 else s36 s351 :: SBool = ~ s40 s352 :: SBool = if s40 then s351 else s40 s353 :: SBool = ~ s44 s354 :: SBool = if s44 then s353 else s44 s355 :: SBool = ~ s48 s356 :: SBool = if s48 then s355 else s48 s357 :: SBool = ~ s54 s358 :: SBool = if s54 then s357 else s54 s359 :: SBool = ~ s60 s360 :: SBool = if s60 then s359 else s60 s361 :: SBool = ~ s66 s362 :: SBool = if s66 then s361 else s66 s363 :: SBool = ~ s72 s364 :: SBool = if s72 then s363 else s72 s365 :: SBool = ~ s78 s366 :: SBool = if s78 then s365 else s78 s367 :: SBool = ~ s86 s368 :: SBool = if s86 then s367 else s86 s369 :: SBool = ~ s94 s370 :: SBool = if s94 then s369 else s94 s371 :: SBool = ~ s102 s372 :: SBool = if s102 then s371 else s102 s373 :: SBool = ~ s110 s374 :: SBool = if s110 then s373 else s110 s375 :: SBool = ~ s118 s376 :: SBool = if s118 then s375 else s118 s377 :: SBool = ~ s126 s378 :: SBool = if s126 then s377 else s126 s379 :: SBool = ~ s134 s380 :: SBool = if s134 then s379 else s134 s381 :: SBool = ~ s142 s382 :: SBool = if s142 then s381 else s142 s383 :: SBool = ~ s150 s384 :: SBool = if s150 then s383 else s150 s385 :: SBool = ~ s158 s386 :: SBool = if s158 then s385 else s158 s387 :: SBool = ~ s166 s388 :: SBool = if s166 then s387 else s166 s389 :: SBool = ~ s174 s390 :: SBool = if s174 then s389 else s174 s391 :: SBool = ~ s182 s392 :: SBool = if s182 then s391 else s182 s393 :: SBool = ~ s190 s394 :: SBool = if s190 then s393 else s190 s395 :: SBool = ~ s198 s396 :: SBool = if s198 then s395 else s198 s397 :: SBool = ~ s206 s398 :: SBool = if s206 then s397 else s206 s399 :: SBool = ~ s214 s400 :: SBool = if s214 then s399 else s214 s401 :: SBool = ~ s222 s402 :: SBool = if s222 then s401 else s222 s403 :: SBool = ~ s230 s404 :: SBool = if s230 then s403 else s230 s405 :: SBool = ~ s238 s406 :: SBool = if s238 then s405 else s238 s407 :: SBool = ~ s246 s408 :: SBool = if s246 then s407 else s246 s409 :: SBool = ~ s254 s410 :: SBool = if s254 then s409 else s254 s411 :: SBool = ~ s262 s412 :: SBool = if s262 then s411 else s262 s413 :: SBool = ~ s270 s414 :: SBool = if s270 then s413 else s270 s415 :: SBool = ~ s278 s416 :: SBool = if s278 then s415 else s278 s417 :: SBool = ~ s286 s418 :: SBool = if s286 then s417 else s286 s419 :: SBool = ~ s294 s420 :: SBool = if s294 then s419 else s294 s421 :: SBool = ~ s302 s422 :: SBool = if s302 then s421 else s302 s423 :: SBool = ~ s310 s424 :: SBool = if s310 then s423 else s310 s425 :: SBool = ~ s318 s426 :: SBool = if s318 then s425 else s318 s427 :: SBool = ~ s326 s428 :: SBool = if s326 then s427 else s326 s429 :: SBool = ~ s334 s430 :: SBool = if s334 then s429 else s334 s431 :: SWord1 = choose [15:15] s11 s432 :: SBool = s13 /= s431 s433 :: SBool = ~ s432 s434 :: SBool = if s214 then s433 else s432 s435 :: SBool = ~ s434 s436 :: SBool = if s254 then s435 else s434 s437 :: SBool = ~ s436 s438 :: SBool = if s310 then s437 else s436 s439 :: SWord1 = choose [14:14] s11 s440 :: SBool = s13 /= s439 s441 :: SBool = ~ s440 s442 :: SBool = if s222 then s441 else s440 s443 :: SBool = ~ s442 s444 :: SBool = if s262 then s443 else s442 s445 :: SBool = ~ s444 s446 :: SBool = if s318 then s445 else s444 s447 :: SWord1 = choose [13:13] s11 s448 :: SBool = s13 /= s447 s449 :: SBool = ~ s448 s450 :: SBool = if s230 then s449 else s448 s451 :: SBool = ~ s450 s452 :: SBool = if s270 then s451 else s450 s453 :: SBool = ~ s452 s454 :: SBool = if s326 then s453 else s452 s455 :: SWord1 = choose [12:12] s11 s456 :: SBool = s13 /= s455 s457 :: SBool = ~ s456 s458 :: SBool = if s238 then s457 else s456 s459 :: SBool = ~ s458 s460 :: SBool = if s278 then s459 else s458 s461 :: SBool = ~ s460 s462 :: SBool = if s334 then s461 else s460 s463 :: SWord1 = choose [11:11] s11 s464 :: SBool = s13 /= s463 s465 :: SBool = ~ s464 s466 :: SBool = if s246 then s465 else s464 s467 :: SBool = ~ s466 s468 :: SBool = if s286 then s467 else s466 s469 :: SWord1 = choose [10:10] s11 s470 :: SBool = s13 /= s469 s471 :: SBool = ~ s470 s472 :: SBool = if s254 then s471 else s470 s473 :: SBool = ~ s472 s474 :: SBool = if s294 then s473 else s472 s475 :: SWord1 = choose [9:9] s11 s476 :: SBool = s13 /= s475 s477 :: SBool = ~ s476 s478 :: SBool = if s262 then s477 else s476 s479 :: SBool = ~ s478 s480 :: SBool = if s302 then s479 else s478 s481 :: SWord1 = choose [8:8] s11 s482 :: SBool = s13 /= s481 s483 :: SBool = ~ s482 s484 :: SBool = if s270 then s483 else s482 s485 :: SBool = ~ s484 s486 :: SBool = if s310 then s485 else s484 s487 :: SWord1 = choose [7:7] s11 s488 :: SBool = s13 /= s487 s489 :: SBool = ~ s488 s490 :: SBool = if s278 then s489 else s488 s491 :: SBool = ~ s490 s492 :: SBool = if s318 then s491 else s490 s493 :: SWord1 = choose [6:6] s11 s494 :: SBool = s13 /= s493 s495 :: SBool = ~ s494 s496 :: SBool = if s286 then s495 else s494 s497 :: SBool = ~ s496 s498 :: SBool = if s326 then s497 else s496 s499 :: SWord1 = choose [5:5] s11 s500 :: SBool = s13 /= s499 s501 :: SBool = ~ s500 s502 :: SBool = if s294 then s501 else s500 s503 :: SBool = ~ s502 s504 :: SBool = if s334 then s503 else s502 s505 :: SWord1 = choose [4:4] s11 s506 :: SBool = s13 /= s505 s507 :: SBool = ~ s506 s508 :: SBool = if s302 then s507 else s506 s509 :: SWord1 = choose [3:3] s11 s510 :: SBool = s13 /= s509 s511 :: SBool = ~ s510 s512 :: SBool = if s310 then s511 else s510 s513 :: SWord1 = choose [2:2] s11 s514 :: SBool = s13 /= s513 s515 :: SBool = ~ s514 s516 :: SBool = if s318 then s515 else s514 s517 :: SWord1 = choose [1:1] s11 s518 :: SBool = s13 /= s517 s519 :: SBool = ~ s518 s520 :: SBool = if s326 then s519 else s518 s521 :: SWord1 = choose [0:0] s11 s522 :: SBool = s13 /= s521 s523 :: SBool = ~ s522 s524 :: SBool = if s334 then s523 else s522 s527 :: SWord64 = if s524 then s525 else s526 s529 :: SWord64 = s527 | s528 s530 :: SWord64 = if s520 then s529 else s527 s532 :: SWord64 = s530 | s531 s533 :: SWord64 = if s516 then s532 else s530 s535 :: SWord64 = s533 | s534 s536 :: SWord64 = if s512 then s535 else s533 s538 :: SWord64 = s536 | s537 s539 :: SWord64 = if s508 then s538 else s536 s541 :: SWord64 = s539 | s540 s542 :: SWord64 = if s504 then s541 else s539 s544 :: SWord64 = s542 | s543 s545 :: SWord64 = if s498 then s544 else s542 s547 :: SWord64 = s545 | s546 s548 :: SWord64 = if s492 then s547 else s545 s550 :: SWord64 = s548 | s549 s551 :: SWord64 = if s486 then s550 else s548 s553 :: SWord64 = s551 | s552 s554 :: SWord64 = if s480 then s553 else s551 s556 :: SWord64 = s554 | s555 s557 :: SWord64 = if s474 then s556 else s554 s559 :: SWord64 = s557 | s558 s560 :: SWord64 = if s468 then s559 else s557 s562 :: SWord64 = s560 | s561 s563 :: SWord64 = if s462 then s562 else s560 s565 :: SWord64 = s563 | s564 s566 :: SWord64 = if s454 then s565 else s563 s568 :: SWord64 = s566 | s567 s569 :: SWord64 = if s446 then s568 else s566 s571 :: SWord64 = s569 | s570 s572 :: SWord64 = if s438 then s571 else s569 s574 :: SWord64 = s572 | s573 s575 :: SWord64 = if s430 then s574 else s572 s577 :: SWord64 = s575 | s576 s578 :: SWord64 = if s428 then s577 else s575 s580 :: SWord64 = s578 | s579 s581 :: SWord64 = if s426 then s580 else s578 s583 :: SWord64 = s581 | s582 s584 :: SWord64 = if s424 then s583 else s581 s586 :: SWord64 = s584 | s585 s587 :: SWord64 = if s422 then s586 else s584 s589 :: SWord64 = s587 | s588 s590 :: SWord64 = if s420 then s589 else s587 s592 :: SWord64 = s590 | s591 s593 :: SWord64 = if s418 then s592 else s590 s595 :: SWord64 = s593 | s594 s596 :: SWord64 = if s416 then s595 else s593 s598 :: SWord64 = s596 | s597 s599 :: SWord64 = if s414 then s598 else s596 s601 :: SWord64 = s599 | s600 s602 :: SWord64 = if s412 then s601 else s599 s604 :: SWord64 = s602 | s603 s605 :: SWord64 = if s410 then s604 else s602 s607 :: SWord64 = s605 | s606 s608 :: SWord64 = if s408 then s607 else s605 s610 :: SWord64 = s608 | s609 s611 :: SWord64 = if s406 then s610 else s608 s613 :: SWord64 = s611 | s612 s614 :: SWord64 = if s404 then s613 else s611 s616 :: SWord64 = s614 | s615 s617 :: SWord64 = if s402 then s616 else s614 s619 :: SWord64 = s617 | s618 s620 :: SWord64 = if s400 then s619 else s617 s622 :: SWord64 = s620 | s621 s623 :: SWord64 = if s398 then s622 else s620 s625 :: SWord64 = s623 | s624 s626 :: SWord64 = if s396 then s625 else s623 s628 :: SWord64 = s626 | s627 s629 :: SWord64 = if s394 then s628 else s626 s631 :: SWord64 = s629 | s630 s632 :: SWord64 = if s392 then s631 else s629 s634 :: SWord64 = s632 | s633 s635 :: SWord64 = if s390 then s634 else s632 s637 :: SWord64 = s635 | s636 s638 :: SWord64 = if s388 then s637 else s635 s640 :: SWord64 = s638 | s639 s641 :: SWord64 = if s386 then s640 else s638 s643 :: SWord64 = s641 | s642 s644 :: SWord64 = if s384 then s643 else s641 s646 :: SWord64 = s644 | s645 s647 :: SWord64 = if s382 then s646 else s644 s649 :: SWord64 = s647 | s648 s650 :: SWord64 = if s380 then s649 else s647 s652 :: SWord64 = s650 | s651 s653 :: SWord64 = if s378 then s652 else s650 s655 :: SWord64 = s653 | s654 s656 :: SWord64 = if s376 then s655 else s653 s658 :: SWord64 = s656 | s657 s659 :: SWord64 = if s374 then s658 else s656 s661 :: SWord64 = s659 | s660 s662 :: SWord64 = if s372 then s661 else s659 s664 :: SWord64 = s662 | s663 s665 :: SWord64 = if s370 then s664 else s662 s667 :: SWord64 = s665 | s666 s668 :: SWord64 = if s368 then s667 else s665 s670 :: SWord64 = s668 | s669 s671 :: SWord64 = if s366 then s670 else s668 s673 :: SWord64 = s671 | s672 s674 :: SWord64 = if s364 then s673 else s671 s676 :: SWord64 = s674 | s675 s677 :: SWord64 = if s362 then s676 else s674 s679 :: SWord64 = s677 | s678 s680 :: SWord64 = if s360 then s679 else s677 s682 :: SWord64 = s680 | s681 s683 :: SWord64 = if s358 then s682 else s680 s685 :: SWord64 = s683 | s684 s686 :: SWord64 = if s356 then s685 else s683 s688 :: SWord64 = s686 | s687 s689 :: SWord64 = if s354 then s688 else s686 s691 :: SWord64 = s689 | s690 s692 :: SWord64 = if s352 then s691 else s689 s694 :: SWord64 = s692 | s693 s695 :: SWord64 = if s350 then s694 else s692 s697 :: SWord64 = s695 | s696 s698 :: SWord64 = if s348 then s697 else s695 s700 :: SWord64 = s698 | s699 s701 :: SWord64 = if s346 then s700 else s698 s703 :: SWord64 = s701 | s702 s704 :: SWord64 = if s344 then s703 else s701 s706 :: SWord64 = s704 | s705 s707 :: SWord64 = if s342 then s706 else s704 s709 :: SWord64 = s707 | s708 s710 :: SWord64 = if s340 then s709 else s707 s712 :: SWord64 = s710 | s711 s713 :: SWord64 = if s338 then s712 else s710 s715 :: SWord64 = s713 | s714 s716 :: SWord64 = if s336 then s715 else s713 s717 :: SWord32 = choose [31:0] s716 s718 :: SWord16 = choose [15:0] s717 s719 :: SWord32 = s1 # s718 s720 :: SWord64 = s0 # s719 s721 :: SWord1 = choose [0:0] s720 s722 :: SBool = s13 /= s721 s723 :: SWord32 = s3 # s9 s724 :: SWord64 = s2 # s723 s725 :: SWord1 = choose [63:63] s724 s726 :: SBool = s13 /= s725 s727 :: SWord1 = choose [62:62] s724 s728 :: SBool = s13 /= s727 s729 :: SWord1 = choose [61:61] s724 s730 :: SBool = s13 /= s729 s731 :: SWord1 = choose [60:60] s724 s732 :: SBool = s13 /= s731 s733 :: SWord1 = choose [59:59] s724 s734 :: SBool = s13 /= s733 s735 :: SBool = ~ s734 s736 :: SBool = if s726 then s735 else s734 s737 :: SWord1 = choose [58:58] s724 s738 :: SBool = s13 /= s737 s739 :: SBool = ~ s738 s740 :: SBool = if s728 then s739 else s738 s741 :: SWord1 = choose [57:57] s724 s742 :: SBool = s13 /= s741 s743 :: SBool = ~ s742 s744 :: SBool = if s730 then s743 else s742 s745 :: SWord1 = choose [56:56] s724 s746 :: SBool = s13 /= s745 s747 :: SBool = ~ s746 s748 :: SBool = if s732 then s747 else s746 s749 :: SWord1 = choose [55:55] s724 s750 :: SBool = s13 /= s749 s751 :: SBool = ~ s750 s752 :: SBool = if s736 then s751 else s750 s753 :: SWord1 = choose [54:54] s724 s754 :: SBool = s13 /= s753 s755 :: SBool = ~ s754 s756 :: SBool = if s740 then s755 else s754 s757 :: SWord1 = choose [53:53] s724 s758 :: SBool = s13 /= s757 s759 :: SBool = ~ s758 s760 :: SBool = if s744 then s759 else s758 s761 :: SWord1 = choose [52:52] s724 s762 :: SBool = s13 /= s761 s763 :: SBool = ~ s762 s764 :: SBool = if s726 then s763 else s762 s765 :: SBool = ~ s764 s766 :: SBool = if s748 then s765 else s764 s767 :: SWord1 = choose [51:51] s724 s768 :: SBool = s13 /= s767 s769 :: SBool = ~ s768 s770 :: SBool = if s728 then s769 else s768 s771 :: SBool = ~ s770 s772 :: SBool = if s752 then s771 else s770 s773 :: SWord1 = choose [50:50] s724 s774 :: SBool = s13 /= s773 s775 :: SBool = ~ s774 s776 :: SBool = if s730 then s775 else s774 s777 :: SBool = ~ s776 s778 :: SBool = if s756 then s777 else s776 s779 :: SWord1 = choose [49:49] s724 s780 :: SBool = s13 /= s779 s781 :: SBool = ~ s780 s782 :: SBool = if s732 then s781 else s780 s783 :: SBool = ~ s782 s784 :: SBool = if s760 then s783 else s782 s785 :: SWord1 = choose [48:48] s724 s786 :: SBool = s13 /= s785 s787 :: SBool = ~ s786 s788 :: SBool = if s736 then s787 else s786 s789 :: SBool = ~ s788 s790 :: SBool = if s766 then s789 else s788 s791 :: SWord1 = choose [47:47] s724 s792 :: SBool = s13 /= s791 s793 :: SBool = ~ s792 s794 :: SBool = if s726 then s793 else s792 s795 :: SBool = ~ s794 s796 :: SBool = if s740 then s795 else s794 s797 :: SBool = ~ s796 s798 :: SBool = if s772 then s797 else s796 s799 :: SWord1 = choose [46:46] s724 s800 :: SBool = s13 /= s799 s801 :: SBool = ~ s800 s802 :: SBool = if s728 then s801 else s800 s803 :: SBool = ~ s802 s804 :: SBool = if s744 then s803 else s802 s805 :: SBool = ~ s804 s806 :: SBool = if s778 then s805 else s804 s807 :: SWord1 = choose [45:45] s724 s808 :: SBool = s13 /= s807 s809 :: SBool = ~ s808 s810 :: SBool = if s730 then s809 else s808 s811 :: SBool = ~ s810 s812 :: SBool = if s748 then s811 else s810 s813 :: SBool = ~ s812 s814 :: SBool = if s784 then s813 else s812 s815 :: SWord1 = choose [44:44] s724 s816 :: SBool = s13 /= s815 s817 :: SBool = ~ s816 s818 :: SBool = if s732 then s817 else s816 s819 :: SBool = ~ s818 s820 :: SBool = if s752 then s819 else s818 s821 :: SBool = ~ s820 s822 :: SBool = if s790 then s821 else s820 s823 :: SWord1 = choose [43:43] s724 s824 :: SBool = s13 /= s823 s825 :: SBool = ~ s824 s826 :: SBool = if s736 then s825 else s824 s827 :: SBool = ~ s826 s828 :: SBool = if s756 then s827 else s826 s829 :: SBool = ~ s828 s830 :: SBool = if s798 then s829 else s828 s831 :: SWord1 = choose [42:42] s724 s832 :: SBool = s13 /= s831 s833 :: SBool = ~ s832 s834 :: SBool = if s740 then s833 else s832 s835 :: SBool = ~ s834 s836 :: SBool = if s760 then s835 else s834 s837 :: SBool = ~ s836 s838 :: SBool = if s806 then s837 else s836 s839 :: SWord1 = choose [41:41] s724 s840 :: SBool = s13 /= s839 s841 :: SBool = ~ s840 s842 :: SBool = if s744 then s841 else s840 s843 :: SBool = ~ s842 s844 :: SBool = if s766 then s843 else s842 s845 :: SBool = ~ s844 s846 :: SBool = if s814 then s845 else s844 s847 :: SWord1 = choose [40:40] s724 s848 :: SBool = s13 /= s847 s849 :: SBool = ~ s848 s850 :: SBool = if s748 then s849 else s848 s851 :: SBool = ~ s850 s852 :: SBool = if s772 then s851 else s850 s853 :: SBool = ~ s852 s854 :: SBool = if s822 then s853 else s852 s855 :: SWord1 = choose [39:39] s724 s856 :: SBool = s13 /= s855 s857 :: SBool = ~ s856 s858 :: SBool = if s752 then s857 else s856 s859 :: SBool = ~ s858 s860 :: SBool = if s778 then s859 else s858 s861 :: SBool = ~ s860 s862 :: SBool = if s830 then s861 else s860 s863 :: SWord1 = choose [38:38] s724 s864 :: SBool = s13 /= s863 s865 :: SBool = ~ s864 s866 :: SBool = if s756 then s865 else s864 s867 :: SBool = ~ s866 s868 :: SBool = if s784 then s867 else s866 s869 :: SBool = ~ s868 s870 :: SBool = if s838 then s869 else s868 s871 :: SWord1 = choose [37:37] s724 s872 :: SBool = s13 /= s871 s873 :: SBool = ~ s872 s874 :: SBool = if s760 then s873 else s872 s875 :: SBool = ~ s874 s876 :: SBool = if s790 then s875 else s874 s877 :: SBool = ~ s876 s878 :: SBool = if s846 then s877 else s876 s879 :: SWord1 = choose [36:36] s724 s880 :: SBool = s13 /= s879 s881 :: SBool = ~ s880 s882 :: SBool = if s766 then s881 else s880 s883 :: SBool = ~ s882 s884 :: SBool = if s798 then s883 else s882 s885 :: SBool = ~ s884 s886 :: SBool = if s854 then s885 else s884 s887 :: SWord1 = choose [35:35] s724 s888 :: SBool = s13 /= s887 s889 :: SBool = ~ s888 s890 :: SBool = if s772 then s889 else s888 s891 :: SBool = ~ s890 s892 :: SBool = if s806 then s891 else s890 s893 :: SBool = ~ s892 s894 :: SBool = if s862 then s893 else s892 s895 :: SWord1 = choose [34:34] s724 s896 :: SBool = s13 /= s895 s897 :: SBool = ~ s896 s898 :: SBool = if s778 then s897 else s896 s899 :: SBool = ~ s898 s900 :: SBool = if s814 then s899 else s898 s901 :: SBool = ~ s900 s902 :: SBool = if s870 then s901 else s900 s903 :: SWord1 = choose [33:33] s724 s904 :: SBool = s13 /= s903 s905 :: SBool = ~ s904 s906 :: SBool = if s784 then s905 else s904 s907 :: SBool = ~ s906 s908 :: SBool = if s822 then s907 else s906 s909 :: SBool = ~ s908 s910 :: SBool = if s878 then s909 else s908 s911 :: SWord1 = choose [32:32] s724 s912 :: SBool = s13 /= s911 s913 :: SBool = ~ s912 s914 :: SBool = if s790 then s913 else s912 s915 :: SBool = ~ s914 s916 :: SBool = if s830 then s915 else s914 s917 :: SBool = ~ s916 s918 :: SBool = if s886 then s917 else s916 s919 :: SWord1 = choose [31:31] s724 s920 :: SBool = s13 /= s919 s921 :: SBool = ~ s920 s922 :: SBool = if s798 then s921 else s920 s923 :: SBool = ~ s922 s924 :: SBool = if s838 then s923 else s922 s925 :: SBool = ~ s924 s926 :: SBool = if s894 then s925 else s924 s927 :: SWord1 = choose [30:30] s724 s928 :: SBool = s13 /= s927 s929 :: SBool = ~ s928 s930 :: SBool = if s806 then s929 else s928 s931 :: SBool = ~ s930 s932 :: SBool = if s846 then s931 else s930 s933 :: SBool = ~ s932 s934 :: SBool = if s902 then s933 else s932 s935 :: SWord1 = choose [29:29] s724 s936 :: SBool = s13 /= s935 s937 :: SBool = ~ s936 s938 :: SBool = if s814 then s937 else s936 s939 :: SBool = ~ s938 s940 :: SBool = if s854 then s939 else s938 s941 :: SBool = ~ s940 s942 :: SBool = if s910 then s941 else s940 s943 :: SWord1 = choose [28:28] s724 s944 :: SBool = s13 /= s943 s945 :: SBool = ~ s944 s946 :: SBool = if s822 then s945 else s944 s947 :: SBool = ~ s946 s948 :: SBool = if s862 then s947 else s946 s949 :: SBool = ~ s948 s950 :: SBool = if s918 then s949 else s948 s951 :: SWord1 = choose [27:27] s724 s952 :: SBool = s13 /= s951 s953 :: SBool = ~ s952 s954 :: SBool = if s830 then s953 else s952 s955 :: SBool = ~ s954 s956 :: SBool = if s870 then s955 else s954 s957 :: SBool = ~ s956 s958 :: SBool = if s926 then s957 else s956 s959 :: SWord1 = choose [26:26] s724 s960 :: SBool = s13 /= s959 s961 :: SBool = ~ s960 s962 :: SBool = if s838 then s961 else s960 s963 :: SBool = ~ s962 s964 :: SBool = if s878 then s963 else s962 s965 :: SBool = ~ s964 s966 :: SBool = if s934 then s965 else s964 s967 :: SWord1 = choose [25:25] s724 s968 :: SBool = s13 /= s967 s969 :: SBool = ~ s968 s970 :: SBool = if s846 then s969 else s968 s971 :: SBool = ~ s970 s972 :: SBool = if s886 then s971 else s970 s973 :: SBool = ~ s972 s974 :: SBool = if s942 then s973 else s972 s975 :: SWord1 = choose [24:24] s724 s976 :: SBool = s13 /= s975 s977 :: SBool = ~ s976 s978 :: SBool = if s854 then s977 else s976 s979 :: SBool = ~ s978 s980 :: SBool = if s894 then s979 else s978 s981 :: SBool = ~ s980 s982 :: SBool = if s950 then s981 else s980 s983 :: SWord1 = choose [23:23] s724 s984 :: SBool = s13 /= s983 s985 :: SBool = ~ s984 s986 :: SBool = if s862 then s985 else s984 s987 :: SBool = ~ s986 s988 :: SBool = if s902 then s987 else s986 s989 :: SBool = ~ s988 s990 :: SBool = if s958 then s989 else s988 s991 :: SWord1 = choose [22:22] s724 s992 :: SBool = s13 /= s991 s993 :: SBool = ~ s992 s994 :: SBool = if s870 then s993 else s992 s995 :: SBool = ~ s994 s996 :: SBool = if s910 then s995 else s994 s997 :: SBool = ~ s996 s998 :: SBool = if s966 then s997 else s996 s999 :: SWord1 = choose [21:21] s724 s1000 :: SBool = s13 /= s999 s1001 :: SBool = ~ s1000 s1002 :: SBool = if s878 then s1001 else s1000 s1003 :: SBool = ~ s1002 s1004 :: SBool = if s918 then s1003 else s1002 s1005 :: SBool = ~ s1004 s1006 :: SBool = if s974 then s1005 else s1004 s1007 :: SWord1 = choose [20:20] s724 s1008 :: SBool = s13 /= s1007 s1009 :: SBool = ~ s1008 s1010 :: SBool = if s886 then s1009 else s1008 s1011 :: SBool = ~ s1010 s1012 :: SBool = if s926 then s1011 else s1010 s1013 :: SBool = ~ s1012 s1014 :: SBool = if s982 then s1013 else s1012 s1015 :: SWord1 = choose [19:19] s724 s1016 :: SBool = s13 /= s1015 s1017 :: SBool = ~ s1016 s1018 :: SBool = if s894 then s1017 else s1016 s1019 :: SBool = ~ s1018 s1020 :: SBool = if s934 then s1019 else s1018 s1021 :: SBool = ~ s1020 s1022 :: SBool = if s990 then s1021 else s1020 s1023 :: SWord1 = choose [18:18] s724 s1024 :: SBool = s13 /= s1023 s1025 :: SBool = ~ s1024 s1026 :: SBool = if s902 then s1025 else s1024 s1027 :: SBool = ~ s1026 s1028 :: SBool = if s942 then s1027 else s1026 s1029 :: SBool = ~ s1028 s1030 :: SBool = if s998 then s1029 else s1028 s1031 :: SWord1 = choose [17:17] s724 s1032 :: SBool = s13 /= s1031 s1033 :: SBool = ~ s1032 s1034 :: SBool = if s910 then s1033 else s1032 s1035 :: SBool = ~ s1034 s1036 :: SBool = if s950 then s1035 else s1034 s1037 :: SBool = ~ s1036 s1038 :: SBool = if s1006 then s1037 else s1036 s1039 :: SWord1 = choose [16:16] s724 s1040 :: SBool = s13 /= s1039 s1041 :: SBool = ~ s1040 s1042 :: SBool = if s918 then s1041 else s1040 s1043 :: SBool = ~ s1042 s1044 :: SBool = if s958 then s1043 else s1042 s1045 :: SBool = ~ s1044 s1046 :: SBool = if s1014 then s1045 else s1044 s1047 :: SBool = ~ s726 s1048 :: SBool = if s726 then s1047 else s726 s1049 :: SBool = ~ s728 s1050 :: SBool = if s728 then s1049 else s728 s1051 :: SBool = ~ s730 s1052 :: SBool = if s730 then s1051 else s730 s1053 :: SBool = ~ s732 s1054 :: SBool = if s732 then s1053 else s732 s1055 :: SBool = ~ s736 s1056 :: SBool = if s736 then s1055 else s736 s1057 :: SBool = ~ s740 s1058 :: SBool = if s740 then s1057 else s740 s1059 :: SBool = ~ s744 s1060 :: SBool = if s744 then s1059 else s744 s1061 :: SBool = ~ s748 s1062 :: SBool = if s748 then s1061 else s748 s1063 :: SBool = ~ s752 s1064 :: SBool = if s752 then s1063 else s752 s1065 :: SBool = ~ s756 s1066 :: SBool = if s756 then s1065 else s756 s1067 :: SBool = ~ s760 s1068 :: SBool = if s760 then s1067 else s760 s1069 :: SBool = ~ s766 s1070 :: SBool = if s766 then s1069 else s766 s1071 :: SBool = ~ s772 s1072 :: SBool = if s772 then s1071 else s772 s1073 :: SBool = ~ s778 s1074 :: SBool = if s778 then s1073 else s778 s1075 :: SBool = ~ s784 s1076 :: SBool = if s784 then s1075 else s784 s1077 :: SBool = ~ s790 s1078 :: SBool = if s790 then s1077 else s790 s1079 :: SBool = ~ s798 s1080 :: SBool = if s798 then s1079 else s798 s1081 :: SBool = ~ s806 s1082 :: SBool = if s806 then s1081 else s806 s1083 :: SBool = ~ s814 s1084 :: SBool = if s814 then s1083 else s814 s1085 :: SBool = ~ s822 s1086 :: SBool = if s822 then s1085 else s822 s1087 :: SBool = ~ s830 s1088 :: SBool = if s830 then s1087 else s830 s1089 :: SBool = ~ s838 s1090 :: SBool = if s838 then s1089 else s838 s1091 :: SBool = ~ s846 s1092 :: SBool = if s846 then s1091 else s846 s1093 :: SBool = ~ s854 s1094 :: SBool = if s854 then s1093 else s854 s1095 :: SBool = ~ s862 s1096 :: SBool = if s862 then s1095 else s862 s1097 :: SBool = ~ s870 s1098 :: SBool = if s870 then s1097 else s870 s1099 :: SBool = ~ s878 s1100 :: SBool = if s878 then s1099 else s878 s1101 :: SBool = ~ s886 s1102 :: SBool = if s886 then s1101 else s886 s1103 :: SBool = ~ s894 s1104 :: SBool = if s894 then s1103 else s894 s1105 :: SBool = ~ s902 s1106 :: SBool = if s902 then s1105 else s902 s1107 :: SBool = ~ s910 s1108 :: SBool = if s910 then s1107 else s910 s1109 :: SBool = ~ s918 s1110 :: SBool = if s918 then s1109 else s918 s1111 :: SBool = ~ s926 s1112 :: SBool = if s926 then s1111 else s926 s1113 :: SBool = ~ s934 s1114 :: SBool = if s934 then s1113 else s934 s1115 :: SBool = ~ s942 s1116 :: SBool = if s942 then s1115 else s942 s1117 :: SBool = ~ s950 s1118 :: SBool = if s950 then s1117 else s950 s1119 :: SBool = ~ s958 s1120 :: SBool = if s958 then s1119 else s958 s1121 :: SBool = ~ s966 s1122 :: SBool = if s966 then s1121 else s966 s1123 :: SBool = ~ s974 s1124 :: SBool = if s974 then s1123 else s974 s1125 :: SBool = ~ s982 s1126 :: SBool = if s982 then s1125 else s982 s1127 :: SBool = ~ s990 s1128 :: SBool = if s990 then s1127 else s990 s1129 :: SBool = ~ s998 s1130 :: SBool = if s998 then s1129 else s998 s1131 :: SBool = ~ s1006 s1132 :: SBool = if s1006 then s1131 else s1006 s1133 :: SBool = ~ s1014 s1134 :: SBool = if s1014 then s1133 else s1014 s1135 :: SBool = ~ s1022 s1136 :: SBool = if s1022 then s1135 else s1022 s1137 :: SBool = ~ s1030 s1138 :: SBool = if s1030 then s1137 else s1030 s1139 :: SBool = ~ s1038 s1140 :: SBool = if s1038 then s1139 else s1038 s1141 :: SBool = ~ s1046 s1142 :: SBool = if s1046 then s1141 else s1046 s1143 :: SWord1 = choose [15:15] s724 s1144 :: SBool = s13 /= s1143 s1145 :: SBool = ~ s1144 s1146 :: SBool = if s926 then s1145 else s1144 s1147 :: SBool = ~ s1146 s1148 :: SBool = if s966 then s1147 else s1146 s1149 :: SBool = ~ s1148 s1150 :: SBool = if s1022 then s1149 else s1148 s1151 :: SWord1 = choose [14:14] s724 s1152 :: SBool = s13 /= s1151 s1153 :: SBool = ~ s1152 s1154 :: SBool = if s934 then s1153 else s1152 s1155 :: SBool = ~ s1154 s1156 :: SBool = if s974 then s1155 else s1154 s1157 :: SBool = ~ s1156 s1158 :: SBool = if s1030 then s1157 else s1156 s1159 :: SWord1 = choose [13:13] s724 s1160 :: SBool = s13 /= s1159 s1161 :: SBool = ~ s1160 s1162 :: SBool = if s942 then s1161 else s1160 s1163 :: SBool = ~ s1162 s1164 :: SBool = if s982 then s1163 else s1162 s1165 :: SBool = ~ s1164 s1166 :: SBool = if s1038 then s1165 else s1164 s1167 :: SWord1 = choose [12:12] s724 s1168 :: SBool = s13 /= s1167 s1169 :: SBool = ~ s1168 s1170 :: SBool = if s950 then s1169 else s1168 s1171 :: SBool = ~ s1170 s1172 :: SBool = if s990 then s1171 else s1170 s1173 :: SBool = ~ s1172 s1174 :: SBool = if s1046 then s1173 else s1172 s1175 :: SWord1 = choose [11:11] s724 s1176 :: SBool = s13 /= s1175 s1177 :: SBool = ~ s1176 s1178 :: SBool = if s958 then s1177 else s1176 s1179 :: SBool = ~ s1178 s1180 :: SBool = if s998 then s1179 else s1178 s1181 :: SWord1 = choose [10:10] s724 s1182 :: SBool = s13 /= s1181 s1183 :: SBool = ~ s1182 s1184 :: SBool = if s966 then s1183 else s1182 s1185 :: SBool = ~ s1184 s1186 :: SBool = if s1006 then s1185 else s1184 s1187 :: SWord1 = choose [9:9] s724 s1188 :: SBool = s13 /= s1187 s1189 :: SBool = ~ s1188 s1190 :: SBool = if s974 then s1189 else s1188 s1191 :: SBool = ~ s1190 s1192 :: SBool = if s1014 then s1191 else s1190 s1193 :: SWord1 = choose [8:8] s724 s1194 :: SBool = s13 /= s1193 s1195 :: SBool = ~ s1194 s1196 :: SBool = if s982 then s1195 else s1194 s1197 :: SBool = ~ s1196 s1198 :: SBool = if s1022 then s1197 else s1196 s1199 :: SWord1 = choose [7:7] s724 s1200 :: SBool = s13 /= s1199 s1201 :: SBool = ~ s1200 s1202 :: SBool = if s990 then s1201 else s1200 s1203 :: SBool = ~ s1202 s1204 :: SBool = if s1030 then s1203 else s1202 s1205 :: SWord1 = choose [6:6] s724 s1206 :: SBool = s13 /= s1205 s1207 :: SBool = ~ s1206 s1208 :: SBool = if s998 then s1207 else s1206 s1209 :: SBool = ~ s1208 s1210 :: SBool = if s1038 then s1209 else s1208 s1211 :: SWord1 = choose [5:5] s724 s1212 :: SBool = s13 /= s1211 s1213 :: SBool = ~ s1212 s1214 :: SBool = if s1006 then s1213 else s1212 s1215 :: SBool = ~ s1214 s1216 :: SBool = if s1046 then s1215 else s1214 s1217 :: SWord1 = choose [4:4] s724 s1218 :: SBool = s13 /= s1217 s1219 :: SBool = ~ s1218 s1220 :: SBool = if s1014 then s1219 else s1218 s1221 :: SWord1 = choose [3:3] s724 s1222 :: SBool = s13 /= s1221 s1223 :: SBool = ~ s1222 s1224 :: SBool = if s1022 then s1223 else s1222 s1225 :: SWord1 = choose [2:2] s724 s1226 :: SBool = s13 /= s1225 s1227 :: SBool = ~ s1226 s1228 :: SBool = if s1030 then s1227 else s1226 s1229 :: SWord1 = choose [1:1] s724 s1230 :: SBool = s13 /= s1229 s1231 :: SBool = ~ s1230 s1232 :: SBool = if s1038 then s1231 else s1230 s1233 :: SWord1 = choose [0:0] s724 s1234 :: SBool = s13 /= s1233 s1235 :: SBool = ~ s1234 s1236 :: SBool = if s1046 then s1235 else s1234 s1237 :: SWord64 = if s1236 then s525 else s526 s1238 :: SWord64 = s528 | s1237 s1239 :: SWord64 = if s1232 then s1238 else s1237 s1240 :: SWord64 = s531 | s1239 s1241 :: SWord64 = if s1228 then s1240 else s1239 s1242 :: SWord64 = s534 | s1241 s1243 :: SWord64 = if s1224 then s1242 else s1241 s1244 :: SWord64 = s537 | s1243 s1245 :: SWord64 = if s1220 then s1244 else s1243 s1246 :: SWord64 = s540 | s1245 s1247 :: SWord64 = if s1216 then s1246 else s1245 s1248 :: SWord64 = s543 | s1247 s1249 :: SWord64 = if s1210 then s1248 else s1247 s1250 :: SWord64 = s546 | s1249 s1251 :: SWord64 = if s1204 then s1250 else s1249 s1252 :: SWord64 = s549 | s1251 s1253 :: SWord64 = if s1198 then s1252 else s1251 s1254 :: SWord64 = s552 | s1253 s1255 :: SWord64 = if s1192 then s1254 else s1253 s1256 :: SWord64 = s555 | s1255 s1257 :: SWord64 = if s1186 then s1256 else s1255 s1258 :: SWord64 = s558 | s1257 s1259 :: SWord64 = if s1180 then s1258 else s1257 s1260 :: SWord64 = s561 | s1259 s1261 :: SWord64 = if s1174 then s1260 else s1259 s1262 :: SWord64 = s564 | s1261 s1263 :: SWord64 = if s1166 then s1262 else s1261 s1264 :: SWord64 = s567 | s1263 s1265 :: SWord64 = if s1158 then s1264 else s1263 s1266 :: SWord64 = s570 | s1265 s1267 :: SWord64 = if s1150 then s1266 else s1265 s1268 :: SWord64 = s573 | s1267 s1269 :: SWord64 = if s1142 then s1268 else s1267 s1270 :: SWord64 = s576 | s1269 s1271 :: SWord64 = if s1140 then s1270 else s1269 s1272 :: SWord64 = s579 | s1271 s1273 :: SWord64 = if s1138 then s1272 else s1271 s1274 :: SWord64 = s582 | s1273 s1275 :: SWord64 = if s1136 then s1274 else s1273 s1276 :: SWord64 = s585 | s1275 s1277 :: SWord64 = if s1134 then s1276 else s1275 s1278 :: SWord64 = s588 | s1277 s1279 :: SWord64 = if s1132 then s1278 else s1277 s1280 :: SWord64 = s591 | s1279 s1281 :: SWord64 = if s1130 then s1280 else s1279 s1282 :: SWord64 = s594 | s1281 s1283 :: SWord64 = if s1128 then s1282 else s1281 s1284 :: SWord64 = s597 | s1283 s1285 :: SWord64 = if s1126 then s1284 else s1283 s1286 :: SWord64 = s600 | s1285 s1287 :: SWord64 = if s1124 then s1286 else s1285 s1288 :: SWord64 = s603 | s1287 s1289 :: SWord64 = if s1122 then s1288 else s1287 s1290 :: SWord64 = s606 | s1289 s1291 :: SWord64 = if s1120 then s1290 else s1289 s1292 :: SWord64 = s609 | s1291 s1293 :: SWord64 = if s1118 then s1292 else s1291 s1294 :: SWord64 = s612 | s1293 s1295 :: SWord64 = if s1116 then s1294 else s1293 s1296 :: SWord64 = s615 | s1295 s1297 :: SWord64 = if s1114 then s1296 else s1295 s1298 :: SWord64 = s618 | s1297 s1299 :: SWord64 = if s1112 then s1298 else s1297 s1300 :: SWord64 = s621 | s1299 s1301 :: SWord64 = if s1110 then s1300 else s1299 s1302 :: SWord64 = s624 | s1301 s1303 :: SWord64 = if s1108 then s1302 else s1301 s1304 :: SWord64 = s627 | s1303 s1305 :: SWord64 = if s1106 then s1304 else s1303 s1306 :: SWord64 = s630 | s1305 s1307 :: SWord64 = if s1104 then s1306 else s1305 s1308 :: SWord64 = s633 | s1307 s1309 :: SWord64 = if s1102 then s1308 else s1307 s1310 :: SWord64 = s636 | s1309 s1311 :: SWord64 = if s1100 then s1310 else s1309 s1312 :: SWord64 = s639 | s1311 s1313 :: SWord64 = if s1098 then s1312 else s1311 s1314 :: SWord64 = s642 | s1313 s1315 :: SWord64 = if s1096 then s1314 else s1313 s1316 :: SWord64 = s645 | s1315 s1317 :: SWord64 = if s1094 then s1316 else s1315 s1318 :: SWord64 = s648 | s1317 s1319 :: SWord64 = if s1092 then s1318 else s1317 s1320 :: SWord64 = s651 | s1319 s1321 :: SWord64 = if s1090 then s1320 else s1319 s1322 :: SWord64 = s654 | s1321 s1323 :: SWord64 = if s1088 then s1322 else s1321 s1324 :: SWord64 = s657 | s1323 s1325 :: SWord64 = if s1086 then s1324 else s1323 s1326 :: SWord64 = s660 | s1325 s1327 :: SWord64 = if s1084 then s1326 else s1325 s1328 :: SWord64 = s663 | s1327 s1329 :: SWord64 = if s1082 then s1328 else s1327 s1330 :: SWord64 = s666 | s1329 s1331 :: SWord64 = if s1080 then s1330 else s1329 s1332 :: SWord64 = s669 | s1331 s1333 :: SWord64 = if s1078 then s1332 else s1331 s1334 :: SWord64 = s672 | s1333 s1335 :: SWord64 = if s1076 then s1334 else s1333 s1336 :: SWord64 = s675 | s1335 s1337 :: SWord64 = if s1074 then s1336 else s1335 s1338 :: SWord64 = s678 | s1337 s1339 :: SWord64 = if s1072 then s1338 else s1337 s1340 :: SWord64 = s681 | s1339 s1341 :: SWord64 = if s1070 then s1340 else s1339 s1342 :: SWord64 = s684 | s1341 s1343 :: SWord64 = if s1068 then s1342 else s1341 s1344 :: SWord64 = s687 | s1343 s1345 :: SWord64 = if s1066 then s1344 else s1343 s1346 :: SWord64 = s690 | s1345 s1347 :: SWord64 = if s1064 then s1346 else s1345 s1348 :: SWord64 = s693 | s1347 s1349 :: SWord64 = if s1062 then s1348 else s1347 s1350 :: SWord64 = s696 | s1349 s1351 :: SWord64 = if s1060 then s1350 else s1349 s1352 :: SWord64 = s699 | s1351 s1353 :: SWord64 = if s1058 then s1352 else s1351 s1354 :: SWord64 = s702 | s1353 s1355 :: SWord64 = if s1056 then s1354 else s1353 s1356 :: SWord64 = s705 | s1355 s1357 :: SWord64 = if s1054 then s1356 else s1355 s1358 :: SWord64 = s708 | s1357 s1359 :: SWord64 = if s1052 then s1358 else s1357 s1360 :: SWord64 = s711 | s1359 s1361 :: SWord64 = if s1050 then s1360 else s1359 s1362 :: SWord64 = s714 | s1361 s1363 :: SWord64 = if s1048 then s1362 else s1361 s1364 :: SWord32 = choose [31:0] s1363 s1365 :: SWord16 = choose [15:0] s1364 s1366 :: SWord32 = s3 # s1365 s1367 :: SWord64 = s2 # s1366 s1368 :: SWord1 = choose [0:0] s1367 s1369 :: SBool = s13 /= s1368 s1370 :: SBool = s722 == s1369 s1371 :: SWord1 = choose [1:1] s720 s1372 :: SBool = s13 /= s1371 s1373 :: SWord1 = choose [1:1] s1367 s1374 :: SBool = s13 /= s1373 s1375 :: SBool = s1372 == s1374 s1376 :: SWord1 = choose [2:2] s720 s1377 :: SBool = s13 /= s1376 s1378 :: SWord1 = choose [2:2] s1367 s1379 :: SBool = s13 /= s1378 s1380 :: SBool = s1377 == s1379 s1381 :: SWord1 = choose [3:3] s720 s1382 :: SBool = s13 /= s1381 s1383 :: SWord1 = choose [3:3] s1367 s1384 :: SBool = s13 /= s1383 s1385 :: SBool = s1382 == s1384 s1386 :: SWord1 = choose [4:4] s720 s1387 :: SBool = s13 /= s1386 s1388 :: SWord1 = choose [4:4] s1367 s1389 :: SBool = s13 /= s1388 s1390 :: SBool = s1387 == s1389 s1391 :: SWord1 = choose [5:5] s720 s1392 :: SBool = s13 /= s1391 s1393 :: SWord1 = choose [5:5] s1367 s1394 :: SBool = s13 /= s1393 s1395 :: SBool = s1392 == s1394 s1396 :: SWord1 = choose [6:6] s720 s1397 :: SBool = s13 /= s1396 s1398 :: SWord1 = choose [6:6] s1367 s1399 :: SBool = s13 /= s1398 s1400 :: SBool = s1397 == s1399 s1401 :: SWord1 = choose [7:7] s720 s1402 :: SBool = s13 /= s1401 s1403 :: SWord1 = choose [7:7] s1367 s1404 :: SBool = s13 /= s1403 s1405 :: SBool = s1402 == s1404 s1406 :: SWord1 = choose [8:8] s720 s1407 :: SBool = s13 /= s1406 s1408 :: SWord1 = choose [8:8] s1367 s1409 :: SBool = s13 /= s1408 s1410 :: SBool = s1407 == s1409 s1411 :: SWord1 = choose [9:9] s720 s1412 :: SBool = s13 /= s1411 s1413 :: SWord1 = choose [9:9] s1367 s1414 :: SBool = s13 /= s1413 s1415 :: SBool = s1412 == s1414 s1416 :: SWord1 = choose [10:10] s720 s1417 :: SBool = s13 /= s1416 s1418 :: SWord1 = choose [10:10] s1367 s1419 :: SBool = s13 /= s1418 s1420 :: SBool = s1417 == s1419 s1421 :: SWord1 = choose [11:11] s720 s1422 :: SBool = s13 /= s1421 s1423 :: SWord1 = choose [11:11] s1367 s1424 :: SBool = s13 /= s1423 s1425 :: SBool = s1422 == s1424 s1426 :: SWord1 = choose [12:12] s720 s1427 :: SBool = s13 /= s1426 s1428 :: SWord1 = choose [12:12] s1367 s1429 :: SBool = s13 /= s1428 s1430 :: SBool = s1427 == s1429 s1431 :: SWord1 = choose [13:13] s720 s1432 :: SBool = s13 /= s1431 s1433 :: SWord1 = choose [13:13] s1367 s1434 :: SBool = s13 /= s1433 s1435 :: SBool = s1432 == s1434 s1436 :: SWord1 = choose [14:14] s720 s1437 :: SBool = s13 /= s1436 s1438 :: SWord1 = choose [14:14] s1367 s1439 :: SBool = s13 /= s1438 s1440 :: SBool = s1437 == s1439 s1441 :: SWord1 = choose [15:15] s720 s1442 :: SBool = s13 /= s1441 s1443 :: SWord1 = choose [15:15] s1367 s1444 :: SBool = s13 /= s1443 s1445 :: SBool = s1442 == s1444 s1446 :: SWord1 = choose [16:16] s720 s1447 :: SBool = s13 /= s1446 s1448 :: SWord1 = choose [16:16] s1367 s1449 :: SBool = s13 /= s1448 s1450 :: SBool = s1447 == s1449 s1451 :: SWord1 = choose [17:17] s720 s1452 :: SBool = s13 /= s1451 s1453 :: SWord1 = choose [17:17] s1367 s1454 :: SBool = s13 /= s1453 s1455 :: SBool = s1452 == s1454 s1456 :: SWord1 = choose [18:18] s720 s1457 :: SBool = s13 /= s1456 s1458 :: SWord1 = choose [18:18] s1367 s1459 :: SBool = s13 /= s1458 s1460 :: SBool = s1457 == s1459 s1461 :: SWord1 = choose [19:19] s720 s1462 :: SBool = s13 /= s1461 s1463 :: SWord1 = choose [19:19] s1367 s1464 :: SBool = s13 /= s1463 s1465 :: SBool = s1462 == s1464 s1466 :: SWord1 = choose [20:20] s720 s1467 :: SBool = s13 /= s1466 s1468 :: SWord1 = choose [20:20] s1367 s1469 :: SBool = s13 /= s1468 s1470 :: SBool = s1467 == s1469 s1471 :: SWord1 = choose [21:21] s720 s1472 :: SBool = s13 /= s1471 s1473 :: SWord1 = choose [21:21] s1367 s1474 :: SBool = s13 /= s1473 s1475 :: SBool = s1472 == s1474 s1476 :: SWord1 = choose [22:22] s720 s1477 :: SBool = s13 /= s1476 s1478 :: SWord1 = choose [22:22] s1367 s1479 :: SBool = s13 /= s1478 s1480 :: SBool = s1477 == s1479 s1481 :: SWord1 = choose [23:23] s720 s1482 :: SBool = s13 /= s1481 s1483 :: SWord1 = choose [23:23] s1367 s1484 :: SBool = s13 /= s1483 s1485 :: SBool = s1482 == s1484 s1486 :: SWord1 = choose [24:24] s720 s1487 :: SBool = s13 /= s1486 s1488 :: SWord1 = choose [24:24] s1367 s1489 :: SBool = s13 /= s1488 s1490 :: SBool = s1487 == s1489 s1491 :: SWord1 = choose [25:25] s720 s1492 :: SBool = s13 /= s1491 s1493 :: SWord1 = choose [25:25] s1367 s1494 :: SBool = s13 /= s1493 s1495 :: SBool = s1492 == s1494 s1496 :: SWord1 = choose [26:26] s720 s1497 :: SBool = s13 /= s1496 s1498 :: SWord1 = choose [26:26] s1367 s1499 :: SBool = s13 /= s1498 s1500 :: SBool = s1497 == s1499 s1501 :: SWord1 = choose [27:27] s720 s1502 :: SBool = s13 /= s1501 s1503 :: SWord1 = choose [27:27] s1367 s1504 :: SBool = s13 /= s1503 s1505 :: SBool = s1502 == s1504 s1506 :: SWord1 = choose [28:28] s720 s1507 :: SBool = s13 /= s1506 s1508 :: SWord1 = choose [28:28] s1367 s1509 :: SBool = s13 /= s1508 s1510 :: SBool = s1507 == s1509 s1511 :: SWord1 = choose [29:29] s720 s1512 :: SBool = s13 /= s1511 s1513 :: SWord1 = choose [29:29] s1367 s1514 :: SBool = s13 /= s1513 s1515 :: SBool = s1512 == s1514 s1516 :: SWord1 = choose [30:30] s720 s1517 :: SBool = s13 /= s1516 s1518 :: SWord1 = choose [30:30] s1367 s1519 :: SBool = s13 /= s1518 s1520 :: SBool = s1517 == s1519 s1521 :: SWord1 = choose [31:31] s720 s1522 :: SBool = s13 /= s1521 s1523 :: SWord1 = choose [31:31] s1367 s1524 :: SBool = s13 /= s1523 s1525 :: SBool = s1522 == s1524 s1526 :: SWord1 = choose [32:32] s720 s1527 :: SBool = s13 /= s1526 s1528 :: SWord1 = choose [32:32] s1367 s1529 :: SBool = s13 /= s1528 s1530 :: SBool = s1527 == s1529 s1531 :: SWord1 = choose [33:33] s720 s1532 :: SBool = s13 /= s1531 s1533 :: SWord1 = choose [33:33] s1367 s1534 :: SBool = s13 /= s1533 s1535 :: SBool = s1532 == s1534 s1536 :: SWord1 = choose [34:34] s720 s1537 :: SBool = s13 /= s1536 s1538 :: SWord1 = choose [34:34] s1367 s1539 :: SBool = s13 /= s1538 s1540 :: SBool = s1537 == s1539 s1541 :: SWord1 = choose [35:35] s720 s1542 :: SBool = s13 /= s1541 s1543 :: SWord1 = choose [35:35] s1367 s1544 :: SBool = s13 /= s1543 s1545 :: SBool = s1542 == s1544 s1546 :: SWord1 = choose [36:36] s720 s1547 :: SBool = s13 /= s1546 s1548 :: SWord1 = choose [36:36] s1367 s1549 :: SBool = s13 /= s1548 s1550 :: SBool = s1547 == s1549 s1551 :: SWord1 = choose [37:37] s720 s1552 :: SBool = s13 /= s1551 s1553 :: SWord1 = choose [37:37] s1367 s1554 :: SBool = s13 /= s1553 s1555 :: SBool = s1552 == s1554 s1556 :: SWord1 = choose [38:38] s720 s1557 :: SBool = s13 /= s1556 s1558 :: SWord1 = choose [38:38] s1367 s1559 :: SBool = s13 /= s1558 s1560 :: SBool = s1557 == s1559 s1561 :: SWord1 = choose [39:39] s720 s1562 :: SBool = s13 /= s1561 s1563 :: SWord1 = choose [39:39] s1367 s1564 :: SBool = s13 /= s1563 s1565 :: SBool = s1562 == s1564 s1566 :: SWord1 = choose [40:40] s720 s1567 :: SBool = s13 /= s1566 s1568 :: SWord1 = choose [40:40] s1367 s1569 :: SBool = s13 /= s1568 s1570 :: SBool = s1567 == s1569 s1571 :: SWord1 = choose [41:41] s720 s1572 :: SBool = s13 /= s1571 s1573 :: SWord1 = choose [41:41] s1367 s1574 :: SBool = s13 /= s1573 s1575 :: SBool = s1572 == s1574 s1576 :: SWord1 = choose [42:42] s720 s1577 :: SBool = s13 /= s1576 s1578 :: SWord1 = choose [42:42] s1367 s1579 :: SBool = s13 /= s1578 s1580 :: SBool = s1577 == s1579 s1581 :: SWord1 = choose [43:43] s720 s1582 :: SBool = s13 /= s1581 s1583 :: SWord1 = choose [43:43] s1367 s1584 :: SBool = s13 /= s1583 s1585 :: SBool = s1582 == s1584 s1586 :: SWord1 = choose [44:44] s720 s1587 :: SBool = s13 /= s1586 s1588 :: SWord1 = choose [44:44] s1367 s1589 :: SBool = s13 /= s1588 s1590 :: SBool = s1587 == s1589 s1591 :: SWord1 = choose [45:45] s720 s1592 :: SBool = s13 /= s1591 s1593 :: SWord1 = choose [45:45] s1367 s1594 :: SBool = s13 /= s1593 s1595 :: SBool = s1592 == s1594 s1596 :: SWord1 = choose [46:46] s720 s1597 :: SBool = s13 /= s1596 s1598 :: SWord1 = choose [46:46] s1367 s1599 :: SBool = s13 /= s1598 s1600 :: SBool = s1597 == s1599 s1601 :: SWord1 = choose [47:47] s720 s1602 :: SBool = s13 /= s1601 s1603 :: SWord1 = choose [47:47] s1367 s1604 :: SBool = s13 /= s1603 s1605 :: SBool = s1602 == s1604 s1606 :: SWord1 = choose [48:48] s720 s1607 :: SBool = s13 /= s1606 s1608 :: SWord1 = choose [48:48] s1367 s1609 :: SBool = s13 /= s1608 s1610 :: SBool = s1607 == s1609 s1611 :: SWord1 = choose [49:49] s720 s1612 :: SBool = s13 /= s1611 s1613 :: SWord1 = choose [49:49] s1367 s1614 :: SBool = s13 /= s1613 s1615 :: SBool = s1612 == s1614 s1616 :: SWord1 = choose [50:50] s720 s1617 :: SBool = s13 /= s1616 s1618 :: SWord1 = choose [50:50] s1367 s1619 :: SBool = s13 /= s1618 s1620 :: SBool = s1617 == s1619 s1621 :: SWord1 = choose [51:51] s720 s1622 :: SBool = s13 /= s1621 s1623 :: SWord1 = choose [51:51] s1367 s1624 :: SBool = s13 /= s1623 s1625 :: SBool = s1622 == s1624 s1626 :: SWord1 = choose [52:52] s720 s1627 :: SBool = s13 /= s1626 s1628 :: SWord1 = choose [52:52] s1367 s1629 :: SBool = s13 /= s1628 s1630 :: SBool = s1627 == s1629 s1631 :: SWord1 = choose [53:53] s720 s1632 :: SBool = s13 /= s1631 s1633 :: SWord1 = choose [53:53] s1367 s1634 :: SBool = s13 /= s1633 s1635 :: SBool = s1632 == s1634 s1636 :: SWord1 = choose [54:54] s720 s1637 :: SBool = s13 /= s1636 s1638 :: SWord1 = choose [54:54] s1367 s1639 :: SBool = s13 /= s1638 s1640 :: SBool = s1637 == s1639 s1641 :: SWord1 = choose [55:55] s720 s1642 :: SBool = s13 /= s1641 s1643 :: SWord1 = choose [55:55] s1367 s1644 :: SBool = s13 /= s1643 s1645 :: SBool = s1642 == s1644 s1646 :: SWord1 = choose [56:56] s720 s1647 :: SBool = s13 /= s1646 s1648 :: SWord1 = choose [56:56] s1367 s1649 :: SBool = s13 /= s1648 s1650 :: SBool = s1647 == s1649 s1651 :: SWord1 = choose [57:57] s720 s1652 :: SBool = s13 /= s1651 s1653 :: SWord1 = choose [57:57] s1367 s1654 :: SBool = s13 /= s1653 s1655 :: SBool = s1652 == s1654 s1656 :: SWord1 = choose [58:58] s720 s1657 :: SBool = s13 /= s1656 s1658 :: SWord1 = choose [58:58] s1367 s1659 :: SBool = s13 /= s1658 s1660 :: SBool = s1657 == s1659 s1661 :: SWord1 = choose [59:59] s720 s1662 :: SBool = s13 /= s1661 s1663 :: SWord1 = choose [59:59] s1367 s1664 :: SBool = s13 /= s1663 s1665 :: SBool = s1662 == s1664 s1666 :: SWord1 = choose [60:60] s720 s1667 :: SBool = s13 /= s1666 s1668 :: SWord1 = choose [60:60] s1367 s1669 :: SBool = s13 /= s1668 s1670 :: SBool = s1667 == s1669 s1671 :: SWord1 = choose [61:61] s720 s1672 :: SBool = s13 /= s1671 s1673 :: SWord1 = choose [61:61] s1367 s1674 :: SBool = s13 /= s1673 s1675 :: SBool = s1672 == s1674 s1676 :: SWord1 = choose [62:62] s720 s1677 :: SBool = s13 /= s1676 s1678 :: SWord1 = choose [62:62] s1367 s1679 :: SBool = s13 /= s1678 s1680 :: SBool = s1677 == s1679 s1681 :: SWord1 = choose [63:63] s720 s1682 :: SBool = s13 /= s1681 s1683 :: SWord1 = choose [63:63] s1367 s1684 :: SBool = s13 /= s1683 s1685 :: SBool = s1682 == s1684 s1688 :: SWord8 = if s1685 then s1686 else s1687 s1689 :: SWord8 = s1687 + s1688 s1690 :: SWord8 = if s1680 then s1688 else s1689 s1691 :: SWord8 = s1687 + s1690 s1692 :: SWord8 = if s1675 then s1690 else s1691 s1693 :: SWord8 = s1687 + s1692 s1694 :: SWord8 = if s1670 then s1692 else s1693 s1695 :: SWord8 = s1687 + s1694 s1696 :: SWord8 = if s1665 then s1694 else s1695 s1697 :: SWord8 = s1687 + s1696 s1698 :: SWord8 = if s1660 then s1696 else s1697 s1699 :: SWord8 = s1687 + s1698 s1700 :: SWord8 = if s1655 then s1698 else s1699 s1701 :: SWord8 = s1687 + s1700 s1702 :: SWord8 = if s1650 then s1700 else s1701 s1703 :: SWord8 = s1687 + s1702 s1704 :: SWord8 = if s1645 then s1702 else s1703 s1705 :: SWord8 = s1687 + s1704 s1706 :: SWord8 = if s1640 then s1704 else s1705 s1707 :: SWord8 = s1687 + s1706 s1708 :: SWord8 = if s1635 then s1706 else s1707 s1709 :: SWord8 = s1687 + s1708 s1710 :: SWord8 = if s1630 then s1708 else s1709 s1711 :: SWord8 = s1687 + s1710 s1712 :: SWord8 = if s1625 then s1710 else s1711 s1713 :: SWord8 = s1687 + s1712 s1714 :: SWord8 = if s1620 then s1712 else s1713 s1715 :: SWord8 = s1687 + s1714 s1716 :: SWord8 = if s1615 then s1714 else s1715 s1717 :: SWord8 = s1687 + s1716 s1718 :: SWord8 = if s1610 then s1716 else s1717 s1719 :: SWord8 = s1687 + s1718 s1720 :: SWord8 = if s1605 then s1718 else s1719 s1721 :: SWord8 = s1687 + s1720 s1722 :: SWord8 = if s1600 then s1720 else s1721 s1723 :: SWord8 = s1687 + s1722 s1724 :: SWord8 = if s1595 then s1722 else s1723 s1725 :: SWord8 = s1687 + s1724 s1726 :: SWord8 = if s1590 then s1724 else s1725 s1727 :: SWord8 = s1687 + s1726 s1728 :: SWord8 = if s1585 then s1726 else s1727 s1729 :: SWord8 = s1687 + s1728 s1730 :: SWord8 = if s1580 then s1728 else s1729 s1731 :: SWord8 = s1687 + s1730 s1732 :: SWord8 = if s1575 then s1730 else s1731 s1733 :: SWord8 = s1687 + s1732 s1734 :: SWord8 = if s1570 then s1732 else s1733 s1735 :: SWord8 = s1687 + s1734 s1736 :: SWord8 = if s1565 then s1734 else s1735 s1737 :: SWord8 = s1687 + s1736 s1738 :: SWord8 = if s1560 then s1736 else s1737 s1739 :: SWord8 = s1687 + s1738 s1740 :: SWord8 = if s1555 then s1738 else s1739 s1741 :: SWord8 = s1687 + s1740 s1742 :: SWord8 = if s1550 then s1740 else s1741 s1743 :: SWord8 = s1687 + s1742 s1744 :: SWord8 = if s1545 then s1742 else s1743 s1745 :: SWord8 = s1687 + s1744 s1746 :: SWord8 = if s1540 then s1744 else s1745 s1747 :: SWord8 = s1687 + s1746 s1748 :: SWord8 = if s1535 then s1746 else s1747 s1749 :: SWord8 = s1687 + s1748 s1750 :: SWord8 = if s1530 then s1748 else s1749 s1751 :: SWord8 = s1687 + s1750 s1752 :: SWord8 = if s1525 then s1750 else s1751 s1753 :: SWord8 = s1687 + s1752 s1754 :: SWord8 = if s1520 then s1752 else s1753 s1755 :: SWord8 = s1687 + s1754 s1756 :: SWord8 = if s1515 then s1754 else s1755 s1757 :: SWord8 = s1687 + s1756 s1758 :: SWord8 = if s1510 then s1756 else s1757 s1759 :: SWord8 = s1687 + s1758 s1760 :: SWord8 = if s1505 then s1758 else s1759 s1761 :: SWord8 = s1687 + s1760 s1762 :: SWord8 = if s1500 then s1760 else s1761 s1763 :: SWord8 = s1687 + s1762 s1764 :: SWord8 = if s1495 then s1762 else s1763 s1765 :: SWord8 = s1687 + s1764 s1766 :: SWord8 = if s1490 then s1764 else s1765 s1767 :: SWord8 = s1687 + s1766 s1768 :: SWord8 = if s1485 then s1766 else s1767 s1769 :: SWord8 = s1687 + s1768 s1770 :: SWord8 = if s1480 then s1768 else s1769 s1771 :: SWord8 = s1687 + s1770 s1772 :: SWord8 = if s1475 then s1770 else s1771 s1773 :: SWord8 = s1687 + s1772 s1774 :: SWord8 = if s1470 then s1772 else s1773 s1775 :: SWord8 = s1687 + s1774 s1776 :: SWord8 = if s1465 then s1774 else s1775 s1777 :: SWord8 = s1687 + s1776 s1778 :: SWord8 = if s1460 then s1776 else s1777 s1779 :: SWord8 = s1687 + s1778 s1780 :: SWord8 = if s1455 then s1778 else s1779 s1781 :: SWord8 = s1687 + s1780 s1782 :: SWord8 = if s1450 then s1780 else s1781 s1783 :: SWord8 = s1687 + s1782 s1784 :: SWord8 = if s1445 then s1782 else s1783 s1785 :: SWord8 = s1687 + s1784 s1786 :: SWord8 = if s1440 then s1784 else s1785 s1787 :: SWord8 = s1687 + s1786 s1788 :: SWord8 = if s1435 then s1786 else s1787 s1789 :: SWord8 = s1687 + s1788 s1790 :: SWord8 = if s1430 then s1788 else s1789 s1791 :: SWord8 = s1687 + s1790 s1792 :: SWord8 = if s1425 then s1790 else s1791 s1793 :: SWord8 = s1687 + s1792 s1794 :: SWord8 = if s1420 then s1792 else s1793 s1795 :: SWord8 = s1687 + s1794 s1796 :: SWord8 = if s1415 then s1794 else s1795 s1797 :: SWord8 = s1687 + s1796 s1798 :: SWord8 = if s1410 then s1796 else s1797 s1799 :: SWord8 = s1687 + s1798 s1800 :: SWord8 = if s1405 then s1798 else s1799 s1801 :: SWord8 = s1687 + s1800 s1802 :: SWord8 = if s1400 then s1800 else s1801 s1803 :: SWord8 = s1687 + s1802 s1804 :: SWord8 = if s1395 then s1802 else s1803 s1805 :: SWord8 = s1687 + s1804 s1806 :: SWord8 = if s1390 then s1804 else s1805 s1807 :: SWord8 = s1687 + s1806 s1808 :: SWord8 = if s1385 then s1806 else s1807 s1809 :: SWord8 = s1687 + s1808 s1810 :: SWord8 = if s1380 then s1808 else s1809 s1811 :: SWord8 = s1687 + s1810 s1812 :: SWord8 = if s1375 then s1810 else s1811 s1813 :: SWord8 = s1687 + s1812 s1814 :: SWord8 = if s1370 then s1812 else s1813 s1816 :: SBool = s1814 > s1815 s1817 :: SBool = s8 | s1816 CONSTRAINTS ASSERTIONS OUTPUTS s1817sbv-5.12/SBVUnitTest/GoldFiles/cgUninterpret.gold0000644000000000000000000000550412725411266020135 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for tstShiftLeft. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: tstShiftLeft_driver tstShiftLeft.o: tstShiftLeft.c tstShiftLeft.h ${CC} ${CCFLAGS} -c $< -o $@ tstShiftLeft_driver.o: tstShiftLeft_driver.c ${CC} ${CCFLAGS} -c $< -o $@ tstShiftLeft_driver: tstShiftLeft.o tstShiftLeft_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f tstShiftLeft_driver == END: "Makefile" ================== == BEGIN: "tstShiftLeft.h" ================ /* Header file for tstShiftLeft. Automatically generated by SBV. Do not edit! */ #ifndef __tstShiftLeft__HEADER_INCLUDED__ #define __tstShiftLeft__HEADER_INCLUDED__ #include #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: */ SWord32 tstShiftLeft(const SWord32 *vs); #endif /* __tstShiftLeft__HEADER_INCLUDED__ */ == END: "tstShiftLeft.h" ================== == BEGIN: "tstShiftLeft_driver.c" ================ /* Example driver program for tstShiftLeft. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "tstShiftLeft.h" int main(void) { const SWord32 vs[3] = { 0x00000001UL, 0x00000002UL, 0x00000003UL }; printf("Contents of input array vs:\n"); int vs_ctr; for(vs_ctr = 0; vs_ctr < 3 ; ++vs_ctr) printf(" vs[%d] = 0x%08"PRIx32"UL\n", vs_ctr ,vs[vs_ctr]); const SWord32 __result = tstShiftLeft(vs); printf("tstShiftLeft(vs) = 0x%08"PRIx32"UL\n", __result); return 0; } == END: "tstShiftLeft_driver.c" ================== == BEGIN: "tstShiftLeft.c" ================ /* File: "tstShiftLeft.c". Automatically generated by SBV. Do not edit! */ #include "tstShiftLeft.h" /* User specified custom code for "SBV_SHIFTLEFT" */ #define SBV_SHIFTLEFT(x, y) ((x) << (y)) SWord32 tstShiftLeft(const SWord32 *vs) { const SWord32 s0 = vs[0]; const SWord32 s1 = vs[1]; const SWord32 s2 = vs[2]; const SWord32 s3 = /* Uninterpreted function */ SBV_SHIFTLEFT(s0, s2); const SWord32 s4 = /* Uninterpreted function */ SBV_SHIFTLEFT(s1, s2); const SWord32 s5 = s3 + s4; return s5; } == END: "tstShiftLeft.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/codeGen1.gold0000644000000000000000000001374012725411266016732 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for foo. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: foo_driver foo.o: foo.c foo.h ${CC} ${CCFLAGS} -c $< -o $@ foo_driver.o: foo_driver.c ${CC} ${CCFLAGS} -c $< -o $@ foo_driver: foo.o foo_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f foo_driver == END: "Makefile" ================== == BEGIN: "foo.h" ================ /* Header file for foo. Automatically generated by SBV. Do not edit! */ #ifndef __foo__HEADER_INCLUDED__ #define __foo__HEADER_INCLUDED__ #include #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: */ SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z, SInt16 *zArr, SInt64 *yArr); #endif /* __foo__HEADER_INCLUDED__ */ == END: "foo.h" ================== == BEGIN: "foo_driver.c" ================ /* Example driver program for foo. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "foo.h" int main(void) { const SInt64 xArr[45] = { 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL }; printf("Contents of input array xArr:\n"); int xArr_ctr; for(xArr_ctr = 0; xArr_ctr < 45 ; ++xArr_ctr) printf(" xArr[%d] = %"PRId64"LL\n", xArr_ctr ,xArr[xArr_ctr]); SWord16 z; SInt16 zArr[7]; SInt64 yArr[45]; const SInt16 __result = foo(0x0000, xArr, &z, zArr, yArr); printf("foo(0x0000, xArr, &z, zArr, yArr) = %"PRId16"\n", __result); printf(" z = 0x%04"PRIx16"U\n", z); int zArr_ctr; for(zArr_ctr = 0; zArr_ctr < 7 ; ++zArr_ctr) printf(" zArr[%d] = %"PRId16"\n", zArr_ctr ,zArr[zArr_ctr]); int yArr_ctr; for(yArr_ctr = 0; yArr_ctr < 45 ; ++yArr_ctr) printf(" yArr[%d] = %"PRId64"LL\n", yArr_ctr ,yArr[yArr_ctr]); return 0; } == END: "foo_driver.c" ================== == BEGIN: "foo.c" ================ /* File: "foo.c". Automatically generated by SBV. Do not edit! */ #include "foo.h" SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z, SInt16 *zArr, SInt64 *yArr) { const SInt16 s0 = x; const SInt64 s1 = xArr[0]; const SInt64 s2 = xArr[1]; const SInt64 s3 = xArr[2]; const SInt64 s4 = xArr[3]; const SInt64 s5 = xArr[4]; const SInt64 s6 = xArr[5]; const SInt64 s7 = xArr[6]; const SInt64 s8 = xArr[7]; const SInt64 s9 = xArr[8]; const SInt64 s10 = xArr[9]; const SInt64 s11 = xArr[10]; const SInt64 s12 = xArr[11]; const SInt64 s13 = xArr[12]; const SInt64 s14 = xArr[13]; const SInt64 s15 = xArr[14]; const SInt64 s16 = xArr[15]; const SInt64 s17 = xArr[16]; const SInt64 s18 = xArr[17]; const SInt64 s19 = xArr[18]; const SInt64 s20 = xArr[19]; const SInt64 s21 = xArr[20]; const SInt64 s22 = xArr[21]; const SInt64 s23 = xArr[22]; const SInt64 s24 = xArr[23]; const SInt64 s25 = xArr[24]; const SInt64 s26 = xArr[25]; const SInt64 s27 = xArr[26]; const SInt64 s28 = xArr[27]; const SInt64 s29 = xArr[28]; const SInt64 s30 = xArr[29]; const SInt64 s31 = xArr[30]; const SInt64 s32 = xArr[31]; const SInt64 s33 = xArr[32]; const SInt64 s34 = xArr[33]; const SInt64 s35 = xArr[34]; const SInt64 s36 = xArr[35]; const SInt64 s37 = xArr[36]; const SInt64 s38 = xArr[37]; const SInt64 s39 = xArr[38]; const SInt64 s40 = xArr[39]; const SInt64 s41 = xArr[40]; const SInt64 s42 = xArr[41]; const SInt64 s43 = xArr[42]; const SInt64 s44 = xArr[43]; const SInt64 s45 = xArr[44]; const SInt16 s48 = s0 + 0x0001; const SInt16 s50 = s0 * 0x0002; *z = 0x0005U; zArr[0] = s48; zArr[1] = s48; zArr[2] = s48; zArr[3] = s48; zArr[4] = s48; zArr[5] = s48; zArr[6] = s48; yArr[0] = s1; yArr[1] = s2; yArr[2] = s3; yArr[3] = s4; yArr[4] = s5; yArr[5] = s6; yArr[6] = s7; yArr[7] = s8; yArr[8] = s9; yArr[9] = s10; yArr[10] = s11; yArr[11] = s12; yArr[12] = s13; yArr[13] = s14; yArr[14] = s15; yArr[15] = s16; yArr[16] = s17; yArr[17] = s18; yArr[18] = s19; yArr[19] = s20; yArr[20] = s21; yArr[21] = s22; yArr[22] = s23; yArr[23] = s24; yArr[24] = s25; yArr[25] = s26; yArr[26] = s27; yArr[27] = s28; yArr[28] = s29; yArr[29] = s30; yArr[30] = s31; yArr[31] = s32; yArr[32] = s33; yArr[33] = s34; yArr[34] = s35; yArr[35] = s36; yArr[36] = s37; yArr[37] = s38; yArr[38] = s39; yArr[39] = s40; yArr[40] = s41; yArr[41] = s42; yArr[42] = s43; yArr[43] = s44; yArr[44] = s45; return s50; } == END: "foo.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/coins.gold0000644000000000000000000004475412725411266016431 0ustar0000000000000000INPUTS s0 :: SWord16, existential, aliasing "c1" s18 :: SWord16, existential, aliasing "c2" s30 :: SWord16, existential, aliasing "c3" s42 :: SWord16, existential, aliasing "c4" s54 :: SWord16, existential, aliasing "c5" s66 :: SWord16, existential, aliasing "c6" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s1 = 1 :: Word16 s3 = 5 :: Word16 s5 = 10 :: Word16 s7 = 25 :: Word16 s9 = 50 :: Word16 s11 = 100 :: Word16 s84 = 0 :: Word16 s88 = 95 :: Word16 s551 = 115 :: Word16 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s2 :: SBool = s0 == s1 s4 :: SBool = s0 == s3 s6 :: SBool = s0 == s5 s8 :: SBool = s0 == s7 s10 :: SBool = s0 == s9 s12 :: SBool = s0 == s11 s13 :: SBool = s10 | s12 s14 :: SBool = s8 | s13 s15 :: SBool = s6 | s14 s16 :: SBool = s4 | s15 s17 :: SBool = s2 | s16 s19 :: SBool = s1 == s18 s20 :: SBool = s3 == s18 s21 :: SBool = s5 == s18 s22 :: SBool = s7 == s18 s23 :: SBool = s9 == s18 s24 :: SBool = s11 == s18 s25 :: SBool = s23 | s24 s26 :: SBool = s22 | s25 s27 :: SBool = s21 | s26 s28 :: SBool = s20 | s27 s29 :: SBool = s19 | s28 s31 :: SBool = s1 == s30 s32 :: SBool = s3 == s30 s33 :: SBool = s5 == s30 s34 :: SBool = s7 == s30 s35 :: SBool = s9 == s30 s36 :: SBool = s11 == s30 s37 :: SBool = s35 | s36 s38 :: SBool = s34 | s37 s39 :: SBool = s33 | s38 s40 :: SBool = s32 | s39 s41 :: SBool = s31 | s40 s43 :: SBool = s1 == s42 s44 :: SBool = s3 == s42 s45 :: SBool = s5 == s42 s46 :: SBool = s7 == s42 s47 :: SBool = s9 == s42 s48 :: SBool = s11 == s42 s49 :: SBool = s47 | s48 s50 :: SBool = s46 | s49 s51 :: SBool = s45 | s50 s52 :: SBool = s44 | s51 s53 :: SBool = s43 | s52 s55 :: SBool = s1 == s54 s56 :: SBool = s3 == s54 s57 :: SBool = s5 == s54 s58 :: SBool = s7 == s54 s59 :: SBool = s9 == s54 s60 :: SBool = s11 == s54 s61 :: SBool = s59 | s60 s62 :: SBool = s58 | s61 s63 :: SBool = s57 | s62 s64 :: SBool = s56 | s63 s65 :: SBool = s55 | s64 s67 :: SBool = s1 == s66 s68 :: SBool = s3 == s66 s69 :: SBool = s5 == s66 s70 :: SBool = s7 == s66 s71 :: SBool = s9 == s66 s72 :: SBool = s11 == s66 s73 :: SBool = s71 | s72 s74 :: SBool = s70 | s73 s75 :: SBool = s69 | s74 s76 :: SBool = s68 | s75 s77 :: SBool = s67 | s76 s78 :: SWord16 = s0 + s18 s79 :: SBool = s11 /= s78 s80 :: SBool = s9 /= s78 s81 :: SBool = s7 /= s78 s82 :: SBool = s5 /= s78 s83 :: SBool = s3 /= s78 s85 :: SWord16 = if s10 then s84 else s0 s86 :: SWord16 = if s23 then s84 else s18 s87 :: SWord16 = s85 + s86 s89 :: SBool = s87 /= s88 s90 :: SWord16 = s0 + s30 s91 :: SBool = s11 /= s90 s92 :: SBool = s9 /= s90 s93 :: SBool = s7 /= s90 s94 :: SBool = s5 /= s90 s95 :: SBool = s3 /= s90 s96 :: SWord16 = if s35 then s84 else s30 s97 :: SWord16 = s85 + s96 s98 :: SBool = s88 /= s97 s99 :: SWord16 = s0 + s42 s100 :: SBool = s11 /= s99 s101 :: SBool = s9 /= s99 s102 :: SBool = s7 /= s99 s103 :: SBool = s5 /= s99 s104 :: SBool = s3 /= s99 s105 :: SWord16 = if s47 then s84 else s42 s106 :: SWord16 = s85 + s105 s107 :: SBool = s88 /= s106 s108 :: SWord16 = s0 + s54 s109 :: SBool = s11 /= s108 s110 :: SBool = s9 /= s108 s111 :: SBool = s7 /= s108 s112 :: SBool = s5 /= s108 s113 :: SBool = s3 /= s108 s114 :: SWord16 = if s59 then s84 else s54 s115 :: SWord16 = s85 + s114 s116 :: SBool = s88 /= s115 s117 :: SWord16 = s0 + s66 s118 :: SBool = s11 /= s117 s119 :: SBool = s9 /= s117 s120 :: SBool = s7 /= s117 s121 :: SBool = s5 /= s117 s122 :: SBool = s3 /= s117 s123 :: SWord16 = if s71 then s84 else s66 s124 :: SWord16 = s85 + s123 s125 :: SBool = s88 /= s124 s126 :: SWord16 = s18 + s30 s127 :: SBool = s11 /= s126 s128 :: SBool = s9 /= s126 s129 :: SBool = s7 /= s126 s130 :: SBool = s5 /= s126 s131 :: SBool = s3 /= s126 s132 :: SWord16 = s86 + s96 s133 :: SBool = s88 /= s132 s134 :: SWord16 = s18 + s42 s135 :: SBool = s11 /= s134 s136 :: SBool = s9 /= s134 s137 :: SBool = s7 /= s134 s138 :: SBool = s5 /= s134 s139 :: SBool = s3 /= s134 s140 :: SWord16 = s86 + s105 s141 :: SBool = s88 /= s140 s142 :: SWord16 = s18 + s54 s143 :: SBool = s11 /= s142 s144 :: SBool = s9 /= s142 s145 :: SBool = s7 /= s142 s146 :: SBool = s5 /= s142 s147 :: SBool = s3 /= s142 s148 :: SWord16 = s86 + s114 s149 :: SBool = s88 /= s148 s150 :: SWord16 = s18 + s66 s151 :: SBool = s11 /= s150 s152 :: SBool = s9 /= s150 s153 :: SBool = s7 /= s150 s154 :: SBool = s5 /= s150 s155 :: SBool = s3 /= s150 s156 :: SWord16 = s86 + s123 s157 :: SBool = s88 /= s156 s158 :: SWord16 = s30 + s42 s159 :: SBool = s11 /= s158 s160 :: SBool = s9 /= s158 s161 :: SBool = s7 /= s158 s162 :: SBool = s5 /= s158 s163 :: SBool = s3 /= s158 s164 :: SWord16 = s96 + s105 s165 :: SBool = s88 /= s164 s166 :: SWord16 = s30 + s54 s167 :: SBool = s11 /= s166 s168 :: SBool = s9 /= s166 s169 :: SBool = s7 /= s166 s170 :: SBool = s5 /= s166 s171 :: SBool = s3 /= s166 s172 :: SWord16 = s96 + s114 s173 :: SBool = s88 /= s172 s174 :: SWord16 = s30 + s66 s175 :: SBool = s11 /= s174 s176 :: SBool = s9 /= s174 s177 :: SBool = s7 /= s174 s178 :: SBool = s5 /= s174 s179 :: SBool = s3 /= s174 s180 :: SWord16 = s96 + s123 s181 :: SBool = s88 /= s180 s182 :: SWord16 = s42 + s54 s183 :: SBool = s11 /= s182 s184 :: SBool = s9 /= s182 s185 :: SBool = s7 /= s182 s186 :: SBool = s5 /= s182 s187 :: SBool = s3 /= s182 s188 :: SWord16 = s105 + s114 s189 :: SBool = s88 /= s188 s190 :: SWord16 = s42 + s66 s191 :: SBool = s11 /= s190 s192 :: SBool = s9 /= s190 s193 :: SBool = s7 /= s190 s194 :: SBool = s5 /= s190 s195 :: SBool = s3 /= s190 s196 :: SWord16 = s105 + s123 s197 :: SBool = s88 /= s196 s198 :: SWord16 = s54 + s66 s199 :: SBool = s11 /= s198 s200 :: SBool = s9 /= s198 s201 :: SBool = s7 /= s198 s202 :: SBool = s5 /= s198 s203 :: SBool = s3 /= s198 s204 :: SWord16 = s114 + s123 s205 :: SBool = s88 /= s204 s206 :: SWord16 = s30 + s78 s207 :: SBool = s11 /= s206 s208 :: SBool = s9 /= s206 s209 :: SBool = s7 /= s206 s210 :: SBool = s5 /= s206 s211 :: SBool = s3 /= s206 s212 :: SWord16 = s87 + s96 s213 :: SBool = s88 /= s212 s214 :: SWord16 = s42 + s78 s215 :: SBool = s11 /= s214 s216 :: SBool = s9 /= s214 s217 :: SBool = s7 /= s214 s218 :: SBool = s5 /= s214 s219 :: SBool = s3 /= s214 s220 :: SWord16 = s87 + s105 s221 :: SBool = s88 /= s220 s222 :: SWord16 = s54 + s78 s223 :: SBool = s11 /= s222 s224 :: SBool = s9 /= s222 s225 :: SBool = s7 /= s222 s226 :: SBool = s5 /= s222 s227 :: SBool = s3 /= s222 s228 :: SWord16 = s87 + s114 s229 :: SBool = s88 /= s228 s230 :: SWord16 = s66 + s78 s231 :: SBool = s11 /= s230 s232 :: SBool = s9 /= s230 s233 :: SBool = s7 /= s230 s234 :: SBool = s5 /= s230 s235 :: SBool = s3 /= s230 s236 :: SWord16 = s87 + s123 s237 :: SBool = s88 /= s236 s238 :: SWord16 = s42 + s90 s239 :: SBool = s11 /= s238 s240 :: SBool = s9 /= s238 s241 :: SBool = s7 /= s238 s242 :: SBool = s5 /= s238 s243 :: SBool = s3 /= s238 s244 :: SWord16 = s97 + s105 s245 :: SBool = s88 /= s244 s246 :: SWord16 = s54 + s90 s247 :: SBool = s11 /= s246 s248 :: SBool = s9 /= s246 s249 :: SBool = s7 /= s246 s250 :: SBool = s5 /= s246 s251 :: SBool = s3 /= s246 s252 :: SWord16 = s97 + s114 s253 :: SBool = s88 /= s252 s254 :: SWord16 = s66 + s90 s255 :: SBool = s11 /= s254 s256 :: SBool = s9 /= s254 s257 :: SBool = s7 /= s254 s258 :: SBool = s5 /= s254 s259 :: SBool = s3 /= s254 s260 :: SWord16 = s97 + s123 s261 :: SBool = s88 /= s260 s262 :: SWord16 = s54 + s99 s263 :: SBool = s11 /= s262 s264 :: SBool = s9 /= s262 s265 :: SBool = s7 /= s262 s266 :: SBool = s5 /= s262 s267 :: SBool = s3 /= s262 s268 :: SWord16 = s106 + s114 s269 :: SBool = s88 /= s268 s270 :: SWord16 = s66 + s99 s271 :: SBool = s11 /= s270 s272 :: SBool = s9 /= s270 s273 :: SBool = s7 /= s270 s274 :: SBool = s5 /= s270 s275 :: SBool = s3 /= s270 s276 :: SWord16 = s106 + s123 s277 :: SBool = s88 /= s276 s278 :: SWord16 = s66 + s108 s279 :: SBool = s11 /= s278 s280 :: SBool = s9 /= s278 s281 :: SBool = s7 /= s278 s282 :: SBool = s5 /= s278 s283 :: SBool = s3 /= s278 s284 :: SWord16 = s115 + s123 s285 :: SBool = s88 /= s284 s286 :: SWord16 = s42 + s126 s287 :: SBool = s11 /= s286 s288 :: SBool = s9 /= s286 s289 :: SBool = s7 /= s286 s290 :: SBool = s5 /= s286 s291 :: SBool = s3 /= s286 s292 :: SWord16 = s105 + s132 s293 :: SBool = s88 /= s292 s294 :: SWord16 = s54 + s126 s295 :: SBool = s11 /= s294 s296 :: SBool = s9 /= s294 s297 :: SBool = s7 /= s294 s298 :: SBool = s5 /= s294 s299 :: SBool = s3 /= s294 s300 :: SWord16 = s114 + s132 s301 :: SBool = s88 /= s300 s302 :: SWord16 = s66 + s126 s303 :: SBool = s11 /= s302 s304 :: SBool = s9 /= s302 s305 :: SBool = s7 /= s302 s306 :: SBool = s5 /= s302 s307 :: SBool = s3 /= s302 s308 :: SWord16 = s123 + s132 s309 :: SBool = s88 /= s308 s310 :: SWord16 = s54 + s134 s311 :: SBool = s11 /= s310 s312 :: SBool = s9 /= s310 s313 :: SBool = s7 /= s310 s314 :: SBool = s5 /= s310 s315 :: SBool = s3 /= s310 s316 :: SWord16 = s114 + s140 s317 :: SBool = s88 /= s316 s318 :: SWord16 = s66 + s134 s319 :: SBool = s11 /= s318 s320 :: SBool = s9 /= s318 s321 :: SBool = s7 /= s318 s322 :: SBool = s5 /= s318 s323 :: SBool = s3 /= s318 s324 :: SWord16 = s123 + s140 s325 :: SBool = s88 /= s324 s326 :: SWord16 = s66 + s142 s327 :: SBool = s11 /= s326 s328 :: SBool = s9 /= s326 s329 :: SBool = s7 /= s326 s330 :: SBool = s5 /= s326 s331 :: SBool = s3 /= s326 s332 :: SWord16 = s123 + s148 s333 :: SBool = s88 /= s332 s334 :: SWord16 = s54 + s158 s335 :: SBool = s11 /= s334 s336 :: SBool = s9 /= s334 s337 :: SBool = s7 /= s334 s338 :: SBool = s5 /= s334 s339 :: SBool = s3 /= s334 s340 :: SWord16 = s114 + s164 s341 :: SBool = s88 /= s340 s342 :: SWord16 = s66 + s158 s343 :: SBool = s11 /= s342 s344 :: SBool = s9 /= s342 s345 :: SBool = s7 /= s342 s346 :: SBool = s5 /= s342 s347 :: SBool = s3 /= s342 s348 :: SWord16 = s123 + s164 s349 :: SBool = s88 /= s348 s350 :: SWord16 = s66 + s166 s351 :: SBool = s11 /= s350 s352 :: SBool = s9 /= s350 s353 :: SBool = s7 /= s350 s354 :: SBool = s5 /= s350 s355 :: SBool = s3 /= s350 s356 :: SWord16 = s123 + s172 s357 :: SBool = s88 /= s356 s358 :: SWord16 = s66 + s182 s359 :: SBool = s11 /= s358 s360 :: SBool = s9 /= s358 s361 :: SBool = s7 /= s358 s362 :: SBool = s5 /= s358 s363 :: SBool = s3 /= s358 s364 :: SWord16 = s123 + s188 s365 :: SBool = s88 /= s364 s366 :: SWord16 = s42 + s206 s367 :: SBool = s11 /= s366 s368 :: SBool = s9 /= s366 s369 :: SBool = s7 /= s366 s370 :: SBool = s5 /= s366 s371 :: SBool = s3 /= s366 s372 :: SWord16 = s105 + s212 s373 :: SBool = s88 /= s372 s374 :: SWord16 = s54 + s206 s375 :: SBool = s11 /= s374 s376 :: SBool = s9 /= s374 s377 :: SBool = s7 /= s374 s378 :: SBool = s5 /= s374 s379 :: SBool = s3 /= s374 s380 :: SWord16 = s114 + s212 s381 :: SBool = s88 /= s380 s382 :: SWord16 = s66 + s206 s383 :: SBool = s11 /= s382 s384 :: SBool = s9 /= s382 s385 :: SBool = s7 /= s382 s386 :: SBool = s5 /= s382 s387 :: SBool = s3 /= s382 s388 :: SWord16 = s123 + s212 s389 :: SBool = s88 /= s388 s390 :: SWord16 = s54 + s214 s391 :: SBool = s11 /= s390 s392 :: SBool = s9 /= s390 s393 :: SBool = s7 /= s390 s394 :: SBool = s5 /= s390 s395 :: SBool = s3 /= s390 s396 :: SWord16 = s114 + s220 s397 :: SBool = s88 /= s396 s398 :: SWord16 = s66 + s214 s399 :: SBool = s11 /= s398 s400 :: SBool = s9 /= s398 s401 :: SBool = s7 /= s398 s402 :: SBool = s5 /= s398 s403 :: SBool = s3 /= s398 s404 :: SWord16 = s123 + s220 s405 :: SBool = s88 /= s404 s406 :: SWord16 = s66 + s222 s407 :: SBool = s11 /= s406 s408 :: SBool = s9 /= s406 s409 :: SBool = s7 /= s406 s410 :: SBool = s5 /= s406 s411 :: SBool = s3 /= s406 s412 :: SWord16 = s123 + s228 s413 :: SBool = s88 /= s412 s414 :: SWord16 = s54 + s238 s415 :: SBool = s11 /= s414 s416 :: SBool = s9 /= s414 s417 :: SBool = s7 /= s414 s418 :: SBool = s5 /= s414 s419 :: SBool = s3 /= s414 s420 :: SWord16 = s114 + s244 s421 :: SBool = s88 /= s420 s422 :: SWord16 = s66 + s238 s423 :: SBool = s11 /= s422 s424 :: SBool = s9 /= s422 s425 :: SBool = s7 /= s422 s426 :: SBool = s5 /= s422 s427 :: SBool = s3 /= s422 s428 :: SWord16 = s123 + s244 s429 :: SBool = s88 /= s428 s430 :: SWord16 = s66 + s246 s431 :: SBool = s11 /= s430 s432 :: SBool = s9 /= s430 s433 :: SBool = s7 /= s430 s434 :: SBool = s5 /= s430 s435 :: SBool = s3 /= s430 s436 :: SWord16 = s123 + s252 s437 :: SBool = s88 /= s436 s438 :: SWord16 = s66 + s262 s439 :: SBool = s11 /= s438 s440 :: SBool = s9 /= s438 s441 :: SBool = s7 /= s438 s442 :: SBool = s5 /= s438 s443 :: SBool = s3 /= s438 s444 :: SWord16 = s123 + s268 s445 :: SBool = s88 /= s444 s446 :: SWord16 = s54 + s286 s447 :: SBool = s11 /= s446 s448 :: SBool = s9 /= s446 s449 :: SBool = s7 /= s446 s450 :: SBool = s5 /= s446 s451 :: SBool = s3 /= s446 s452 :: SWord16 = s114 + s292 s453 :: SBool = s88 /= s452 s454 :: SWord16 = s66 + s286 s455 :: SBool = s11 /= s454 s456 :: SBool = s9 /= s454 s457 :: SBool = s7 /= s454 s458 :: SBool = s5 /= s454 s459 :: SBool = s3 /= s454 s460 :: SWord16 = s123 + s292 s461 :: SBool = s88 /= s460 s462 :: SWord16 = s66 + s294 s463 :: SBool = s11 /= s462 s464 :: SBool = s9 /= s462 s465 :: SBool = s7 /= s462 s466 :: SBool = s5 /= s462 s467 :: SBool = s3 /= s462 s468 :: SWord16 = s123 + s300 s469 :: SBool = s88 /= s468 s470 :: SWord16 = s66 + s310 s471 :: SBool = s11 /= s470 s472 :: SBool = s9 /= s470 s473 :: SBool = s7 /= s470 s474 :: SBool = s5 /= s470 s475 :: SBool = s3 /= s470 s476 :: SWord16 = s123 + s316 s477 :: SBool = s88 /= s476 s478 :: SWord16 = s66 + s334 s479 :: SBool = s11 /= s478 s480 :: SBool = s9 /= s478 s481 :: SBool = s7 /= s478 s482 :: SBool = s5 /= s478 s483 :: SBool = s3 /= s478 s484 :: SWord16 = s123 + s340 s485 :: SBool = s88 /= s484 s486 :: SWord16 = s54 + s366 s487 :: SBool = s11 /= s486 s488 :: SBool = s9 /= s486 s489 :: SBool = s7 /= s486 s490 :: SBool = s5 /= s486 s491 :: SBool = s3 /= s486 s492 :: SWord16 = s114 + s372 s493 :: SBool = s88 /= s492 s494 :: SWord16 = s66 + s366 s495 :: SBool = s11 /= s494 s496 :: SBool = s9 /= s494 s497 :: SBool = s7 /= s494 s498 :: SBool = s5 /= s494 s499 :: SBool = s3 /= s494 s500 :: SWord16 = s123 + s372 s501 :: SBool = s88 /= s500 s502 :: SWord16 = s66 + s374 s503 :: SBool = s11 /= s502 s504 :: SBool = s9 /= s502 s505 :: SBool = s7 /= s502 s506 :: SBool = s5 /= s502 s507 :: SBool = s3 /= s502 s508 :: SWord16 = s123 + s380 s509 :: SBool = s88 /= s508 s510 :: SWord16 = s66 + s390 s511 :: SBool = s11 /= s510 s512 :: SBool = s9 /= s510 s513 :: SBool = s7 /= s510 s514 :: SBool = s5 /= s510 s515 :: SBool = s3 /= s510 s516 :: SWord16 = s123 + s396 s517 :: SBool = s88 /= s516 s518 :: SWord16 = s66 + s414 s519 :: SBool = s11 /= s518 s520 :: SBool = s9 /= s518 s521 :: SBool = s7 /= s518 s522 :: SBool = s5 /= s518 s523 :: SBool = s3 /= s518 s524 :: SWord16 = s123 + s420 s525 :: SBool = s88 /= s524 s526 :: SWord16 = s66 + s446 s527 :: SBool = s11 /= s526 s528 :: SBool = s9 /= s526 s529 :: SBool = s7 /= s526 s530 :: SBool = s5 /= s526 s531 :: SBool = s3 /= s526 s532 :: SWord16 = s123 + s452 s533 :: SBool = s88 /= s532 s534 :: SWord16 = s66 + s486 s535 :: SBool = s11 /= s534 s536 :: SBool = s9 /= s534 s537 :: SBool = s7 /= s534 s538 :: SBool = s5 /= s534 s539 :: SBool = s3 /= s534 s540 :: SWord16 = s123 + s492 s541 :: SBool = s88 /= s540 s542 :: SBool = s0 >= s18 s543 :: SBool = s18 >= s30 s544 :: SBool = s30 >= s42 s545 :: SBool = s42 >= s54 s546 :: SBool = s54 >= s66 s547 :: SBool = s545 & s546 s548 :: SBool = s544 & s547 s549 :: SBool = s543 & s548 s550 :: SBool = s542 & s549 s552 :: SBool = s534 == s551 CONSTRAINTS s17 s29 s41 s53 s65 s77 s79 s80 s81 s82 s83 s89 s91 s92 s93 s94 s95 s98 s100 s101 s102 s103 s104 s107 s109 s110 s111 s112 s113 s116 s118 s119 s120 s121 s122 s125 s127 s128 s129 s130 s131 s133 s135 s136 s137 s138 s139 s141 s143 s144 s145 s146 s147 s149 s151 s152 s153 s154 s155 s157 s159 s160 s161 s162 s163 s165 s167 s168 s169 s170 s171 s173 s175 s176 s177 s178 s179 s181 s183 s184 s185 s186 s187 s189 s191 s192 s193 s194 s195 s197 s199 s200 s201 s202 s203 s205 s207 s208 s209 s210 s211 s213 s215 s216 s217 s218 s219 s221 s223 s224 s225 s226 s227 s229 s231 s232 s233 s234 s235 s237 s239 s240 s241 s242 s243 s245 s247 s248 s249 s250 s251 s253 s255 s256 s257 s258 s259 s261 s263 s264 s265 s266 s267 s269 s271 s272 s273 s274 s275 s277 s279 s280 s281 s282 s283 s285 s287 s288 s289 s290 s291 s293 s295 s296 s297 s298 s299 s301 s303 s304 s305 s306 s307 s309 s311 s312 s313 s314 s315 s317 s319 s320 s321 s322 s323 s325 s327 s328 s329 s330 s331 s333 s335 s336 s337 s338 s339 s341 s343 s344 s345 s346 s347 s349 s351 s352 s353 s354 s355 s357 s359 s360 s361 s362 s363 s365 s367 s368 s369 s370 s371 s373 s375 s376 s377 s378 s379 s381 s383 s384 s385 s386 s387 s389 s391 s392 s393 s394 s395 s397 s399 s400 s401 s402 s403 s405 s407 s408 s409 s410 s411 s413 s415 s416 s417 s418 s419 s421 s423 s424 s425 s426 s427 s429 s431 s432 s433 s434 s435 s437 s439 s440 s441 s442 s443 s445 s447 s448 s449 s450 s451 s453 s455 s456 s457 s458 s459 s461 s463 s464 s465 s466 s467 s469 s471 s472 s473 s474 s475 s477 s479 s480 s481 s482 s483 s485 s487 s488 s489 s490 s491 s493 s495 s496 s497 s498 s499 s501 s503 s504 s505 s506 s507 s509 s511 s512 s513 s514 s515 s517 s519 s520 s521 s522 s523 s525 s527 s528 s529 s530 s531 s533 s535 s536 s537 s538 s539 s541 s550 ASSERTIONS OUTPUTS s552sbv-5.12/SBVUnitTest/GoldFiles/counts.gold0000644000000000000000000020034112725411266016613 0ustar0000000000000000INPUTS s0 :: SWord8 s1 :: SWord8 s2 :: SWord8 s3 :: SWord8 s4 :: SWord8 s5 :: SWord8 s6 :: SWord8 s7 :: SWord8 s8 :: SWord8 s9 :: SWord8 CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s10 = 10 :: Word8 s12 = 0 :: Word8 s32 = 2 :: Word8 s33 = 1 :: Word8 s35 = 100 :: Word8 s555 = 3 :: Word8 s716 = 4 :: Word8 s877 = 5 :: Word8 s1038 = 6 :: Word8 s1199 = 7 :: Word8 s1360 = 8 :: Word8 s1521 = 9 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s11 :: SBool = s9 < s10 s13 :: SBool = s9 == s12 s14 :: SBool = s8 < s10 s15 :: SBool = s8 == s12 s16 :: SBool = s7 < s10 s17 :: SBool = s7 == s12 s18 :: SBool = s6 < s10 s19 :: SBool = s6 == s12 s20 :: SBool = s5 < s10 s21 :: SBool = s5 == s12 s22 :: SBool = s4 < s10 s23 :: SBool = s4 == s12 s24 :: SBool = s3 < s10 s25 :: SBool = s3 == s12 s26 :: SBool = s2 < s10 s27 :: SBool = s2 == s12 s28 :: SBool = s1 < s10 s29 :: SBool = s1 == s12 s30 :: SBool = s0 < s10 s31 :: SBool = s0 == s12 s34 :: SWord8 = if s31 then s32 else s33 s36 :: SBool = s0 < s35 s37 :: SWord8 = s0 rem s10 s38 :: SBool = s12 == s37 s39 :: SWord8 = s0 quot s10 s40 :: SWord8 = s39 rem s10 s41 :: SBool = s12 == s40 s42 :: SWord8 = if s41 then s32 else s33 s43 :: SWord8 = s33 + s42 s44 :: SWord8 = if s38 then s43 else s42 s45 :: SWord8 = s39 quot s10 s46 :: SBool = s12 == s45 s47 :: SWord8 = if s46 then s32 else s33 s48 :: SWord8 = s33 + s47 s49 :: SWord8 = if s41 then s48 else s47 s50 :: SWord8 = s33 + s49 s51 :: SWord8 = if s38 then s50 else s49 s52 :: SWord8 = if s36 then s44 else s51 s53 :: SWord8 = if s30 then s34 else s52 s54 :: SWord8 = s33 + s53 s55 :: SWord8 = if s29 then s54 else s53 s56 :: SBool = s1 < s35 s57 :: SWord8 = s1 rem s10 s58 :: SBool = s12 == s57 s59 :: SWord8 = s1 quot s10 s60 :: SWord8 = s59 rem s10 s61 :: SBool = s12 == s60 s62 :: SWord8 = if s61 then s54 else s53 s63 :: SWord8 = s33 + s62 s64 :: SWord8 = if s58 then s63 else s62 s65 :: SWord8 = s59 quot s10 s66 :: SBool = s12 == s65 s67 :: SWord8 = if s66 then s54 else s53 s68 :: SWord8 = s33 + s67 s69 :: SWord8 = if s61 then s68 else s67 s70 :: SWord8 = s33 + s69 s71 :: SWord8 = if s58 then s70 else s69 s72 :: SWord8 = if s56 then s64 else s71 s73 :: SWord8 = if s28 then s55 else s72 s74 :: SWord8 = s33 + s73 s75 :: SWord8 = if s27 then s74 else s73 s76 :: SBool = s2 < s35 s77 :: SWord8 = s2 rem s10 s78 :: SBool = s12 == s77 s79 :: SWord8 = s2 quot s10 s80 :: SWord8 = s79 rem s10 s81 :: SBool = s12 == s80 s82 :: SWord8 = if s81 then s74 else s73 s83 :: SWord8 = s33 + s82 s84 :: SWord8 = if s78 then s83 else s82 s85 :: SWord8 = s79 quot s10 s86 :: SBool = s12 == s85 s87 :: SWord8 = if s86 then s74 else s73 s88 :: SWord8 = s33 + s87 s89 :: SWord8 = if s81 then s88 else s87 s90 :: SWord8 = s33 + s89 s91 :: SWord8 = if s78 then s90 else s89 s92 :: SWord8 = if s76 then s84 else s91 s93 :: SWord8 = if s26 then s75 else s92 s94 :: SWord8 = s33 + s93 s95 :: SWord8 = if s25 then s94 else s93 s96 :: SBool = s3 < s35 s97 :: SWord8 = s3 rem s10 s98 :: SBool = s12 == s97 s99 :: SWord8 = s3 quot s10 s100 :: SWord8 = s99 rem s10 s101 :: SBool = s12 == s100 s102 :: SWord8 = if s101 then s94 else s93 s103 :: SWord8 = s33 + s102 s104 :: SWord8 = if s98 then s103 else s102 s105 :: SWord8 = s99 quot s10 s106 :: SBool = s12 == s105 s107 :: SWord8 = if s106 then s94 else s93 s108 :: SWord8 = s33 + s107 s109 :: SWord8 = if s101 then s108 else s107 s110 :: SWord8 = s33 + s109 s111 :: SWord8 = if s98 then s110 else s109 s112 :: SWord8 = if s96 then s104 else s111 s113 :: SWord8 = if s24 then s95 else s112 s114 :: SWord8 = s33 + s113 s115 :: SWord8 = if s23 then s114 else s113 s116 :: SBool = s4 < s35 s117 :: SWord8 = s4 rem s10 s118 :: SBool = s12 == s117 s119 :: SWord8 = s4 quot s10 s120 :: SWord8 = s119 rem s10 s121 :: SBool = s12 == s120 s122 :: SWord8 = if s121 then s114 else s113 s123 :: SWord8 = s33 + s122 s124 :: SWord8 = if s118 then s123 else s122 s125 :: SWord8 = s119 quot s10 s126 :: SBool = s12 == s125 s127 :: SWord8 = if s126 then s114 else s113 s128 :: SWord8 = s33 + s127 s129 :: SWord8 = if s121 then s128 else s127 s130 :: SWord8 = s33 + s129 s131 :: SWord8 = if s118 then s130 else s129 s132 :: SWord8 = if s116 then s124 else s131 s133 :: SWord8 = if s22 then s115 else s132 s134 :: SWord8 = s33 + s133 s135 :: SWord8 = if s21 then s134 else s133 s136 :: SBool = s5 < s35 s137 :: SWord8 = s5 rem s10 s138 :: SBool = s12 == s137 s139 :: SWord8 = s5 quot s10 s140 :: SWord8 = s139 rem s10 s141 :: SBool = s12 == s140 s142 :: SWord8 = if s141 then s134 else s133 s143 :: SWord8 = s33 + s142 s144 :: SWord8 = if s138 then s143 else s142 s145 :: SWord8 = s139 quot s10 s146 :: SBool = s12 == s145 s147 :: SWord8 = if s146 then s134 else s133 s148 :: SWord8 = s33 + s147 s149 :: SWord8 = if s141 then s148 else s147 s150 :: SWord8 = s33 + s149 s151 :: SWord8 = if s138 then s150 else s149 s152 :: SWord8 = if s136 then s144 else s151 s153 :: SWord8 = if s20 then s135 else s152 s154 :: SWord8 = s33 + s153 s155 :: SWord8 = if s19 then s154 else s153 s156 :: SBool = s6 < s35 s157 :: SWord8 = s6 rem s10 s158 :: SBool = s12 == s157 s159 :: SWord8 = s6 quot s10 s160 :: SWord8 = s159 rem s10 s161 :: SBool = s12 == s160 s162 :: SWord8 = if s161 then s154 else s153 s163 :: SWord8 = s33 + s162 s164 :: SWord8 = if s158 then s163 else s162 s165 :: SWord8 = s159 quot s10 s166 :: SBool = s12 == s165 s167 :: SWord8 = if s166 then s154 else s153 s168 :: SWord8 = s33 + s167 s169 :: SWord8 = if s161 then s168 else s167 s170 :: SWord8 = s33 + s169 s171 :: SWord8 = if s158 then s170 else s169 s172 :: SWord8 = if s156 then s164 else s171 s173 :: SWord8 = if s18 then s155 else s172 s174 :: SWord8 = s33 + s173 s175 :: SWord8 = if s17 then s174 else s173 s176 :: SBool = s7 < s35 s177 :: SWord8 = s7 rem s10 s178 :: SBool = s12 == s177 s179 :: SWord8 = s7 quot s10 s180 :: SWord8 = s179 rem s10 s181 :: SBool = s12 == s180 s182 :: SWord8 = if s181 then s174 else s173 s183 :: SWord8 = s33 + s182 s184 :: SWord8 = if s178 then s183 else s182 s185 :: SWord8 = s179 quot s10 s186 :: SBool = s12 == s185 s187 :: SWord8 = if s186 then s174 else s173 s188 :: SWord8 = s33 + s187 s189 :: SWord8 = if s181 then s188 else s187 s190 :: SWord8 = s33 + s189 s191 :: SWord8 = if s178 then s190 else s189 s192 :: SWord8 = if s176 then s184 else s191 s193 :: SWord8 = if s16 then s175 else s192 s194 :: SWord8 = s33 + s193 s195 :: SWord8 = if s15 then s194 else s193 s196 :: SBool = s8 < s35 s197 :: SWord8 = s8 rem s10 s198 :: SBool = s12 == s197 s199 :: SWord8 = s8 quot s10 s200 :: SWord8 = s199 rem s10 s201 :: SBool = s12 == s200 s202 :: SWord8 = if s201 then s194 else s193 s203 :: SWord8 = s33 + s202 s204 :: SWord8 = if s198 then s203 else s202 s205 :: SWord8 = s199 quot s10 s206 :: SBool = s12 == s205 s207 :: SWord8 = if s206 then s194 else s193 s208 :: SWord8 = s33 + s207 s209 :: SWord8 = if s201 then s208 else s207 s210 :: SWord8 = s33 + s209 s211 :: SWord8 = if s198 then s210 else s209 s212 :: SWord8 = if s196 then s204 else s211 s213 :: SWord8 = if s14 then s195 else s212 s214 :: SWord8 = s33 + s213 s215 :: SWord8 = if s13 then s214 else s213 s216 :: SBool = s9 < s35 s217 :: SWord8 = s9 rem s10 s218 :: SBool = s12 == s217 s219 :: SWord8 = s9 quot s10 s220 :: SWord8 = s219 rem s10 s221 :: SBool = s12 == s220 s222 :: SWord8 = if s221 then s214 else s213 s223 :: SWord8 = s33 + s222 s224 :: SWord8 = if s218 then s223 else s222 s225 :: SWord8 = s219 quot s10 s226 :: SBool = s12 == s225 s227 :: SWord8 = if s226 then s214 else s213 s228 :: SWord8 = s33 + s227 s229 :: SWord8 = if s221 then s228 else s227 s230 :: SWord8 = s33 + s229 s231 :: SWord8 = if s218 then s230 else s229 s232 :: SWord8 = if s216 then s224 else s231 s233 :: SWord8 = if s11 then s215 else s232 s234 :: SBool = s0 == s233 s235 :: SBool = s9 == s33 s236 :: SBool = s8 == s33 s237 :: SBool = s7 == s33 s238 :: SBool = s6 == s33 s239 :: SBool = s5 == s33 s240 :: SBool = s4 == s33 s241 :: SBool = s3 == s33 s242 :: SBool = s2 == s33 s243 :: SBool = s1 == s33 s244 :: SBool = s0 == s33 s245 :: SWord8 = if s244 then s32 else s33 s246 :: SBool = s33 == s37 s247 :: SBool = s33 == s40 s248 :: SWord8 = if s247 then s32 else s33 s249 :: SWord8 = s33 + s248 s250 :: SWord8 = if s246 then s249 else s248 s251 :: SBool = s33 == s45 s252 :: SWord8 = if s251 then s32 else s33 s253 :: SWord8 = s33 + s252 s254 :: SWord8 = if s247 then s253 else s252 s255 :: SWord8 = s33 + s254 s256 :: SWord8 = if s246 then s255 else s254 s257 :: SWord8 = if s36 then s250 else s256 s258 :: SWord8 = if s30 then s245 else s257 s259 :: SWord8 = s33 + s258 s260 :: SWord8 = if s243 then s259 else s258 s261 :: SBool = s33 == s57 s262 :: SBool = s33 == s60 s263 :: SWord8 = if s262 then s259 else s258 s264 :: SWord8 = s33 + s263 s265 :: SWord8 = if s261 then s264 else s263 s266 :: SBool = s33 == s65 s267 :: SWord8 = if s266 then s259 else s258 s268 :: SWord8 = s33 + s267 s269 :: SWord8 = if s262 then s268 else s267 s270 :: SWord8 = s33 + s269 s271 :: SWord8 = if s261 then s270 else s269 s272 :: SWord8 = if s56 then s265 else s271 s273 :: SWord8 = if s28 then s260 else s272 s274 :: SWord8 = s33 + s273 s275 :: SWord8 = if s242 then s274 else s273 s276 :: SBool = s33 == s77 s277 :: SBool = s33 == s80 s278 :: SWord8 = if s277 then s274 else s273 s279 :: SWord8 = s33 + s278 s280 :: SWord8 = if s276 then s279 else s278 s281 :: SBool = s33 == s85 s282 :: SWord8 = if s281 then s274 else s273 s283 :: SWord8 = s33 + s282 s284 :: SWord8 = if s277 then s283 else s282 s285 :: SWord8 = s33 + s284 s286 :: SWord8 = if s276 then s285 else s284 s287 :: SWord8 = if s76 then s280 else s286 s288 :: SWord8 = if s26 then s275 else s287 s289 :: SWord8 = s33 + s288 s290 :: SWord8 = if s241 then s289 else s288 s291 :: SBool = s33 == s97 s292 :: SBool = s33 == s100 s293 :: SWord8 = if s292 then s289 else s288 s294 :: SWord8 = s33 + s293 s295 :: SWord8 = if s291 then s294 else s293 s296 :: SBool = s33 == s105 s297 :: SWord8 = if s296 then s289 else s288 s298 :: SWord8 = s33 + s297 s299 :: SWord8 = if s292 then s298 else s297 s300 :: SWord8 = s33 + s299 s301 :: SWord8 = if s291 then s300 else s299 s302 :: SWord8 = if s96 then s295 else s301 s303 :: SWord8 = if s24 then s290 else s302 s304 :: SWord8 = s33 + s303 s305 :: SWord8 = if s240 then s304 else s303 s306 :: SBool = s33 == s117 s307 :: SBool = s33 == s120 s308 :: SWord8 = if s307 then s304 else s303 s309 :: SWord8 = s33 + s308 s310 :: SWord8 = if s306 then s309 else s308 s311 :: SBool = s33 == s125 s312 :: SWord8 = if s311 then s304 else s303 s313 :: SWord8 = s33 + s312 s314 :: SWord8 = if s307 then s313 else s312 s315 :: SWord8 = s33 + s314 s316 :: SWord8 = if s306 then s315 else s314 s317 :: SWord8 = if s116 then s310 else s316 s318 :: SWord8 = if s22 then s305 else s317 s319 :: SWord8 = s33 + s318 s320 :: SWord8 = if s239 then s319 else s318 s321 :: SBool = s33 == s137 s322 :: SBool = s33 == s140 s323 :: SWord8 = if s322 then s319 else s318 s324 :: SWord8 = s33 + s323 s325 :: SWord8 = if s321 then s324 else s323 s326 :: SBool = s33 == s145 s327 :: SWord8 = if s326 then s319 else s318 s328 :: SWord8 = s33 + s327 s329 :: SWord8 = if s322 then s328 else s327 s330 :: SWord8 = s33 + s329 s331 :: SWord8 = if s321 then s330 else s329 s332 :: SWord8 = if s136 then s325 else s331 s333 :: SWord8 = if s20 then s320 else s332 s334 :: SWord8 = s33 + s333 s335 :: SWord8 = if s238 then s334 else s333 s336 :: SBool = s33 == s157 s337 :: SBool = s33 == s160 s338 :: SWord8 = if s337 then s334 else s333 s339 :: SWord8 = s33 + s338 s340 :: SWord8 = if s336 then s339 else s338 s341 :: SBool = s33 == s165 s342 :: SWord8 = if s341 then s334 else s333 s343 :: SWord8 = s33 + s342 s344 :: SWord8 = if s337 then s343 else s342 s345 :: SWord8 = s33 + s344 s346 :: SWord8 = if s336 then s345 else s344 s347 :: SWord8 = if s156 then s340 else s346 s348 :: SWord8 = if s18 then s335 else s347 s349 :: SWord8 = s33 + s348 s350 :: SWord8 = if s237 then s349 else s348 s351 :: SBool = s33 == s177 s352 :: SBool = s33 == s180 s353 :: SWord8 = if s352 then s349 else s348 s354 :: SWord8 = s33 + s353 s355 :: SWord8 = if s351 then s354 else s353 s356 :: SBool = s33 == s185 s357 :: SWord8 = if s356 then s349 else s348 s358 :: SWord8 = s33 + s357 s359 :: SWord8 = if s352 then s358 else s357 s360 :: SWord8 = s33 + s359 s361 :: SWord8 = if s351 then s360 else s359 s362 :: SWord8 = if s176 then s355 else s361 s363 :: SWord8 = if s16 then s350 else s362 s364 :: SWord8 = s33 + s363 s365 :: SWord8 = if s236 then s364 else s363 s366 :: SBool = s33 == s197 s367 :: SBool = s33 == s200 s368 :: SWord8 = if s367 then s364 else s363 s369 :: SWord8 = s33 + s368 s370 :: SWord8 = if s366 then s369 else s368 s371 :: SBool = s33 == s205 s372 :: SWord8 = if s371 then s364 else s363 s373 :: SWord8 = s33 + s372 s374 :: SWord8 = if s367 then s373 else s372 s375 :: SWord8 = s33 + s374 s376 :: SWord8 = if s366 then s375 else s374 s377 :: SWord8 = if s196 then s370 else s376 s378 :: SWord8 = if s14 then s365 else s377 s379 :: SWord8 = s33 + s378 s380 :: SWord8 = if s235 then s379 else s378 s381 :: SBool = s33 == s217 s382 :: SBool = s33 == s220 s383 :: SWord8 = if s382 then s379 else s378 s384 :: SWord8 = s33 + s383 s385 :: SWord8 = if s381 then s384 else s383 s386 :: SBool = s33 == s225 s387 :: SWord8 = if s386 then s379 else s378 s388 :: SWord8 = s33 + s387 s389 :: SWord8 = if s382 then s388 else s387 s390 :: SWord8 = s33 + s389 s391 :: SWord8 = if s381 then s390 else s389 s392 :: SWord8 = if s216 then s385 else s391 s393 :: SWord8 = if s11 then s380 else s392 s394 :: SBool = s1 == s393 s395 :: SBool = s9 == s32 s396 :: SBool = s8 == s32 s397 :: SBool = s7 == s32 s398 :: SBool = s6 == s32 s399 :: SBool = s5 == s32 s400 :: SBool = s4 == s32 s401 :: SBool = s3 == s32 s402 :: SBool = s2 == s32 s403 :: SBool = s1 == s32 s404 :: SBool = s0 == s32 s405 :: SWord8 = if s404 then s32 else s33 s406 :: SBool = s32 == s37 s407 :: SBool = s32 == s40 s408 :: SWord8 = if s407 then s32 else s33 s409 :: SWord8 = s33 + s408 s410 :: SWord8 = if s406 then s409 else s408 s411 :: SBool = s32 == s45 s412 :: SWord8 = if s411 then s32 else s33 s413 :: SWord8 = s33 + s412 s414 :: SWord8 = if s407 then s413 else s412 s415 :: SWord8 = s33 + s414 s416 :: SWord8 = if s406 then s415 else s414 s417 :: SWord8 = if s36 then s410 else s416 s418 :: SWord8 = if s30 then s405 else s417 s419 :: SWord8 = s33 + s418 s420 :: SWord8 = if s403 then s419 else s418 s421 :: SBool = s32 == s57 s422 :: SBool = s32 == s60 s423 :: SWord8 = if s422 then s419 else s418 s424 :: SWord8 = s33 + s423 s425 :: SWord8 = if s421 then s424 else s423 s426 :: SBool = s32 == s65 s427 :: SWord8 = if s426 then s419 else s418 s428 :: SWord8 = s33 + s427 s429 :: SWord8 = if s422 then s428 else s427 s430 :: SWord8 = s33 + s429 s431 :: SWord8 = if s421 then s430 else s429 s432 :: SWord8 = if s56 then s425 else s431 s433 :: SWord8 = if s28 then s420 else s432 s434 :: SWord8 = s33 + s433 s435 :: SWord8 = if s402 then s434 else s433 s436 :: SBool = s32 == s77 s437 :: SBool = s32 == s80 s438 :: SWord8 = if s437 then s434 else s433 s439 :: SWord8 = s33 + s438 s440 :: SWord8 = if s436 then s439 else s438 s441 :: SBool = s32 == s85 s442 :: SWord8 = if s441 then s434 else s433 s443 :: SWord8 = s33 + s442 s444 :: SWord8 = if s437 then s443 else s442 s445 :: SWord8 = s33 + s444 s446 :: SWord8 = if s436 then s445 else s444 s447 :: SWord8 = if s76 then s440 else s446 s448 :: SWord8 = if s26 then s435 else s447 s449 :: SWord8 = s33 + s448 s450 :: SWord8 = if s401 then s449 else s448 s451 :: SBool = s32 == s97 s452 :: SBool = s32 == s100 s453 :: SWord8 = if s452 then s449 else s448 s454 :: SWord8 = s33 + s453 s455 :: SWord8 = if s451 then s454 else s453 s456 :: SBool = s32 == s105 s457 :: SWord8 = if s456 then s449 else s448 s458 :: SWord8 = s33 + s457 s459 :: SWord8 = if s452 then s458 else s457 s460 :: SWord8 = s33 + s459 s461 :: SWord8 = if s451 then s460 else s459 s462 :: SWord8 = if s96 then s455 else s461 s463 :: SWord8 = if s24 then s450 else s462 s464 :: SWord8 = s33 + s463 s465 :: SWord8 = if s400 then s464 else s463 s466 :: SBool = s32 == s117 s467 :: SBool = s32 == s120 s468 :: SWord8 = if s467 then s464 else s463 s469 :: SWord8 = s33 + s468 s470 :: SWord8 = if s466 then s469 else s468 s471 :: SBool = s32 == s125 s472 :: SWord8 = if s471 then s464 else s463 s473 :: SWord8 = s33 + s472 s474 :: SWord8 = if s467 then s473 else s472 s475 :: SWord8 = s33 + s474 s476 :: SWord8 = if s466 then s475 else s474 s477 :: SWord8 = if s116 then s470 else s476 s478 :: SWord8 = if s22 then s465 else s477 s479 :: SWord8 = s33 + s478 s480 :: SWord8 = if s399 then s479 else s478 s481 :: SBool = s32 == s137 s482 :: SBool = s32 == s140 s483 :: SWord8 = if s482 then s479 else s478 s484 :: SWord8 = s33 + s483 s485 :: SWord8 = if s481 then s484 else s483 s486 :: SBool = s32 == s145 s487 :: SWord8 = if s486 then s479 else s478 s488 :: SWord8 = s33 + s487 s489 :: SWord8 = if s482 then s488 else s487 s490 :: SWord8 = s33 + s489 s491 :: SWord8 = if s481 then s490 else s489 s492 :: SWord8 = if s136 then s485 else s491 s493 :: SWord8 = if s20 then s480 else s492 s494 :: SWord8 = s33 + s493 s495 :: SWord8 = if s398 then s494 else s493 s496 :: SBool = s32 == s157 s497 :: SBool = s32 == s160 s498 :: SWord8 = if s497 then s494 else s493 s499 :: SWord8 = s33 + s498 s500 :: SWord8 = if s496 then s499 else s498 s501 :: SBool = s32 == s165 s502 :: SWord8 = if s501 then s494 else s493 s503 :: SWord8 = s33 + s502 s504 :: SWord8 = if s497 then s503 else s502 s505 :: SWord8 = s33 + s504 s506 :: SWord8 = if s496 then s505 else s504 s507 :: SWord8 = if s156 then s500 else s506 s508 :: SWord8 = if s18 then s495 else s507 s509 :: SWord8 = s33 + s508 s510 :: SWord8 = if s397 then s509 else s508 s511 :: SBool = s32 == s177 s512 :: SBool = s32 == s180 s513 :: SWord8 = if s512 then s509 else s508 s514 :: SWord8 = s33 + s513 s515 :: SWord8 = if s511 then s514 else s513 s516 :: SBool = s32 == s185 s517 :: SWord8 = if s516 then s509 else s508 s518 :: SWord8 = s33 + s517 s519 :: SWord8 = if s512 then s518 else s517 s520 :: SWord8 = s33 + s519 s521 :: SWord8 = if s511 then s520 else s519 s522 :: SWord8 = if s176 then s515 else s521 s523 :: SWord8 = if s16 then s510 else s522 s524 :: SWord8 = s33 + s523 s525 :: SWord8 = if s396 then s524 else s523 s526 :: SBool = s32 == s197 s527 :: SBool = s32 == s200 s528 :: SWord8 = if s527 then s524 else s523 s529 :: SWord8 = s33 + s528 s530 :: SWord8 = if s526 then s529 else s528 s531 :: SBool = s32 == s205 s532 :: SWord8 = if s531 then s524 else s523 s533 :: SWord8 = s33 + s532 s534 :: SWord8 = if s527 then s533 else s532 s535 :: SWord8 = s33 + s534 s536 :: SWord8 = if s526 then s535 else s534 s537 :: SWord8 = if s196 then s530 else s536 s538 :: SWord8 = if s14 then s525 else s537 s539 :: SWord8 = s33 + s538 s540 :: SWord8 = if s395 then s539 else s538 s541 :: SBool = s32 == s217 s542 :: SBool = s32 == s220 s543 :: SWord8 = if s542 then s539 else s538 s544 :: SWord8 = s33 + s543 s545 :: SWord8 = if s541 then s544 else s543 s546 :: SBool = s32 == s225 s547 :: SWord8 = if s546 then s539 else s538 s548 :: SWord8 = s33 + s547 s549 :: SWord8 = if s542 then s548 else s547 s550 :: SWord8 = s33 + s549 s551 :: SWord8 = if s541 then s550 else s549 s552 :: SWord8 = if s216 then s545 else s551 s553 :: SWord8 = if s11 then s540 else s552 s554 :: SBool = s2 == s553 s556 :: SBool = s9 == s555 s557 :: SBool = s8 == s555 s558 :: SBool = s7 == s555 s559 :: SBool = s6 == s555 s560 :: SBool = s5 == s555 s561 :: SBool = s4 == s555 s562 :: SBool = s3 == s555 s563 :: SBool = s2 == s555 s564 :: SBool = s1 == s555 s565 :: SBool = s0 == s555 s566 :: SWord8 = if s565 then s32 else s33 s567 :: SBool = s37 == s555 s568 :: SBool = s40 == s555 s569 :: SWord8 = if s568 then s32 else s33 s570 :: SWord8 = s33 + s569 s571 :: SWord8 = if s567 then s570 else s569 s572 :: SBool = s45 == s555 s573 :: SWord8 = if s572 then s32 else s33 s574 :: SWord8 = s33 + s573 s575 :: SWord8 = if s568 then s574 else s573 s576 :: SWord8 = s33 + s575 s577 :: SWord8 = if s567 then s576 else s575 s578 :: SWord8 = if s36 then s571 else s577 s579 :: SWord8 = if s30 then s566 else s578 s580 :: SWord8 = s33 + s579 s581 :: SWord8 = if s564 then s580 else s579 s582 :: SBool = s57 == s555 s583 :: SBool = s60 == s555 s584 :: SWord8 = if s583 then s580 else s579 s585 :: SWord8 = s33 + s584 s586 :: SWord8 = if s582 then s585 else s584 s587 :: SBool = s65 == s555 s588 :: SWord8 = if s587 then s580 else s579 s589 :: SWord8 = s33 + s588 s590 :: SWord8 = if s583 then s589 else s588 s591 :: SWord8 = s33 + s590 s592 :: SWord8 = if s582 then s591 else s590 s593 :: SWord8 = if s56 then s586 else s592 s594 :: SWord8 = if s28 then s581 else s593 s595 :: SWord8 = s33 + s594 s596 :: SWord8 = if s563 then s595 else s594 s597 :: SBool = s77 == s555 s598 :: SBool = s80 == s555 s599 :: SWord8 = if s598 then s595 else s594 s600 :: SWord8 = s33 + s599 s601 :: SWord8 = if s597 then s600 else s599 s602 :: SBool = s85 == s555 s603 :: SWord8 = if s602 then s595 else s594 s604 :: SWord8 = s33 + s603 s605 :: SWord8 = if s598 then s604 else s603 s606 :: SWord8 = s33 + s605 s607 :: SWord8 = if s597 then s606 else s605 s608 :: SWord8 = if s76 then s601 else s607 s609 :: SWord8 = if s26 then s596 else s608 s610 :: SWord8 = s33 + s609 s611 :: SWord8 = if s562 then s610 else s609 s612 :: SBool = s97 == s555 s613 :: SBool = s100 == s555 s614 :: SWord8 = if s613 then s610 else s609 s615 :: SWord8 = s33 + s614 s616 :: SWord8 = if s612 then s615 else s614 s617 :: SBool = s105 == s555 s618 :: SWord8 = if s617 then s610 else s609 s619 :: SWord8 = s33 + s618 s620 :: SWord8 = if s613 then s619 else s618 s621 :: SWord8 = s33 + s620 s622 :: SWord8 = if s612 then s621 else s620 s623 :: SWord8 = if s96 then s616 else s622 s624 :: SWord8 = if s24 then s611 else s623 s625 :: SWord8 = s33 + s624 s626 :: SWord8 = if s561 then s625 else s624 s627 :: SBool = s117 == s555 s628 :: SBool = s120 == s555 s629 :: SWord8 = if s628 then s625 else s624 s630 :: SWord8 = s33 + s629 s631 :: SWord8 = if s627 then s630 else s629 s632 :: SBool = s125 == s555 s633 :: SWord8 = if s632 then s625 else s624 s634 :: SWord8 = s33 + s633 s635 :: SWord8 = if s628 then s634 else s633 s636 :: SWord8 = s33 + s635 s637 :: SWord8 = if s627 then s636 else s635 s638 :: SWord8 = if s116 then s631 else s637 s639 :: SWord8 = if s22 then s626 else s638 s640 :: SWord8 = s33 + s639 s641 :: SWord8 = if s560 then s640 else s639 s642 :: SBool = s137 == s555 s643 :: SBool = s140 == s555 s644 :: SWord8 = if s643 then s640 else s639 s645 :: SWord8 = s33 + s644 s646 :: SWord8 = if s642 then s645 else s644 s647 :: SBool = s145 == s555 s648 :: SWord8 = if s647 then s640 else s639 s649 :: SWord8 = s33 + s648 s650 :: SWord8 = if s643 then s649 else s648 s651 :: SWord8 = s33 + s650 s652 :: SWord8 = if s642 then s651 else s650 s653 :: SWord8 = if s136 then s646 else s652 s654 :: SWord8 = if s20 then s641 else s653 s655 :: SWord8 = s33 + s654 s656 :: SWord8 = if s559 then s655 else s654 s657 :: SBool = s157 == s555 s658 :: SBool = s160 == s555 s659 :: SWord8 = if s658 then s655 else s654 s660 :: SWord8 = s33 + s659 s661 :: SWord8 = if s657 then s660 else s659 s662 :: SBool = s165 == s555 s663 :: SWord8 = if s662 then s655 else s654 s664 :: SWord8 = s33 + s663 s665 :: SWord8 = if s658 then s664 else s663 s666 :: SWord8 = s33 + s665 s667 :: SWord8 = if s657 then s666 else s665 s668 :: SWord8 = if s156 then s661 else s667 s669 :: SWord8 = if s18 then s656 else s668 s670 :: SWord8 = s33 + s669 s671 :: SWord8 = if s558 then s670 else s669 s672 :: SBool = s177 == s555 s673 :: SBool = s180 == s555 s674 :: SWord8 = if s673 then s670 else s669 s675 :: SWord8 = s33 + s674 s676 :: SWord8 = if s672 then s675 else s674 s677 :: SBool = s185 == s555 s678 :: SWord8 = if s677 then s670 else s669 s679 :: SWord8 = s33 + s678 s680 :: SWord8 = if s673 then s679 else s678 s681 :: SWord8 = s33 + s680 s682 :: SWord8 = if s672 then s681 else s680 s683 :: SWord8 = if s176 then s676 else s682 s684 :: SWord8 = if s16 then s671 else s683 s685 :: SWord8 = s33 + s684 s686 :: SWord8 = if s557 then s685 else s684 s687 :: SBool = s197 == s555 s688 :: SBool = s200 == s555 s689 :: SWord8 = if s688 then s685 else s684 s690 :: SWord8 = s33 + s689 s691 :: SWord8 = if s687 then s690 else s689 s692 :: SBool = s205 == s555 s693 :: SWord8 = if s692 then s685 else s684 s694 :: SWord8 = s33 + s693 s695 :: SWord8 = if s688 then s694 else s693 s696 :: SWord8 = s33 + s695 s697 :: SWord8 = if s687 then s696 else s695 s698 :: SWord8 = if s196 then s691 else s697 s699 :: SWord8 = if s14 then s686 else s698 s700 :: SWord8 = s33 + s699 s701 :: SWord8 = if s556 then s700 else s699 s702 :: SBool = s217 == s555 s703 :: SBool = s220 == s555 s704 :: SWord8 = if s703 then s700 else s699 s705 :: SWord8 = s33 + s704 s706 :: SWord8 = if s702 then s705 else s704 s707 :: SBool = s225 == s555 s708 :: SWord8 = if s707 then s700 else s699 s709 :: SWord8 = s33 + s708 s710 :: SWord8 = if s703 then s709 else s708 s711 :: SWord8 = s33 + s710 s712 :: SWord8 = if s702 then s711 else s710 s713 :: SWord8 = if s216 then s706 else s712 s714 :: SWord8 = if s11 then s701 else s713 s715 :: SBool = s3 == s714 s717 :: SBool = s9 == s716 s718 :: SBool = s8 == s716 s719 :: SBool = s7 == s716 s720 :: SBool = s6 == s716 s721 :: SBool = s5 == s716 s722 :: SBool = s4 == s716 s723 :: SBool = s3 == s716 s724 :: SBool = s2 == s716 s725 :: SBool = s1 == s716 s726 :: SBool = s0 == s716 s727 :: SWord8 = if s726 then s32 else s33 s728 :: SBool = s37 == s716 s729 :: SBool = s40 == s716 s730 :: SWord8 = if s729 then s32 else s33 s731 :: SWord8 = s33 + s730 s732 :: SWord8 = if s728 then s731 else s730 s733 :: SBool = s45 == s716 s734 :: SWord8 = if s733 then s32 else s33 s735 :: SWord8 = s33 + s734 s736 :: SWord8 = if s729 then s735 else s734 s737 :: SWord8 = s33 + s736 s738 :: SWord8 = if s728 then s737 else s736 s739 :: SWord8 = if s36 then s732 else s738 s740 :: SWord8 = if s30 then s727 else s739 s741 :: SWord8 = s33 + s740 s742 :: SWord8 = if s725 then s741 else s740 s743 :: SBool = s57 == s716 s744 :: SBool = s60 == s716 s745 :: SWord8 = if s744 then s741 else s740 s746 :: SWord8 = s33 + s745 s747 :: SWord8 = if s743 then s746 else s745 s748 :: SBool = s65 == s716 s749 :: SWord8 = if s748 then s741 else s740 s750 :: SWord8 = s33 + s749 s751 :: SWord8 = if s744 then s750 else s749 s752 :: SWord8 = s33 + s751 s753 :: SWord8 = if s743 then s752 else s751 s754 :: SWord8 = if s56 then s747 else s753 s755 :: SWord8 = if s28 then s742 else s754 s756 :: SWord8 = s33 + s755 s757 :: SWord8 = if s724 then s756 else s755 s758 :: SBool = s77 == s716 s759 :: SBool = s80 == s716 s760 :: SWord8 = if s759 then s756 else s755 s761 :: SWord8 = s33 + s760 s762 :: SWord8 = if s758 then s761 else s760 s763 :: SBool = s85 == s716 s764 :: SWord8 = if s763 then s756 else s755 s765 :: SWord8 = s33 + s764 s766 :: SWord8 = if s759 then s765 else s764 s767 :: SWord8 = s33 + s766 s768 :: SWord8 = if s758 then s767 else s766 s769 :: SWord8 = if s76 then s762 else s768 s770 :: SWord8 = if s26 then s757 else s769 s771 :: SWord8 = s33 + s770 s772 :: SWord8 = if s723 then s771 else s770 s773 :: SBool = s97 == s716 s774 :: SBool = s100 == s716 s775 :: SWord8 = if s774 then s771 else s770 s776 :: SWord8 = s33 + s775 s777 :: SWord8 = if s773 then s776 else s775 s778 :: SBool = s105 == s716 s779 :: SWord8 = if s778 then s771 else s770 s780 :: SWord8 = s33 + s779 s781 :: SWord8 = if s774 then s780 else s779 s782 :: SWord8 = s33 + s781 s783 :: SWord8 = if s773 then s782 else s781 s784 :: SWord8 = if s96 then s777 else s783 s785 :: SWord8 = if s24 then s772 else s784 s786 :: SWord8 = s33 + s785 s787 :: SWord8 = if s722 then s786 else s785 s788 :: SBool = s117 == s716 s789 :: SBool = s120 == s716 s790 :: SWord8 = if s789 then s786 else s785 s791 :: SWord8 = s33 + s790 s792 :: SWord8 = if s788 then s791 else s790 s793 :: SBool = s125 == s716 s794 :: SWord8 = if s793 then s786 else s785 s795 :: SWord8 = s33 + s794 s796 :: SWord8 = if s789 then s795 else s794 s797 :: SWord8 = s33 + s796 s798 :: SWord8 = if s788 then s797 else s796 s799 :: SWord8 = if s116 then s792 else s798 s800 :: SWord8 = if s22 then s787 else s799 s801 :: SWord8 = s33 + s800 s802 :: SWord8 = if s721 then s801 else s800 s803 :: SBool = s137 == s716 s804 :: SBool = s140 == s716 s805 :: SWord8 = if s804 then s801 else s800 s806 :: SWord8 = s33 + s805 s807 :: SWord8 = if s803 then s806 else s805 s808 :: SBool = s145 == s716 s809 :: SWord8 = if s808 then s801 else s800 s810 :: SWord8 = s33 + s809 s811 :: SWord8 = if s804 then s810 else s809 s812 :: SWord8 = s33 + s811 s813 :: SWord8 = if s803 then s812 else s811 s814 :: SWord8 = if s136 then s807 else s813 s815 :: SWord8 = if s20 then s802 else s814 s816 :: SWord8 = s33 + s815 s817 :: SWord8 = if s720 then s816 else s815 s818 :: SBool = s157 == s716 s819 :: SBool = s160 == s716 s820 :: SWord8 = if s819 then s816 else s815 s821 :: SWord8 = s33 + s820 s822 :: SWord8 = if s818 then s821 else s820 s823 :: SBool = s165 == s716 s824 :: SWord8 = if s823 then s816 else s815 s825 :: SWord8 = s33 + s824 s826 :: SWord8 = if s819 then s825 else s824 s827 :: SWord8 = s33 + s826 s828 :: SWord8 = if s818 then s827 else s826 s829 :: SWord8 = if s156 then s822 else s828 s830 :: SWord8 = if s18 then s817 else s829 s831 :: SWord8 = s33 + s830 s832 :: SWord8 = if s719 then s831 else s830 s833 :: SBool = s177 == s716 s834 :: SBool = s180 == s716 s835 :: SWord8 = if s834 then s831 else s830 s836 :: SWord8 = s33 + s835 s837 :: SWord8 = if s833 then s836 else s835 s838 :: SBool = s185 == s716 s839 :: SWord8 = if s838 then s831 else s830 s840 :: SWord8 = s33 + s839 s841 :: SWord8 = if s834 then s840 else s839 s842 :: SWord8 = s33 + s841 s843 :: SWord8 = if s833 then s842 else s841 s844 :: SWord8 = if s176 then s837 else s843 s845 :: SWord8 = if s16 then s832 else s844 s846 :: SWord8 = s33 + s845 s847 :: SWord8 = if s718 then s846 else s845 s848 :: SBool = s197 == s716 s849 :: SBool = s200 == s716 s850 :: SWord8 = if s849 then s846 else s845 s851 :: SWord8 = s33 + s850 s852 :: SWord8 = if s848 then s851 else s850 s853 :: SBool = s205 == s716 s854 :: SWord8 = if s853 then s846 else s845 s855 :: SWord8 = s33 + s854 s856 :: SWord8 = if s849 then s855 else s854 s857 :: SWord8 = s33 + s856 s858 :: SWord8 = if s848 then s857 else s856 s859 :: SWord8 = if s196 then s852 else s858 s860 :: SWord8 = if s14 then s847 else s859 s861 :: SWord8 = s33 + s860 s862 :: SWord8 = if s717 then s861 else s860 s863 :: SBool = s217 == s716 s864 :: SBool = s220 == s716 s865 :: SWord8 = if s864 then s861 else s860 s866 :: SWord8 = s33 + s865 s867 :: SWord8 = if s863 then s866 else s865 s868 :: SBool = s225 == s716 s869 :: SWord8 = if s868 then s861 else s860 s870 :: SWord8 = s33 + s869 s871 :: SWord8 = if s864 then s870 else s869 s872 :: SWord8 = s33 + s871 s873 :: SWord8 = if s863 then s872 else s871 s874 :: SWord8 = if s216 then s867 else s873 s875 :: SWord8 = if s11 then s862 else s874 s876 :: SBool = s4 == s875 s878 :: SBool = s9 == s877 s879 :: SBool = s8 == s877 s880 :: SBool = s7 == s877 s881 :: SBool = s6 == s877 s882 :: SBool = s5 == s877 s883 :: SBool = s4 == s877 s884 :: SBool = s3 == s877 s885 :: SBool = s2 == s877 s886 :: SBool = s1 == s877 s887 :: SBool = s0 == s877 s888 :: SWord8 = if s887 then s32 else s33 s889 :: SBool = s37 == s877 s890 :: SBool = s40 == s877 s891 :: SWord8 = if s890 then s32 else s33 s892 :: SWord8 = s33 + s891 s893 :: SWord8 = if s889 then s892 else s891 s894 :: SBool = s45 == s877 s895 :: SWord8 = if s894 then s32 else s33 s896 :: SWord8 = s33 + s895 s897 :: SWord8 = if s890 then s896 else s895 s898 :: SWord8 = s33 + s897 s899 :: SWord8 = if s889 then s898 else s897 s900 :: SWord8 = if s36 then s893 else s899 s901 :: SWord8 = if s30 then s888 else s900 s902 :: SWord8 = s33 + s901 s903 :: SWord8 = if s886 then s902 else s901 s904 :: SBool = s57 == s877 s905 :: SBool = s60 == s877 s906 :: SWord8 = if s905 then s902 else s901 s907 :: SWord8 = s33 + s906 s908 :: SWord8 = if s904 then s907 else s906 s909 :: SBool = s65 == s877 s910 :: SWord8 = if s909 then s902 else s901 s911 :: SWord8 = s33 + s910 s912 :: SWord8 = if s905 then s911 else s910 s913 :: SWord8 = s33 + s912 s914 :: SWord8 = if s904 then s913 else s912 s915 :: SWord8 = if s56 then s908 else s914 s916 :: SWord8 = if s28 then s903 else s915 s917 :: SWord8 = s33 + s916 s918 :: SWord8 = if s885 then s917 else s916 s919 :: SBool = s77 == s877 s920 :: SBool = s80 == s877 s921 :: SWord8 = if s920 then s917 else s916 s922 :: SWord8 = s33 + s921 s923 :: SWord8 = if s919 then s922 else s921 s924 :: SBool = s85 == s877 s925 :: SWord8 = if s924 then s917 else s916 s926 :: SWord8 = s33 + s925 s927 :: SWord8 = if s920 then s926 else s925 s928 :: SWord8 = s33 + s927 s929 :: SWord8 = if s919 then s928 else s927 s930 :: SWord8 = if s76 then s923 else s929 s931 :: SWord8 = if s26 then s918 else s930 s932 :: SWord8 = s33 + s931 s933 :: SWord8 = if s884 then s932 else s931 s934 :: SBool = s97 == s877 s935 :: SBool = s100 == s877 s936 :: SWord8 = if s935 then s932 else s931 s937 :: SWord8 = s33 + s936 s938 :: SWord8 = if s934 then s937 else s936 s939 :: SBool = s105 == s877 s940 :: SWord8 = if s939 then s932 else s931 s941 :: SWord8 = s33 + s940 s942 :: SWord8 = if s935 then s941 else s940 s943 :: SWord8 = s33 + s942 s944 :: SWord8 = if s934 then s943 else s942 s945 :: SWord8 = if s96 then s938 else s944 s946 :: SWord8 = if s24 then s933 else s945 s947 :: SWord8 = s33 + s946 s948 :: SWord8 = if s883 then s947 else s946 s949 :: SBool = s117 == s877 s950 :: SBool = s120 == s877 s951 :: SWord8 = if s950 then s947 else s946 s952 :: SWord8 = s33 + s951 s953 :: SWord8 = if s949 then s952 else s951 s954 :: SBool = s125 == s877 s955 :: SWord8 = if s954 then s947 else s946 s956 :: SWord8 = s33 + s955 s957 :: SWord8 = if s950 then s956 else s955 s958 :: SWord8 = s33 + s957 s959 :: SWord8 = if s949 then s958 else s957 s960 :: SWord8 = if s116 then s953 else s959 s961 :: SWord8 = if s22 then s948 else s960 s962 :: SWord8 = s33 + s961 s963 :: SWord8 = if s882 then s962 else s961 s964 :: SBool = s137 == s877 s965 :: SBool = s140 == s877 s966 :: SWord8 = if s965 then s962 else s961 s967 :: SWord8 = s33 + s966 s968 :: SWord8 = if s964 then s967 else s966 s969 :: SBool = s145 == s877 s970 :: SWord8 = if s969 then s962 else s961 s971 :: SWord8 = s33 + s970 s972 :: SWord8 = if s965 then s971 else s970 s973 :: SWord8 = s33 + s972 s974 :: SWord8 = if s964 then s973 else s972 s975 :: SWord8 = if s136 then s968 else s974 s976 :: SWord8 = if s20 then s963 else s975 s977 :: SWord8 = s33 + s976 s978 :: SWord8 = if s881 then s977 else s976 s979 :: SBool = s157 == s877 s980 :: SBool = s160 == s877 s981 :: SWord8 = if s980 then s977 else s976 s982 :: SWord8 = s33 + s981 s983 :: SWord8 = if s979 then s982 else s981 s984 :: SBool = s165 == s877 s985 :: SWord8 = if s984 then s977 else s976 s986 :: SWord8 = s33 + s985 s987 :: SWord8 = if s980 then s986 else s985 s988 :: SWord8 = s33 + s987 s989 :: SWord8 = if s979 then s988 else s987 s990 :: SWord8 = if s156 then s983 else s989 s991 :: SWord8 = if s18 then s978 else s990 s992 :: SWord8 = s33 + s991 s993 :: SWord8 = if s880 then s992 else s991 s994 :: SBool = s177 == s877 s995 :: SBool = s180 == s877 s996 :: SWord8 = if s995 then s992 else s991 s997 :: SWord8 = s33 + s996 s998 :: SWord8 = if s994 then s997 else s996 s999 :: SBool = s185 == s877 s1000 :: SWord8 = if s999 then s992 else s991 s1001 :: SWord8 = s33 + s1000 s1002 :: SWord8 = if s995 then s1001 else s1000 s1003 :: SWord8 = s33 + s1002 s1004 :: SWord8 = if s994 then s1003 else s1002 s1005 :: SWord8 = if s176 then s998 else s1004 s1006 :: SWord8 = if s16 then s993 else s1005 s1007 :: SWord8 = s33 + s1006 s1008 :: SWord8 = if s879 then s1007 else s1006 s1009 :: SBool = s197 == s877 s1010 :: SBool = s200 == s877 s1011 :: SWord8 = if s1010 then s1007 else s1006 s1012 :: SWord8 = s33 + s1011 s1013 :: SWord8 = if s1009 then s1012 else s1011 s1014 :: SBool = s205 == s877 s1015 :: SWord8 = if s1014 then s1007 else s1006 s1016 :: SWord8 = s33 + s1015 s1017 :: SWord8 = if s1010 then s1016 else s1015 s1018 :: SWord8 = s33 + s1017 s1019 :: SWord8 = if s1009 then s1018 else s1017 s1020 :: SWord8 = if s196 then s1013 else s1019 s1021 :: SWord8 = if s14 then s1008 else s1020 s1022 :: SWord8 = s33 + s1021 s1023 :: SWord8 = if s878 then s1022 else s1021 s1024 :: SBool = s217 == s877 s1025 :: SBool = s220 == s877 s1026 :: SWord8 = if s1025 then s1022 else s1021 s1027 :: SWord8 = s33 + s1026 s1028 :: SWord8 = if s1024 then s1027 else s1026 s1029 :: SBool = s225 == s877 s1030 :: SWord8 = if s1029 then s1022 else s1021 s1031 :: SWord8 = s33 + s1030 s1032 :: SWord8 = if s1025 then s1031 else s1030 s1033 :: SWord8 = s33 + s1032 s1034 :: SWord8 = if s1024 then s1033 else s1032 s1035 :: SWord8 = if s216 then s1028 else s1034 s1036 :: SWord8 = if s11 then s1023 else s1035 s1037 :: SBool = s5 == s1036 s1039 :: SBool = s9 == s1038 s1040 :: SBool = s8 == s1038 s1041 :: SBool = s7 == s1038 s1042 :: SBool = s6 == s1038 s1043 :: SBool = s5 == s1038 s1044 :: SBool = s4 == s1038 s1045 :: SBool = s3 == s1038 s1046 :: SBool = s2 == s1038 s1047 :: SBool = s1 == s1038 s1048 :: SBool = s0 == s1038 s1049 :: SWord8 = if s1048 then s32 else s33 s1050 :: SBool = s37 == s1038 s1051 :: SBool = s40 == s1038 s1052 :: SWord8 = if s1051 then s32 else s33 s1053 :: SWord8 = s33 + s1052 s1054 :: SWord8 = if s1050 then s1053 else s1052 s1055 :: SBool = s45 == s1038 s1056 :: SWord8 = if s1055 then s32 else s33 s1057 :: SWord8 = s33 + s1056 s1058 :: SWord8 = if s1051 then s1057 else s1056 s1059 :: SWord8 = s33 + s1058 s1060 :: SWord8 = if s1050 then s1059 else s1058 s1061 :: SWord8 = if s36 then s1054 else s1060 s1062 :: SWord8 = if s30 then s1049 else s1061 s1063 :: SWord8 = s33 + s1062 s1064 :: SWord8 = if s1047 then s1063 else s1062 s1065 :: SBool = s57 == s1038 s1066 :: SBool = s60 == s1038 s1067 :: SWord8 = if s1066 then s1063 else s1062 s1068 :: SWord8 = s33 + s1067 s1069 :: SWord8 = if s1065 then s1068 else s1067 s1070 :: SBool = s65 == s1038 s1071 :: SWord8 = if s1070 then s1063 else s1062 s1072 :: SWord8 = s33 + s1071 s1073 :: SWord8 = if s1066 then s1072 else s1071 s1074 :: SWord8 = s33 + s1073 s1075 :: SWord8 = if s1065 then s1074 else s1073 s1076 :: SWord8 = if s56 then s1069 else s1075 s1077 :: SWord8 = if s28 then s1064 else s1076 s1078 :: SWord8 = s33 + s1077 s1079 :: SWord8 = if s1046 then s1078 else s1077 s1080 :: SBool = s77 == s1038 s1081 :: SBool = s80 == s1038 s1082 :: SWord8 = if s1081 then s1078 else s1077 s1083 :: SWord8 = s33 + s1082 s1084 :: SWord8 = if s1080 then s1083 else s1082 s1085 :: SBool = s85 == s1038 s1086 :: SWord8 = if s1085 then s1078 else s1077 s1087 :: SWord8 = s33 + s1086 s1088 :: SWord8 = if s1081 then s1087 else s1086 s1089 :: SWord8 = s33 + s1088 s1090 :: SWord8 = if s1080 then s1089 else s1088 s1091 :: SWord8 = if s76 then s1084 else s1090 s1092 :: SWord8 = if s26 then s1079 else s1091 s1093 :: SWord8 = s33 + s1092 s1094 :: SWord8 = if s1045 then s1093 else s1092 s1095 :: SBool = s97 == s1038 s1096 :: SBool = s100 == s1038 s1097 :: SWord8 = if s1096 then s1093 else s1092 s1098 :: SWord8 = s33 + s1097 s1099 :: SWord8 = if s1095 then s1098 else s1097 s1100 :: SBool = s105 == s1038 s1101 :: SWord8 = if s1100 then s1093 else s1092 s1102 :: SWord8 = s33 + s1101 s1103 :: SWord8 = if s1096 then s1102 else s1101 s1104 :: SWord8 = s33 + s1103 s1105 :: SWord8 = if s1095 then s1104 else s1103 s1106 :: SWord8 = if s96 then s1099 else s1105 s1107 :: SWord8 = if s24 then s1094 else s1106 s1108 :: SWord8 = s33 + s1107 s1109 :: SWord8 = if s1044 then s1108 else s1107 s1110 :: SBool = s117 == s1038 s1111 :: SBool = s120 == s1038 s1112 :: SWord8 = if s1111 then s1108 else s1107 s1113 :: SWord8 = s33 + s1112 s1114 :: SWord8 = if s1110 then s1113 else s1112 s1115 :: SBool = s125 == s1038 s1116 :: SWord8 = if s1115 then s1108 else s1107 s1117 :: SWord8 = s33 + s1116 s1118 :: SWord8 = if s1111 then s1117 else s1116 s1119 :: SWord8 = s33 + s1118 s1120 :: SWord8 = if s1110 then s1119 else s1118 s1121 :: SWord8 = if s116 then s1114 else s1120 s1122 :: SWord8 = if s22 then s1109 else s1121 s1123 :: SWord8 = s33 + s1122 s1124 :: SWord8 = if s1043 then s1123 else s1122 s1125 :: SBool = s137 == s1038 s1126 :: SBool = s140 == s1038 s1127 :: SWord8 = if s1126 then s1123 else s1122 s1128 :: SWord8 = s33 + s1127 s1129 :: SWord8 = if s1125 then s1128 else s1127 s1130 :: SBool = s145 == s1038 s1131 :: SWord8 = if s1130 then s1123 else s1122 s1132 :: SWord8 = s33 + s1131 s1133 :: SWord8 = if s1126 then s1132 else s1131 s1134 :: SWord8 = s33 + s1133 s1135 :: SWord8 = if s1125 then s1134 else s1133 s1136 :: SWord8 = if s136 then s1129 else s1135 s1137 :: SWord8 = if s20 then s1124 else s1136 s1138 :: SWord8 = s33 + s1137 s1139 :: SWord8 = if s1042 then s1138 else s1137 s1140 :: SBool = s157 == s1038 s1141 :: SBool = s160 == s1038 s1142 :: SWord8 = if s1141 then s1138 else s1137 s1143 :: SWord8 = s33 + s1142 s1144 :: SWord8 = if s1140 then s1143 else s1142 s1145 :: SBool = s165 == s1038 s1146 :: SWord8 = if s1145 then s1138 else s1137 s1147 :: SWord8 = s33 + s1146 s1148 :: SWord8 = if s1141 then s1147 else s1146 s1149 :: SWord8 = s33 + s1148 s1150 :: SWord8 = if s1140 then s1149 else s1148 s1151 :: SWord8 = if s156 then s1144 else s1150 s1152 :: SWord8 = if s18 then s1139 else s1151 s1153 :: SWord8 = s33 + s1152 s1154 :: SWord8 = if s1041 then s1153 else s1152 s1155 :: SBool = s177 == s1038 s1156 :: SBool = s180 == s1038 s1157 :: SWord8 = if s1156 then s1153 else s1152 s1158 :: SWord8 = s33 + s1157 s1159 :: SWord8 = if s1155 then s1158 else s1157 s1160 :: SBool = s185 == s1038 s1161 :: SWord8 = if s1160 then s1153 else s1152 s1162 :: SWord8 = s33 + s1161 s1163 :: SWord8 = if s1156 then s1162 else s1161 s1164 :: SWord8 = s33 + s1163 s1165 :: SWord8 = if s1155 then s1164 else s1163 s1166 :: SWord8 = if s176 then s1159 else s1165 s1167 :: SWord8 = if s16 then s1154 else s1166 s1168 :: SWord8 = s33 + s1167 s1169 :: SWord8 = if s1040 then s1168 else s1167 s1170 :: SBool = s197 == s1038 s1171 :: SBool = s200 == s1038 s1172 :: SWord8 = if s1171 then s1168 else s1167 s1173 :: SWord8 = s33 + s1172 s1174 :: SWord8 = if s1170 then s1173 else s1172 s1175 :: SBool = s205 == s1038 s1176 :: SWord8 = if s1175 then s1168 else s1167 s1177 :: SWord8 = s33 + s1176 s1178 :: SWord8 = if s1171 then s1177 else s1176 s1179 :: SWord8 = s33 + s1178 s1180 :: SWord8 = if s1170 then s1179 else s1178 s1181 :: SWord8 = if s196 then s1174 else s1180 s1182 :: SWord8 = if s14 then s1169 else s1181 s1183 :: SWord8 = s33 + s1182 s1184 :: SWord8 = if s1039 then s1183 else s1182 s1185 :: SBool = s217 == s1038 s1186 :: SBool = s220 == s1038 s1187 :: SWord8 = if s1186 then s1183 else s1182 s1188 :: SWord8 = s33 + s1187 s1189 :: SWord8 = if s1185 then s1188 else s1187 s1190 :: SBool = s225 == s1038 s1191 :: SWord8 = if s1190 then s1183 else s1182 s1192 :: SWord8 = s33 + s1191 s1193 :: SWord8 = if s1186 then s1192 else s1191 s1194 :: SWord8 = s33 + s1193 s1195 :: SWord8 = if s1185 then s1194 else s1193 s1196 :: SWord8 = if s216 then s1189 else s1195 s1197 :: SWord8 = if s11 then s1184 else s1196 s1198 :: SBool = s6 == s1197 s1200 :: SBool = s9 == s1199 s1201 :: SBool = s8 == s1199 s1202 :: SBool = s7 == s1199 s1203 :: SBool = s6 == s1199 s1204 :: SBool = s5 == s1199 s1205 :: SBool = s4 == s1199 s1206 :: SBool = s3 == s1199 s1207 :: SBool = s2 == s1199 s1208 :: SBool = s1 == s1199 s1209 :: SBool = s0 == s1199 s1210 :: SWord8 = if s1209 then s32 else s33 s1211 :: SBool = s37 == s1199 s1212 :: SBool = s40 == s1199 s1213 :: SWord8 = if s1212 then s32 else s33 s1214 :: SWord8 = s33 + s1213 s1215 :: SWord8 = if s1211 then s1214 else s1213 s1216 :: SBool = s45 == s1199 s1217 :: SWord8 = if s1216 then s32 else s33 s1218 :: SWord8 = s33 + s1217 s1219 :: SWord8 = if s1212 then s1218 else s1217 s1220 :: SWord8 = s33 + s1219 s1221 :: SWord8 = if s1211 then s1220 else s1219 s1222 :: SWord8 = if s36 then s1215 else s1221 s1223 :: SWord8 = if s30 then s1210 else s1222 s1224 :: SWord8 = s33 + s1223 s1225 :: SWord8 = if s1208 then s1224 else s1223 s1226 :: SBool = s57 == s1199 s1227 :: SBool = s60 == s1199 s1228 :: SWord8 = if s1227 then s1224 else s1223 s1229 :: SWord8 = s33 + s1228 s1230 :: SWord8 = if s1226 then s1229 else s1228 s1231 :: SBool = s65 == s1199 s1232 :: SWord8 = if s1231 then s1224 else s1223 s1233 :: SWord8 = s33 + s1232 s1234 :: SWord8 = if s1227 then s1233 else s1232 s1235 :: SWord8 = s33 + s1234 s1236 :: SWord8 = if s1226 then s1235 else s1234 s1237 :: SWord8 = if s56 then s1230 else s1236 s1238 :: SWord8 = if s28 then s1225 else s1237 s1239 :: SWord8 = s33 + s1238 s1240 :: SWord8 = if s1207 then s1239 else s1238 s1241 :: SBool = s77 == s1199 s1242 :: SBool = s80 == s1199 s1243 :: SWord8 = if s1242 then s1239 else s1238 s1244 :: SWord8 = s33 + s1243 s1245 :: SWord8 = if s1241 then s1244 else s1243 s1246 :: SBool = s85 == s1199 s1247 :: SWord8 = if s1246 then s1239 else s1238 s1248 :: SWord8 = s33 + s1247 s1249 :: SWord8 = if s1242 then s1248 else s1247 s1250 :: SWord8 = s33 + s1249 s1251 :: SWord8 = if s1241 then s1250 else s1249 s1252 :: SWord8 = if s76 then s1245 else s1251 s1253 :: SWord8 = if s26 then s1240 else s1252 s1254 :: SWord8 = s33 + s1253 s1255 :: SWord8 = if s1206 then s1254 else s1253 s1256 :: SBool = s97 == s1199 s1257 :: SBool = s100 == s1199 s1258 :: SWord8 = if s1257 then s1254 else s1253 s1259 :: SWord8 = s33 + s1258 s1260 :: SWord8 = if s1256 then s1259 else s1258 s1261 :: SBool = s105 == s1199 s1262 :: SWord8 = if s1261 then s1254 else s1253 s1263 :: SWord8 = s33 + s1262 s1264 :: SWord8 = if s1257 then s1263 else s1262 s1265 :: SWord8 = s33 + s1264 s1266 :: SWord8 = if s1256 then s1265 else s1264 s1267 :: SWord8 = if s96 then s1260 else s1266 s1268 :: SWord8 = if s24 then s1255 else s1267 s1269 :: SWord8 = s33 + s1268 s1270 :: SWord8 = if s1205 then s1269 else s1268 s1271 :: SBool = s117 == s1199 s1272 :: SBool = s120 == s1199 s1273 :: SWord8 = if s1272 then s1269 else s1268 s1274 :: SWord8 = s33 + s1273 s1275 :: SWord8 = if s1271 then s1274 else s1273 s1276 :: SBool = s125 == s1199 s1277 :: SWord8 = if s1276 then s1269 else s1268 s1278 :: SWord8 = s33 + s1277 s1279 :: SWord8 = if s1272 then s1278 else s1277 s1280 :: SWord8 = s33 + s1279 s1281 :: SWord8 = if s1271 then s1280 else s1279 s1282 :: SWord8 = if s116 then s1275 else s1281 s1283 :: SWord8 = if s22 then s1270 else s1282 s1284 :: SWord8 = s33 + s1283 s1285 :: SWord8 = if s1204 then s1284 else s1283 s1286 :: SBool = s137 == s1199 s1287 :: SBool = s140 == s1199 s1288 :: SWord8 = if s1287 then s1284 else s1283 s1289 :: SWord8 = s33 + s1288 s1290 :: SWord8 = if s1286 then s1289 else s1288 s1291 :: SBool = s145 == s1199 s1292 :: SWord8 = if s1291 then s1284 else s1283 s1293 :: SWord8 = s33 + s1292 s1294 :: SWord8 = if s1287 then s1293 else s1292 s1295 :: SWord8 = s33 + s1294 s1296 :: SWord8 = if s1286 then s1295 else s1294 s1297 :: SWord8 = if s136 then s1290 else s1296 s1298 :: SWord8 = if s20 then s1285 else s1297 s1299 :: SWord8 = s33 + s1298 s1300 :: SWord8 = if s1203 then s1299 else s1298 s1301 :: SBool = s157 == s1199 s1302 :: SBool = s160 == s1199 s1303 :: SWord8 = if s1302 then s1299 else s1298 s1304 :: SWord8 = s33 + s1303 s1305 :: SWord8 = if s1301 then s1304 else s1303 s1306 :: SBool = s165 == s1199 s1307 :: SWord8 = if s1306 then s1299 else s1298 s1308 :: SWord8 = s33 + s1307 s1309 :: SWord8 = if s1302 then s1308 else s1307 s1310 :: SWord8 = s33 + s1309 s1311 :: SWord8 = if s1301 then s1310 else s1309 s1312 :: SWord8 = if s156 then s1305 else s1311 s1313 :: SWord8 = if s18 then s1300 else s1312 s1314 :: SWord8 = s33 + s1313 s1315 :: SWord8 = if s1202 then s1314 else s1313 s1316 :: SBool = s177 == s1199 s1317 :: SBool = s180 == s1199 s1318 :: SWord8 = if s1317 then s1314 else s1313 s1319 :: SWord8 = s33 + s1318 s1320 :: SWord8 = if s1316 then s1319 else s1318 s1321 :: SBool = s185 == s1199 s1322 :: SWord8 = if s1321 then s1314 else s1313 s1323 :: SWord8 = s33 + s1322 s1324 :: SWord8 = if s1317 then s1323 else s1322 s1325 :: SWord8 = s33 + s1324 s1326 :: SWord8 = if s1316 then s1325 else s1324 s1327 :: SWord8 = if s176 then s1320 else s1326 s1328 :: SWord8 = if s16 then s1315 else s1327 s1329 :: SWord8 = s33 + s1328 s1330 :: SWord8 = if s1201 then s1329 else s1328 s1331 :: SBool = s197 == s1199 s1332 :: SBool = s200 == s1199 s1333 :: SWord8 = if s1332 then s1329 else s1328 s1334 :: SWord8 = s33 + s1333 s1335 :: SWord8 = if s1331 then s1334 else s1333 s1336 :: SBool = s205 == s1199 s1337 :: SWord8 = if s1336 then s1329 else s1328 s1338 :: SWord8 = s33 + s1337 s1339 :: SWord8 = if s1332 then s1338 else s1337 s1340 :: SWord8 = s33 + s1339 s1341 :: SWord8 = if s1331 then s1340 else s1339 s1342 :: SWord8 = if s196 then s1335 else s1341 s1343 :: SWord8 = if s14 then s1330 else s1342 s1344 :: SWord8 = s33 + s1343 s1345 :: SWord8 = if s1200 then s1344 else s1343 s1346 :: SBool = s217 == s1199 s1347 :: SBool = s220 == s1199 s1348 :: SWord8 = if s1347 then s1344 else s1343 s1349 :: SWord8 = s33 + s1348 s1350 :: SWord8 = if s1346 then s1349 else s1348 s1351 :: SBool = s225 == s1199 s1352 :: SWord8 = if s1351 then s1344 else s1343 s1353 :: SWord8 = s33 + s1352 s1354 :: SWord8 = if s1347 then s1353 else s1352 s1355 :: SWord8 = s33 + s1354 s1356 :: SWord8 = if s1346 then s1355 else s1354 s1357 :: SWord8 = if s216 then s1350 else s1356 s1358 :: SWord8 = if s11 then s1345 else s1357 s1359 :: SBool = s7 == s1358 s1361 :: SBool = s9 == s1360 s1362 :: SBool = s8 == s1360 s1363 :: SBool = s7 == s1360 s1364 :: SBool = s6 == s1360 s1365 :: SBool = s5 == s1360 s1366 :: SBool = s4 == s1360 s1367 :: SBool = s3 == s1360 s1368 :: SBool = s2 == s1360 s1369 :: SBool = s1 == s1360 s1370 :: SBool = s0 == s1360 s1371 :: SWord8 = if s1370 then s32 else s33 s1372 :: SBool = s37 == s1360 s1373 :: SBool = s40 == s1360 s1374 :: SWord8 = if s1373 then s32 else s33 s1375 :: SWord8 = s33 + s1374 s1376 :: SWord8 = if s1372 then s1375 else s1374 s1377 :: SBool = s45 == s1360 s1378 :: SWord8 = if s1377 then s32 else s33 s1379 :: SWord8 = s33 + s1378 s1380 :: SWord8 = if s1373 then s1379 else s1378 s1381 :: SWord8 = s33 + s1380 s1382 :: SWord8 = if s1372 then s1381 else s1380 s1383 :: SWord8 = if s36 then s1376 else s1382 s1384 :: SWord8 = if s30 then s1371 else s1383 s1385 :: SWord8 = s33 + s1384 s1386 :: SWord8 = if s1369 then s1385 else s1384 s1387 :: SBool = s57 == s1360 s1388 :: SBool = s60 == s1360 s1389 :: SWord8 = if s1388 then s1385 else s1384 s1390 :: SWord8 = s33 + s1389 s1391 :: SWord8 = if s1387 then s1390 else s1389 s1392 :: SBool = s65 == s1360 s1393 :: SWord8 = if s1392 then s1385 else s1384 s1394 :: SWord8 = s33 + s1393 s1395 :: SWord8 = if s1388 then s1394 else s1393 s1396 :: SWord8 = s33 + s1395 s1397 :: SWord8 = if s1387 then s1396 else s1395 s1398 :: SWord8 = if s56 then s1391 else s1397 s1399 :: SWord8 = if s28 then s1386 else s1398 s1400 :: SWord8 = s33 + s1399 s1401 :: SWord8 = if s1368 then s1400 else s1399 s1402 :: SBool = s77 == s1360 s1403 :: SBool = s80 == s1360 s1404 :: SWord8 = if s1403 then s1400 else s1399 s1405 :: SWord8 = s33 + s1404 s1406 :: SWord8 = if s1402 then s1405 else s1404 s1407 :: SBool = s85 == s1360 s1408 :: SWord8 = if s1407 then s1400 else s1399 s1409 :: SWord8 = s33 + s1408 s1410 :: SWord8 = if s1403 then s1409 else s1408 s1411 :: SWord8 = s33 + s1410 s1412 :: SWord8 = if s1402 then s1411 else s1410 s1413 :: SWord8 = if s76 then s1406 else s1412 s1414 :: SWord8 = if s26 then s1401 else s1413 s1415 :: SWord8 = s33 + s1414 s1416 :: SWord8 = if s1367 then s1415 else s1414 s1417 :: SBool = s97 == s1360 s1418 :: SBool = s100 == s1360 s1419 :: SWord8 = if s1418 then s1415 else s1414 s1420 :: SWord8 = s33 + s1419 s1421 :: SWord8 = if s1417 then s1420 else s1419 s1422 :: SBool = s105 == s1360 s1423 :: SWord8 = if s1422 then s1415 else s1414 s1424 :: SWord8 = s33 + s1423 s1425 :: SWord8 = if s1418 then s1424 else s1423 s1426 :: SWord8 = s33 + s1425 s1427 :: SWord8 = if s1417 then s1426 else s1425 s1428 :: SWord8 = if s96 then s1421 else s1427 s1429 :: SWord8 = if s24 then s1416 else s1428 s1430 :: SWord8 = s33 + s1429 s1431 :: SWord8 = if s1366 then s1430 else s1429 s1432 :: SBool = s117 == s1360 s1433 :: SBool = s120 == s1360 s1434 :: SWord8 = if s1433 then s1430 else s1429 s1435 :: SWord8 = s33 + s1434 s1436 :: SWord8 = if s1432 then s1435 else s1434 s1437 :: SBool = s125 == s1360 s1438 :: SWord8 = if s1437 then s1430 else s1429 s1439 :: SWord8 = s33 + s1438 s1440 :: SWord8 = if s1433 then s1439 else s1438 s1441 :: SWord8 = s33 + s1440 s1442 :: SWord8 = if s1432 then s1441 else s1440 s1443 :: SWord8 = if s116 then s1436 else s1442 s1444 :: SWord8 = if s22 then s1431 else s1443 s1445 :: SWord8 = s33 + s1444 s1446 :: SWord8 = if s1365 then s1445 else s1444 s1447 :: SBool = s137 == s1360 s1448 :: SBool = s140 == s1360 s1449 :: SWord8 = if s1448 then s1445 else s1444 s1450 :: SWord8 = s33 + s1449 s1451 :: SWord8 = if s1447 then s1450 else s1449 s1452 :: SBool = s145 == s1360 s1453 :: SWord8 = if s1452 then s1445 else s1444 s1454 :: SWord8 = s33 + s1453 s1455 :: SWord8 = if s1448 then s1454 else s1453 s1456 :: SWord8 = s33 + s1455 s1457 :: SWord8 = if s1447 then s1456 else s1455 s1458 :: SWord8 = if s136 then s1451 else s1457 s1459 :: SWord8 = if s20 then s1446 else s1458 s1460 :: SWord8 = s33 + s1459 s1461 :: SWord8 = if s1364 then s1460 else s1459 s1462 :: SBool = s157 == s1360 s1463 :: SBool = s160 == s1360 s1464 :: SWord8 = if s1463 then s1460 else s1459 s1465 :: SWord8 = s33 + s1464 s1466 :: SWord8 = if s1462 then s1465 else s1464 s1467 :: SBool = s165 == s1360 s1468 :: SWord8 = if s1467 then s1460 else s1459 s1469 :: SWord8 = s33 + s1468 s1470 :: SWord8 = if s1463 then s1469 else s1468 s1471 :: SWord8 = s33 + s1470 s1472 :: SWord8 = if s1462 then s1471 else s1470 s1473 :: SWord8 = if s156 then s1466 else s1472 s1474 :: SWord8 = if s18 then s1461 else s1473 s1475 :: SWord8 = s33 + s1474 s1476 :: SWord8 = if s1363 then s1475 else s1474 s1477 :: SBool = s177 == s1360 s1478 :: SBool = s180 == s1360 s1479 :: SWord8 = if s1478 then s1475 else s1474 s1480 :: SWord8 = s33 + s1479 s1481 :: SWord8 = if s1477 then s1480 else s1479 s1482 :: SBool = s185 == s1360 s1483 :: SWord8 = if s1482 then s1475 else s1474 s1484 :: SWord8 = s33 + s1483 s1485 :: SWord8 = if s1478 then s1484 else s1483 s1486 :: SWord8 = s33 + s1485 s1487 :: SWord8 = if s1477 then s1486 else s1485 s1488 :: SWord8 = if s176 then s1481 else s1487 s1489 :: SWord8 = if s16 then s1476 else s1488 s1490 :: SWord8 = s33 + s1489 s1491 :: SWord8 = if s1362 then s1490 else s1489 s1492 :: SBool = s197 == s1360 s1493 :: SBool = s200 == s1360 s1494 :: SWord8 = if s1493 then s1490 else s1489 s1495 :: SWord8 = s33 + s1494 s1496 :: SWord8 = if s1492 then s1495 else s1494 s1497 :: SBool = s205 == s1360 s1498 :: SWord8 = if s1497 then s1490 else s1489 s1499 :: SWord8 = s33 + s1498 s1500 :: SWord8 = if s1493 then s1499 else s1498 s1501 :: SWord8 = s33 + s1500 s1502 :: SWord8 = if s1492 then s1501 else s1500 s1503 :: SWord8 = if s196 then s1496 else s1502 s1504 :: SWord8 = if s14 then s1491 else s1503 s1505 :: SWord8 = s33 + s1504 s1506 :: SWord8 = if s1361 then s1505 else s1504 s1507 :: SBool = s217 == s1360 s1508 :: SBool = s220 == s1360 s1509 :: SWord8 = if s1508 then s1505 else s1504 s1510 :: SWord8 = s33 + s1509 s1511 :: SWord8 = if s1507 then s1510 else s1509 s1512 :: SBool = s225 == s1360 s1513 :: SWord8 = if s1512 then s1505 else s1504 s1514 :: SWord8 = s33 + s1513 s1515 :: SWord8 = if s1508 then s1514 else s1513 s1516 :: SWord8 = s33 + s1515 s1517 :: SWord8 = if s1507 then s1516 else s1515 s1518 :: SWord8 = if s216 then s1511 else s1517 s1519 :: SWord8 = if s11 then s1506 else s1518 s1520 :: SBool = s8 == s1519 s1522 :: SBool = s9 == s1521 s1523 :: SBool = s8 == s1521 s1524 :: SBool = s7 == s1521 s1525 :: SBool = s6 == s1521 s1526 :: SBool = s5 == s1521 s1527 :: SBool = s4 == s1521 s1528 :: SBool = s3 == s1521 s1529 :: SBool = s2 == s1521 s1530 :: SBool = s1 == s1521 s1531 :: SBool = s0 == s1521 s1532 :: SWord8 = if s1531 then s32 else s33 s1533 :: SBool = s37 == s1521 s1534 :: SBool = s40 == s1521 s1535 :: SWord8 = if s1534 then s32 else s33 s1536 :: SWord8 = s33 + s1535 s1537 :: SWord8 = if s1533 then s1536 else s1535 s1538 :: SBool = s45 == s1521 s1539 :: SWord8 = if s1538 then s32 else s33 s1540 :: SWord8 = s33 + s1539 s1541 :: SWord8 = if s1534 then s1540 else s1539 s1542 :: SWord8 = s33 + s1541 s1543 :: SWord8 = if s1533 then s1542 else s1541 s1544 :: SWord8 = if s36 then s1537 else s1543 s1545 :: SWord8 = if s30 then s1532 else s1544 s1546 :: SWord8 = s33 + s1545 s1547 :: SWord8 = if s1530 then s1546 else s1545 s1548 :: SBool = s57 == s1521 s1549 :: SBool = s60 == s1521 s1550 :: SWord8 = if s1549 then s1546 else s1545 s1551 :: SWord8 = s33 + s1550 s1552 :: SWord8 = if s1548 then s1551 else s1550 s1553 :: SBool = s65 == s1521 s1554 :: SWord8 = if s1553 then s1546 else s1545 s1555 :: SWord8 = s33 + s1554 s1556 :: SWord8 = if s1549 then s1555 else s1554 s1557 :: SWord8 = s33 + s1556 s1558 :: SWord8 = if s1548 then s1557 else s1556 s1559 :: SWord8 = if s56 then s1552 else s1558 s1560 :: SWord8 = if s28 then s1547 else s1559 s1561 :: SWord8 = s33 + s1560 s1562 :: SWord8 = if s1529 then s1561 else s1560 s1563 :: SBool = s77 == s1521 s1564 :: SBool = s80 == s1521 s1565 :: SWord8 = if s1564 then s1561 else s1560 s1566 :: SWord8 = s33 + s1565 s1567 :: SWord8 = if s1563 then s1566 else s1565 s1568 :: SBool = s85 == s1521 s1569 :: SWord8 = if s1568 then s1561 else s1560 s1570 :: SWord8 = s33 + s1569 s1571 :: SWord8 = if s1564 then s1570 else s1569 s1572 :: SWord8 = s33 + s1571 s1573 :: SWord8 = if s1563 then s1572 else s1571 s1574 :: SWord8 = if s76 then s1567 else s1573 s1575 :: SWord8 = if s26 then s1562 else s1574 s1576 :: SWord8 = s33 + s1575 s1577 :: SWord8 = if s1528 then s1576 else s1575 s1578 :: SBool = s97 == s1521 s1579 :: SBool = s100 == s1521 s1580 :: SWord8 = if s1579 then s1576 else s1575 s1581 :: SWord8 = s33 + s1580 s1582 :: SWord8 = if s1578 then s1581 else s1580 s1583 :: SBool = s105 == s1521 s1584 :: SWord8 = if s1583 then s1576 else s1575 s1585 :: SWord8 = s33 + s1584 s1586 :: SWord8 = if s1579 then s1585 else s1584 s1587 :: SWord8 = s33 + s1586 s1588 :: SWord8 = if s1578 then s1587 else s1586 s1589 :: SWord8 = if s96 then s1582 else s1588 s1590 :: SWord8 = if s24 then s1577 else s1589 s1591 :: SWord8 = s33 + s1590 s1592 :: SWord8 = if s1527 then s1591 else s1590 s1593 :: SBool = s117 == s1521 s1594 :: SBool = s120 == s1521 s1595 :: SWord8 = if s1594 then s1591 else s1590 s1596 :: SWord8 = s33 + s1595 s1597 :: SWord8 = if s1593 then s1596 else s1595 s1598 :: SBool = s125 == s1521 s1599 :: SWord8 = if s1598 then s1591 else s1590 s1600 :: SWord8 = s33 + s1599 s1601 :: SWord8 = if s1594 then s1600 else s1599 s1602 :: SWord8 = s33 + s1601 s1603 :: SWord8 = if s1593 then s1602 else s1601 s1604 :: SWord8 = if s116 then s1597 else s1603 s1605 :: SWord8 = if s22 then s1592 else s1604 s1606 :: SWord8 = s33 + s1605 s1607 :: SWord8 = if s1526 then s1606 else s1605 s1608 :: SBool = s137 == s1521 s1609 :: SBool = s140 == s1521 s1610 :: SWord8 = if s1609 then s1606 else s1605 s1611 :: SWord8 = s33 + s1610 s1612 :: SWord8 = if s1608 then s1611 else s1610 s1613 :: SBool = s145 == s1521 s1614 :: SWord8 = if s1613 then s1606 else s1605 s1615 :: SWord8 = s33 + s1614 s1616 :: SWord8 = if s1609 then s1615 else s1614 s1617 :: SWord8 = s33 + s1616 s1618 :: SWord8 = if s1608 then s1617 else s1616 s1619 :: SWord8 = if s136 then s1612 else s1618 s1620 :: SWord8 = if s20 then s1607 else s1619 s1621 :: SWord8 = s33 + s1620 s1622 :: SWord8 = if s1525 then s1621 else s1620 s1623 :: SBool = s157 == s1521 s1624 :: SBool = s160 == s1521 s1625 :: SWord8 = if s1624 then s1621 else s1620 s1626 :: SWord8 = s33 + s1625 s1627 :: SWord8 = if s1623 then s1626 else s1625 s1628 :: SBool = s165 == s1521 s1629 :: SWord8 = if s1628 then s1621 else s1620 s1630 :: SWord8 = s33 + s1629 s1631 :: SWord8 = if s1624 then s1630 else s1629 s1632 :: SWord8 = s33 + s1631 s1633 :: SWord8 = if s1623 then s1632 else s1631 s1634 :: SWord8 = if s156 then s1627 else s1633 s1635 :: SWord8 = if s18 then s1622 else s1634 s1636 :: SWord8 = s33 + s1635 s1637 :: SWord8 = if s1524 then s1636 else s1635 s1638 :: SBool = s177 == s1521 s1639 :: SBool = s180 == s1521 s1640 :: SWord8 = if s1639 then s1636 else s1635 s1641 :: SWord8 = s33 + s1640 s1642 :: SWord8 = if s1638 then s1641 else s1640 s1643 :: SBool = s185 == s1521 s1644 :: SWord8 = if s1643 then s1636 else s1635 s1645 :: SWord8 = s33 + s1644 s1646 :: SWord8 = if s1639 then s1645 else s1644 s1647 :: SWord8 = s33 + s1646 s1648 :: SWord8 = if s1638 then s1647 else s1646 s1649 :: SWord8 = if s176 then s1642 else s1648 s1650 :: SWord8 = if s16 then s1637 else s1649 s1651 :: SWord8 = s33 + s1650 s1652 :: SWord8 = if s1523 then s1651 else s1650 s1653 :: SBool = s197 == s1521 s1654 :: SBool = s200 == s1521 s1655 :: SWord8 = if s1654 then s1651 else s1650 s1656 :: SWord8 = s33 + s1655 s1657 :: SWord8 = if s1653 then s1656 else s1655 s1658 :: SBool = s205 == s1521 s1659 :: SWord8 = if s1658 then s1651 else s1650 s1660 :: SWord8 = s33 + s1659 s1661 :: SWord8 = if s1654 then s1660 else s1659 s1662 :: SWord8 = s33 + s1661 s1663 :: SWord8 = if s1653 then s1662 else s1661 s1664 :: SWord8 = if s196 then s1657 else s1663 s1665 :: SWord8 = if s14 then s1652 else s1664 s1666 :: SWord8 = s33 + s1665 s1667 :: SWord8 = if s1522 then s1666 else s1665 s1668 :: SBool = s217 == s1521 s1669 :: SBool = s220 == s1521 s1670 :: SWord8 = if s1669 then s1666 else s1665 s1671 :: SWord8 = s33 + s1670 s1672 :: SWord8 = if s1668 then s1671 else s1670 s1673 :: SBool = s225 == s1521 s1674 :: SWord8 = if s1673 then s1666 else s1665 s1675 :: SWord8 = s33 + s1674 s1676 :: SWord8 = if s1669 then s1675 else s1674 s1677 :: SWord8 = s33 + s1676 s1678 :: SWord8 = if s1668 then s1677 else s1676 s1679 :: SWord8 = if s216 then s1672 else s1678 s1680 :: SWord8 = if s11 then s1667 else s1679 s1681 :: SBool = s9 == s1680 s1682 :: SBool = s1520 & s1681 s1683 :: SBool = s1359 & s1682 s1684 :: SBool = s1198 & s1683 s1685 :: SBool = s1037 & s1684 s1686 :: SBool = s876 & s1685 s1687 :: SBool = s715 & s1686 s1688 :: SBool = s554 & s1687 s1689 :: SBool = s394 & s1688 s1690 :: SBool = s234 & s1689 CONSTRAINTS ASSERTIONS OUTPUTS s1690sbv-5.12/SBVUnitTest/GoldFiles/crcPolyExist.gold0000644000000000000000000041357012725411266017742 0ustar0000000000000000INPUTS s0 :: SWord16, existential, aliasing "poly" s1 :: SWord32, aliasing "sh" s2 :: SWord16, aliasing "sl" s3 :: SWord32, aliasing "rh" s4 :: SWord16, aliasing "rl" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s6 = 0 :: Word1 s18 = 1 :: Word8 s3340 = 0 :: Word8 s3468 = 4 :: Word8 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s5 :: SWord1 = choose [0:0] s0 s7 :: SBool = s5 /= s6 s8 :: SBool = s1 == s3 s9 :: SBool = s2 == s4 s10 :: SBool = s8 & s9 s11 :: SBool = ~ s10 s12 :: SBool = ~ s11 s13 :: SWord1 = choose [31:31] s1 s14 :: SBool = s6 /= s13 s15 :: SWord1 = choose [31:31] s3 s16 :: SBool = s6 /= s15 s17 :: SBool = s14 ^ s16 s19 :: SWord1 = choose [30:30] s1 s20 :: SBool = s6 /= s19 s21 :: SWord1 = choose [30:30] s3 s22 :: SBool = s6 /= s21 s23 :: SBool = s20 ^ s22 s24 :: SWord1 = choose [29:29] s1 s25 :: SBool = s6 /= s24 s26 :: SWord1 = choose [29:29] s3 s27 :: SBool = s6 /= s26 s28 :: SBool = s25 ^ s27 s29 :: SWord1 = choose [28:28] s1 s30 :: SBool = s6 /= s29 s31 :: SWord1 = choose [28:28] s3 s32 :: SBool = s6 /= s31 s33 :: SBool = s30 ^ s32 s34 :: SWord1 = choose [27:27] s1 s35 :: SBool = s6 /= s34 s36 :: SWord1 = choose [27:27] s3 s37 :: SBool = s6 /= s36 s38 :: SBool = s35 ^ s37 s39 :: SWord1 = choose [26:26] s1 s40 :: SBool = s6 /= s39 s41 :: SWord1 = choose [26:26] s3 s42 :: SBool = s6 /= s41 s43 :: SBool = s40 ^ s42 s44 :: SWord1 = choose [25:25] s1 s45 :: SBool = s6 /= s44 s46 :: SWord1 = choose [25:25] s3 s47 :: SBool = s6 /= s46 s48 :: SBool = s45 ^ s47 s49 :: SWord1 = choose [24:24] s1 s50 :: SBool = s6 /= s49 s51 :: SWord1 = choose [24:24] s3 s52 :: SBool = s6 /= s51 s53 :: SBool = s50 ^ s52 s54 :: SWord1 = choose [23:23] s1 s55 :: SBool = s6 /= s54 s56 :: SWord1 = choose [23:23] s3 s57 :: SBool = s6 /= s56 s58 :: SBool = s55 ^ s57 s59 :: SWord1 = choose [22:22] s1 s60 :: SBool = s6 /= s59 s61 :: SWord1 = choose [22:22] s3 s62 :: SBool = s6 /= s61 s63 :: SBool = s60 ^ s62 s64 :: SWord1 = choose [21:21] s1 s65 :: SBool = s6 /= s64 s66 :: SWord1 = choose [21:21] s3 s67 :: SBool = s6 /= s66 s68 :: SBool = s65 ^ s67 s69 :: SWord1 = choose [20:20] s1 s70 :: SBool = s6 /= s69 s71 :: SWord1 = choose [20:20] s3 s72 :: SBool = s6 /= s71 s73 :: SBool = s70 ^ s72 s74 :: SWord1 = choose [19:19] s1 s75 :: SBool = s6 /= s74 s76 :: SWord1 = choose [19:19] s3 s77 :: SBool = s6 /= s76 s78 :: SBool = s75 ^ s77 s79 :: SWord1 = choose [18:18] s1 s80 :: SBool = s6 /= s79 s81 :: SWord1 = choose [18:18] s3 s82 :: SBool = s6 /= s81 s83 :: SBool = s80 ^ s82 s84 :: SWord1 = choose [17:17] s1 s85 :: SBool = s6 /= s84 s86 :: SWord1 = choose [17:17] s3 s87 :: SBool = s6 /= s86 s88 :: SBool = s85 ^ s87 s89 :: SWord1 = choose [16:16] s1 s90 :: SBool = s6 /= s89 s91 :: SWord1 = choose [16:16] s3 s92 :: SBool = s6 /= s91 s93 :: SBool = s90 ^ s92 s94 :: SWord1 = choose [15:15] s1 s95 :: SBool = s6 /= s94 s96 :: SWord1 = choose [15:15] s3 s97 :: SBool = s6 /= s96 s98 :: SBool = s95 ^ s97 s99 :: SWord1 = choose [14:14] s1 s100 :: SBool = s6 /= s99 s101 :: SWord1 = choose [14:14] s3 s102 :: SBool = s6 /= s101 s103 :: SBool = s100 ^ s102 s104 :: SWord1 = choose [13:13] s1 s105 :: SBool = s6 /= s104 s106 :: SWord1 = choose [13:13] s3 s107 :: SBool = s6 /= s106 s108 :: SBool = s105 ^ s107 s109 :: SWord1 = choose [12:12] s1 s110 :: SBool = s6 /= s109 s111 :: SWord1 = choose [12:12] s3 s112 :: SBool = s6 /= s111 s113 :: SBool = s110 ^ s112 s114 :: SWord1 = choose [11:11] s1 s115 :: SBool = s6 /= s114 s116 :: SWord1 = choose [11:11] s3 s117 :: SBool = s6 /= s116 s118 :: SBool = s115 ^ s117 s119 :: SWord1 = choose [10:10] s1 s120 :: SBool = s6 /= s119 s121 :: SWord1 = choose [10:10] s3 s122 :: SBool = s6 /= s121 s123 :: SBool = s120 ^ s122 s124 :: SWord1 = choose [9:9] s1 s125 :: SBool = s6 /= s124 s126 :: SWord1 = choose [9:9] s3 s127 :: SBool = s6 /= s126 s128 :: SBool = s125 ^ s127 s129 :: SWord1 = choose [8:8] s1 s130 :: SBool = s6 /= s129 s131 :: SWord1 = choose [8:8] s3 s132 :: SBool = s6 /= s131 s133 :: SBool = s130 ^ s132 s134 :: SWord1 = choose [7:7] s1 s135 :: SBool = s6 /= s134 s136 :: SWord1 = choose [7:7] s3 s137 :: SBool = s6 /= s136 s138 :: SBool = s135 ^ s137 s139 :: SWord1 = choose [6:6] s1 s140 :: SBool = s6 /= s139 s141 :: SWord1 = choose [6:6] s3 s142 :: SBool = s6 /= s141 s143 :: SBool = s140 ^ s142 s144 :: SWord1 = choose [5:5] s1 s145 :: SBool = s6 /= s144 s146 :: SWord1 = choose [5:5] s3 s147 :: SBool = s6 /= s146 s148 :: SBool = s145 ^ s147 s149 :: SWord1 = choose [4:4] s1 s150 :: SBool = s6 /= s149 s151 :: SWord1 = choose [4:4] s3 s152 :: SBool = s6 /= s151 s153 :: SBool = s150 ^ s152 s154 :: SWord1 = choose [3:3] s1 s155 :: SBool = s6 /= s154 s156 :: SWord1 = choose [3:3] s3 s157 :: SBool = s6 /= s156 s158 :: SBool = s155 ^ s157 s159 :: SWord1 = choose [2:2] s1 s160 :: SBool = s6 /= s159 s161 :: SWord1 = choose [2:2] s3 s162 :: SBool = s6 /= s161 s163 :: SBool = s160 ^ s162 s164 :: SWord1 = choose [1:1] s1 s165 :: SBool = s6 /= s164 s166 :: SWord1 = choose [1:1] s3 s167 :: SBool = s6 /= s166 s168 :: SBool = s165 ^ s167 s169 :: SWord1 = choose [0:0] s1 s170 :: SBool = s6 /= s169 s171 :: SWord1 = choose [0:0] s3 s172 :: SBool = s6 /= s171 s173 :: SBool = s170 ^ s172 s174 :: SWord1 = choose [15:15] s2 s175 :: SBool = s6 /= s174 s176 :: SWord1 = choose [15:15] s4 s177 :: SBool = s6 /= s176 s178 :: SBool = s175 ^ s177 s179 :: SWord1 = choose [14:14] s2 s180 :: SBool = s6 /= s179 s181 :: SWord1 = choose [14:14] s4 s182 :: SBool = s6 /= s181 s183 :: SBool = s180 ^ s182 s184 :: SWord1 = choose [13:13] s2 s185 :: SBool = s6 /= s184 s186 :: SWord1 = choose [13:13] s4 s187 :: SBool = s6 /= s186 s188 :: SBool = s185 ^ s187 s189 :: SWord1 = choose [12:12] s2 s190 :: SBool = s6 /= s189 s191 :: SWord1 = choose [12:12] s4 s192 :: SBool = s6 /= s191 s193 :: SBool = s190 ^ s192 s194 :: SWord1 = choose [11:11] s2 s195 :: SBool = s6 /= s194 s196 :: SWord1 = choose [11:11] s4 s197 :: SBool = s6 /= s196 s198 :: SBool = s195 ^ s197 s199 :: SWord1 = choose [10:10] s2 s200 :: SBool = s6 /= s199 s201 :: SWord1 = choose [10:10] s4 s202 :: SBool = s6 /= s201 s203 :: SBool = s200 ^ s202 s204 :: SWord1 = choose [9:9] s2 s205 :: SBool = s6 /= s204 s206 :: SWord1 = choose [9:9] s4 s207 :: SBool = s6 /= s206 s208 :: SBool = s205 ^ s207 s209 :: SWord1 = choose [8:8] s2 s210 :: SBool = s6 /= s209 s211 :: SWord1 = choose [8:8] s4 s212 :: SBool = s6 /= s211 s213 :: SBool = s210 ^ s212 s214 :: SWord1 = choose [7:7] s2 s215 :: SBool = s6 /= s214 s216 :: SWord1 = choose [7:7] s4 s217 :: SBool = s6 /= s216 s218 :: SBool = s215 ^ s217 s219 :: SWord1 = choose [6:6] s2 s220 :: SBool = s6 /= s219 s221 :: SWord1 = choose [6:6] s4 s222 :: SBool = s6 /= s221 s223 :: SBool = s220 ^ s222 s224 :: SWord1 = choose [5:5] s2 s225 :: SBool = s6 /= s224 s226 :: SWord1 = choose [5:5] s4 s227 :: SBool = s6 /= s226 s228 :: SBool = s225 ^ s227 s229 :: SWord1 = choose [4:4] s2 s230 :: SBool = s6 /= s229 s231 :: SWord1 = choose [4:4] s4 s232 :: SBool = s6 /= s231 s233 :: SBool = s230 ^ s232 s234 :: SWord1 = choose [3:3] s2 s235 :: SBool = s6 /= s234 s236 :: SWord1 = choose [3:3] s4 s237 :: SBool = s6 /= s236 s238 :: SBool = s235 ^ s237 s239 :: SWord1 = choose [2:2] s2 s240 :: SBool = s6 /= s239 s241 :: SWord1 = choose [2:2] s4 s242 :: SBool = s6 /= s241 s243 :: SBool = s240 ^ s242 s244 :: SWord1 = choose [1:1] s2 s245 :: SBool = s6 /= s244 s246 :: SWord1 = choose [1:1] s4 s247 :: SBool = s6 /= s246 s248 :: SBool = s245 ^ s247 s249 :: SWord1 = choose [0:0] s2 s250 :: SBool = s6 /= s249 s251 :: SWord1 = choose [0:0] s4 s252 :: SBool = s6 /= s251 s253 :: SBool = s250 ^ s252 s254 :: SWord1 = choose [15:15] s0 s255 :: SBool = s6 /= s254 s256 :: SBool = s20 ^ s255 s257 :: SBool = if s14 then s256 else s20 s258 :: SWord1 = choose [14:14] s0 s259 :: SBool = s6 /= s258 s260 :: SBool = s25 ^ s259 s261 :: SBool = if s14 then s260 else s25 s262 :: SBool = s255 ^ s261 s263 :: SBool = if s257 then s262 else s261 s264 :: SWord1 = choose [13:13] s0 s265 :: SBool = s6 /= s264 s266 :: SBool = s30 ^ s265 s267 :: SBool = if s14 then s266 else s30 s268 :: SBool = s259 ^ s267 s269 :: SBool = if s257 then s268 else s267 s270 :: SBool = s255 ^ s269 s271 :: SBool = if s263 then s270 else s269 s272 :: SWord1 = choose [12:12] s0 s273 :: SBool = s6 /= s272 s274 :: SBool = s35 ^ s273 s275 :: SBool = if s14 then s274 else s35 s276 :: SBool = s265 ^ s275 s277 :: SBool = if s257 then s276 else s275 s278 :: SBool = s259 ^ s277 s279 :: SBool = if s263 then s278 else s277 s280 :: SBool = s255 ^ s279 s281 :: SBool = if s271 then s280 else s279 s282 :: SWord1 = choose [11:11] s0 s283 :: SBool = s6 /= s282 s284 :: SBool = s40 ^ s283 s285 :: SBool = if s14 then s284 else s40 s286 :: SBool = s273 ^ s285 s287 :: SBool = if s257 then s286 else s285 s288 :: SBool = s265 ^ s287 s289 :: SBool = if s263 then s288 else s287 s290 :: SBool = s259 ^ s289 s291 :: SBool = if s271 then s290 else s289 s292 :: SBool = s255 ^ s291 s293 :: SBool = if s281 then s292 else s291 s294 :: SWord1 = choose [10:10] s0 s295 :: SBool = s6 /= s294 s296 :: SBool = s45 ^ s295 s297 :: SBool = if s14 then s296 else s45 s298 :: SBool = s283 ^ s297 s299 :: SBool = if s257 then s298 else s297 s300 :: SBool = s273 ^ s299 s301 :: SBool = if s263 then s300 else s299 s302 :: SBool = s265 ^ s301 s303 :: SBool = if s271 then s302 else s301 s304 :: SBool = s259 ^ s303 s305 :: SBool = if s281 then s304 else s303 s306 :: SBool = s255 ^ s305 s307 :: SBool = if s293 then s306 else s305 s308 :: SWord1 = choose [9:9] s0 s309 :: SBool = s6 /= s308 s310 :: SBool = s50 ^ s309 s311 :: SBool = if s14 then s310 else s50 s312 :: SBool = s295 ^ s311 s313 :: SBool = if s257 then s312 else s311 s314 :: SBool = s283 ^ s313 s315 :: SBool = if s263 then s314 else s313 s316 :: SBool = s273 ^ s315 s317 :: SBool = if s271 then s316 else s315 s318 :: SBool = s265 ^ s317 s319 :: SBool = if s281 then s318 else s317 s320 :: SBool = s259 ^ s319 s321 :: SBool = if s293 then s320 else s319 s322 :: SBool = s255 ^ s321 s323 :: SBool = if s307 then s322 else s321 s324 :: SWord1 = choose [8:8] s0 s325 :: SBool = s6 /= s324 s326 :: SBool = s55 ^ s325 s327 :: SBool = if s14 then s326 else s55 s328 :: SBool = s309 ^ s327 s329 :: SBool = if s257 then s328 else s327 s330 :: SBool = s295 ^ s329 s331 :: SBool = if s263 then s330 else s329 s332 :: SBool = s283 ^ s331 s333 :: SBool = if s271 then s332 else s331 s334 :: SBool = s273 ^ s333 s335 :: SBool = if s281 then s334 else s333 s336 :: SBool = s265 ^ s335 s337 :: SBool = if s293 then s336 else s335 s338 :: SBool = s259 ^ s337 s339 :: SBool = if s307 then s338 else s337 s340 :: SBool = s255 ^ s339 s341 :: SBool = if s323 then s340 else s339 s342 :: SWord1 = choose [7:7] s0 s343 :: SBool = s6 /= s342 s344 :: SBool = s60 ^ s343 s345 :: SBool = if s14 then s344 else s60 s346 :: SBool = s325 ^ s345 s347 :: SBool = if s257 then s346 else s345 s348 :: SBool = s309 ^ s347 s349 :: SBool = if s263 then s348 else s347 s350 :: SBool = s295 ^ s349 s351 :: SBool = if s271 then s350 else s349 s352 :: SBool = s283 ^ s351 s353 :: SBool = if s281 then s352 else s351 s354 :: SBool = s273 ^ s353 s355 :: SBool = if s293 then s354 else s353 s356 :: SBool = s265 ^ s355 s357 :: SBool = if s307 then s356 else s355 s358 :: SBool = s259 ^ s357 s359 :: SBool = if s323 then s358 else s357 s360 :: SBool = s255 ^ s359 s361 :: SBool = if s341 then s360 else s359 s362 :: SWord1 = choose [6:6] s0 s363 :: SBool = s6 /= s362 s364 :: SBool = s65 ^ s363 s365 :: SBool = if s14 then s364 else s65 s366 :: SBool = s343 ^ s365 s367 :: SBool = if s257 then s366 else s365 s368 :: SBool = s325 ^ s367 s369 :: SBool = if s263 then s368 else s367 s370 :: SBool = s309 ^ s369 s371 :: SBool = if s271 then s370 else s369 s372 :: SBool = s295 ^ s371 s373 :: SBool = if s281 then s372 else s371 s374 :: SBool = s283 ^ s373 s375 :: SBool = if s293 then s374 else s373 s376 :: SBool = s273 ^ s375 s377 :: SBool = if s307 then s376 else s375 s378 :: SBool = s265 ^ s377 s379 :: SBool = if s323 then s378 else s377 s380 :: SBool = s259 ^ s379 s381 :: SBool = if s341 then s380 else s379 s382 :: SBool = s255 ^ s381 s383 :: SBool = if s361 then s382 else s381 s384 :: SWord1 = choose [5:5] s0 s385 :: SBool = s6 /= s384 s386 :: SBool = s70 ^ s385 s387 :: SBool = if s14 then s386 else s70 s388 :: SBool = s363 ^ s387 s389 :: SBool = if s257 then s388 else s387 s390 :: SBool = s343 ^ s389 s391 :: SBool = if s263 then s390 else s389 s392 :: SBool = s325 ^ s391 s393 :: SBool = if s271 then s392 else s391 s394 :: SBool = s309 ^ s393 s395 :: SBool = if s281 then s394 else s393 s396 :: SBool = s295 ^ s395 s397 :: SBool = if s293 then s396 else s395 s398 :: SBool = s283 ^ s397 s399 :: SBool = if s307 then s398 else s397 s400 :: SBool = s273 ^ s399 s401 :: SBool = if s323 then s400 else s399 s402 :: SBool = s265 ^ s401 s403 :: SBool = if s341 then s402 else s401 s404 :: SBool = s259 ^ s403 s405 :: SBool = if s361 then s404 else s403 s406 :: SBool = s255 ^ s405 s407 :: SBool = if s383 then s406 else s405 s408 :: SWord1 = choose [4:4] s0 s409 :: SBool = s6 /= s408 s410 :: SBool = s75 ^ s409 s411 :: SBool = if s14 then s410 else s75 s412 :: SBool = s385 ^ s411 s413 :: SBool = if s257 then s412 else s411 s414 :: SBool = s363 ^ s413 s415 :: SBool = if s263 then s414 else s413 s416 :: SBool = s343 ^ s415 s417 :: SBool = if s271 then s416 else s415 s418 :: SBool = s325 ^ s417 s419 :: SBool = if s281 then s418 else s417 s420 :: SBool = s309 ^ s419 s421 :: SBool = if s293 then s420 else s419 s422 :: SBool = s295 ^ s421 s423 :: SBool = if s307 then s422 else s421 s424 :: SBool = s283 ^ s423 s425 :: SBool = if s323 then s424 else s423 s426 :: SBool = s273 ^ s425 s427 :: SBool = if s341 then s426 else s425 s428 :: SBool = s265 ^ s427 s429 :: SBool = if s361 then s428 else s427 s430 :: SBool = s259 ^ s429 s431 :: SBool = if s383 then s430 else s429 s432 :: SBool = s255 ^ s431 s433 :: SBool = if s407 then s432 else s431 s434 :: SWord1 = choose [3:3] s0 s435 :: SBool = s6 /= s434 s436 :: SBool = s80 ^ s435 s437 :: SBool = if s14 then s436 else s80 s438 :: SBool = s409 ^ s437 s439 :: SBool = if s257 then s438 else s437 s440 :: SBool = s385 ^ s439 s441 :: SBool = if s263 then s440 else s439 s442 :: SBool = s363 ^ s441 s443 :: SBool = if s271 then s442 else s441 s444 :: SBool = s343 ^ s443 s445 :: SBool = if s281 then s444 else s443 s446 :: SBool = s325 ^ s445 s447 :: SBool = if s293 then s446 else s445 s448 :: SBool = s309 ^ s447 s449 :: SBool = if s307 then s448 else s447 s450 :: SBool = s295 ^ s449 s451 :: SBool = if s323 then s450 else s449 s452 :: SBool = s283 ^ s451 s453 :: SBool = if s341 then s452 else s451 s454 :: SBool = s273 ^ s453 s455 :: SBool = if s361 then s454 else s453 s456 :: SBool = s265 ^ s455 s457 :: SBool = if s383 then s456 else s455 s458 :: SBool = s259 ^ s457 s459 :: SBool = if s407 then s458 else s457 s460 :: SBool = s255 ^ s459 s461 :: SBool = if s433 then s460 else s459 s462 :: SWord1 = choose [2:2] s0 s463 :: SBool = s6 /= s462 s464 :: SBool = s85 ^ s463 s465 :: SBool = if s14 then s464 else s85 s466 :: SBool = s435 ^ s465 s467 :: SBool = if s257 then s466 else s465 s468 :: SBool = s409 ^ s467 s469 :: SBool = if s263 then s468 else s467 s470 :: SBool = s385 ^ s469 s471 :: SBool = if s271 then s470 else s469 s472 :: SBool = s363 ^ s471 s473 :: SBool = if s281 then s472 else s471 s474 :: SBool = s343 ^ s473 s475 :: SBool = if s293 then s474 else s473 s476 :: SBool = s325 ^ s475 s477 :: SBool = if s307 then s476 else s475 s478 :: SBool = s309 ^ s477 s479 :: SBool = if s323 then s478 else s477 s480 :: SBool = s295 ^ s479 s481 :: SBool = if s341 then s480 else s479 s482 :: SBool = s283 ^ s481 s483 :: SBool = if s361 then s482 else s481 s484 :: SBool = s273 ^ s483 s485 :: SBool = if s383 then s484 else s483 s486 :: SBool = s265 ^ s485 s487 :: SBool = if s407 then s486 else s485 s488 :: SBool = s259 ^ s487 s489 :: SBool = if s433 then s488 else s487 s490 :: SBool = s255 ^ s489 s491 :: SBool = if s461 then s490 else s489 s492 :: SWord1 = choose [1:1] s0 s493 :: SBool = s6 /= s492 s494 :: SBool = s90 ^ s493 s495 :: SBool = if s14 then s494 else s90 s496 :: SBool = s463 ^ s495 s497 :: SBool = if s257 then s496 else s495 s498 :: SBool = s435 ^ s497 s499 :: SBool = if s263 then s498 else s497 s500 :: SBool = s409 ^ s499 s501 :: SBool = if s271 then s500 else s499 s502 :: SBool = s385 ^ s501 s503 :: SBool = if s281 then s502 else s501 s504 :: SBool = s363 ^ s503 s505 :: SBool = if s293 then s504 else s503 s506 :: SBool = s343 ^ s505 s507 :: SBool = if s307 then s506 else s505 s508 :: SBool = s325 ^ s507 s509 :: SBool = if s323 then s508 else s507 s510 :: SBool = s309 ^ s509 s511 :: SBool = if s341 then s510 else s509 s512 :: SBool = s295 ^ s511 s513 :: SBool = if s361 then s512 else s511 s514 :: SBool = s283 ^ s513 s515 :: SBool = if s383 then s514 else s513 s516 :: SBool = s273 ^ s515 s517 :: SBool = if s407 then s516 else s515 s518 :: SBool = s265 ^ s517 s519 :: SBool = if s433 then s518 else s517 s520 :: SBool = s259 ^ s519 s521 :: SBool = if s461 then s520 else s519 s522 :: SBool = s255 ^ s521 s523 :: SBool = if s491 then s522 else s521 s524 :: SBool = s7 ^ s95 s525 :: SBool = if s14 then s524 else s95 s526 :: SBool = s493 ^ s525 s527 :: SBool = if s257 then s526 else s525 s528 :: SBool = s463 ^ s527 s529 :: SBool = if s263 then s528 else s527 s530 :: SBool = s435 ^ s529 s531 :: SBool = if s271 then s530 else s529 s532 :: SBool = s409 ^ s531 s533 :: SBool = if s281 then s532 else s531 s534 :: SBool = s385 ^ s533 s535 :: SBool = if s293 then s534 else s533 s536 :: SBool = s363 ^ s535 s537 :: SBool = if s307 then s536 else s535 s538 :: SBool = s343 ^ s537 s539 :: SBool = if s323 then s538 else s537 s540 :: SBool = s325 ^ s539 s541 :: SBool = if s341 then s540 else s539 s542 :: SBool = s309 ^ s541 s543 :: SBool = if s361 then s542 else s541 s544 :: SBool = s295 ^ s543 s545 :: SBool = if s383 then s544 else s543 s546 :: SBool = s283 ^ s545 s547 :: SBool = if s407 then s546 else s545 s548 :: SBool = s273 ^ s547 s549 :: SBool = if s433 then s548 else s547 s550 :: SBool = s265 ^ s549 s551 :: SBool = if s461 then s550 else s549 s552 :: SBool = s259 ^ s551 s553 :: SBool = if s491 then s552 else s551 s554 :: SBool = s255 ^ s553 s555 :: SBool = if s523 then s554 else s553 s556 :: SBool = s7 ^ s100 s557 :: SBool = if s257 then s556 else s100 s558 :: SBool = s493 ^ s557 s559 :: SBool = if s263 then s558 else s557 s560 :: SBool = s463 ^ s559 s561 :: SBool = if s271 then s560 else s559 s562 :: SBool = s435 ^ s561 s563 :: SBool = if s281 then s562 else s561 s564 :: SBool = s409 ^ s563 s565 :: SBool = if s293 then s564 else s563 s566 :: SBool = s385 ^ s565 s567 :: SBool = if s307 then s566 else s565 s568 :: SBool = s363 ^ s567 s569 :: SBool = if s323 then s568 else s567 s570 :: SBool = s343 ^ s569 s571 :: SBool = if s341 then s570 else s569 s572 :: SBool = s325 ^ s571 s573 :: SBool = if s361 then s572 else s571 s574 :: SBool = s309 ^ s573 s575 :: SBool = if s383 then s574 else s573 s576 :: SBool = s295 ^ s575 s577 :: SBool = if s407 then s576 else s575 s578 :: SBool = s283 ^ s577 s579 :: SBool = if s433 then s578 else s577 s580 :: SBool = s273 ^ s579 s581 :: SBool = if s461 then s580 else s579 s582 :: SBool = s265 ^ s581 s583 :: SBool = if s491 then s582 else s581 s584 :: SBool = s259 ^ s583 s585 :: SBool = if s523 then s584 else s583 s586 :: SBool = s255 ^ s585 s587 :: SBool = if s555 then s586 else s585 s588 :: SBool = s7 ^ s105 s589 :: SBool = if s263 then s588 else s105 s590 :: SBool = s493 ^ s589 s591 :: SBool = if s271 then s590 else s589 s592 :: SBool = s463 ^ s591 s593 :: SBool = if s281 then s592 else s591 s594 :: SBool = s435 ^ s593 s595 :: SBool = if s293 then s594 else s593 s596 :: SBool = s409 ^ s595 s597 :: SBool = if s307 then s596 else s595 s598 :: SBool = s385 ^ s597 s599 :: SBool = if s323 then s598 else s597 s600 :: SBool = s363 ^ s599 s601 :: SBool = if s341 then s600 else s599 s602 :: SBool = s343 ^ s601 s603 :: SBool = if s361 then s602 else s601 s604 :: SBool = s325 ^ s603 s605 :: SBool = if s383 then s604 else s603 s606 :: SBool = s309 ^ s605 s607 :: SBool = if s407 then s606 else s605 s608 :: SBool = s295 ^ s607 s609 :: SBool = if s433 then s608 else s607 s610 :: SBool = s283 ^ s609 s611 :: SBool = if s461 then s610 else s609 s612 :: SBool = s273 ^ s611 s613 :: SBool = if s491 then s612 else s611 s614 :: SBool = s265 ^ s613 s615 :: SBool = if s523 then s614 else s613 s616 :: SBool = s259 ^ s615 s617 :: SBool = if s555 then s616 else s615 s618 :: SBool = s255 ^ s617 s619 :: SBool = if s587 then s618 else s617 s620 :: SBool = s7 ^ s110 s621 :: SBool = if s271 then s620 else s110 s622 :: SBool = s493 ^ s621 s623 :: SBool = if s281 then s622 else s621 s624 :: SBool = s463 ^ s623 s625 :: SBool = if s293 then s624 else s623 s626 :: SBool = s435 ^ s625 s627 :: SBool = if s307 then s626 else s625 s628 :: SBool = s409 ^ s627 s629 :: SBool = if s323 then s628 else s627 s630 :: SBool = s385 ^ s629 s631 :: SBool = if s341 then s630 else s629 s632 :: SBool = s363 ^ s631 s633 :: SBool = if s361 then s632 else s631 s634 :: SBool = s343 ^ s633 s635 :: SBool = if s383 then s634 else s633 s636 :: SBool = s325 ^ s635 s637 :: SBool = if s407 then s636 else s635 s638 :: SBool = s309 ^ s637 s639 :: SBool = if s433 then s638 else s637 s640 :: SBool = s295 ^ s639 s641 :: SBool = if s461 then s640 else s639 s642 :: SBool = s283 ^ s641 s643 :: SBool = if s491 then s642 else s641 s644 :: SBool = s273 ^ s643 s645 :: SBool = if s523 then s644 else s643 s646 :: SBool = s265 ^ s645 s647 :: SBool = if s555 then s646 else s645 s648 :: SBool = s259 ^ s647 s649 :: SBool = if s587 then s648 else s647 s650 :: SBool = s255 ^ s649 s651 :: SBool = if s619 then s650 else s649 s652 :: SBool = s7 ^ s115 s653 :: SBool = if s281 then s652 else s115 s654 :: SBool = s493 ^ s653 s655 :: SBool = if s293 then s654 else s653 s656 :: SBool = s463 ^ s655 s657 :: SBool = if s307 then s656 else s655 s658 :: SBool = s435 ^ s657 s659 :: SBool = if s323 then s658 else s657 s660 :: SBool = s409 ^ s659 s661 :: SBool = if s341 then s660 else s659 s662 :: SBool = s385 ^ s661 s663 :: SBool = if s361 then s662 else s661 s664 :: SBool = s363 ^ s663 s665 :: SBool = if s383 then s664 else s663 s666 :: SBool = s343 ^ s665 s667 :: SBool = if s407 then s666 else s665 s668 :: SBool = s325 ^ s667 s669 :: SBool = if s433 then s668 else s667 s670 :: SBool = s309 ^ s669 s671 :: SBool = if s461 then s670 else s669 s672 :: SBool = s295 ^ s671 s673 :: SBool = if s491 then s672 else s671 s674 :: SBool = s283 ^ s673 s675 :: SBool = if s523 then s674 else s673 s676 :: SBool = s273 ^ s675 s677 :: SBool = if s555 then s676 else s675 s678 :: SBool = s265 ^ s677 s679 :: SBool = if s587 then s678 else s677 s680 :: SBool = s259 ^ s679 s681 :: SBool = if s619 then s680 else s679 s682 :: SBool = s255 ^ s681 s683 :: SBool = if s651 then s682 else s681 s684 :: SBool = s7 ^ s120 s685 :: SBool = if s293 then s684 else s120 s686 :: SBool = s493 ^ s685 s687 :: SBool = if s307 then s686 else s685 s688 :: SBool = s463 ^ s687 s689 :: SBool = if s323 then s688 else s687 s690 :: SBool = s435 ^ s689 s691 :: SBool = if s341 then s690 else s689 s692 :: SBool = s409 ^ s691 s693 :: SBool = if s361 then s692 else s691 s694 :: SBool = s385 ^ s693 s695 :: SBool = if s383 then s694 else s693 s696 :: SBool = s363 ^ s695 s697 :: SBool = if s407 then s696 else s695 s698 :: SBool = s343 ^ s697 s699 :: SBool = if s433 then s698 else s697 s700 :: SBool = s325 ^ s699 s701 :: SBool = if s461 then s700 else s699 s702 :: SBool = s309 ^ s701 s703 :: SBool = if s491 then s702 else s701 s704 :: SBool = s295 ^ s703 s705 :: SBool = if s523 then s704 else s703 s706 :: SBool = s283 ^ s705 s707 :: SBool = if s555 then s706 else s705 s708 :: SBool = s273 ^ s707 s709 :: SBool = if s587 then s708 else s707 s710 :: SBool = s265 ^ s709 s711 :: SBool = if s619 then s710 else s709 s712 :: SBool = s259 ^ s711 s713 :: SBool = if s651 then s712 else s711 s714 :: SBool = s255 ^ s713 s715 :: SBool = if s683 then s714 else s713 s716 :: SBool = s7 ^ s125 s717 :: SBool = if s307 then s716 else s125 s718 :: SBool = s493 ^ s717 s719 :: SBool = if s323 then s718 else s717 s720 :: SBool = s463 ^ s719 s721 :: SBool = if s341 then s720 else s719 s722 :: SBool = s435 ^ s721 s723 :: SBool = if s361 then s722 else s721 s724 :: SBool = s409 ^ s723 s725 :: SBool = if s383 then s724 else s723 s726 :: SBool = s385 ^ s725 s727 :: SBool = if s407 then s726 else s725 s728 :: SBool = s363 ^ s727 s729 :: SBool = if s433 then s728 else s727 s730 :: SBool = s343 ^ s729 s731 :: SBool = if s461 then s730 else s729 s732 :: SBool = s325 ^ s731 s733 :: SBool = if s491 then s732 else s731 s734 :: SBool = s309 ^ s733 s735 :: SBool = if s523 then s734 else s733 s736 :: SBool = s295 ^ s735 s737 :: SBool = if s555 then s736 else s735 s738 :: SBool = s283 ^ s737 s739 :: SBool = if s587 then s738 else s737 s740 :: SBool = s273 ^ s739 s741 :: SBool = if s619 then s740 else s739 s742 :: SBool = s265 ^ s741 s743 :: SBool = if s651 then s742 else s741 s744 :: SBool = s259 ^ s743 s745 :: SBool = if s683 then s744 else s743 s746 :: SBool = s255 ^ s745 s747 :: SBool = if s715 then s746 else s745 s748 :: SBool = s7 ^ s130 s749 :: SBool = if s323 then s748 else s130 s750 :: SBool = s493 ^ s749 s751 :: SBool = if s341 then s750 else s749 s752 :: SBool = s463 ^ s751 s753 :: SBool = if s361 then s752 else s751 s754 :: SBool = s435 ^ s753 s755 :: SBool = if s383 then s754 else s753 s756 :: SBool = s409 ^ s755 s757 :: SBool = if s407 then s756 else s755 s758 :: SBool = s385 ^ s757 s759 :: SBool = if s433 then s758 else s757 s760 :: SBool = s363 ^ s759 s761 :: SBool = if s461 then s760 else s759 s762 :: SBool = s343 ^ s761 s763 :: SBool = if s491 then s762 else s761 s764 :: SBool = s325 ^ s763 s765 :: SBool = if s523 then s764 else s763 s766 :: SBool = s309 ^ s765 s767 :: SBool = if s555 then s766 else s765 s768 :: SBool = s295 ^ s767 s769 :: SBool = if s587 then s768 else s767 s770 :: SBool = s283 ^ s769 s771 :: SBool = if s619 then s770 else s769 s772 :: SBool = s273 ^ s771 s773 :: SBool = if s651 then s772 else s771 s774 :: SBool = s265 ^ s773 s775 :: SBool = if s683 then s774 else s773 s776 :: SBool = s259 ^ s775 s777 :: SBool = if s715 then s776 else s775 s778 :: SBool = s255 ^ s777 s779 :: SBool = if s747 then s778 else s777 s780 :: SBool = s7 ^ s135 s781 :: SBool = if s341 then s780 else s135 s782 :: SBool = s493 ^ s781 s783 :: SBool = if s361 then s782 else s781 s784 :: SBool = s463 ^ s783 s785 :: SBool = if s383 then s784 else s783 s786 :: SBool = s435 ^ s785 s787 :: SBool = if s407 then s786 else s785 s788 :: SBool = s409 ^ s787 s789 :: SBool = if s433 then s788 else s787 s790 :: SBool = s385 ^ s789 s791 :: SBool = if s461 then s790 else s789 s792 :: SBool = s363 ^ s791 s793 :: SBool = if s491 then s792 else s791 s794 :: SBool = s343 ^ s793 s795 :: SBool = if s523 then s794 else s793 s796 :: SBool = s325 ^ s795 s797 :: SBool = if s555 then s796 else s795 s798 :: SBool = s309 ^ s797 s799 :: SBool = if s587 then s798 else s797 s800 :: SBool = s295 ^ s799 s801 :: SBool = if s619 then s800 else s799 s802 :: SBool = s283 ^ s801 s803 :: SBool = if s651 then s802 else s801 s804 :: SBool = s273 ^ s803 s805 :: SBool = if s683 then s804 else s803 s806 :: SBool = s265 ^ s805 s807 :: SBool = if s715 then s806 else s805 s808 :: SBool = s259 ^ s807 s809 :: SBool = if s747 then s808 else s807 s810 :: SBool = s255 ^ s809 s811 :: SBool = if s779 then s810 else s809 s812 :: SBool = s7 ^ s140 s813 :: SBool = if s361 then s812 else s140 s814 :: SBool = s493 ^ s813 s815 :: SBool = if s383 then s814 else s813 s816 :: SBool = s463 ^ s815 s817 :: SBool = if s407 then s816 else s815 s818 :: SBool = s435 ^ s817 s819 :: SBool = if s433 then s818 else s817 s820 :: SBool = s409 ^ s819 s821 :: SBool = if s461 then s820 else s819 s822 :: SBool = s385 ^ s821 s823 :: SBool = if s491 then s822 else s821 s824 :: SBool = s363 ^ s823 s825 :: SBool = if s523 then s824 else s823 s826 :: SBool = s343 ^ s825 s827 :: SBool = if s555 then s826 else s825 s828 :: SBool = s325 ^ s827 s829 :: SBool = if s587 then s828 else s827 s830 :: SBool = s309 ^ s829 s831 :: SBool = if s619 then s830 else s829 s832 :: SBool = s295 ^ s831 s833 :: SBool = if s651 then s832 else s831 s834 :: SBool = s283 ^ s833 s835 :: SBool = if s683 then s834 else s833 s836 :: SBool = s273 ^ s835 s837 :: SBool = if s715 then s836 else s835 s838 :: SBool = s265 ^ s837 s839 :: SBool = if s747 then s838 else s837 s840 :: SBool = s259 ^ s839 s841 :: SBool = if s779 then s840 else s839 s842 :: SBool = s255 ^ s841 s843 :: SBool = if s811 then s842 else s841 s844 :: SBool = s7 ^ s145 s845 :: SBool = if s383 then s844 else s145 s846 :: SBool = s493 ^ s845 s847 :: SBool = if s407 then s846 else s845 s848 :: SBool = s463 ^ s847 s849 :: SBool = if s433 then s848 else s847 s850 :: SBool = s435 ^ s849 s851 :: SBool = if s461 then s850 else s849 s852 :: SBool = s409 ^ s851 s853 :: SBool = if s491 then s852 else s851 s854 :: SBool = s385 ^ s853 s855 :: SBool = if s523 then s854 else s853 s856 :: SBool = s363 ^ s855 s857 :: SBool = if s555 then s856 else s855 s858 :: SBool = s343 ^ s857 s859 :: SBool = if s587 then s858 else s857 s860 :: SBool = s325 ^ s859 s861 :: SBool = if s619 then s860 else s859 s862 :: SBool = s309 ^ s861 s863 :: SBool = if s651 then s862 else s861 s864 :: SBool = s295 ^ s863 s865 :: SBool = if s683 then s864 else s863 s866 :: SBool = s283 ^ s865 s867 :: SBool = if s715 then s866 else s865 s868 :: SBool = s273 ^ s867 s869 :: SBool = if s747 then s868 else s867 s870 :: SBool = s265 ^ s869 s871 :: SBool = if s779 then s870 else s869 s872 :: SBool = s259 ^ s871 s873 :: SBool = if s811 then s872 else s871 s874 :: SBool = s255 ^ s873 s875 :: SBool = if s843 then s874 else s873 s876 :: SBool = s7 ^ s150 s877 :: SBool = if s407 then s876 else s150 s878 :: SBool = s493 ^ s877 s879 :: SBool = if s433 then s878 else s877 s880 :: SBool = s463 ^ s879 s881 :: SBool = if s461 then s880 else s879 s882 :: SBool = s435 ^ s881 s883 :: SBool = if s491 then s882 else s881 s884 :: SBool = s409 ^ s883 s885 :: SBool = if s523 then s884 else s883 s886 :: SBool = s385 ^ s885 s887 :: SBool = if s555 then s886 else s885 s888 :: SBool = s363 ^ s887 s889 :: SBool = if s587 then s888 else s887 s890 :: SBool = s343 ^ s889 s891 :: SBool = if s619 then s890 else s889 s892 :: SBool = s325 ^ s891 s893 :: SBool = if s651 then s892 else s891 s894 :: SBool = s309 ^ s893 s895 :: SBool = if s683 then s894 else s893 s896 :: SBool = s295 ^ s895 s897 :: SBool = if s715 then s896 else s895 s898 :: SBool = s283 ^ s897 s899 :: SBool = if s747 then s898 else s897 s900 :: SBool = s273 ^ s899 s901 :: SBool = if s779 then s900 else s899 s902 :: SBool = s265 ^ s901 s903 :: SBool = if s811 then s902 else s901 s904 :: SBool = s259 ^ s903 s905 :: SBool = if s843 then s904 else s903 s906 :: SBool = s255 ^ s905 s907 :: SBool = if s875 then s906 else s905 s908 :: SBool = s7 ^ s155 s909 :: SBool = if s433 then s908 else s155 s910 :: SBool = s493 ^ s909 s911 :: SBool = if s461 then s910 else s909 s912 :: SBool = s463 ^ s911 s913 :: SBool = if s491 then s912 else s911 s914 :: SBool = s435 ^ s913 s915 :: SBool = if s523 then s914 else s913 s916 :: SBool = s409 ^ s915 s917 :: SBool = if s555 then s916 else s915 s918 :: SBool = s385 ^ s917 s919 :: SBool = if s587 then s918 else s917 s920 :: SBool = s363 ^ s919 s921 :: SBool = if s619 then s920 else s919 s922 :: SBool = s343 ^ s921 s923 :: SBool = if s651 then s922 else s921 s924 :: SBool = s325 ^ s923 s925 :: SBool = if s683 then s924 else s923 s926 :: SBool = s309 ^ s925 s927 :: SBool = if s715 then s926 else s925 s928 :: SBool = s295 ^ s927 s929 :: SBool = if s747 then s928 else s927 s930 :: SBool = s283 ^ s929 s931 :: SBool = if s779 then s930 else s929 s932 :: SBool = s273 ^ s931 s933 :: SBool = if s811 then s932 else s931 s934 :: SBool = s265 ^ s933 s935 :: SBool = if s843 then s934 else s933 s936 :: SBool = s259 ^ s935 s937 :: SBool = if s875 then s936 else s935 s938 :: SBool = s255 ^ s937 s939 :: SBool = if s907 then s938 else s937 s940 :: SBool = s7 ^ s160 s941 :: SBool = if s461 then s940 else s160 s942 :: SBool = s493 ^ s941 s943 :: SBool = if s491 then s942 else s941 s944 :: SBool = s463 ^ s943 s945 :: SBool = if s523 then s944 else s943 s946 :: SBool = s435 ^ s945 s947 :: SBool = if s555 then s946 else s945 s948 :: SBool = s409 ^ s947 s949 :: SBool = if s587 then s948 else s947 s950 :: SBool = s385 ^ s949 s951 :: SBool = if s619 then s950 else s949 s952 :: SBool = s363 ^ s951 s953 :: SBool = if s651 then s952 else s951 s954 :: SBool = s343 ^ s953 s955 :: SBool = if s683 then s954 else s953 s956 :: SBool = s325 ^ s955 s957 :: SBool = if s715 then s956 else s955 s958 :: SBool = s309 ^ s957 s959 :: SBool = if s747 then s958 else s957 s960 :: SBool = s295 ^ s959 s961 :: SBool = if s779 then s960 else s959 s962 :: SBool = s283 ^ s961 s963 :: SBool = if s811 then s962 else s961 s964 :: SBool = s273 ^ s963 s965 :: SBool = if s843 then s964 else s963 s966 :: SBool = s265 ^ s965 s967 :: SBool = if s875 then s966 else s965 s968 :: SBool = s259 ^ s967 s969 :: SBool = if s907 then s968 else s967 s970 :: SBool = s255 ^ s969 s971 :: SBool = if s939 then s970 else s969 s972 :: SBool = s7 ^ s165 s973 :: SBool = if s491 then s972 else s165 s974 :: SBool = s493 ^ s973 s975 :: SBool = if s523 then s974 else s973 s976 :: SBool = s463 ^ s975 s977 :: SBool = if s555 then s976 else s975 s978 :: SBool = s435 ^ s977 s979 :: SBool = if s587 then s978 else s977 s980 :: SBool = s409 ^ s979 s981 :: SBool = if s619 then s980 else s979 s982 :: SBool = s385 ^ s981 s983 :: SBool = if s651 then s982 else s981 s984 :: SBool = s363 ^ s983 s985 :: SBool = if s683 then s984 else s983 s986 :: SBool = s343 ^ s985 s987 :: SBool = if s715 then s986 else s985 s988 :: SBool = s325 ^ s987 s989 :: SBool = if s747 then s988 else s987 s990 :: SBool = s309 ^ s989 s991 :: SBool = if s779 then s990 else s989 s992 :: SBool = s295 ^ s991 s993 :: SBool = if s811 then s992 else s991 s994 :: SBool = s283 ^ s993 s995 :: SBool = if s843 then s994 else s993 s996 :: SBool = s273 ^ s995 s997 :: SBool = if s875 then s996 else s995 s998 :: SBool = s265 ^ s997 s999 :: SBool = if s907 then s998 else s997 s1000 :: SBool = s259 ^ s999 s1001 :: SBool = if s939 then s1000 else s999 s1002 :: SBool = s255 ^ s1001 s1003 :: SBool = if s971 then s1002 else s1001 s1004 :: SBool = s7 ^ s170 s1005 :: SBool = if s523 then s1004 else s170 s1006 :: SBool = s493 ^ s1005 s1007 :: SBool = if s555 then s1006 else s1005 s1008 :: SBool = s463 ^ s1007 s1009 :: SBool = if s587 then s1008 else s1007 s1010 :: SBool = s435 ^ s1009 s1011 :: SBool = if s619 then s1010 else s1009 s1012 :: SBool = s409 ^ s1011 s1013 :: SBool = if s651 then s1012 else s1011 s1014 :: SBool = s385 ^ s1013 s1015 :: SBool = if s683 then s1014 else s1013 s1016 :: SBool = s363 ^ s1015 s1017 :: SBool = if s715 then s1016 else s1015 s1018 :: SBool = s343 ^ s1017 s1019 :: SBool = if s747 then s1018 else s1017 s1020 :: SBool = s325 ^ s1019 s1021 :: SBool = if s779 then s1020 else s1019 s1022 :: SBool = s309 ^ s1021 s1023 :: SBool = if s811 then s1022 else s1021 s1024 :: SBool = s295 ^ s1023 s1025 :: SBool = if s843 then s1024 else s1023 s1026 :: SBool = s283 ^ s1025 s1027 :: SBool = if s875 then s1026 else s1025 s1028 :: SBool = s273 ^ s1027 s1029 :: SBool = if s907 then s1028 else s1027 s1030 :: SBool = s265 ^ s1029 s1031 :: SBool = if s939 then s1030 else s1029 s1032 :: SBool = s259 ^ s1031 s1033 :: SBool = if s971 then s1032 else s1031 s1034 :: SBool = s255 ^ s1033 s1035 :: SBool = if s1003 then s1034 else s1033 s1036 :: SBool = s7 ^ s175 s1037 :: SBool = if s555 then s1036 else s175 s1038 :: SBool = s493 ^ s1037 s1039 :: SBool = if s587 then s1038 else s1037 s1040 :: SBool = s463 ^ s1039 s1041 :: SBool = if s619 then s1040 else s1039 s1042 :: SBool = s435 ^ s1041 s1043 :: SBool = if s651 then s1042 else s1041 s1044 :: SBool = s409 ^ s1043 s1045 :: SBool = if s683 then s1044 else s1043 s1046 :: SBool = s385 ^ s1045 s1047 :: SBool = if s715 then s1046 else s1045 s1048 :: SBool = s363 ^ s1047 s1049 :: SBool = if s747 then s1048 else s1047 s1050 :: SBool = s343 ^ s1049 s1051 :: SBool = if s779 then s1050 else s1049 s1052 :: SBool = s325 ^ s1051 s1053 :: SBool = if s811 then s1052 else s1051 s1054 :: SBool = s309 ^ s1053 s1055 :: SBool = if s843 then s1054 else s1053 s1056 :: SBool = s295 ^ s1055 s1057 :: SBool = if s875 then s1056 else s1055 s1058 :: SBool = s283 ^ s1057 s1059 :: SBool = if s907 then s1058 else s1057 s1060 :: SBool = s273 ^ s1059 s1061 :: SBool = if s939 then s1060 else s1059 s1062 :: SBool = s265 ^ s1061 s1063 :: SBool = if s971 then s1062 else s1061 s1064 :: SBool = s259 ^ s1063 s1065 :: SBool = if s1003 then s1064 else s1063 s1066 :: SBool = s255 ^ s1065 s1067 :: SBool = if s1035 then s1066 else s1065 s1068 :: SBool = s7 ^ s180 s1069 :: SBool = if s587 then s1068 else s180 s1070 :: SBool = s493 ^ s1069 s1071 :: SBool = if s619 then s1070 else s1069 s1072 :: SBool = s463 ^ s1071 s1073 :: SBool = if s651 then s1072 else s1071 s1074 :: SBool = s435 ^ s1073 s1075 :: SBool = if s683 then s1074 else s1073 s1076 :: SBool = s409 ^ s1075 s1077 :: SBool = if s715 then s1076 else s1075 s1078 :: SBool = s385 ^ s1077 s1079 :: SBool = if s747 then s1078 else s1077 s1080 :: SBool = s363 ^ s1079 s1081 :: SBool = if s779 then s1080 else s1079 s1082 :: SBool = s343 ^ s1081 s1083 :: SBool = if s811 then s1082 else s1081 s1084 :: SBool = s325 ^ s1083 s1085 :: SBool = if s843 then s1084 else s1083 s1086 :: SBool = s309 ^ s1085 s1087 :: SBool = if s875 then s1086 else s1085 s1088 :: SBool = s295 ^ s1087 s1089 :: SBool = if s907 then s1088 else s1087 s1090 :: SBool = s283 ^ s1089 s1091 :: SBool = if s939 then s1090 else s1089 s1092 :: SBool = s273 ^ s1091 s1093 :: SBool = if s971 then s1092 else s1091 s1094 :: SBool = s265 ^ s1093 s1095 :: SBool = if s1003 then s1094 else s1093 s1096 :: SBool = s259 ^ s1095 s1097 :: SBool = if s1035 then s1096 else s1095 s1098 :: SBool = s255 ^ s1097 s1099 :: SBool = if s1067 then s1098 else s1097 s1100 :: SBool = s7 ^ s185 s1101 :: SBool = if s619 then s1100 else s185 s1102 :: SBool = s493 ^ s1101 s1103 :: SBool = if s651 then s1102 else s1101 s1104 :: SBool = s463 ^ s1103 s1105 :: SBool = if s683 then s1104 else s1103 s1106 :: SBool = s435 ^ s1105 s1107 :: SBool = if s715 then s1106 else s1105 s1108 :: SBool = s409 ^ s1107 s1109 :: SBool = if s747 then s1108 else s1107 s1110 :: SBool = s385 ^ s1109 s1111 :: SBool = if s779 then s1110 else s1109 s1112 :: SBool = s363 ^ s1111 s1113 :: SBool = if s811 then s1112 else s1111 s1114 :: SBool = s343 ^ s1113 s1115 :: SBool = if s843 then s1114 else s1113 s1116 :: SBool = s325 ^ s1115 s1117 :: SBool = if s875 then s1116 else s1115 s1118 :: SBool = s309 ^ s1117 s1119 :: SBool = if s907 then s1118 else s1117 s1120 :: SBool = s295 ^ s1119 s1121 :: SBool = if s939 then s1120 else s1119 s1122 :: SBool = s283 ^ s1121 s1123 :: SBool = if s971 then s1122 else s1121 s1124 :: SBool = s273 ^ s1123 s1125 :: SBool = if s1003 then s1124 else s1123 s1126 :: SBool = s265 ^ s1125 s1127 :: SBool = if s1035 then s1126 else s1125 s1128 :: SBool = s259 ^ s1127 s1129 :: SBool = if s1067 then s1128 else s1127 s1130 :: SBool = s255 ^ s1129 s1131 :: SBool = if s1099 then s1130 else s1129 s1132 :: SBool = s7 ^ s190 s1133 :: SBool = if s651 then s1132 else s190 s1134 :: SBool = s493 ^ s1133 s1135 :: SBool = if s683 then s1134 else s1133 s1136 :: SBool = s463 ^ s1135 s1137 :: SBool = if s715 then s1136 else s1135 s1138 :: SBool = s435 ^ s1137 s1139 :: SBool = if s747 then s1138 else s1137 s1140 :: SBool = s409 ^ s1139 s1141 :: SBool = if s779 then s1140 else s1139 s1142 :: SBool = s385 ^ s1141 s1143 :: SBool = if s811 then s1142 else s1141 s1144 :: SBool = s363 ^ s1143 s1145 :: SBool = if s843 then s1144 else s1143 s1146 :: SBool = s343 ^ s1145 s1147 :: SBool = if s875 then s1146 else s1145 s1148 :: SBool = s325 ^ s1147 s1149 :: SBool = if s907 then s1148 else s1147 s1150 :: SBool = s309 ^ s1149 s1151 :: SBool = if s939 then s1150 else s1149 s1152 :: SBool = s295 ^ s1151 s1153 :: SBool = if s971 then s1152 else s1151 s1154 :: SBool = s283 ^ s1153 s1155 :: SBool = if s1003 then s1154 else s1153 s1156 :: SBool = s273 ^ s1155 s1157 :: SBool = if s1035 then s1156 else s1155 s1158 :: SBool = s265 ^ s1157 s1159 :: SBool = if s1067 then s1158 else s1157 s1160 :: SBool = s259 ^ s1159 s1161 :: SBool = if s1099 then s1160 else s1159 s1162 :: SBool = s255 ^ s1161 s1163 :: SBool = if s1131 then s1162 else s1161 s1164 :: SBool = s7 ^ s195 s1165 :: SBool = if s683 then s1164 else s195 s1166 :: SBool = s493 ^ s1165 s1167 :: SBool = if s715 then s1166 else s1165 s1168 :: SBool = s463 ^ s1167 s1169 :: SBool = if s747 then s1168 else s1167 s1170 :: SBool = s435 ^ s1169 s1171 :: SBool = if s779 then s1170 else s1169 s1172 :: SBool = s409 ^ s1171 s1173 :: SBool = if s811 then s1172 else s1171 s1174 :: SBool = s385 ^ s1173 s1175 :: SBool = if s843 then s1174 else s1173 s1176 :: SBool = s363 ^ s1175 s1177 :: SBool = if s875 then s1176 else s1175 s1178 :: SBool = s343 ^ s1177 s1179 :: SBool = if s907 then s1178 else s1177 s1180 :: SBool = s325 ^ s1179 s1181 :: SBool = if s939 then s1180 else s1179 s1182 :: SBool = s309 ^ s1181 s1183 :: SBool = if s971 then s1182 else s1181 s1184 :: SBool = s295 ^ s1183 s1185 :: SBool = if s1003 then s1184 else s1183 s1186 :: SBool = s283 ^ s1185 s1187 :: SBool = if s1035 then s1186 else s1185 s1188 :: SBool = s273 ^ s1187 s1189 :: SBool = if s1067 then s1188 else s1187 s1190 :: SBool = s265 ^ s1189 s1191 :: SBool = if s1099 then s1190 else s1189 s1192 :: SBool = s259 ^ s1191 s1193 :: SBool = if s1131 then s1192 else s1191 s1194 :: SBool = s255 ^ s1193 s1195 :: SBool = if s1163 then s1194 else s1193 s1196 :: SBool = s7 ^ s200 s1197 :: SBool = if s715 then s1196 else s200 s1198 :: SBool = s493 ^ s1197 s1199 :: SBool = if s747 then s1198 else s1197 s1200 :: SBool = s463 ^ s1199 s1201 :: SBool = if s779 then s1200 else s1199 s1202 :: SBool = s435 ^ s1201 s1203 :: SBool = if s811 then s1202 else s1201 s1204 :: SBool = s409 ^ s1203 s1205 :: SBool = if s843 then s1204 else s1203 s1206 :: SBool = s385 ^ s1205 s1207 :: SBool = if s875 then s1206 else s1205 s1208 :: SBool = s363 ^ s1207 s1209 :: SBool = if s907 then s1208 else s1207 s1210 :: SBool = s343 ^ s1209 s1211 :: SBool = if s939 then s1210 else s1209 s1212 :: SBool = s325 ^ s1211 s1213 :: SBool = if s971 then s1212 else s1211 s1214 :: SBool = s309 ^ s1213 s1215 :: SBool = if s1003 then s1214 else s1213 s1216 :: SBool = s295 ^ s1215 s1217 :: SBool = if s1035 then s1216 else s1215 s1218 :: SBool = s283 ^ s1217 s1219 :: SBool = if s1067 then s1218 else s1217 s1220 :: SBool = s273 ^ s1219 s1221 :: SBool = if s1099 then s1220 else s1219 s1222 :: SBool = s265 ^ s1221 s1223 :: SBool = if s1131 then s1222 else s1221 s1224 :: SBool = s259 ^ s1223 s1225 :: SBool = if s1163 then s1224 else s1223 s1226 :: SBool = s255 ^ s1225 s1227 :: SBool = if s1195 then s1226 else s1225 s1228 :: SBool = s7 ^ s205 s1229 :: SBool = if s747 then s1228 else s205 s1230 :: SBool = s493 ^ s1229 s1231 :: SBool = if s779 then s1230 else s1229 s1232 :: SBool = s463 ^ s1231 s1233 :: SBool = if s811 then s1232 else s1231 s1234 :: SBool = s435 ^ s1233 s1235 :: SBool = if s843 then s1234 else s1233 s1236 :: SBool = s409 ^ s1235 s1237 :: SBool = if s875 then s1236 else s1235 s1238 :: SBool = s385 ^ s1237 s1239 :: SBool = if s907 then s1238 else s1237 s1240 :: SBool = s363 ^ s1239 s1241 :: SBool = if s939 then s1240 else s1239 s1242 :: SBool = s343 ^ s1241 s1243 :: SBool = if s971 then s1242 else s1241 s1244 :: SBool = s325 ^ s1243 s1245 :: SBool = if s1003 then s1244 else s1243 s1246 :: SBool = s309 ^ s1245 s1247 :: SBool = if s1035 then s1246 else s1245 s1248 :: SBool = s295 ^ s1247 s1249 :: SBool = if s1067 then s1248 else s1247 s1250 :: SBool = s283 ^ s1249 s1251 :: SBool = if s1099 then s1250 else s1249 s1252 :: SBool = s273 ^ s1251 s1253 :: SBool = if s1131 then s1252 else s1251 s1254 :: SBool = s265 ^ s1253 s1255 :: SBool = if s1163 then s1254 else s1253 s1256 :: SBool = s259 ^ s1255 s1257 :: SBool = if s1195 then s1256 else s1255 s1258 :: SBool = s255 ^ s1257 s1259 :: SBool = if s1227 then s1258 else s1257 s1260 :: SBool = s7 ^ s210 s1261 :: SBool = if s779 then s1260 else s210 s1262 :: SBool = s493 ^ s1261 s1263 :: SBool = if s811 then s1262 else s1261 s1264 :: SBool = s463 ^ s1263 s1265 :: SBool = if s843 then s1264 else s1263 s1266 :: SBool = s435 ^ s1265 s1267 :: SBool = if s875 then s1266 else s1265 s1268 :: SBool = s409 ^ s1267 s1269 :: SBool = if s907 then s1268 else s1267 s1270 :: SBool = s385 ^ s1269 s1271 :: SBool = if s939 then s1270 else s1269 s1272 :: SBool = s363 ^ s1271 s1273 :: SBool = if s971 then s1272 else s1271 s1274 :: SBool = s343 ^ s1273 s1275 :: SBool = if s1003 then s1274 else s1273 s1276 :: SBool = s325 ^ s1275 s1277 :: SBool = if s1035 then s1276 else s1275 s1278 :: SBool = s309 ^ s1277 s1279 :: SBool = if s1067 then s1278 else s1277 s1280 :: SBool = s295 ^ s1279 s1281 :: SBool = if s1099 then s1280 else s1279 s1282 :: SBool = s283 ^ s1281 s1283 :: SBool = if s1131 then s1282 else s1281 s1284 :: SBool = s273 ^ s1283 s1285 :: SBool = if s1163 then s1284 else s1283 s1286 :: SBool = s265 ^ s1285 s1287 :: SBool = if s1195 then s1286 else s1285 s1288 :: SBool = s259 ^ s1287 s1289 :: SBool = if s1227 then s1288 else s1287 s1290 :: SBool = s255 ^ s1289 s1291 :: SBool = if s1259 then s1290 else s1289 s1292 :: SBool = s7 ^ s215 s1293 :: SBool = if s811 then s1292 else s215 s1294 :: SBool = s493 ^ s1293 s1295 :: SBool = if s843 then s1294 else s1293 s1296 :: SBool = s463 ^ s1295 s1297 :: SBool = if s875 then s1296 else s1295 s1298 :: SBool = s435 ^ s1297 s1299 :: SBool = if s907 then s1298 else s1297 s1300 :: SBool = s409 ^ s1299 s1301 :: SBool = if s939 then s1300 else s1299 s1302 :: SBool = s385 ^ s1301 s1303 :: SBool = if s971 then s1302 else s1301 s1304 :: SBool = s363 ^ s1303 s1305 :: SBool = if s1003 then s1304 else s1303 s1306 :: SBool = s343 ^ s1305 s1307 :: SBool = if s1035 then s1306 else s1305 s1308 :: SBool = s325 ^ s1307 s1309 :: SBool = if s1067 then s1308 else s1307 s1310 :: SBool = s309 ^ s1309 s1311 :: SBool = if s1099 then s1310 else s1309 s1312 :: SBool = s295 ^ s1311 s1313 :: SBool = if s1131 then s1312 else s1311 s1314 :: SBool = s283 ^ s1313 s1315 :: SBool = if s1163 then s1314 else s1313 s1316 :: SBool = s273 ^ s1315 s1317 :: SBool = if s1195 then s1316 else s1315 s1318 :: SBool = s265 ^ s1317 s1319 :: SBool = if s1227 then s1318 else s1317 s1320 :: SBool = s259 ^ s1319 s1321 :: SBool = if s1259 then s1320 else s1319 s1322 :: SBool = s255 ^ s1321 s1323 :: SBool = if s1291 then s1322 else s1321 s1324 :: SBool = s7 ^ s220 s1325 :: SBool = if s843 then s1324 else s220 s1326 :: SBool = s493 ^ s1325 s1327 :: SBool = if s875 then s1326 else s1325 s1328 :: SBool = s463 ^ s1327 s1329 :: SBool = if s907 then s1328 else s1327 s1330 :: SBool = s435 ^ s1329 s1331 :: SBool = if s939 then s1330 else s1329 s1332 :: SBool = s409 ^ s1331 s1333 :: SBool = if s971 then s1332 else s1331 s1334 :: SBool = s385 ^ s1333 s1335 :: SBool = if s1003 then s1334 else s1333 s1336 :: SBool = s363 ^ s1335 s1337 :: SBool = if s1035 then s1336 else s1335 s1338 :: SBool = s343 ^ s1337 s1339 :: SBool = if s1067 then s1338 else s1337 s1340 :: SBool = s325 ^ s1339 s1341 :: SBool = if s1099 then s1340 else s1339 s1342 :: SBool = s309 ^ s1341 s1343 :: SBool = if s1131 then s1342 else s1341 s1344 :: SBool = s295 ^ s1343 s1345 :: SBool = if s1163 then s1344 else s1343 s1346 :: SBool = s283 ^ s1345 s1347 :: SBool = if s1195 then s1346 else s1345 s1348 :: SBool = s273 ^ s1347 s1349 :: SBool = if s1227 then s1348 else s1347 s1350 :: SBool = s265 ^ s1349 s1351 :: SBool = if s1259 then s1350 else s1349 s1352 :: SBool = s259 ^ s1351 s1353 :: SBool = if s1291 then s1352 else s1351 s1354 :: SBool = s255 ^ s1353 s1355 :: SBool = if s1323 then s1354 else s1353 s1356 :: SBool = s7 ^ s225 s1357 :: SBool = if s875 then s1356 else s225 s1358 :: SBool = s493 ^ s1357 s1359 :: SBool = if s907 then s1358 else s1357 s1360 :: SBool = s463 ^ s1359 s1361 :: SBool = if s939 then s1360 else s1359 s1362 :: SBool = s435 ^ s1361 s1363 :: SBool = if s971 then s1362 else s1361 s1364 :: SBool = s409 ^ s1363 s1365 :: SBool = if s1003 then s1364 else s1363 s1366 :: SBool = s385 ^ s1365 s1367 :: SBool = if s1035 then s1366 else s1365 s1368 :: SBool = s363 ^ s1367 s1369 :: SBool = if s1067 then s1368 else s1367 s1370 :: SBool = s343 ^ s1369 s1371 :: SBool = if s1099 then s1370 else s1369 s1372 :: SBool = s325 ^ s1371 s1373 :: SBool = if s1131 then s1372 else s1371 s1374 :: SBool = s309 ^ s1373 s1375 :: SBool = if s1163 then s1374 else s1373 s1376 :: SBool = s295 ^ s1375 s1377 :: SBool = if s1195 then s1376 else s1375 s1378 :: SBool = s283 ^ s1377 s1379 :: SBool = if s1227 then s1378 else s1377 s1380 :: SBool = s273 ^ s1379 s1381 :: SBool = if s1259 then s1380 else s1379 s1382 :: SBool = s265 ^ s1381 s1383 :: SBool = if s1291 then s1382 else s1381 s1384 :: SBool = s259 ^ s1383 s1385 :: SBool = if s1323 then s1384 else s1383 s1386 :: SBool = s255 ^ s1385 s1387 :: SBool = if s1355 then s1386 else s1385 s1388 :: SBool = s7 ^ s230 s1389 :: SBool = if s907 then s1388 else s230 s1390 :: SBool = s493 ^ s1389 s1391 :: SBool = if s939 then s1390 else s1389 s1392 :: SBool = s463 ^ s1391 s1393 :: SBool = if s971 then s1392 else s1391 s1394 :: SBool = s435 ^ s1393 s1395 :: SBool = if s1003 then s1394 else s1393 s1396 :: SBool = s409 ^ s1395 s1397 :: SBool = if s1035 then s1396 else s1395 s1398 :: SBool = s385 ^ s1397 s1399 :: SBool = if s1067 then s1398 else s1397 s1400 :: SBool = s363 ^ s1399 s1401 :: SBool = if s1099 then s1400 else s1399 s1402 :: SBool = s343 ^ s1401 s1403 :: SBool = if s1131 then s1402 else s1401 s1404 :: SBool = s325 ^ s1403 s1405 :: SBool = if s1163 then s1404 else s1403 s1406 :: SBool = s309 ^ s1405 s1407 :: SBool = if s1195 then s1406 else s1405 s1408 :: SBool = s295 ^ s1407 s1409 :: SBool = if s1227 then s1408 else s1407 s1410 :: SBool = s283 ^ s1409 s1411 :: SBool = if s1259 then s1410 else s1409 s1412 :: SBool = s273 ^ s1411 s1413 :: SBool = if s1291 then s1412 else s1411 s1414 :: SBool = s265 ^ s1413 s1415 :: SBool = if s1323 then s1414 else s1413 s1416 :: SBool = s259 ^ s1415 s1417 :: SBool = if s1355 then s1416 else s1415 s1418 :: SBool = s255 ^ s1417 s1419 :: SBool = if s1387 then s1418 else s1417 s1420 :: SBool = s7 ^ s235 s1421 :: SBool = if s939 then s1420 else s235 s1422 :: SBool = s493 ^ s1421 s1423 :: SBool = if s971 then s1422 else s1421 s1424 :: SBool = s463 ^ s1423 s1425 :: SBool = if s1003 then s1424 else s1423 s1426 :: SBool = s435 ^ s1425 s1427 :: SBool = if s1035 then s1426 else s1425 s1428 :: SBool = s409 ^ s1427 s1429 :: SBool = if s1067 then s1428 else s1427 s1430 :: SBool = s385 ^ s1429 s1431 :: SBool = if s1099 then s1430 else s1429 s1432 :: SBool = s363 ^ s1431 s1433 :: SBool = if s1131 then s1432 else s1431 s1434 :: SBool = s343 ^ s1433 s1435 :: SBool = if s1163 then s1434 else s1433 s1436 :: SBool = s325 ^ s1435 s1437 :: SBool = if s1195 then s1436 else s1435 s1438 :: SBool = s309 ^ s1437 s1439 :: SBool = if s1227 then s1438 else s1437 s1440 :: SBool = s295 ^ s1439 s1441 :: SBool = if s1259 then s1440 else s1439 s1442 :: SBool = s283 ^ s1441 s1443 :: SBool = if s1291 then s1442 else s1441 s1444 :: SBool = s273 ^ s1443 s1445 :: SBool = if s1323 then s1444 else s1443 s1446 :: SBool = s265 ^ s1445 s1447 :: SBool = if s1355 then s1446 else s1445 s1448 :: SBool = s259 ^ s1447 s1449 :: SBool = if s1387 then s1448 else s1447 s1450 :: SBool = s255 ^ s1449 s1451 :: SBool = if s1419 then s1450 else s1449 s1452 :: SBool = s7 ^ s240 s1453 :: SBool = if s971 then s1452 else s240 s1454 :: SBool = s493 ^ s1453 s1455 :: SBool = if s1003 then s1454 else s1453 s1456 :: SBool = s463 ^ s1455 s1457 :: SBool = if s1035 then s1456 else s1455 s1458 :: SBool = s435 ^ s1457 s1459 :: SBool = if s1067 then s1458 else s1457 s1460 :: SBool = s409 ^ s1459 s1461 :: SBool = if s1099 then s1460 else s1459 s1462 :: SBool = s385 ^ s1461 s1463 :: SBool = if s1131 then s1462 else s1461 s1464 :: SBool = s363 ^ s1463 s1465 :: SBool = if s1163 then s1464 else s1463 s1466 :: SBool = s343 ^ s1465 s1467 :: SBool = if s1195 then s1466 else s1465 s1468 :: SBool = s325 ^ s1467 s1469 :: SBool = if s1227 then s1468 else s1467 s1470 :: SBool = s309 ^ s1469 s1471 :: SBool = if s1259 then s1470 else s1469 s1472 :: SBool = s295 ^ s1471 s1473 :: SBool = if s1291 then s1472 else s1471 s1474 :: SBool = s283 ^ s1473 s1475 :: SBool = if s1323 then s1474 else s1473 s1476 :: SBool = s273 ^ s1475 s1477 :: SBool = if s1355 then s1476 else s1475 s1478 :: SBool = s265 ^ s1477 s1479 :: SBool = if s1387 then s1478 else s1477 s1480 :: SBool = s259 ^ s1479 s1481 :: SBool = if s1419 then s1480 else s1479 s1482 :: SBool = s255 ^ s1481 s1483 :: SBool = if s1451 then s1482 else s1481 s1484 :: SBool = s7 ^ s245 s1485 :: SBool = if s1003 then s1484 else s245 s1486 :: SBool = s493 ^ s1485 s1487 :: SBool = if s1035 then s1486 else s1485 s1488 :: SBool = s463 ^ s1487 s1489 :: SBool = if s1067 then s1488 else s1487 s1490 :: SBool = s435 ^ s1489 s1491 :: SBool = if s1099 then s1490 else s1489 s1492 :: SBool = s409 ^ s1491 s1493 :: SBool = if s1131 then s1492 else s1491 s1494 :: SBool = s385 ^ s1493 s1495 :: SBool = if s1163 then s1494 else s1493 s1496 :: SBool = s363 ^ s1495 s1497 :: SBool = if s1195 then s1496 else s1495 s1498 :: SBool = s343 ^ s1497 s1499 :: SBool = if s1227 then s1498 else s1497 s1500 :: SBool = s325 ^ s1499 s1501 :: SBool = if s1259 then s1500 else s1499 s1502 :: SBool = s309 ^ s1501 s1503 :: SBool = if s1291 then s1502 else s1501 s1504 :: SBool = s295 ^ s1503 s1505 :: SBool = if s1323 then s1504 else s1503 s1506 :: SBool = s283 ^ s1505 s1507 :: SBool = if s1355 then s1506 else s1505 s1508 :: SBool = s273 ^ s1507 s1509 :: SBool = if s1387 then s1508 else s1507 s1510 :: SBool = s265 ^ s1509 s1511 :: SBool = if s1419 then s1510 else s1509 s1512 :: SBool = s259 ^ s1511 s1513 :: SBool = if s1451 then s1512 else s1511 s1514 :: SBool = s255 ^ s1513 s1515 :: SBool = if s1483 then s1514 else s1513 s1516 :: SBool = s7 ^ s250 s1517 :: SBool = if s1035 then s1516 else s250 s1518 :: SBool = s493 ^ s1517 s1519 :: SBool = if s1067 then s1518 else s1517 s1520 :: SBool = s463 ^ s1519 s1521 :: SBool = if s1099 then s1520 else s1519 s1522 :: SBool = s435 ^ s1521 s1523 :: SBool = if s1131 then s1522 else s1521 s1524 :: SBool = s409 ^ s1523 s1525 :: SBool = if s1163 then s1524 else s1523 s1526 :: SBool = s385 ^ s1525 s1527 :: SBool = if s1195 then s1526 else s1525 s1528 :: SBool = s363 ^ s1527 s1529 :: SBool = if s1227 then s1528 else s1527 s1530 :: SBool = s343 ^ s1529 s1531 :: SBool = if s1259 then s1530 else s1529 s1532 :: SBool = s325 ^ s1531 s1533 :: SBool = if s1291 then s1532 else s1531 s1534 :: SBool = s309 ^ s1533 s1535 :: SBool = if s1323 then s1534 else s1533 s1536 :: SBool = s295 ^ s1535 s1537 :: SBool = if s1355 then s1536 else s1535 s1538 :: SBool = s283 ^ s1537 s1539 :: SBool = if s1387 then s1538 else s1537 s1540 :: SBool = s273 ^ s1539 s1541 :: SBool = if s1419 then s1540 else s1539 s1542 :: SBool = s265 ^ s1541 s1543 :: SBool = if s1451 then s1542 else s1541 s1544 :: SBool = s259 ^ s1543 s1545 :: SBool = if s1483 then s1544 else s1543 s1546 :: SBool = s255 ^ s1545 s1547 :: SBool = if s1515 then s1546 else s1545 s1548 :: SBool = if s1067 then s7 else s_2 s1549 :: SBool = s493 ^ s1548 s1550 :: SBool = if s1099 then s1549 else s1548 s1551 :: SBool = s463 ^ s1550 s1552 :: SBool = if s1131 then s1551 else s1550 s1553 :: SBool = s435 ^ s1552 s1554 :: SBool = if s1163 then s1553 else s1552 s1555 :: SBool = s409 ^ s1554 s1556 :: SBool = if s1195 then s1555 else s1554 s1557 :: SBool = s385 ^ s1556 s1558 :: SBool = if s1227 then s1557 else s1556 s1559 :: SBool = s363 ^ s1558 s1560 :: SBool = if s1259 then s1559 else s1558 s1561 :: SBool = s343 ^ s1560 s1562 :: SBool = if s1291 then s1561 else s1560 s1563 :: SBool = s325 ^ s1562 s1564 :: SBool = if s1323 then s1563 else s1562 s1565 :: SBool = s309 ^ s1564 s1566 :: SBool = if s1355 then s1565 else s1564 s1567 :: SBool = s295 ^ s1566 s1568 :: SBool = if s1387 then s1567 else s1566 s1569 :: SBool = s283 ^ s1568 s1570 :: SBool = if s1419 then s1569 else s1568 s1571 :: SBool = s273 ^ s1570 s1572 :: SBool = if s1451 then s1571 else s1570 s1573 :: SBool = s265 ^ s1572 s1574 :: SBool = if s1483 then s1573 else s1572 s1575 :: SBool = s259 ^ s1574 s1576 :: SBool = if s1515 then s1575 else s1574 s1577 :: SBool = s255 ^ s1576 s1578 :: SBool = if s1547 then s1577 else s1576 s1579 :: SBool = s22 ^ s255 s1580 :: SBool = if s16 then s1579 else s22 s1581 :: SBool = s27 ^ s259 s1582 :: SBool = if s16 then s1581 else s27 s1583 :: SBool = s255 ^ s1582 s1584 :: SBool = if s1580 then s1583 else s1582 s1585 :: SBool = s32 ^ s265 s1586 :: SBool = if s16 then s1585 else s32 s1587 :: SBool = s259 ^ s1586 s1588 :: SBool = if s1580 then s1587 else s1586 s1589 :: SBool = s255 ^ s1588 s1590 :: SBool = if s1584 then s1589 else s1588 s1591 :: SBool = s37 ^ s273 s1592 :: SBool = if s16 then s1591 else s37 s1593 :: SBool = s265 ^ s1592 s1594 :: SBool = if s1580 then s1593 else s1592 s1595 :: SBool = s259 ^ s1594 s1596 :: SBool = if s1584 then s1595 else s1594 s1597 :: SBool = s255 ^ s1596 s1598 :: SBool = if s1590 then s1597 else s1596 s1599 :: SBool = s42 ^ s283 s1600 :: SBool = if s16 then s1599 else s42 s1601 :: SBool = s273 ^ s1600 s1602 :: SBool = if s1580 then s1601 else s1600 s1603 :: SBool = s265 ^ s1602 s1604 :: SBool = if s1584 then s1603 else s1602 s1605 :: SBool = s259 ^ s1604 s1606 :: SBool = if s1590 then s1605 else s1604 s1607 :: SBool = s255 ^ s1606 s1608 :: SBool = if s1598 then s1607 else s1606 s1609 :: SBool = s47 ^ s295 s1610 :: SBool = if s16 then s1609 else s47 s1611 :: SBool = s283 ^ s1610 s1612 :: SBool = if s1580 then s1611 else s1610 s1613 :: SBool = s273 ^ s1612 s1614 :: SBool = if s1584 then s1613 else s1612 s1615 :: SBool = s265 ^ s1614 s1616 :: SBool = if s1590 then s1615 else s1614 s1617 :: SBool = s259 ^ s1616 s1618 :: SBool = if s1598 then s1617 else s1616 s1619 :: SBool = s255 ^ s1618 s1620 :: SBool = if s1608 then s1619 else s1618 s1621 :: SBool = s52 ^ s309 s1622 :: SBool = if s16 then s1621 else s52 s1623 :: SBool = s295 ^ s1622 s1624 :: SBool = if s1580 then s1623 else s1622 s1625 :: SBool = s283 ^ s1624 s1626 :: SBool = if s1584 then s1625 else s1624 s1627 :: SBool = s273 ^ s1626 s1628 :: SBool = if s1590 then s1627 else s1626 s1629 :: SBool = s265 ^ s1628 s1630 :: SBool = if s1598 then s1629 else s1628 s1631 :: SBool = s259 ^ s1630 s1632 :: SBool = if s1608 then s1631 else s1630 s1633 :: SBool = s255 ^ s1632 s1634 :: SBool = if s1620 then s1633 else s1632 s1635 :: SBool = s57 ^ s325 s1636 :: SBool = if s16 then s1635 else s57 s1637 :: SBool = s309 ^ s1636 s1638 :: SBool = if s1580 then s1637 else s1636 s1639 :: SBool = s295 ^ s1638 s1640 :: SBool = if s1584 then s1639 else s1638 s1641 :: SBool = s283 ^ s1640 s1642 :: SBool = if s1590 then s1641 else s1640 s1643 :: SBool = s273 ^ s1642 s1644 :: SBool = if s1598 then s1643 else s1642 s1645 :: SBool = s265 ^ s1644 s1646 :: SBool = if s1608 then s1645 else s1644 s1647 :: SBool = s259 ^ s1646 s1648 :: SBool = if s1620 then s1647 else s1646 s1649 :: SBool = s255 ^ s1648 s1650 :: SBool = if s1634 then s1649 else s1648 s1651 :: SBool = s62 ^ s343 s1652 :: SBool = if s16 then s1651 else s62 s1653 :: SBool = s325 ^ s1652 s1654 :: SBool = if s1580 then s1653 else s1652 s1655 :: SBool = s309 ^ s1654 s1656 :: SBool = if s1584 then s1655 else s1654 s1657 :: SBool = s295 ^ s1656 s1658 :: SBool = if s1590 then s1657 else s1656 s1659 :: SBool = s283 ^ s1658 s1660 :: SBool = if s1598 then s1659 else s1658 s1661 :: SBool = s273 ^ s1660 s1662 :: SBool = if s1608 then s1661 else s1660 s1663 :: SBool = s265 ^ s1662 s1664 :: SBool = if s1620 then s1663 else s1662 s1665 :: SBool = s259 ^ s1664 s1666 :: SBool = if s1634 then s1665 else s1664 s1667 :: SBool = s255 ^ s1666 s1668 :: SBool = if s1650 then s1667 else s1666 s1669 :: SBool = s67 ^ s363 s1670 :: SBool = if s16 then s1669 else s67 s1671 :: SBool = s343 ^ s1670 s1672 :: SBool = if s1580 then s1671 else s1670 s1673 :: SBool = s325 ^ s1672 s1674 :: SBool = if s1584 then s1673 else s1672 s1675 :: SBool = s309 ^ s1674 s1676 :: SBool = if s1590 then s1675 else s1674 s1677 :: SBool = s295 ^ s1676 s1678 :: SBool = if s1598 then s1677 else s1676 s1679 :: SBool = s283 ^ s1678 s1680 :: SBool = if s1608 then s1679 else s1678 s1681 :: SBool = s273 ^ s1680 s1682 :: SBool = if s1620 then s1681 else s1680 s1683 :: SBool = s265 ^ s1682 s1684 :: SBool = if s1634 then s1683 else s1682 s1685 :: SBool = s259 ^ s1684 s1686 :: SBool = if s1650 then s1685 else s1684 s1687 :: SBool = s255 ^ s1686 s1688 :: SBool = if s1668 then s1687 else s1686 s1689 :: SBool = s72 ^ s385 s1690 :: SBool = if s16 then s1689 else s72 s1691 :: SBool = s363 ^ s1690 s1692 :: SBool = if s1580 then s1691 else s1690 s1693 :: SBool = s343 ^ s1692 s1694 :: SBool = if s1584 then s1693 else s1692 s1695 :: SBool = s325 ^ s1694 s1696 :: SBool = if s1590 then s1695 else s1694 s1697 :: SBool = s309 ^ s1696 s1698 :: SBool = if s1598 then s1697 else s1696 s1699 :: SBool = s295 ^ s1698 s1700 :: SBool = if s1608 then s1699 else s1698 s1701 :: SBool = s283 ^ s1700 s1702 :: SBool = if s1620 then s1701 else s1700 s1703 :: SBool = s273 ^ s1702 s1704 :: SBool = if s1634 then s1703 else s1702 s1705 :: SBool = s265 ^ s1704 s1706 :: SBool = if s1650 then s1705 else s1704 s1707 :: SBool = s259 ^ s1706 s1708 :: SBool = if s1668 then s1707 else s1706 s1709 :: SBool = s255 ^ s1708 s1710 :: SBool = if s1688 then s1709 else s1708 s1711 :: SBool = s77 ^ s409 s1712 :: SBool = if s16 then s1711 else s77 s1713 :: SBool = s385 ^ s1712 s1714 :: SBool = if s1580 then s1713 else s1712 s1715 :: SBool = s363 ^ s1714 s1716 :: SBool = if s1584 then s1715 else s1714 s1717 :: SBool = s343 ^ s1716 s1718 :: SBool = if s1590 then s1717 else s1716 s1719 :: SBool = s325 ^ s1718 s1720 :: SBool = if s1598 then s1719 else s1718 s1721 :: SBool = s309 ^ s1720 s1722 :: SBool = if s1608 then s1721 else s1720 s1723 :: SBool = s295 ^ s1722 s1724 :: SBool = if s1620 then s1723 else s1722 s1725 :: SBool = s283 ^ s1724 s1726 :: SBool = if s1634 then s1725 else s1724 s1727 :: SBool = s273 ^ s1726 s1728 :: SBool = if s1650 then s1727 else s1726 s1729 :: SBool = s265 ^ s1728 s1730 :: SBool = if s1668 then s1729 else s1728 s1731 :: SBool = s259 ^ s1730 s1732 :: SBool = if s1688 then s1731 else s1730 s1733 :: SBool = s255 ^ s1732 s1734 :: SBool = if s1710 then s1733 else s1732 s1735 :: SBool = s82 ^ s435 s1736 :: SBool = if s16 then s1735 else s82 s1737 :: SBool = s409 ^ s1736 s1738 :: SBool = if s1580 then s1737 else s1736 s1739 :: SBool = s385 ^ s1738 s1740 :: SBool = if s1584 then s1739 else s1738 s1741 :: SBool = s363 ^ s1740 s1742 :: SBool = if s1590 then s1741 else s1740 s1743 :: SBool = s343 ^ s1742 s1744 :: SBool = if s1598 then s1743 else s1742 s1745 :: SBool = s325 ^ s1744 s1746 :: SBool = if s1608 then s1745 else s1744 s1747 :: SBool = s309 ^ s1746 s1748 :: SBool = if s1620 then s1747 else s1746 s1749 :: SBool = s295 ^ s1748 s1750 :: SBool = if s1634 then s1749 else s1748 s1751 :: SBool = s283 ^ s1750 s1752 :: SBool = if s1650 then s1751 else s1750 s1753 :: SBool = s273 ^ s1752 s1754 :: SBool = if s1668 then s1753 else s1752 s1755 :: SBool = s265 ^ s1754 s1756 :: SBool = if s1688 then s1755 else s1754 s1757 :: SBool = s259 ^ s1756 s1758 :: SBool = if s1710 then s1757 else s1756 s1759 :: SBool = s255 ^ s1758 s1760 :: SBool = if s1734 then s1759 else s1758 s1761 :: SBool = s87 ^ s463 s1762 :: SBool = if s16 then s1761 else s87 s1763 :: SBool = s435 ^ s1762 s1764 :: SBool = if s1580 then s1763 else s1762 s1765 :: SBool = s409 ^ s1764 s1766 :: SBool = if s1584 then s1765 else s1764 s1767 :: SBool = s385 ^ s1766 s1768 :: SBool = if s1590 then s1767 else s1766 s1769 :: SBool = s363 ^ s1768 s1770 :: SBool = if s1598 then s1769 else s1768 s1771 :: SBool = s343 ^ s1770 s1772 :: SBool = if s1608 then s1771 else s1770 s1773 :: SBool = s325 ^ s1772 s1774 :: SBool = if s1620 then s1773 else s1772 s1775 :: SBool = s309 ^ s1774 s1776 :: SBool = if s1634 then s1775 else s1774 s1777 :: SBool = s295 ^ s1776 s1778 :: SBool = if s1650 then s1777 else s1776 s1779 :: SBool = s283 ^ s1778 s1780 :: SBool = if s1668 then s1779 else s1778 s1781 :: SBool = s273 ^ s1780 s1782 :: SBool = if s1688 then s1781 else s1780 s1783 :: SBool = s265 ^ s1782 s1784 :: SBool = if s1710 then s1783 else s1782 s1785 :: SBool = s259 ^ s1784 s1786 :: SBool = if s1734 then s1785 else s1784 s1787 :: SBool = s255 ^ s1786 s1788 :: SBool = if s1760 then s1787 else s1786 s1789 :: SBool = s92 ^ s493 s1790 :: SBool = if s16 then s1789 else s92 s1791 :: SBool = s463 ^ s1790 s1792 :: SBool = if s1580 then s1791 else s1790 s1793 :: SBool = s435 ^ s1792 s1794 :: SBool = if s1584 then s1793 else s1792 s1795 :: SBool = s409 ^ s1794 s1796 :: SBool = if s1590 then s1795 else s1794 s1797 :: SBool = s385 ^ s1796 s1798 :: SBool = if s1598 then s1797 else s1796 s1799 :: SBool = s363 ^ s1798 s1800 :: SBool = if s1608 then s1799 else s1798 s1801 :: SBool = s343 ^ s1800 s1802 :: SBool = if s1620 then s1801 else s1800 s1803 :: SBool = s325 ^ s1802 s1804 :: SBool = if s1634 then s1803 else s1802 s1805 :: SBool = s309 ^ s1804 s1806 :: SBool = if s1650 then s1805 else s1804 s1807 :: SBool = s295 ^ s1806 s1808 :: SBool = if s1668 then s1807 else s1806 s1809 :: SBool = s283 ^ s1808 s1810 :: SBool = if s1688 then s1809 else s1808 s1811 :: SBool = s273 ^ s1810 s1812 :: SBool = if s1710 then s1811 else s1810 s1813 :: SBool = s265 ^ s1812 s1814 :: SBool = if s1734 then s1813 else s1812 s1815 :: SBool = s259 ^ s1814 s1816 :: SBool = if s1760 then s1815 else s1814 s1817 :: SBool = s255 ^ s1816 s1818 :: SBool = if s1788 then s1817 else s1816 s1819 :: SBool = s7 ^ s97 s1820 :: SBool = if s16 then s1819 else s97 s1821 :: SBool = s493 ^ s1820 s1822 :: SBool = if s1580 then s1821 else s1820 s1823 :: SBool = s463 ^ s1822 s1824 :: SBool = if s1584 then s1823 else s1822 s1825 :: SBool = s435 ^ s1824 s1826 :: SBool = if s1590 then s1825 else s1824 s1827 :: SBool = s409 ^ s1826 s1828 :: SBool = if s1598 then s1827 else s1826 s1829 :: SBool = s385 ^ s1828 s1830 :: SBool = if s1608 then s1829 else s1828 s1831 :: SBool = s363 ^ s1830 s1832 :: SBool = if s1620 then s1831 else s1830 s1833 :: SBool = s343 ^ s1832 s1834 :: SBool = if s1634 then s1833 else s1832 s1835 :: SBool = s325 ^ s1834 s1836 :: SBool = if s1650 then s1835 else s1834 s1837 :: SBool = s309 ^ s1836 s1838 :: SBool = if s1668 then s1837 else s1836 s1839 :: SBool = s295 ^ s1838 s1840 :: SBool = if s1688 then s1839 else s1838 s1841 :: SBool = s283 ^ s1840 s1842 :: SBool = if s1710 then s1841 else s1840 s1843 :: SBool = s273 ^ s1842 s1844 :: SBool = if s1734 then s1843 else s1842 s1845 :: SBool = s265 ^ s1844 s1846 :: SBool = if s1760 then s1845 else s1844 s1847 :: SBool = s259 ^ s1846 s1848 :: SBool = if s1788 then s1847 else s1846 s1849 :: SBool = s255 ^ s1848 s1850 :: SBool = if s1818 then s1849 else s1848 s1851 :: SBool = s7 ^ s102 s1852 :: SBool = if s1580 then s1851 else s102 s1853 :: SBool = s493 ^ s1852 s1854 :: SBool = if s1584 then s1853 else s1852 s1855 :: SBool = s463 ^ s1854 s1856 :: SBool = if s1590 then s1855 else s1854 s1857 :: SBool = s435 ^ s1856 s1858 :: SBool = if s1598 then s1857 else s1856 s1859 :: SBool = s409 ^ s1858 s1860 :: SBool = if s1608 then s1859 else s1858 s1861 :: SBool = s385 ^ s1860 s1862 :: SBool = if s1620 then s1861 else s1860 s1863 :: SBool = s363 ^ s1862 s1864 :: SBool = if s1634 then s1863 else s1862 s1865 :: SBool = s343 ^ s1864 s1866 :: SBool = if s1650 then s1865 else s1864 s1867 :: SBool = s325 ^ s1866 s1868 :: SBool = if s1668 then s1867 else s1866 s1869 :: SBool = s309 ^ s1868 s1870 :: SBool = if s1688 then s1869 else s1868 s1871 :: SBool = s295 ^ s1870 s1872 :: SBool = if s1710 then s1871 else s1870 s1873 :: SBool = s283 ^ s1872 s1874 :: SBool = if s1734 then s1873 else s1872 s1875 :: SBool = s273 ^ s1874 s1876 :: SBool = if s1760 then s1875 else s1874 s1877 :: SBool = s265 ^ s1876 s1878 :: SBool = if s1788 then s1877 else s1876 s1879 :: SBool = s259 ^ s1878 s1880 :: SBool = if s1818 then s1879 else s1878 s1881 :: SBool = s255 ^ s1880 s1882 :: SBool = if s1850 then s1881 else s1880 s1883 :: SBool = s7 ^ s107 s1884 :: SBool = if s1584 then s1883 else s107 s1885 :: SBool = s493 ^ s1884 s1886 :: SBool = if s1590 then s1885 else s1884 s1887 :: SBool = s463 ^ s1886 s1888 :: SBool = if s1598 then s1887 else s1886 s1889 :: SBool = s435 ^ s1888 s1890 :: SBool = if s1608 then s1889 else s1888 s1891 :: SBool = s409 ^ s1890 s1892 :: SBool = if s1620 then s1891 else s1890 s1893 :: SBool = s385 ^ s1892 s1894 :: SBool = if s1634 then s1893 else s1892 s1895 :: SBool = s363 ^ s1894 s1896 :: SBool = if s1650 then s1895 else s1894 s1897 :: SBool = s343 ^ s1896 s1898 :: SBool = if s1668 then s1897 else s1896 s1899 :: SBool = s325 ^ s1898 s1900 :: SBool = if s1688 then s1899 else s1898 s1901 :: SBool = s309 ^ s1900 s1902 :: SBool = if s1710 then s1901 else s1900 s1903 :: SBool = s295 ^ s1902 s1904 :: SBool = if s1734 then s1903 else s1902 s1905 :: SBool = s283 ^ s1904 s1906 :: SBool = if s1760 then s1905 else s1904 s1907 :: SBool = s273 ^ s1906 s1908 :: SBool = if s1788 then s1907 else s1906 s1909 :: SBool = s265 ^ s1908 s1910 :: SBool = if s1818 then s1909 else s1908 s1911 :: SBool = s259 ^ s1910 s1912 :: SBool = if s1850 then s1911 else s1910 s1913 :: SBool = s255 ^ s1912 s1914 :: SBool = if s1882 then s1913 else s1912 s1915 :: SBool = s7 ^ s112 s1916 :: SBool = if s1590 then s1915 else s112 s1917 :: SBool = s493 ^ s1916 s1918 :: SBool = if s1598 then s1917 else s1916 s1919 :: SBool = s463 ^ s1918 s1920 :: SBool = if s1608 then s1919 else s1918 s1921 :: SBool = s435 ^ s1920 s1922 :: SBool = if s1620 then s1921 else s1920 s1923 :: SBool = s409 ^ s1922 s1924 :: SBool = if s1634 then s1923 else s1922 s1925 :: SBool = s385 ^ s1924 s1926 :: SBool = if s1650 then s1925 else s1924 s1927 :: SBool = s363 ^ s1926 s1928 :: SBool = if s1668 then s1927 else s1926 s1929 :: SBool = s343 ^ s1928 s1930 :: SBool = if s1688 then s1929 else s1928 s1931 :: SBool = s325 ^ s1930 s1932 :: SBool = if s1710 then s1931 else s1930 s1933 :: SBool = s309 ^ s1932 s1934 :: SBool = if s1734 then s1933 else s1932 s1935 :: SBool = s295 ^ s1934 s1936 :: SBool = if s1760 then s1935 else s1934 s1937 :: SBool = s283 ^ s1936 s1938 :: SBool = if s1788 then s1937 else s1936 s1939 :: SBool = s273 ^ s1938 s1940 :: SBool = if s1818 then s1939 else s1938 s1941 :: SBool = s265 ^ s1940 s1942 :: SBool = if s1850 then s1941 else s1940 s1943 :: SBool = s259 ^ s1942 s1944 :: SBool = if s1882 then s1943 else s1942 s1945 :: SBool = s255 ^ s1944 s1946 :: SBool = if s1914 then s1945 else s1944 s1947 :: SBool = s7 ^ s117 s1948 :: SBool = if s1598 then s1947 else s117 s1949 :: SBool = s493 ^ s1948 s1950 :: SBool = if s1608 then s1949 else s1948 s1951 :: SBool = s463 ^ s1950 s1952 :: SBool = if s1620 then s1951 else s1950 s1953 :: SBool = s435 ^ s1952 s1954 :: SBool = if s1634 then s1953 else s1952 s1955 :: SBool = s409 ^ s1954 s1956 :: SBool = if s1650 then s1955 else s1954 s1957 :: SBool = s385 ^ s1956 s1958 :: SBool = if s1668 then s1957 else s1956 s1959 :: SBool = s363 ^ s1958 s1960 :: SBool = if s1688 then s1959 else s1958 s1961 :: SBool = s343 ^ s1960 s1962 :: SBool = if s1710 then s1961 else s1960 s1963 :: SBool = s325 ^ s1962 s1964 :: SBool = if s1734 then s1963 else s1962 s1965 :: SBool = s309 ^ s1964 s1966 :: SBool = if s1760 then s1965 else s1964 s1967 :: SBool = s295 ^ s1966 s1968 :: SBool = if s1788 then s1967 else s1966 s1969 :: SBool = s283 ^ s1968 s1970 :: SBool = if s1818 then s1969 else s1968 s1971 :: SBool = s273 ^ s1970 s1972 :: SBool = if s1850 then s1971 else s1970 s1973 :: SBool = s265 ^ s1972 s1974 :: SBool = if s1882 then s1973 else s1972 s1975 :: SBool = s259 ^ s1974 s1976 :: SBool = if s1914 then s1975 else s1974 s1977 :: SBool = s255 ^ s1976 s1978 :: SBool = if s1946 then s1977 else s1976 s1979 :: SBool = s7 ^ s122 s1980 :: SBool = if s1608 then s1979 else s122 s1981 :: SBool = s493 ^ s1980 s1982 :: SBool = if s1620 then s1981 else s1980 s1983 :: SBool = s463 ^ s1982 s1984 :: SBool = if s1634 then s1983 else s1982 s1985 :: SBool = s435 ^ s1984 s1986 :: SBool = if s1650 then s1985 else s1984 s1987 :: SBool = s409 ^ s1986 s1988 :: SBool = if s1668 then s1987 else s1986 s1989 :: SBool = s385 ^ s1988 s1990 :: SBool = if s1688 then s1989 else s1988 s1991 :: SBool = s363 ^ s1990 s1992 :: SBool = if s1710 then s1991 else s1990 s1993 :: SBool = s343 ^ s1992 s1994 :: SBool = if s1734 then s1993 else s1992 s1995 :: SBool = s325 ^ s1994 s1996 :: SBool = if s1760 then s1995 else s1994 s1997 :: SBool = s309 ^ s1996 s1998 :: SBool = if s1788 then s1997 else s1996 s1999 :: SBool = s295 ^ s1998 s2000 :: SBool = if s1818 then s1999 else s1998 s2001 :: SBool = s283 ^ s2000 s2002 :: SBool = if s1850 then s2001 else s2000 s2003 :: SBool = s273 ^ s2002 s2004 :: SBool = if s1882 then s2003 else s2002 s2005 :: SBool = s265 ^ s2004 s2006 :: SBool = if s1914 then s2005 else s2004 s2007 :: SBool = s259 ^ s2006 s2008 :: SBool = if s1946 then s2007 else s2006 s2009 :: SBool = s255 ^ s2008 s2010 :: SBool = if s1978 then s2009 else s2008 s2011 :: SBool = s7 ^ s127 s2012 :: SBool = if s1620 then s2011 else s127 s2013 :: SBool = s493 ^ s2012 s2014 :: SBool = if s1634 then s2013 else s2012 s2015 :: SBool = s463 ^ s2014 s2016 :: SBool = if s1650 then s2015 else s2014 s2017 :: SBool = s435 ^ s2016 s2018 :: SBool = if s1668 then s2017 else s2016 s2019 :: SBool = s409 ^ s2018 s2020 :: SBool = if s1688 then s2019 else s2018 s2021 :: SBool = s385 ^ s2020 s2022 :: SBool = if s1710 then s2021 else s2020 s2023 :: SBool = s363 ^ s2022 s2024 :: SBool = if s1734 then s2023 else s2022 s2025 :: SBool = s343 ^ s2024 s2026 :: SBool = if s1760 then s2025 else s2024 s2027 :: SBool = s325 ^ s2026 s2028 :: SBool = if s1788 then s2027 else s2026 s2029 :: SBool = s309 ^ s2028 s2030 :: SBool = if s1818 then s2029 else s2028 s2031 :: SBool = s295 ^ s2030 s2032 :: SBool = if s1850 then s2031 else s2030 s2033 :: SBool = s283 ^ s2032 s2034 :: SBool = if s1882 then s2033 else s2032 s2035 :: SBool = s273 ^ s2034 s2036 :: SBool = if s1914 then s2035 else s2034 s2037 :: SBool = s265 ^ s2036 s2038 :: SBool = if s1946 then s2037 else s2036 s2039 :: SBool = s259 ^ s2038 s2040 :: SBool = if s1978 then s2039 else s2038 s2041 :: SBool = s255 ^ s2040 s2042 :: SBool = if s2010 then s2041 else s2040 s2043 :: SBool = s7 ^ s132 s2044 :: SBool = if s1634 then s2043 else s132 s2045 :: SBool = s493 ^ s2044 s2046 :: SBool = if s1650 then s2045 else s2044 s2047 :: SBool = s463 ^ s2046 s2048 :: SBool = if s1668 then s2047 else s2046 s2049 :: SBool = s435 ^ s2048 s2050 :: SBool = if s1688 then s2049 else s2048 s2051 :: SBool = s409 ^ s2050 s2052 :: SBool = if s1710 then s2051 else s2050 s2053 :: SBool = s385 ^ s2052 s2054 :: SBool = if s1734 then s2053 else s2052 s2055 :: SBool = s363 ^ s2054 s2056 :: SBool = if s1760 then s2055 else s2054 s2057 :: SBool = s343 ^ s2056 s2058 :: SBool = if s1788 then s2057 else s2056 s2059 :: SBool = s325 ^ s2058 s2060 :: SBool = if s1818 then s2059 else s2058 s2061 :: SBool = s309 ^ s2060 s2062 :: SBool = if s1850 then s2061 else s2060 s2063 :: SBool = s295 ^ s2062 s2064 :: SBool = if s1882 then s2063 else s2062 s2065 :: SBool = s283 ^ s2064 s2066 :: SBool = if s1914 then s2065 else s2064 s2067 :: SBool = s273 ^ s2066 s2068 :: SBool = if s1946 then s2067 else s2066 s2069 :: SBool = s265 ^ s2068 s2070 :: SBool = if s1978 then s2069 else s2068 s2071 :: SBool = s259 ^ s2070 s2072 :: SBool = if s2010 then s2071 else s2070 s2073 :: SBool = s255 ^ s2072 s2074 :: SBool = if s2042 then s2073 else s2072 s2075 :: SBool = s7 ^ s137 s2076 :: SBool = if s1650 then s2075 else s137 s2077 :: SBool = s493 ^ s2076 s2078 :: SBool = if s1668 then s2077 else s2076 s2079 :: SBool = s463 ^ s2078 s2080 :: SBool = if s1688 then s2079 else s2078 s2081 :: SBool = s435 ^ s2080 s2082 :: SBool = if s1710 then s2081 else s2080 s2083 :: SBool = s409 ^ s2082 s2084 :: SBool = if s1734 then s2083 else s2082 s2085 :: SBool = s385 ^ s2084 s2086 :: SBool = if s1760 then s2085 else s2084 s2087 :: SBool = s363 ^ s2086 s2088 :: SBool = if s1788 then s2087 else s2086 s2089 :: SBool = s343 ^ s2088 s2090 :: SBool = if s1818 then s2089 else s2088 s2091 :: SBool = s325 ^ s2090 s2092 :: SBool = if s1850 then s2091 else s2090 s2093 :: SBool = s309 ^ s2092 s2094 :: SBool = if s1882 then s2093 else s2092 s2095 :: SBool = s295 ^ s2094 s2096 :: SBool = if s1914 then s2095 else s2094 s2097 :: SBool = s283 ^ s2096 s2098 :: SBool = if s1946 then s2097 else s2096 s2099 :: SBool = s273 ^ s2098 s2100 :: SBool = if s1978 then s2099 else s2098 s2101 :: SBool = s265 ^ s2100 s2102 :: SBool = if s2010 then s2101 else s2100 s2103 :: SBool = s259 ^ s2102 s2104 :: SBool = if s2042 then s2103 else s2102 s2105 :: SBool = s255 ^ s2104 s2106 :: SBool = if s2074 then s2105 else s2104 s2107 :: SBool = s7 ^ s142 s2108 :: SBool = if s1668 then s2107 else s142 s2109 :: SBool = s493 ^ s2108 s2110 :: SBool = if s1688 then s2109 else s2108 s2111 :: SBool = s463 ^ s2110 s2112 :: SBool = if s1710 then s2111 else s2110 s2113 :: SBool = s435 ^ s2112 s2114 :: SBool = if s1734 then s2113 else s2112 s2115 :: SBool = s409 ^ s2114 s2116 :: SBool = if s1760 then s2115 else s2114 s2117 :: SBool = s385 ^ s2116 s2118 :: SBool = if s1788 then s2117 else s2116 s2119 :: SBool = s363 ^ s2118 s2120 :: SBool = if s1818 then s2119 else s2118 s2121 :: SBool = s343 ^ s2120 s2122 :: SBool = if s1850 then s2121 else s2120 s2123 :: SBool = s325 ^ s2122 s2124 :: SBool = if s1882 then s2123 else s2122 s2125 :: SBool = s309 ^ s2124 s2126 :: SBool = if s1914 then s2125 else s2124 s2127 :: SBool = s295 ^ s2126 s2128 :: SBool = if s1946 then s2127 else s2126 s2129 :: SBool = s283 ^ s2128 s2130 :: SBool = if s1978 then s2129 else s2128 s2131 :: SBool = s273 ^ s2130 s2132 :: SBool = if s2010 then s2131 else s2130 s2133 :: SBool = s265 ^ s2132 s2134 :: SBool = if s2042 then s2133 else s2132 s2135 :: SBool = s259 ^ s2134 s2136 :: SBool = if s2074 then s2135 else s2134 s2137 :: SBool = s255 ^ s2136 s2138 :: SBool = if s2106 then s2137 else s2136 s2139 :: SBool = s7 ^ s147 s2140 :: SBool = if s1688 then s2139 else s147 s2141 :: SBool = s493 ^ s2140 s2142 :: SBool = if s1710 then s2141 else s2140 s2143 :: SBool = s463 ^ s2142 s2144 :: SBool = if s1734 then s2143 else s2142 s2145 :: SBool = s435 ^ s2144 s2146 :: SBool = if s1760 then s2145 else s2144 s2147 :: SBool = s409 ^ s2146 s2148 :: SBool = if s1788 then s2147 else s2146 s2149 :: SBool = s385 ^ s2148 s2150 :: SBool = if s1818 then s2149 else s2148 s2151 :: SBool = s363 ^ s2150 s2152 :: SBool = if s1850 then s2151 else s2150 s2153 :: SBool = s343 ^ s2152 s2154 :: SBool = if s1882 then s2153 else s2152 s2155 :: SBool = s325 ^ s2154 s2156 :: SBool = if s1914 then s2155 else s2154 s2157 :: SBool = s309 ^ s2156 s2158 :: SBool = if s1946 then s2157 else s2156 s2159 :: SBool = s295 ^ s2158 s2160 :: SBool = if s1978 then s2159 else s2158 s2161 :: SBool = s283 ^ s2160 s2162 :: SBool = if s2010 then s2161 else s2160 s2163 :: SBool = s273 ^ s2162 s2164 :: SBool = if s2042 then s2163 else s2162 s2165 :: SBool = s265 ^ s2164 s2166 :: SBool = if s2074 then s2165 else s2164 s2167 :: SBool = s259 ^ s2166 s2168 :: SBool = if s2106 then s2167 else s2166 s2169 :: SBool = s255 ^ s2168 s2170 :: SBool = if s2138 then s2169 else s2168 s2171 :: SBool = s7 ^ s152 s2172 :: SBool = if s1710 then s2171 else s152 s2173 :: SBool = s493 ^ s2172 s2174 :: SBool = if s1734 then s2173 else s2172 s2175 :: SBool = s463 ^ s2174 s2176 :: SBool = if s1760 then s2175 else s2174 s2177 :: SBool = s435 ^ s2176 s2178 :: SBool = if s1788 then s2177 else s2176 s2179 :: SBool = s409 ^ s2178 s2180 :: SBool = if s1818 then s2179 else s2178 s2181 :: SBool = s385 ^ s2180 s2182 :: SBool = if s1850 then s2181 else s2180 s2183 :: SBool = s363 ^ s2182 s2184 :: SBool = if s1882 then s2183 else s2182 s2185 :: SBool = s343 ^ s2184 s2186 :: SBool = if s1914 then s2185 else s2184 s2187 :: SBool = s325 ^ s2186 s2188 :: SBool = if s1946 then s2187 else s2186 s2189 :: SBool = s309 ^ s2188 s2190 :: SBool = if s1978 then s2189 else s2188 s2191 :: SBool = s295 ^ s2190 s2192 :: SBool = if s2010 then s2191 else s2190 s2193 :: SBool = s283 ^ s2192 s2194 :: SBool = if s2042 then s2193 else s2192 s2195 :: SBool = s273 ^ s2194 s2196 :: SBool = if s2074 then s2195 else s2194 s2197 :: SBool = s265 ^ s2196 s2198 :: SBool = if s2106 then s2197 else s2196 s2199 :: SBool = s259 ^ s2198 s2200 :: SBool = if s2138 then s2199 else s2198 s2201 :: SBool = s255 ^ s2200 s2202 :: SBool = if s2170 then s2201 else s2200 s2203 :: SBool = s7 ^ s157 s2204 :: SBool = if s1734 then s2203 else s157 s2205 :: SBool = s493 ^ s2204 s2206 :: SBool = if s1760 then s2205 else s2204 s2207 :: SBool = s463 ^ s2206 s2208 :: SBool = if s1788 then s2207 else s2206 s2209 :: SBool = s435 ^ s2208 s2210 :: SBool = if s1818 then s2209 else s2208 s2211 :: SBool = s409 ^ s2210 s2212 :: SBool = if s1850 then s2211 else s2210 s2213 :: SBool = s385 ^ s2212 s2214 :: SBool = if s1882 then s2213 else s2212 s2215 :: SBool = s363 ^ s2214 s2216 :: SBool = if s1914 then s2215 else s2214 s2217 :: SBool = s343 ^ s2216 s2218 :: SBool = if s1946 then s2217 else s2216 s2219 :: SBool = s325 ^ s2218 s2220 :: SBool = if s1978 then s2219 else s2218 s2221 :: SBool = s309 ^ s2220 s2222 :: SBool = if s2010 then s2221 else s2220 s2223 :: SBool = s295 ^ s2222 s2224 :: SBool = if s2042 then s2223 else s2222 s2225 :: SBool = s283 ^ s2224 s2226 :: SBool = if s2074 then s2225 else s2224 s2227 :: SBool = s273 ^ s2226 s2228 :: SBool = if s2106 then s2227 else s2226 s2229 :: SBool = s265 ^ s2228 s2230 :: SBool = if s2138 then s2229 else s2228 s2231 :: SBool = s259 ^ s2230 s2232 :: SBool = if s2170 then s2231 else s2230 s2233 :: SBool = s255 ^ s2232 s2234 :: SBool = if s2202 then s2233 else s2232 s2235 :: SBool = s7 ^ s162 s2236 :: SBool = if s1760 then s2235 else s162 s2237 :: SBool = s493 ^ s2236 s2238 :: SBool = if s1788 then s2237 else s2236 s2239 :: SBool = s463 ^ s2238 s2240 :: SBool = if s1818 then s2239 else s2238 s2241 :: SBool = s435 ^ s2240 s2242 :: SBool = if s1850 then s2241 else s2240 s2243 :: SBool = s409 ^ s2242 s2244 :: SBool = if s1882 then s2243 else s2242 s2245 :: SBool = s385 ^ s2244 s2246 :: SBool = if s1914 then s2245 else s2244 s2247 :: SBool = s363 ^ s2246 s2248 :: SBool = if s1946 then s2247 else s2246 s2249 :: SBool = s343 ^ s2248 s2250 :: SBool = if s1978 then s2249 else s2248 s2251 :: SBool = s325 ^ s2250 s2252 :: SBool = if s2010 then s2251 else s2250 s2253 :: SBool = s309 ^ s2252 s2254 :: SBool = if s2042 then s2253 else s2252 s2255 :: SBool = s295 ^ s2254 s2256 :: SBool = if s2074 then s2255 else s2254 s2257 :: SBool = s283 ^ s2256 s2258 :: SBool = if s2106 then s2257 else s2256 s2259 :: SBool = s273 ^ s2258 s2260 :: SBool = if s2138 then s2259 else s2258 s2261 :: SBool = s265 ^ s2260 s2262 :: SBool = if s2170 then s2261 else s2260 s2263 :: SBool = s259 ^ s2262 s2264 :: SBool = if s2202 then s2263 else s2262 s2265 :: SBool = s255 ^ s2264 s2266 :: SBool = if s2234 then s2265 else s2264 s2267 :: SBool = s7 ^ s167 s2268 :: SBool = if s1788 then s2267 else s167 s2269 :: SBool = s493 ^ s2268 s2270 :: SBool = if s1818 then s2269 else s2268 s2271 :: SBool = s463 ^ s2270 s2272 :: SBool = if s1850 then s2271 else s2270 s2273 :: SBool = s435 ^ s2272 s2274 :: SBool = if s1882 then s2273 else s2272 s2275 :: SBool = s409 ^ s2274 s2276 :: SBool = if s1914 then s2275 else s2274 s2277 :: SBool = s385 ^ s2276 s2278 :: SBool = if s1946 then s2277 else s2276 s2279 :: SBool = s363 ^ s2278 s2280 :: SBool = if s1978 then s2279 else s2278 s2281 :: SBool = s343 ^ s2280 s2282 :: SBool = if s2010 then s2281 else s2280 s2283 :: SBool = s325 ^ s2282 s2284 :: SBool = if s2042 then s2283 else s2282 s2285 :: SBool = s309 ^ s2284 s2286 :: SBool = if s2074 then s2285 else s2284 s2287 :: SBool = s295 ^ s2286 s2288 :: SBool = if s2106 then s2287 else s2286 s2289 :: SBool = s283 ^ s2288 s2290 :: SBool = if s2138 then s2289 else s2288 s2291 :: SBool = s273 ^ s2290 s2292 :: SBool = if s2170 then s2291 else s2290 s2293 :: SBool = s265 ^ s2292 s2294 :: SBool = if s2202 then s2293 else s2292 s2295 :: SBool = s259 ^ s2294 s2296 :: SBool = if s2234 then s2295 else s2294 s2297 :: SBool = s255 ^ s2296 s2298 :: SBool = if s2266 then s2297 else s2296 s2299 :: SBool = s7 ^ s172 s2300 :: SBool = if s1818 then s2299 else s172 s2301 :: SBool = s493 ^ s2300 s2302 :: SBool = if s1850 then s2301 else s2300 s2303 :: SBool = s463 ^ s2302 s2304 :: SBool = if s1882 then s2303 else s2302 s2305 :: SBool = s435 ^ s2304 s2306 :: SBool = if s1914 then s2305 else s2304 s2307 :: SBool = s409 ^ s2306 s2308 :: SBool = if s1946 then s2307 else s2306 s2309 :: SBool = s385 ^ s2308 s2310 :: SBool = if s1978 then s2309 else s2308 s2311 :: SBool = s363 ^ s2310 s2312 :: SBool = if s2010 then s2311 else s2310 s2313 :: SBool = s343 ^ s2312 s2314 :: SBool = if s2042 then s2313 else s2312 s2315 :: SBool = s325 ^ s2314 s2316 :: SBool = if s2074 then s2315 else s2314 s2317 :: SBool = s309 ^ s2316 s2318 :: SBool = if s2106 then s2317 else s2316 s2319 :: SBool = s295 ^ s2318 s2320 :: SBool = if s2138 then s2319 else s2318 s2321 :: SBool = s283 ^ s2320 s2322 :: SBool = if s2170 then s2321 else s2320 s2323 :: SBool = s273 ^ s2322 s2324 :: SBool = if s2202 then s2323 else s2322 s2325 :: SBool = s265 ^ s2324 s2326 :: SBool = if s2234 then s2325 else s2324 s2327 :: SBool = s259 ^ s2326 s2328 :: SBool = if s2266 then s2327 else s2326 s2329 :: SBool = s255 ^ s2328 s2330 :: SBool = if s2298 then s2329 else s2328 s2331 :: SBool = s7 ^ s177 s2332 :: SBool = if s1850 then s2331 else s177 s2333 :: SBool = s493 ^ s2332 s2334 :: SBool = if s1882 then s2333 else s2332 s2335 :: SBool = s463 ^ s2334 s2336 :: SBool = if s1914 then s2335 else s2334 s2337 :: SBool = s435 ^ s2336 s2338 :: SBool = if s1946 then s2337 else s2336 s2339 :: SBool = s409 ^ s2338 s2340 :: SBool = if s1978 then s2339 else s2338 s2341 :: SBool = s385 ^ s2340 s2342 :: SBool = if s2010 then s2341 else s2340 s2343 :: SBool = s363 ^ s2342 s2344 :: SBool = if s2042 then s2343 else s2342 s2345 :: SBool = s343 ^ s2344 s2346 :: SBool = if s2074 then s2345 else s2344 s2347 :: SBool = s325 ^ s2346 s2348 :: SBool = if s2106 then s2347 else s2346 s2349 :: SBool = s309 ^ s2348 s2350 :: SBool = if s2138 then s2349 else s2348 s2351 :: SBool = s295 ^ s2350 s2352 :: SBool = if s2170 then s2351 else s2350 s2353 :: SBool = s283 ^ s2352 s2354 :: SBool = if s2202 then s2353 else s2352 s2355 :: SBool = s273 ^ s2354 s2356 :: SBool = if s2234 then s2355 else s2354 s2357 :: SBool = s265 ^ s2356 s2358 :: SBool = if s2266 then s2357 else s2356 s2359 :: SBool = s259 ^ s2358 s2360 :: SBool = if s2298 then s2359 else s2358 s2361 :: SBool = s255 ^ s2360 s2362 :: SBool = if s2330 then s2361 else s2360 s2363 :: SBool = s7 ^ s182 s2364 :: SBool = if s1882 then s2363 else s182 s2365 :: SBool = s493 ^ s2364 s2366 :: SBool = if s1914 then s2365 else s2364 s2367 :: SBool = s463 ^ s2366 s2368 :: SBool = if s1946 then s2367 else s2366 s2369 :: SBool = s435 ^ s2368 s2370 :: SBool = if s1978 then s2369 else s2368 s2371 :: SBool = s409 ^ s2370 s2372 :: SBool = if s2010 then s2371 else s2370 s2373 :: SBool = s385 ^ s2372 s2374 :: SBool = if s2042 then s2373 else s2372 s2375 :: SBool = s363 ^ s2374 s2376 :: SBool = if s2074 then s2375 else s2374 s2377 :: SBool = s343 ^ s2376 s2378 :: SBool = if s2106 then s2377 else s2376 s2379 :: SBool = s325 ^ s2378 s2380 :: SBool = if s2138 then s2379 else s2378 s2381 :: SBool = s309 ^ s2380 s2382 :: SBool = if s2170 then s2381 else s2380 s2383 :: SBool = s295 ^ s2382 s2384 :: SBool = if s2202 then s2383 else s2382 s2385 :: SBool = s283 ^ s2384 s2386 :: SBool = if s2234 then s2385 else s2384 s2387 :: SBool = s273 ^ s2386 s2388 :: SBool = if s2266 then s2387 else s2386 s2389 :: SBool = s265 ^ s2388 s2390 :: SBool = if s2298 then s2389 else s2388 s2391 :: SBool = s259 ^ s2390 s2392 :: SBool = if s2330 then s2391 else s2390 s2393 :: SBool = s255 ^ s2392 s2394 :: SBool = if s2362 then s2393 else s2392 s2395 :: SBool = s7 ^ s187 s2396 :: SBool = if s1914 then s2395 else s187 s2397 :: SBool = s493 ^ s2396 s2398 :: SBool = if s1946 then s2397 else s2396 s2399 :: SBool = s463 ^ s2398 s2400 :: SBool = if s1978 then s2399 else s2398 s2401 :: SBool = s435 ^ s2400 s2402 :: SBool = if s2010 then s2401 else s2400 s2403 :: SBool = s409 ^ s2402 s2404 :: SBool = if s2042 then s2403 else s2402 s2405 :: SBool = s385 ^ s2404 s2406 :: SBool = if s2074 then s2405 else s2404 s2407 :: SBool = s363 ^ s2406 s2408 :: SBool = if s2106 then s2407 else s2406 s2409 :: SBool = s343 ^ s2408 s2410 :: SBool = if s2138 then s2409 else s2408 s2411 :: SBool = s325 ^ s2410 s2412 :: SBool = if s2170 then s2411 else s2410 s2413 :: SBool = s309 ^ s2412 s2414 :: SBool = if s2202 then s2413 else s2412 s2415 :: SBool = s295 ^ s2414 s2416 :: SBool = if s2234 then s2415 else s2414 s2417 :: SBool = s283 ^ s2416 s2418 :: SBool = if s2266 then s2417 else s2416 s2419 :: SBool = s273 ^ s2418 s2420 :: SBool = if s2298 then s2419 else s2418 s2421 :: SBool = s265 ^ s2420 s2422 :: SBool = if s2330 then s2421 else s2420 s2423 :: SBool = s259 ^ s2422 s2424 :: SBool = if s2362 then s2423 else s2422 s2425 :: SBool = s255 ^ s2424 s2426 :: SBool = if s2394 then s2425 else s2424 s2427 :: SBool = s7 ^ s192 s2428 :: SBool = if s1946 then s2427 else s192 s2429 :: SBool = s493 ^ s2428 s2430 :: SBool = if s1978 then s2429 else s2428 s2431 :: SBool = s463 ^ s2430 s2432 :: SBool = if s2010 then s2431 else s2430 s2433 :: SBool = s435 ^ s2432 s2434 :: SBool = if s2042 then s2433 else s2432 s2435 :: SBool = s409 ^ s2434 s2436 :: SBool = if s2074 then s2435 else s2434 s2437 :: SBool = s385 ^ s2436 s2438 :: SBool = if s2106 then s2437 else s2436 s2439 :: SBool = s363 ^ s2438 s2440 :: SBool = if s2138 then s2439 else s2438 s2441 :: SBool = s343 ^ s2440 s2442 :: SBool = if s2170 then s2441 else s2440 s2443 :: SBool = s325 ^ s2442 s2444 :: SBool = if s2202 then s2443 else s2442 s2445 :: SBool = s309 ^ s2444 s2446 :: SBool = if s2234 then s2445 else s2444 s2447 :: SBool = s295 ^ s2446 s2448 :: SBool = if s2266 then s2447 else s2446 s2449 :: SBool = s283 ^ s2448 s2450 :: SBool = if s2298 then s2449 else s2448 s2451 :: SBool = s273 ^ s2450 s2452 :: SBool = if s2330 then s2451 else s2450 s2453 :: SBool = s265 ^ s2452 s2454 :: SBool = if s2362 then s2453 else s2452 s2455 :: SBool = s259 ^ s2454 s2456 :: SBool = if s2394 then s2455 else s2454 s2457 :: SBool = s255 ^ s2456 s2458 :: SBool = if s2426 then s2457 else s2456 s2459 :: SBool = s7 ^ s197 s2460 :: SBool = if s1978 then s2459 else s197 s2461 :: SBool = s493 ^ s2460 s2462 :: SBool = if s2010 then s2461 else s2460 s2463 :: SBool = s463 ^ s2462 s2464 :: SBool = if s2042 then s2463 else s2462 s2465 :: SBool = s435 ^ s2464 s2466 :: SBool = if s2074 then s2465 else s2464 s2467 :: SBool = s409 ^ s2466 s2468 :: SBool = if s2106 then s2467 else s2466 s2469 :: SBool = s385 ^ s2468 s2470 :: SBool = if s2138 then s2469 else s2468 s2471 :: SBool = s363 ^ s2470 s2472 :: SBool = if s2170 then s2471 else s2470 s2473 :: SBool = s343 ^ s2472 s2474 :: SBool = if s2202 then s2473 else s2472 s2475 :: SBool = s325 ^ s2474 s2476 :: SBool = if s2234 then s2475 else s2474 s2477 :: SBool = s309 ^ s2476 s2478 :: SBool = if s2266 then s2477 else s2476 s2479 :: SBool = s295 ^ s2478 s2480 :: SBool = if s2298 then s2479 else s2478 s2481 :: SBool = s283 ^ s2480 s2482 :: SBool = if s2330 then s2481 else s2480 s2483 :: SBool = s273 ^ s2482 s2484 :: SBool = if s2362 then s2483 else s2482 s2485 :: SBool = s265 ^ s2484 s2486 :: SBool = if s2394 then s2485 else s2484 s2487 :: SBool = s259 ^ s2486 s2488 :: SBool = if s2426 then s2487 else s2486 s2489 :: SBool = s255 ^ s2488 s2490 :: SBool = if s2458 then s2489 else s2488 s2491 :: SBool = s7 ^ s202 s2492 :: SBool = if s2010 then s2491 else s202 s2493 :: SBool = s493 ^ s2492 s2494 :: SBool = if s2042 then s2493 else s2492 s2495 :: SBool = s463 ^ s2494 s2496 :: SBool = if s2074 then s2495 else s2494 s2497 :: SBool = s435 ^ s2496 s2498 :: SBool = if s2106 then s2497 else s2496 s2499 :: SBool = s409 ^ s2498 s2500 :: SBool = if s2138 then s2499 else s2498 s2501 :: SBool = s385 ^ s2500 s2502 :: SBool = if s2170 then s2501 else s2500 s2503 :: SBool = s363 ^ s2502 s2504 :: SBool = if s2202 then s2503 else s2502 s2505 :: SBool = s343 ^ s2504 s2506 :: SBool = if s2234 then s2505 else s2504 s2507 :: SBool = s325 ^ s2506 s2508 :: SBool = if s2266 then s2507 else s2506 s2509 :: SBool = s309 ^ s2508 s2510 :: SBool = if s2298 then s2509 else s2508 s2511 :: SBool = s295 ^ s2510 s2512 :: SBool = if s2330 then s2511 else s2510 s2513 :: SBool = s283 ^ s2512 s2514 :: SBool = if s2362 then s2513 else s2512 s2515 :: SBool = s273 ^ s2514 s2516 :: SBool = if s2394 then s2515 else s2514 s2517 :: SBool = s265 ^ s2516 s2518 :: SBool = if s2426 then s2517 else s2516 s2519 :: SBool = s259 ^ s2518 s2520 :: SBool = if s2458 then s2519 else s2518 s2521 :: SBool = s255 ^ s2520 s2522 :: SBool = if s2490 then s2521 else s2520 s2523 :: SBool = s7 ^ s207 s2524 :: SBool = if s2042 then s2523 else s207 s2525 :: SBool = s493 ^ s2524 s2526 :: SBool = if s2074 then s2525 else s2524 s2527 :: SBool = s463 ^ s2526 s2528 :: SBool = if s2106 then s2527 else s2526 s2529 :: SBool = s435 ^ s2528 s2530 :: SBool = if s2138 then s2529 else s2528 s2531 :: SBool = s409 ^ s2530 s2532 :: SBool = if s2170 then s2531 else s2530 s2533 :: SBool = s385 ^ s2532 s2534 :: SBool = if s2202 then s2533 else s2532 s2535 :: SBool = s363 ^ s2534 s2536 :: SBool = if s2234 then s2535 else s2534 s2537 :: SBool = s343 ^ s2536 s2538 :: SBool = if s2266 then s2537 else s2536 s2539 :: SBool = s325 ^ s2538 s2540 :: SBool = if s2298 then s2539 else s2538 s2541 :: SBool = s309 ^ s2540 s2542 :: SBool = if s2330 then s2541 else s2540 s2543 :: SBool = s295 ^ s2542 s2544 :: SBool = if s2362 then s2543 else s2542 s2545 :: SBool = s283 ^ s2544 s2546 :: SBool = if s2394 then s2545 else s2544 s2547 :: SBool = s273 ^ s2546 s2548 :: SBool = if s2426 then s2547 else s2546 s2549 :: SBool = s265 ^ s2548 s2550 :: SBool = if s2458 then s2549 else s2548 s2551 :: SBool = s259 ^ s2550 s2552 :: SBool = if s2490 then s2551 else s2550 s2553 :: SBool = s255 ^ s2552 s2554 :: SBool = if s2522 then s2553 else s2552 s2555 :: SBool = s7 ^ s212 s2556 :: SBool = if s2074 then s2555 else s212 s2557 :: SBool = s493 ^ s2556 s2558 :: SBool = if s2106 then s2557 else s2556 s2559 :: SBool = s463 ^ s2558 s2560 :: SBool = if s2138 then s2559 else s2558 s2561 :: SBool = s435 ^ s2560 s2562 :: SBool = if s2170 then s2561 else s2560 s2563 :: SBool = s409 ^ s2562 s2564 :: SBool = if s2202 then s2563 else s2562 s2565 :: SBool = s385 ^ s2564 s2566 :: SBool = if s2234 then s2565 else s2564 s2567 :: SBool = s363 ^ s2566 s2568 :: SBool = if s2266 then s2567 else s2566 s2569 :: SBool = s343 ^ s2568 s2570 :: SBool = if s2298 then s2569 else s2568 s2571 :: SBool = s325 ^ s2570 s2572 :: SBool = if s2330 then s2571 else s2570 s2573 :: SBool = s309 ^ s2572 s2574 :: SBool = if s2362 then s2573 else s2572 s2575 :: SBool = s295 ^ s2574 s2576 :: SBool = if s2394 then s2575 else s2574 s2577 :: SBool = s283 ^ s2576 s2578 :: SBool = if s2426 then s2577 else s2576 s2579 :: SBool = s273 ^ s2578 s2580 :: SBool = if s2458 then s2579 else s2578 s2581 :: SBool = s265 ^ s2580 s2582 :: SBool = if s2490 then s2581 else s2580 s2583 :: SBool = s259 ^ s2582 s2584 :: SBool = if s2522 then s2583 else s2582 s2585 :: SBool = s255 ^ s2584 s2586 :: SBool = if s2554 then s2585 else s2584 s2587 :: SBool = s7 ^ s217 s2588 :: SBool = if s2106 then s2587 else s217 s2589 :: SBool = s493 ^ s2588 s2590 :: SBool = if s2138 then s2589 else s2588 s2591 :: SBool = s463 ^ s2590 s2592 :: SBool = if s2170 then s2591 else s2590 s2593 :: SBool = s435 ^ s2592 s2594 :: SBool = if s2202 then s2593 else s2592 s2595 :: SBool = s409 ^ s2594 s2596 :: SBool = if s2234 then s2595 else s2594 s2597 :: SBool = s385 ^ s2596 s2598 :: SBool = if s2266 then s2597 else s2596 s2599 :: SBool = s363 ^ s2598 s2600 :: SBool = if s2298 then s2599 else s2598 s2601 :: SBool = s343 ^ s2600 s2602 :: SBool = if s2330 then s2601 else s2600 s2603 :: SBool = s325 ^ s2602 s2604 :: SBool = if s2362 then s2603 else s2602 s2605 :: SBool = s309 ^ s2604 s2606 :: SBool = if s2394 then s2605 else s2604 s2607 :: SBool = s295 ^ s2606 s2608 :: SBool = if s2426 then s2607 else s2606 s2609 :: SBool = s283 ^ s2608 s2610 :: SBool = if s2458 then s2609 else s2608 s2611 :: SBool = s273 ^ s2610 s2612 :: SBool = if s2490 then s2611 else s2610 s2613 :: SBool = s265 ^ s2612 s2614 :: SBool = if s2522 then s2613 else s2612 s2615 :: SBool = s259 ^ s2614 s2616 :: SBool = if s2554 then s2615 else s2614 s2617 :: SBool = s255 ^ s2616 s2618 :: SBool = if s2586 then s2617 else s2616 s2619 :: SBool = s7 ^ s222 s2620 :: SBool = if s2138 then s2619 else s222 s2621 :: SBool = s493 ^ s2620 s2622 :: SBool = if s2170 then s2621 else s2620 s2623 :: SBool = s463 ^ s2622 s2624 :: SBool = if s2202 then s2623 else s2622 s2625 :: SBool = s435 ^ s2624 s2626 :: SBool = if s2234 then s2625 else s2624 s2627 :: SBool = s409 ^ s2626 s2628 :: SBool = if s2266 then s2627 else s2626 s2629 :: SBool = s385 ^ s2628 s2630 :: SBool = if s2298 then s2629 else s2628 s2631 :: SBool = s363 ^ s2630 s2632 :: SBool = if s2330 then s2631 else s2630 s2633 :: SBool = s343 ^ s2632 s2634 :: SBool = if s2362 then s2633 else s2632 s2635 :: SBool = s325 ^ s2634 s2636 :: SBool = if s2394 then s2635 else s2634 s2637 :: SBool = s309 ^ s2636 s2638 :: SBool = if s2426 then s2637 else s2636 s2639 :: SBool = s295 ^ s2638 s2640 :: SBool = if s2458 then s2639 else s2638 s2641 :: SBool = s283 ^ s2640 s2642 :: SBool = if s2490 then s2641 else s2640 s2643 :: SBool = s273 ^ s2642 s2644 :: SBool = if s2522 then s2643 else s2642 s2645 :: SBool = s265 ^ s2644 s2646 :: SBool = if s2554 then s2645 else s2644 s2647 :: SBool = s259 ^ s2646 s2648 :: SBool = if s2586 then s2647 else s2646 s2649 :: SBool = s255 ^ s2648 s2650 :: SBool = if s2618 then s2649 else s2648 s2651 :: SBool = s7 ^ s227 s2652 :: SBool = if s2170 then s2651 else s227 s2653 :: SBool = s493 ^ s2652 s2654 :: SBool = if s2202 then s2653 else s2652 s2655 :: SBool = s463 ^ s2654 s2656 :: SBool = if s2234 then s2655 else s2654 s2657 :: SBool = s435 ^ s2656 s2658 :: SBool = if s2266 then s2657 else s2656 s2659 :: SBool = s409 ^ s2658 s2660 :: SBool = if s2298 then s2659 else s2658 s2661 :: SBool = s385 ^ s2660 s2662 :: SBool = if s2330 then s2661 else s2660 s2663 :: SBool = s363 ^ s2662 s2664 :: SBool = if s2362 then s2663 else s2662 s2665 :: SBool = s343 ^ s2664 s2666 :: SBool = if s2394 then s2665 else s2664 s2667 :: SBool = s325 ^ s2666 s2668 :: SBool = if s2426 then s2667 else s2666 s2669 :: SBool = s309 ^ s2668 s2670 :: SBool = if s2458 then s2669 else s2668 s2671 :: SBool = s295 ^ s2670 s2672 :: SBool = if s2490 then s2671 else s2670 s2673 :: SBool = s283 ^ s2672 s2674 :: SBool = if s2522 then s2673 else s2672 s2675 :: SBool = s273 ^ s2674 s2676 :: SBool = if s2554 then s2675 else s2674 s2677 :: SBool = s265 ^ s2676 s2678 :: SBool = if s2586 then s2677 else s2676 s2679 :: SBool = s259 ^ s2678 s2680 :: SBool = if s2618 then s2679 else s2678 s2681 :: SBool = s255 ^ s2680 s2682 :: SBool = if s2650 then s2681 else s2680 s2683 :: SBool = s7 ^ s232 s2684 :: SBool = if s2202 then s2683 else s232 s2685 :: SBool = s493 ^ s2684 s2686 :: SBool = if s2234 then s2685 else s2684 s2687 :: SBool = s463 ^ s2686 s2688 :: SBool = if s2266 then s2687 else s2686 s2689 :: SBool = s435 ^ s2688 s2690 :: SBool = if s2298 then s2689 else s2688 s2691 :: SBool = s409 ^ s2690 s2692 :: SBool = if s2330 then s2691 else s2690 s2693 :: SBool = s385 ^ s2692 s2694 :: SBool = if s2362 then s2693 else s2692 s2695 :: SBool = s363 ^ s2694 s2696 :: SBool = if s2394 then s2695 else s2694 s2697 :: SBool = s343 ^ s2696 s2698 :: SBool = if s2426 then s2697 else s2696 s2699 :: SBool = s325 ^ s2698 s2700 :: SBool = if s2458 then s2699 else s2698 s2701 :: SBool = s309 ^ s2700 s2702 :: SBool = if s2490 then s2701 else s2700 s2703 :: SBool = s295 ^ s2702 s2704 :: SBool = if s2522 then s2703 else s2702 s2705 :: SBool = s283 ^ s2704 s2706 :: SBool = if s2554 then s2705 else s2704 s2707 :: SBool = s273 ^ s2706 s2708 :: SBool = if s2586 then s2707 else s2706 s2709 :: SBool = s265 ^ s2708 s2710 :: SBool = if s2618 then s2709 else s2708 s2711 :: SBool = s259 ^ s2710 s2712 :: SBool = if s2650 then s2711 else s2710 s2713 :: SBool = s255 ^ s2712 s2714 :: SBool = if s2682 then s2713 else s2712 s2715 :: SBool = s7 ^ s237 s2716 :: SBool = if s2234 then s2715 else s237 s2717 :: SBool = s493 ^ s2716 s2718 :: SBool = if s2266 then s2717 else s2716 s2719 :: SBool = s463 ^ s2718 s2720 :: SBool = if s2298 then s2719 else s2718 s2721 :: SBool = s435 ^ s2720 s2722 :: SBool = if s2330 then s2721 else s2720 s2723 :: SBool = s409 ^ s2722 s2724 :: SBool = if s2362 then s2723 else s2722 s2725 :: SBool = s385 ^ s2724 s2726 :: SBool = if s2394 then s2725 else s2724 s2727 :: SBool = s363 ^ s2726 s2728 :: SBool = if s2426 then s2727 else s2726 s2729 :: SBool = s343 ^ s2728 s2730 :: SBool = if s2458 then s2729 else s2728 s2731 :: SBool = s325 ^ s2730 s2732 :: SBool = if s2490 then s2731 else s2730 s2733 :: SBool = s309 ^ s2732 s2734 :: SBool = if s2522 then s2733 else s2732 s2735 :: SBool = s295 ^ s2734 s2736 :: SBool = if s2554 then s2735 else s2734 s2737 :: SBool = s283 ^ s2736 s2738 :: SBool = if s2586 then s2737 else s2736 s2739 :: SBool = s273 ^ s2738 s2740 :: SBool = if s2618 then s2739 else s2738 s2741 :: SBool = s265 ^ s2740 s2742 :: SBool = if s2650 then s2741 else s2740 s2743 :: SBool = s259 ^ s2742 s2744 :: SBool = if s2682 then s2743 else s2742 s2745 :: SBool = s255 ^ s2744 s2746 :: SBool = if s2714 then s2745 else s2744 s2747 :: SBool = s7 ^ s242 s2748 :: SBool = if s2266 then s2747 else s242 s2749 :: SBool = s493 ^ s2748 s2750 :: SBool = if s2298 then s2749 else s2748 s2751 :: SBool = s463 ^ s2750 s2752 :: SBool = if s2330 then s2751 else s2750 s2753 :: SBool = s435 ^ s2752 s2754 :: SBool = if s2362 then s2753 else s2752 s2755 :: SBool = s409 ^ s2754 s2756 :: SBool = if s2394 then s2755 else s2754 s2757 :: SBool = s385 ^ s2756 s2758 :: SBool = if s2426 then s2757 else s2756 s2759 :: SBool = s363 ^ s2758 s2760 :: SBool = if s2458 then s2759 else s2758 s2761 :: SBool = s343 ^ s2760 s2762 :: SBool = if s2490 then s2761 else s2760 s2763 :: SBool = s325 ^ s2762 s2764 :: SBool = if s2522 then s2763 else s2762 s2765 :: SBool = s309 ^ s2764 s2766 :: SBool = if s2554 then s2765 else s2764 s2767 :: SBool = s295 ^ s2766 s2768 :: SBool = if s2586 then s2767 else s2766 s2769 :: SBool = s283 ^ s2768 s2770 :: SBool = if s2618 then s2769 else s2768 s2771 :: SBool = s273 ^ s2770 s2772 :: SBool = if s2650 then s2771 else s2770 s2773 :: SBool = s265 ^ s2772 s2774 :: SBool = if s2682 then s2773 else s2772 s2775 :: SBool = s259 ^ s2774 s2776 :: SBool = if s2714 then s2775 else s2774 s2777 :: SBool = s255 ^ s2776 s2778 :: SBool = if s2746 then s2777 else s2776 s2779 :: SBool = s7 ^ s247 s2780 :: SBool = if s2298 then s2779 else s247 s2781 :: SBool = s493 ^ s2780 s2782 :: SBool = if s2330 then s2781 else s2780 s2783 :: SBool = s463 ^ s2782 s2784 :: SBool = if s2362 then s2783 else s2782 s2785 :: SBool = s435 ^ s2784 s2786 :: SBool = if s2394 then s2785 else s2784 s2787 :: SBool = s409 ^ s2786 s2788 :: SBool = if s2426 then s2787 else s2786 s2789 :: SBool = s385 ^ s2788 s2790 :: SBool = if s2458 then s2789 else s2788 s2791 :: SBool = s363 ^ s2790 s2792 :: SBool = if s2490 then s2791 else s2790 s2793 :: SBool = s343 ^ s2792 s2794 :: SBool = if s2522 then s2793 else s2792 s2795 :: SBool = s325 ^ s2794 s2796 :: SBool = if s2554 then s2795 else s2794 s2797 :: SBool = s309 ^ s2796 s2798 :: SBool = if s2586 then s2797 else s2796 s2799 :: SBool = s295 ^ s2798 s2800 :: SBool = if s2618 then s2799 else s2798 s2801 :: SBool = s283 ^ s2800 s2802 :: SBool = if s2650 then s2801 else s2800 s2803 :: SBool = s273 ^ s2802 s2804 :: SBool = if s2682 then s2803 else s2802 s2805 :: SBool = s265 ^ s2804 s2806 :: SBool = if s2714 then s2805 else s2804 s2807 :: SBool = s259 ^ s2806 s2808 :: SBool = if s2746 then s2807 else s2806 s2809 :: SBool = s255 ^ s2808 s2810 :: SBool = if s2778 then s2809 else s2808 s2811 :: SBool = s7 ^ s252 s2812 :: SBool = if s2330 then s2811 else s252 s2813 :: SBool = s493 ^ s2812 s2814 :: SBool = if s2362 then s2813 else s2812 s2815 :: SBool = s463 ^ s2814 s2816 :: SBool = if s2394 then s2815 else s2814 s2817 :: SBool = s435 ^ s2816 s2818 :: SBool = if s2426 then s2817 else s2816 s2819 :: SBool = s409 ^ s2818 s2820 :: SBool = if s2458 then s2819 else s2818 s2821 :: SBool = s385 ^ s2820 s2822 :: SBool = if s2490 then s2821 else s2820 s2823 :: SBool = s363 ^ s2822 s2824 :: SBool = if s2522 then s2823 else s2822 s2825 :: SBool = s343 ^ s2824 s2826 :: SBool = if s2554 then s2825 else s2824 s2827 :: SBool = s325 ^ s2826 s2828 :: SBool = if s2586 then s2827 else s2826 s2829 :: SBool = s309 ^ s2828 s2830 :: SBool = if s2618 then s2829 else s2828 s2831 :: SBool = s295 ^ s2830 s2832 :: SBool = if s2650 then s2831 else s2830 s2833 :: SBool = s283 ^ s2832 s2834 :: SBool = if s2682 then s2833 else s2832 s2835 :: SBool = s273 ^ s2834 s2836 :: SBool = if s2714 then s2835 else s2834 s2837 :: SBool = s265 ^ s2836 s2838 :: SBool = if s2746 then s2837 else s2836 s2839 :: SBool = s259 ^ s2838 s2840 :: SBool = if s2778 then s2839 else s2838 s2841 :: SBool = s255 ^ s2840 s2842 :: SBool = if s2810 then s2841 else s2840 s2843 :: SBool = if s2362 then s7 else s_2 s2844 :: SBool = s493 ^ s2843 s2845 :: SBool = if s2394 then s2844 else s2843 s2846 :: SBool = s463 ^ s2845 s2847 :: SBool = if s2426 then s2846 else s2845 s2848 :: SBool = s435 ^ s2847 s2849 :: SBool = if s2458 then s2848 else s2847 s2850 :: SBool = s409 ^ s2849 s2851 :: SBool = if s2490 then s2850 else s2849 s2852 :: SBool = s385 ^ s2851 s2853 :: SBool = if s2522 then s2852 else s2851 s2854 :: SBool = s363 ^ s2853 s2855 :: SBool = if s2554 then s2854 else s2853 s2856 :: SBool = s343 ^ s2855 s2857 :: SBool = if s2586 then s2856 else s2855 s2858 :: SBool = s325 ^ s2857 s2859 :: SBool = if s2618 then s2858 else s2857 s2860 :: SBool = s309 ^ s2859 s2861 :: SBool = if s2650 then s2860 else s2859 s2862 :: SBool = s295 ^ s2861 s2863 :: SBool = if s2682 then s2862 else s2861 s2864 :: SBool = s283 ^ s2863 s2865 :: SBool = if s2714 then s2864 else s2863 s2866 :: SBool = s273 ^ s2865 s2867 :: SBool = if s2746 then s2866 else s2865 s2868 :: SBool = s265 ^ s2867 s2869 :: SBool = if s2778 then s2868 else s2867 s2870 :: SBool = s259 ^ s2869 s2871 :: SBool = if s2810 then s2870 else s2869 s2872 :: SBool = s255 ^ s2871 s2873 :: SBool = if s2842 then s2872 else s2871 s2874 :: SBool = s1578 ^ s2873 s2875 :: SBool = if s1099 then s7 else s_2 s2876 :: SBool = s493 ^ s2875 s2877 :: SBool = if s1131 then s2876 else s2875 s2878 :: SBool = s463 ^ s2877 s2879 :: SBool = if s1163 then s2878 else s2877 s2880 :: SBool = s435 ^ s2879 s2881 :: SBool = if s1195 then s2880 else s2879 s2882 :: SBool = s409 ^ s2881 s2883 :: SBool = if s1227 then s2882 else s2881 s2884 :: SBool = s385 ^ s2883 s2885 :: SBool = if s1259 then s2884 else s2883 s2886 :: SBool = s363 ^ s2885 s2887 :: SBool = if s1291 then s2886 else s2885 s2888 :: SBool = s343 ^ s2887 s2889 :: SBool = if s1323 then s2888 else s2887 s2890 :: SBool = s325 ^ s2889 s2891 :: SBool = if s1355 then s2890 else s2889 s2892 :: SBool = s309 ^ s2891 s2893 :: SBool = if s1387 then s2892 else s2891 s2894 :: SBool = s295 ^ s2893 s2895 :: SBool = if s1419 then s2894 else s2893 s2896 :: SBool = s283 ^ s2895 s2897 :: SBool = if s1451 then s2896 else s2895 s2898 :: SBool = s273 ^ s2897 s2899 :: SBool = if s1483 then s2898 else s2897 s2900 :: SBool = s265 ^ s2899 s2901 :: SBool = if s1515 then s2900 else s2899 s2902 :: SBool = s259 ^ s2901 s2903 :: SBool = if s1547 then s2902 else s2901 s2904 :: SBool = if s2394 then s7 else s_2 s2905 :: SBool = s493 ^ s2904 s2906 :: SBool = if s2426 then s2905 else s2904 s2907 :: SBool = s463 ^ s2906 s2908 :: SBool = if s2458 then s2907 else s2906 s2909 :: SBool = s435 ^ s2908 s2910 :: SBool = if s2490 then s2909 else s2908 s2911 :: SBool = s409 ^ s2910 s2912 :: SBool = if s2522 then s2911 else s2910 s2913 :: SBool = s385 ^ s2912 s2914 :: SBool = if s2554 then s2913 else s2912 s2915 :: SBool = s363 ^ s2914 s2916 :: SBool = if s2586 then s2915 else s2914 s2917 :: SBool = s343 ^ s2916 s2918 :: SBool = if s2618 then s2917 else s2916 s2919 :: SBool = s325 ^ s2918 s2920 :: SBool = if s2650 then s2919 else s2918 s2921 :: SBool = s309 ^ s2920 s2922 :: SBool = if s2682 then s2921 else s2920 s2923 :: SBool = s295 ^ s2922 s2924 :: SBool = if s2714 then s2923 else s2922 s2925 :: SBool = s283 ^ s2924 s2926 :: SBool = if s2746 then s2925 else s2924 s2927 :: SBool = s273 ^ s2926 s2928 :: SBool = if s2778 then s2927 else s2926 s2929 :: SBool = s265 ^ s2928 s2930 :: SBool = if s2810 then s2929 else s2928 s2931 :: SBool = s259 ^ s2930 s2932 :: SBool = if s2842 then s2931 else s2930 s2933 :: SBool = s2903 ^ s2932 s2934 :: SBool = if s1131 then s7 else s_2 s2935 :: SBool = s493 ^ s2934 s2936 :: SBool = if s1163 then s2935 else s2934 s2937 :: SBool = s463 ^ s2936 s2938 :: SBool = if s1195 then s2937 else s2936 s2939 :: SBool = s435 ^ s2938 s2940 :: SBool = if s1227 then s2939 else s2938 s2941 :: SBool = s409 ^ s2940 s2942 :: SBool = if s1259 then s2941 else s2940 s2943 :: SBool = s385 ^ s2942 s2944 :: SBool = if s1291 then s2943 else s2942 s2945 :: SBool = s363 ^ s2944 s2946 :: SBool = if s1323 then s2945 else s2944 s2947 :: SBool = s343 ^ s2946 s2948 :: SBool = if s1355 then s2947 else s2946 s2949 :: SBool = s325 ^ s2948 s2950 :: SBool = if s1387 then s2949 else s2948 s2951 :: SBool = s309 ^ s2950 s2952 :: SBool = if s1419 then s2951 else s2950 s2953 :: SBool = s295 ^ s2952 s2954 :: SBool = if s1451 then s2953 else s2952 s2955 :: SBool = s283 ^ s2954 s2956 :: SBool = if s1483 then s2955 else s2954 s2957 :: SBool = s273 ^ s2956 s2958 :: SBool = if s1515 then s2957 else s2956 s2959 :: SBool = s265 ^ s2958 s2960 :: SBool = if s1547 then s2959 else s2958 s2961 :: SBool = if s2426 then s7 else s_2 s2962 :: SBool = s493 ^ s2961 s2963 :: SBool = if s2458 then s2962 else s2961 s2964 :: SBool = s463 ^ s2963 s2965 :: SBool = if s2490 then s2964 else s2963 s2966 :: SBool = s435 ^ s2965 s2967 :: SBool = if s2522 then s2966 else s2965 s2968 :: SBool = s409 ^ s2967 s2969 :: SBool = if s2554 then s2968 else s2967 s2970 :: SBool = s385 ^ s2969 s2971 :: SBool = if s2586 then s2970 else s2969 s2972 :: SBool = s363 ^ s2971 s2973 :: SBool = if s2618 then s2972 else s2971 s2974 :: SBool = s343 ^ s2973 s2975 :: SBool = if s2650 then s2974 else s2973 s2976 :: SBool = s325 ^ s2975 s2977 :: SBool = if s2682 then s2976 else s2975 s2978 :: SBool = s309 ^ s2977 s2979 :: SBool = if s2714 then s2978 else s2977 s2980 :: SBool = s295 ^ s2979 s2981 :: SBool = if s2746 then s2980 else s2979 s2982 :: SBool = s283 ^ s2981 s2983 :: SBool = if s2778 then s2982 else s2981 s2984 :: SBool = s273 ^ s2983 s2985 :: SBool = if s2810 then s2984 else s2983 s2986 :: SBool = s265 ^ s2985 s2987 :: SBool = if s2842 then s2986 else s2985 s2988 :: SBool = s2960 ^ s2987 s2989 :: SBool = if s1163 then s7 else s_2 s2990 :: SBool = s493 ^ s2989 s2991 :: SBool = if s1195 then s2990 else s2989 s2992 :: SBool = s463 ^ s2991 s2993 :: SBool = if s1227 then s2992 else s2991 s2994 :: SBool = s435 ^ s2993 s2995 :: SBool = if s1259 then s2994 else s2993 s2996 :: SBool = s409 ^ s2995 s2997 :: SBool = if s1291 then s2996 else s2995 s2998 :: SBool = s385 ^ s2997 s2999 :: SBool = if s1323 then s2998 else s2997 s3000 :: SBool = s363 ^ s2999 s3001 :: SBool = if s1355 then s3000 else s2999 s3002 :: SBool = s343 ^ s3001 s3003 :: SBool = if s1387 then s3002 else s3001 s3004 :: SBool = s325 ^ s3003 s3005 :: SBool = if s1419 then s3004 else s3003 s3006 :: SBool = s309 ^ s3005 s3007 :: SBool = if s1451 then s3006 else s3005 s3008 :: SBool = s295 ^ s3007 s3009 :: SBool = if s1483 then s3008 else s3007 s3010 :: SBool = s283 ^ s3009 s3011 :: SBool = if s1515 then s3010 else s3009 s3012 :: SBool = s273 ^ s3011 s3013 :: SBool = if s1547 then s3012 else s3011 s3014 :: SBool = if s2458 then s7 else s_2 s3015 :: SBool = s493 ^ s3014 s3016 :: SBool = if s2490 then s3015 else s3014 s3017 :: SBool = s463 ^ s3016 s3018 :: SBool = if s2522 then s3017 else s3016 s3019 :: SBool = s435 ^ s3018 s3020 :: SBool = if s2554 then s3019 else s3018 s3021 :: SBool = s409 ^ s3020 s3022 :: SBool = if s2586 then s3021 else s3020 s3023 :: SBool = s385 ^ s3022 s3024 :: SBool = if s2618 then s3023 else s3022 s3025 :: SBool = s363 ^ s3024 s3026 :: SBool = if s2650 then s3025 else s3024 s3027 :: SBool = s343 ^ s3026 s3028 :: SBool = if s2682 then s3027 else s3026 s3029 :: SBool = s325 ^ s3028 s3030 :: SBool = if s2714 then s3029 else s3028 s3031 :: SBool = s309 ^ s3030 s3032 :: SBool = if s2746 then s3031 else s3030 s3033 :: SBool = s295 ^ s3032 s3034 :: SBool = if s2778 then s3033 else s3032 s3035 :: SBool = s283 ^ s3034 s3036 :: SBool = if s2810 then s3035 else s3034 s3037 :: SBool = s273 ^ s3036 s3038 :: SBool = if s2842 then s3037 else s3036 s3039 :: SBool = s3013 ^ s3038 s3040 :: SBool = if s1195 then s7 else s_2 s3041 :: SBool = s493 ^ s3040 s3042 :: SBool = if s1227 then s3041 else s3040 s3043 :: SBool = s463 ^ s3042 s3044 :: SBool = if s1259 then s3043 else s3042 s3045 :: SBool = s435 ^ s3044 s3046 :: SBool = if s1291 then s3045 else s3044 s3047 :: SBool = s409 ^ s3046 s3048 :: SBool = if s1323 then s3047 else s3046 s3049 :: SBool = s385 ^ s3048 s3050 :: SBool = if s1355 then s3049 else s3048 s3051 :: SBool = s363 ^ s3050 s3052 :: SBool = if s1387 then s3051 else s3050 s3053 :: SBool = s343 ^ s3052 s3054 :: SBool = if s1419 then s3053 else s3052 s3055 :: SBool = s325 ^ s3054 s3056 :: SBool = if s1451 then s3055 else s3054 s3057 :: SBool = s309 ^ s3056 s3058 :: SBool = if s1483 then s3057 else s3056 s3059 :: SBool = s295 ^ s3058 s3060 :: SBool = if s1515 then s3059 else s3058 s3061 :: SBool = s283 ^ s3060 s3062 :: SBool = if s1547 then s3061 else s3060 s3063 :: SBool = if s2490 then s7 else s_2 s3064 :: SBool = s493 ^ s3063 s3065 :: SBool = if s2522 then s3064 else s3063 s3066 :: SBool = s463 ^ s3065 s3067 :: SBool = if s2554 then s3066 else s3065 s3068 :: SBool = s435 ^ s3067 s3069 :: SBool = if s2586 then s3068 else s3067 s3070 :: SBool = s409 ^ s3069 s3071 :: SBool = if s2618 then s3070 else s3069 s3072 :: SBool = s385 ^ s3071 s3073 :: SBool = if s2650 then s3072 else s3071 s3074 :: SBool = s363 ^ s3073 s3075 :: SBool = if s2682 then s3074 else s3073 s3076 :: SBool = s343 ^ s3075 s3077 :: SBool = if s2714 then s3076 else s3075 s3078 :: SBool = s325 ^ s3077 s3079 :: SBool = if s2746 then s3078 else s3077 s3080 :: SBool = s309 ^ s3079 s3081 :: SBool = if s2778 then s3080 else s3079 s3082 :: SBool = s295 ^ s3081 s3083 :: SBool = if s2810 then s3082 else s3081 s3084 :: SBool = s283 ^ s3083 s3085 :: SBool = if s2842 then s3084 else s3083 s3086 :: SBool = s3062 ^ s3085 s3087 :: SBool = if s1227 then s7 else s_2 s3088 :: SBool = s493 ^ s3087 s3089 :: SBool = if s1259 then s3088 else s3087 s3090 :: SBool = s463 ^ s3089 s3091 :: SBool = if s1291 then s3090 else s3089 s3092 :: SBool = s435 ^ s3091 s3093 :: SBool = if s1323 then s3092 else s3091 s3094 :: SBool = s409 ^ s3093 s3095 :: SBool = if s1355 then s3094 else s3093 s3096 :: SBool = s385 ^ s3095 s3097 :: SBool = if s1387 then s3096 else s3095 s3098 :: SBool = s363 ^ s3097 s3099 :: SBool = if s1419 then s3098 else s3097 s3100 :: SBool = s343 ^ s3099 s3101 :: SBool = if s1451 then s3100 else s3099 s3102 :: SBool = s325 ^ s3101 s3103 :: SBool = if s1483 then s3102 else s3101 s3104 :: SBool = s309 ^ s3103 s3105 :: SBool = if s1515 then s3104 else s3103 s3106 :: SBool = s295 ^ s3105 s3107 :: SBool = if s1547 then s3106 else s3105 s3108 :: SBool = if s2522 then s7 else s_2 s3109 :: SBool = s493 ^ s3108 s3110 :: SBool = if s2554 then s3109 else s3108 s3111 :: SBool = s463 ^ s3110 s3112 :: SBool = if s2586 then s3111 else s3110 s3113 :: SBool = s435 ^ s3112 s3114 :: SBool = if s2618 then s3113 else s3112 s3115 :: SBool = s409 ^ s3114 s3116 :: SBool = if s2650 then s3115 else s3114 s3117 :: SBool = s385 ^ s3116 s3118 :: SBool = if s2682 then s3117 else s3116 s3119 :: SBool = s363 ^ s3118 s3120 :: SBool = if s2714 then s3119 else s3118 s3121 :: SBool = s343 ^ s3120 s3122 :: SBool = if s2746 then s3121 else s3120 s3123 :: SBool = s325 ^ s3122 s3124 :: SBool = if s2778 then s3123 else s3122 s3125 :: SBool = s309 ^ s3124 s3126 :: SBool = if s2810 then s3125 else s3124 s3127 :: SBool = s295 ^ s3126 s3128 :: SBool = if s2842 then s3127 else s3126 s3129 :: SBool = s3107 ^ s3128 s3130 :: SBool = if s1259 then s7 else s_2 s3131 :: SBool = s493 ^ s3130 s3132 :: SBool = if s1291 then s3131 else s3130 s3133 :: SBool = s463 ^ s3132 s3134 :: SBool = if s1323 then s3133 else s3132 s3135 :: SBool = s435 ^ s3134 s3136 :: SBool = if s1355 then s3135 else s3134 s3137 :: SBool = s409 ^ s3136 s3138 :: SBool = if s1387 then s3137 else s3136 s3139 :: SBool = s385 ^ s3138 s3140 :: SBool = if s1419 then s3139 else s3138 s3141 :: SBool = s363 ^ s3140 s3142 :: SBool = if s1451 then s3141 else s3140 s3143 :: SBool = s343 ^ s3142 s3144 :: SBool = if s1483 then s3143 else s3142 s3145 :: SBool = s325 ^ s3144 s3146 :: SBool = if s1515 then s3145 else s3144 s3147 :: SBool = s309 ^ s3146 s3148 :: SBool = if s1547 then s3147 else s3146 s3149 :: SBool = if s2554 then s7 else s_2 s3150 :: SBool = s493 ^ s3149 s3151 :: SBool = if s2586 then s3150 else s3149 s3152 :: SBool = s463 ^ s3151 s3153 :: SBool = if s2618 then s3152 else s3151 s3154 :: SBool = s435 ^ s3153 s3155 :: SBool = if s2650 then s3154 else s3153 s3156 :: SBool = s409 ^ s3155 s3157 :: SBool = if s2682 then s3156 else s3155 s3158 :: SBool = s385 ^ s3157 s3159 :: SBool = if s2714 then s3158 else s3157 s3160 :: SBool = s363 ^ s3159 s3161 :: SBool = if s2746 then s3160 else s3159 s3162 :: SBool = s343 ^ s3161 s3163 :: SBool = if s2778 then s3162 else s3161 s3164 :: SBool = s325 ^ s3163 s3165 :: SBool = if s2810 then s3164 else s3163 s3166 :: SBool = s309 ^ s3165 s3167 :: SBool = if s2842 then s3166 else s3165 s3168 :: SBool = s3148 ^ s3167 s3169 :: SBool = if s1291 then s7 else s_2 s3170 :: SBool = s493 ^ s3169 s3171 :: SBool = if s1323 then s3170 else s3169 s3172 :: SBool = s463 ^ s3171 s3173 :: SBool = if s1355 then s3172 else s3171 s3174 :: SBool = s435 ^ s3173 s3175 :: SBool = if s1387 then s3174 else s3173 s3176 :: SBool = s409 ^ s3175 s3177 :: SBool = if s1419 then s3176 else s3175 s3178 :: SBool = s385 ^ s3177 s3179 :: SBool = if s1451 then s3178 else s3177 s3180 :: SBool = s363 ^ s3179 s3181 :: SBool = if s1483 then s3180 else s3179 s3182 :: SBool = s343 ^ s3181 s3183 :: SBool = if s1515 then s3182 else s3181 s3184 :: SBool = s325 ^ s3183 s3185 :: SBool = if s1547 then s3184 else s3183 s3186 :: SBool = if s2586 then s7 else s_2 s3187 :: SBool = s493 ^ s3186 s3188 :: SBool = if s2618 then s3187 else s3186 s3189 :: SBool = s463 ^ s3188 s3190 :: SBool = if s2650 then s3189 else s3188 s3191 :: SBool = s435 ^ s3190 s3192 :: SBool = if s2682 then s3191 else s3190 s3193 :: SBool = s409 ^ s3192 s3194 :: SBool = if s2714 then s3193 else s3192 s3195 :: SBool = s385 ^ s3194 s3196 :: SBool = if s2746 then s3195 else s3194 s3197 :: SBool = s363 ^ s3196 s3198 :: SBool = if s2778 then s3197 else s3196 s3199 :: SBool = s343 ^ s3198 s3200 :: SBool = if s2810 then s3199 else s3198 s3201 :: SBool = s325 ^ s3200 s3202 :: SBool = if s2842 then s3201 else s3200 s3203 :: SBool = s3185 ^ s3202 s3204 :: SBool = if s1323 then s7 else s_2 s3205 :: SBool = s493 ^ s3204 s3206 :: SBool = if s1355 then s3205 else s3204 s3207 :: SBool = s463 ^ s3206 s3208 :: SBool = if s1387 then s3207 else s3206 s3209 :: SBool = s435 ^ s3208 s3210 :: SBool = if s1419 then s3209 else s3208 s3211 :: SBool = s409 ^ s3210 s3212 :: SBool = if s1451 then s3211 else s3210 s3213 :: SBool = s385 ^ s3212 s3214 :: SBool = if s1483 then s3213 else s3212 s3215 :: SBool = s363 ^ s3214 s3216 :: SBool = if s1515 then s3215 else s3214 s3217 :: SBool = s343 ^ s3216 s3218 :: SBool = if s1547 then s3217 else s3216 s3219 :: SBool = if s2618 then s7 else s_2 s3220 :: SBool = s493 ^ s3219 s3221 :: SBool = if s2650 then s3220 else s3219 s3222 :: SBool = s463 ^ s3221 s3223 :: SBool = if s2682 then s3222 else s3221 s3224 :: SBool = s435 ^ s3223 s3225 :: SBool = if s2714 then s3224 else s3223 s3226 :: SBool = s409 ^ s3225 s3227 :: SBool = if s2746 then s3226 else s3225 s3228 :: SBool = s385 ^ s3227 s3229 :: SBool = if s2778 then s3228 else s3227 s3230 :: SBool = s363 ^ s3229 s3231 :: SBool = if s2810 then s3230 else s3229 s3232 :: SBool = s343 ^ s3231 s3233 :: SBool = if s2842 then s3232 else s3231 s3234 :: SBool = s3218 ^ s3233 s3235 :: SBool = if s1355 then s7 else s_2 s3236 :: SBool = s493 ^ s3235 s3237 :: SBool = if s1387 then s3236 else s3235 s3238 :: SBool = s463 ^ s3237 s3239 :: SBool = if s1419 then s3238 else s3237 s3240 :: SBool = s435 ^ s3239 s3241 :: SBool = if s1451 then s3240 else s3239 s3242 :: SBool = s409 ^ s3241 s3243 :: SBool = if s1483 then s3242 else s3241 s3244 :: SBool = s385 ^ s3243 s3245 :: SBool = if s1515 then s3244 else s3243 s3246 :: SBool = s363 ^ s3245 s3247 :: SBool = if s1547 then s3246 else s3245 s3248 :: SBool = if s2650 then s7 else s_2 s3249 :: SBool = s493 ^ s3248 s3250 :: SBool = if s2682 then s3249 else s3248 s3251 :: SBool = s463 ^ s3250 s3252 :: SBool = if s2714 then s3251 else s3250 s3253 :: SBool = s435 ^ s3252 s3254 :: SBool = if s2746 then s3253 else s3252 s3255 :: SBool = s409 ^ s3254 s3256 :: SBool = if s2778 then s3255 else s3254 s3257 :: SBool = s385 ^ s3256 s3258 :: SBool = if s2810 then s3257 else s3256 s3259 :: SBool = s363 ^ s3258 s3260 :: SBool = if s2842 then s3259 else s3258 s3261 :: SBool = s3247 ^ s3260 s3262 :: SBool = if s1387 then s7 else s_2 s3263 :: SBool = s493 ^ s3262 s3264 :: SBool = if s1419 then s3263 else s3262 s3265 :: SBool = s463 ^ s3264 s3266 :: SBool = if s1451 then s3265 else s3264 s3267 :: SBool = s435 ^ s3266 s3268 :: SBool = if s1483 then s3267 else s3266 s3269 :: SBool = s409 ^ s3268 s3270 :: SBool = if s1515 then s3269 else s3268 s3271 :: SBool = s385 ^ s3270 s3272 :: SBool = if s1547 then s3271 else s3270 s3273 :: SBool = if s2682 then s7 else s_2 s3274 :: SBool = s493 ^ s3273 s3275 :: SBool = if s2714 then s3274 else s3273 s3276 :: SBool = s463 ^ s3275 s3277 :: SBool = if s2746 then s3276 else s3275 s3278 :: SBool = s435 ^ s3277 s3279 :: SBool = if s2778 then s3278 else s3277 s3280 :: SBool = s409 ^ s3279 s3281 :: SBool = if s2810 then s3280 else s3279 s3282 :: SBool = s385 ^ s3281 s3283 :: SBool = if s2842 then s3282 else s3281 s3284 :: SBool = s3272 ^ s3283 s3285 :: SBool = if s1419 then s7 else s_2 s3286 :: SBool = s493 ^ s3285 s3287 :: SBool = if s1451 then s3286 else s3285 s3288 :: SBool = s463 ^ s3287 s3289 :: SBool = if s1483 then s3288 else s3287 s3290 :: SBool = s435 ^ s3289 s3291 :: SBool = if s1515 then s3290 else s3289 s3292 :: SBool = s409 ^ s3291 s3293 :: SBool = if s1547 then s3292 else s3291 s3294 :: SBool = if s2714 then s7 else s_2 s3295 :: SBool = s493 ^ s3294 s3296 :: SBool = if s2746 then s3295 else s3294 s3297 :: SBool = s463 ^ s3296 s3298 :: SBool = if s2778 then s3297 else s3296 s3299 :: SBool = s435 ^ s3298 s3300 :: SBool = if s2810 then s3299 else s3298 s3301 :: SBool = s409 ^ s3300 s3302 :: SBool = if s2842 then s3301 else s3300 s3303 :: SBool = s3293 ^ s3302 s3304 :: SBool = if s1451 then s7 else s_2 s3305 :: SBool = s493 ^ s3304 s3306 :: SBool = if s1483 then s3305 else s3304 s3307 :: SBool = s463 ^ s3306 s3308 :: SBool = if s1515 then s3307 else s3306 s3309 :: SBool = s435 ^ s3308 s3310 :: SBool = if s1547 then s3309 else s3308 s3311 :: SBool = if s2746 then s7 else s_2 s3312 :: SBool = s493 ^ s3311 s3313 :: SBool = if s2778 then s3312 else s3311 s3314 :: SBool = s463 ^ s3313 s3315 :: SBool = if s2810 then s3314 else s3313 s3316 :: SBool = s435 ^ s3315 s3317 :: SBool = if s2842 then s3316 else s3315 s3318 :: SBool = s3310 ^ s3317 s3319 :: SBool = if s1483 then s7 else s_2 s3320 :: SBool = s493 ^ s3319 s3321 :: SBool = if s1515 then s3320 else s3319 s3322 :: SBool = s463 ^ s3321 s3323 :: SBool = if s1547 then s3322 else s3321 s3324 :: SBool = if s2778 then s7 else s_2 s3325 :: SBool = s493 ^ s3324 s3326 :: SBool = if s2810 then s3325 else s3324 s3327 :: SBool = s463 ^ s3326 s3328 :: SBool = if s2842 then s3327 else s3326 s3329 :: SBool = s3323 ^ s3328 s3330 :: SBool = if s1515 then s7 else s_2 s3331 :: SBool = s493 ^ s3330 s3332 :: SBool = if s1547 then s3331 else s3330 s3333 :: SBool = if s2810 then s7 else s_2 s3334 :: SBool = s493 ^ s3333 s3335 :: SBool = if s2842 then s3334 else s3333 s3336 :: SBool = s3332 ^ s3335 s3337 :: SBool = if s1547 then s7 else s_2 s3338 :: SBool = if s2842 then s7 else s_2 s3339 :: SBool = s3337 ^ s3338 s3341 :: SWord8 = if s3339 then s18 else s3340 s3342 :: SWord8 = s18 + s3341 s3343 :: SWord8 = if s3336 then s3342 else s3341 s3344 :: SWord8 = s18 + s3343 s3345 :: SWord8 = if s3329 then s3344 else s3343 s3346 :: SWord8 = s18 + s3345 s3347 :: SWord8 = if s3318 then s3346 else s3345 s3348 :: SWord8 = s18 + s3347 s3349 :: SWord8 = if s3303 then s3348 else s3347 s3350 :: SWord8 = s18 + s3349 s3351 :: SWord8 = if s3284 then s3350 else s3349 s3352 :: SWord8 = s18 + s3351 s3353 :: SWord8 = if s3261 then s3352 else s3351 s3354 :: SWord8 = s18 + s3353 s3355 :: SWord8 = if s3234 then s3354 else s3353 s3356 :: SWord8 = s18 + s3355 s3357 :: SWord8 = if s3203 then s3356 else s3355 s3358 :: SWord8 = s18 + s3357 s3359 :: SWord8 = if s3168 then s3358 else s3357 s3360 :: SWord8 = s18 + s3359 s3361 :: SWord8 = if s3129 then s3360 else s3359 s3362 :: SWord8 = s18 + s3361 s3363 :: SWord8 = if s3086 then s3362 else s3361 s3364 :: SWord8 = s18 + s3363 s3365 :: SWord8 = if s3039 then s3364 else s3363 s3366 :: SWord8 = s18 + s3365 s3367 :: SWord8 = if s2988 then s3366 else s3365 s3368 :: SWord8 = s18 + s3367 s3369 :: SWord8 = if s2933 then s3368 else s3367 s3370 :: SWord8 = s18 + s3369 s3371 :: SWord8 = if s2874 then s3370 else s3369 s3372 :: SWord8 = s18 + s3371 s3373 :: SWord8 = if s253 then s3372 else s3371 s3374 :: SWord8 = s18 + s3373 s3375 :: SWord8 = if s248 then s3374 else s3373 s3376 :: SWord8 = s18 + s3375 s3377 :: SWord8 = if s243 then s3376 else s3375 s3378 :: SWord8 = s18 + s3377 s3379 :: SWord8 = if s238 then s3378 else s3377 s3380 :: SWord8 = s18 + s3379 s3381 :: SWord8 = if s233 then s3380 else s3379 s3382 :: SWord8 = s18 + s3381 s3383 :: SWord8 = if s228 then s3382 else s3381 s3384 :: SWord8 = s18 + s3383 s3385 :: SWord8 = if s223 then s3384 else s3383 s3386 :: SWord8 = s18 + s3385 s3387 :: SWord8 = if s218 then s3386 else s3385 s3388 :: SWord8 = s18 + s3387 s3389 :: SWord8 = if s213 then s3388 else s3387 s3390 :: SWord8 = s18 + s3389 s3391 :: SWord8 = if s208 then s3390 else s3389 s3392 :: SWord8 = s18 + s3391 s3393 :: SWord8 = if s203 then s3392 else s3391 s3394 :: SWord8 = s18 + s3393 s3395 :: SWord8 = if s198 then s3394 else s3393 s3396 :: SWord8 = s18 + s3395 s3397 :: SWord8 = if s193 then s3396 else s3395 s3398 :: SWord8 = s18 + s3397 s3399 :: SWord8 = if s188 then s3398 else s3397 s3400 :: SWord8 = s18 + s3399 s3401 :: SWord8 = if s183 then s3400 else s3399 s3402 :: SWord8 = s18 + s3401 s3403 :: SWord8 = if s178 then s3402 else s3401 s3404 :: SWord8 = s18 + s3403 s3405 :: SWord8 = if s173 then s3404 else s3403 s3406 :: SWord8 = s18 + s3405 s3407 :: SWord8 = if s168 then s3406 else s3405 s3408 :: SWord8 = s18 + s3407 s3409 :: SWord8 = if s163 then s3408 else s3407 s3410 :: SWord8 = s18 + s3409 s3411 :: SWord8 = if s158 then s3410 else s3409 s3412 :: SWord8 = s18 + s3411 s3413 :: SWord8 = if s153 then s3412 else s3411 s3414 :: SWord8 = s18 + s3413 s3415 :: SWord8 = if s148 then s3414 else s3413 s3416 :: SWord8 = s18 + s3415 s3417 :: SWord8 = if s143 then s3416 else s3415 s3418 :: SWord8 = s18 + s3417 s3419 :: SWord8 = if s138 then s3418 else s3417 s3420 :: SWord8 = s18 + s3419 s3421 :: SWord8 = if s133 then s3420 else s3419 s3422 :: SWord8 = s18 + s3421 s3423 :: SWord8 = if s128 then s3422 else s3421 s3424 :: SWord8 = s18 + s3423 s3425 :: SWord8 = if s123 then s3424 else s3423 s3426 :: SWord8 = s18 + s3425 s3427 :: SWord8 = if s118 then s3426 else s3425 s3428 :: SWord8 = s18 + s3427 s3429 :: SWord8 = if s113 then s3428 else s3427 s3430 :: SWord8 = s18 + s3429 s3431 :: SWord8 = if s108 then s3430 else s3429 s3432 :: SWord8 = s18 + s3431 s3433 :: SWord8 = if s103 then s3432 else s3431 s3434 :: SWord8 = s18 + s3433 s3435 :: SWord8 = if s98 then s3434 else s3433 s3436 :: SWord8 = s18 + s3435 s3437 :: SWord8 = if s93 then s3436 else s3435 s3438 :: SWord8 = s18 + s3437 s3439 :: SWord8 = if s88 then s3438 else s3437 s3440 :: SWord8 = s18 + s3439 s3441 :: SWord8 = if s83 then s3440 else s3439 s3442 :: SWord8 = s18 + s3441 s3443 :: SWord8 = if s78 then s3442 else s3441 s3444 :: SWord8 = s18 + s3443 s3445 :: SWord8 = if s73 then s3444 else s3443 s3446 :: SWord8 = s18 + s3445 s3447 :: SWord8 = if s68 then s3446 else s3445 s3448 :: SWord8 = s18 + s3447 s3449 :: SWord8 = if s63 then s3448 else s3447 s3450 :: SWord8 = s18 + s3449 s3451 :: SWord8 = if s58 then s3450 else s3449 s3452 :: SWord8 = s18 + s3451 s3453 :: SWord8 = if s53 then s3452 else s3451 s3454 :: SWord8 = s18 + s3453 s3455 :: SWord8 = if s48 then s3454 else s3453 s3456 :: SWord8 = s18 + s3455 s3457 :: SWord8 = if s43 then s3456 else s3455 s3458 :: SWord8 = s18 + s3457 s3459 :: SWord8 = if s38 then s3458 else s3457 s3460 :: SWord8 = s18 + s3459 s3461 :: SWord8 = if s33 then s3460 else s3459 s3462 :: SWord8 = s18 + s3461 s3463 :: SWord8 = if s28 then s3462 else s3461 s3464 :: SWord8 = s18 + s3463 s3465 :: SWord8 = if s23 then s3464 else s3463 s3466 :: SWord8 = s18 + s3465 s3467 :: SWord8 = if s17 then s3466 else s3465 s3469 :: SBool = s3467 >= s3468 s3470 :: SBool = s12 | s3469 s3471 :: SBool = s7 & s3470 CONSTRAINTS ASSERTIONS OUTPUTS s3471sbv-5.12/SBVUnitTest/GoldFiles/crcUSB5_1.gold0000644000000000000000000001223212725411266016726 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for crcUSB5. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: crcUSB5_driver crcUSB5.o: crcUSB5.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver.o: crcUSB5_driver.c ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver: crcUSB5.o crcUSB5_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f crcUSB5_driver == END: "Makefile" ================== == BEGIN: "crcUSB5.h" ================ /* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */ #ifndef __crcUSB5__HEADER_INCLUDED__ #define __crcUSB5__HEADER_INCLUDED__ #include #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: */ SWord16 crcUSB5(const SWord16 msg); #endif /* __crcUSB5__HEADER_INCLUDED__ */ == END: "crcUSB5.h" ================== == BEGIN: "crcUSB5_driver.c" ================ /* Example driver program for crcUSB5. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "crcUSB5.h" int main(void) { const SWord16 __result = crcUSB5(0xfedcU); printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result); return 0; } == END: "crcUSB5_driver.c" ================== == BEGIN: "crcUSB5.c" ================ /* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */ #include "crcUSB5.h" SWord16 crcUSB5(const SWord16 msg) { const SWord16 s0 = msg; const SBool s1 = (SBool) ((s0 >> 10) & 1); const SBool s3 = s1 != false; const SBool s4 = (SBool) ((s0 >> 9) & 1); const SBool s5 = false != s4; const SBool s6 = (SBool) ((s0 >> 8) & 1); const SBool s7 = false != s6; const SBool s8 = (SBool) ((s0 >> 7) & 1); const SBool s9 = false != s8; const SBool s10 = (SBool) ((s0 >> 6) & 1); const SBool s11 = false != s10; const SBool s12 = (SBool) ((s0 >> 5) & 1); const SBool s13 = false != s12; const SBool s14 = (SBool) ((s0 >> 4) & 1); const SBool s15 = false != s14; const SBool s16 = (SBool) ((s0 >> 3) & 1); const SBool s17 = false != s16; const SBool s18 = (SBool) ((s0 >> 2) & 1); const SBool s19 = false != s18; const SBool s20 = (SBool) ((s0 >> 1) & 1); const SBool s21 = false != s20; const SBool s22 = (SBool) ((s0 >> 0) & 1); const SBool s23 = false != s22; const SBool s24 = !s9; const SBool s25 = s3 ? s24 : s9; const SBool s26 = !s11; const SBool s27 = s5 ? s26 : s11; const SBool s28 = !s13; const SBool s29 = s3 ? s28 : s13; const SBool s30 = !s29; const SBool s31 = s7 ? s30 : s29; const SBool s32 = !s15; const SBool s33 = s5 ? s32 : s15; const SBool s34 = !s33; const SBool s35 = s25 ? s34 : s33; const SBool s36 = !s17; const SBool s37 = s7 ? s36 : s17; const SBool s38 = !s37; const SBool s39 = s27 ? s38 : s37; const SBool s40 = !s19; const SBool s41 = s25 ? s40 : s19; const SBool s42 = !s41; const SBool s43 = s31 ? s42 : s41; const SBool s44 = !s21; const SBool s45 = s27 ? s44 : s21; const SBool s46 = !s45; const SBool s47 = s35 ? s46 : s45; const SBool s48 = !s23; const SBool s49 = s31 ? s48 : s23; const SBool s50 = !s49; const SBool s51 = s39 ? s50 : s49; const SBool s52 = !s35; const SBool s53 = s43 ? s52 : s35; const SBool s54 = !s39; const SBool s55 = s47 ? s54 : s39; const SBool s56 = !s43; const SBool s57 = s51 ? s56 : s43; const SWord16 s60 = s51 ? 0x0001U : 0x0000U; const SWord16 s62 = s60 | 0x0002U; const SWord16 s63 = s47 ? s62 : s60; const SWord16 s65 = s63 | 0x0004U; const SWord16 s66 = s57 ? s65 : s63; const SWord16 s68 = s66 | 0x0008U; const SWord16 s69 = s55 ? s68 : s66; const SWord16 s71 = s69 | 0x0010U; const SWord16 s72 = s53 ? s71 : s69; const SWord16 s74 = s72 | 0x0020U; const SWord16 s75 = s23 ? s74 : s72; const SWord16 s77 = s75 | 0x0040U; const SWord16 s78 = s21 ? s77 : s75; const SWord16 s80 = s78 | 0x0080U; const SWord16 s81 = s19 ? s80 : s78; const SWord16 s83 = s81 | 0x0100U; const SWord16 s84 = s17 ? s83 : s81; const SWord16 s86 = s84 | 0x0200U; const SWord16 s87 = s15 ? s86 : s84; const SWord16 s89 = s87 | 0x0400U; const SWord16 s90 = s13 ? s89 : s87; const SWord16 s92 = s90 | 0x0800U; const SWord16 s93 = s11 ? s92 : s90; const SWord16 s95 = s93 | 0x1000U; const SWord16 s96 = s9 ? s95 : s93; const SWord16 s98 = s96 | 0x2000U; const SWord16 s99 = s7 ? s98 : s96; const SWord16 s101 = s99 | 0x4000U; const SWord16 s102 = s5 ? s101 : s99; const SWord16 s104 = s102 | 0x8000U; const SWord16 s105 = s3 ? s104 : s102; return s105; } == END: "crcUSB5.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/crcUSB5_2.gold0000644000000000000000000001536212725411266016736 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for crcUSB5. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: crcUSB5_driver crcUSB5.o: crcUSB5.c crcUSB5.h ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver.o: crcUSB5_driver.c ${CC} ${CCFLAGS} -c $< -o $@ crcUSB5_driver: crcUSB5.o crcUSB5_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f crcUSB5_driver == END: "Makefile" ================== == BEGIN: "crcUSB5.h" ================ /* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */ #ifndef __crcUSB5__HEADER_INCLUDED__ #define __crcUSB5__HEADER_INCLUDED__ #include #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: */ SWord16 crcUSB5(const SWord16 msg); #endif /* __crcUSB5__HEADER_INCLUDED__ */ == END: "crcUSB5.h" ================== == BEGIN: "crcUSB5_driver.c" ================ /* Example driver program for crcUSB5. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "crcUSB5.h" int main(void) { const SWord16 __result = crcUSB5(0xfedcU); printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result); return 0; } == END: "crcUSB5_driver.c" ================== == BEGIN: "crcUSB5.c" ================ /* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */ #include "crcUSB5.h" SWord16 crcUSB5(const SWord16 msg) { const SWord16 s0 = msg; const SWord16 s1 = s0 << 5; const SBool s2 = (SBool) ((s1 >> 15) & 1); const SBool s4 = s2 != false; const SBool s5 = (SBool) ((s1 >> 14) & 1); const SBool s6 = false != s5; const SBool s7 = (SBool) ((s1 >> 13) & 1); const SBool s8 = false != s7; const SBool s9 = (SBool) ((s1 >> 12) & 1); const SBool s10 = false != s9; const SBool s11 = !s10; const SBool s12 = s4 ? s11 : s10; const SBool s13 = (SBool) ((s1 >> 11) & 1); const SBool s14 = false != s13; const SBool s15 = !s14; const SBool s16 = s6 ? s15 : s14; const SBool s17 = (SBool) ((s1 >> 10) & 1); const SBool s18 = false != s17; const SBool s19 = !s18; const SBool s20 = s4 ? s19 : s18; const SBool s21 = !s20; const SBool s22 = s8 ? s21 : s20; const SBool s23 = (SBool) ((s1 >> 9) & 1); const SBool s24 = false != s23; const SBool s25 = !s24; const SBool s26 = s6 ? s25 : s24; const SBool s27 = !s26; const SBool s28 = s12 ? s27 : s26; const SBool s29 = (SBool) ((s1 >> 8) & 1); const SBool s30 = false != s29; const SBool s31 = !s30; const SBool s32 = s8 ? s31 : s30; const SBool s33 = !s32; const SBool s34 = s16 ? s33 : s32; const SBool s35 = (SBool) ((s1 >> 7) & 1); const SBool s36 = false != s35; const SBool s37 = !s36; const SBool s38 = s12 ? s37 : s36; const SBool s39 = !s38; const SBool s40 = s22 ? s39 : s38; const SBool s41 = (SBool) ((s1 >> 6) & 1); const SBool s42 = false != s41; const SBool s43 = !s42; const SBool s44 = s16 ? s43 : s42; const SBool s45 = !s44; const SBool s46 = s28 ? s45 : s44; const SBool s47 = (SBool) ((s1 >> 5) & 1); const SBool s48 = false != s47; const SBool s49 = !s48; const SBool s50 = s22 ? s49 : s48; const SBool s51 = !s50; const SBool s52 = s34 ? s51 : s50; const SBool s53 = !s4; const SBool s54 = s4 ? s53 : s4; const SBool s55 = !s6; const SBool s56 = s6 ? s55 : s6; const SBool s57 = !s8; const SBool s58 = s8 ? s57 : s8; const SBool s59 = !s12; const SBool s60 = s12 ? s59 : s12; const SBool s61 = !s16; const SBool s62 = s16 ? s61 : s16; const SBool s63 = !s22; const SBool s64 = s22 ? s63 : s22; const SBool s65 = !s28; const SBool s66 = s28 ? s65 : s28; const SBool s67 = !s34; const SBool s68 = s34 ? s67 : s34; const SBool s69 = !s40; const SBool s70 = s40 ? s69 : s40; const SBool s71 = !s46; const SBool s72 = s46 ? s71 : s46; const SBool s73 = !s52; const SBool s74 = s52 ? s73 : s52; const SBool s75 = (SBool) ((s1 >> 4) & 1); const SBool s76 = false != s75; const SBool s77 = !s76; const SBool s78 = s28 ? s77 : s76; const SBool s79 = !s78; const SBool s80 = s40 ? s79 : s78; const SBool s81 = (SBool) ((s1 >> 3) & 1); const SBool s82 = false != s81; const SBool s83 = !s82; const SBool s84 = s34 ? s83 : s82; const SBool s85 = !s84; const SBool s86 = s46 ? s85 : s84; const SBool s87 = (SBool) ((s1 >> 2) & 1); const SBool s88 = false != s87; const SBool s89 = !s88; const SBool s90 = s40 ? s89 : s88; const SBool s91 = !s90; const SBool s92 = s52 ? s91 : s90; const SBool s93 = (SBool) ((s1 >> 1) & 1); const SBool s94 = false != s93; const SBool s95 = !s94; const SBool s96 = s46 ? s95 : s94; const SBool s97 = (SBool) ((s1 >> 0) & 1); const SBool s98 = false != s97; const SBool s99 = !s98; const SBool s100 = s52 ? s99 : s98; const SWord16 s103 = s100 ? 0x0001U : 0x0000U; const SWord16 s105 = s103 | 0x0002U; const SWord16 s106 = s96 ? s105 : s103; const SWord16 s108 = s106 | 0x0004U; const SWord16 s109 = s92 ? s108 : s106; const SWord16 s111 = s109 | 0x0008U; const SWord16 s112 = s86 ? s111 : s109; const SWord16 s114 = s112 | 0x0010U; const SWord16 s115 = s80 ? s114 : s112; const SWord16 s117 = s115 | 0x0020U; const SWord16 s118 = s74 ? s117 : s115; const SWord16 s120 = s118 | 0x0040U; const SWord16 s121 = s72 ? s120 : s118; const SWord16 s123 = s121 | 0x0080U; const SWord16 s124 = s70 ? s123 : s121; const SWord16 s126 = s124 | 0x0100U; const SWord16 s127 = s68 ? s126 : s124; const SWord16 s129 = s127 | 0x0200U; const SWord16 s130 = s66 ? s129 : s127; const SWord16 s132 = s130 | 0x0400U; const SWord16 s133 = s64 ? s132 : s130; const SWord16 s135 = s133 | 0x0800U; const SWord16 s136 = s62 ? s135 : s133; const SWord16 s138 = s136 | 0x1000U; const SWord16 s139 = s60 ? s138 : s136; const SWord16 s141 = s139 | 0x2000U; const SWord16 s142 = s58 ? s141 : s139; const SWord16 s144 = s142 | 0x4000U; const SWord16 s145 = s56 ? s144 : s142; const SWord16 s147 = s145 | 0x8000U; const SWord16 s148 = s54 ? s147 : s145; const SWord16 s149 = s1 | s148; return s149; } == END: "crcUSB5.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/dogCatMouse.gold0000644000000000000000000000015712725411266017515 0ustar0000000000000000Solution #1: dog = 3 :: Integer cat = 41 :: Integer mouse = 56 :: Integer This is the only solution.sbv-5.12/SBVUnitTest/GoldFiles/euler185.gold0000644000000000000000000000052712725411266016656 0ustar0000000000000000Solution #1: s0 = 4 :: Word8 s1 = 6 :: Word8 s2 = 4 :: Word8 s3 = 0 :: Word8 s4 = 2 :: Word8 s5 = 6 :: Word8 s6 = 1 :: Word8 s7 = 5 :: Word8 s8 = 7 :: Word8 s9 = 1 :: Word8 s10 = 8 :: Word8 s11 = 4 :: Word8 s12 = 9 :: Word8 s13 = 5 :: Word8 s14 = 3 :: Word8 s15 = 3 :: Word8 This is the only solution.sbv-5.12/SBVUnitTest/GoldFiles/fib1.gold0000644000000000000000000002160512725411266016125 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for fib1. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: fib1_driver fib1.o: fib1.c fib1.h ${CC} ${CCFLAGS} -c $< -o $@ fib1_driver.o: fib1_driver.c ${CC} ${CCFLAGS} -c $< -o $@ fib1_driver: fib1.o fib1_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f fib1_driver == END: "Makefile" ================== == BEGIN: "fib1.h" ================ /* Header file for fib1. Automatically generated by SBV. Do not edit! */ #ifndef __fib1__HEADER_INCLUDED__ #define __fib1__HEADER_INCLUDED__ #include #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: */ SWord64 fib1(const SWord64 n); #endif /* __fib1__HEADER_INCLUDED__ */ == END: "fib1.h" ================== == BEGIN: "fib1_driver.c" ================ /* Example driver program for fib1. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "fib1.h" int main(void) { const SWord64 __result = fib1(0x000000000000000cULL); printf("fib1(0x000000000000000cULL) = 0x%016"PRIx64"ULL\n", __result); return 0; } == END: "fib1_driver.c" ================== == BEGIN: "fib1.c" ================ /* File: "fib1.c". Automatically generated by SBV. Do not edit! */ #include "fib1.h" SWord64 fib1(const SWord64 n) { const SWord64 s0 = n; const SBool s2 = s0 == 0x0000000000000000ULL; const SBool s4 = s0 == 0x0000000000000001ULL; const SBool s6 = s0 == 0x0000000000000002ULL; const SBool s8 = s0 == 0x0000000000000003ULL; const SBool s10 = s0 == 0x0000000000000004ULL; const SBool s12 = s0 == 0x0000000000000005ULL; const SBool s14 = s0 == 0x0000000000000006ULL; const SBool s17 = s0 == 0x0000000000000007ULL; const SBool s19 = s0 == 0x0000000000000008ULL; const SBool s22 = s0 == 0x0000000000000009ULL; const SBool s25 = s0 == 0x000000000000000aULL; const SBool s28 = s0 == 0x000000000000000bULL; const SBool s31 = s0 == 0x000000000000000cULL; const SBool s33 = s0 == 0x000000000000000dULL; const SBool s36 = s0 == 0x000000000000000eULL; const SBool s39 = s0 == 0x000000000000000fULL; const SBool s42 = s0 == 0x0000000000000010ULL; const SBool s45 = s0 == 0x0000000000000011ULL; const SBool s48 = s0 == 0x0000000000000012ULL; const SBool s51 = s0 == 0x0000000000000013ULL; const SBool s54 = s0 == 0x0000000000000014ULL; const SBool s56 = s0 == 0x0000000000000015ULL; const SBool s59 = s0 == 0x0000000000000016ULL; const SBool s62 = s0 == 0x0000000000000017ULL; const SBool s65 = s0 == 0x0000000000000018ULL; const SBool s68 = s0 == 0x0000000000000019ULL; const SBool s71 = s0 == 0x000000000000001aULL; const SBool s74 = s0 == 0x000000000000001bULL; const SBool s77 = s0 == 0x000000000000001cULL; const SBool s80 = s0 == 0x000000000000001dULL; const SBool s83 = s0 == 0x000000000000001eULL; const SBool s86 = s0 == 0x000000000000001fULL; const SBool s89 = s0 == 0x0000000000000020ULL; const SBool s92 = s0 == 0x0000000000000021ULL; const SBool s94 = s0 == 0x0000000000000022ULL; const SBool s97 = s0 == 0x0000000000000023ULL; const SBool s100 = s0 == 0x0000000000000024ULL; const SBool s103 = s0 == 0x0000000000000025ULL; const SBool s106 = s0 == 0x0000000000000026ULL; const SBool s109 = s0 == 0x0000000000000027ULL; const SBool s112 = s0 == 0x0000000000000028ULL; const SBool s115 = s0 == 0x0000000000000029ULL; const SBool s118 = s0 == 0x000000000000002aULL; const SBool s121 = s0 == 0x000000000000002bULL; const SBool s124 = s0 == 0x000000000000002cULL; const SBool s127 = s0 == 0x000000000000002dULL; const SBool s130 = s0 == 0x000000000000002eULL; const SBool s133 = s0 == 0x000000000000002fULL; const SBool s136 = s0 == 0x0000000000000030ULL; const SBool s139 = s0 == 0x0000000000000031ULL; const SBool s142 = s0 == 0x0000000000000032ULL; const SBool s145 = s0 == 0x0000000000000033ULL; const SBool s148 = s0 == 0x0000000000000034ULL; const SBool s151 = s0 == 0x0000000000000035ULL; const SBool s154 = s0 == 0x0000000000000036ULL; const SBool s156 = s0 == 0x0000000000000037ULL; const SBool s159 = s0 == 0x0000000000000038ULL; const SBool s162 = s0 == 0x0000000000000039ULL; const SBool s165 = s0 == 0x000000000000003aULL; const SBool s168 = s0 == 0x000000000000003bULL; const SBool s171 = s0 == 0x000000000000003cULL; const SBool s174 = s0 == 0x000000000000003dULL; const SBool s177 = s0 == 0x000000000000003eULL; const SBool s180 = s0 == 0x000000000000003fULL; const SWord64 s183 = s180 ? 0x000005f6c7b064e2ULL : 0x000009a661ca20bbULL; const SWord64 s184 = s177 ? 0x000003af9a19bbd9ULL : s183; const SWord64 s185 = s174 ? 0x000002472d96a909ULL : s184; const SWord64 s186 = s171 ? 0x000001686c8312d0ULL : s185; const SWord64 s187 = s168 ? 0x000000dec1139639ULL : s186; const SWord64 s188 = s165 ? 0x00000089ab6f7c97ULL : s187; const SWord64 s189 = s162 ? 0x0000005515a419a2ULL : s188; const SWord64 s190 = s159 ? 0x0000003495cb62f5ULL : s189; const SWord64 s191 = s156 ? 0x000000207fd8b6adULL : s190; const SWord64 s192 = s154 ? 0x0000001415f2ac48ULL : s191; const SWord64 s193 = s151 ? 0x0000000c69e60a65ULL : s192; const SWord64 s194 = s148 ? 0x00000007ac0ca1e3ULL : s193; const SWord64 s195 = s145 ? 0x00000004bdd96882ULL : s194; const SWord64 s196 = s142 ? 0x00000002ee333961ULL : s195; const SWord64 s197 = s139 ? 0x00000001cfa62f21ULL : s196; const SWord64 s198 = s136 ? 0x000000011e8d0a40ULL : s197; const SWord64 s199 = s133 ? 0x00000000b11924e1ULL : s198; const SWord64 s200 = s130 ? 0x000000006d73e55fULL : s199; const SWord64 s201 = s127 ? 0x0000000043a53f82ULL : s200; const SWord64 s202 = s124 ? 0x0000000029cea5ddULL : s201; const SWord64 s203 = s121 ? 0x0000000019d699a5ULL : s202; const SWord64 s204 = s118 ? 0x000000000ff80c38ULL : s203; const SWord64 s205 = s115 ? 0x0000000009de8d6dULL : s204; const SWord64 s206 = s112 ? 0x0000000006197ecbULL : s205; const SWord64 s207 = s109 ? 0x0000000003c50ea2ULL : s206; const SWord64 s208 = s106 ? 0x0000000002547029ULL : s207; const SWord64 s209 = s103 ? 0x0000000001709e79ULL : s208; const SWord64 s210 = s100 ? 0x0000000000e3d1b0ULL : s209; const SWord64 s211 = s97 ? 0x00000000008cccc9ULL : s210; const SWord64 s212 = s94 ? 0x00000000005704e7ULL : s211; const SWord64 s213 = s92 ? 0x000000000035c7e2ULL : s212; const SWord64 s214 = s89 ? 0x0000000000213d05ULL : s213; const SWord64 s215 = s86 ? 0x0000000000148addULL : s214; const SWord64 s216 = s83 ? 0x00000000000cb228ULL : s215; const SWord64 s217 = s80 ? 0x000000000007d8b5ULL : s216; const SWord64 s218 = s77 ? 0x000000000004d973ULL : s217; const SWord64 s219 = s74 ? 0x000000000002ff42ULL : s218; const SWord64 s220 = s71 ? 0x000000000001da31ULL : s219; const SWord64 s221 = s68 ? 0x0000000000012511ULL : s220; const SWord64 s222 = s65 ? 0x000000000000b520ULL : s221; const SWord64 s223 = s62 ? 0x0000000000006ff1ULL : s222; const SWord64 s224 = s59 ? 0x000000000000452fULL : s223; const SWord64 s225 = s56 ? 0x0000000000002ac2ULL : s224; const SWord64 s226 = s54 ? 0x0000000000001a6dULL : s225; const SWord64 s227 = s51 ? 0x0000000000001055ULL : s226; const SWord64 s228 = s48 ? 0x0000000000000a18ULL : s227; const SWord64 s229 = s45 ? 0x000000000000063dULL : s228; const SWord64 s230 = s42 ? 0x00000000000003dbULL : s229; const SWord64 s231 = s39 ? 0x0000000000000262ULL : s230; const SWord64 s232 = s36 ? 0x0000000000000179ULL : s231; const SWord64 s233 = s33 ? 0x00000000000000e9ULL : s232; const SWord64 s234 = s31 ? 0x0000000000000090ULL : s233; const SWord64 s235 = s28 ? 0x0000000000000059ULL : s234; const SWord64 s236 = s25 ? 0x0000000000000037ULL : s235; const SWord64 s237 = s22 ? 0x0000000000000022ULL : s236; const SWord64 s238 = s19 ? 0x0000000000000015ULL : s237; const SWord64 s239 = s17 ? 0x000000000000000dULL : s238; const SWord64 s240 = s14 ? 0x0000000000000008ULL : s239; const SWord64 s241 = s12 ? 0x0000000000000005ULL : s240; const SWord64 s242 = s10 ? 0x0000000000000003ULL : s241; const SWord64 s243 = s8 ? 0x0000000000000002ULL : s242; const SWord64 s244 = s6 ? 0x0000000000000001ULL : s243; const SWord64 s245 = s4 ? 0x0000000000000001ULL : s244; const SWord64 s246 = s2 ? 0x0000000000000000ULL : s245; return s246; } == END: "fib1.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/fib2.gold0000644000000000000000000000730712725411266016131 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for fib2. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: fib2_driver fib2.o: fib2.c fib2.h ${CC} ${CCFLAGS} -c $< -o $@ fib2_driver.o: fib2_driver.c ${CC} ${CCFLAGS} -c $< -o $@ fib2_driver: fib2.o fib2_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f fib2_driver == END: "Makefile" ================== == BEGIN: "fib2.h" ================ /* Header file for fib2. Automatically generated by SBV. Do not edit! */ #ifndef __fib2__HEADER_INCLUDED__ #define __fib2__HEADER_INCLUDED__ #include #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: */ SWord64 fib2(const SWord64 n); #endif /* __fib2__HEADER_INCLUDED__ */ == END: "fib2.h" ================== == BEGIN: "fib2_driver.c" ================ /* Example driver program for fib2. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "fib2.h" int main(void) { const SWord64 __result = fib2(0x0000000000000014ULL); printf("fib2(0x0000000000000014ULL) = 0x%016"PRIx64"ULL\n", __result); return 0; } == END: "fib2_driver.c" ================== == BEGIN: "fib2.c" ================ /* File: "fib2.c". Automatically generated by SBV. Do not edit! */ #include "fib2.h" SWord64 fib2(const SWord64 n) { const SWord64 s0 = n; static const SWord64 table0[] = { 0x0000000000000000ULL, 0x0000000000000001ULL, 0x0000000000000001ULL, 0x0000000000000002ULL, 0x0000000000000003ULL, 0x0000000000000005ULL, 0x0000000000000008ULL, 0x000000000000000dULL, 0x0000000000000015ULL, 0x0000000000000022ULL, 0x0000000000000037ULL, 0x0000000000000059ULL, 0x0000000000000090ULL, 0x00000000000000e9ULL, 0x0000000000000179ULL, 0x0000000000000262ULL, 0x00000000000003dbULL, 0x000000000000063dULL, 0x0000000000000a18ULL, 0x0000000000001055ULL, 0x0000000000001a6dULL, 0x0000000000002ac2ULL, 0x000000000000452fULL, 0x0000000000006ff1ULL, 0x000000000000b520ULL, 0x0000000000012511ULL, 0x000000000001da31ULL, 0x000000000002ff42ULL, 0x000000000004d973ULL, 0x000000000007d8b5ULL, 0x00000000000cb228ULL, 0x0000000000148addULL, 0x0000000000213d05ULL, 0x000000000035c7e2ULL, 0x00000000005704e7ULL, 0x00000000008cccc9ULL, 0x0000000000e3d1b0ULL, 0x0000000001709e79ULL, 0x0000000002547029ULL, 0x0000000003c50ea2ULL, 0x0000000006197ecbULL, 0x0000000009de8d6dULL, 0x000000000ff80c38ULL, 0x0000000019d699a5ULL, 0x0000000029cea5ddULL, 0x0000000043a53f82ULL, 0x000000006d73e55fULL, 0x00000000b11924e1ULL, 0x000000011e8d0a40ULL, 0x00000001cfa62f21ULL, 0x00000002ee333961ULL, 0x00000004bdd96882ULL, 0x00000007ac0ca1e3ULL, 0x0000000c69e60a65ULL, 0x0000001415f2ac48ULL, 0x000000207fd8b6adULL, 0x0000003495cb62f5ULL, 0x0000005515a419a2ULL, 0x00000089ab6f7c97ULL, 0x000000dec1139639ULL, 0x000001686c8312d0ULL, 0x000002472d96a909ULL, 0x000003af9a19bbd9ULL, 0x000005f6c7b064e2ULL, 0x000009a661ca20bbULL }; const SWord64 s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0]; return s65; } == END: "fib2.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/floats_cgen.gold0000644000000000000000000024035312725411266017573 0ustar0000000000000000== BEGIN: "toFP_Int8_ToFloat.c" ================ /* File: "toFP_Int8_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Int8_ToFloat(const SInt8 a) { const SInt8 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Int8_ToFloat.c" ================== == BEGIN: "toFP_Int16_ToFloat.c" ================ /* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Int16_ToFloat(const SInt16 a) { const SInt16 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Int16_ToFloat.c" ================== == BEGIN: "toFP_Int32_ToFloat.c" ================ /* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Int32_ToFloat(const SInt32 a) { const SInt32 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Int32_ToFloat.c" ================== == BEGIN: "toFP_Int64_ToFloat.c" ================ /* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Int64_ToFloat(const SInt64 a) { const SInt64 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Int64_ToFloat.c" ================== == BEGIN: "toFP_Word8_ToFloat.c" ================ /* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Word8_ToFloat(const SWord8 a) { const SWord8 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Word8_ToFloat.c" ================== == BEGIN: "toFP_Word16_ToFloat.c" ================ /* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Word16_ToFloat(const SWord16 a) { const SWord16 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Word16_ToFloat.c" ================== == BEGIN: "toFP_Word32_ToFloat.c" ================ /* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Word32_ToFloat(const SWord32 a) { const SWord32 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Word32_ToFloat.c" ================== == BEGIN: "toFP_Word64_ToFloat.c" ================ /* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Word64_ToFloat(const SWord64 a) { const SWord64 s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Word64_ToFloat.c" ================== == BEGIN: "toFP_Float_ToFloat.c" ================ /* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Float_ToFloat(const SFloat a) { const SFloat s0 = a; return s0; } == END: "toFP_Float_ToFloat.c" ================== == BEGIN: "toFP_Double_ToFloat.c" ================ /* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Double_ToFloat(const SDouble a) { const SDouble s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Double_ToFloat.c" ================== == BEGIN: "toFP_Integer_ToFloat.c" ================ /* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Integer_ToFloat(const SInteger a) { const SInteger s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Integer_ToFloat.c" ================== == BEGIN: "toFP_Real_ToFloat.c" ================ /* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat toFP_Real_ToFloat(const SReal a) { const SReal s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "toFP_Real_ToFloat.c" ================== == BEGIN: "toFP_Int8_ToDouble.c" ================ /* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Int8_ToDouble(const SInt8 a) { const SInt8 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Int8_ToDouble.c" ================== == BEGIN: "toFP_Int16_ToDouble.c" ================ /* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Int16_ToDouble(const SInt16 a) { const SInt16 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Int16_ToDouble.c" ================== == BEGIN: "toFP_Int32_ToDouble.c" ================ /* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Int32_ToDouble(const SInt32 a) { const SInt32 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Int32_ToDouble.c" ================== == BEGIN: "toFP_Int64_ToDouble.c" ================ /* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Int64_ToDouble(const SInt64 a) { const SInt64 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Int64_ToDouble.c" ================== == BEGIN: "toFP_Word8_ToDouble.c" ================ /* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Word8_ToDouble(const SWord8 a) { const SWord8 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Word8_ToDouble.c" ================== == BEGIN: "toFP_Word16_ToDouble.c" ================ /* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Word16_ToDouble(const SWord16 a) { const SWord16 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Word16_ToDouble.c" ================== == BEGIN: "toFP_Word32_ToDouble.c" ================ /* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Word32_ToDouble(const SWord32 a) { const SWord32 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Word32_ToDouble.c" ================== == BEGIN: "toFP_Word64_ToDouble.c" ================ /* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Word64_ToDouble(const SWord64 a) { const SWord64 s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Word64_ToDouble.c" ================== == BEGIN: "toFP_Float_ToDouble.c" ================ /* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Float_ToDouble(const SFloat a) { const SFloat s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Float_ToDouble.c" ================== == BEGIN: "toFP_Double_ToDouble.c" ================ /* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Double_ToDouble(const SDouble a) { const SDouble s0 = a; return s0; } == END: "toFP_Double_ToDouble.c" ================== == BEGIN: "toFP_Integer_ToDouble.c" ================ /* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Integer_ToDouble(const SInteger a) { const SInteger s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Integer_ToDouble.c" ================== == BEGIN: "toFP_Real_ToDouble.c" ================ /* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble toFP_Real_ToDouble(const SReal a) { const SReal s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "toFP_Real_ToDouble.c" ================== == BEGIN: "fromFP_Float_ToInt8.c" ================ /* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt8 fromFP_Float_ToInt8(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt8 s6 = (SInt8) s0; const SInt8 s8 = s4 ? s6 : 0; return s8; } == END: "fromFP_Float_ToInt8.c" ================== == BEGIN: "fromFP_Float_ToInt16.c" ================ /* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt16 fromFP_Float_ToInt16(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt16 s6 = (SInt16) s0; const SInt16 s8 = s4 ? s6 : 0x0000; return s8; } == END: "fromFP_Float_ToInt16.c" ================== == BEGIN: "fromFP_Float_ToInt32.c" ================ /* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt32 fromFP_Float_ToInt32(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt32 s6 = (SInt32) s0; const SInt32 s8 = s4 ? s6 : 0x00000000L; return s8; } == END: "fromFP_Float_ToInt32.c" ================== == BEGIN: "fromFP_Float_ToInt64.c" ================ /* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt64 fromFP_Float_ToInt64(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt64 s6 = (SInt64) s0; const SInt64 s8 = s4 ? s6 : 0x0000000000000000LL; return s8; } == END: "fromFP_Float_ToInt64.c" ================== == BEGIN: "fromFP_Float_ToWord8.c" ================ /* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord8 fromFP_Float_ToWord8(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord8 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabsf(s0))) : ((SWord8) s0); const SWord8 s8 = s4 ? s6 : 0; return s8; } == END: "fromFP_Float_ToWord8.c" ================== == BEGIN: "fromFP_Float_ToWord16.c" ================ /* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord16 fromFP_Float_ToWord16(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabsf(s0))) : ((SWord16) s0); const SWord16 s8 = s4 ? s6 : 0x0000U; return s8; } == END: "fromFP_Float_ToWord16.c" ================== == BEGIN: "fromFP_Float_ToWord32.c" ================ /* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord32 fromFP_Float_ToWord32(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabsf(s0))) : ((SWord32) s0); const SWord32 s8 = s4 ? s6 : 0x00000000UL; return s8; } == END: "fromFP_Float_ToWord32.c" ================== == BEGIN: "fromFP_Float_ToWord64.c" ================ /* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord64 fromFP_Float_ToWord64(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabsf(s0))) : ((SWord64) s0); const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL; return s8; } == END: "fromFP_Float_ToWord64.c" ================== == BEGIN: "fromFP_Float_ToFloat.c" ================ /* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat fromFP_Float_ToFloat(const SFloat a) { const SFloat s0 = a; return s0; } == END: "fromFP_Float_ToFloat.c" ================== == BEGIN: "fromFP_Float_ToDouble.c" ================ /* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble fromFP_Float_ToDouble(const SFloat a) { const SFloat s0 = a; const SDouble s2 = (SDouble) s0; return s2; } == END: "fromFP_Float_ToDouble.c" ================== == BEGIN: "fromFP_Float_ToInteger.c" ================ /* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInteger fromFP_Float_ToInteger(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInteger s6 = (SInteger) s0; const SInteger s8 = s4 ? s6 : 0x0000000000000000LL; return s8; } == END: "fromFP_Float_ToInteger.c" ================== == BEGIN: "fromFP_Float_ToReal.c" ================ /* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SReal fromFP_Float_ToReal(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SReal s6 = (SReal) s0; const SReal s8 = s4 ? s6 : 0.0L; return s8; } == END: "fromFP_Float_ToReal.c" ================== == BEGIN: "fromFP_DoubleTo_Int8.c" ================ /* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt8 fromFP_DoubleTo_Int8(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt8 s6 = (SInt8) s0; const SInt8 s8 = s4 ? s6 : 0; return s8; } == END: "fromFP_DoubleTo_Int8.c" ================== == BEGIN: "fromFP_DoubleTo_Int16.c" ================ /* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt16 fromFP_DoubleTo_Int16(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt16 s6 = (SInt16) s0; const SInt16 s8 = s4 ? s6 : 0x0000; return s8; } == END: "fromFP_DoubleTo_Int16.c" ================== == BEGIN: "fromFP_DoubleTo_Int32.c" ================ /* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt32 fromFP_DoubleTo_Int32(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt32 s6 = (SInt32) s0; const SInt32 s8 = s4 ? s6 : 0x00000000L; return s8; } == END: "fromFP_DoubleTo_Int32.c" ================== == BEGIN: "fromFP_DoubleTo_Int64.c" ================ /* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInt64 fromFP_DoubleTo_Int64(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInt64 s6 = (SInt64) s0; const SInt64 s8 = s4 ? s6 : 0x0000000000000000LL; return s8; } == END: "fromFP_DoubleTo_Int64.c" ================== == BEGIN: "fromFP_DoubleTo_Word8.c" ================ /* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord8 fromFP_DoubleTo_Word8(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord8 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabs(s0))) : ((SWord8) s0); const SWord8 s8 = s4 ? s6 : 0; return s8; } == END: "fromFP_DoubleTo_Word8.c" ================== == BEGIN: "fromFP_DoubleTo_Word16.c" ================ /* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord16 fromFP_DoubleTo_Word16(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabs(s0))) : ((SWord16) s0); const SWord16 s8 = s4 ? s6 : 0x0000U; return s8; } == END: "fromFP_DoubleTo_Word16.c" ================== == BEGIN: "fromFP_DoubleTo_Word32.c" ================ /* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord32 fromFP_DoubleTo_Word32(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabs(s0))) : ((SWord32) s0); const SWord32 s8 = s4 ? s6 : 0x00000000UL; return s8; } == END: "fromFP_DoubleTo_Word32.c" ================== == BEGIN: "fromFP_DoubleTo_Word64.c" ================ /* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord64 fromFP_DoubleTo_Word64(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabs(s0))) : ((SWord64) s0); const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL; return s8; } == END: "fromFP_DoubleTo_Word64.c" ================== == BEGIN: "fromFP_DoubleTo_Float.c" ================ /* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat fromFP_DoubleTo_Float(const SDouble a) { const SDouble s0 = a; const SFloat s2 = (SFloat) s0; return s2; } == END: "fromFP_DoubleTo_Float.c" ================== == BEGIN: "fromFP_DoubleTo_Double.c" ================ /* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble fromFP_DoubleTo_Double(const SDouble a) { const SDouble s0 = a; return s0; } == END: "fromFP_DoubleTo_Double.c" ================== == BEGIN: "fromFP_DoubleTo_Integer.c" ================ /* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SInteger fromFP_DoubleTo_Integer(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SInteger s6 = (SInteger) s0; const SInteger s8 = s4 ? s6 : 0x0000000000000000LL; return s8; } == END: "fromFP_DoubleTo_Integer.c" ================== == BEGIN: "fromFP_DoubleTo_Real.c" ================ /* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SReal fromFP_DoubleTo_Real(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); const SBool s2 = isinf(s0); const SBool s3 = s1 || s2; const SBool s4 = !s3; const SReal s6 = (SReal) s0; const SReal s8 = s4 ? s6 : 0.0L; return s8; } == END: "fromFP_DoubleTo_Real.c" ================== == BEGIN: "fromFP_SWord32_SFloat.c" ================ /* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat fromFP_SWord32_SFloat(const SWord32 a) { const SWord32 s0 = a; SFloat s1; memcpy(&s1, &s0, sizeof(SFloat)); return s1; } == END: "fromFP_SWord32_SFloat.c" ================== == BEGIN: "fromFP_SWord64_SDouble.c" ================ /* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble fromFP_SWord64_SDouble(const SWord64 a) { const SWord64 s0 = a; SDouble s1; memcpy(&s1, &s0, sizeof(SDouble)); return s1; } == END: "fromFP_SWord64_SDouble.c" ================== == BEGIN: "fromFP_SFloat_SWord32.c" ================ /* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord32 fromFP_SFloat_SWord32(const SFloat a) { const SFloat s0 = a; SWord32 s1; memcpy(&s1, &s0, sizeof(SWord32)); return s1; } == END: "fromFP_SFloat_SWord32.c" ================== == BEGIN: "fromFP_SDouble_SWord64.c" ================ /* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SWord64 fromFP_SDouble_SWord64(const SDouble a) { const SDouble s0 = a; SWord64 s1; memcpy(&s1, &s0, sizeof(SWord64)); return s1; } == END: "fromFP_SDouble_SWord64.c" ================== == BEGIN: "f_FP_Abs.c" ================ /* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Abs(const SFloat a) { const SFloat s0 = a; const SFloat s1 = fabsf(s0); return s1; } == END: "f_FP_Abs.c" ================== == BEGIN: "d_FP_Abs.c" ================ /* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Abs(const SDouble a) { const SDouble s0 = a; const SDouble s1 = fabs(s0); return s1; } == END: "d_FP_Abs.c" ================== == BEGIN: "f_FP_Neg.c" ================ /* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Neg(const SFloat a) { const SFloat s0 = a; const SFloat s1 = (- s0); return s1; } == END: "f_FP_Neg.c" ================== == BEGIN: "d_FP_Neg.c" ================ /* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Neg(const SDouble a) { const SDouble s0 = a; const SDouble s1 = (- s0); return s1; } == END: "d_FP_Neg.c" ================== == BEGIN: "f_FP_Add.c" ================ /* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Add(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s3 = s0 + s1; return s3; } == END: "f_FP_Add.c" ================== == BEGIN: "d_FP_Add.c" ================ /* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Add(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s3 = s0 + s1; return s3; } == END: "d_FP_Add.c" ================== == BEGIN: "f_FP_Sub.c" ================ /* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Sub(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s3 = s0 - s1; return s3; } == END: "f_FP_Sub.c" ================== == BEGIN: "d_FP_Sub.c" ================ /* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Sub(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s3 = s0 - s1; return s3; } == END: "d_FP_Sub.c" ================== == BEGIN: "f_FP_Mul.c" ================ /* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Mul(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s3 = s0 * s1; return s3; } == END: "f_FP_Mul.c" ================== == BEGIN: "d_FP_Mul.c" ================ /* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Mul(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s3 = s0 * s1; return s3; } == END: "d_FP_Mul.c" ================== == BEGIN: "f_FP_Div.c" ================ /* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Div(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s3 = s0 / s1; return s3; } == END: "f_FP_Div.c" ================== == BEGIN: "d_FP_Div.c" ================ /* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Div(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s3 = s0 / s1; return s3; } == END: "d_FP_Div.c" ================== == BEGIN: "f_FP_FMA.c" ================ /* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s2 = c; const SFloat s4 = fmaf(s0, s1, s2); return s4; } == END: "f_FP_FMA.c" ================== == BEGIN: "d_FP_FMA.c" ================ /* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_FMA(const SDouble a, const SDouble b, const SDouble c) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s2 = c; const SDouble s4 = fma(s0, s1, s2); return s4; } == END: "d_FP_FMA.c" ================== == BEGIN: "f_FP_Sqrt.c" ================ /* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Sqrt(const SFloat a) { const SFloat s0 = a; const SFloat s2 = sqrtf(s0); return s2; } == END: "f_FP_Sqrt.c" ================== == BEGIN: "d_FP_Sqrt.c" ================ /* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Sqrt(const SDouble a) { const SDouble s0 = a; const SDouble s2 = sqrt(s0); return s2; } == END: "d_FP_Sqrt.c" ================== == BEGIN: "f_FP_Rem.c" ================ /* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Rem(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s2 = fmodf(s0, s1); return s2; } == END: "f_FP_Rem.c" ================== == BEGIN: "d_FP_Rem.c" ================ /* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Rem(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s2 = fmod(s0, s1); return s2; } == END: "d_FP_Rem.c" ================== == BEGIN: "f_FP_RoundToIntegral.c" ================ /* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_RoundToIntegral(const SFloat a) { const SFloat s0 = a; const SFloat s2 = rintf(s0); return s2; } == END: "f_FP_RoundToIntegral.c" ================== == BEGIN: "d_FP_RoundToIntegral.c" ================ /* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_RoundToIntegral(const SDouble a) { const SDouble s0 = a; const SDouble s2 = rint(s0); return s2; } == END: "d_FP_RoundToIntegral.c" ================== == BEGIN: "f_FP_Min.c" ================ /* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Min(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fminf(s0, s1); return s2; } == END: "f_FP_Min.c" ================== == BEGIN: "d_FP_Min.c" ================ /* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Min(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmin(s0, s1); return s2; } == END: "d_FP_Min.c" ================== == BEGIN: "f_FP_Max.c" ================ /* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SFloat f_FP_Max(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fmaxf(s0, s1); return s2; } == END: "f_FP_Max.c" ================== == BEGIN: "d_FP_Max.c" ================ /* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SDouble d_FP_Max(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmax(s0, s1); return s2; } == END: "d_FP_Max.c" ================== == BEGIN: "f_FP_IsEqualObject.c" ================ /* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsEqualObject(const SFloat a, const SFloat b) { const SFloat s0 = a; const SFloat s1 = b; const SBool s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); return s2; } == END: "f_FP_IsEqualObject.c" ================== == BEGIN: "d_FP_IsEqualObject.c" ================ /* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsEqualObject(const SDouble a, const SDouble b) { const SDouble s0 = a; const SDouble s1 = b; const SBool s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1); return s2; } == END: "d_FP_IsEqualObject.c" ================== == BEGIN: "f_FP_IsNormal.c" ================ /* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsNormal(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnormal(s0); return s1; } == END: "f_FP_IsNormal.c" ================== == BEGIN: "d_FP_IsNormal.c" ================ /* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsNormal(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnormal(s0); return s1; } == END: "d_FP_IsNormal.c" ================== == BEGIN: "f_FP_IsZero.c" ================ /* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsZero(const SFloat a) { const SFloat s0 = a; const SBool s1 = FP_ZERO == fpclassify(s0); return s1; } == END: "f_FP_IsZero.c" ================== == BEGIN: "d_FP_IsZero.c" ================ /* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsZero(const SDouble a) { const SDouble s0 = a; const SBool s1 = FP_ZERO == fpclassify(s0); return s1; } == END: "d_FP_IsZero.c" ================== == BEGIN: "f_FP_IsSubnormal.c" ================ /* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsSubnormal(const SFloat a) { const SFloat s0 = a; const SBool s1 = FP_SUBNORMAL == fpclassify(s0); return s1; } == END: "f_FP_IsSubnormal.c" ================== == BEGIN: "d_FP_IsSubnormal.c" ================ /* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsSubnormal(const SDouble a) { const SDouble s0 = a; const SBool s1 = FP_SUBNORMAL == fpclassify(s0); return s1; } == END: "d_FP_IsSubnormal.c" ================== == BEGIN: "f_FP_IsInfinite.c" ================ /* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsInfinite(const SFloat a) { const SFloat s0 = a; const SBool s1 = isinf(s0); return s1; } == END: "f_FP_IsInfinite.c" ================== == BEGIN: "d_FP_IsInfinite.c" ================ /* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsInfinite(const SDouble a) { const SDouble s0 = a; const SBool s1 = isinf(s0); return s1; } == END: "d_FP_IsInfinite.c" ================== == BEGIN: "f_FP_IsNaN.c" ================ /* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsNaN(const SFloat a) { const SFloat s0 = a; const SBool s1 = isnan(s0); return s1; } == END: "f_FP_IsNaN.c" ================== == BEGIN: "d_FP_IsNaN.c" ================ /* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsNaN(const SDouble a) { const SDouble s0 = a; const SBool s1 = isnan(s0); return s1; } == END: "d_FP_IsNaN.c" ================== == BEGIN: "f_FP_IsNegative.c" ================ /* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsNegative(const SFloat a) { const SFloat s0 = a; const SBool s1 = !isnan(s0) && signbit(s0); return s1; } == END: "f_FP_IsNegative.c" ================== == BEGIN: "d_FP_IsNegative.c" ================ /* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsNegative(const SDouble a) { const SDouble s0 = a; const SBool s1 = !isnan(s0) && signbit(s0); return s1; } == END: "d_FP_IsNegative.c" ================== == BEGIN: "f_FP_IsPositive.c" ================ /* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool f_FP_IsPositive(const SFloat a) { const SFloat s0 = a; const SBool s1 = !isnan(s0) && !signbit(s0); return s1; } == END: "f_FP_IsPositive.c" ================== == BEGIN: "d_FP_IsPositive.c" ================ /* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */ #include "floatCodeGen.h" SBool d_FP_IsPositive(const SDouble a) { const SDouble s0 = a; const SBool s1 = !isnan(s0) && !signbit(s0); return s1; } == END: "d_FP_IsPositive.c" ================== == BEGIN: "floatCodeGen.h" ================ /* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */ #ifndef __floatCodeGen__HEADER_INCLUDED__ #define __floatCodeGen__HEADER_INCLUDED__ #include #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) = %.6g\n", __result); } void toFP_Int16_ToFloat_driver(void) { const SFloat __result = toFP_Int16_ToFloat(0x002a); printf("toFP_Int16_ToFloat(0x002a) = %.6g\n", __result); } void toFP_Int32_ToFloat_driver(void) { const SFloat __result = toFP_Int32_ToFloat(0x0000002aL); printf("toFP_Int32_ToFloat(0x0000002aL) = %.6g\n", __result); } void toFP_Int64_ToFloat_driver(void) { const SFloat __result = toFP_Int64_ToFloat(0x000000000000002aLL); printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %.6g\n", __result); } void toFP_Word8_ToFloat_driver(void) { const SFloat __result = toFP_Word8_ToFloat(42); printf("toFP_Word8_ToFloat(42) = %.6g\n", __result); } void toFP_Word16_ToFloat_driver(void) { const SFloat __result = toFP_Word16_ToFloat(0x002aU); printf("toFP_Word16_ToFloat(0x002aU) = %.6g\n", __result); } void toFP_Word32_ToFloat_driver(void) { const SFloat __result = toFP_Word32_ToFloat(0x0000002aUL); printf("toFP_Word32_ToFloat(0x0000002aUL) = %.6g\n", __result); } void toFP_Word64_ToFloat_driver(void) { const SFloat __result = toFP_Word64_ToFloat(0x000000000000002aULL); printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %.6g\n", __result); } void toFP_Float_ToFloat_driver(void) { const SFloat __result = toFP_Float_ToFloat(42.0F); printf("toFP_Float_ToFloat(42.0F) = %.6g\n", __result); } void toFP_Double_ToFloat_driver(void) { const SFloat __result = toFP_Double_ToFloat(42.0); printf("toFP_Double_ToFloat(42.0) = %.6g\n", __result); } void toFP_Integer_ToFloat_driver(void) { const SFloat __result = toFP_Integer_ToFloat(0x000000000000002aLL); printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %.6g\n", __result); } void toFP_Real_ToFloat_driver(void) { const SFloat __result = toFP_Real_ToFloat(42.0L); printf("toFP_Real_ToFloat(42.0L) = %.6g\n", __result); } void toFP_Int8_ToDouble_driver(void) { const SDouble __result = toFP_Int8_ToDouble(42); printf("toFP_Int8_ToDouble(42) = %.15g\n", __result); } void toFP_Int16_ToDouble_driver(void) { const SDouble __result = toFP_Int16_ToDouble(0x002a); printf("toFP_Int16_ToDouble(0x002a) = %.15g\n", __result); } void toFP_Int32_ToDouble_driver(void) { const SDouble __result = toFP_Int32_ToDouble(0x0000002aL); printf("toFP_Int32_ToDouble(0x0000002aL) = %.15g\n", __result); } void toFP_Int64_ToDouble_driver(void) { const SDouble __result = toFP_Int64_ToDouble(0x000000000000002aLL); printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %.15g\n", __result); } void toFP_Word8_ToDouble_driver(void) { const SDouble __result = toFP_Word8_ToDouble(42); printf("toFP_Word8_ToDouble(42) = %.15g\n", __result); } void toFP_Word16_ToDouble_driver(void) { const SDouble __result = toFP_Word16_ToDouble(0x002aU); printf("toFP_Word16_ToDouble(0x002aU) = %.15g\n", __result); } void toFP_Word32_ToDouble_driver(void) { const SDouble __result = toFP_Word32_ToDouble(0x0000002aUL); printf("toFP_Word32_ToDouble(0x0000002aUL) = %.15g\n", __result); } void toFP_Word64_ToDouble_driver(void) { const SDouble __result = toFP_Word64_ToDouble(0x000000000000002aULL); printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %.15g\n", __result); } void toFP_Float_ToDouble_driver(void) { const SDouble __result = toFP_Float_ToDouble(42.0F); printf("toFP_Float_ToDouble(42.0F) = %.15g\n", __result); } void toFP_Double_ToDouble_driver(void) { const SDouble __result = toFP_Double_ToDouble(42.0); printf("toFP_Double_ToDouble(42.0) = %.15g\n", __result); } void toFP_Integer_ToDouble_driver(void) { const SDouble __result = toFP_Integer_ToDouble(0x000000000000002aLL); printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %.15g\n", __result); } void toFP_Real_ToDouble_driver(void) { const SDouble __result = toFP_Real_ToDouble(42.0L); printf("toFP_Real_ToDouble(42.0L) = %.15g\n", __result); } void fromFP_Float_ToInt8_driver(void) { const SInt8 __result = fromFP_Float_ToInt8(42.0F); printf("fromFP_Float_ToInt8(42.0F) = %"PRId8"\n", __result); } void fromFP_Float_ToInt16_driver(void) { const SInt16 __result = fromFP_Float_ToInt16(42.0F); printf("fromFP_Float_ToInt16(42.0F) = %"PRId16"\n", __result); } void fromFP_Float_ToInt32_driver(void) { const SInt32 __result = fromFP_Float_ToInt32(42.0F); printf("fromFP_Float_ToInt32(42.0F) = %"PRId32"L\n", __result); } void fromFP_Float_ToInt64_driver(void) { const SInt64 __result = fromFP_Float_ToInt64(42.0F); printf("fromFP_Float_ToInt64(42.0F) = %"PRId64"LL\n", __result); } void fromFP_Float_ToWord8_driver(void) { const SWord8 __result = fromFP_Float_ToWord8(42.0F); printf("fromFP_Float_ToWord8(42.0F) = %"PRIu8"\n", __result); } void fromFP_Float_ToWord16_driver(void) { const SWord16 __result = fromFP_Float_ToWord16(42.0F); printf("fromFP_Float_ToWord16(42.0F) = 0x%04"PRIx16"U\n", __result); } void fromFP_Float_ToWord32_driver(void) { const SWord32 __result = fromFP_Float_ToWord32(42.0F); printf("fromFP_Float_ToWord32(42.0F) = 0x%08"PRIx32"UL\n", __result); } void fromFP_Float_ToWord64_driver(void) { const SWord64 __result = fromFP_Float_ToWord64(42.0F); printf("fromFP_Float_ToWord64(42.0F) = 0x%016"PRIx64"ULL\n", __result); } void fromFP_Float_ToFloat_driver(void) { const SFloat __result = fromFP_Float_ToFloat(42.0F); printf("fromFP_Float_ToFloat(42.0F) = %.6g\n", __result); } void fromFP_Float_ToDouble_driver(void) { const SDouble __result = fromFP_Float_ToDouble(42.0F); printf("fromFP_Float_ToDouble(42.0F) = %.15g\n", __result); } void fromFP_Float_ToInteger_driver(void) { const SInteger __result = fromFP_Float_ToInteger(42.0F); printf("fromFP_Float_ToInteger(42.0F) = %"PRId64"LL\n", __result); } void fromFP_Float_ToReal_driver(void) { const SReal __result = fromFP_Float_ToReal(42.0F); printf("fromFP_Float_ToReal(42.0F) = %Lf\n", __result); } void fromFP_DoubleTo_Int8_driver(void) { const SInt8 __result = fromFP_DoubleTo_Int8(42.0); printf("fromFP_DoubleTo_Int8(42.0) = %"PRId8"\n", __result); } void fromFP_DoubleTo_Int16_driver(void) { const SInt16 __result = fromFP_DoubleTo_Int16(42.0); printf("fromFP_DoubleTo_Int16(42.0) = %"PRId16"\n", __result); } void fromFP_DoubleTo_Int32_driver(void) { const SInt32 __result = fromFP_DoubleTo_Int32(42.0); printf("fromFP_DoubleTo_Int32(42.0) = %"PRId32"L\n", __result); } void fromFP_DoubleTo_Int64_driver(void) { const SInt64 __result = fromFP_DoubleTo_Int64(42.0); printf("fromFP_DoubleTo_Int64(42.0) = %"PRId64"LL\n", __result); } void fromFP_DoubleTo_Word8_driver(void) { const SWord8 __result = fromFP_DoubleTo_Word8(42.0); printf("fromFP_DoubleTo_Word8(42.0) = %"PRIu8"\n", __result); } void fromFP_DoubleTo_Word16_driver(void) { const SWord16 __result = fromFP_DoubleTo_Word16(42.0); printf("fromFP_DoubleTo_Word16(42.0) = 0x%04"PRIx16"U\n", __result); } void fromFP_DoubleTo_Word32_driver(void) { const SWord32 __result = fromFP_DoubleTo_Word32(42.0); printf("fromFP_DoubleTo_Word32(42.0) = 0x%08"PRIx32"UL\n", __result); } void fromFP_DoubleTo_Word64_driver(void) { const SWord64 __result = fromFP_DoubleTo_Word64(42.0); printf("fromFP_DoubleTo_Word64(42.0) = 0x%016"PRIx64"ULL\n", __result); } void fromFP_DoubleTo_Float_driver(void) { const SFloat __result = fromFP_DoubleTo_Float(42.0); printf("fromFP_DoubleTo_Float(42.0) = %.6g\n", __result); } void fromFP_DoubleTo_Double_driver(void) { const SDouble __result = fromFP_DoubleTo_Double(42.0); printf("fromFP_DoubleTo_Double(42.0) = %.15g\n", __result); } void fromFP_DoubleTo_Integer_driver(void) { const SInteger __result = fromFP_DoubleTo_Integer(42.0); printf("fromFP_DoubleTo_Integer(42.0) = %"PRId64"LL\n", __result); } void fromFP_DoubleTo_Real_driver(void) { const SReal __result = fromFP_DoubleTo_Real(42.0); printf("fromFP_DoubleTo_Real(42.0) = %Lf\n", __result); } void fromFP_SWord32_SFloat_driver(void) { const SFloat __result = fromFP_SWord32_SFloat(0x0000002aUL); printf("fromFP_SWord32_SFloat(0x0000002aUL) = %.6g\n", __result); } void fromFP_SWord64_SDouble_driver(void) { const SDouble __result = fromFP_SWord64_SDouble(0x000000000000002aULL); printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %.15g\n", __result); } void fromFP_SFloat_SWord32_driver(void) { const SWord32 __result = fromFP_SFloat_SWord32(42.0F); printf("fromFP_SFloat_SWord32(42.0F) = 0x%08"PRIx32"UL\n", __result); } void fromFP_SDouble_SWord64_driver(void) { const SWord64 __result = fromFP_SDouble_SWord64(42.0); printf("fromFP_SDouble_SWord64(42.0) = 0x%016"PRIx64"ULL\n", __result); } void f_FP_Abs_driver(void) { const SFloat __result = f_FP_Abs(42.0F); printf("f_FP_Abs(42.0F) = %.6g\n", __result); } void d_FP_Abs_driver(void) { const SDouble __result = d_FP_Abs(42.0); printf("d_FP_Abs(42.0) = %.15g\n", __result); } void f_FP_Neg_driver(void) { const SFloat __result = f_FP_Neg(42.0F); printf("f_FP_Neg(42.0F) = %.6g\n", __result); } void d_FP_Neg_driver(void) { const SDouble __result = d_FP_Neg(42.0); printf("d_FP_Neg(42.0) = %.15g\n", __result); } void f_FP_Add_driver(void) { const SFloat __result = f_FP_Add(42.0F, 43.0F); printf("f_FP_Add(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Add_driver(void) { const SDouble __result = d_FP_Add(42.0, 43.0); printf("d_FP_Add(42.0, 43.0) = %.15g\n", __result); } void f_FP_Sub_driver(void) { const SFloat __result = f_FP_Sub(42.0F, 43.0F); printf("f_FP_Sub(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Sub_driver(void) { const SDouble __result = d_FP_Sub(42.0, 43.0); printf("d_FP_Sub(42.0, 43.0) = %.15g\n", __result); } void f_FP_Mul_driver(void) { const SFloat __result = f_FP_Mul(42.0F, 43.0F); printf("f_FP_Mul(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Mul_driver(void) { const SDouble __result = d_FP_Mul(42.0, 43.0); printf("d_FP_Mul(42.0, 43.0) = %.15g\n", __result); } void f_FP_Div_driver(void) { const SFloat __result = f_FP_Div(42.0F, 43.0F); printf("f_FP_Div(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Div_driver(void) { const SDouble __result = d_FP_Div(42.0, 43.0); printf("d_FP_Div(42.0, 43.0) = %.15g\n", __result); } void f_FP_FMA_driver(void) { const SFloat __result = f_FP_FMA(42.0F, 43.0F, 44.0F); printf("f_FP_FMA(42.0F, 43.0F, 44.0F) = %.6g\n", __result); } void d_FP_FMA_driver(void) { const SDouble __result = d_FP_FMA(42.0, 43.0, 44.0); printf("d_FP_FMA(42.0, 43.0, 44.0) = %.15g\n", __result); } void f_FP_Sqrt_driver(void) { const SFloat __result = f_FP_Sqrt(42.0F); printf("f_FP_Sqrt(42.0F) = %.6g\n", __result); } void d_FP_Sqrt_driver(void) { const SDouble __result = d_FP_Sqrt(42.0); printf("d_FP_Sqrt(42.0) = %.15g\n", __result); } void f_FP_Rem_driver(void) { const SFloat __result = f_FP_Rem(42.0F, 43.0F); printf("f_FP_Rem(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Rem_driver(void) { const SDouble __result = d_FP_Rem(42.0, 43.0); printf("d_FP_Rem(42.0, 43.0) = %.15g\n", __result); } void f_FP_RoundToIntegral_driver(void) { const SFloat __result = f_FP_RoundToIntegral(42.0F); printf("f_FP_RoundToIntegral(42.0F) = %.6g\n", __result); } void d_FP_RoundToIntegral_driver(void) { const SDouble __result = d_FP_RoundToIntegral(42.0); printf("d_FP_RoundToIntegral(42.0) = %.15g\n", __result); } void f_FP_Min_driver(void) { const SFloat __result = f_FP_Min(42.0F, 43.0F); printf("f_FP_Min(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Min_driver(void) { const SDouble __result = d_FP_Min(42.0, 43.0); printf("d_FP_Min(42.0, 43.0) = %.15g\n", __result); } void f_FP_Max_driver(void) { const SFloat __result = f_FP_Max(42.0F, 43.0F); printf("f_FP_Max(42.0F, 43.0F) = %.6g\n", __result); } void d_FP_Max_driver(void) { const SDouble __result = d_FP_Max(42.0, 43.0); printf("d_FP_Max(42.0, 43.0) = %.15g\n", __result); } void f_FP_IsEqualObject_driver(void) { const SBool __result = f_FP_IsEqualObject(42.0F, 43.0F); printf("f_FP_IsEqualObject(42.0F, 43.0F) = %d\n", __result); } void d_FP_IsEqualObject_driver(void) { const SBool __result = d_FP_IsEqualObject(42.0, 43.0); printf("d_FP_IsEqualObject(42.0, 43.0) = %d\n", __result); } void f_FP_IsNormal_driver(void) { const SBool __result = f_FP_IsNormal(42.0F); printf("f_FP_IsNormal(42.0F) = %d\n", __result); } void d_FP_IsNormal_driver(void) { const SBool __result = d_FP_IsNormal(42.0); printf("d_FP_IsNormal(42.0) = %d\n", __result); } void f_FP_IsZero_driver(void) { const SBool __result = f_FP_IsZero(42.0F); printf("f_FP_IsZero(42.0F) = %d\n", __result); } void d_FP_IsZero_driver(void) { const SBool __result = d_FP_IsZero(42.0); printf("d_FP_IsZero(42.0) = %d\n", __result); } void f_FP_IsSubnormal_driver(void) { const SBool __result = f_FP_IsSubnormal(42.0F); printf("f_FP_IsSubnormal(42.0F) = %d\n", __result); } void d_FP_IsSubnormal_driver(void) { const SBool __result = d_FP_IsSubnormal(42.0); printf("d_FP_IsSubnormal(42.0) = %d\n", __result); } void f_FP_IsInfinite_driver(void) { const SBool __result = f_FP_IsInfinite(42.0F); printf("f_FP_IsInfinite(42.0F) = %d\n", __result); } void d_FP_IsInfinite_driver(void) { const SBool __result = d_FP_IsInfinite(42.0); printf("d_FP_IsInfinite(42.0) = %d\n", __result); } void f_FP_IsNaN_driver(void) { const SBool __result = f_FP_IsNaN(42.0F); printf("f_FP_IsNaN(42.0F) = %d\n", __result); } void d_FP_IsNaN_driver(void) { const SBool __result = d_FP_IsNaN(42.0); printf("d_FP_IsNaN(42.0) = %d\n", __result); } void f_FP_IsNegative_driver(void) { const SBool __result = f_FP_IsNegative(42.0F); printf("f_FP_IsNegative(42.0F) = %d\n", __result); } void d_FP_IsNegative_driver(void) { const SBool __result = d_FP_IsNegative(42.0); printf("d_FP_IsNegative(42.0) = %d\n", __result); } void f_FP_IsPositive_driver(void) { const SBool __result = f_FP_IsPositive(42.0F); printf("f_FP_IsPositive(42.0F) = %d\n", __result); } void d_FP_IsPositive_driver(void) { const SBool __result = d_FP_IsPositive(42.0); printf("d_FP_IsPositive(42.0) = %d\n", __result); } int main(void) { printf("====================================\n"); printf("** Driver run for toFP_Int8_ToFloat:\n"); printf("====================================\n"); toFP_Int8_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Int16_ToFloat:\n"); printf("=====================================\n"); toFP_Int16_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Int32_ToFloat:\n"); printf("=====================================\n"); toFP_Int32_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Int64_ToFloat:\n"); printf("=====================================\n"); toFP_Int64_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Word8_ToFloat:\n"); printf("=====================================\n"); toFP_Word8_ToFloat_driver(); printf("======================================\n"); printf("** Driver run for toFP_Word16_ToFloat:\n"); printf("======================================\n"); toFP_Word16_ToFloat_driver(); printf("======================================\n"); printf("** Driver run for toFP_Word32_ToFloat:\n"); printf("======================================\n"); toFP_Word32_ToFloat_driver(); printf("======================================\n"); printf("** Driver run for toFP_Word64_ToFloat:\n"); printf("======================================\n"); toFP_Word64_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Float_ToFloat:\n"); printf("=====================================\n"); toFP_Float_ToFloat_driver(); printf("======================================\n"); printf("** Driver run for toFP_Double_ToFloat:\n"); printf("======================================\n"); toFP_Double_ToFloat_driver(); printf("=======================================\n"); printf("** Driver run for toFP_Integer_ToFloat:\n"); printf("=======================================\n"); toFP_Integer_ToFloat_driver(); printf("====================================\n"); printf("** Driver run for toFP_Real_ToFloat:\n"); printf("====================================\n"); toFP_Real_ToFloat_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Int8_ToDouble:\n"); printf("=====================================\n"); toFP_Int8_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for toFP_Int16_ToDouble:\n"); printf("======================================\n"); toFP_Int16_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for toFP_Int32_ToDouble:\n"); printf("======================================\n"); toFP_Int32_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for toFP_Int64_ToDouble:\n"); printf("======================================\n"); toFP_Int64_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for toFP_Word8_ToDouble:\n"); printf("======================================\n"); toFP_Word8_ToDouble_driver(); printf("=======================================\n"); printf("** Driver run for toFP_Word16_ToDouble:\n"); printf("=======================================\n"); toFP_Word16_ToDouble_driver(); printf("=======================================\n"); printf("** Driver run for toFP_Word32_ToDouble:\n"); printf("=======================================\n"); toFP_Word32_ToDouble_driver(); printf("=======================================\n"); printf("** Driver run for toFP_Word64_ToDouble:\n"); printf("=======================================\n"); toFP_Word64_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for toFP_Float_ToDouble:\n"); printf("======================================\n"); toFP_Float_ToDouble_driver(); printf("=======================================\n"); printf("** Driver run for toFP_Double_ToDouble:\n"); printf("=======================================\n"); toFP_Double_ToDouble_driver(); printf("========================================\n"); printf("** Driver run for toFP_Integer_ToDouble:\n"); printf("========================================\n"); toFP_Integer_ToDouble_driver(); printf("=====================================\n"); printf("** Driver run for toFP_Real_ToDouble:\n"); printf("=====================================\n"); toFP_Real_ToDouble_driver(); printf("======================================\n"); printf("** Driver run for fromFP_Float_ToInt8:\n"); printf("======================================\n"); fromFP_Float_ToInt8_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_Float_ToInt16:\n"); printf("=======================================\n"); fromFP_Float_ToInt16_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_Float_ToInt32:\n"); printf("=======================================\n"); fromFP_Float_ToInt32_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_Float_ToInt64:\n"); printf("=======================================\n"); fromFP_Float_ToInt64_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_Float_ToWord8:\n"); printf("=======================================\n"); fromFP_Float_ToWord8_driver(); printf("========================================\n"); printf("** Driver run for fromFP_Float_ToWord16:\n"); printf("========================================\n"); fromFP_Float_ToWord16_driver(); printf("========================================\n"); printf("** Driver run for fromFP_Float_ToWord32:\n"); printf("========================================\n"); fromFP_Float_ToWord32_driver(); printf("========================================\n"); printf("** Driver run for fromFP_Float_ToWord64:\n"); printf("========================================\n"); fromFP_Float_ToWord64_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_Float_ToFloat:\n"); printf("=======================================\n"); fromFP_Float_ToFloat_driver(); printf("========================================\n"); printf("** Driver run for fromFP_Float_ToDouble:\n"); printf("========================================\n"); fromFP_Float_ToDouble_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_Float_ToInteger:\n"); printf("=========================================\n"); fromFP_Float_ToInteger_driver(); printf("======================================\n"); printf("** Driver run for fromFP_Float_ToReal:\n"); printf("======================================\n"); fromFP_Float_ToReal_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_DoubleTo_Int8:\n"); printf("=======================================\n"); fromFP_DoubleTo_Int8_driver(); printf("========================================\n"); printf("** Driver run for fromFP_DoubleTo_Int16:\n"); printf("========================================\n"); fromFP_DoubleTo_Int16_driver(); printf("========================================\n"); printf("** Driver run for fromFP_DoubleTo_Int32:\n"); printf("========================================\n"); fromFP_DoubleTo_Int32_driver(); printf("========================================\n"); printf("** Driver run for fromFP_DoubleTo_Int64:\n"); printf("========================================\n"); fromFP_DoubleTo_Int64_driver(); printf("========================================\n"); printf("** Driver run for fromFP_DoubleTo_Word8:\n"); printf("========================================\n"); fromFP_DoubleTo_Word8_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_DoubleTo_Word16:\n"); printf("=========================================\n"); fromFP_DoubleTo_Word16_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_DoubleTo_Word32:\n"); printf("=========================================\n"); fromFP_DoubleTo_Word32_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_DoubleTo_Word64:\n"); printf("=========================================\n"); fromFP_DoubleTo_Word64_driver(); printf("========================================\n"); printf("** Driver run for fromFP_DoubleTo_Float:\n"); printf("========================================\n"); fromFP_DoubleTo_Float_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_DoubleTo_Double:\n"); printf("=========================================\n"); fromFP_DoubleTo_Double_driver(); printf("==========================================\n"); printf("** Driver run for fromFP_DoubleTo_Integer:\n"); printf("==========================================\n"); fromFP_DoubleTo_Integer_driver(); printf("=======================================\n"); printf("** Driver run for fromFP_DoubleTo_Real:\n"); printf("=======================================\n"); fromFP_DoubleTo_Real_driver(); printf("========================================\n"); printf("** Driver run for fromFP_SWord32_SFloat:\n"); printf("========================================\n"); fromFP_SWord32_SFloat_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_SWord64_SDouble:\n"); printf("=========================================\n"); fromFP_SWord64_SDouble_driver(); printf("========================================\n"); printf("** Driver run for fromFP_SFloat_SWord32:\n"); printf("========================================\n"); fromFP_SFloat_SWord32_driver(); printf("=========================================\n"); printf("** Driver run for fromFP_SDouble_SWord64:\n"); printf("=========================================\n"); fromFP_SDouble_SWord64_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Abs:\n"); printf("===========================\n"); f_FP_Abs_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Abs:\n"); printf("===========================\n"); d_FP_Abs_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Neg:\n"); printf("===========================\n"); f_FP_Neg_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Neg:\n"); printf("===========================\n"); d_FP_Neg_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Add:\n"); printf("===========================\n"); f_FP_Add_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Add:\n"); printf("===========================\n"); d_FP_Add_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Sub:\n"); printf("===========================\n"); f_FP_Sub_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Sub:\n"); printf("===========================\n"); d_FP_Sub_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Mul:\n"); printf("===========================\n"); f_FP_Mul_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Mul:\n"); printf("===========================\n"); d_FP_Mul_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Div:\n"); printf("===========================\n"); f_FP_Div_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Div:\n"); printf("===========================\n"); d_FP_Div_driver(); printf("===========================\n"); printf("** Driver run for f_FP_FMA:\n"); printf("===========================\n"); f_FP_FMA_driver(); printf("===========================\n"); printf("** Driver run for d_FP_FMA:\n"); printf("===========================\n"); d_FP_FMA_driver(); printf("============================\n"); printf("** Driver run for f_FP_Sqrt:\n"); printf("============================\n"); f_FP_Sqrt_driver(); printf("============================\n"); printf("** Driver run for d_FP_Sqrt:\n"); printf("============================\n"); d_FP_Sqrt_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Rem:\n"); printf("===========================\n"); f_FP_Rem_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Rem:\n"); printf("===========================\n"); d_FP_Rem_driver(); printf("=======================================\n"); printf("** Driver run for f_FP_RoundToIntegral:\n"); printf("=======================================\n"); f_FP_RoundToIntegral_driver(); printf("=======================================\n"); printf("** Driver run for d_FP_RoundToIntegral:\n"); printf("=======================================\n"); d_FP_RoundToIntegral_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Min:\n"); printf("===========================\n"); f_FP_Min_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Min:\n"); printf("===========================\n"); d_FP_Min_driver(); printf("===========================\n"); printf("** Driver run for f_FP_Max:\n"); printf("===========================\n"); f_FP_Max_driver(); printf("===========================\n"); printf("** Driver run for d_FP_Max:\n"); printf("===========================\n"); d_FP_Max_driver(); printf("=====================================\n"); printf("** Driver run for f_FP_IsEqualObject:\n"); printf("=====================================\n"); f_FP_IsEqualObject_driver(); printf("=====================================\n"); printf("** Driver run for d_FP_IsEqualObject:\n"); printf("=====================================\n"); d_FP_IsEqualObject_driver(); printf("================================\n"); printf("** Driver run for f_FP_IsNormal:\n"); printf("================================\n"); f_FP_IsNormal_driver(); printf("================================\n"); printf("** Driver run for d_FP_IsNormal:\n"); printf("================================\n"); d_FP_IsNormal_driver(); printf("==============================\n"); printf("** Driver run for f_FP_IsZero:\n"); printf("==============================\n"); f_FP_IsZero_driver(); printf("==============================\n"); printf("** Driver run for d_FP_IsZero:\n"); printf("==============================\n"); d_FP_IsZero_driver(); printf("===================================\n"); printf("** Driver run for f_FP_IsSubnormal:\n"); printf("===================================\n"); f_FP_IsSubnormal_driver(); printf("===================================\n"); printf("** Driver run for d_FP_IsSubnormal:\n"); printf("===================================\n"); d_FP_IsSubnormal_driver(); printf("==================================\n"); printf("** Driver run for f_FP_IsInfinite:\n"); printf("==================================\n"); f_FP_IsInfinite_driver(); printf("==================================\n"); printf("** Driver run for d_FP_IsInfinite:\n"); printf("==================================\n"); d_FP_IsInfinite_driver(); printf("=============================\n"); printf("** Driver run for f_FP_IsNaN:\n"); printf("=============================\n"); f_FP_IsNaN_driver(); printf("=============================\n"); printf("** Driver run for d_FP_IsNaN:\n"); printf("=============================\n"); d_FP_IsNaN_driver(); printf("==================================\n"); printf("** Driver run for f_FP_IsNegative:\n"); printf("==================================\n"); f_FP_IsNegative_driver(); printf("==================================\n"); printf("** Driver run for d_FP_IsNegative:\n"); printf("==================================\n"); d_FP_IsNegative_driver(); printf("==================================\n"); printf("** Driver run for f_FP_IsPositive:\n"); printf("==================================\n"); f_FP_IsPositive_driver(); printf("==================================\n"); printf("** Driver run for d_FP_IsPositive:\n"); printf("==================================\n"); d_FP_IsPositive_driver(); return 0; } == END: "floatCodeGen_driver.c" ================== == BEGIN: "Makefile" ================ # Makefile for floatCodeGen. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer AR?=ar ARFLAGS?=cr all: floatCodeGen.a floatCodeGen_driver floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o ${AR} ${ARFLAGS} $@ $^ floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h ${CC} ${CCFLAGS} $< -o $@ floatCodeGen.a toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Add.o: f_FP_Add.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Add.o: d_FP_Add.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Div.o: f_FP_Div.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Div.o: d_FP_Div.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Min.o: f_FP_Min.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Min.o: d_FP_Min.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_Max.o: f_FP_Max.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_Max.o: d_FP_Max.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h ${CC} ${CCFLAGS} -c $< -o $@ clean: rm -f *.o veryclean: clean rm -f floatCodeGen.a floatCodeGen_driver == END: "Makefile" ==================sbv-5.12/SBVUnitTest/GoldFiles/gcd.gold0000644000000000000000000000731412725411266016042 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for sgcd. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: sgcd_driver sgcd.o: sgcd.c sgcd.h ${CC} ${CCFLAGS} -c $< -o $@ sgcd_driver.o: sgcd_driver.c ${CC} ${CCFLAGS} -c $< -o $@ sgcd_driver: sgcd.o sgcd_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f sgcd_driver == END: "Makefile" ================== == BEGIN: "sgcd.h" ================ /* Header file for sgcd. Automatically generated by SBV. Do not edit! */ #ifndef __sgcd__HEADER_INCLUDED__ #define __sgcd__HEADER_INCLUDED__ #include #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: */ SWord8 sgcd(const SWord8 x, const SWord8 y); #endif /* __sgcd__HEADER_INCLUDED__ */ == END: "sgcd.h" ================== == BEGIN: "sgcd_driver.c" ================ /* Example driver program for sgcd. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "sgcd.h" int main(void) { const SWord8 __result = sgcd(55, 154); printf("sgcd(55, 154) = %"PRIu8"\n", __result); return 0; } == END: "sgcd_driver.c" ================== == BEGIN: "sgcd.c" ================ /* File: "sgcd.c". Automatically generated by SBV. Do not edit! */ #include "sgcd.h" SWord8 sgcd(const SWord8 x, const SWord8 y) { const SWord8 s0 = x; const SWord8 s1 = y; const SBool s3 = s1 == 0; const SWord8 s4 = (s1 == 0) ? s0 : (s0 % s1); const SWord8 s5 = s3 ? s0 : s4; const SBool s6 = 0 == s5; const SWord8 s7 = (s5 == 0) ? s1 : (s1 % s5); const SWord8 s8 = s6 ? s1 : s7; const SBool s9 = 0 == s8; const SWord8 s10 = (s8 == 0) ? s5 : (s5 % s8); const SWord8 s11 = s9 ? s5 : s10; const SBool s12 = 0 == s11; const SWord8 s13 = (s11 == 0) ? s8 : (s8 % s11); const SWord8 s14 = s12 ? s8 : s13; const SBool s15 = 0 == s14; const SWord8 s16 = (s14 == 0) ? s11 : (s11 % s14); const SWord8 s17 = s15 ? s11 : s16; const SBool s18 = 0 == s17; const SWord8 s19 = (s17 == 0) ? s14 : (s14 % s17); const SWord8 s20 = s18 ? s14 : s19; const SBool s21 = 0 == s20; const SWord8 s22 = (s20 == 0) ? s17 : (s17 % s20); const SWord8 s23 = s21 ? s17 : s22; const SBool s24 = 0 == s23; const SWord8 s25 = (s23 == 0) ? s20 : (s20 % s23); const SWord8 s26 = s24 ? s20 : s25; const SBool s27 = 0 == s26; const SWord8 s28 = (s26 == 0) ? s23 : (s23 % s26); const SWord8 s29 = s27 ? s23 : s28; const SBool s30 = 0 == s29; const SWord8 s31 = (s29 == 0) ? s26 : (s26 % s29); const SWord8 s32 = s30 ? s26 : s31; const SBool s33 = 0 == s32; const SWord8 s34 = (s32 == 0) ? s29 : (s29 % s32); const SWord8 s35 = s33 ? s29 : s34; const SBool s36 = 0 == s35; const SWord8 s37 = s36 ? s32 : s35; const SWord8 s38 = s33 ? s29 : s37; const SWord8 s39 = s30 ? s26 : s38; const SWord8 s40 = s27 ? s23 : s39; const SWord8 s41 = s24 ? s20 : s40; const SWord8 s42 = s21 ? s17 : s41; const SWord8 s43 = s18 ? s14 : s42; const SWord8 s44 = s15 ? s11 : s43; const SWord8 s45 = s12 ? s8 : s44; const SWord8 s46 = s9 ? s5 : s45; const SWord8 s47 = s6 ? s1 : s46; const SWord8 s48 = s3 ? s0 : s47; return s48; } == END: "sgcd.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/higher-1.gold0000644000000000000000000000000612725411266016700 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-2.gold0000644000000000000000000000000612725411266016701 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-3.gold0000644000000000000000000000000612725411266016702 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-4.gold0000644000000000000000000000000612725411266016703 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-5.gold0000644000000000000000000000000612725411266016704 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-6.gold0000644000000000000000000000000612725411266016705 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-7.gold0000644000000000000000000000000612725411266016706 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-8.gold0000644000000000000000000000000612725411266016707 0ustar0000000000000000Q.E.D.sbv-5.12/SBVUnitTest/GoldFiles/higher-9.gold0000644000000000000000000000006112725411266016711 0ustar0000000000000000Falsifiable. Counter-example: s0 = 128 :: Word8sbv-5.12/SBVUnitTest/GoldFiles/iteTest1.gold0000644000000000000000000000030412725411266016777 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE CONSTRAINTS ASSERTIONS OUTPUTSsbv-5.12/SBVUnitTest/GoldFiles/iteTest2.gold0000644000000000000000000000030412725411266017000 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE CONSTRAINTS ASSERTIONS OUTPUTSsbv-5.12/SBVUnitTest/GoldFiles/iteTest3.gold0000644000000000000000000000030412725411266017001 0ustar0000000000000000INPUTS s0 :: SWord8, aliasing "x" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE CONSTRAINTS ASSERTIONS OUTPUTSsbv-5.12/SBVUnitTest/GoldFiles/legato.gold0000644000000000000000000123505412725411266016565 0ustar0000000000000000INPUTS s0 :: SWord32, existential, aliasing "addrX" s1 :: SWord8, existential, aliasing "x" s2 :: SWord32, existential, aliasing "addrY" s3 :: SWord8, existential, aliasing "y" s4 :: SWord32, existential, aliasing "addrLow" s5 :: SWord8, existential, aliasing "regX" s6 :: SWord8, existential, aliasing "regA" s7 :: SWord8, existential, aliasing "memVals" s8 :: SBool, existential, aliasing "flagC" s9 :: SBool, existential, aliasing "flagZ" CONSTANTS s_2 = False :: Bool s_1 = True :: Bool s19 = 0 :: Word1 s17 = 0 :: Word8 s24 = 128 :: Word8 s26 = 127 :: Word8 s16 = 256 :: Word16 TABLES ARRAYS UNINTERPRETED CONSTANTS USER GIVEN CODE SEGMENTS AXIOMS DEFINE s10 :: SBool = s0 /= s2 s11 :: SBool = s0 /= s4 s12 :: SBool = s10 & s11 s13 :: SBool = s2 /= s4 s14 :: SBool = s12 & s13 s15 :: SBool = ~ s14 s18 :: SWord1 = choose [0:0] s1 s20 :: SBool = s18 /= s19 s21 :: SBool = s_2 == s20 s22 :: SBool = s0 == s4 s23 :: SWord8 = s1 >>> 1 s25 :: SWord8 = s23 | s24 s27 :: SWord8 = s23 & s26 s28 :: SWord8 = if s8 then s25 else s27 s29 :: SBool = s2 == s4 s30 :: SWord8 = if s29 then s3 else s7 s31 :: SWord8 = if s22 then s1 else s30 s32 :: SWord8 = if s22 then s28 else s31 s33 :: SWord8 = s32 >>> 1 s34 :: SWord8 = s26 & s33 s35 :: SWord8 = if s22 then s34 else s28 s36 :: SWord1 = choose [0:0] s35 s37 :: SBool = s19 /= s36 s38 :: SBool = s_2 == s37 s39 :: SWord8 = if s20 then s24 else s17 s40 :: SWord1 = choose [0:0] s39 s41 :: SBool = s19 /= s40 s42 :: SWord1 = choose [0:0] s32 s43 :: SBool = s19 /= s42 s44 :: SWord8 = s35 >>> 1 s45 :: SWord8 = s24 | s44 s46 :: SWord8 = s26 & s44 s47 :: SWord8 = if s43 then s45 else s46 s48 :: SWord8 = if s22 then s47 else s34 s49 :: SWord8 = s48 >>> 1 s50 :: SWord8 = s24 | s49 s51 :: SWord8 = s26 & s49 s52 :: SWord8 = if s41 then s50 else s51 s53 :: SWord8 = if s22 then s52 else s47 s54 :: SWord1 = choose [0:0] s53 s55 :: SBool = s19 /= s54 s56 :: SBool = s_2 == s55 s57 :: SWord8 = s39 >>> 1 s58 :: SWord8 = s24 | s57 s59 :: SWord8 = s26 & s57 s60 :: SWord8 = if s37 then s58 else s59 s61 :: SWord1 = choose [0:0] s60 s62 :: SBool = s19 /= s61 s63 :: SWord1 = choose [0:0] s48 s64 :: SBool = s19 /= s63 s65 :: SWord8 = s53 >>> 1 s66 :: SWord8 = s24 | s65 s67 :: SWord8 = s26 & s65 s68 :: SWord8 = if s64 then s66 else s67 s69 :: SWord8 = if s22 then s68 else s52 s70 :: SWord8 = s69 >>> 1 s71 :: SWord8 = s24 | s70 s72 :: SWord8 = s26 & s70 s73 :: SWord8 = if s62 then s71 else s72 s74 :: SWord8 = if s22 then s73 else s68 s75 :: SWord1 = choose [0:0] s74 s76 :: SBool = s19 /= s75 s77 :: SBool = s_2 == s76 s78 :: SWord8 = s60 >>> 1 s79 :: SWord8 = s24 | s78 s80 :: SWord8 = s26 & s78 s81 :: SWord8 = if s55 then s79 else s80 s82 :: SWord1 = choose [0:0] s81 s83 :: SBool = s19 /= s82 s84 :: SWord1 = choose [0:0] s69 s85 :: SBool = s19 /= s84 s86 :: SWord8 = s74 >>> 1 s87 :: SWord8 = s24 | s86 s88 :: SWord8 = s26 & s86 s89 :: SWord8 = if s85 then s87 else s88 s90 :: SWord8 = if s22 then s89 else s73 s91 :: SWord8 = s90 >>> 1 s92 :: SWord8 = s24 | s91 s93 :: SWord8 = s26 & s91 s94 :: SWord8 = if s83 then s92 else s93 s95 :: SWord8 = if s22 then s94 else s89 s96 :: SWord1 = choose [0:0] s95 s97 :: SBool = s19 /= s96 s98 :: SBool = s_2 == s97 s99 :: SWord8 = s81 >>> 1 s100 :: SWord8 = s24 | s99 s101 :: SWord8 = s26 & s99 s102 :: SWord8 = if s76 then s100 else s101 s103 :: SWord1 = choose [0:0] s102 s104 :: SBool = s19 /= s103 s105 :: SWord1 = choose [0:0] s90 s106 :: SBool = s19 /= s105 s107 :: SWord8 = s95 >>> 1 s108 :: SWord8 = s24 | s107 s109 :: SWord8 = s26 & s107 s110 :: SWord8 = if s106 then s108 else s109 s111 :: SWord8 = if s22 then s110 else s94 s112 :: SWord8 = s111 >>> 1 s113 :: SWord8 = s24 | s112 s114 :: SWord8 = s26 & s112 s115 :: SWord8 = if s104 then s113 else s114 s116 :: SWord8 = if s22 then s115 else s110 s117 :: SWord1 = choose [0:0] s116 s118 :: SBool = s19 /= s117 s119 :: SBool = s_2 == s118 s120 :: SWord8 = s102 >>> 1 s121 :: SWord8 = s24 | s120 s122 :: SWord8 = s26 & s120 s123 :: SWord8 = if s97 then s121 else s122 s124 :: SWord1 = choose [0:0] s123 s125 :: SBool = s19 /= s124 s126 :: SWord1 = choose [0:0] s111 s127 :: SBool = s19 /= s126 s128 :: SWord8 = s116 >>> 1 s129 :: SWord8 = s24 | s128 s130 :: SWord8 = s26 & s128 s131 :: SWord8 = if s127 then s129 else s130 s132 :: SWord8 = if s22 then s131 else s115 s133 :: SWord8 = s132 >>> 1 s134 :: SWord8 = s24 | s133 s135 :: SWord8 = s26 & s133 s136 :: SWord8 = if s125 then s134 else s135 s137 :: SWord8 = if s22 then s136 else s131 s138 :: SWord1 = choose [0:0] s137 s139 :: SBool = s19 /= s138 s140 :: SBool = s_2 == s139 s141 :: SWord8 = s123 >>> 1 s142 :: SWord8 = s24 | s141 s143 :: SWord8 = s26 & s141 s144 :: SWord8 = if s118 then s142 else s143 s145 :: SWord1 = choose [0:0] s144 s146 :: SBool = s19 /= s145 s147 :: SWord1 = choose [0:0] s132 s148 :: SBool = s19 /= s147 s149 :: SWord8 = s137 >>> 1 s150 :: SWord8 = s24 | s149 s151 :: SWord8 = s26 & s149 s152 :: SWord8 = if s148 then s150 else s151 s153 :: SWord8 = if s22 then s152 else s136 s154 :: SWord8 = s153 >>> 1 s155 :: SWord8 = s24 | s154 s156 :: SWord8 = s26 & s154 s157 :: SWord8 = if s146 then s155 else s156 s158 :: SWord8 = if s22 then s157 else s152 s159 :: SWord1 = choose [0:0] s158 s160 :: SBool = s19 /= s159 s161 :: SBool = s_2 == s160 s162 :: SWord8 = s144 >>> 1 s163 :: SWord8 = s24 | s162 s164 :: SWord8 = s26 & s162 s165 :: SWord8 = if s139 then s163 else s164 s166 :: SWord8 = s165 >>> 1 s167 :: SWord8 = s24 | s166 s168 :: SWord8 = s26 & s166 s169 :: SWord8 = if s160 then s167 else s168 s170 :: SBool = s0 == s2 s171 :: SWord1 = choose [0:0] s153 s172 :: SBool = s19 /= s171 s173 :: SWord8 = s158 >>> 1 s174 :: SWord8 = s24 | s173 s175 :: SWord8 = s26 & s173 s176 :: SWord8 = if s172 then s174 else s175 s177 :: SWord8 = if s170 then s1 else s3 s178 :: SWord8 = if s170 then s28 else s177 s179 :: SWord8 = if s29 then s34 else s178 s180 :: SWord8 = if s170 then s47 else s179 s181 :: SWord8 = if s29 then s52 else s180 s182 :: SWord8 = if s170 then s68 else s181 s183 :: SWord8 = if s29 then s73 else s182 s184 :: SWord8 = if s170 then s89 else s183 s185 :: SWord8 = if s29 then s94 else s184 s186 :: SWord8 = if s170 then s110 else s185 s187 :: SWord8 = if s29 then s115 else s186 s188 :: SWord8 = if s170 then s131 else s187 s189 :: SWord8 = if s29 then s136 else s188 s190 :: SWord8 = if s170 then s152 else s189 s191 :: SWord8 = if s29 then s157 else s190 s192 :: SWord8 = if s170 then s176 else s191 s193 :: SWord8 = s165 + s192 s194 :: SBool = s193 < s192 s195 :: SBool = s193 < s165 s196 :: SBool = s194 | s195 s197 :: SWord8 = s193 >>> 1 s198 :: SWord8 = s24 | s197 s199 :: SWord8 = s26 & s197 s200 :: SWord8 = if s196 then s198 else s199 s201 :: SWord8 = if s161 then s169 else s200 s202 :: SWord8 = s144 + s190 s203 :: SWord1 = choose [0:0] s202 s204 :: SBool = s19 /= s203 s205 :: SWord8 = if s204 then s155 else s156 s206 :: SWord8 = if s22 then s205 else s152 s207 :: SWord1 = choose [0:0] s206 s208 :: SBool = s19 /= s207 s209 :: SBool = s_2 == s208 s210 :: SBool = s202 < s190 s211 :: SBool = s202 < s144 s212 :: SBool = s210 | s211 s213 :: SWord8 = s202 >>> 1 s214 :: SWord8 = s24 | s213 s215 :: SWord8 = s26 & s213 s216 :: SWord8 = if s212 then s214 else s215 s217 :: SWord8 = s216 >>> 1 s218 :: SWord8 = s24 | s217 s219 :: SWord8 = s26 & s217 s220 :: SWord8 = if s208 then s218 else s219 s221 :: SWord8 = s206 >>> 1 s222 :: SWord8 = s24 | s221 s223 :: SWord8 = s26 & s221 s224 :: SWord8 = if s172 then s222 else s223 s225 :: SWord8 = if s29 then s205 else s190 s226 :: SWord8 = if s170 then s224 else s225 s227 :: SWord8 = s216 + s226 s228 :: SBool = s227 < s226 s229 :: SBool = s227 < s216 s230 :: SBool = s228 | s229 s231 :: SWord8 = s227 >>> 1 s232 :: SWord8 = s24 | s231 s233 :: SWord8 = s26 & s231 s234 :: SWord8 = if s230 then s232 else s233 s235 :: SWord8 = if s209 then s220 else s234 s236 :: SWord8 = if s140 then s201 else s235 s237 :: SWord8 = s123 + s188 s238 :: SWord1 = choose [0:0] s237 s239 :: SBool = s19 /= s238 s240 :: SWord8 = if s239 then s134 else s135 s241 :: SWord8 = if s22 then s240 else s131 s242 :: SWord1 = choose [0:0] s241 s243 :: SBool = s19 /= s242 s244 :: SBool = s_2 == s243 s245 :: SBool = s237 < s188 s246 :: SBool = s237 < s123 s247 :: SBool = s245 | s246 s248 :: SWord8 = s237 >>> 1 s249 :: SWord8 = s24 | s248 s250 :: SWord8 = s26 & s248 s251 :: SWord8 = if s247 then s249 else s250 s252 :: SWord1 = choose [0:0] s251 s253 :: SBool = s19 /= s252 s254 :: SWord8 = s241 >>> 1 s255 :: SWord8 = s24 | s254 s256 :: SWord8 = s26 & s254 s257 :: SWord8 = if s148 then s255 else s256 s258 :: SWord8 = if s22 then s257 else s240 s259 :: SWord8 = s258 >>> 1 s260 :: SWord8 = s24 | s259 s261 :: SWord8 = s26 & s259 s262 :: SWord8 = if s253 then s260 else s261 s263 :: SWord8 = if s22 then s262 else s257 s264 :: SWord1 = choose [0:0] s263 s265 :: SBool = s19 /= s264 s266 :: SBool = s_2 == s265 s267 :: SWord8 = s251 >>> 1 s268 :: SWord8 = s24 | s267 s269 :: SWord8 = s26 & s267 s270 :: SWord8 = if s243 then s268 else s269 s271 :: SWord8 = s270 >>> 1 s272 :: SWord8 = s24 | s271 s273 :: SWord8 = s26 & s271 s274 :: SWord8 = if s265 then s272 else s273 s275 :: SWord1 = choose [0:0] s258 s276 :: SBool = s19 /= s275 s277 :: SWord8 = s263 >>> 1 s278 :: SWord8 = s24 | s277 s279 :: SWord8 = s26 & s277 s280 :: SWord8 = if s276 then s278 else s279 s281 :: SWord8 = if s29 then s240 else s188 s282 :: SWord8 = if s170 then s257 else s281 s283 :: SWord8 = if s29 then s262 else s282 s284 :: SWord8 = if s170 then s280 else s283 s285 :: SWord8 = s270 + s284 s286 :: SBool = s285 < s284 s287 :: SBool = s285 < s270 s288 :: SBool = s286 | s287 s289 :: SWord8 = s285 >>> 1 s290 :: SWord8 = s24 | s289 s291 :: SWord8 = s26 & s289 s292 :: SWord8 = if s288 then s290 else s291 s293 :: SWord8 = if s266 then s274 else s292 s294 :: SWord8 = s251 + s282 s295 :: SWord1 = choose [0:0] s294 s296 :: SBool = s19 /= s295 s297 :: SWord8 = if s296 then s260 else s261 s298 :: SWord8 = if s22 then s297 else s257 s299 :: SWord1 = choose [0:0] s298 s300 :: SBool = s19 /= s299 s301 :: SBool = s_2 == s300 s302 :: SBool = s294 < s282 s303 :: SBool = s294 < s251 s304 :: SBool = s302 | s303 s305 :: SWord8 = s294 >>> 1 s306 :: SWord8 = s24 | s305 s307 :: SWord8 = s26 & s305 s308 :: SWord8 = if s304 then s306 else s307 s309 :: SWord8 = s308 >>> 1 s310 :: SWord8 = s24 | s309 s311 :: SWord8 = s26 & s309 s312 :: SWord8 = if s300 then s310 else s311 s313 :: SWord8 = s298 >>> 1 s314 :: SWord8 = s24 | s313 s315 :: SWord8 = s26 & s313 s316 :: SWord8 = if s276 then s314 else s315 s317 :: SWord8 = if s29 then s297 else s282 s318 :: SWord8 = if s170 then s316 else s317 s319 :: SWord8 = s308 + s318 s320 :: SBool = s319 < s318 s321 :: SBool = s319 < s308 s322 :: SBool = s320 | s321 s323 :: SWord8 = s319 >>> 1 s324 :: SWord8 = s24 | s323 s325 :: SWord8 = s26 & s323 s326 :: SWord8 = if s322 then s324 else s325 s327 :: SWord8 = if s301 then s312 else s326 s328 :: SWord8 = if s244 then s293 else s327 s329 :: SWord8 = if s119 then s236 else s328 s330 :: SWord8 = s102 + s186 s331 :: SWord1 = choose [0:0] s330 s332 :: SBool = s19 /= s331 s333 :: SWord8 = if s332 then s113 else s114 s334 :: SWord8 = if s22 then s333 else s110 s335 :: SWord1 = choose [0:0] s334 s336 :: SBool = s19 /= s335 s337 :: SBool = s_2 == s336 s338 :: SBool = s330 < s186 s339 :: SBool = s330 < s102 s340 :: SBool = s338 | s339 s341 :: SWord8 = s330 >>> 1 s342 :: SWord8 = s24 | s341 s343 :: SWord8 = s26 & s341 s344 :: SWord8 = if s340 then s342 else s343 s345 :: SWord1 = choose [0:0] s344 s346 :: SBool = s19 /= s345 s347 :: SWord8 = s334 >>> 1 s348 :: SWord8 = s24 | s347 s349 :: SWord8 = s26 & s347 s350 :: SWord8 = if s127 then s348 else s349 s351 :: SWord8 = if s22 then s350 else s333 s352 :: SWord8 = s351 >>> 1 s353 :: SWord8 = s24 | s352 s354 :: SWord8 = s26 & s352 s355 :: SWord8 = if s346 then s353 else s354 s356 :: SWord8 = if s22 then s355 else s350 s357 :: SWord1 = choose [0:0] s356 s358 :: SBool = s19 /= s357 s359 :: SBool = s_2 == s358 s360 :: SWord8 = s344 >>> 1 s361 :: SWord8 = s24 | s360 s362 :: SWord8 = s26 & s360 s363 :: SWord8 = if s336 then s361 else s362 s364 :: SWord1 = choose [0:0] s363 s365 :: SBool = s19 /= s364 s366 :: SWord1 = choose [0:0] s351 s367 :: SBool = s19 /= s366 s368 :: SWord8 = s356 >>> 1 s369 :: SWord8 = s24 | s368 s370 :: SWord8 = s26 & s368 s371 :: SWord8 = if s367 then s369 else s370 s372 :: SWord8 = if s22 then s371 else s355 s373 :: SWord8 = s372 >>> 1 s374 :: SWord8 = s24 | s373 s375 :: SWord8 = s26 & s373 s376 :: SWord8 = if s365 then s374 else s375 s377 :: SWord8 = if s22 then s376 else s371 s378 :: SWord1 = choose [0:0] s377 s379 :: SBool = s19 /= s378 s380 :: SBool = s_2 == s379 s381 :: SWord8 = s363 >>> 1 s382 :: SWord8 = s24 | s381 s383 :: SWord8 = s26 & s381 s384 :: SWord8 = if s358 then s382 else s383 s385 :: SWord8 = s384 >>> 1 s386 :: SWord8 = s24 | s385 s387 :: SWord8 = s26 & s385 s388 :: SWord8 = if s379 then s386 else s387 s389 :: SWord1 = choose [0:0] s372 s390 :: SBool = s19 /= s389 s391 :: SWord8 = s377 >>> 1 s392 :: SWord8 = s24 | s391 s393 :: SWord8 = s26 & s391 s394 :: SWord8 = if s390 then s392 else s393 s395 :: SWord8 = if s29 then s333 else s186 s396 :: SWord8 = if s170 then s350 else s395 s397 :: SWord8 = if s29 then s355 else s396 s398 :: SWord8 = if s170 then s371 else s397 s399 :: SWord8 = if s29 then s376 else s398 s400 :: SWord8 = if s170 then s394 else s399 s401 :: SWord8 = s384 + s400 s402 :: SBool = s401 < s400 s403 :: SBool = s401 < s384 s404 :: SBool = s402 | s403 s405 :: SWord8 = s401 >>> 1 s406 :: SWord8 = s24 | s405 s407 :: SWord8 = s26 & s405 s408 :: SWord8 = if s404 then s406 else s407 s409 :: SWord8 = if s380 then s388 else s408 s410 :: SWord8 = s363 + s398 s411 :: SWord1 = choose [0:0] s410 s412 :: SBool = s19 /= s411 s413 :: SWord8 = if s412 then s374 else s375 s414 :: SWord8 = if s22 then s413 else s371 s415 :: SWord1 = choose [0:0] s414 s416 :: SBool = s19 /= s415 s417 :: SBool = s_2 == s416 s418 :: SBool = s410 < s398 s419 :: SBool = s410 < s363 s420 :: SBool = s418 | s419 s421 :: SWord8 = s410 >>> 1 s422 :: SWord8 = s24 | s421 s423 :: SWord8 = s26 & s421 s424 :: SWord8 = if s420 then s422 else s423 s425 :: SWord8 = s424 >>> 1 s426 :: SWord8 = s24 | s425 s427 :: SWord8 = s26 & s425 s428 :: SWord8 = if s416 then s426 else s427 s429 :: SWord8 = s414 >>> 1 s430 :: SWord8 = s24 | s429 s431 :: SWord8 = s26 & s429 s432 :: SWord8 = if s390 then s430 else s431 s433 :: SWord8 = if s29 then s413 else s398 s434 :: SWord8 = if s170 then s432 else s433 s435 :: SWord8 = s424 + s434 s436 :: SBool = s435 < s434 s437 :: SBool = s435 < s424 s438 :: SBool = s436 | s437 s439 :: SWord8 = s435 >>> 1 s440 :: SWord8 = s24 | s439 s441 :: SWord8 = s26 & s439 s442 :: SWord8 = if s438 then s440 else s441 s443 :: SWord8 = if s417 then s428 else s442 s444 :: SWord8 = if s359 then s409 else s443 s445 :: SWord8 = s344 + s396 s446 :: SWord1 = choose [0:0] s445 s447 :: SBool = s19 /= s446 s448 :: SWord8 = if s447 then s353 else s354 s449 :: SWord8 = if s22 then s448 else s350 s450 :: SWord1 = choose [0:0] s449 s451 :: SBool = s19 /= s450 s452 :: SBool = s_2 == s451 s453 :: SBool = s445 < s396 s454 :: SBool = s445 < s344 s455 :: SBool = s453 | s454 s456 :: SWord8 = s445 >>> 1 s457 :: SWord8 = s24 | s456 s458 :: SWord8 = s26 & s456 s459 :: SWord8 = if s455 then s457 else s458 s460 :: SWord1 = choose [0:0] s459 s461 :: SBool = s19 /= s460 s462 :: SWord8 = s449 >>> 1 s463 :: SWord8 = s24 | s462 s464 :: SWord8 = s26 & s462 s465 :: SWord8 = if s367 then s463 else s464 s466 :: SWord8 = if s22 then s465 else s448 s467 :: SWord8 = s466 >>> 1 s468 :: SWord8 = s24 | s467 s469 :: SWord8 = s26 & s467 s470 :: SWord8 = if s461 then s468 else s469 s471 :: SWord8 = if s22 then s470 else s465 s472 :: SWord1 = choose [0:0] s471 s473 :: SBool = s19 /= s472 s474 :: SBool = s_2 == s473 s475 :: SWord8 = s459 >>> 1 s476 :: SWord8 = s24 | s475 s477 :: SWord8 = s26 & s475 s478 :: SWord8 = if s451 then s476 else s477 s479 :: SWord8 = s478 >>> 1 s480 :: SWord8 = s24 | s479 s481 :: SWord8 = s26 & s479 s482 :: SWord8 = if s473 then s480 else s481 s483 :: SWord1 = choose [0:0] s466 s484 :: SBool = s19 /= s483 s485 :: SWord8 = s471 >>> 1 s486 :: SWord8 = s24 | s485 s487 :: SWord8 = s26 & s485 s488 :: SWord8 = if s484 then s486 else s487 s489 :: SWord8 = if s29 then s448 else s396 s490 :: SWord8 = if s170 then s465 else s489 s491 :: SWord8 = if s29 then s470 else s490 s492 :: SWord8 = if s170 then s488 else s491 s493 :: SWord8 = s478 + s492 s494 :: SBool = s493 < s492 s495 :: SBool = s493 < s478 s496 :: SBool = s494 | s495 s497 :: SWord8 = s493 >>> 1 s498 :: SWord8 = s24 | s497 s499 :: SWord8 = s26 & s497 s500 :: SWord8 = if s496 then s498 else s499 s501 :: SWord8 = if s474 then s482 else s500 s502 :: SWord8 = s459 + s490 s503 :: SWord1 = choose [0:0] s502 s504 :: SBool = s19 /= s503 s505 :: SWord8 = if s504 then s468 else s469 s506 :: SWord8 = if s22 then s505 else s465 s507 :: SWord1 = choose [0:0] s506 s508 :: SBool = s19 /= s507 s509 :: SBool = s_2 == s508 s510 :: SBool = s502 < s490 s511 :: SBool = s502 < s459 s512 :: SBool = s510 | s511 s513 :: SWord8 = s502 >>> 1 s514 :: SWord8 = s24 | s513 s515 :: SWord8 = s26 & s513 s516 :: SWord8 = if s512 then s514 else s515 s517 :: SWord8 = s516 >>> 1 s518 :: SWord8 = s24 | s517 s519 :: SWord8 = s26 & s517 s520 :: SWord8 = if s508 then s518 else s519 s521 :: SWord8 = s506 >>> 1 s522 :: SWord8 = s24 | s521 s523 :: SWord8 = s26 & s521 s524 :: SWord8 = if s484 then s522 else s523 s525 :: SWord8 = if s29 then s505 else s490 s526 :: SWord8 = if s170 then s524 else s525 s527 :: SWord8 = s516 + s526 s528 :: SBool = s527 < s526 s529 :: SBool = s527 < s516 s530 :: SBool = s528 | s529 s531 :: SWord8 = s527 >>> 1 s532 :: SWord8 = s24 | s531 s533 :: SWord8 = s26 & s531 s534 :: SWord8 = if s530 then s532 else s533 s535 :: SWord8 = if s509 then s520 else s534 s536 :: SWord8 = if s452 then s501 else s535 s537 :: SWord8 = if s337 then s444 else s536 s538 :: SWord8 = if s98 then s329 else s537 s539 :: SWord8 = s81 + s184 s540 :: SWord1 = choose [0:0] s539 s541 :: SBool = s19 /= s540 s542 :: SWord8 = if s541 then s92 else s93 s543 :: SWord8 = if s22 then s542 else s89 s544 :: SWord1 = choose [0:0] s543 s545 :: SBool = s19 /= s544 s546 :: SBool = s_2 == s545 s547 :: SBool = s539 < s184 s548 :: SBool = s539 < s81 s549 :: SBool = s547 | s548 s550 :: SWord8 = s539 >>> 1 s551 :: SWord8 = s24 | s550 s552 :: SWord8 = s26 & s550 s553 :: SWord8 = if s549 then s551 else s552 s554 :: SWord1 = choose [0:0] s553 s555 :: SBool = s19 /= s554 s556 :: SWord8 = s543 >>> 1 s557 :: SWord8 = s24 | s556 s558 :: SWord8 = s26 & s556 s559 :: SWord8 = if s106 then s557 else s558 s560 :: SWord8 = if s22 then s559 else s542 s561 :: SWord8 = s560 >>> 1 s562 :: SWord8 = s24 | s561 s563 :: SWord8 = s26 & s561 s564 :: SWord8 = if s555 then s562 else s563 s565 :: SWord8 = if s22 then s564 else s559 s566 :: SWord1 = choose [0:0] s565 s567 :: SBool = s19 /= s566 s568 :: SBool = s_2 == s567 s569 :: SWord8 = s553 >>> 1 s570 :: SWord8 = s24 | s569 s571 :: SWord8 = s26 & s569 s572 :: SWord8 = if s545 then s570 else s571 s573 :: SWord1 = choose [0:0] s572 s574 :: SBool = s19 /= s573 s575 :: SWord1 = choose [0:0] s560 s576 :: SBool = s19 /= s575 s577 :: SWord8 = s565 >>> 1 s578 :: SWord8 = s24 | s577 s579 :: SWord8 = s26 & s577 s580 :: SWord8 = if s576 then s578 else s579 s581 :: SWord8 = if s22 then s580 else s564 s582 :: SWord8 = s581 >>> 1 s583 :: SWord8 = s24 | s582 s584 :: SWord8 = s26 & s582 s585 :: SWord8 = if s574 then s583 else s584 s586 :: SWord8 = if s22 then s585 else s580 s587 :: SWord1 = choose [0:0] s586 s588 :: SBool = s19 /= s587 s589 :: SBool = s_2 == s588 s590 :: SWord8 = s572 >>> 1 s591 :: SWord8 = s24 | s590 s592 :: SWord8 = s26 & s590 s593 :: SWord8 = if s567 then s591 else s592 s594 :: SWord1 = choose [0:0] s593 s595 :: SBool = s19 /= s594 s596 :: SWord1 = choose [0:0] s581 s597 :: SBool = s19 /= s596 s598 :: SWord8 = s586 >>> 1 s599 :: SWord8 = s24 | s598 s600 :: SWord8 = s26 & s598 s601 :: SWord8 = if s597 then s599 else s600 s602 :: SWord8 = if s22 then s601 else s585 s603 :: SWord8 = s602 >>> 1 s604 :: SWord8 = s24 | s603 s605 :: SWord8 = s26 & s603 s606 :: SWord8 = if s595 then s604 else s605 s607 :: SWord8 = if s22 then s606 else s601 s608 :: SWord1 = choose [0:0] s607 s609 :: SBool = s19 /= s608 s610 :: SBool = s_2 == s609 s611 :: SWord8 = s593 >>> 1 s612 :: SWord8 = s24 | s611 s613 :: SWord8 = s26 & s611 s614 :: SWord8 = if s588 then s612 else s613 s615 :: SWord8 = s614 >>> 1 s616 :: SWord8 = s24 | s615 s617 :: SWord8 = s26 & s615 s618 :: SWord8 = if s609 then s616 else s617 s619 :: SWord1 = choose [0:0] s602 s620 :: SBool = s19 /= s619 s621 :: SWord8 = s607 >>> 1 s622 :: SWord8 = s24 | s621 s623 :: SWord8 = s26 & s621 s624 :: SWord8 = if s620 then s622 else s623 s625 :: SWord8 = if s29 then s542 else s184 s626 :: SWord8 = if s170 then s559 else s625 s627 :: SWord8 = if s29 then s564 else s626 s628 :: SWord8 = if s170 then s580 else s627 s629 :: SWord8 = if s29 then s585 else s628 s630 :: SWord8 = if s170 then s601 else s629 s631 :: SWord8 = if s29 then s606 else s630 s632 :: SWord8 = if s170 then s624 else s631 s633 :: SWord8 = s614 + s632 s634 :: SBool = s633 < s632 s635 :: SBool = s633 < s614 s636 :: SBool = s634 | s635 s637 :: SWord8 = s633 >>> 1 s638 :: SWord8 = s24 | s637 s639 :: SWord8 = s26 & s637 s640 :: SWord8 = if s636 then s638 else s639 s641 :: SWord8 = if s610 then s618 else s640 s642 :: SWord8 = s593 + s630 s643 :: SWord1 = choose [0:0] s642 s644 :: SBool = s19 /= s643 s645 :: SWord8 = if s644 then s604 else s605 s646 :: SWord8 = if s22 then s645 else s601 s647 :: SWord1 = choose [0:0] s646 s648 :: SBool = s19 /= s647 s649 :: SBool = s_2 == s648 s650 :: SBool = s642 < s630 s651 :: SBool = s642 < s593 s652 :: SBool = s650 | s651 s653 :: SWord8 = s642 >>> 1 s654 :: SWord8 = s24 | s653 s655 :: SWord8 = s26 & s653 s656 :: SWord8 = if s652 then s654 else s655 s657 :: SWord8 = s656 >>> 1 s658 :: SWord8 = s24 | s657 s659 :: SWord8 = s26 & s657 s660 :: SWord8 = if s648 then s658 else s659 s661 :: SWord8 = s646 >>> 1 s662 :: SWord8 = s24 | s661 s663 :: SWord8 = s26 & s661 s664 :: SWord8 = if s620 then s662 else s663 s665 :: SWord8 = if s29 then s645 else s630 s666 :: SWord8 = if s170 then s664 else s665 s667 :: SWord8 = s656 + s666 s668 :: SBool = s667 < s666 s669 :: SBool = s667 < s656 s670 :: SBool = s668 | s669 s671 :: SWord8 = s667 >>> 1 s672 :: SWord8 = s24 | s671 s673 :: SWord8 = s26 & s671 s674 :: SWord8 = if s670 then s672 else s673 s675 :: SWord8 = if s649 then s660 else s674 s676 :: SWord8 = if s589 then s641 else s675 s677 :: SWord8 = s572 + s628 s678 :: SWord1 = choose [0:0] s677 s679 :: SBool = s19 /= s678 s680 :: SWord8 = if s679 then s583 else s584 s681 :: SWord8 = if s22 then s680 else s580 s682 :: SWord1 = choose [0:0] s681 s683 :: SBool = s19 /= s682 s684 :: SBool = s_2 == s683 s685 :: SBool = s677 < s628 s686 :: SBool = s677 < s572 s687 :: SBool = s685 | s686 s688 :: SWord8 = s677 >>> 1 s689 :: SWord8 = s24 | s688 s690 :: SWord8 = s26 & s688 s691 :: SWord8 = if s687 then s689 else s690 s692 :: SWord1 = choose [0:0] s691 s693 :: SBool = s19 /= s692 s694 :: SWord8 = s681 >>> 1 s695 :: SWord8 = s24 | s694 s696 :: SWord8 = s26 & s694 s697 :: SWord8 = if s597 then s695 else s696 s698 :: SWord8 = if s22 then s697 else s680 s699 :: SWord8 = s698 >>> 1 s700 :: SWord8 = s24 | s699 s701 :: SWord8 = s26 & s699 s702 :: SWord8 = if s693 then s700 else s701 s703 :: SWord8 = if s22 then s702 else s697 s704 :: SWord1 = choose [0:0] s703 s705 :: SBool = s19 /= s704 s706 :: SBool = s_2 == s705 s707 :: SWord8 = s691 >>> 1 s708 :: SWord8 = s24 | s707 s709 :: SWord8 = s26 & s707 s710 :: SWord8 = if s683 then s708 else s709 s711 :: SWord8 = s710 >>> 1 s712 :: SWord8 = s24 | s711 s713 :: SWord8 = s26 & s711 s714 :: SWord8 = if s705 then s712 else s713 s715 :: SWord1 = choose [0:0] s698 s716 :: SBool = s19 /= s715 s717 :: SWord8 = s703 >>> 1 s718 :: SWord8 = s24 | s717 s719 :: SWord8 = s26 & s717 s720 :: SWord8 = if s716 then s718 else s719 s721 :: SWord8 = if s29 then s680 else s628 s722 :: SWord8 = if s170 then s697 else s721 s723 :: SWord8 = if s29 then s702 else s722 s724 :: SWord8 = if s170 then s720 else s723 s725 :: SWord8 = s710 + s724 s726 :: SBool = s725 < s724 s727 :: SBool = s725 < s710 s728 :: SBool = s726 | s727 s729 :: SWord8 = s725 >>> 1 s730 :: SWord8 = s24 | s729 s731 :: SWord8 = s26 & s729 s732 :: SWord8 = if s728 then s730 else s731 s733 :: SWord8 = if s706 then s714 else s732 s734 :: SWord8 = s691 + s722 s735 :: SWord1 = choose [0:0] s734 s736 :: SBool = s19 /= s735 s737 :: SWord8 = if s736 then s700 else s701 s738 :: SWord8 = if s22 then s737 else s697 s739 :: SWord1 = choose [0:0] s738 s740 :: SBool = s19 /= s739 s741 :: SBool = s_2 == s740 s742 :: SBool = s734 < s722 s743 :: SBool = s734 < s691 s744 :: SBool = s742 | s743 s745 :: SWord8 = s734 >>> 1 s746 :: SWord8 = s24 | s745 s747 :: SWord8 = s26 & s745 s748 :: SWord8 = if s744 then s746 else s747 s749 :: SWord8 = s748 >>> 1 s750 :: SWord8 = s24 | s749 s751 :: SWord8 = s26 & s749 s752 :: SWord8 = if s740 then s750 else s751 s753 :: SWord8 = s738 >>> 1 s754 :: SWord8 = s24 | s753 s755 :: SWord8 = s26 & s753 s756 :: SWord8 = if s716 then s754 else s755 s757 :: SWord8 = if s29 then s737 else s722 s758 :: SWord8 = if s170 then s756 else s757 s759 :: SWord8 = s748 + s758 s760 :: SBool = s759 < s758 s761 :: SBool = s759 < s748 s762 :: SBool = s760 | s761 s763 :: SWord8 = s759 >>> 1 s764 :: SWord8 = s24 | s763 s765 :: SWord8 = s26 & s763 s766 :: SWord8 = if s762 then s764 else s765 s767 :: SWord8 = if s741 then s752 else s766 s768 :: SWord8 = if s684 then s733 else s767 s769 :: SWord8 = if s568 then s676 else s768 s770 :: SWord8 = s553 + s626 s771 :: SWord1 = choose [0:0] s770 s772 :: SBool = s19 /= s771 s773 :: SWord8 = if s772 then s562 else s563 s774 :: SWord8 = if s22 then s773 else s559 s775 :: SWord1 = choose [0:0] s774 s776 :: SBool = s19 /= s775 s777 :: SBool = s_2 == s776 s778 :: SBool = s770 < s626 s779 :: SBool = s770 < s553 s780 :: SBool = s778 | s779 s781 :: SWord8 = s770 >>> 1 s782 :: SWord8 = s24 | s781 s783 :: SWord8 = s26 & s781 s784 :: SWord8 = if s780 then s782 else s783 s785 :: SWord1 = choose [0:0] s784 s786 :: SBool = s19 /= s785 s787 :: SWord8 = s774 >>> 1 s788 :: SWord8 = s24 | s787 s789 :: SWord8 = s26 & s787 s790 :: SWord8 = if s576 then s788 else s789 s791 :: SWord8 = if s22 then s790 else s773 s792 :: SWord8 = s791 >>> 1 s793 :: SWord8 = s24 | s792 s794 :: SWord8 = s26 & s792 s795 :: SWord8 = if s786 then s793 else s794 s796 :: SWord8 = if s22 then s795 else s790 s797 :: SWord1 = choose [0:0] s796 s798 :: SBool = s19 /= s797 s799 :: SBool = s_2 == s798 s800 :: SWord8 = s784 >>> 1 s801 :: SWord8 = s24 | s800 s802 :: SWord8 = s26 & s800 s803 :: SWord8 = if s776 then s801 else s802 s804 :: SWord1 = choose [0:0] s803 s805 :: SBool = s19 /= s804 s806 :: SWord1 = choose [0:0] s791 s807 :: SBool = s19 /= s806 s808 :: SWord8 = s796 >>> 1 s809 :: SWord8 = s24 | s808 s810 :: SWord8 = s26 & s808 s811 :: SWord8 = if s807 then s809 else s810 s812 :: SWord8 = if s22 then s811 else s795 s813 :: SWord8 = s812 >>> 1 s814 :: SWord8 = s24 | s813 s815 :: SWord8 = s26 & s813 s816 :: SWord8 = if s805 then s814 else s815 s817 :: SWord8 = if s22 then s816 else s811 s818 :: SWord1 = choose [0:0] s817 s819 :: SBool = s19 /= s818 s820 :: SBool = s_2 == s819 s821 :: SWord8 = s803 >>> 1 s822 :: SWord8 = s24 | s821 s823 :: SWord8 = s26 & s821 s824 :: SWord8 = if s798 then s822 else s823 s825 :: SWord8 = s824 >>> 1 s826 :: SWord8 = s24 | s825 s827 :: SWord8 = s26 & s825 s828 :: SWord8 = if s819 then s826 else s827 s829 :: SWord1 = choose [0:0] s812 s830 :: SBool = s19 /= s829 s831 :: SWord8 = s817 >>> 1 s832 :: SWord8 = s24 | s831 s833 :: SWord8 = s26 & s831 s834 :: SWord8 = if s830 then s832 else s833 s835 :: SWord8 = if s29 then s773 else s626 s836 :: SWord8 = if s170 then s790 else s835 s837 :: SWord8 = if s29 then s795 else s836 s838 :: SWord8 = if s170 then s811 else s837 s839 :: SWord8 = if s29 then s816 else s838 s840 :: SWord8 = if s170 then s834 else s839 s841 :: SWord8 = s824 + s840 s842 :: SBool = s841 < s840 s843 :: SBool = s841 < s824 s844 :: SBool = s842 | s843 s845 :: SWord8 = s841 >>> 1 s846 :: SWord8 = s24 | s845 s847 :: SWord8 = s26 & s845 s848 :: SWord8 = if s844 then s846 else s847 s849 :: SWord8 = if s820 then s828 else s848 s850 :: SWord8 = s803 + s838 s851 :: SWord1 = choose [0:0] s850 s852 :: SBool = s19 /= s851 s853 :: SWord8 = if s852 then s814 else s815 s854 :: SWord8 = if s22 then s853 else s811 s855 :: SWord1 = choose [0:0] s854 s856 :: SBool = s19 /= s855 s857 :: SBool = s_2 == s856 s858 :: SBool = s850 < s838 s859 :: SBool = s850 < s803 s860 :: SBool = s858 | s859 s861 :: SWord8 = s850 >>> 1 s862 :: SWord8 = s24 | s861 s863 :: SWord8 = s26 & s861 s864 :: SWord8 = if s860 then s862 else s863 s865 :: SWord8 = s864 >>> 1 s866 :: SWord8 = s24 | s865 s867 :: SWord8 = s26 & s865 s868 :: SWord8 = if s856 then s866 else s867 s869 :: SWord8 = s854 >>> 1 s870 :: SWord8 = s24 | s869 s871 :: SWord8 = s26 & s869 s872 :: SWord8 = if s830 then s870 else s871 s873 :: SWord8 = if s29 then s853 else s838 s874 :: SWord8 = if s170 then s872 else s873 s875 :: SWord8 = s864 + s874 s876 :: SBool = s875 < s874 s877 :: SBool = s875 < s864 s878 :: SBool = s876 | s877 s879 :: SWord8 = s875 >>> 1 s880 :: SWord8 = s24 | s879 s881 :: SWord8 = s26 & s879 s882 :: SWord8 = if s878 then s880 else s881 s883 :: SWord8 = if s857 then s868 else s882 s884 :: SWord8 = if s799 then s849 else s883 s885 :: SWord8 = s784 + s836 s886 :: SWord1 = choose [0:0] s885 s887 :: SBool = s19 /= s886 s888 :: SWord8 = if s887 then s793 else s794 s889 :: SWord8 = if s22 then s888 else s790 s890 :: SWord1 = choose [0:0] s889 s891 :: SBool = s19 /= s890 s892 :: SBool = s_2 == s891 s893 :: SBool = s885 < s836 s894 :: SBool = s885 < s784 s895 :: SBool = s893 | s894 s896 :: SWord8 = s885 >>> 1 s897 :: SWord8 = s24 | s896 s898 :: SWord8 = s26 & s896 s899 :: SWord8 = if s895 then s897 else s898 s900 :: SWord1 = choose [0:0] s899 s901 :: SBool = s19 /= s900 s902 :: SWord8 = s889 >>> 1 s903 :: SWord8 = s24 | s902 s904 :: SWord8 = s26 & s902 s905 :: SWord8 = if s807 then s903 else s904 s906 :: SWord8 = if s22 then s905 else s888 s907 :: SWord8 = s906 >>> 1 s908 :: SWord8 = s24 | s907 s909 :: SWord8 = s26 & s907 s910 :: SWord8 = if s901 then s908 else s909 s911 :: SWord8 = if s22 then s910 else s905 s912 :: SWord1 = choose [0:0] s911 s913 :: SBool = s19 /= s912 s914 :: SBool = s_2 == s913 s915 :: SWord8 = s899 >>> 1 s916 :: SWord8 = s24 | s915 s917 :: SWord8 = s26 & s915 s918 :: SWord8 = if s891 then s916 else s917 s919 :: SWord8 = s918 >>> 1 s920 :: SWord8 = s24 | s919 s921 :: SWord8 = s26 & s919 s922 :: SWord8 = if s913 then s920 else s921 s923 :: SWord1 = choose [0:0] s906 s924 :: SBool = s19 /= s923 s925 :: SWord8 = s911 >>> 1 s926 :: SWord8 = s24 | s925 s927 :: SWord8 = s26 & s925 s928 :: SWord8 = if s924 then s926 else s927 s929 :: SWord8 = if s29 then s888 else s836 s930 :: SWord8 = if s170 then s905 else s929 s931 :: SWord8 = if s29 then s910 else s930 s932 :: SWord8 = if s170 then s928 else s931 s933 :: SWord8 = s918 + s932 s934 :: SBool = s933 < s932 s935 :: SBool = s933 < s918 s936 :: SBool = s934 | s935 s937 :: SWord8 = s933 >>> 1 s938 :: SWord8 = s24 | s937 s939 :: SWord8 = s26 & s937 s940 :: SWord8 = if s936 then s938 else s939 s941 :: SWord8 = if s914 then s922 else s940 s942 :: SWord8 = s899 + s930 s943 :: SWord1 = choose [0:0] s942 s944 :: SBool = s19 /= s943 s945 :: SWord8 = if s944 then s908 else s909 s946 :: SWord8 = if s22 then s945 else s905 s947 :: SWord1 = choose [0:0] s946 s948 :: SBool = s19 /= s947 s949 :: SBool = s_2 == s948 s950 :: SBool = s942 < s930 s951 :: SBool = s942 < s899 s952 :: SBool = s950 | s951 s953 :: SWord8 = s942 >>> 1 s954 :: SWord8 = s24 | s953 s955 :: SWord8 = s26 & s953 s956 :: SWord8 = if s952 then s954 else s955 s957 :: SWord8 = s956 >>> 1 s958 :: SWord8 = s24 | s957 s959 :: SWord8 = s26 & s957 s960 :: SWord8 = if s948 then s958 else s959 s961 :: SWord8 = s946 >>> 1 s962 :: SWord8 = s24 | s961 s963 :: SWord8 = s26 & s961 s964 :: SWord8 = if s924 then s962 else s963 s965 :: SWord8 = if s29 then s945 else s930 s966 :: SWord8 = if s170 then s964 else s965 s967 :: SWord8 = s956 + s966 s968 :: SBool = s967 < s966 s969 :: SBool = s967 < s956 s970 :: SBool = s968 | s969 s971 :: SWord8 = s967 >>> 1 s972 :: SWord8 = s24 | s971 s973 :: SWord8 = s26 & s971 s974 :: SWord8 = if s970 then s972 else s973 s975 :: SWord8 = if s949 then s960 else s974 s976 :: SWord8 = if s892 then s941 else s975 s977 :: SWord8 = if s777 then s884 else s976 s978 :: SWord8 = if s546 then s769 else s977 s979 :: SWord8 = if s77 then s538 else s978 s980 :: SWord8 = s60 + s182 s981 :: SWord1 = choose [0:0] s980 s982 :: SBool = s19 /= s981 s983 :: SWord8 = if s982 then s71 else s72 s984 :: SWord8 = if s22 then s983 else s68 s985 :: SWord1 = choose [0:0] s984 s986 :: SBool = s19 /= s985 s987 :: SBool = s_2 == s986 s988 :: SBool = s980 < s182 s989 :: SBool = s980 < s60 s990 :: SBool = s988 | s989 s991 :: SWord8 = s980 >>> 1 s992 :: SWord8 = s24 | s991 s993 :: SWord8 = s26 & s991 s994 :: SWord8 = if s990 then s992 else s993 s995 :: SWord1 = choose [0:0] s994 s996 :: SBool = s19 /= s995 s997 :: SWord8 = s984 >>> 1 s998 :: SWord8 = s24 | s997 s999 :: SWord8 = s26 & s997 s1000 :: SWord8 = if s85 then s998 else s999 s1001 :: SWord8 = if s22 then s1000 else s983 s1002 :: SWord8 = s1001 >>> 1 s1003 :: SWord8 = s24 | s1002 s1004 :: SWord8 = s26 & s1002 s1005 :: SWord8 = if s996 then s1003 else s1004 s1006 :: SWord8 = if s22 then s1005 else s1000 s1007 :: SWord1 = choose [0:0] s1006 s1008 :: SBool = s19 /= s1007 s1009 :: SBool = s_2 == s1008 s1010 :: SWord8 = s994 >>> 1 s1011 :: SWord8 = s24 | s1010 s1012 :: SWord8 = s26 & s1010 s1013 :: SWord8 = if s986 then s1011 else s1012 s1014 :: SWord1 = choose [0:0] s1013 s1015 :: SBool = s19 /= s1014 s1016 :: SWord1 = choose [0:0] s1001 s1017 :: SBool = s19 /= s1016 s1018 :: SWord8 = s1006 >>> 1 s1019 :: SWord8 = s24 | s1018 s1020 :: SWord8 = s26 & s1018 s1021 :: SWord8 = if s1017 then s1019 else s1020 s1022 :: SWord8 = if s22 then s1021 else s1005 s1023 :: SWord8 = s1022 >>> 1 s1024 :: SWord8 = s24 | s1023 s1025 :: SWord8 = s26 & s1023 s1026 :: SWord8 = if s1015 then s1024 else s1025 s1027 :: SWord8 = if s22 then s1026 else s1021 s1028 :: SWord1 = choose [0:0] s1027 s1029 :: SBool = s19 /= s1028 s1030 :: SBool = s_2 == s1029 s1031 :: SWord8 = s1013 >>> 1 s1032 :: SWord8 = s24 | s1031 s1033 :: SWord8 = s26 & s1031 s1034 :: SWord8 = if s1008 then s1032 else s1033 s1035 :: SWord1 = choose [0:0] s1034 s1036 :: SBool = s19 /= s1035 s1037 :: SWord1 = choose [0:0] s1022 s1038 :: SBool = s19 /= s1037 s1039 :: SWord8 = s1027 >>> 1 s1040 :: SWord8 = s24 | s1039 s1041 :: SWord8 = s26 & s1039 s1042 :: SWord8 = if s1038 then s1040 else s1041 s1043 :: SWord8 = if s22 then s1042 else s1026 s1044 :: SWord8 = s1043 >>> 1 s1045 :: SWord8 = s24 | s1044 s1046 :: SWord8 = s26 & s1044 s1047 :: SWord8 = if s1036 then s1045 else s1046 s1048 :: SWord8 = if s22 then s1047 else s1042 s1049 :: SWord1 = choose [0:0] s1048 s1050 :: SBool = s19 /= s1049 s1051 :: SBool = s_2 == s1050 s1052 :: SWord8 = s1034 >>> 1 s1053 :: SWord8 = s24 | s1052 s1054 :: SWord8 = s26 & s1052 s1055 :: SWord8 = if s1029 then s1053 else s1054 s1056 :: SWord1 = choose [0:0] s1055 s1057 :: SBool = s19 /= s1056 s1058 :: SWord1 = choose [0:0] s1043 s1059 :: SBool = s19 /= s1058 s1060 :: SWord8 = s1048 >>> 1 s1061 :: SWord8 = s24 | s1060 s1062 :: SWord8 = s26 & s1060 s1063 :: SWord8 = if s1059 then s1061 else s1062 s1064 :: SWord8 = if s22 then s1063 else s1047 s1065 :: SWord8 = s1064 >>> 1 s1066 :: SWord8 = s24 | s1065 s1067 :: SWord8 = s26 & s1065 s1068 :: SWord8 = if s1057 then s1066 else s1067 s1069 :: SWord8 = if s22 then s1068 else s1063 s1070 :: SWord1 = choose [0:0] s1069 s1071 :: SBool = s19 /= s1070 s1072 :: SBool = s_2 == s1071 s1073 :: SWord8 = s1055 >>> 1 s1074 :: SWord8 = s24 | s1073 s1075 :: SWord8 = s26 & s1073 s1076 :: SWord8 = if s1050 then s1074 else s1075 s1077 :: SWord8 = s1076 >>> 1 s1078 :: SWord8 = s24 | s1077 s1079 :: SWord8 = s26 & s1077 s1080 :: SWord8 = if s1071 then s1078 else s1079 s1081 :: SWord1 = choose [0:0] s1064 s1082 :: SBool = s19 /= s1081 s1083 :: SWord8 = s1069 >>> 1 s1084 :: SWord8 = s24 | s1083 s1085 :: SWord8 = s26 & s1083 s1086 :: SWord8 = if s1082 then s1084 else s1085 s1087 :: SWord8 = if s29 then s983 else s182 s1088 :: SWord8 = if s170 then s1000 else s1087 s1089 :: SWord8 = if s29 then s1005 else s1088 s1090 :: SWord8 = if s170 then s1021 else s1089 s1091 :: SWord8 = if s29 then s1026 else s1090 s1092 :: SWord8 = if s170 then s1042 else s1091 s1093 :: SWord8 = if s29 then s1047 else s1092 s1094 :: SWord8 = if s170 then s1063 else s1093 s1095 :: SWord8 = if s29 then s1068 else s1094 s1096 :: SWord8 = if s170 then s1086 else s1095 s1097 :: SWord8 = s1076 + s1096 s1098 :: SBool = s1097 < s1096 s1099 :: SBool = s1097 < s1076 s1100 :: SBool = s1098 | s1099 s1101 :: SWord8 = s1097 >>> 1 s1102 :: SWord8 = s24 | s1101 s1103 :: SWord8 = s26 & s1101 s1104 :: SWord8 = if s1100 then s1102 else s1103 s1105 :: SWord8 = if s1072 then s1080 else s1104 s1106 :: SWord8 = s1055 + s1094 s1107 :: SWord1 = choose [0:0] s1106 s1108 :: SBool = s19 /= s1107 s1109 :: SWord8 = if s1108 then s1066 else s1067 s1110 :: SWord8 = if s22 then s1109 else s1063 s1111 :: SWord1 = choose [0:0] s1110 s1112 :: SBool = s19 /= s1111 s1113 :: SBool = s_2 == s1112 s1114 :: SBool = s1106 < s1094 s1115 :: SBool = s1106 < s1055 s1116 :: SBool = s1114 | s1115 s1117 :: SWord8 = s1106 >>> 1 s1118 :: SWord8 = s24 | s1117 s1119 :: SWord8 = s26 & s1117 s1120 :: SWord8 = if s1116 then s1118 else s1119 s1121 :: SWord8 = s1120 >>> 1 s1122 :: SWord8 = s24 | s1121 s1123 :: SWord8 = s26 & s1121 s1124 :: SWord8 = if s1112 then s1122 else s1123 s1125 :: SWord8 = s1110 >>> 1 s1126 :: SWord8 = s24 | s1125 s1127 :: SWord8 = s26 & s1125 s1128 :: SWord8 = if s1082 then s1126 else s1127 s1129 :: SWord8 = if s29 then s1109 else s1094 s1130 :: SWord8 = if s170 then s1128 else s1129 s1131 :: SWord8 = s1120 + s1130 s1132 :: SBool = s1131 < s1130 s1133 :: SBool = s1131 < s1120 s1134 :: SBool = s1132 | s1133 s1135 :: SWord8 = s1131 >>> 1 s1136 :: SWord8 = s24 | s1135 s1137 :: SWord8 = s26 & s1135 s1138 :: SWord8 = if s1134 then s1136 else s1137 s1139 :: SWord8 = if s1113 then s1124 else s1138 s1140 :: SWord8 = if s1051 then s1105 else s1139 s1141 :: SWord8 = s1034 + s1092 s1142 :: SWord1 = choose [0:0] s1141 s1143 :: SBool = s19 /= s1142 s1144 :: SWord8 = if s1143 then s1045 else s1046 s1145 :: SWord8 = if s22 then s1144 else s1042 s1146 :: SWord1 = choose [0:0] s1145 s1147 :: SBool = s19 /= s1146 s1148 :: SBool = s_2 == s1147 s1149 :: SBool = s1141 < s1092 s1150 :: SBool = s1141 < s1034 s1151 :: SBool = s1149 | s1150 s1152 :: SWord8 = s1141 >>> 1 s1153 :: SWord8 = s24 | s1152 s1154 :: SWord8 = s26 & s1152 s1155 :: SWord8 = if s1151 then s1153 else s1154 s1156 :: SWord1 = choose [0:0] s1155 s1157 :: SBool = s19 /= s1156 s1158 :: SWord8 = s1145 >>> 1 s1159 :: SWord8 = s24 | s1158 s1160 :: SWord8 = s26 & s1158 s1161 :: SWord8 = if s1059 then s1159 else s1160 s1162 :: SWord8 = if s22 then s1161 else s1144 s1163 :: SWord8 = s1162 >>> 1 s1164 :: SWord8 = s24 | s1163 s1165 :: SWord8 = s26 & s1163 s1166 :: SWord8 = if s1157 then s1164 else s1165 s1167 :: SWord8 = if s22 then s1166 else s1161 s1168 :: SWord1 = choose [0:0] s1167 s1169 :: SBool = s19 /= s1168 s1170 :: SBool = s_2 == s1169 s1171 :: SWord8 = s1155 >>> 1 s1172 :: SWord8 = s24 | s1171 s1173 :: SWord8 = s26 & s1171 s1174 :: SWord8 = if s1147 then s1172 else s1173 s1175 :: SWord8 = s1174 >>> 1 s1176 :: SWord8 = s24 | s1175 s1177 :: SWord8 = s26 & s1175 s1178 :: SWord8 = if s1169 then s1176 else s1177 s1179 :: SWord1 = choose [0:0] s1162 s1180 :: SBool = s19 /= s1179 s1181 :: SWord8 = s1167 >>> 1 s1182 :: SWord8 = s24 | s1181 s1183 :: SWord8 = s26 & s1181 s1184 :: SWord8 = if s1180 then s1182 else s1183 s1185 :: SWord8 = if s29 then s1144 else s1092 s1186 :: SWord8 = if s170 then s1161 else s1185 s1187 :: SWord8 = if s29 then s1166 else s1186 s1188 :: SWord8 = if s170 then s1184 else s1187 s1189 :: SWord8 = s1174 + s1188 s1190 :: SBool = s1189 < s1188 s1191 :: SBool = s1189 < s1174 s1192 :: SBool = s1190 | s1191 s1193 :: SWord8 = s1189 >>> 1 s1194 :: SWord8 = s24 | s1193 s1195 :: SWord8 = s26 & s1193 s1196 :: SWord8 = if s1192 then s1194 else s1195 s1197 :: SWord8 = if s1170 then s1178 else s1196 s1198 :: SWord8 = s1155 + s1186 s1199 :: SWord1 = choose [0:0] s1198 s1200 :: SBool = s19 /= s1199 s1201 :: SWord8 = if s1200 then s1164 else s1165 s1202 :: SWord8 = if s22 then s1201 else s1161 s1203 :: SWord1 = choose [0:0] s1202 s1204 :: SBool = s19 /= s1203 s1205 :: SBool = s_2 == s1204 s1206 :: SBool = s1198 < s1186 s1207 :: SBool = s1198 < s1155 s1208 :: SBool = s1206 | s1207 s1209 :: SWord8 = s1198 >>> 1 s1210 :: SWord8 = s24 | s1209 s1211 :: SWord8 = s26 & s1209 s1212 :: SWord8 = if s1208 then s1210 else s1211 s1213 :: SWord8 = s1212 >>> 1 s1214 :: SWord8 = s24 | s1213 s1215 :: SWord8 = s26 & s1213 s1216 :: SWord8 = if s1204 then s1214 else s1215 s1217 :: SWord8 = s1202 >>> 1 s1218 :: SWord8 = s24 | s1217 s1219 :: SWord8 = s26 & s1217 s1220 :: SWord8 = if s1180 then s1218 else s1219 s1221 :: SWord8 = if s29 then s1201 else s1186 s1222 :: SWord8 = if s170 then s1220 else s1221 s1223 :: SWord8 = s1212 + s1222 s1224 :: SBool = s1223 < s1222 s1225 :: SBool = s1223 < s1212 s1226 :: SBool = s1224 | s1225 s1227 :: SWord8 = s1223 >>> 1 s1228 :: SWord8 = s24 | s1227 s1229 :: SWord8 = s26 & s1227 s1230 :: SWord8 = if s1226 then s1228 else s1229 s1231 :: SWord8 = if s1205 then s1216 else s1230 s1232 :: SWord8 = if s1148 then s1197 else s1231 s1233 :: SWord8 = if s1030 then s1140 else s1232 s1234 :: SWord8 = s1013 + s1090 s1235 :: SWord1 = choose [0:0] s1234 s1236 :: SBool = s19 /= s1235 s1237 :: SWord8 = if s1236 then s1024 else s1025 s1238 :: SWord8 = if s22 then s1237 else s1021 s1239 :: SWord1 = choose [0:0] s1238 s1240 :: SBool = s19 /= s1239 s1241 :: SBool = s_2 == s1240 s1242 :: SBool = s1234 < s1090 s1243 :: SBool = s1234 < s1013 s1244 :: SBool = s1242 | s1243 s1245 :: SWord8 = s1234 >>> 1 s1246 :: SWord8 = s24 | s1245 s1247 :: SWord8 = s26 & s1245 s1248 :: SWord8 = if s1244 then s1246 else s1247 s1249 :: SWord1 = choose [0:0] s1248 s1250 :: SBool = s19 /= s1249 s1251 :: SWord8 = s1238 >>> 1 s1252 :: SWord8 = s24 | s1251 s1253 :: SWord8 = s26 & s1251 s1254 :: SWord8 = if s1038 then s1252 else s1253 s1255 :: SWord8 = if s22 then s1254 else s1237 s1256 :: SWord8 = s1255 >>> 1 s1257 :: SWord8 = s24 | s1256 s1258 :: SWord8 = s26 & s1256 s1259 :: SWord8 = if s1250 then s1257 else s1258 s1260 :: SWord8 = if s22 then s1259 else s1254 s1261 :: SWord1 = choose [0:0] s1260 s1262 :: SBool = s19 /= s1261 s1263 :: SBool = s_2 == s1262 s1264 :: SWord8 = s1248 >>> 1 s1265 :: SWord8 = s24 | s1264 s1266 :: SWord8 = s26 & s1264 s1267 :: SWord8 = if s1240 then s1265 else s1266 s1268 :: SWord1 = choose [0:0] s1267 s1269 :: SBool = s19 /= s1268 s1270 :: SWord1 = choose [0:0] s1255 s1271 :: SBool = s19 /= s1270 s1272 :: SWord8 = s1260 >>> 1 s1273 :: SWord8 = s24 | s1272 s1274 :: SWord8 = s26 & s1272 s1275 :: SWord8 = if s1271 then s1273 else s1274 s1276 :: SWord8 = if s22 then s1275 else s1259 s1277 :: SWord8 = s1276 >>> 1 s1278 :: SWord8 = s24 | s1277 s1279 :: SWord8 = s26 & s1277 s1280 :: SWord8 = if s1269 then s1278 else s1279 s1281 :: SWord8 = if s22 then s1280 else s1275 s1282 :: SWord1 = choose [0:0] s1281 s1283 :: SBool = s19 /= s1282 s1284 :: SBool = s_2 == s1283 s1285 :: SWord8 = s1267 >>> 1 s1286 :: SWord8 = s24 | s1285 s1287 :: SWord8 = s26 & s1285 s1288 :: SWord8 = if s1262 then s1286 else s1287 s1289 :: SWord8 = s1288 >>> 1 s1290 :: SWord8 = s24 | s1289 s1291 :: SWord8 = s26 & s1289 s1292 :: SWord8 = if s1283 then s1290 else s1291 s1293 :: SWord1 = choose [0:0] s1276 s1294 :: SBool = s19 /= s1293 s1295 :: SWord8 = s1281 >>> 1 s1296 :: SWord8 = s24 | s1295 s1297 :: SWord8 = s26 & s1295 s1298 :: SWord8 = if s1294 then s1296 else s1297 s1299 :: SWord8 = if s29 then s1237 else s1090 s1300 :: SWord8 = if s170 then s1254 else s1299 s1301 :: SWord8 = if s29 then s1259 else s1300 s1302 :: SWord8 = if s170 then s1275 else s1301 s1303 :: SWord8 = if s29 then s1280 else s1302 s1304 :: SWord8 = if s170 then s1298 else s1303 s1305 :: SWord8 = s1288 + s1304 s1306 :: SBool = s1305 < s1304 s1307 :: SBool = s1305 < s1288 s1308 :: SBool = s1306 | s1307 s1309 :: SWord8 = s1305 >>> 1 s1310 :: SWord8 = s24 | s1309 s1311 :: SWord8 = s26 & s1309 s1312 :: SWord8 = if s1308 then s1310 else s1311 s1313 :: SWord8 = if s1284 then s1292 else s1312 s1314 :: SWord8 = s1267 + s1302 s1315 :: SWord1 = choose [0:0] s1314 s1316 :: SBool = s19 /= s1315 s1317 :: SWord8 = if s1316 then s1278 else s1279 s1318 :: SWord8 = if s22 then s1317 else s1275 s1319 :: SWord1 = choose [0:0] s1318 s1320 :: SBool = s19 /= s1319 s1321 :: SBool = s_2 == s1320 s1322 :: SBool = s1314 < s1302 s1323 :: SBool = s1314 < s1267 s1324 :: SBool = s1322 | s1323 s1325 :: SWord8 = s1314 >>> 1 s1326 :: SWord8 = s24 | s1325 s1327 :: SWord8 = s26 & s1325 s1328 :: SWord8 = if s1324 then s1326 else s1327 s1329 :: SWord8 = s1328 >>> 1 s1330 :: SWord8 = s24 | s1329 s1331 :: SWord8 = s26 & s1329 s1332 :: SWord8 = if s1320 then s1330 else s1331 s1333 :: SWord8 = s1318 >>> 1 s1334 :: SWord8 = s24 | s1333 s1335 :: SWord8 = s26 & s1333 s1336 :: SWord8 = if s1294 then s1334 else s1335 s1337 :: SWord8 = if s29 then s1317 else s1302 s1338 :: SWord8 = if s170 then s1336 else s1337 s1339 :: SWord8 = s1328 + s1338 s1340 :: SBool = s1339 < s1338 s1341 :: SBool = s1339 < s1328 s1342 :: SBool = s1340 | s1341 s1343 :: SWord8 = s1339 >>> 1 s1344 :: SWord8 = s24 | s1343 s1345 :: SWord8 = s26 & s1343 s1346 :: SWord8 = if s1342 then s1344 else s1345 s1347 :: SWord8 = if s1321 then s1332 else s1346 s1348 :: SWord8 = if s1263 then s1313 else s1347 s1349 :: SWord8 = s1248 + s1300 s1350 :: SWord1 = choose [0:0] s1349 s1351 :: SBool = s19 /= s1350 s1352 :: SWord8 = if s1351 then s1257 else s1258 s1353 :: SWord8 = if s22 then s1352 else s1254 s1354 :: SWord1 = choose [0:0] s1353 s1355 :: SBool = s19 /= s1354 s1356 :: SBool = s_2 == s1355 s1357 :: SBool = s1349 < s1300 s1358 :: SBool = s1349 < s1248 s1359 :: SBool = s1357 | s1358 s1360 :: SWord8 = s1349 >>> 1 s1361 :: SWord8 = s24 | s1360 s1362 :: SWord8 = s26 & s1360 s1363 :: SWord8 = if s1359 then s1361 else s1362 s1364 :: SWord1 = choose [0:0] s1363 s1365 :: SBool = s19 /= s1364 s1366 :: SWord8 = s1353 >>> 1 s1367 :: SWord8 = s24 | s1366 s1368 :: SWord8 = s26 & s1366 s1369 :: SWord8 = if s1271 then s1367 else s1368 s1370 :: SWord8 = if s22 then s1369 else s1352 s1371 :: SWord8 = s1370 >>> 1 s1372 :: SWord8 = s24 | s1371 s1373 :: SWord8 = s26 & s1371 s1374 :: SWord8 = if s1365 then s1372 else s1373 s1375 :: SWord8 = if s22 then s1374 else s1369 s1376 :: SWord1 = choose [0:0] s1375 s1377 :: SBool = s19 /= s1376 s1378 :: SBool = s_2 == s1377 s1379 :: SWord8 = s1363 >>> 1 s1380 :: SWord8 = s24 | s1379 s1381 :: SWord8 = s26 & s1379 s1382 :: SWord8 = if s1355 then s1380 else s1381 s1383 :: SWord8 = s1382 >>> 1 s1384 :: SWord8 = s24 | s1383 s1385 :: SWord8 = s26 & s1383 s1386 :: SWord8 = if s1377 then s1384 else s1385 s1387 :: SWord1 = choose [0:0] s1370 s1388 :: SBool = s19 /= s1387 s1389 :: SWord8 = s1375 >>> 1 s1390 :: SWord8 = s24 | s1389 s1391 :: SWord8 = s26 & s1389 s1392 :: SWord8 = if s1388 then s1390 else s1391 s1393 :: SWord8 = if s29 then s1352 else s1300 s1394 :: SWord8 = if s170 then s1369 else s1393 s1395 :: SWord8 = if s29 then s1374 else s1394 s1396 :: SWord8 = if s170 then s1392 else s1395 s1397 :: SWord8 = s1382 + s1396 s1398 :: SBool = s1397 < s1396 s1399 :: SBool = s1397 < s1382 s1400 :: SBool = s1398 | s1399 s1401 :: SWord8 = s1397 >>> 1 s1402 :: SWord8 = s24 | s1401 s1403 :: SWord8 = s26 & s1401 s1404 :: SWord8 = if s1400 then s1402 else s1403 s1405 :: SWord8 = if s1378 then s1386 else s1404 s1406 :: SWord8 = s1363 + s1394 s1407 :: SWord1 = choose [0:0] s1406 s1408 :: SBool = s19 /= s1407 s1409 :: SWord8 = if s1408 then s1372 else s1373 s1410 :: SWord8 = if s22 then s1409 else s1369 s1411 :: SWord1 = choose [0:0] s1410 s1412 :: SBool = s19 /= s1411 s1413 :: SBool = s_2 == s1412 s1414 :: SBool = s1406 < s1394 s1415 :: SBool = s1406 < s1363 s1416 :: SBool = s1414 | s1415 s1417 :: SWord8 = s1406 >>> 1 s1418 :: SWord8 = s24 | s1417 s1419 :: SWord8 = s26 & s1417 s1420 :: SWord8 = if s1416 then s1418 else s1419 s1421 :: SWord8 = s1420 >>> 1 s1422 :: SWord8 = s24 | s1421 s1423 :: SWord8 = s26 & s1421 s1424 :: SWord8 = if s1412 then s1422 else s1423 s1425 :: SWord8 = s1410 >>> 1 s1426 :: SWord8 = s24 | s1425 s1427 :: SWord8 = s26 & s1425 s1428 :: SWord8 = if s1388 then s1426 else s1427 s1429 :: SWord8 = if s29 then s1409 else s1394 s1430 :: SWord8 = if s170 then s1428 else s1429 s1431 :: SWord8 = s1420 + s1430 s1432 :: SBool = s1431 < s1430 s1433 :: SBool = s1431 < s1420 s1434 :: SBool = s1432 | s1433 s1435 :: SWord8 = s1431 >>> 1 s1436 :: SWord8 = s24 | s1435 s1437 :: SWord8 = s26 & s1435 s1438 :: SWord8 = if s1434 then s1436 else s1437 s1439 :: SWord8 = if s1413 then s1424 else s1438 s1440 :: SWord8 = if s1356 then s1405 else s1439 s1441 :: SWord8 = if s1241 then s1348 else s1440 s1442 :: SWord8 = if s1009 then s1233 else s1441 s1443 :: SWord8 = s994 + s1088 s1444 :: SWord1 = choose [0:0] s1443 s1445 :: SBool = s19 /= s1444 s1446 :: SWord8 = if s1445 then s1003 else s1004 s1447 :: SWord8 = if s22 then s1446 else s1000 s1448 :: SWord1 = choose [0:0] s1447 s1449 :: SBool = s19 /= s1448 s1450 :: SBool = s_2 == s1449 s1451 :: SBool = s1443 < s1088 s1452 :: SBool = s1443 < s994 s1453 :: SBool = s1451 | s1452 s1454 :: SWord8 = s1443 >>> 1 s1455 :: SWord8 = s24 | s1454 s1456 :: SWord8 = s26 & s1454 s1457 :: SWord8 = if s1453 then s1455 else s1456 s1458 :: SWord1 = choose [0:0] s1457 s1459 :: SBool = s19 /= s1458 s1460 :: SWord8 = s1447 >>> 1 s1461 :: SWord8 = s24 | s1460 s1462 :: SWord8 = s26 & s1460 s1463 :: SWord8 = if s1017 then s1461 else s1462 s1464 :: SWord8 = if s22 then s1463 else s1446 s1465 :: SWord8 = s1464 >>> 1 s1466 :: SWord8 = s24 | s1465 s1467 :: SWord8 = s26 & s1465 s1468 :: SWord8 = if s1459 then s1466 else s1467 s1469 :: SWord8 = if s22 then s1468 else s1463 s1470 :: SWord1 = choose [0:0] s1469 s1471 :: SBool = s19 /= s1470 s1472 :: SBool = s_2 == s1471 s1473 :: SWord8 = s1457 >>> 1 s1474 :: SWord8 = s24 | s1473 s1475 :: SWord8 = s26 & s1473 s1476 :: SWord8 = if s1449 then s1474 else s1475 s1477 :: SWord1 = choose [0:0] s1476 s1478 :: SBool = s19 /= s1477 s1479 :: SWord1 = choose [0:0] s1464 s1480 :: SBool = s19 /= s1479 s1481 :: SWord8 = s1469 >>> 1 s1482 :: SWord8 = s24 | s1481 s1483 :: SWord8 = s26 & s1481 s1484 :: SWord8 = if s1480 then s1482 else s1483 s1485 :: SWord8 = if s22 then s1484 else s1468 s1486 :: SWord8 = s1485 >>> 1 s1487 :: SWord8 = s24 | s1486 s1488 :: SWord8 = s26 & s1486 s1489 :: SWord8 = if s1478 then s1487 else s1488 s1490 :: SWord8 = if s22 then s1489 else s1484 s1491 :: SWord1 = choose [0:0] s1490 s1492 :: SBool = s19 /= s1491 s1493 :: SBool = s_2 == s1492 s1494 :: SWord8 = s1476 >>> 1 s1495 :: SWord8 = s24 | s1494 s1496 :: SWord8 = s26 & s1494 s1497 :: SWord8 = if s1471 then s1495 else s1496 s1498 :: SWord1 = choose [0:0] s1497 s1499 :: SBool = s19 /= s1498 s1500 :: SWord1 = choose [0:0] s1485 s1501 :: SBool = s19 /= s1500 s1502 :: SWord8 = s1490 >>> 1 s1503 :: SWord8 = s24 | s1502 s1504 :: SWord8 = s26 & s1502 s1505 :: SWord8 = if s1501 then s1503 else s1504 s1506 :: SWord8 = if s22 then s1505 else s1489 s1507 :: SWord8 = s1506 >>> 1 s1508 :: SWord8 = s24 | s1507 s1509 :: SWord8 = s26 & s1507 s1510 :: SWord8 = if s1499 then s1508 else s1509 s1511 :: SWord8 = if s22 then s1510 else s1505 s1512 :: SWord1 = choose [0:0] s1511 s1513 :: SBool = s19 /= s1512 s1514 :: SBool = s_2 == s1513 s1515 :: SWord8 = s1497 >>> 1 s1516 :: SWord8 = s24 | s1515 s1517 :: SWord8 = s26 & s1515 s1518 :: SWord8 = if s1492 then s1516 else s1517 s1519 :: SWord8 = s1518 >>> 1 s1520 :: SWord8 = s24 | s1519 s1521 :: SWord8 = s26 & s1519 s1522 :: SWord8 = if s1513 then s1520 else s1521 s1523 :: SWord1 = choose [0:0] s1506 s1524 :: SBool = s19 /= s1523 s1525 :: SWord8 = s1511 >>> 1 s1526 :: SWord8 = s24 | s1525 s1527 :: SWord8 = s26 & s1525 s1528 :: SWord8 = if s1524 then s1526 else s1527 s1529 :: SWord8 = if s29 then s1446 else s1088 s1530 :: SWord8 = if s170 then s1463 else s1529 s1531 :: SWord8 = if s29 then s1468 else s1530 s1532 :: SWord8 = if s170 then s1484 else s1531 s1533 :: SWord8 = if s29 then s1489 else s1532 s1534 :: SWord8 = if s170 then s1505 else s1533 s1535 :: SWord8 = if s29 then s1510 else s1534 s1536 :: SWord8 = if s170 then s1528 else s1535 s1537 :: SWord8 = s1518 + s1536 s1538 :: SBool = s1537 < s1536 s1539 :: SBool = s1537 < s1518 s1540 :: SBool = s1538 | s1539 s1541 :: SWord8 = s1537 >>> 1 s1542 :: SWord8 = s24 | s1541 s1543 :: SWord8 = s26 & s1541 s1544 :: SWord8 = if s1540 then s1542 else s1543 s1545 :: SWord8 = if s1514 then s1522 else s1544 s1546 :: SWord8 = s1497 + s1534 s1547 :: SWord1 = choose [0:0] s1546 s1548 :: SBool = s19 /= s1547 s1549 :: SWord8 = if s1548 then s1508 else s1509 s1550 :: SWord8 = if s22 then s1549 else s1505 s1551 :: SWord1 = choose [0:0] s1550 s1552 :: SBool = s19 /= s1551 s1553 :: SBool = s_2 == s1552 s1554 :: SBool = s1546 < s1534 s1555 :: SBool = s1546 < s1497 s1556 :: SBool = s1554 | s1555 s1557 :: SWord8 = s1546 >>> 1 s1558 :: SWord8 = s24 | s1557 s1559 :: SWord8 = s26 & s1557 s1560 :: SWord8 = if s1556 then s1558 else s1559 s1561 :: SWord8 = s1560 >>> 1 s1562 :: SWord8 = s24 | s1561 s1563 :: SWord8 = s26 & s1561 s1564 :: SWord8 = if s1552 then s1562 else s1563 s1565 :: SWord8 = s1550 >>> 1 s1566 :: SWord8 = s24 | s1565 s1567 :: SWord8 = s26 & s1565 s1568 :: SWord8 = if s1524 then s1566 else s1567 s1569 :: SWord8 = if s29 then s1549 else s1534 s1570 :: SWord8 = if s170 then s1568 else s1569 s1571 :: SWord8 = s1560 + s1570 s1572 :: SBool = s1571 < s1570 s1573 :: SBool = s1571 < s1560 s1574 :: SBool = s1572 | s1573 s1575 :: SWord8 = s1571 >>> 1 s1576 :: SWord8 = s24 | s1575 s1577 :: SWord8 = s26 & s1575 s1578 :: SWord8 = if s1574 then s1576 else s1577 s1579 :: SWord8 = if s1553 then s1564 else s1578 s1580 :: SWord8 = if s1493 then s1545 else s1579 s1581 :: SWord8 = s1476 + s1532 s1582 :: SWord1 = choose [0:0] s1581 s1583 :: SBool = s19 /= s1582 s1584 :: SWord8 = if s1583 then s1487 else s1488 s1585 :: SWord8 = if s22 then s1584 else s1484 s1586 :: SWord1 = choose [0:0] s1585 s1587 :: SBool = s19 /= s1586 s1588 :: SBool = s_2 == s1587 s1589 :: SBool = s1581 < s1532 s1590 :: SBool = s1581 < s1476 s1591 :: SBool = s1589 | s1590 s1592 :: SWord8 = s1581 >>> 1 s1593 :: SWord8 = s24 | s1592 s1594 :: SWord8 = s26 & s1592 s1595 :: SWord8 = if s1591 then s1593 else s1594 s1596 :: SWord1 = choose [0:0] s1595 s1597 :: SBool = s19 /= s1596 s1598 :: SWord8 = s1585 >>> 1 s1599 :: SWord8 = s24 | s1598 s1600 :: SWord8 = s26 & s1598 s1601 :: SWord8 = if s1501 then s1599 else s1600 s1602 :: SWord8 = if s22 then s1601 else s1584 s1603 :: SWord8 = s1602 >>> 1 s1604 :: SWord8 = s24 | s1603 s1605 :: SWord8 = s26 & s1603 s1606 :: SWord8 = if s1597 then s1604 else s1605 s1607 :: SWord8 = if s22 then s1606 else s1601 s1608 :: SWord1 = choose [0:0] s1607 s1609 :: SBool = s19 /= s1608 s1610 :: SBool = s_2 == s1609 s1611 :: SWord8 = s1595 >>> 1 s1612 :: SWord8 = s24 | s1611 s1613 :: SWord8 = s26 & s1611 s1614 :: SWord8 = if s1587 then s1612 else s1613 s1615 :: SWord8 = s1614 >>> 1 s1616 :: SWord8 = s24 | s1615 s1617 :: SWord8 = s26 & s1615 s1618 :: SWord8 = if s1609 then s1616 else s1617 s1619 :: SWord1 = choose [0:0] s1602 s1620 :: SBool = s19 /= s1619 s1621 :: SWord8 = s1607 >>> 1 s1622 :: SWord8 = s24 | s1621 s1623 :: SWord8 = s26 & s1621 s1624 :: SWord8 = if s1620 then s1622 else s1623 s1625 :: SWord8 = if s29 then s1584 else s1532 s1626 :: SWord8 = if s170 then s1601 else s1625 s1627 :: SWord8 = if s29 then s1606 else s1626 s1628 :: SWord8 = if s170 then s1624 else s1627 s1629 :: SWord8 = s1614 + s1628 s1630 :: SBool = s1629 < s1628 s1631 :: SBool = s1629 < s1614 s1632 :: SBool = s1630 | s1631 s1633 :: SWord8 = s1629 >>> 1 s1634 :: SWord8 = s24 | s1633 s1635 :: SWord8 = s26 & s1633 s1636 :: SWord8 = if s1632 then s1634 else s1635 s1637 :: SWord8 = if s1610 then s1618 else s1636 s1638 :: SWord8 = s1595 + s1626 s1639 :: SWord1 = choose [0:0] s1638 s1640 :: SBool = s19 /= s1639 s1641 :: SWord8 = if s1640 then s1604 else s1605 s1642 :: SWord8 = if s22 then s1641 else s1601 s1643 :: SWord1 = choose [0:0] s1642 s1644 :: SBool = s19 /= s1643 s1645 :: SBool = s_2 == s1644 s1646 :: SBool = s1638 < s1626 s1647 :: SBool = s1638 < s1595 s1648 :: SBool = s1646 | s1647 s1649 :: SWord8 = s1638 >>> 1 s1650 :: SWord8 = s24 | s1649 s1651 :: SWord8 = s26 & s1649 s1652 :: SWord8 = if s1648 then s1650 else s1651 s1653 :: SWord8 = s1652 >>> 1 s1654 :: SWord8 = s24 | s1653 s1655 :: SWord8 = s26 & s1653 s1656 :: SWord8 = if s1644 then s1654 else s1655 s1657 :: SWord8 = s1642 >>> 1 s1658 :: SWord8 = s24 | s1657 s1659 :: SWord8 = s26 & s1657 s1660 :: SWord8 = if s1620 then s1658 else s1659 s1661 :: SWord8 = if s29 then s1641 else s1626 s1662 :: SWord8 = if s170 then s1660 else s1661 s1663 :: SWord8 = s1652 + s1662 s1664 :: SBool = s1663 < s1662 s1665 :: SBool = s1663 < s1652 s1666 :: SBool = s1664 | s1665 s1667 :: SWord8 = s1663 >>> 1 s1668 :: SWord8 = s24 | s1667 s1669 :: SWord8 = s26 & s1667 s1670 :: SWord8 = if s1666 then s1668 else s1669 s1671 :: SWord8 = if s1645 then s1656 else s1670 s1672 :: SWord8 = if s1588 then s1637 else s1671 s1673 :: SWord8 = if s1472 then s1580 else s1672 s1674 :: SWord8 = s1457 + s1530 s1675 :: SWord1 = choose [0:0] s1674 s1676 :: SBool = s19 /= s1675 s1677 :: SWord8 = if s1676 then s1466 else s1467 s1678 :: SWord8 = if s22 then s1677 else s1463 s1679 :: SWord1 = choose [0:0] s1678 s1680 :: SBool = s19 /= s1679 s1681 :: SBool = s_2 == s1680 s1682 :: SBool = s1674 < s1530 s1683 :: SBool = s1674 < s1457 s1684 :: SBool = s1682 | s1683 s1685 :: SWord8 = s1674 >>> 1 s1686 :: SWord8 = s24 | s1685 s1687 :: SWord8 = s26 & s1685 s1688 :: SWord8 = if s1684 then s1686 else s1687 s1689 :: SWord1 = choose [0:0] s1688 s1690 :: SBool = s19 /= s1689 s1691 :: SWord8 = s1678 >>> 1 s1692 :: SWord8 = s24 | s1691 s1693 :: SWord8 = s26 & s1691 s1694 :: SWord8 = if s1480 then s1692 else s1693 s1695 :: SWord8 = if s22 then s1694 else s1677 s1696 :: SWord8 = s1695 >>> 1 s1697 :: SWord8 = s24 | s1696 s1698 :: SWord8 = s26 & s1696 s1699 :: SWord8 = if s1690 then s1697 else s1698 s1700 :: SWord8 = if s22 then s1699 else s1694 s1701 :: SWord1 = choose [0:0] s1700 s1702 :: SBool = s19 /= s1701 s1703 :: SBool = s_2 == s1702 s1704 :: SWord8 = s1688 >>> 1 s1705 :: SWord8 = s24 | s1704 s1706 :: SWord8 = s26 & s1704 s1707 :: SWord8 = if s1680 then s1705 else s1706 s1708 :: SWord1 = choose [0:0] s1707 s1709 :: SBool = s19 /= s1708 s1710 :: SWord1 = choose [0:0] s1695 s1711 :: SBool = s19 /= s1710 s1712 :: SWord8 = s1700 >>> 1 s1713 :: SWord8 = s24 | s1712 s1714 :: SWord8 = s26 & s1712 s1715 :: SWord8 = if s1711 then s1713 else s1714 s1716 :: SWord8 = if s22 then s1715 else s1699 s1717 :: SWord8 = s1716 >>> 1 s1718 :: SWord8 = s24 | s1717 s1719 :: SWord8 = s26 & s1717 s1720 :: SWord8 = if s1709 then s1718 else s1719 s1721 :: SWord8 = if s22 then s1720 else s1715 s1722 :: SWord1 = choose [0:0] s1721 s1723 :: SBool = s19 /= s1722 s1724 :: SBool = s_2 == s1723 s1725 :: SWord8 = s1707 >>> 1 s1726 :: SWord8 = s24 | s1725 s1727 :: SWord8 = s26 & s1725 s1728 :: SWord8 = if s1702 then s1726 else s1727 s1729 :: SWord8 = s1728 >>> 1 s1730 :: SWord8 = s24 | s1729 s1731 :: SWord8 = s26 & s1729 s1732 :: SWord8 = if s1723 then s1730 else s1731 s1733 :: SWord1 = choose [0:0] s1716 s1734 :: SBool = s19 /= s1733 s1735 :: SWord8 = s1721 >>> 1 s1736 :: SWord8 = s24 | s1735 s1737 :: SWord8 = s26 & s1735 s1738 :: SWord8 = if s1734 then s1736 else s1737 s1739 :: SWord8 = if s29 then s1677 else s1530 s1740 :: SWord8 = if s170 then s1694 else s1739 s1741 :: SWord8 = if s29 then s1699 else s1740 s1742 :: SWord8 = if s170 then s1715 else s1741 s1743 :: SWord8 = if s29 then s1720 else s1742 s1744 :: SWord8 = if s170 then s1738 else s1743 s1745 :: SWord8 = s1728 + s1744 s1746 :: SBool = s1745 < s1744 s1747 :: SBool = s1745 < s1728 s1748 :: SBool = s1746 | s1747 s1749 :: SWord8 = s1745 >>> 1 s1750 :: SWord8 = s24 | s1749 s1751 :: SWord8 = s26 & s1749 s1752 :: SWord8 = if s1748 then s1750 else s1751 s1753 :: SWord8 = if s1724 then s1732 else s1752 s1754 :: SWord8 = s1707 + s1742 s1755 :: SWord1 = choose [0:0] s1754 s1756 :: SBool = s19 /= s1755 s1757 :: SWord8 = if s1756 then s1718 else s1719 s1758 :: SWord8 = if s22 then s1757 else s1715 s1759 :: SWord1 = choose [0:0] s1758 s1760 :: SBool = s19 /= s1759 s1761 :: SBool = s_2 == s1760 s1762 :: SBool = s1754 < s1742 s1763 :: SBool = s1754 < s1707 s1764 :: SBool = s1762 | s1763 s1765 :: SWord8 = s1754 >>> 1 s1766 :: SWord8 = s24 | s1765 s1767 :: SWord8 = s26 & s1765 s1768 :: SWord8 = if s1764 then s1766 else s1767 s1769 :: SWord8 = s1768 >>> 1 s1770 :: SWord8 = s24 | s1769 s1771 :: SWord8 = s26 & s1769 s1772 :: SWord8 = if s1760 then s1770 else s1771 s1773 :: SWord8 = s1758 >>> 1 s1774 :: SWord8 = s24 | s1773 s1775 :: SWord8 = s26 & s1773 s1776 :: SWord8 = if s1734 then s1774 else s1775 s1777 :: SWord8 = if s29 then s1757 else s1742 s1778 :: SWord8 = if s170 then s1776 else s1777 s1779 :: SWord8 = s1768 + s1778 s1780 :: SBool = s1779 < s1778 s1781 :: SBool = s1779 < s1768 s1782 :: SBool = s1780 | s1781 s1783 :: SWord8 = s1779 >>> 1 s1784 :: SWord8 = s24 | s1783 s1785 :: SWord8 = s26 & s1783 s1786 :: SWord8 = if s1782 then s1784 else s1785 s1787 :: SWord8 = if s1761 then s1772 else s1786 s1788 :: SWord8 = if s1703 then s1753 else s1787 s1789 :: SWord8 = s1688 + s1740 s1790 :: SWord1 = choose [0:0] s1789 s1791 :: SBool = s19 /= s1790 s1792 :: SWord8 = if s1791 then s1697 else s1698 s1793 :: SWord8 = if s22 then s1792 else s1694 s1794 :: SWord1 = choose [0:0] s1793 s1795 :: SBool = s19 /= s1794 s1796 :: SBool = s_2 == s1795 s1797 :: SBool = s1789 < s1740 s1798 :: SBool = s1789 < s1688 s1799 :: SBool = s1797 | s1798 s1800 :: SWord8 = s1789 >>> 1 s1801 :: SWord8 = s24 | s1800 s1802 :: SWord8 = s26 & s1800 s1803 :: SWord8 = if s1799 then s1801 else s1802 s1804 :: SWord1 = choose [0:0] s1803 s1805 :: SBool = s19 /= s1804 s1806 :: SWord8 = s1793 >>> 1 s1807 :: SWord8 = s24 | s1806 s1808 :: SWord8 = s26 & s1806 s1809 :: SWord8 = if s1711 then s1807 else s1808 s1810 :: SWord8 = if s22 then s1809 else s1792 s1811 :: SWord8 = s1810 >>> 1 s1812 :: SWord8 = s24 | s1811 s1813 :: SWord8 = s26 & s1811 s1814 :: SWord8 = if s1805 then s1812 else s1813 s1815 :: SWord8 = if s22 then s1814 else s1809 s1816 :: SWord1 = choose [0:0] s1815 s1817 :: SBool = s19 /= s1816 s1818 :: SBool = s_2 == s1817 s1819 :: SWord8 = s1803 >>> 1 s1820 :: SWord8 = s24 | s1819 s1821 :: SWord8 = s26 & s1819 s1822 :: SWord8 = if s1795 then s1820 else s1821 s1823 :: SWord8 = s1822 >>> 1 s1824 :: SWord8 = s24 | s1823 s1825 :: SWord8 = s26 & s1823 s1826 :: SWord8 = if s1817 then s1824 else s1825 s1827 :: SWord1 = choose [0:0] s1810 s1828 :: SBool = s19 /= s1827 s1829 :: SWord8 = s1815 >>> 1 s1830 :: SWord8 = s24 | s1829 s1831 :: SWord8 = s26 & s1829 s1832 :: SWord8 = if s1828 then s1830 else s1831 s1833 :: SWord8 = if s29 then s1792 else s1740 s1834 :: SWord8 = if s170 then s1809 else s1833 s1835 :: SWord8 = if s29 then s1814 else s1834 s1836 :: SWord8 = if s170 then s1832 else s1835 s1837 :: SWord8 = s1822 + s1836 s1838 :: SBool = s1837 < s1836 s1839 :: SBool = s1837 < s1822 s1840 :: SBool = s1838 | s1839 s1841 :: SWord8 = s1837 >>> 1 s1842 :: SWord8 = s24 | s1841 s1843 :: SWord8 = s26 & s1841 s1844 :: SWord8 = if s1840 then s1842 else s1843 s1845 :: SWord8 = if s1818 then s1826 else s1844 s1846 :: SWord8 = s1803 + s1834 s1847 :: SWord1 = choose [0:0] s1846 s1848 :: SBool = s19 /= s1847 s1849 :: SWord8 = if s1848 then s1812 else s1813 s1850 :: SWord8 = if s22 then s1849 else s1809 s1851 :: SWord1 = choose [0:0] s1850 s1852 :: SBool = s19 /= s1851 s1853 :: SBool = s_2 == s1852 s1854 :: SBool = s1846 < s1834 s1855 :: SBool = s1846 < s1803 s1856 :: SBool = s1854 | s1855 s1857 :: SWord8 = s1846 >>> 1 s1858 :: SWord8 = s24 | s1857 s1859 :: SWord8 = s26 & s1857 s1860 :: SWord8 = if s1856 then s1858 else s1859 s1861 :: SWord8 = s1860 >>> 1 s1862 :: SWord8 = s24 | s1861 s1863 :: SWord8 = s26 & s1861 s1864 :: SWord8 = if s1852 then s1862 else s1863 s1865 :: SWord8 = s1850 >>> 1 s1866 :: SWord8 = s24 | s1865 s1867 :: SWord8 = s26 & s1865 s1868 :: SWord8 = if s1828 then s1866 else s1867 s1869 :: SWord8 = if s29 then s1849 else s1834 s1870 :: SWord8 = if s170 then s1868 else s1869 s1871 :: SWord8 = s1860 + s1870 s1872 :: SBool = s1871 < s1870 s1873 :: SBool = s1871 < s1860 s1874 :: SBool = s1872 | s1873 s1875 :: SWord8 = s1871 >>> 1 s1876 :: SWord8 = s24 | s1875 s1877 :: SWord8 = s26 & s1875 s1878 :: SWord8 = if s1874 then s1876 else s1877 s1879 :: SWord8 = if s1853 then s1864 else s1878 s1880 :: SWord8 = if s1796 then s1845 else s1879 s1881 :: SWord8 = if s1681 then s1788 else s1880 s1882 :: SWord8 = if s1450 then s1673 else s1881 s1883 :: SWord8 = if s987 then s1442 else s1882 s1884 :: SWord8 = if s56 then s979 else s1883 s1885 :: SWord8 = s39 + s180 s1886 :: SWord1 = choose [0:0] s1885 s1887 :: SBool = s19 /= s1886 s1888 :: SWord8 = if s1887 then s50 else s51 s1889 :: SWord8 = if s22 then s1888 else s47 s1890 :: SWord1 = choose [0:0] s1889 s1891 :: SBool = s19 /= s1890 s1892 :: SBool = s_2 == s1891 s1893 :: SBool = s1885 < s180 s1894 :: SBool = s1885 < s39 s1895 :: SBool = s1893 | s1894 s1896 :: SWord8 = s1885 >>> 1 s1897 :: SWord8 = s24 | s1896 s1898 :: SWord8 = s26 & s1896 s1899 :: SWord8 = if s1895 then s1897 else s1898 s1900 :: SWord1 = choose [0:0] s1899 s1901 :: SBool = s19 /= s1900 s1902 :: SWord8 = s1889 >>> 1 s1903 :: SWord8 = s24 | s1902 s1904 :: SWord8 = s26 & s1902 s1905 :: SWord8 = if s64 then s1903 else s1904 s1906 :: SWord8 = if s22 then s1905 else s1888 s1907 :: SWord8 = s1906 >>> 1 s1908 :: SWord8 = s24 | s1907 s1909 :: SWord8 = s26 & s1907 s1910 :: SWord8 = if s1901 then s1908 else s1909 s1911 :: SWord8 = if s22 then s1910 else s1905 s1912 :: SWord1 = choose [0:0] s1911 s1913 :: SBool = s19 /= s1912 s1914 :: SBool = s_2 == s1913 s1915 :: SWord8 = s1899 >>> 1 s1916 :: SWord8 = s24 | s1915 s1917 :: SWord8 = s26 & s1915 s1918 :: SWord8 = if s1891 then s1916 else s1917 s1919 :: SWord1 = choose [0:0] s1918 s1920 :: SBool = s19 /= s1919 s1921 :: SWord1 = choose [0:0] s1906 s1922 :: SBool = s19 /= s1921 s1923 :: SWord8 = s1911 >>> 1 s1924 :: SWord8 = s24 | s1923 s1925 :: SWord8 = s26 & s1923 s1926 :: SWord8 = if s1922 then s1924 else s1925 s1927 :: SWord8 = if s22 then s1926 else s1910 s1928 :: SWord8 = s1927 >>> 1 s1929 :: SWord8 = s24 | s1928 s1930 :: SWord8 = s26 & s1928 s1931 :: SWord8 = if s1920 then s1929 else s1930 s1932 :: SWord8 = if s22 then s1931 else s1926 s1933 :: SWord1 = choose [0:0] s1932 s1934 :: SBool = s19 /= s1933 s1935 :: SBool = s_2 == s1934 s1936 :: SWord8 = s1918 >>> 1 s1937 :: SWord8 = s24 | s1936 s1938 :: SWord8 = s26 & s1936 s1939 :: SWord8 = if s1913 then s1937 else s1938 s1940 :: SWord1 = choose [0:0] s1939 s1941 :: SBool = s19 /= s1940 s1942 :: SWord1 = choose [0:0] s1927 s1943 :: SBool = s19 /= s1942 s1944 :: SWord8 = s1932 >>> 1 s1945 :: SWord8 = s24 | s1944 s1946 :: SWord8 = s26 & s1944 s1947 :: SWord8 = if s1943 then s1945 else s1946 s1948 :: SWord8 = if s22 then s1947 else s1931 s1949 :: SWord8 = s1948 >>> 1 s1950 :: SWord8 = s24 | s1949 s1951 :: SWord8 = s26 & s1949 s1952 :: SWord8 = if s1941 then s1950 else s1951 s1953 :: SWord8 = if s22 then s1952 else s1947 s1954 :: SWord1 = choose [0:0] s1953 s1955 :: SBool = s19 /= s1954 s1956 :: SBool = s_2 == s1955 s1957 :: SWord8 = s1939 >>> 1 s1958 :: SWord8 = s24 | s1957 s1959 :: SWord8 = s26 & s1957 s1960 :: SWord8 = if s1934 then s1958 else s1959 s1961 :: SWord1 = choose [0:0] s1960 s1962 :: SBool = s19 /= s1961 s1963 :: SWord1 = choose [0:0] s1948 s1964 :: SBool = s19 /= s1963 s1965 :: SWord8 = s1953 >>> 1 s1966 :: SWord8 = s24 | s1965 s1967 :: SWord8 = s26 & s1965 s1968 :: SWord8 = if s1964 then s1966 else s1967 s1969 :: SWord8 = if s22 then s1968 else s1952 s1970 :: SWord8 = s1969 >>> 1 s1971 :: SWord8 = s24 | s1970 s1972 :: SWord8 = s26 & s1970 s1973 :: SWord8 = if s1962 then s1971 else s1972 s1974 :: SWord8 = if s22 then s1973 else s1968 s1975 :: SWord1 = choose [0:0] s1974 s1976 :: SBool = s19 /= s1975 s1977 :: SBool = s_2 == s1976 s1978 :: SWord8 = s1960 >>> 1 s1979 :: SWord8 = s24 | s1978 s1980 :: SWord8 = s26 & s1978 s1981 :: SWord8 = if s1955 then s1979 else s1980 s1982 :: SWord1 = choose [0:0] s1981 s1983 :: SBool = s19 /= s1982 s1984 :: SWord1 = choose [0:0] s1969 s1985 :: SBool = s19 /= s1984 s1986 :: SWord8 = s1974 >>> 1 s1987 :: SWord8 = s24 | s1986 s1988 :: SWord8 = s26 & s1986 s1989 :: SWord8 = if s1985 then s1987 else s1988 s1990 :: SWord8 = if s22 then s1989 else s1973 s1991 :: SWord8 = s1990 >>> 1 s1992 :: SWord8 = s24 | s1991 s1993 :: SWord8 = s26 & s1991 s1994 :: SWord8 = if s1983 then s1992 else s1993 s1995 :: SWord8 = if s22 then s1994 else s1989 s1996 :: SWord1 = choose [0:0] s1995 s1997 :: SBool = s19 /= s1996 s1998 :: SBool = s_2 == s1997 s1999 :: SWord8 = s1981 >>> 1 s2000 :: SWord8 = s24 | s1999 s2001 :: SWord8 = s26 & s1999 s2002 :: SWord8 = if s1976 then s2000 else s2001 s2003 :: SWord8 = s2002 >>> 1 s2004 :: SWord8 = s24 | s2003 s2005 :: SWord8 = s26 & s2003 s2006 :: SWord8 = if s1997 then s2004 else s2005 s2007 :: SWord1 = choose [0:0] s1990 s2008 :: SBool = s19 /= s2007 s2009 :: SWord8 = s1995 >>> 1 s2010 :: SWord8 = s24 | s2009 s2011 :: SWord8 = s26 & s2009 s2012 :: SWord8 = if s2008 then s2010 else s2011 s2013 :: SWord8 = if s29 then s1888 else s180 s2014 :: SWord8 = if s170 then s1905 else s2013 s2015 :: SWord8 = if s29 then s1910 else s2014 s2016 :: SWord8 = if s170 then s1926 else s2015 s2017 :: SWord8 = if s29 then s1931 else s2016 s2018 :: SWord8 = if s170 then s1947 else s2017 s2019 :: SWord8 = if s29 then s1952 else s2018 s2020 :: SWord8 = if s170 then s1968 else s2019 s2021 :: SWord8 = if s29 then s1973 else s2020 s2022 :: SWord8 = if s170 then s1989 else s2021 s2023 :: SWord8 = if s29 then s1994 else s2022 s2024 :: SWord8 = if s170 then s2012 else s2023 s2025 :: SWord8 = s2002 + s2024 s2026 :: SBool = s2025 < s2024 s2027 :: SBool = s2025 < s2002 s2028 :: SBool = s2026 | s2027 s2029 :: SWord8 = s2025 >>> 1 s2030 :: SWord8 = s24 | s2029 s2031 :: SWord8 = s26 & s2029 s2032 :: SWord8 = if s2028 then s2030 else s2031 s2033 :: SWord8 = if s1998 then s2006 else s2032 s2034 :: SWord8 = s1981 + s2022 s2035 :: SWord1 = choose [0:0] s2034 s2036 :: SBool = s19 /= s2035 s2037 :: SWord8 = if s2036 then s1992 else s1993 s2038 :: SWord8 = if s22 then s2037 else s1989 s2039 :: SWord1 = choose [0:0] s2038 s2040 :: SBool = s19 /= s2039 s2041 :: SBool = s_2 == s2040 s2042 :: SBool = s2034 < s2022 s2043 :: SBool = s2034 < s1981 s2044 :: SBool = s2042 | s2043 s2045 :: SWord8 = s2034 >>> 1 s2046 :: SWord8 = s24 | s2045 s2047 :: SWord8 = s26 & s2045 s2048 :: SWord8 = if s2044 then s2046 else s2047 s2049 :: SWord8 = s2048 >>> 1 s2050 :: SWord8 = s24 | s2049 s2051 :: SWord8 = s26 & s2049 s2052 :: SWord8 = if s2040 then s2050 else s2051 s2053 :: SWord8 = s2038 >>> 1 s2054 :: SWord8 = s24 | s2053 s2055 :: SWord8 = s26 & s2053 s2056 :: SWord8 = if s2008 then s2054 else s2055 s2057 :: SWord8 = if s29 then s2037 else s2022 s2058 :: SWord8 = if s170 then s2056 else s2057 s2059 :: SWord8 = s2048 + s2058 s2060 :: SBool = s2059 < s2058 s2061 :: SBool = s2059 < s2048 s2062 :: SBool = s2060 | s2061 s2063 :: SWord8 = s2059 >>> 1 s2064 :: SWord8 = s24 | s2063 s2065 :: SWord8 = s26 & s2063 s2066 :: SWord8 = if s2062 then s2064 else s2065 s2067 :: SWord8 = if s2041 then s2052 else s2066 s2068 :: SWord8 = if s1977 then s2033 else s2067 s2069 :: SWord8 = s1960 + s2020 s2070 :: SWord1 = choose [0:0] s2069 s2071 :: SBool = s19 /= s2070 s2072 :: SWord8 = if s2071 then s1971 else s1972 s2073 :: SWord8 = if s22 then s2072 else s1968 s2074 :: SWord1 = choose [0:0] s2073 s2075 :: SBool = s19 /= s2074 s2076 :: SBool = s_2 == s2075 s2077 :: SBool = s2069 < s2020 s2078 :: SBool = s2069 < s1960 s2079 :: SBool = s2077 | s2078 s2080 :: SWord8 = s2069 >>> 1 s2081 :: SWord8 = s24 | s2080 s2082 :: SWord8 = s26 & s2080 s2083 :: SWord8 = if s2079 then s2081 else s2082 s2084 :: SWord1 = choose [0:0] s2083 s2085 :: SBool = s19 /= s2084 s2086 :: SWord8 = s2073 >>> 1 s2087 :: SWord8 = s24 | s2086 s2088 :: SWord8 = s26 & s2086 s2089 :: SWord8 = if s1985 then s2087 else s2088 s2090 :: SWord8 = if s22 then s2089 else s2072 s2091 :: SWord8 = s2090 >>> 1 s2092 :: SWord8 = s24 | s2091 s2093 :: SWord8 = s26 & s2091 s2094 :: SWord8 = if s2085 then s2092 else s2093 s2095 :: SWord8 = if s22 then s2094 else s2089 s2096 :: SWord1 = choose [0:0] s2095 s2097 :: SBool = s19 /= s2096 s2098 :: SBool = s_2 == s2097 s2099 :: SWord8 = s2083 >>> 1 s2100 :: SWord8 = s24 | s2099 s2101 :: SWord8 = s26 & s2099 s2102 :: SWord8 = if s2075 then s2100 else s2101 s2103 :: SWord8 = s2102 >>> 1 s2104 :: SWord8 = s24 | s2103 s2105 :: SWord8 = s26 & s2103 s2106 :: SWord8 = if s2097 then s2104 else s2105 s2107 :: SWord1 = choose [0:0] s2090 s2108 :: SBool = s19 /= s2107 s2109 :: SWord8 = s2095 >>> 1 s2110 :: SWord8 = s24 | s2109 s2111 :: SWord8 = s26 & s2109 s2112 :: SWord8 = if s2108 then s2110 else s2111 s2113 :: SWord8 = if s29 then s2072 else s2020 s2114 :: SWord8 = if s170 then s2089 else s2113 s2115 :: SWord8 = if s29 then s2094 else s2114 s2116 :: SWord8 = if s170 then s2112 else s2115 s2117 :: SWord8 = s2102 + s2116 s2118 :: SBool = s2117 < s2116 s2119 :: SBool = s2117 < s2102 s2120 :: SBool = s2118 | s2119 s2121 :: SWord8 = s2117 >>> 1 s2122 :: SWord8 = s24 | s2121 s2123 :: SWord8 = s26 & s2121 s2124 :: SWord8 = if s2120 then s2122 else s2123 s2125 :: SWord8 = if s2098 then s2106 else s2124 s2126 :: SWord8 = s2083 + s2114 s2127 :: SWord1 = choose [0:0] s2126 s2128 :: SBool = s19 /= s2127 s2129 :: SWord8 = if s2128 then s2092 else s2093 s2130 :: SWord8 = if s22 then s2129 else s2089 s2131 :: SWord1 = choose [0:0] s2130 s2132 :: SBool = s19 /= s2131 s2133 :: SBool = s_2 == s2132 s2134 :: SBool = s2126 < s2114 s2135 :: SBool = s2126 < s2083 s2136 :: SBool = s2134 | s2135 s2137 :: SWord8 = s2126 >>> 1 s2138 :: SWord8 = s24 | s2137 s2139 :: SWord8 = s26 & s2137 s2140 :: SWord8 = if s2136 then s2138 else s2139 s2141 :: SWord8 = s2140 >>> 1 s2142 :: SWord8 = s24 | s2141 s2143 :: SWord8 = s26 & s2141 s2144 :: SWord8 = if s2132 then s2142 else s2143 s2145 :: SWord8 = s2130 >>> 1 s2146 :: SWord8 = s24 | s2145 s2147 :: SWord8 = s26 & s2145 s2148 :: SWord8 = if s2108 then s2146 else s2147 s2149 :: SWord8 = if s29 then s2129 else s2114 s2150 :: SWord8 = if s170 then s2148 else s2149 s2151 :: SWord8 = s2140 + s2150 s2152 :: SBool = s2151 < s2150 s2153 :: SBool = s2151 < s2140 s2154 :: SBool = s2152 | s2153 s2155 :: SWord8 = s2151 >>> 1 s2156 :: SWord8 = s24 | s2155 s2157 :: SWord8 = s26 & s2155 s2158 :: SWord8 = if s2154 then s2156 else s2157 s2159 :: SWord8 = if s2133 then s2144 else s2158 s2160 :: SWord8 = if s2076 then s2125 else s2159 s2161 :: SWord8 = if s1956 then s2068 else s2160 s2162 :: SWord8 = s1939 + s2018 s2163 :: SWord1 = choose [0:0] s2162 s2164 :: SBool = s19 /= s2163 s2165 :: SWord8 = if s2164 then s1950 else s1951 s2166 :: SWord8 = if s22 then s2165 else s1947 s2167 :: SWord1 = choose [0:0] s2166 s2168 :: SBool = s19 /= s2167 s2169 :: SBool = s_2 == s2168 s2170 :: SBool = s2162 < s2018 s2171 :: SBool = s2162 < s1939 s2172 :: SBool = s2170 | s2171 s2173 :: SWord8 = s2162 >>> 1 s2174 :: SWord8 = s24 | s2173 s2175 :: SWord8 = s26 & s2173 s2176 :: SWord8 = if s2172 then s2174 else s2175 s2177 :: SWord1 = choose [0:0] s2176 s2178 :: SBool = s19 /= s2177 s2179 :: SWord8 = s2166 >>> 1 s2180 :: SWord8 = s24 | s2179 s2181 :: SWord8 = s26 & s2179 s2182 :: SWord8 = if s1964 then s2180 else s2181 s2183 :: SWord8 = if s22 then s2182 else s2165 s2184 :: SWord8 = s2183 >>> 1 s2185 :: SWord8 = s24 | s2184 s2186 :: SWord8 = s26 & s2184 s2187 :: SWord8 = if s2178 then s2185 else s2186 s2188 :: SWord8 = if s22 then s2187 else s2182 s2189 :: SWord1 = choose [0:0] s2188 s2190 :: SBool = s19 /= s2189 s2191 :: SBool = s_2 == s2190 s2192 :: SWord8 = s2176 >>> 1 s2193 :: SWord8 = s24 | s2192 s2194 :: SWord8 = s26 & s2192 s2195 :: SWord8 = if s2168 then s2193 else s2194 s2196 :: SWord1 = choose [0:0] s2195 s2197 :: SBool = s19 /= s2196 s2198 :: SWord1 = choose [0:0] s2183 s2199 :: SBool = s19 /= s2198 s2200 :: SWord8 = s2188 >>> 1 s2201 :: SWord8 = s24 | s2200 s2202 :: SWord8 = s26 & s2200 s2203 :: SWord8 = if s2199 then s2201 else s2202 s2204 :: SWord8 = if s22 then s2203 else s2187 s2205 :: SWord8 = s2204 >>> 1 s2206 :: SWord8 = s24 | s2205 s2207 :: SWord8 = s26 & s2205 s2208 :: SWord8 = if s2197 then s2206 else s2207 s2209 :: SWord8 = if s22 then s2208 else s2203 s2210 :: SWord1 = choose [0:0] s2209 s2211 :: SBool = s19 /= s2210 s2212 :: SBool = s_2 == s2211 s2213 :: SWord8 = s2195 >>> 1 s2214 :: SWord8 = s24 | s2213 s2215 :: SWord8 = s26 & s2213 s2216 :: SWord8 = if s2190 then s2214 else s2215 s2217 :: SWord8 = s2216 >>> 1 s2218 :: SWord8 = s24 | s2217 s2219 :: SWord8 = s26 & s2217 s2220 :: SWord8 = if s2211 then s2218 else s2219 s2221 :: SWord1 = choose [0:0] s2204 s2222 :: SBool = s19 /= s2221 s2223 :: SWord8 = s2209 >>> 1 s2224 :: SWord8 = s24 | s2223 s2225 :: SWord8 = s26 & s2223 s2226 :: SWord8 = if s2222 then s2224 else s2225 s2227 :: SWord8 = if s29 then s2165 else s2018 s2228 :: SWord8 = if s170 then s2182 else s2227 s2229 :: SWord8 = if s29 then s2187 else s2228 s2230 :: SWord8 = if s170 then s2203 else s2229 s2231 :: SWord8 = if s29 then s2208 else s2230 s2232 :: SWord8 = if s170 then s2226 else s2231 s2233 :: SWord8 = s2216 + s2232 s2234 :: SBool = s2233 < s2232 s2235 :: SBool = s2233 < s2216 s2236 :: SBool = s2234 | s2235 s2237 :: SWord8 = s2233 >>> 1 s2238 :: SWord8 = s24 | s2237 s2239 :: SWord8 = s26 & s2237 s2240 :: SWord8 = if s2236 then s2238 else s2239 s2241 :: SWord8 = if s2212 then s2220 else s2240 s2242 :: SWord8 = s2195 + s2230 s2243 :: SWord1 = choose [0:0] s2242 s2244 :: SBool = s19 /= s2243 s2245 :: SWord8 = if s2244 then s2206 else s2207 s2246 :: SWord8 = if s22 then s2245 else s2203 s2247 :: SWord1 = choose [0:0] s2246 s2248 :: SBool = s19 /= s2247 s2249 :: SBool = s_2 == s2248 s2250 :: SBool = s2242 < s2230 s2251 :: SBool = s2242 < s2195 s2252 :: SBool = s2250 | s2251 s2253 :: SWord8 = s2242 >>> 1 s2254 :: SWord8 = s24 | s2253 s2255 :: SWord8 = s26 & s2253 s2256 :: SWord8 = if s2252 then s2254 else s2255 s2257 :: SWord8 = s2256 >>> 1 s2258 :: SWord8 = s24 | s2257 s2259 :: SWord8 = s26 & s2257 s2260 :: SWord8 = if s2248 then s2258 else s2259 s2261 :: SWord8 = s2246 >>> 1 s2262 :: SWord8 = s24 | s2261 s2263 :: SWord8 = s26 & s2261 s2264 :: SWord8 = if s2222 then s2262 else s2263 s2265 :: SWord8 = if s29 then s2245 else s2230 s2266 :: SWord8 = if s170 then s2264 else s2265 s2267 :: SWord8 = s2256 + s2266 s2268 :: SBool = s2267 < s2266 s2269 :: SBool = s2267 < s2256 s2270 :: SBool = s2268 | s2269 s2271 :: SWord8 = s2267 >>> 1 s2272 :: SWord8 = s24 | s2271 s2273 :: SWord8 = s26 & s2271 s2274 :: SWord8 = if s2270 then s2272 else s2273 s2275 :: SWord8 = if s2249 then s2260 else s2274 s2276 :: SWord8 = if s2191 then s2241 else s2275 s2277 :: SWord8 = s2176 + s2228 s2278 :: SWord1 = choose [0:0] s2277 s2279 :: SBool = s19 /= s2278 s2280 :: SWord8 = if s2279 then s2185 else s2186 s2281 :: SWord8 = if s22 then s2280 else s2182 s2282 :: SWord1 = choose [0:0] s2281 s2283 :: SBool = s19 /= s2282 s2284 :: SBool = s_2 == s2283 s2285 :: SBool = s2277 < s2228 s2286 :: SBool = s2277 < s2176 s2287 :: SBool = s2285 | s2286 s2288 :: SWord8 = s2277 >>> 1 s2289 :: SWord8 = s24 | s2288 s2290 :: SWord8 = s26 & s2288 s2291 :: SWord8 = if s2287 then s2289 else s2290 s2292 :: SWord1 = choose [0:0] s2291 s2293 :: SBool = s19 /= s2292 s2294 :: SWord8 = s2281 >>> 1 s2295 :: SWord8 = s24 | s2294 s2296 :: SWord8 = s26 & s2294 s2297 :: SWord8 = if s2199 then s2295 else s2296 s2298 :: SWord8 = if s22 then s2297 else s2280 s2299 :: SWord8 = s2298 >>> 1 s2300 :: SWord8 = s24 | s2299 s2301 :: SWord8 = s26 & s2299 s2302 :: SWord8 = if s2293 then s2300 else s2301 s2303 :: SWord8 = if s22 then s2302 else s2297 s2304 :: SWord1 = choose [0:0] s2303 s2305 :: SBool = s19 /= s2304 s2306 :: SBool = s_2 == s2305 s2307 :: SWord8 = s2291 >>> 1 s2308 :: SWord8 = s24 | s2307 s2309 :: SWord8 = s26 & s2307 s2310 :: SWord8 = if s2283 then s2308 else s2309 s2311 :: SWord8 = s2310 >>> 1 s2312 :: SWord8 = s24 | s2311 s2313 :: SWord8 = s26 & s2311 s2314 :: SWord8 = if s2305 then s2312 else s2313 s2315 :: SWord1 = choose [0:0] s2298 s2316 :: SBool = s19 /= s2315 s2317 :: SWord8 = s2303 >>> 1 s2318 :: SWord8 = s24 | s2317 s2319 :: SWord8 = s26 & s2317 s2320 :: SWord8 = if s2316 then s2318 else s2319 s2321 :: SWord8 = if s29 then s2280 else s2228 s2322 :: SWord8 = if s170 then s2297 else s2321 s2323 :: SWord8 = if s29 then s2302 else s2322 s2324 :: SWord8 = if s170 then s2320 else s2323 s2325 :: SWord8 = s2310 + s2324 s2326 :: SBool = s2325 < s2324 s2327 :: SBool = s2325 < s2310 s2328 :: SBool = s2326 | s2327 s2329 :: SWord8 = s2325 >>> 1 s2330 :: SWord8 = s24 | s2329 s2331 :: SWord8 = s26 & s2329 s2332 :: SWord8 = if s2328 then s2330 else s2331 s2333 :: SWord8 = if s2306 then s2314 else s2332 s2334 :: SWord8 = s2291 + s2322 s2335 :: SWord1 = choose [0:0] s2334 s2336 :: SBool = s19 /= s2335 s2337 :: SWord8 = if s2336 then s2300 else s2301 s2338 :: SWord8 = if s22 then s2337 else s2297 s2339 :: SWord1 = choose [0:0] s2338 s2340 :: SBool = s19 /= s2339 s2341 :: SBool = s_2 == s2340 s2342 :: SBool = s2334 < s2322 s2343 :: SBool = s2334 < s2291 s2344 :: SBool = s2342 | s2343 s2345 :: SWord8 = s2334 >>> 1 s2346 :: SWord8 = s24 | s2345 s2347 :: SWord8 = s26 & s2345 s2348 :: SWord8 = if s2344 then s2346 else s2347 s2349 :: SWord8 = s2348 >>> 1 s2350 :: SWord8 = s24 | s2349 s2351 :: SWord8 = s26 & s2349 s2352 :: SWord8 = if s2340 then s2350 else s2351 s2353 :: SWord8 = s2338 >>> 1 s2354 :: SWord8 = s24 | s2353 s2355 :: SWord8 = s26 & s2353 s2356 :: SWord8 = if s2316 then s2354 else s2355 s2357 :: SWord8 = if s29 then s2337 else s2322 s2358 :: SWord8 = if s170 then s2356 else s2357 s2359 :: SWord8 = s2348 + s2358 s2360 :: SBool = s2359 < s2358 s2361 :: SBool = s2359 < s2348 s2362 :: SBool = s2360 | s2361 s2363 :: SWord8 = s2359 >>> 1 s2364 :: SWord8 = s24 | s2363 s2365 :: SWord8 = s26 & s2363 s2366 :: SWord8 = if s2362 then s2364 else s2365 s2367 :: SWord8 = if s2341 then s2352 else s2366 s2368 :: SWord8 = if s2284 then s2333 else s2367 s2369 :: SWord8 = if s2169 then s2276 else s2368 s2370 :: SWord8 = if s1935 then s2161 else s2369 s2371 :: SWord8 = s1918 + s2016 s2372 :: SWord1 = choose [0:0] s2371 s2373 :: SBool = s19 /= s2372 s2374 :: SWord8 = if s2373 then s1929 else s1930 s2375 :: SWord8 = if s22 then s2374 else s1926 s2376 :: SWord1 = choose [0:0] s2375 s2377 :: SBool = s19 /= s2376 s2378 :: SBool = s_2 == s2377 s2379 :: SBool = s2371 < s2016 s2380 :: SBool = s2371 < s1918 s2381 :: SBool = s2379 | s2380 s2382 :: SWord8 = s2371 >>> 1 s2383 :: SWord8 = s24 | s2382 s2384 :: SWord8 = s26 & s2382 s2385 :: SWord8 = if s2381 then s2383 else s2384 s2386 :: SWord1 = choose [0:0] s2385 s2387 :: SBool = s19 /= s2386 s2388 :: SWord8 = s2375 >>> 1 s2389 :: SWord8 = s24 | s2388 s2390 :: SWord8 = s26 & s2388 s2391 :: SWord8 = if s1943 then s2389 else s2390 s2392 :: SWord8 = if s22 then s2391 else s2374 s2393 :: SWord8 = s2392 >>> 1 s2394 :: SWord8 = s24 | s2393 s2395 :: SWord8 = s26 & s2393 s2396 :: SWord8 = if s2387 then s2394 else s2395 s2397 :: SWord8 = if s22 then s2396 else s2391 s2398 :: SWord1 = choose [0:0] s2397 s2399 :: SBool = s19 /= s2398 s2400 :: SBool = s_2 == s2399 s2401 :: SWord8 = s2385 >>> 1 s2402 :: SWord8 = s24 | s2401 s2403 :: SWord8 = s26 & s2401 s2404 :: SWord8 = if s2377 then s2402 else s2403 s2405 :: SWord1 = choose [0:0] s2404 s2406 :: SBool = s19 /= s2405 s2407 :: SWord1 = choose [0:0] s2392 s2408 :: SBool = s19 /= s2407 s2409 :: SWord8 = s2397 >>> 1 s2410 :: SWord8 = s24 | s2409 s2411 :: SWord8 = s26 & s2409 s2412 :: SWord8 = if s2408 then s2410 else s2411 s2413 :: SWord8 = if s22 then s2412 else s2396 s2414 :: SWord8 = s2413 >>> 1 s2415 :: SWord8 = s24 | s2414 s2416 :: SWord8 = s26 & s2414 s2417 :: SWord8 = if s2406 then s2415 else s2416 s2418 :: SWord8 = if s22 then s2417 else s2412 s2419 :: SWord1 = choose [0:0] s2418 s2420 :: SBool = s19 /= s2419 s2421 :: SBool = s_2 == s2420 s2422 :: SWord8 = s2404 >>> 1 s2423 :: SWord8 = s24 | s2422 s2424 :: SWord8 = s26 & s2422 s2425 :: SWord8 = if s2399 then s2423 else s2424 s2426 :: SWord1 = choose [0:0] s2425 s2427 :: SBool = s19 /= s2426 s2428 :: SWord1 = choose [0:0] s2413 s2429 :: SBool = s19 /= s2428 s2430 :: SWord8 = s2418 >>> 1 s2431 :: SWord8 = s24 | s2430 s2432 :: SWord8 = s26 & s2430 s2433 :: SWord8 = if s2429 then s2431 else s2432 s2434 :: SWord8 = if s22 then s2433 else s2417 s2435 :: SWord8 = s2434 >>> 1 s2436 :: SWord8 = s24 | s2435 s2437 :: SWord8 = s26 & s2435 s2438 :: SWord8 = if s2427 then s2436 else s2437 s2439 :: SWord8 = if s22 then s2438 else s2433 s2440 :: SWord1 = choose [0:0] s2439 s2441 :: SBool = s19 /= s2440 s2442 :: SBool = s_2 == s2441 s2443 :: SWord8 = s2425 >>> 1 s2444 :: SWord8 = s24 | s2443 s2445 :: SWord8 = s26 & s2443 s2446 :: SWord8 = if s2420 then s2444 else s2445 s2447 :: SWord8 = s2446 >>> 1 s2448 :: SWord8 = s24 | s2447 s2449 :: SWord8 = s26 & s2447 s2450 :: SWord8 = if s2441 then s2448 else s2449 s2451 :: SWord1 = choose [0:0] s2434 s2452 :: SBool = s19 /= s2451 s2453 :: SWord8 = s2439 >>> 1 s2454 :: SWord8 = s24 | s2453 s2455 :: SWord8 = s26 & s2453 s2456 :: SWord8 = if s2452 then s2454 else s2455 s2457 :: SWord8 = if s29 then s2374 else s2016 s2458 :: SWord8 = if s170 then s2391 else s2457 s2459 :: SWord8 = if s29 then s2396 else s2458 s2460 :: SWord8 = if s170 then s2412 else s2459 s2461 :: SWord8 = if s29 then s2417 else s2460 s2462 :: SWord8 = if s170 then s2433 else s2461 s2463 :: SWord8 = if s29 then s2438 else s2462 s2464 :: SWord8 = if s170 then s2456 else s2463 s2465 :: SWord8 = s2446 + s2464 s2466 :: SBool = s2465 < s2464 s2467 :: SBool = s2465 < s2446 s2468 :: SBool = s2466 | s2467 s2469 :: SWord8 = s2465 >>> 1 s2470 :: SWord8 = s24 | s2469 s2471 :: SWord8 = s26 & s2469 s2472 :: SWord8 = if s2468 then s2470 else s2471 s2473 :: SWord8 = if s2442 then s2450 else s2472 s2474 :: SWord8 = s2425 + s2462 s2475 :: SWord1 = choose [0:0] s2474 s2476 :: SBool = s19 /= s2475 s2477 :: SWord8 = if s2476 then s2436 else s2437 s2478 :: SWord8 = if s22 then s2477 else s2433 s2479 :: SWord1 = choose [0:0] s2478 s2480 :: SBool = s19 /= s2479 s2481 :: SBool = s_2 == s2480 s2482 :: SBool = s2474 < s2462 s2483 :: SBool = s2474 < s2425 s2484 :: SBool = s2482 | s2483 s2485 :: SWord8 = s2474 >>> 1 s2486 :: SWord8 = s24 | s2485 s2487 :: SWord8 = s26 & s2485 s2488 :: SWord8 = if s2484 then s2486 else s2487 s2489 :: SWord8 = s2488 >>> 1 s2490 :: SWord8 = s24 | s2489 s2491 :: SWord8 = s26 & s2489 s2492 :: SWord8 = if s2480 then s2490 else s2491 s2493 :: SWord8 = s2478 >>> 1 s2494 :: SWord8 = s24 | s2493 s2495 :: SWord8 = s26 & s2493 s2496 :: SWord8 = if s2452 then s2494 else s2495 s2497 :: SWord8 = if s29 then s2477 else s2462 s2498 :: SWord8 = if s170 then s2496 else s2497 s2499 :: SWord8 = s2488 + s2498 s2500 :: SBool = s2499 < s2498 s2501 :: SBool = s2499 < s2488 s2502 :: SBool = s2500 | s2501 s2503 :: SWord8 = s2499 >>> 1 s2504 :: SWord8 = s24 | s2503 s2505 :: SWord8 = s26 & s2503 s2506 :: SWord8 = if s2502 then s2504 else s2505 s2507 :: SWord8 = if s2481 then s2492 else s2506 s2508 :: SWord8 = if s2421 then s2473 else s2507 s2509 :: SWord8 = s2404 + s2460 s2510 :: SWord1 = choose [0:0] s2509 s2511 :: SBool = s19 /= s2510 s2512 :: SWord8 = if s2511 then s2415 else s2416 s2513 :: SWord8 = if s22 then s2512 else s2412 s2514 :: SWord1 = choose [0:0] s2513 s2515 :: SBool = s19 /= s2514 s2516 :: SBool = s_2 == s2515 s2517 :: SBool = s2509 < s2460 s2518 :: SBool = s2509 < s2404 s2519 :: SBool = s2517 | s2518 s2520 :: SWord8 = s2509 >>> 1 s2521 :: SWord8 = s24 | s2520 s2522 :: SWord8 = s26 & s2520 s2523 :: SWord8 = if s2519 then s2521 else s2522 s2524 :: SWord1 = choose [0:0] s2523 s2525 :: SBool = s19 /= s2524 s2526 :: SWord8 = s2513 >>> 1 s2527 :: SWord8 = s24 | s2526 s2528 :: SWord8 = s26 & s2526 s2529 :: SWord8 = if s2429 then s2527 else s2528 s2530 :: SWord8 = if s22 then s2529 else s2512 s2531 :: SWord8 = s2530 >>> 1 s2532 :: SWord8 = s24 | s2531 s2533 :: SWord8 = s26 & s2531 s2534 :: SWord8 = if s2525 then s2532 else s2533 s2535 :: SWord8 = if s22 then s2534 else s2529 s2536 :: SWord1 = choose [0:0] s2535 s2537 :: SBool = s19 /= s2536 s2538 :: SBool = s_2 == s2537 s2539 :: SWord8 = s2523 >>> 1 s2540 :: SWord8 = s24 | s2539 s2541 :: SWord8 = s26 & s2539 s2542 :: SWord8 = if s2515 then s2540 else s2541 s2543 :: SWord8 = s2542 >>> 1 s2544 :: SWord8 = s24 | s2543 s2545 :: SWord8 = s26 & s2543 s2546 :: SWord8 = if s2537 then s2544 else s2545 s2547 :: SWord1 = choose [0:0] s2530 s2548 :: SBool = s19 /= s2547 s2549 :: SWord8 = s2535 >>> 1 s2550 :: SWord8 = s24 | s2549 s2551 :: SWord8 = s26 & s2549 s2552 :: SWord8 = if s2548 then s2550 else s2551 s2553 :: SWord8 = if s29 then s2512 else s2460 s2554 :: SWord8 = if s170 then s2529 else s2553 s2555 :: SWord8 = if s29 then s2534 else s2554 s2556 :: SWord8 = if s170 then s2552 else s2555 s2557 :: SWord8 = s2542 + s2556 s2558 :: SBool = s2557 < s2556 s2559 :: SBool = s2557 < s2542 s2560 :: SBool = s2558 | s2559 s2561 :: SWord8 = s2557 >>> 1 s2562 :: SWord8 = s24 | s2561 s2563 :: SWord8 = s26 & s2561 s2564 :: SWord8 = if s2560 then s2562 else s2563 s2565 :: SWord8 = if s2538 then s2546 else s2564 s2566 :: SWord8 = s2523 + s2554 s2567 :: SWord1 = choose [0:0] s2566 s2568 :: SBool = s19 /= s2567 s2569 :: SWord8 = if s2568 then s2532 else s2533 s2570 :: SWord8 = if s22 then s2569 else s2529 s2571 :: SWord1 = choose [0:0] s2570 s2572 :: SBool = s19 /= s2571 s2573 :: SBool = s_2 == s2572 s2574 :: SBool = s2566 < s2554 s2575 :: SBool = s2566 < s2523 s2576 :: SBool = s2574 | s2575 s2577 :: SWord8 = s2566 >>> 1 s2578 :: SWord8 = s24 | s2577 s2579 :: SWord8 = s26 & s2577 s2580 :: SWord8 = if s2576 then s2578 else s2579 s2581 :: SWord8 = s2580 >>> 1 s2582 :: SWord8 = s24 | s2581 s2583 :: SWord8 = s26 & s2581 s2584 :: SWord8 = if s2572 then s2582 else s2583 s2585 :: SWord8 = s2570 >>> 1 s2586 :: SWord8 = s24 | s2585 s2587 :: SWord8 = s26 & s2585 s2588 :: SWord8 = if s2548 then s2586 else s2587 s2589 :: SWord8 = if s29 then s2569 else s2554 s2590 :: SWord8 = if s170 then s2588 else s2589 s2591 :: SWord8 = s2580 + s2590 s2592 :: SBool = s2591 < s2590 s2593 :: SBool = s2591 < s2580 s2594 :: SBool = s2592 | s2593 s2595 :: SWord8 = s2591 >>> 1 s2596 :: SWord8 = s24 | s2595 s2597 :: SWord8 = s26 & s2595 s2598 :: SWord8 = if s2594 then s2596 else s2597 s2599 :: SWord8 = if s2573 then s2584 else s2598 s2600 :: SWord8 = if s2516 then s2565 else s2599 s2601 :: SWord8 = if s2400 then s2508 else s2600 s2602 :: SWord8 = s2385 + s2458 s2603 :: SWord1 = choose [0:0] s2602 s2604 :: SBool = s19 /= s2603 s2605 :: SWord8 = if s2604 then s2394 else s2395 s2606 :: SWord8 = if s22 then s2605 else s2391 s2607 :: SWord1 = choose [0:0] s2606 s2608 :: SBool = s19 /= s2607 s2609 :: SBool = s_2 == s2608 s2610 :: SBool = s2602 < s2458 s2611 :: SBool = s2602 < s2385 s2612 :: SBool = s2610 | s2611 s2613 :: SWord8 = s2602 >>> 1 s2614 :: SWord8 = s24 | s2613 s2615 :: SWord8 = s26 & s2613 s2616 :: SWord8 = if s2612 then s2614 else s2615 s2617 :: SWord1 = choose [0:0] s2616 s2618 :: SBool = s19 /= s2617 s2619 :: SWord8 = s2606 >>> 1 s2620 :: SWord8 = s24 | s2619 s2621 :: SWord8 = s26 & s2619 s2622 :: SWord8 = if s2408 then s2620 else s2621 s2623 :: SWord8 = if s22 then s2622 else s2605 s2624 :: SWord8 = s2623 >>> 1 s2625 :: SWord8 = s24 | s2624 s2626 :: SWord8 = s26 & s2624 s2627 :: SWord8 = if s2618 then s2625 else s2626 s2628 :: SWord8 = if s22 then s2627 else s2622 s2629 :: SWord1 = choose [0:0] s2628 s2630 :: SBool = s19 /= s2629 s2631 :: SBool = s_2 == s2630 s2632 :: SWord8 = s2616 >>> 1 s2633 :: SWord8 = s24 | s2632 s2634 :: SWord8 = s26 & s2632 s2635 :: SWord8 = if s2608 then s2633 else s2634 s2636 :: SWord1 = choose [0:0] s2635 s2637 :: SBool = s19 /= s2636 s2638 :: SWord1 = choose [0:0] s2623 s2639 :: SBool = s19 /= s2638 s2640 :: SWord8 = s2628 >>> 1 s2641 :: SWord8 = s24 | s2640 s2642 :: SWord8 = s26 & s2640 s2643 :: SWord8 = if s2639 then s2641 else s2642 s2644 :: SWord8 = if s22 then s2643 else s2627 s2645 :: SWord8 = s2644 >>> 1 s2646 :: SWord8 = s24 | s2645 s2647 :: SWord8 = s26 & s2645 s2648 :: SWord8 = if s2637 then s2646 else s2647 s2649 :: SWord8 = if s22 then s2648 else s2643 s2650 :: SWord1 = choose [0:0] s2649 s2651 :: SBool = s19 /= s2650 s2652 :: SBool = s_2 == s2651 s2653 :: SWord8 = s2635 >>> 1 s2654 :: SWord8 = s24 | s2653 s2655 :: SWord8 = s26 & s2653 s2656 :: SWord8 = if s2630 then s2654 else s2655 s2657 :: SWord8 = s2656 >>> 1 s2658 :: SWord8 = s24 | s2657 s2659 :: SWord8 = s26 & s2657 s2660 :: SWord8 = if s2651 then s2658 else s2659 s2661 :: SWord1 = choose [0:0] s2644 s2662 :: SBool = s19 /= s2661 s2663 :: SWord8 = s2649 >>> 1 s2664 :: SWord8 = s24 | s2663 s2665 :: SWord8 = s26 & s2663 s2666 :: SWord8 = if s2662 then s2664 else s2665 s2667 :: SWord8 = if s29 then s2605 else s2458 s2668 :: SWord8 = if s170 then s2622 else s2667 s2669 :: SWord8 = if s29 then s2627 else s2668 s2670 :: SWord8 = if s170 then s2643 else s2669 s2671 :: SWord8 = if s29 then s2648 else s2670 s2672 :: SWord8 = if s170 then s2666 else s2671 s2673 :: SWord8 = s2656 + s2672 s2674 :: SBool = s2673 < s2672 s2675 :: SBool = s2673 < s2656 s2676 :: SBool = s2674 | s2675 s2677 :: SWord8 = s2673 >>> 1 s2678 :: SWord8 = s24 | s2677 s2679 :: SWord8 = s26 & s2677 s2680 :: SWord8 = if s2676 then s2678 else s2679 s2681 :: SWord8 = if s2652 then s2660 else s2680 s2682 :: SWord8 = s2635 + s2670 s2683 :: SWord1 = choose [0:0] s2682 s2684 :: SBool = s19 /= s2683 s2685 :: SWord8 = if s2684 then s2646 else s2647 s2686 :: SWord8 = if s22 then s2685 else s2643 s2687 :: SWord1 = choose [0:0] s2686 s2688 :: SBool = s19 /= s2687 s2689 :: SBool = s_2 == s2688 s2690 :: SBool = s2682 < s2670 s2691 :: SBool = s2682 < s2635 s2692 :: SBool = s2690 | s2691 s2693 :: SWord8 = s2682 >>> 1 s2694 :: SWord8 = s24 | s2693 s2695 :: SWord8 = s26 & s2693 s2696 :: SWord8 = if s2692 then s2694 else s2695 s2697 :: SWord8 = s2696 >>> 1 s2698 :: SWord8 = s24 | s2697 s2699 :: SWord8 = s26 & s2697 s2700 :: SWord8 = if s2688 then s2698 else s2699 s2701 :: SWord8 = s2686 >>> 1 s2702 :: SWord8 = s24 | s2701 s2703 :: SWord8 = s26 & s2701 s2704 :: SWord8 = if s2662 then s2702 else s2703 s2705 :: SWord8 = if s29 then s2685 else s2670 s2706 :: SWord8 = if s170 then s2704 else s2705 s2707 :: SWord8 = s2696 + s2706 s2708 :: SBool = s2707 < s2706 s2709 :: SBool = s2707 < s2696 s2710 :: SBool = s2708 | s2709 s2711 :: SWord8 = s2707 >>> 1 s2712 :: SWord8 = s24 | s2711 s2713 :: SWord8 = s26 & s2711 s2714 :: SWord8 = if s2710 then s2712 else s2713 s2715 :: SWord8 = if s2689 then s2700 else s2714 s2716 :: SWord8 = if s2631 then s2681 else s2715 s2717 :: SWord8 = s2616 + s2668 s2718 :: SWord1 = choose [0:0] s2717 s2719 :: SBool = s19 /= s2718 s2720 :: SWord8 = if s2719 then s2625 else s2626 s2721 :: SWord8 = if s22 then s2720 else s2622 s2722 :: SWord1 = choose [0:0] s2721 s2723 :: SBool = s19 /= s2722 s2724 :: SBool = s_2 == s2723 s2725 :: SBool = s2717 < s2668 s2726 :: SBool = s2717 < s2616 s2727 :: SBool = s2725 | s2726 s2728 :: SWord8 = s2717 >>> 1 s2729 :: SWord8 = s24 | s2728 s2730 :: SWord8 = s26 & s2728 s2731 :: SWord8 = if s2727 then s2729 else s2730 s2732 :: SWord1 = choose [0:0] s2731 s2733 :: SBool = s19 /= s2732 s2734 :: SWord8 = s2721 >>> 1 s2735 :: SWord8 = s24 | s2734 s2736 :: SWord8 = s26 & s2734 s2737 :: SWord8 = if s2639 then s2735 else s2736 s2738 :: SWord8 = if s22 then s2737 else s2720 s2739 :: SWord8 = s2738 >>> 1 s2740 :: SWord8 = s24 | s2739 s2741 :: SWord8 = s26 & s2739 s2742 :: SWord8 = if s2733 then s2740 else s2741 s2743 :: SWord8 = if s22 then s2742 else s2737 s2744 :: SWord1 = choose [0:0] s2743 s2745 :: SBool = s19 /= s2744 s2746 :: SBool = s_2 == s2745 s2747 :: SWord8 = s2731 >>> 1 s2748 :: SWord8 = s24 | s2747 s2749 :: SWord8 = s26 & s2747 s2750 :: SWord8 = if s2723 then s2748 else s2749 s2751 :: SWord8 = s2750 >>> 1 s2752 :: SWord8 = s24 | s2751 s2753 :: SWord8 = s26 & s2751 s2754 :: SWord8 = if s2745 then s2752 else s2753 s2755 :: SWord1 = choose [0:0] s2738 s2756 :: SBool = s19 /= s2755 s2757 :: SWord8 = s2743 >>> 1 s2758 :: SWord8 = s24 | s2757 s2759 :: SWord8 = s26 & s2757 s2760 :: SWord8 = if s2756 then s2758 else s2759 s2761 :: SWord8 = if s29 then s2720 else s2668 s2762 :: SWord8 = if s170 then s2737 else s2761 s2763 :: SWord8 = if s29 then s2742 else s2762 s2764 :: SWord8 = if s170 then s2760 else s2763 s2765 :: SWord8 = s2750 + s2764 s2766 :: SBool = s2765 < s2764 s2767 :: SBool = s2765 < s2750 s2768 :: SBool = s2766 | s2767 s2769 :: SWord8 = s2765 >>> 1 s2770 :: SWord8 = s24 | s2769 s2771 :: SWord8 = s26 & s2769 s2772 :: SWord8 = if s2768 then s2770 else s2771 s2773 :: SWord8 = if s2746 then s2754 else s2772 s2774 :: SWord8 = s2731 + s2762 s2775 :: SWord1 = choose [0:0] s2774 s2776 :: SBool = s19 /= s2775 s2777 :: SWord8 = if s2776 then s2740 else s2741 s2778 :: SWord8 = if s22 then s2777 else s2737 s2779 :: SWord1 = choose [0:0] s2778 s2780 :: SBool = s19 /= s2779 s2781 :: SBool = s_2 == s2780 s2782 :: SBool = s2774 < s2762 s2783 :: SBool = s2774 < s2731 s2784 :: SBool = s2782 | s2783 s2785 :: SWord8 = s2774 >>> 1 s2786 :: SWord8 = s24 | s2785 s2787 :: SWord8 = s26 & s2785 s2788 :: SWord8 = if s2784 then s2786 else s2787 s2789 :: SWord8 = s2788 >>> 1 s2790 :: SWord8 = s24 | s2789 s2791 :: SWord8 = s26 & s2789 s2792 :: SWord8 = if s2780 then s2790 else s2791 s2793 :: SWord8 = s2778 >>> 1 s2794 :: SWord8 = s24 | s2793 s2795 :: SWord8 = s26 & s2793 s2796 :: SWord8 = if s2756 then s2794 else s2795 s2797 :: SWord8 = if s29 then s2777 else s2762 s2798 :: SWord8 = if s170 then s2796 else s2797 s2799 :: SWord8 = s2788 + s2798 s2800 :: SBool = s2799 < s2798 s2801 :: SBool = s2799 < s2788 s2802 :: SBool = s2800 | s2801 s2803 :: SWord8 = s2799 >>> 1 s2804 :: SWord8 = s24 | s2803 s2805 :: SWord8 = s26 & s2803 s2806 :: SWord8 = if s2802 then s2804 else s2805 s2807 :: SWord8 = if s2781 then s2792 else s2806 s2808 :: SWord8 = if s2724 then s2773 else s2807 s2809 :: SWord8 = if s2609 then s2716 else s2808 s2810 :: SWord8 = if s2378 then s2601 else s2809 s2811 :: SWord8 = if s1914 then s2370 else s2810 s2812 :: SWord8 = s1899 + s2014 s2813 :: SWord1 = choose [0:0] s2812 s2814 :: SBool = s19 /= s2813 s2815 :: SWord8 = if s2814 then s1908 else s1909 s2816 :: SWord8 = if s22 then s2815 else s1905 s2817 :: SWord1 = choose [0:0] s2816 s2818 :: SBool = s19 /= s2817 s2819 :: SBool = s_2 == s2818 s2820 :: SBool = s2812 < s2014 s2821 :: SBool = s2812 < s1899 s2822 :: SBool = s2820 | s2821 s2823 :: SWord8 = s2812 >>> 1 s2824 :: SWord8 = s24 | s2823 s2825 :: SWord8 = s26 & s2823 s2826 :: SWord8 = if s2822 then s2824 else s2825 s2827 :: SWord1 = choose [0:0] s2826 s2828 :: SBool = s19 /= s2827 s2829 :: SWord8 = s2816 >>> 1 s2830 :: SWord8 = s24 | s2829 s2831 :: SWord8 = s26 & s2829 s2832 :: SWord8 = if s1922 then s2830 else s2831 s2833 :: SWord8 = if s22 then s2832 else s2815 s2834 :: SWord8 = s2833 >>> 1 s2835 :: SWord8 = s24 | s2834 s2836 :: SWord8 = s26 & s2834 s2837 :: SWord8 = if s2828 then s2835 else s2836 s2838 :: SWord8 = if s22 then s2837 else s2832 s2839 :: SWord1 = choose [0:0] s2838 s2840 :: SBool = s19 /= s2839 s2841 :: SBool = s_2 == s2840 s2842 :: SWord8 = s2826 >>> 1 s2843 :: SWord8 = s24 | s2842 s2844 :: SWord8 = s26 & s2842 s2845 :: SWord8 = if s2818 then s2843 else s2844 s2846 :: SWord1 = choose [0:0] s2845 s2847 :: SBool = s19 /= s2846 s2848 :: SWord1 = choose [0:0] s2833 s2849 :: SBool = s19 /= s2848 s2850 :: SWord8 = s2838 >>> 1 s2851 :: SWord8 = s24 | s2850 s2852 :: SWord8 = s26 & s2850 s2853 :: SWord8 = if s2849 then s2851 else s2852 s2854 :: SWord8 = if s22 then s2853 else s2837 s2855 :: SWord8 = s2854 >>> 1 s2856 :: SWord8 = s24 | s2855 s2857 :: SWord8 = s26 & s2855 s2858 :: SWord8 = if s2847 then s2856 else s2857 s2859 :: SWord8 = if s22 then s2858 else s2853 s2860 :: SWord1 = choose [0:0] s2859 s2861 :: SBool = s19 /= s2860 s2862 :: SBool = s_2 == s2861 s2863 :: SWord8 = s2845 >>> 1 s2864 :: SWord8 = s24 | s2863 s2865 :: SWord8 = s26 & s2863 s2866 :: SWord8 = if s2840 then s2864 else s2865 s2867 :: SWord1 = choose [0:0] s2866 s2868 :: SBool = s19 /= s2867 s2869 :: SWord1 = choose [0:0] s2854 s2870 :: SBool = s19 /= s2869 s2871 :: SWord8 = s2859 >>> 1 s2872 :: SWord8 = s24 | s2871 s2873 :: SWord8 = s26 & s2871 s2874 :: SWord8 = if s2870 then s2872 else s2873 s2875 :: SWord8 = if s22 then s2874 else s2858 s2876 :: SWord8 = s2875 >>> 1 s2877 :: SWord8 = s24 | s2876 s2878 :: SWord8 = s26 & s2876 s2879 :: SWord8 = if s2868 then s2877 else s2878 s2880 :: SWord8 = if s22 then s2879 else s2874 s2881 :: SWord1 = choose [0:0] s2880 s2882 :: SBool = s19 /= s2881 s2883 :: SBool = s_2 == s2882 s2884 :: SWord8 = s2866 >>> 1 s2885 :: SWord8 = s24 | s2884 s2886 :: SWord8 = s26 & s2884 s2887 :: SWord8 = if s2861 then s2885 else s2886 s2888 :: SWord1 = choose [0:0] s2887 s2889 :: SBool = s19 /= s2888 s2890 :: SWord1 = choose [0:0] s2875 s2891 :: SBool = s19 /= s2890 s2892 :: SWord8 = s2880 >>> 1 s2893 :: SWord8 = s24 | s2892 s2894 :: SWord8 = s26 & s2892 s2895 :: SWord8 = if s2891 then s2893 else s2894 s2896 :: SWord8 = if s22 then s2895 else s2879 s2897 :: SWord8 = s2896 >>> 1 s2898 :: SWord8 = s24 | s2897 s2899 :: SWord8 = s26 & s2897 s2900 :: SWord8 = if s2889 then s2898 else s2899 s2901 :: SWord8 = if s22 then s2900 else s2895 s2902 :: SWord1 = choose [0:0] s2901 s2903 :: SBool = s19 /= s2902 s2904 :: SBool = s_2 == s2903 s2905 :: SWord8 = s2887 >>> 1 s2906 :: SWord8 = s24 | s2905 s2907 :: SWord8 = s26 & s2905 s2908 :: SWord8 = if s2882 then s2906 else s2907 s2909 :: SWord8 = s2908 >>> 1 s2910 :: SWord8 = s24 | s2909 s2911 :: SWord8 = s26 & s2909 s2912 :: SWord8 = if s2903 then s2910 else s2911 s2913 :: SWord1 = choose [0:0] s2896 s2914 :: SBool = s19 /= s2913 s2915 :: SWord8 = s2901 >>> 1 s2916 :: SWord8 = s24 | s2915 s2917 :: SWord8 = s26 & s2915 s2918 :: SWord8 = if s2914 then s2916 else s2917 s2919 :: SWord8 = if s29 then s2815 else s2014 s2920 :: SWord8 = if s170 then s2832 else s2919 s2921 :: SWord8 = if s29 then s2837 else s2920 s2922 :: SWord8 = if s170 then s2853 else s2921 s2923 :: SWord8 = if s29 then s2858 else s2922 s2924 :: SWord8 = if s170 then s2874 else s2923 s2925 :: SWord8 = if s29 then s2879 else s2924 s2926 :: SWord8 = if s170 then s2895 else s2925 s2927 :: SWord8 = if s29 then s2900 else s2926 s2928 :: SWord8 = if s170 then s2918 else s2927 s2929 :: SWord8 = s2908 + s2928 s2930 :: SBool = s2929 < s2928 s2931 :: SBool = s2929 < s2908 s2932 :: SBool = s2930 | s2931 s2933 :: SWord8 = s2929 >>> 1 s2934 :: SWord8 = s24 | s2933 s2935 :: SWord8 = s26 & s2933 s2936 :: SWord8 = if s2932 then s2934 else s2935 s2937 :: SWord8 = if s2904 then s2912 else s2936 s2938 :: SWord8 = s2887 + s2926 s2939 :: SWord1 = choose [0:0] s2938 s2940 :: SBool = s19 /= s2939 s2941 :: SWord8 = if s2940 then s2898 else s2899 s2942 :: SWord8 = if s22 then s2941 else s2895 s2943 :: SWord1 = choose [0:0] s2942 s2944 :: SBool = s19 /= s2943 s2945 :: SBool = s_2 == s2944 s2946 :: SBool = s2938 < s2926 s2947 :: SBool = s2938 < s2887 s2948 :: SBool = s2946 | s2947 s2949 :: SWord8 = s2938 >>> 1 s2950 :: SWord8 = s24 | s2949 s2951 :: SWord8 = s26 & s2949 s2952 :: SWord8 = if s2948 then s2950 else s2951 s2953 :: SWord8 = s2952 >>> 1 s2954 :: SWord8 = s24 | s2953 s2955 :: SWord8 = s26 & s2953 s2956 :: SWord8 = if s2944 then s2954 else s2955 s2957 :: SWord8 = s2942 >>> 1 s2958 :: SWord8 = s24 | s2957 s2959 :: SWord8 = s26 & s2957 s2960 :: SWord8 = if s2914 then s2958 else s2959 s2961 :: SWord8 = if s29 then s2941 else s2926 s2962 :: SWord8 = if s170 then s2960 else s2961 s2963 :: SWord8 = s2952 + s2962 s2964 :: SBool = s2963 < s2962 s2965 :: SBool = s2963 < s2952 s2966 :: SBool = s2964 | s2965 s2967 :: SWord8 = s2963 >>> 1 s2968 :: SWord8 = s24 | s2967 s2969 :: SWord8 = s26 & s2967 s2970 :: SWord8 = if s2966 then s2968 else s2969 s2971 :: SWord8 = if s2945 then s2956 else s2970 s2972 :: SWord8 = if s2883 then s2937 else s2971 s2973 :: SWord8 = s2866 + s2924 s2974 :: SWord1 = choose [0:0] s2973 s2975 :: SBool = s19 /= s2974 s2976 :: SWord8 = if s2975 then s2877 else s2878 s2977 :: SWord8 = if s22 then s2976 else s2874 s2978 :: SWord1 = choose [0:0] s2977 s2979 :: SBool = s19 /= s2978 s2980 :: SBool = s_2 == s2979 s2981 :: SBool = s2973 < s2924 s2982 :: SBool = s2973 < s2866 s2983 :: SBool = s2981 | s2982 s2984 :: SWord8 = s2973 >>> 1 s2985 :: SWord8 = s24 | s2984 s2986 :: SWord8 = s26 & s2984 s2987 :: SWord8 = if s2983 then s2985 else s2986 s2988 :: SWord1 = choose [0:0] s2987 s2989 :: SBool = s19 /= s2988 s2990 :: SWord8 = s2977 >>> 1 s2991 :: SWord8 = s24 | s2990 s2992 :: SWord8 = s26 & s2990 s2993 :: SWord8 = if s2891 then s2991 else s2992 s2994 :: SWord8 = if s22 then s2993 else s2976 s2995 :: SWord8 = s2994 >>> 1 s2996 :: SWord8 = s24 | s2995 s2997 :: SWord8 = s26 & s2995 s2998 :: SWord8 = if s2989 then s2996 else s2997 s2999 :: SWord8 = if s22 then s2998 else s2993 s3000 :: SWord1 = choose [0:0] s2999 s3001 :: SBool = s19 /= s3000 s3002 :: SBool = s_2 == s3001 s3003 :: SWord8 = s2987 >>> 1 s3004 :: SWord8 = s24 | s3003 s3005 :: SWord8 = s26 & s3003 s3006 :: SWord8 = if s2979 then s3004 else s3005 s3007 :: SWord8 = s3006 >>> 1 s3008 :: SWord8 = s24 | s3007 s3009 :: SWord8 = s26 & s3007 s3010 :: SWord8 = if s3001 then s3008 else s3009 s3011 :: SWord1 = choose [0:0] s2994 s3012 :: SBool = s19 /= s3011 s3013 :: SWord8 = s2999 >>> 1 s3014 :: SWord8 = s24 | s3013 s3015 :: SWord8 = s26 & s3013 s3016 :: SWord8 = if s3012 then s3014 else s3015 s3017 :: SWord8 = if s29 then s2976 else s2924 s3018 :: SWord8 = if s170 then s2993 else s3017 s3019 :: SWord8 = if s29 then s2998 else s3018 s3020 :: SWord8 = if s170 then s3016 else s3019 s3021 :: SWord8 = s3006 + s3020 s3022 :: SBool = s3021 < s3020 s3023 :: SBool = s3021 < s3006 s3024 :: SBool = s3022 | s3023 s3025 :: SWord8 = s3021 >>> 1 s3026 :: SWord8 = s24 | s3025 s3027 :: SWord8 = s26 & s3025 s3028 :: SWord8 = if s3024 then s3026 else s3027 s3029 :: SWord8 = if s3002 then s3010 else s3028 s3030 :: SWord8 = s2987 + s3018 s3031 :: SWord1 = choose [0:0] s3030 s3032 :: SBool = s19 /= s3031 s3033 :: SWord8 = if s3032 then s2996 else s2997 s3034 :: SWord8 = if s22 then s3033 else s2993 s3035 :: SWord1 = choose [0:0] s3034 s3036 :: SBool = s19 /= s3035 s3037 :: SBool = s_2 == s3036 s3038 :: SBool = s3030 < s3018 s3039 :: SBool = s3030 < s2987 s3040 :: SBool = s3038 | s3039 s3041 :: SWord8 = s3030 >>> 1 s3042 :: SWord8 = s24 | s3041 s3043 :: SWord8 = s26 & s3041 s3044 :: SWord8 = if s3040 then s3042 else s3043 s3045 :: SWord8 = s3044 >>> 1 s3046 :: SWord8 = s24 | s3045 s3047 :: SWord8 = s26 & s3045 s3048 :: SWord8 = if s3036 then s3046 else s3047 s3049 :: SWord8 = s3034 >>> 1 s3050 :: SWord8 = s24 | s3049 s3051 :: SWord8 = s26 & s3049 s3052 :: SWord8 = if s3012 then s3050 else s3051 s3053 :: SWord8 = if s29 then s3033 else s3018 s3054 :: SWord8 = if s170 then s3052 else s3053 s3055 :: SWord8 = s3044 + s3054 s3056 :: SBool = s3055 < s3054 s3057 :: SBool = s3055 < s3044 s3058 :: SBool = s3056 | s3057 s3059 :: SWord8 = s3055 >>> 1 s3060 :: SWord8 = s24 | s3059 s3061 :: SWord8 = s26 & s3059 s3062 :: SWord8 = if s3058 then s3060 else s3061 s3063 :: SWord8 = if s3037 then s3048 else s3062 s3064 :: SWord8 = if s2980 then s3029 else s3063 s3065 :: SWord8 = if s2862 then s2972 else s3064 s3066 :: SWord8 = s2845 + s2922 s3067 :: SWord1 = choose [0:0] s3066 s3068 :: SBool = s19 /= s3067 s3069 :: SWord8 = if s3068 then s2856 else s2857 s3070 :: SWord8 = if s22 then s3069 else s2853 s3071 :: SWord1 = choose [0:0] s3070 s3072 :: SBool = s19 /= s3071 s3073 :: SBool = s_2 == s3072 s3074 :: SBool = s3066 < s2922 s3075 :: SBool = s3066 < s2845 s3076 :: SBool = s3074 | s3075 s3077 :: SWord8 = s3066 >>> 1 s3078 :: SWord8 = s24 | s3077 s3079 :: SWord8 = s26 & s3077 s3080 :: SWord8 = if s3076 then s3078 else s3079 s3081 :: SWord1 = choose [0:0] s3080 s3082 :: SBool = s19 /= s3081 s3083 :: SWord8 = s3070 >>> 1 s3084 :: SWord8 = s24 | s3083 s3085 :: SWord8 = s26 & s3083 s3086 :: SWord8 = if s2870 then s3084 else s3085 s3087 :: SWord8 = if s22 then s3086 else s3069 s3088 :: SWord8 = s3087 >>> 1 s3089 :: SWord8 = s24 | s3088 s3090 :: SWord8 = s26 & s3088 s3091 :: SWord8 = if s3082 then s3089 else s3090 s3092 :: SWord8 = if s22 then s3091 else s3086 s3093 :: SWord1 = choose [0:0] s3092 s3094 :: SBool = s19 /= s3093 s3095 :: SBool = s_2 == s3094 s3096 :: SWord8 = s3080 >>> 1 s3097 :: SWord8 = s24 | s3096 s3098 :: SWord8 = s26 & s3096 s3099 :: SWord8 = if s3072 then s3097 else s3098 s3100 :: SWord1 = choose [0:0] s3099 s3101 :: SBool = s19 /= s3100 s3102 :: SWord1 = choose [0:0] s3087 s3103 :: SBool = s19 /= s3102 s3104 :: SWord8 = s3092 >>> 1 s3105 :: SWord8 = s24 | s3104 s3106 :: SWord8 = s26 & s3104 s3107 :: SWord8 = if s3103 then s3105 else s3106 s3108 :: SWord8 = if s22 then s3107 else s3091 s3109 :: SWord8 = s3108 >>> 1 s3110 :: SWord8 = s24 | s3109 s3111 :: SWord8 = s26 & s3109 s3112 :: SWord8 = if s3101 then s3110 else s3111 s3113 :: SWord8 = if s22 then s3112 else s3107 s3114 :: SWord1 = choose [0:0] s3113 s3115 :: SBool = s19 /= s3114 s3116 :: SBool = s_2 == s3115 s3117 :: SWord8 = s3099 >>> 1 s3118 :: SWord8 = s24 | s3117 s3119 :: SWord8 = s26 & s3117 s3120 :: SWord8 = if s3094 then s3118 else s3119 s3121 :: SWord8 = s3120 >>> 1 s3122 :: SWord8 = s24 | s3121 s3123 :: SWord8 = s26 & s3121 s3124 :: SWord8 = if s3115 then s3122 else s3123 s3125 :: SWord1 = choose [0:0] s3108 s3126 :: SBool = s19 /= s3125 s3127 :: SWord8 = s3113 >>> 1 s3128 :: SWord8 = s24 | s3127 s3129 :: SWord8 = s26 & s3127 s3130 :: SWord8 = if s3126 then s3128 else s3129 s3131 :: SWord8 = if s29 then s3069 else s2922 s3132 :: SWord8 = if s170 then s3086 else s3131 s3133 :: SWord8 = if s29 then s3091 else s3132 s3134 :: SWord8 = if s170 then s3107 else s3133 s3135 :: SWord8 = if s29 then s3112 else s3134 s3136 :: SWord8 = if s170 then s3130 else s3135 s3137 :: SWord8 = s3120 + s3136 s3138 :: SBool = s3137 < s3136 s3139 :: SBool = s3137 < s3120 s3140 :: SBool = s3138 | s3139 s3141 :: SWord8 = s3137 >>> 1 s3142 :: SWord8 = s24 | s3141 s3143 :: SWord8 = s26 & s3141 s3144 :: SWord8 = if s3140 then s3142 else s3143 s3145 :: SWord8 = if s3116 then s3124 else s3144 s3146 :: SWord8 = s3099 + s3134 s3147 :: SWord1 = choose [0:0] s3146 s3148 :: SBool = s19 /= s3147 s3149 :: SWord8 = if s3148 then s3110 else s3111 s3150 :: SWord8 = if s22 then s3149 else s3107 s3151 :: SWord1 = choose [0:0] s3150 s3152 :: SBool = s19 /= s3151 s3153 :: SBool = s_2 == s3152 s3154 :: SBool = s3146 < s3134 s3155 :: SBool = s3146 < s3099 s3156 :: SBool = s3154 | s3155 s3157 :: SWord8 = s3146 >>> 1 s3158 :: SWord8 = s24 | s3157 s3159 :: SWord8 = s26 & s3157 s3160 :: SWord8 = if s3156 then s3158 else s3159 s3161 :: SWord8 = s3160 >>> 1 s3162 :: SWord8 = s24 | s3161 s3163 :: SWord8 = s26 & s3161 s3164 :: SWord8 = if s3152 then s3162 else s3163 s3165 :: SWord8 = s3150 >>> 1 s3166 :: SWord8 = s24 | s3165 s3167 :: SWord8 = s26 & s3165 s3168 :: SWord8 = if s3126 then s3166 else s3167 s3169 :: SWord8 = if s29 then s3149 else s3134 s3170 :: SWord8 = if s170 then s3168 else s3169 s3171 :: SWord8 = s3160 + s3170 s3172 :: SBool = s3171 < s3170 s3173 :: SBool = s3171 < s3160 s3174 :: SBool = s3172 | s3173 s3175 :: SWord8 = s3171 >>> 1 s3176 :: SWord8 = s24 | s3175 s3177 :: SWord8 = s26 & s3175 s3178 :: SWord8 = if s3174 then s3176 else s3177 s3179 :: SWord8 = if s3153 then s3164 else s3178 s3180 :: SWord8 = if s3095 then s3145 else s3179 s3181 :: SWord8 = s3080 + s3132 s3182 :: SWord1 = choose [0:0] s3181 s3183 :: SBool = s19 /= s3182 s3184 :: SWord8 = if s3183 then s3089 else s3090 s3185 :: SWord8 = if s22 then s3184 else s3086 s3186 :: SWord1 = choose [0:0] s3185 s3187 :: SBool = s19 /= s3186 s3188 :: SBool = s_2 == s3187 s3189 :: SBool = s3181 < s3132 s3190 :: SBool = s3181 < s3080 s3191 :: SBool = s3189 | s3190 s3192 :: SWord8 = s3181 >>> 1 s3193 :: SWord8 = s24 | s3192 s3194 :: SWord8 = s26 & s3192 s3195 :: SWord8 = if s3191 then s3193 else s3194 s3196 :: SWord1 = choose [0:0] s3195 s3197 :: SBool = s19 /= s3196 s3198 :: SWord8 = s3185 >>> 1 s3199 :: SWord8 = s24 | s3198 s3200 :: SWord8 = s26 & s3198 s3201 :: SWord8 = if s3103 then s3199 else s3200 s3202 :: SWord8 = if s22 then s3201 else s3184 s3203 :: SWord8 = s3202 >>> 1 s3204 :: SWord8 = s24 | s3203 s3205 :: SWord8 = s26 & s3203 s3206 :: SWord8 = if s3197 then s3204 else s3205 s3207 :: SWord8 = if s22 then s3206 else s3201 s3208 :: SWord1 = choose [0:0] s3207 s3209 :: SBool = s19 /= s3208 s3210 :: SBool = s_2 == s3209 s3211 :: SWord8 = s3195 >>> 1 s3212 :: SWord8 = s24 | s3211 s3213 :: SWord8 = s26 & s3211 s3214 :: SWord8 = if s3187 then s3212 else s3213 s3215 :: SWord8 = s3214 >>> 1 s3216 :: SWord8 = s24 | s3215 s3217 :: SWord8 = s26 & s3215 s3218 :: SWord8 = if s3209 then s3216 else s3217 s3219 :: SWord1 = choose [0:0] s3202 s3220 :: SBool = s19 /= s3219 s3221 :: SWord8 = s3207 >>> 1 s3222 :: SWord8 = s24 | s3221 s3223 :: SWord8 = s26 & s3221 s3224 :: SWord8 = if s3220 then s3222 else s3223 s3225 :: SWord8 = if s29 then s3184 else s3132 s3226 :: SWord8 = if s170 then s3201 else s3225 s3227 :: SWord8 = if s29 then s3206 else s3226 s3228 :: SWord8 = if s170 then s3224 else s3227 s3229 :: SWord8 = s3214 + s3228 s3230 :: SBool = s3229 < s3228 s3231 :: SBool = s3229 < s3214 s3232 :: SBool = s3230 | s3231 s3233 :: SWord8 = s3229 >>> 1 s3234 :: SWord8 = s24 | s3233 s3235 :: SWord8 = s26 & s3233 s3236 :: SWord8 = if s3232 then s3234 else s3235 s3237 :: SWord8 = if s3210 then s3218 else s3236 s3238 :: SWord8 = s3195 + s3226 s3239 :: SWord1 = choose [0:0] s3238 s3240 :: SBool = s19 /= s3239 s3241 :: SWord8 = if s3240 then s3204 else s3205 s3242 :: SWord8 = if s22 then s3241 else s3201 s3243 :: SWord1 = choose [0:0] s3242 s3244 :: SBool = s19 /= s3243 s3245 :: SBool = s_2 == s3244 s3246 :: SBool = s3238 < s3226 s3247 :: SBool = s3238 < s3195 s3248 :: SBool = s3246 | s3247 s3249 :: SWord8 = s3238 >>> 1 s3250 :: SWord8 = s24 | s3249 s3251 :: SWord8 = s26 & s3249 s3252 :: SWord8 = if s3248 then s3250 else s3251 s3253 :: SWord8 = s3252 >>> 1 s3254 :: SWord8 = s24 | s3253 s3255 :: SWord8 = s26 & s3253 s3256 :: SWord8 = if s3244 then s3254 else s3255 s3257 :: SWord8 = s3242 >>> 1 s3258 :: SWord8 = s24 | s3257 s3259 :: SWord8 = s26 & s3257 s3260 :: SWord8 = if s3220 then s3258 else s3259 s3261 :: SWord8 = if s29 then s3241 else s3226 s3262 :: SWord8 = if s170 then s3260 else s3261 s3263 :: SWord8 = s3252 + s3262 s3264 :: SBool = s3263 < s3262 s3265 :: SBool = s3263 < s3252 s3266 :: SBool = s3264 | s3265 s3267 :: SWord8 = s3263 >>> 1 s3268 :: SWord8 = s24 | s3267 s3269 :: SWord8 = s26 & s3267 s3270 :: SWord8 = if s3266 then s3268 else s3269 s3271 :: SWord8 = if s3245 then s3256 else s3270 s3272 :: SWord8 = if s3188 then s3237 else s3271 s3273 :: SWord8 = if s3073 then s3180 else s3272 s3274 :: SWord8 = if s2841 then s3065 else s3273 s3275 :: SWord8 = s2826 + s2920 s3276 :: SWord1 = choose [0:0] s3275 s3277 :: SBool = s19 /= s3276 s3278 :: SWord8 = if s3277 then s2835 else s2836 s3279 :: SWord8 = if s22 then s3278 else s2832 s3280 :: SWord1 = choose [0:0] s3279 s3281 :: SBool = s19 /= s3280 s3282 :: SBool = s_2 == s3281 s3283 :: SBool = s3275 < s2920 s3284 :: SBool = s3275 < s2826 s3285 :: SBool = s3283 | s3284 s3286 :: SWord8 = s3275 >>> 1 s3287 :: SWord8 = s24 | s3286 s3288 :: SWord8 = s26 & s3286 s3289 :: SWord8 = if s3285 then s3287 else s3288 s3290 :: SWord1 = choose [0:0] s3289 s3291 :: SBool = s19 /= s3290 s3292 :: SWord8 = s3279 >>> 1 s3293 :: SWord8 = s24 | s3292 s3294 :: SWord8 = s26 & s3292 s3295 :: SWord8 = if s2849 then s3293 else s3294 s3296 :: SWord8 = if s22 then s3295 else s3278 s3297 :: SWord8 = s3296 >>> 1 s3298 :: SWord8 = s24 | s3297 s3299 :: SWord8 = s26 & s3297 s3300 :: SWord8 = if s3291 then s3298 else s3299 s3301 :: SWord8 = if s22 then s3300 else s3295 s3302 :: SWord1 = choose [0:0] s3301 s3303 :: SBool = s19 /= s3302 s3304 :: SBool = s_2 == s3303 s3305 :: SWord8 = s3289 >>> 1 s3306 :: SWord8 = s24 | s3305 s3307 :: SWord8 = s26 & s3305 s3308 :: SWord8 = if s3281 then s3306 else s3307 s3309 :: SWord1 = choose [0:0] s3308 s3310 :: SBool = s19 /= s3309 s3311 :: SWord1 = choose [0:0] s3296 s3312 :: SBool = s19 /= s3311 s3313 :: SWord8 = s3301 >>> 1 s3314 :: SWord8 = s24 | s3313 s3315 :: SWord8 = s26 & s3313 s3316 :: SWord8 = if s3312 then s3314 else s3315 s3317 :: SWord8 = if s22 then s3316 else s3300 s3318 :: SWord8 = s3317 >>> 1 s3319 :: SWord8 = s24 | s3318 s3320 :: SWord8 = s26 & s3318 s3321 :: SWord8 = if s3310 then s3319 else s3320 s3322 :: SWord8 = if s22 then s3321 else s3316 s3323 :: SWord1 = choose [0:0] s3322 s3324 :: SBool = s19 /= s3323 s3325 :: SBool = s_2 == s3324 s3326 :: SWord8 = s3308 >>> 1 s3327 :: SWord8 = s24 | s3326 s3328 :: SWord8 = s26 & s3326 s3329 :: SWord8 = if s3303 then s3327 else s3328 s3330 :: SWord1 = choose [0:0] s3329 s3331 :: SBool = s19 /= s3330 s3332 :: SWord1 = choose [0:0] s3317 s3333 :: SBool = s19 /= s3332 s3334 :: SWord8 = s3322 >>> 1 s3335 :: SWord8 = s24 | s3334 s3336 :: SWord8 = s26 & s3334 s3337 :: SWord8 = if s3333 then s3335 else s3336 s3338 :: SWord8 = if s22 then s3337 else s3321 s3339 :: SWord8 = s3338 >>> 1 s3340 :: SWord8 = s24 | s3339 s3341 :: SWord8 = s26 & s3339 s3342 :: SWord8 = if s3331 then s3340 else s3341 s3343 :: SWord8 = if s22 then s3342 else s3337 s3344 :: SWord1 = choose [0:0] s3343 s3345 :: SBool = s19 /= s3344 s3346 :: SBool = s_2 == s3345 s3347 :: SWord8 = s3329 >>> 1 s3348 :: SWord8 = s24 | s3347 s3349 :: SWord8 = s26 & s3347 s3350 :: SWord8 = if s3324 then s3348 else s3349 s3351 :: SWord8 = s3350 >>> 1 s3352 :: SWord8 = s24 | s3351 s3353 :: SWord8 = s26 & s3351 s3354 :: SWord8 = if s3345 then s3352 else s3353 s3355 :: SWord1 = choose [0:0] s3338 s3356 :: SBool = s19 /= s3355 s3357 :: SWord8 = s3343 >>> 1 s3358 :: SWord8 = s24 | s3357 s3359 :: SWord8 = s26 & s3357 s3360 :: SWord8 = if s3356 then s3358 else s3359 s3361 :: SWord8 = if s29 then s3278 else s2920 s3362 :: SWord8 = if s170 then s3295 else s3361 s3363 :: SWord8 = if s29 then s3300 else s3362 s3364 :: SWord8 = if s170 then s3316 else s3363 s3365 :: SWord8 = if s29 then s3321 else s3364 s3366 :: SWord8 = if s170 then s3337 else s3365 s3367 :: SWord8 = if s29 then s3342 else s3366 s3368 :: SWord8 = if s170 then s3360 else s3367 s3369 :: SWord8 = s3350 + s3368 s3370 :: SBool = s3369 < s3368 s3371 :: SBool = s3369 < s3350 s3372 :: SBool = s3370 | s3371 s3373 :: SWord8 = s3369 >>> 1 s3374 :: SWord8 = s24 | s3373 s3375 :: SWord8 = s26 & s3373 s3376 :: SWord8 = if s3372 then s3374 else s3375 s3377 :: SWord8 = if s3346 then s3354 else s3376 s3378 :: SWord8 = s3329 + s3366 s3379 :: SWord1 = choose [0:0] s3378 s3380 :: SBool = s19 /= s3379 s3381 :: SWord8 = if s3380 then s3340 else s3341 s3382 :: SWord8 = if s22 then s3381 else s3337 s3383 :: SWord1 = choose [0:0] s3382 s3384 :: SBool = s19 /= s3383 s3385 :: SBool = s_2 == s3384 s3386 :: SBool = s3378 < s3366 s3387 :: SBool = s3378 < s3329 s3388 :: SBool = s3386 | s3387 s3389 :: SWord8 = s3378 >>> 1 s3390 :: SWord8 = s24 | s3389 s3391 :: SWord8 = s26 & s3389 s3392 :: SWord8 = if s3388 then s3390 else s3391 s3393 :: SWord8 = s3392 >>> 1 s3394 :: SWord8 = s24 | s3393 s3395 :: SWord8 = s26 & s3393 s3396 :: SWord8 = if s3384 then s3394 else s3395 s3397 :: SWord8 = s3382 >>> 1 s3398 :: SWord8 = s24 | s3397 s3399 :: SWord8 = s26 & s3397 s3400 :: SWord8 = if s3356 then s3398 else s3399 s3401 :: SWord8 = if s29 then s3381 else s3366 s3402 :: SWord8 = if s170 then s3400 else s3401 s3403 :: SWord8 = s3392 + s3402 s3404 :: SBool = s3403 < s3402 s3405 :: SBool = s3403 < s3392 s3406 :: SBool = s3404 | s3405 s3407 :: SWord8 = s3403 >>> 1 s3408 :: SWord8 = s24 | s3407 s3409 :: SWord8 = s26 & s3407 s3410 :: SWord8 = if s3406 then s3408 else s3409 s3411 :: SWord8 = if s3385 then s3396 else s3410 s3412 :: SWord8 = if s3325 then s3377 else s3411 s3413 :: SWord8 = s3308 + s3364 s3414 :: SWord1 = choose [0:0] s3413 s3415 :: SBool = s19 /= s3414 s3416 :: SWord8 = if s3415 then s3319 else s3320 s3417 :: SWord8 = if s22 then s3416 else s3316 s3418 :: SWord1 = choose [0:0] s3417 s3419 :: SBool = s19 /= s3418 s3420 :: SBool = s_2 == s3419 s3421 :: SBool = s3413 < s3364 s3422 :: SBool = s3413 < s3308 s3423 :: SBool = s3421 | s3422 s3424 :: SWord8 = s3413 >>> 1 s3425 :: SWord8 = s24 | s3424 s3426 :: SWord8 = s26 & s3424 s3427 :: SWord8 = if s3423 then s3425 else s3426 s3428 :: SWord1 = choose [0:0] s3427 s3429 :: SBool = s19 /= s3428 s3430 :: SWord8 = s3417 >>> 1 s3431 :: SWord8 = s24 | s3430 s3432 :: SWord8 = s26 & s3430 s3433 :: SWord8 = if s3333 then s3431 else s3432 s3434 :: SWord8 = if s22 then s3433 else s3416 s3435 :: SWord8 = s3434 >>> 1 s3436 :: SWord8 = s24 | s3435 s3437 :: SWord8 = s26 & s3435 s3438 :: SWord8 = if s3429 then s3436 else s3437 s3439 :: SWord8 = if s22 then s3438 else s3433 s3440 :: SWord1 = choose [0:0] s3439 s3441 :: SBool = s19 /= s3440 s3442 :: SBool = s_2 == s3441 s3443 :: SWord8 = s3427 >>> 1 s3444 :: SWord8 = s24 | s3443 s3445 :: SWord8 = s26 & s3443 s3446 :: SWord8 = if s3419 then s3444 else s3445 s3447 :: SWord8 = s3446 >>> 1 s3448 :: SWord8 = s24 | s3447 s3449 :: SWord8 = s26 & s3447 s3450 :: SWord8 = if s3441 then s3448 else s3449 s3451 :: SWord1 = choose [0:0] s3434 s3452 :: SBool = s19 /= s3451 s3453 :: SWord8 = s3439 >>> 1 s3454 :: SWord8 = s24 | s3453 s3455 :: SWord8 = s26 & s3453 s3456 :: SWord8 = if s3452 then s3454 else s3455 s3457 :: SWord8 = if s29 then s3416 else s3364 s3458 :: SWord8 = if s170 then s3433 else s3457 s3459 :: SWord8 = if s29 then s3438 else s3458 s3460 :: SWord8 = if s170 then s3456 else s3459 s3461 :: SWord8 = s3446 + s3460 s3462 :: SBool = s3461 < s3460 s3463 :: SBool = s3461 < s3446 s3464 :: SBool = s3462 | s3463 s3465 :: SWord8 = s3461 >>> 1 s3466 :: SWord8 = s24 | s3465 s3467 :: SWord8 = s26 & s3465 s3468 :: SWord8 = if s3464 then s3466 else s3467 s3469 :: SWord8 = if s3442 then s3450 else s3468 s3470 :: SWord8 = s3427 + s3458 s3471 :: SWord1 = choose [0:0] s3470 s3472 :: SBool = s19 /= s3471 s3473 :: SWord8 = if s3472 then s3436 else s3437 s3474 :: SWord8 = if s22 then s3473 else s3433 s3475 :: SWord1 = choose [0:0] s3474 s3476 :: SBool = s19 /= s3475 s3477 :: SBool = s_2 == s3476 s3478 :: SBool = s3470 < s3458 s3479 :: SBool = s3470 < s3427 s3480 :: SBool = s3478 | s3479 s3481 :: SWord8 = s3470 >>> 1 s3482 :: SWord8 = s24 | s3481 s3483 :: SWord8 = s26 & s3481 s3484 :: SWord8 = if s3480 then s3482 else s3483 s3485 :: SWord8 = s3484 >>> 1 s3486 :: SWord8 = s24 | s3485 s3487 :: SWord8 = s26 & s3485 s3488 :: SWord8 = if s3476 then s3486 else s3487 s3489 :: SWord8 = s3474 >>> 1 s3490 :: SWord8 = s24 | s3489 s3491 :: SWord8 = s26 & s3489 s3492 :: SWord8 = if s3452 then s3490 else s3491 s3493 :: SWord8 = if s29 then s3473 else s3458 s3494 :: SWord8 = if s170 then s3492 else s3493 s3495 :: SWord8 = s3484 + s3494 s3496 :: SBool = s3495 < s3494 s3497 :: SBool = s3495 < s3484 s3498 :: SBool = s3496 | s3497 s3499 :: SWord8 = s3495 >>> 1 s3500 :: SWord8 = s24 | s3499 s3501 :: SWord8 = s26 & s3499 s3502 :: SWord8 = if s3498 then s3500 else s3501 s3503 :: SWord8 = if s3477 then s3488 else s3502 s3504 :: SWord8 = if s3420 then s3469 else s3503 s3505 :: SWord8 = if s3304 then s3412 else s3504 s3506 :: SWord8 = s3289 + s3362 s3507 :: SWord1 = choose [0:0] s3506 s3508 :: SBool = s19 /= s3507 s3509 :: SWord8 = if s3508 then s3298 else s3299 s3510 :: SWord8 = if s22 then s3509 else s3295 s3511 :: SWord1 = choose [0:0] s3510 s3512 :: SBool = s19 /= s3511 s3513 :: SBool = s_2 == s3512 s3514 :: SBool = s3506 < s3362 s3515 :: SBool = s3506 < s3289 s3516 :: SBool = s3514 | s3515 s3517 :: SWord8 = s3506 >>> 1 s3518 :: SWord8 = s24 | s3517 s3519 :: SWord8 = s26 & s3517 s3520 :: SWord8 = if s3516 then s3518 else s3519 s3521 :: SWord1 = choose [0:0] s3520 s3522 :: SBool = s19 /= s3521 s3523 :: SWord8 = s3510 >>> 1 s3524 :: SWord8 = s24 | s3523 s3525 :: SWord8 = s26 & s3523 s3526 :: SWord8 = if s3312 then s3524 else s3525 s3527 :: SWord8 = if s22 then s3526 else s3509 s3528 :: SWord8 = s3527 >>> 1 s3529 :: SWord8 = s24 | s3528 s3530 :: SWord8 = s26 & s3528 s3531 :: SWord8 = if s3522 then s3529 else s3530 s3532 :: SWord8 = if s22 then s3531 else s3526 s3533 :: SWord1 = choose [0:0] s3532 s3534 :: SBool = s19 /= s3533 s3535 :: SBool = s_2 == s3534 s3536 :: SWord8 = s3520 >>> 1 s3537 :: SWord8 = s24 | s3536 s3538 :: SWord8 = s26 & s3536 s3539 :: SWord8 = if s3512 then s3537 else s3538 s3540 :: SWord1 = choose [0:0] s3539 s3541 :: SBool = s19 /= s3540 s3542 :: SWord1 = choose [0:0] s3527 s3543 :: SBool = s19 /= s3542 s3544 :: SWord8 = s3532 >>> 1 s3545 :: SWord8 = s24 | s3544 s3546 :: SWord8 = s26 & s3544 s3547 :: SWord8 = if s3543 then s3545 else s3546 s3548 :: SWord8 = if s22 then s3547 else s3531 s3549 :: SWord8 = s3548 >>> 1 s3550 :: SWord8 = s24 | s3549 s3551 :: SWord8 = s26 & s3549 s3552 :: SWord8 = if s3541 then s3550 else s3551 s3553 :: SWord8 = if s22 then s3552 else s3547 s3554 :: SWord1 = choose [0:0] s3553 s3555 :: SBool = s19 /= s3554 s3556 :: SBool = s_2 == s3555 s3557 :: SWord8 = s3539 >>> 1 s3558 :: SWord8 = s24 | s3557 s3559 :: SWord8 = s26 & s3557 s3560 :: SWord8 = if s3534 then s3558 else s3559 s3561 :: SWord8 = s3560 >>> 1 s3562 :: SWord8 = s24 | s3561 s3563 :: SWord8 = s26 & s3561 s3564 :: SWord8 = if s3555 then s3562 else s3563 s3565 :: SWord1 = choose [0:0] s3548 s3566 :: SBool = s19 /= s3565 s3567 :: SWord8 = s3553 >>> 1 s3568 :: SWord8 = s24 | s3567 s3569 :: SWord8 = s26 & s3567 s3570 :: SWord8 = if s3566 then s3568 else s3569 s3571 :: SWord8 = if s29 then s3509 else s3362 s3572 :: SWord8 = if s170 then s3526 else s3571 s3573 :: SWord8 = if s29 then s3531 else s3572 s3574 :: SWord8 = if s170 then s3547 else s3573 s3575 :: SWord8 = if s29 then s3552 else s3574 s3576 :: SWord8 = if s170 then s3570 else s3575 s3577 :: SWord8 = s3560 + s3576 s3578 :: SBool = s3577 < s3576 s3579 :: SBool = s3577 < s3560 s3580 :: SBool = s3578 | s3579 s3581 :: SWord8 = s3577 >>> 1 s3582 :: SWord8 = s24 | s3581 s3583 :: SWord8 = s26 & s3581 s3584 :: SWord8 = if s3580 then s3582 else s3583 s3585 :: SWord8 = if s3556 then s3564 else s3584 s3586 :: SWord8 = s3539 + s3574 s3587 :: SWord1 = choose [0:0] s3586 s3588 :: SBool = s19 /= s3587 s3589 :: SWord8 = if s3588 then s3550 else s3551 s3590 :: SWord8 = if s22 then s3589 else s3547 s3591 :: SWord1 = choose [0:0] s3590 s3592 :: SBool = s19 /= s3591 s3593 :: SBool = s_2 == s3592 s3594 :: SBool = s3586 < s3574 s3595 :: SBool = s3586 < s3539 s3596 :: SBool = s3594 | s3595 s3597 :: SWord8 = s3586 >>> 1 s3598 :: SWord8 = s24 | s3597 s3599 :: SWord8 = s26 & s3597 s3600 :: SWord8 = if s3596 then s3598 else s3599 s3601 :: SWord8 = s3600 >>> 1 s3602 :: SWord8 = s24 | s3601 s3603 :: SWord8 = s26 & s3601 s3604 :: SWord8 = if s3592 then s3602 else s3603 s3605 :: SWord8 = s3590 >>> 1 s3606 :: SWord8 = s24 | s3605 s3607 :: SWord8 = s26 & s3605 s3608 :: SWord8 = if s3566 then s3606 else s3607 s3609 :: SWord8 = if s29 then s3589 else s3574 s3610 :: SWord8 = if s170 then s3608 else s3609 s3611 :: SWord8 = s3600 + s3610 s3612 :: SBool = s3611 < s3610 s3613 :: SBool = s3611 < s3600 s3614 :: SBool = s3612 | s3613 s3615 :: SWord8 = s3611 >>> 1 s3616 :: SWord8 = s24 | s3615 s3617 :: SWord8 = s26 & s3615 s3618 :: SWord8 = if s3614 then s3616 else s3617 s3619 :: SWord8 = if s3593 then s3604 else s3618 s3620 :: SWord8 = if s3535 then s3585 else s3619 s3621 :: SWord8 = s3520 + s3572 s3622 :: SWord1 = choose [0:0] s3621 s3623 :: SBool = s19 /= s3622 s3624 :: SWord8 = if s3623 then s3529 else s3530 s3625 :: SWord8 = if s22 then s3624 else s3526 s3626 :: SWord1 = choose [0:0] s3625 s3627 :: SBool = s19 /= s3626 s3628 :: SBool = s_2 == s3627 s3629 :: SBool = s3621 < s3572 s3630 :: SBool = s3621 < s3520 s3631 :: SBool = s3629 | s3630 s3632 :: SWord8 = s3621 >>> 1 s3633 :: SWord8 = s24 | s3632 s3634 :: SWord8 = s26 & s3632 s3635 :: SWord8 = if s3631 then s3633 else s3634 s3636 :: SWord1 = choose [0:0] s3635 s3637 :: SBool = s19 /= s3636 s3638 :: SWord8 = s3625 >>> 1 s3639 :: SWord8 = s24 | s3638 s3640 :: SWord8 = s26 & s3638 s3641 :: SWord8 = if s3543 then s3639 else s3640 s3642 :: SWord8 = if s22 then s3641 else s3624 s3643 :: SWord8 = s3642 >>> 1 s3644 :: SWord8 = s24 | s3643 s3645 :: SWord8 = s26 & s3643 s3646 :: SWord8 = if s3637 then s3644 else s3645 s3647 :: SWord8 = if s22 then s3646 else s3641 s3648 :: SWord1 = choose [0:0] s3647 s3649 :: SBool = s19 /= s3648 s3650 :: SBool = s_2 == s3649 s3651 :: SWord8 = s3635 >>> 1 s3652 :: SWord8 = s24 | s3651 s3653 :: SWord8 = s26 & s3651 s3654 :: SWord8 = if s3627 then s3652 else s3653 s3655 :: SWord8 = s3654 >>> 1 s3656 :: SWord8 = s24 | s3655 s3657 :: SWord8 = s26 & s3655 s3658 :: SWord8 = if s3649 then s3656 else s3657 s3659 :: SWord1 = choose [0:0] s3642 s3660 :: SBool = s19 /= s3659 s3661 :: SWord8 = s3647 >>> 1 s3662 :: SWord8 = s24 | s3661 s3663 :: SWord8 = s26 & s3661 s3664 :: SWord8 = if s3660 then s3662 else s3663 s3665 :: SWord8 = if s29 then s3624 else s3572 s3666 :: SWord8 = if s170 then s3641 else s3665 s3667 :: SWord8 = if s29 then s3646 else s3666 s3668 :: SWord8 = if s170 then s3664 else s3667 s3669 :: SWord8 = s3654 + s3668 s3670 :: SBool = s3669 < s3668 s3671 :: SBool = s3669 < s3654 s3672 :: SBool = s3670 | s3671 s3673 :: SWord8 = s3669 >>> 1 s3674 :: SWord8 = s24 | s3673 s3675 :: SWord8 = s26 & s3673 s3676 :: SWord8 = if s3672 then s3674 else s3675 s3677 :: SWord8 = if s3650 then s3658 else s3676 s3678 :: SWord8 = s3635 + s3666 s3679 :: SWord1 = choose [0:0] s3678 s3680 :: SBool = s19 /= s3679 s3681 :: SWord8 = if s3680 then s3644 else s3645 s3682 :: SWord8 = if s22 then s3681 else s3641 s3683 :: SWord1 = choose [0:0] s3682 s3684 :: SBool = s19 /= s3683 s3685 :: SBool = s_2 == s3684 s3686 :: SBool = s3678 < s3666 s3687 :: SBool = s3678 < s3635 s3688 :: SBool = s3686 | s3687 s3689 :: SWord8 = s3678 >>> 1 s3690 :: SWord8 = s24 | s3689 s3691 :: SWord8 = s26 & s3689 s3692 :: SWord8 = if s3688 then s3690 else s3691 s3693 :: SWord8 = s3692 >>> 1 s3694 :: SWord8 = s24 | s3693 s3695 :: SWord8 = s26 & s3693 s3696 :: SWord8 = if s3684 then s3694 else s3695 s3697 :: SWord8 = s3682 >>> 1 s3698 :: SWord8 = s24 | s3697 s3699 :: SWord8 = s26 & s3697 s3700 :: SWord8 = if s3660 then s3698 else s3699 s3701 :: SWord8 = if s29 then s3681 else s3666 s3702 :: SWord8 = if s170 then s3700 else s3701 s3703 :: SWord8 = s3692 + s3702 s3704 :: SBool = s3703 < s3702 s3705 :: SBool = s3703 < s3692 s3706 :: SBool = s3704 | s3705 s3707 :: SWord8 = s3703 >>> 1 s3708 :: SWord8 = s24 | s3707 s3709 :: SWord8 = s26 & s3707 s3710 :: SWord8 = if s3706 then s3708 else s3709 s3711 :: SWord8 = if s3685 then s3696 else s3710 s3712 :: SWord8 = if s3628 then s3677 else s3711 s3713 :: SWord8 = if s3513 then s3620 else s3712 s3714 :: SWord8 = if s3282 then s3505 else s3713 s3715 :: SWord8 = if s2819 then s3274 else s3714 s3716 :: SWord8 = if s1892 then s2811 else s3715 s3717 :: SWord8 = if s38 then s1884 else s3716 s3718 :: SWord1 = choose [0:0] s178 s3719 :: SBool = s19 /= s3718 s3720 :: SWord8 = s24 | s33 s3721 :: SWord8 = if s3719 then s3720 else s34 s3722 :: SWord8 = if s22 then s3721 else s28 s3723 :: SWord1 = choose [0:0] s3722 s3724 :: SBool = s19 /= s3723 s3725 :: SBool = s_2 == s3724 s3726 :: SWord8 = s178 >>> 1 s3727 :: SWord8 = s26 & s3726 s3728 :: SWord1 = choose [0:0] s3727 s3729 :: SBool = s19 /= s3728 s3730 :: SWord8 = s3722 >>> 1 s3731 :: SWord8 = s24 | s3730 s3732 :: SWord8 = s26 & s3730 s3733 :: SWord8 = if s43 then s3731 else s3732 s3734 :: SWord8 = if s22 then s3733 else s3721 s3735 :: SWord8 = s3734 >>> 1 s3736 :: SWord8 = s24 | s3735 s3737 :: SWord8 = s26 & s3735 s3738 :: SWord8 = if s3729 then s3736 else s3737 s3739 :: SWord8 = if s22 then s3738 else s3733 s3740 :: SWord1 = choose [0:0] s3739 s3741 :: SBool = s19 /= s3740 s3742 :: SBool = s_2 == s3741 s3743 :: SWord8 = s3727 >>> 1 s3744 :: SWord8 = s24 | s3743 s3745 :: SWord8 = s26 & s3743 s3746 :: SWord8 = if s3724 then s3744 else s3745 s3747 :: SWord1 = choose [0:0] s3746 s3748 :: SBool = s19 /= s3747 s3749 :: SWord1 = choose [0:0] s3734 s3750 :: SBool = s19 /= s3749 s3751 :: SWord8 = s3739 >>> 1 s3752 :: SWord8 = s24 | s3751 s3753 :: SWord8 = s26 & s3751 s3754 :: SWord8 = if s3750 then s3752 else s3753 s3755 :: SWord8 = if s22 then s3754 else s3738 s3756 :: SWord8 = s3755 >>> 1 s3757 :: SWord8 = s24 | s3756 s3758 :: SWord8 = s26 & s3756 s3759 :: SWord8 = if s3748 then s3757 else s3758 s3760 :: SWord8 = if s22 then s3759 else s3754 s3761 :: SWord1 = choose [0:0] s3760 s3762 :: SBool = s19 /= s3761 s3763 :: SBool = s_2 == s3762 s3764 :: SWord8 = s3746 >>> 1 s3765 :: SWord8 = s24 | s3764 s3766 :: SWord8 = s26 & s3764 s3767 :: SWord8 = if s3741 then s3765 else s3766 s3768 :: SWord1 = choose [0:0] s3767 s3769 :: SBool = s19 /= s3768 s3770 :: SWord1 = choose [0:0] s3755 s3771 :: SBool = s19 /= s3770 s3772 :: SWord8 = s3760 >>> 1 s3773 :: SWord8 = s24 | s3772 s3774 :: SWord8 = s26 & s3772 s3775 :: SWord8 = if s3771 then s3773 else s3774 s3776 :: SWord8 = if s22 then s3775 else s3759 s3777 :: SWord8 = s3776 >>> 1 s3778 :: SWord8 = s24 | s3777 s3779 :: SWord8 = s26 & s3777 s3780 :: SWord8 = if s3769 then s3778 else s3779 s3781 :: SWord8 = if s22 then s3780 else s3775 s3782 :: SWord1 = choose [0:0] s3781 s3783 :: SBool = s19 /= s3782 s3784 :: SBool = s_2 == s3783 s3785 :: SWord8 = s3767 >>> 1 s3786 :: SWord8 = s24 | s3785 s3787 :: SWord8 = s26 & s3785 s3788 :: SWord8 = if s3762 then s3786 else s3787 s3789 :: SWord1 = choose [0:0] s3788 s3790 :: SBool = s19 /= s3789 s3791 :: SWord1 = choose [0:0] s3776 s3792 :: SBool = s19 /= s3791 s3793 :: SWord8 = s3781 >>> 1 s3794 :: SWord8 = s24 | s3793 s3795 :: SWord8 = s26 & s3793 s3796 :: SWord8 = if s3792 then s3794 else s3795 s3797 :: SWord8 = if s22 then s3796 else s3780 s3798 :: SWord8 = s3797 >>> 1 s3799 :: SWord8 = s24 | s3798 s3800 :: SWord8 = s26 & s3798 s3801 :: SWord8 = if s3790 then s3799 else s3800 s3802 :: SWord8 = if s22 then s3801 else s3796 s3803 :: SWord1 = choose [0:0] s3802 s3804 :: SBool = s19 /= s3803 s3805 :: SBool = s_2 == s3804 s3806 :: SWord8 = s3788 >>> 1 s3807 :: SWord8 = s24 | s3806 s3808 :: SWord8 = s26 & s3806 s3809 :: SWord8 = if s3783 then s3807 else s3808 s3810 :: SWord1 = choose [0:0] s3809 s3811 :: SBool = s19 /= s3810 s3812 :: SWord1 = choose [0:0] s3797 s3813 :: SBool = s19 /= s3812 s3814 :: SWord8 = s3802 >>> 1 s3815 :: SWord8 = s24 | s3814 s3816 :: SWord8 = s26 & s3814 s3817 :: SWord8 = if s3813 then s3815 else s3816 s3818 :: SWord8 = if s22 then s3817 else s3801 s3819 :: SWord8 = s3818 >>> 1 s3820 :: SWord8 = s24 | s3819 s3821 :: SWord8 = s26 & s3819 s3822 :: SWord8 = if s3811 then s3820 else s3821 s3823 :: SWord8 = if s22 then s3822 else s3817 s3824 :: SWord1 = choose [0:0] s3823 s3825 :: SBool = s19 /= s3824 s3826 :: SBool = s_2 == s3825 s3827 :: SWord8 = s3809 >>> 1 s3828 :: SWord8 = s24 | s3827 s3829 :: SWord8 = s26 & s3827 s3830 :: SWord8 = if s3804 then s3828 else s3829 s3831 :: SWord1 = choose [0:0] s3830 s3832 :: SBool = s19 /= s3831 s3833 :: SWord1 = choose [0:0] s3818 s3834 :: SBool = s19 /= s3833 s3835 :: SWord8 = s3823 >>> 1 s3836 :: SWord8 = s24 | s3835 s3837 :: SWord8 = s26 & s3835 s3838 :: SWord8 = if s3834 then s3836 else s3837 s3839 :: SWord8 = if s22 then s3838 else s3822 s3840 :: SWord8 = s3839 >>> 1 s3841 :: SWord8 = s24 | s3840 s3842 :: SWord8 = s26 & s3840 s3843 :: SWord8 = if s3832 then s3841 else s3842 s3844 :: SWord8 = if s22 then s3843 else s3838 s3845 :: SWord1 = choose [0:0] s3844 s3846 :: SBool = s19 /= s3845 s3847 :: SBool = s_2 == s3846 s3848 :: SWord8 = s3830 >>> 1 s3849 :: SWord8 = s24 | s3848 s3850 :: SWord8 = s26 & s3848 s3851 :: SWord8 = if s3825 then s3849 else s3850 s3852 :: SWord8 = s3851 >>> 1 s3853 :: SWord8 = s24 | s3852 s3854 :: SWord8 = s26 & s3852 s3855 :: SWord8 = if s3846 then s3853 else s3854 s3856 :: SWord1 = choose [0:0] s3839 s3857 :: SBool = s19 /= s3856 s3858 :: SWord8 = s3844 >>> 1 s3859 :: SWord8 = s24 | s3858 s3860 :: SWord8 = s26 & s3858 s3861 :: SWord8 = if s3857 then s3859 else s3860 s3862 :: SWord8 = if s29 then s3721 else s178 s3863 :: SWord8 = if s170 then s3733 else s3862 s3864 :: SWord8 = if s29 then s3738 else s3863 s3865 :: SWord8 = if s170 then s3754 else s3864 s3866 :: SWord8 = if s29 then s3759 else s3865 s3867 :: SWord8 = if s170 then s3775 else s3866 s3868 :: SWord8 = if s29 then s3780 else s3867 s3869 :: SWord8 = if s170 then s3796 else s3868 s3870 :: SWord8 = if s29 then s3801 else s3869 s3871 :: SWord8 = if s170 then s3817 else s3870 s3872 :: SWord8 = if s29 then s3822 else s3871 s3873 :: SWord8 = if s170 then s3838 else s3872 s3874 :: SWord8 = if s29 then s3843 else s3873 s3875 :: SWord8 = if s170 then s3861 else s3874 s3876 :: SWord8 = s3851 + s3875 s3877 :: SBool = s3876 < s3875 s3878 :: SBool = s3876 < s3851 s3879 :: SBool = s3877 | s3878 s3880 :: SWord8 = s3876 >>> 1 s3881 :: SWord8 = s24 | s3880 s3882 :: SWord8 = s26 & s3880 s3883 :: SWord8 = if s3879 then s3881 else s3882 s3884 :: SWord8 = if s3847 then s3855 else s3883 s3885 :: SWord8 = s3830 + s3873 s3886 :: SWord1 = choose [0:0] s3885 s3887 :: SBool = s19 /= s3886 s3888 :: SWord8 = if s3887 then s3841 else s3842 s3889 :: SWord8 = if s22 then s3888 else s3838 s3890 :: SWord1 = choose [0:0] s3889 s3891 :: SBool = s19 /= s3890 s3892 :: SBool = s_2 == s3891 s3893 :: SBool = s3885 < s3873 s3894 :: SBool = s3885 < s3830 s3895 :: SBool = s3893 | s3894 s3896 :: SWord8 = s3885 >>> 1 s3897 :: SWord8 = s24 | s3896 s3898 :: SWord8 = s26 & s3896 s3899 :: SWord8 = if s3895 then s3897 else s3898 s3900 :: SWord8 = s3899 >>> 1 s3901 :: SWord8 = s24 | s3900 s3902 :: SWord8 = s26 & s3900 s3903 :: SWord8 = if s3891 then s3901 else s3902 s3904 :: SWord8 = s3889 >>> 1 s3905 :: SWord8 = s24 | s3904 s3906 :: SWord8 = s26 & s3904 s3907 :: SWord8 = if s3857 then s3905 else s3906 s3908 :: SWord8 = if s29 then s3888 else s3873 s3909 :: SWord8 = if s170 then s3907 else s3908 s3910 :: SWord8 = s3899 + s3909 s3911 :: SBool = s3910 < s3909 s3912 :: SBool = s3910 < s3899 s3913 :: SBool = s3911 | s3912 s3914 :: SWord8 = s3910 >>> 1 s3915 :: SWord8 = s24 | s3914 s3916 :: SWord8 = s26 & s3914 s3917 :: SWord8 = if s3913 then s3915 else s3916 s3918 :: SWord8 = if s3892 then s3903 else s3917 s3919 :: SWord8 = if s3826 then s3884 else s3918 s3920 :: SWord8 = s3809 + s3871 s3921 :: SWord1 = choose [0:0] s3920 s3922 :: SBool = s19 /= s3921 s3923 :: SWord8 = if s3922 then s3820 else s3821 s3924 :: SWord8 = if s22 then s3923 else s3817 s3925 :: SWord1 = choose [0:0] s3924 s3926 :: SBool = s19 /= s3925 s3927 :: SBool = s_2 == s3926 s3928 :: SBool = s3920 < s3871 s3929 :: SBool = s3920 < s3809 s3930 :: SBool = s3928 | s3929 s3931 :: SWord8 = s3920 >>> 1 s3932 :: SWord8 = s24 | s3931 s3933 :: SWord8 = s26 & s3931 s3934 :: SWord8 = if s3930 then s3932 else s3933 s3935 :: SWord1 = choose [0:0] s3934 s3936 :: SBool = s19 /= s3935 s3937 :: SWord8 = s3924 >>> 1 s3938 :: SWord8 = s24 | s3937 s3939 :: SWord8 = s26 & s3937 s3940 :: SWord8 = if s3834 then s3938 else s3939 s3941 :: SWord8 = if s22 then s3940 else s3923 s3942 :: SWord8 = s3941 >>> 1 s3943 :: SWord8 = s24 | s3942 s3944 :: SWord8 = s26 & s3942 s3945 :: SWord8 = if s3936 then s3943 else s3944 s3946 :: SWord8 = if s22 then s3945 else s3940 s3947 :: SWord1 = choose [0:0] s3946 s3948 :: SBool = s19 /= s3947 s3949 :: SBool = s_2 == s3948 s3950 :: SWord8 = s3934 >>> 1 s3951 :: SWord8 = s24 | s3950 s3952 :: SWord8 = s26 & s3950 s3953 :: SWord8 = if s3926 then s3951 else s3952 s3954 :: SWord8 = s3953 >>> 1 s3955 :: SWord8 = s24 | s3954 s3956 :: SWord8 = s26 & s3954 s3957 :: SWord8 = if s3948 then s3955 else s3956 s3958 :: SWord1 = choose [0:0] s3941 s3959 :: SBool = s19 /= s3958 s3960 :: SWord8 = s3946 >>> 1 s3961 :: SWord8 = s24 | s3960 s3962 :: SWord8 = s26 & s3960 s3963 :: SWord8 = if s3959 then s3961 else s3962 s3964 :: SWord8 = if s29 then s3923 else s3871 s3965 :: SWord8 = if s170 then s3940 else s3964 s3966 :: SWord8 = if s29 then s3945 else s3965 s3967 :: SWord8 = if s170 then s3963 else s3966 s3968 :: SWord8 = s3953 + s3967 s3969 :: SBool = s3968 < s3967 s3970 :: SBool = s3968 < s3953 s3971 :: SBool = s3969 | s3970 s3972 :: SWord8 = s3968 >>> 1 s3973 :: SWord8 = s24 | s3972 s3974 :: SWord8 = s26 & s3972 s3975 :: SWord8 = if s3971 then s3973 else s3974 s3976 :: SWord8 = if s3949 then s3957 else s3975 s3977 :: SWord8 = s3934 + s3965 s3978 :: SWord1 = choose [0:0] s3977 s3979 :: SBool = s19 /= s3978 s3980 :: SWord8 = if s3979 then s3943 else s3944 s3981 :: SWord8 = if s22 then s3980 else s3940 s3982 :: SWord1 = choose [0:0] s3981 s3983 :: SBool = s19 /= s3982 s3984 :: SBool = s_2 == s3983 s3985 :: SBool = s3977 < s3965 s3986 :: SBool = s3977 < s3934 s3987 :: SBool = s3985 | s3986 s3988 :: SWord8 = s3977 >>> 1 s3989 :: SWord8 = s24 | s3988 s3990 :: SWord8 = s26 & s3988 s3991 :: SWord8 = if s3987 then s3989 else s3990 s3992 :: SWord8 = s3991 >>> 1 s3993 :: SWord8 = s24 | s3992 s3994 :: SWord8 = s26 & s3992 s3995 :: SWord8 = if s3983 then s3993 else s3994 s3996 :: SWord8 = s3981 >>> 1 s3997 :: SWord8 = s24 | s3996 s3998 :: SWord8 = s26 & s3996 s3999 :: SWord8 = if s3959 then s3997 else s3998 s4000 :: SWord8 = if s29 then s3980 else s3965 s4001 :: SWord8 = if s170 then s3999 else s4000 s4002 :: SWord8 = s3991 + s4001 s4003 :: SBool = s4002 < s4001 s4004 :: SBool = s4002 < s3991 s4005 :: SBool = s4003 | s4004 s4006 :: SWord8 = s4002 >>> 1 s4007 :: SWord8 = s24 | s4006 s4008 :: SWord8 = s26 & s4006 s4009 :: SWord8 = if s4005 then s4007 else s4008 s4010 :: SWord8 = if s3984 then s3995 else s4009 s4011 :: SWord8 = if s3927 then s3976 else s4010 s4012 :: SWord8 = if s3805 then s3919 else s4011 s4013 :: SWord8 = s3788 + s3869 s4014 :: SWord1 = choose [0:0] s4013 s4015 :: SBool = s19 /= s4014 s4016 :: SWord8 = if s4015 then s3799 else s3800 s4017 :: SWord8 = if s22 then s4016 else s3796 s4018 :: SWord1 = choose [0:0] s4017 s4019 :: SBool = s19 /= s4018 s4020 :: SBool = s_2 == s4019 s4021 :: SBool = s4013 < s3869 s4022 :: SBool = s4013 < s3788 s4023 :: SBool = s4021 | s4022 s4024 :: SWord8 = s4013 >>> 1 s4025 :: SWord8 = s24 | s4024 s4026 :: SWord8 = s26 & s4024 s4027 :: SWord8 = if s4023 then s4025 else s4026 s4028 :: SWord1 = choose [0:0] s4027 s4029 :: SBool = s19 /= s4028 s4030 :: SWord8 = s4017 >>> 1 s4031 :: SWord8 = s24 | s4030 s4032 :: SWord8 = s26 & s4030 s4033 :: SWord8 = if s3813 then s4031 else s4032 s4034 :: SWord8 = if s22 then s4033 else s4016 s4035 :: SWord8 = s4034 >>> 1 s4036 :: SWord8 = s24 | s4035 s4037 :: SWord8 = s26 & s4035 s4038 :: SWord8 = if s4029 then s4036 else s4037 s4039 :: SWord8 = if s22 then s4038 else s4033 s4040 :: SWord1 = choose [0:0] s4039 s4041 :: SBool = s19 /= s4040 s4042 :: SBool = s_2 == s4041 s4043 :: SWord8 = s4027 >>> 1 s4044 :: SWord8 = s24 | s4043 s4045 :: SWord8 = s26 & s4043 s4046 :: SWord8 = if s4019 then s4044 else s4045 s4047 :: SWord1 = choose [0:0] s4046 s4048 :: SBool = s19 /= s4047 s4049 :: SWord1 = choose [0:0] s4034 s4050 :: SBool = s19 /= s4049 s4051 :: SWord8 = s4039 >>> 1 s4052 :: SWord8 = s24 | s4051 s4053 :: SWord8 = s26 & s4051 s4054 :: SWord8 = if s4050 then s4052 else s4053 s4055 :: SWord8 = if s22 then s4054 else s4038 s4056 :: SWord8 = s4055 >>> 1 s4057 :: SWord8 = s24 | s4056 s4058 :: SWord8 = s26 & s4056 s4059 :: SWord8 = if s4048 then s4057 else s4058 s4060 :: SWord8 = if s22 then s4059 else s4054 s4061 :: SWord1 = choose [0:0] s4060 s4062 :: SBool = s19 /= s4061 s4063 :: SBool = s_2 == s4062 s4064 :: SWord8 = s4046 >>> 1 s4065 :: SWord8 = s24 | s4064 s4066 :: SWord8 = s26 & s4064 s4067 :: SWord8 = if s4041 then s4065 else s4066 s4068 :: SWord8 = s4067 >>> 1 s4069 :: SWord8 = s24 | s4068 s4070 :: SWord8 = s26 & s4068 s4071 :: SWord8 = if s4062 then s4069 else s4070 s4072 :: SWord1 = choose [0:0] s4055 s4073 :: SBool = s19 /= s4072 s4074 :: SWord8 = s4060 >>> 1 s4075 :: SWord8 = s24 | s4074 s4076 :: SWord8 = s26 & s4074 s4077 :: SWord8 = if s4073 then s4075 else s4076 s4078 :: SWord8 = if s29 then s4016 else s3869 s4079 :: SWord8 = if s170 then s4033 else s4078 s4080 :: SWord8 = if s29 then s4038 else s4079 s4081 :: SWord8 = if s170 then s4054 else s4080 s4082 :: SWord8 = if s29 then s4059 else s4081 s4083 :: SWord8 = if s170 then s4077 else s4082 s4084 :: SWord8 = s4067 + s4083 s4085 :: SBool = s4084 < s4083 s4086 :: SBool = s4084 < s4067 s4087 :: SBool = s4085 | s4086 s4088 :: SWord8 = s4084 >>> 1 s4089 :: SWord8 = s24 | s4088 s4090 :: SWord8 = s26 & s4088 s4091 :: SWord8 = if s4087 then s4089 else s4090 s4092 :: SWord8 = if s4063 then s4071 else s4091 s4093 :: SWord8 = s4046 + s4081 s4094 :: SWord1 = choose [0:0] s4093 s4095 :: SBool = s19 /= s4094 s4096 :: SWord8 = if s4095 then s4057 else s4058 s4097 :: SWord8 = if s22 then s4096 else s4054 s4098 :: SWord1 = choose [0:0] s4097 s4099 :: SBool = s19 /= s4098 s4100 :: SBool = s_2 == s4099 s4101 :: SBool = s4093 < s4081 s4102 :: SBool = s4093 < s4046 s4103 :: SBool = s4101 | s4102 s4104 :: SWord8 = s4093 >>> 1 s4105 :: SWord8 = s24 | s4104 s4106 :: SWord8 = s26 & s4104 s4107 :: SWord8 = if s4103 then s4105 else s4106 s4108 :: SWord8 = s4107 >>> 1 s4109 :: SWord8 = s24 | s4108 s4110 :: SWord8 = s26 & s4108 s4111 :: SWord8 = if s4099 then s4109 else s4110 s4112 :: SWord8 = s4097 >>> 1 s4113 :: SWord8 = s24 | s4112 s4114 :: SWord8 = s26 & s4112 s4115 :: SWord8 = if s4073 then s4113 else s4114 s4116 :: SWord8 = if s29 then s4096 else s4081 s4117 :: SWord8 = if s170 then s4115 else s4116 s4118 :: SWord8 = s4107 + s4117 s4119 :: SBool = s4118 < s4117 s4120 :: SBool = s4118 < s4107 s4121 :: SBool = s4119 | s4120 s4122 :: SWord8 = s4118 >>> 1 s4123 :: SWord8 = s24 | s4122 s4124 :: SWord8 = s26 & s4122 s4125 :: SWord8 = if s4121 then s4123 else s4124 s4126 :: SWord8 = if s4100 then s4111 else s4125 s4127 :: SWord8 = if s4042 then s4092 else s4126 s4128 :: SWord8 = s4027 + s4079 s4129 :: SWord1 = choose [0:0] s4128 s4130 :: SBool = s19 /= s4129 s4131 :: SWord8 = if s4130 then s4036 else s4037 s4132 :: SWord8 = if s22 then s4131 else s4033 s4133 :: SWord1 = choose [0:0] s4132 s4134 :: SBool = s19 /= s4133 s4135 :: SBool = s_2 == s4134 s4136 :: SBool = s4128 < s4079 s4137 :: SBool = s4128 < s4027 s4138 :: SBool = s4136 | s4137 s4139 :: SWord8 = s4128 >>> 1 s4140 :: SWord8 = s24 | s4139 s4141 :: SWord8 = s26 & s4139 s4142 :: SWord8 = if s4138 then s4140 else s4141 s4143 :: SWord1 = choose [0:0] s4142 s4144 :: SBool = s19 /= s4143 s4145 :: SWord8 = s4132 >>> 1 s4146 :: SWord8 = s24 | s4145 s4147 :: SWord8 = s26 & s4145 s4148 :: SWord8 = if s4050 then s4146 else s4147 s4149 :: SWord8 = if s22 then s4148 else s4131 s4150 :: SWord8 = s4149 >>> 1 s4151 :: SWord8 = s24 | s4150 s4152 :: SWord8 = s26 & s4150 s4153 :: SWord8 = if s4144 then s4151 else s4152 s4154 :: SWord8 = if s22 then s4153 else s4148 s4155 :: SWord1 = choose [0:0] s4154 s4156 :: SBool = s19 /= s4155 s4157 :: SBool = s_2 == s4156 s4158 :: SWord8 = s4142 >>> 1 s4159 :: SWord8 = s24 | s4158 s4160 :: SWord8 = s26 & s4158 s4161 :: SWord8 = if s4134 then s4159 else s4160 s4162 :: SWord8 = s4161 >>> 1 s4163 :: SWord8 = s24 | s4162 s4164 :: SWord8 = s26 & s4162 s4165 :: SWord8 = if s4156 then s4163 else s4164 s4166 :: SWord1 = choose [0:0] s4149 s4167 :: SBool = s19 /= s4166 s4168 :: SWord8 = s4154 >>> 1 s4169 :: SWord8 = s24 | s4168 s4170 :: SWord8 = s26 & s4168 s4171 :: SWord8 = if s4167 then s4169 else s4170 s4172 :: SWord8 = if s29 then s4131 else s4079 s4173 :: SWord8 = if s170 then s4148 else s4172 s4174 :: SWord8 = if s29 then s4153 else s4173 s4175 :: SWord8 = if s170 then s4171 else s4174 s4176 :: SWord8 = s4161 + s4175 s4177 :: SBool = s4176 < s4175 s4178 :: SBool = s4176 < s4161 s4179 :: SBool = s4177 | s4178 s4180 :: SWord8 = s4176 >>> 1 s4181 :: SWord8 = s24 | s4180 s4182 :: SWord8 = s26 & s4180 s4183 :: SWord8 = if s4179 then s4181 else s4182 s4184 :: SWord8 = if s4157 then s4165 else s4183 s4185 :: SWord8 = s4142 + s4173 s4186 :: SWord1 = choose [0:0] s4185 s4187 :: SBool = s19 /= s4186 s4188 :: SWord8 = if s4187 then s4151 else s4152 s4189 :: SWord8 = if s22 then s4188 else s4148 s4190 :: SWord1 = choose [0:0] s4189 s4191 :: SBool = s19 /= s4190 s4192 :: SBool = s_2 == s4191 s4193 :: SBool = s4185 < s4173 s4194 :: SBool = s4185 < s4142 s4195 :: SBool = s4193 | s4194 s4196 :: SWord8 = s4185 >>> 1 s4197 :: SWord8 = s24 | s4196 s4198 :: SWord8 = s26 & s4196 s4199 :: SWord8 = if s4195 then s4197 else s4198 s4200 :: SWord8 = s4199 >>> 1 s4201 :: SWord8 = s24 | s4200 s4202 :: SWord8 = s26 & s4200 s4203 :: SWord8 = if s4191 then s4201 else s4202 s4204 :: SWord8 = s4189 >>> 1 s4205 :: SWord8 = s24 | s4204 s4206 :: SWord8 = s26 & s4204 s4207 :: SWord8 = if s4167 then s4205 else s4206 s4208 :: SWord8 = if s29 then s4188 else s4173 s4209 :: SWord8 = if s170 then s4207 else s4208 s4210 :: SWord8 = s4199 + s4209 s4211 :: SBool = s4210 < s4209 s4212 :: SBool = s4210 < s4199 s4213 :: SBool = s4211 | s4212 s4214 :: SWord8 = s4210 >>> 1 s4215 :: SWord8 = s24 | s4214 s4216 :: SWord8 = s26 & s4214 s4217 :: SWord8 = if s4213 then s4215 else s4216 s4218 :: SWord8 = if s4192 then s4203 else s4217 s4219 :: SWord8 = if s4135 then s4184 else s4218 s4220 :: SWord8 = if s4020 then s4127 else s4219 s4221 :: SWord8 = if s3784 then s4012 else s4220 s4222 :: SWord8 = s3767 + s3867 s4223 :: SWord1 = choose [0:0] s4222 s4224 :: SBool = s19 /= s4223 s4225 :: SWord8 = if s4224 then s3778 else s3779 s4226 :: SWord8 = if s22 then s4225 else s3775 s4227 :: SWord1 = choose [0:0] s4226 s4228 :: SBool = s19 /= s4227 s4229 :: SBool = s_2 == s4228 s4230 :: SBool = s4222 < s3867 s4231 :: SBool = s4222 < s3767 s4232 :: SBool = s4230 | s4231 s4233 :: SWord8 = s4222 >>> 1 s4234 :: SWord8 = s24 | s4233 s4235 :: SWord8 = s26 & s4233 s4236 :: SWord8 = if s4232 then s4234 else s4235 s4237 :: SWord1 = choose [0:0] s4236 s4238 :: SBool = s19 /= s4237 s4239 :: SWord8 = s4226 >>> 1 s4240 :: SWord8 = s24 | s4239 s4241 :: SWord8 = s26 & s4239 s4242 :: SWord8 = if s3792 then s4240 else s4241 s4243 :: SWord8 = if s22 then s4242 else s4225 s4244 :: SWord8 = s4243 >>> 1 s4245 :: SWord8 = s24 | s4244 s4246 :: SWord8 = s26 & s4244 s4247 :: SWord8 = if s4238 then s4245 else s4246 s4248 :: SWord8 = if s22 then s4247 else s4242 s4249 :: SWord1 = choose [0:0] s4248 s4250 :: SBool = s19 /= s4249 s4251 :: SBool = s_2 == s4250 s4252 :: SWord8 = s4236 >>> 1 s4253 :: SWord8 = s24 | s4252 s4254 :: SWord8 = s26 & s4252 s4255 :: SWord8 = if s4228 then s4253 else s4254 s4256 :: SWord1 = choose [0:0] s4255 s4257 :: SBool = s19 /= s4256 s4258 :: SWord1 = choose [0:0] s4243 s4259 :: SBool = s19 /= s4258 s4260 :: SWord8 = s4248 >>> 1 s4261 :: SWord8 = s24 | s4260 s4262 :: SWord8 = s26 & s4260 s4263 :: SWord8 = if s4259 then s4261 else s4262 s4264 :: SWord8 = if s22 then s4263 else s4247 s4265 :: SWord8 = s4264 >>> 1 s4266 :: SWord8 = s24 | s4265 s4267 :: SWord8 = s26 & s4265 s4268 :: SWord8 = if s4257 then s4266 else s4267 s4269 :: SWord8 = if s22 then s4268 else s4263 s4270 :: SWord1 = choose [0:0] s4269 s4271 :: SBool = s19 /= s4270 s4272 :: SBool = s_2 == s4271 s4273 :: SWord8 = s4255 >>> 1 s4274 :: SWord8 = s24 | s4273 s4275 :: SWord8 = s26 & s4273 s4276 :: SWord8 = if s4250 then s4274 else s4275 s4277 :: SWord1 = choose [0:0] s4276 s4278 :: SBool = s19 /= s4277 s4279 :: SWord1 = choose [0:0] s4264 s4280 :: SBool = s19 /= s4279 s4281 :: SWord8 = s4269 >>> 1 s4282 :: SWord8 = s24 | s4281 s4283 :: SWord8 = s26 & s4281 s4284 :: SWord8 = if s4280 then s4282 else s4283 s4285 :: SWord8 = if s22 then s4284 else s4268 s4286 :: SWord8 = s4285 >>> 1 s4287 :: SWord8 = s24 | s4286 s4288 :: SWord8 = s26 & s4286 s4289 :: SWord8 = if s4278 then s4287 else s4288 s4290 :: SWord8 = if s22 then s4289 else s4284 s4291 :: SWord1 = choose [0:0] s4290 s4292 :: SBool = s19 /= s4291 s4293 :: SBool = s_2 == s4292 s4294 :: SWord8 = s4276 >>> 1 s4295 :: SWord8 = s24 | s4294 s4296 :: SWord8 = s26 & s4294 s4297 :: SWord8 = if s4271 then s4295 else s4296 s4298 :: SWord8 = s4297 >>> 1 s4299 :: SWord8 = s24 | s4298 s4300 :: SWord8 = s26 & s4298 s4301 :: SWord8 = if s4292 then s4299 else s4300 s4302 :: SWord1 = choose [0:0] s4285 s4303 :: SBool = s19 /= s4302 s4304 :: SWord8 = s4290 >>> 1 s4305 :: SWord8 = s24 | s4304 s4306 :: SWord8 = s26 & s4304 s4307 :: SWord8 = if s4303 then s4305 else s4306 s4308 :: SWord8 = if s29 then s4225 else s3867 s4309 :: SWord8 = if s170 then s4242 else s4308 s4310 :: SWord8 = if s29 then s4247 else s4309 s4311 :: SWord8 = if s170 then s4263 else s4310 s4312 :: SWord8 = if s29 then s4268 else s4311 s4313 :: SWord8 = if s170 then s4284 else s4312 s4314 :: SWord8 = if s29 then s4289 else s4313 s4315 :: SWord8 = if s170 then s4307 else s4314 s4316 :: SWord8 = s4297 + s4315 s4317 :: SBool = s4316 < s4315 s4318 :: SBool = s4316 < s4297 s4319 :: SBool = s4317 | s4318 s4320 :: SWord8 = s4316 >>> 1 s4321 :: SWord8 = s24 | s4320 s4322 :: SWord8 = s26 & s4320 s4323 :: SWord8 = if s4319 then s4321 else s4322 s4324 :: SWord8 = if s4293 then s4301 else s4323 s4325 :: SWord8 = s4276 + s4313 s4326 :: SWord1 = choose [0:0] s4325 s4327 :: SBool = s19 /= s4326 s4328 :: SWord8 = if s4327 then s4287 else s4288 s4329 :: SWord8 = if s22 then s4328 else s4284 s4330 :: SWord1 = choose [0:0] s4329 s4331 :: SBool = s19 /= s4330 s4332 :: SBool = s_2 == s4331 s4333 :: SBool = s4325 < s4313 s4334 :: SBool = s4325 < s4276 s4335 :: SBool = s4333 | s4334 s4336 :: SWord8 = s4325 >>> 1 s4337 :: SWord8 = s24 | s4336 s4338 :: SWord8 = s26 & s4336 s4339 :: SWord8 = if s4335 then s4337 else s4338 s4340 :: SWord8 = s4339 >>> 1 s4341 :: SWord8 = s24 | s4340 s4342 :: SWord8 = s26 & s4340 s4343 :: SWord8 = if s4331 then s4341 else s4342 s4344 :: SWord8 = s4329 >>> 1 s4345 :: SWord8 = s24 | s4344 s4346 :: SWord8 = s26 & s4344 s4347 :: SWord8 = if s4303 then s4345 else s4346 s4348 :: SWord8 = if s29 then s4328 else s4313 s4349 :: SWord8 = if s170 then s4347 else s4348 s4350 :: SWord8 = s4339 + s4349 s4351 :: SBool = s4350 < s4349 s4352 :: SBool = s4350 < s4339 s4353 :: SBool = s4351 | s4352 s4354 :: SWord8 = s4350 >>> 1 s4355 :: SWord8 = s24 | s4354 s4356 :: SWord8 = s26 & s4354 s4357 :: SWord8 = if s4353 then s4355 else s4356 s4358 :: SWord8 = if s4332 then s4343 else s4357 s4359 :: SWord8 = if s4272 then s4324 else s4358 s4360 :: SWord8 = s4255 + s4311 s4361 :: SWord1 = choose [0:0] s4360 s4362 :: SBool = s19 /= s4361 s4363 :: SWord8 = if s4362 then s4266 else s4267 s4364 :: SWord8 = if s22 then s4363 else s4263 s4365 :: SWord1 = choose [0:0] s4364 s4366 :: SBool = s19 /= s4365 s4367 :: SBool = s_2 == s4366 s4368 :: SBool = s4360 < s4311 s4369 :: SBool = s4360 < s4255 s4370 :: SBool = s4368 | s4369 s4371 :: SWord8 = s4360 >>> 1 s4372 :: SWord8 = s24 | s4371 s4373 :: SWord8 = s26 & s4371 s4374 :: SWord8 = if s4370 then s4372 else s4373 s4375 :: SWord1 = choose [0:0] s4374 s4376 :: SBool = s19 /= s4375 s4377 :: SWord8 = s4364 >>> 1 s4378 :: SWord8 = s24 | s4377 s4379 :: SWord8 = s26 & s4377 s4380 :: SWord8 = if s4280 then s4378 else s4379 s4381 :: SWord8 = if s22 then s4380 else s4363 s4382 :: SWord8 = s4381 >>> 1 s4383 :: SWord8 = s24 | s4382 s4384 :: SWord8 = s26 & s4382 s4385 :: SWord8 = if s4376 then s4383 else s4384 s4386 :: SWord8 = if s22 then s4385 else s4380 s4387 :: SWord1 = choose [0:0] s4386 s4388 :: SBool = s19 /= s4387 s4389 :: SBool = s_2 == s4388 s4390 :: SWord8 = s4374 >>> 1 s4391 :: SWord8 = s24 | s4390 s4392 :: SWord8 = s26 & s4390 s4393 :: SWord8 = if s4366 then s4391 else s4392 s4394 :: SWord8 = s4393 >>> 1 s4395 :: SWord8 = s24 | s4394 s4396 :: SWord8 = s26 & s4394 s4397 :: SWord8 = if s4388 then s4395 else s4396 s4398 :: SWord1 = choose [0:0] s4381 s4399 :: SBool = s19 /= s4398 s4400 :: SWord8 = s4386 >>> 1 s4401 :: SWord8 = s24 | s4400 s4402 :: SWord8 = s26 & s4400 s4403 :: SWord8 = if s4399 then s4401 else s4402 s4404 :: SWord8 = if s29 then s4363 else s4311 s4405 :: SWord8 = if s170 then s4380 else s4404 s4406 :: SWord8 = if s29 then s4385 else s4405 s4407 :: SWord8 = if s170 then s4403 else s4406 s4408 :: SWord8 = s4393 + s4407 s4409 :: SBool = s4408 < s4407 s4410 :: SBool = s4408 < s4393 s4411 :: SBool = s4409 | s4410 s4412 :: SWord8 = s4408 >>> 1 s4413 :: SWord8 = s24 | s4412 s4414 :: SWord8 = s26 & s4412 s4415 :: SWord8 = if s4411 then s4413 else s4414 s4416 :: SWord8 = if s4389 then s4397 else s4415 s4417 :: SWord8 = s4374 + s4405 s4418 :: SWord1 = choose [0:0] s4417 s4419 :: SBool = s19 /= s4418 s4420 :: SWord8 = if s4419 then s4383 else s4384 s4421 :: SWord8 = if s22 then s4420 else s4380 s4422 :: SWord1 = choose [0:0] s4421 s4423 :: SBool = s19 /= s4422 s4424 :: SBool = s_2 == s4423 s4425 :: SBool = s4417 < s4405 s4426 :: SBool = s4417 < s4374 s4427 :: SBool = s4425 | s4426 s4428 :: SWord8 = s4417 >>> 1 s4429 :: SWord8 = s24 | s4428 s4430 :: SWord8 = s26 & s4428 s4431 :: SWord8 = if s4427 then s4429 else s4430 s4432 :: SWord8 = s4431 >>> 1 s4433 :: SWord8 = s24 | s4432 s4434 :: SWord8 = s26 & s4432 s4435 :: SWord8 = if s4423 then s4433 else s4434 s4436 :: SWord8 = s4421 >>> 1 s4437 :: SWord8 = s24 | s4436 s4438 :: SWord8 = s26 & s4436 s4439 :: SWord8 = if s4399 then s4437 else s4438 s4440 :: SWord8 = if s29 then s4420 else s4405 s4441 :: SWord8 = if s170 then s4439 else s4440 s4442 :: SWord8 = s4431 + s4441 s4443 :: SBool = s4442 < s4441 s4444 :: SBool = s4442 < s4431 s4445 :: SBool = s4443 | s4444 s4446 :: SWord8 = s4442 >>> 1 s4447 :: SWord8 = s24 | s4446 s4448 :: SWord8 = s26 & s4446 s4449 :: SWord8 = if s4445 then s4447 else s4448 s4450 :: SWord8 = if s4424 then s4435 else s4449 s4451 :: SWord8 = if s4367 then s4416 else s4450 s4452 :: SWord8 = if s4251 then s4359 else s4451 s4453 :: SWord8 = s4236 + s4309 s4454 :: SWord1 = choose [0:0] s4453 s4455 :: SBool = s19 /= s4454 s4456 :: SWord8 = if s4455 then s4245 else s4246 s4457 :: SWord8 = if s22 then s4456 else s4242 s4458 :: SWord1 = choose [0:0] s4457 s4459 :: SBool = s19 /= s4458 s4460 :: SBool = s_2 == s4459 s4461 :: SBool = s4453 < s4309 s4462 :: SBool = s4453 < s4236 s4463 :: SBool = s4461 | s4462 s4464 :: SWord8 = s4453 >>> 1 s4465 :: SWord8 = s24 | s4464 s4466 :: SWord8 = s26 & s4464 s4467 :: SWord8 = if s4463 then s4465 else s4466 s4468 :: SWord1 = choose [0:0] s4467 s4469 :: SBool = s19 /= s4468 s4470 :: SWord8 = s4457 >>> 1 s4471 :: SWord8 = s24 | s4470 s4472 :: SWord8 = s26 & s4470 s4473 :: SWord8 = if s4259 then s4471 else s4472 s4474 :: SWord8 = if s22 then s4473 else s4456 s4475 :: SWord8 = s4474 >>> 1 s4476 :: SWord8 = s24 | s4475 s4477 :: SWord8 = s26 & s4475 s4478 :: SWord8 = if s4469 then s4476 else s4477 s4479 :: SWord8 = if s22 then s4478 else s4473 s4480 :: SWord1 = choose [0:0] s4479 s4481 :: SBool = s19 /= s4480 s4482 :: SBool = s_2 == s4481 s4483 :: SWord8 = s4467 >>> 1 s4484 :: SWord8 = s24 | s4483 s4485 :: SWord8 = s26 & s4483 s4486 :: SWord8 = if s4459 then s4484 else s4485 s4487 :: SWord1 = choose [0:0] s4486 s4488 :: SBool = s19 /= s4487 s4489 :: SWord1 = choose [0:0] s4474 s4490 :: SBool = s19 /= s4489 s4491 :: SWord8 = s4479 >>> 1 s4492 :: SWord8 = s24 | s4491 s4493 :: SWord8 = s26 & s4491 s4494 :: SWord8 = if s4490 then s4492 else s4493 s4495 :: SWord8 = if s22 then s4494 else s4478 s4496 :: SWord8 = s4495 >>> 1 s4497 :: SWord8 = s24 | s4496 s4498 :: SWord8 = s26 & s4496 s4499 :: SWord8 = if s4488 then s4497 else s4498 s4500 :: SWord8 = if s22 then s4499 else s4494 s4501 :: SWord1 = choose [0:0] s4500 s4502 :: SBool = s19 /= s4501 s4503 :: SBool = s_2 == s4502 s4504 :: SWord8 = s4486 >>> 1 s4505 :: SWord8 = s24 | s4504 s4506 :: SWord8 = s26 & s4504 s4507 :: SWord8 = if s4481 then s4505 else s4506 s4508 :: SWord8 = s4507 >>> 1 s4509 :: SWord8 = s24 | s4508 s4510 :: SWord8 = s26 & s4508 s4511 :: SWord8 = if s4502 then s4509 else s4510 s4512 :: SWord1 = choose [0:0] s4495 s4513 :: SBool = s19 /= s4512 s4514 :: SWord8 = s4500 >>> 1 s4515 :: SWord8 = s24 | s4514 s4516 :: SWord8 = s26 & s4514 s4517 :: SWord8 = if s4513 then s4515 else s4516 s4518 :: SWord8 = if s29 then s4456 else s4309 s4519 :: SWord8 = if s170 then s4473 else s4518 s4520 :: SWord8 = if s29 then s4478 else s4519 s4521 :: SWord8 = if s170 then s4494 else s4520 s4522 :: SWord8 = if s29 then s4499 else s4521 s4523 :: SWord8 = if s170 then s4517 else s4522 s4524 :: SWord8 = s4507 + s4523 s4525 :: SBool = s4524 < s4523 s4526 :: SBool = s4524 < s4507 s4527 :: SBool = s4525 | s4526 s4528 :: SWord8 = s4524 >>> 1 s4529 :: SWord8 = s24 | s4528 s4530 :: SWord8 = s26 & s4528 s4531 :: SWord8 = if s4527 then s4529 else s4530 s4532 :: SWord8 = if s4503 then s4511 else s4531 s4533 :: SWord8 = s4486 + s4521 s4534 :: SWord1 = choose [0:0] s4533 s4535 :: SBool = s19 /= s4534 s4536 :: SWord8 = if s4535 then s4497 else s4498 s4537 :: SWord8 = if s22 then s4536 else s4494 s4538 :: SWord1 = choose [0:0] s4537 s4539 :: SBool = s19 /= s4538 s4540 :: SBool = s_2 == s4539 s4541 :: SBool = s4533 < s4521 s4542 :: SBool = s4533 < s4486 s4543 :: SBool = s4541 | s4542 s4544 :: SWord8 = s4533 >>> 1 s4545 :: SWord8 = s24 | s4544 s4546 :: SWord8 = s26 & s4544 s4547 :: SWord8 = if s4543 then s4545 else s4546 s4548 :: SWord8 = s4547 >>> 1 s4549 :: SWord8 = s24 | s4548 s4550 :: SWord8 = s26 & s4548 s4551 :: SWord8 = if s4539 then s4549 else s4550 s4552 :: SWord8 = s4537 >>> 1 s4553 :: SWord8 = s24 | s4552 s4554 :: SWord8 = s26 & s4552 s4555 :: SWord8 = if s4513 then s4553 else s4554 s4556 :: SWord8 = if s29 then s4536 else s4521 s4557 :: SWord8 = if s170 then s4555 else s4556 s4558 :: SWord8 = s4547 + s4557 s4559 :: SBool = s4558 < s4557 s4560 :: SBool = s4558 < s4547 s4561 :: SBool = s4559 | s4560 s4562 :: SWord8 = s4558 >>> 1 s4563 :: SWord8 = s24 | s4562 s4564 :: SWord8 = s26 & s4562 s4565 :: SWord8 = if s4561 then s4563 else s4564 s4566 :: SWord8 = if s4540 then s4551 else s4565 s4567 :: SWord8 = if s4482 then s4532 else s4566 s4568 :: SWord8 = s4467 + s4519 s4569 :: SWord1 = choose [0:0] s4568 s4570 :: SBool = s19 /= s4569 s4571 :: SWord8 = if s4570 then s4476 else s4477 s4572 :: SWord8 = if s22 then s4571 else s4473 s4573 :: SWord1 = choose [0:0] s4572 s4574 :: SBool = s19 /= s4573 s4575 :: SBool = s_2 == s4574 s4576 :: SBool = s4568 < s4519 s4577 :: SBool = s4568 < s4467 s4578 :: SBool = s4576 | s4577 s4579 :: SWord8 = s4568 >>> 1 s4580 :: SWord8 = s24 | s4579 s4581 :: SWord8 = s26 & s4579 s4582 :: SWord8 = if s4578 then s4580 else s4581 s4583 :: SWord1 = choose [0:0] s4582 s4584 :: SBool = s19 /= s4583 s4585 :: SWord8 = s4572 >>> 1 s4586 :: SWord8 = s24 | s4585 s4587 :: SWord8 = s26 & s4585 s4588 :: SWord8 = if s4490 then s4586 else s4587 s4589 :: SWord8 = if s22 then s4588 else s4571 s4590 :: SWord8 = s4589 >>> 1 s4591 :: SWord8 = s24 | s4590 s4592 :: SWord8 = s26 & s4590 s4593 :: SWord8 = if s4584 then s4591 else s4592 s4594 :: SWord8 = if s22 then s4593 else s4588 s4595 :: SWord1 = choose [0:0] s4594 s4596 :: SBool = s19 /= s4595 s4597 :: SBool = s_2 == s4596 s4598 :: SWord8 = s4582 >>> 1 s4599 :: SWord8 = s24 | s4598 s4600 :: SWord8 = s26 & s4598 s4601 :: SWord8 = if s4574 then s4599 else s4600 s4602 :: SWord8 = s4601 >>> 1 s4603 :: SWord8 = s24 | s4602 s4604 :: SWord8 = s26 & s4602 s4605 :: SWord8 = if s4596 then s4603 else s4604 s4606 :: SWord1 = choose [0:0] s4589 s4607 :: SBool = s19 /= s4606 s4608 :: SWord8 = s4594 >>> 1 s4609 :: SWord8 = s24 | s4608 s4610 :: SWord8 = s26 & s4608 s4611 :: SWord8 = if s4607 then s4609 else s4610 s4612 :: SWord8 = if s29 then s4571 else s4519 s4613 :: SWord8 = if s170 then s4588 else s4612 s4614 :: SWord8 = if s29 then s4593 else s4613 s4615 :: SWord8 = if s170 then s4611 else s4614 s4616 :: SWord8 = s4601 + s4615 s4617 :: SBool = s4616 < s4615 s4618 :: SBool = s4616 < s4601 s4619 :: SBool = s4617 | s4618 s4620 :: SWord8 = s4616 >>> 1 s4621 :: SWord8 = s24 | s4620 s4622 :: SWord8 = s26 & s4620 s4623 :: SWord8 = if s4619 then s4621 else s4622 s4624 :: SWord8 = if s4597 then s4605 else s4623 s4625 :: SWord8 = s4582 + s4613 s4626 :: SWord1 = choose [0:0] s4625 s4627 :: SBool = s19 /= s4626 s4628 :: SWord8 = if s4627 then s4591 else s4592 s4629 :: SWord8 = if s22 then s4628 else s4588 s4630 :: SWord1 = choose [0:0] s4629 s4631 :: SBool = s19 /= s4630 s4632 :: SBool = s_2 == s4631 s4633 :: SBool = s4625 < s4613 s4634 :: SBool = s4625 < s4582 s4635 :: SBool = s4633 | s4634 s4636 :: SWord8 = s4625 >>> 1 s4637 :: SWord8 = s24 | s4636 s4638 :: SWord8 = s26 & s4636 s4639 :: SWord8 = if s4635 then s4637 else s4638 s4640 :: SWord8 = s4639 >>> 1 s4641 :: SWord8 = s24 | s4640 s4642 :: SWord8 = s26 & s4640 s4643 :: SWord8 = if s4631 then s4641 else s4642 s4644 :: SWord8 = s4629 >>> 1 s4645 :: SWord8 = s24 | s4644 s4646 :: SWord8 = s26 & s4644 s4647 :: SWord8 = if s4607 then s4645 else s4646 s4648 :: SWord8 = if s29 then s4628 else s4613 s4649 :: SWord8 = if s170 then s4647 else s4648 s4650 :: SWord8 = s4639 + s4649 s4651 :: SBool = s4650 < s4649 s4652 :: SBool = s4650 < s4639 s4653 :: SBool = s4651 | s4652 s4654 :: SWord8 = s4650 >>> 1 s4655 :: SWord8 = s24 | s4654 s4656 :: SWord8 = s26 & s4654 s4657 :: SWord8 = if s4653 then s4655 else s4656 s4658 :: SWord8 = if s4632 then s4643 else s4657 s4659 :: SWord8 = if s4575 then s4624 else s4658 s4660 :: SWord8 = if s4460 then s4567 else s4659 s4661 :: SWord8 = if s4229 then s4452 else s4660 s4662 :: SWord8 = if s3763 then s4221 else s4661 s4663 :: SWord8 = s3746 + s3865 s4664 :: SWord1 = choose [0:0] s4663 s4665 :: SBool = s19 /= s4664 s4666 :: SWord8 = if s4665 then s3757 else s3758 s4667 :: SWord8 = if s22 then s4666 else s3754 s4668 :: SWord1 = choose [0:0] s4667 s4669 :: SBool = s19 /= s4668 s4670 :: SBool = s_2 == s4669 s4671 :: SBool = s4663 < s3865 s4672 :: SBool = s4663 < s3746 s4673 :: SBool = s4671 | s4672 s4674 :: SWord8 = s4663 >>> 1 s4675 :: SWord8 = s24 | s4674 s4676 :: SWord8 = s26 & s4674 s4677 :: SWord8 = if s4673 then s4675 else s4676 s4678 :: SWord1 = choose [0:0] s4677 s4679 :: SBool = s19 /= s4678 s4680 :: SWord8 = s4667 >>> 1 s4681 :: SWord8 = s24 | s4680 s4682 :: SWord8 = s26 & s4680 s4683 :: SWord8 = if s3771 then s4681 else s4682 s4684 :: SWord8 = if s22 then s4683 else s4666 s4685 :: SWord8 = s4684 >>> 1 s4686 :: SWord8 = s24 | s4685 s4687 :: SWord8 = s26 & s4685 s4688 :: SWord8 = if s4679 then s4686 else s4687 s4689 :: SWord8 = if s22 then s4688 else s4683 s4690 :: SWord1 = choose [0:0] s4689 s4691 :: SBool = s19 /= s4690 s4692 :: SBool = s_2 == s4691 s4693 :: SWord8 = s4677 >>> 1 s4694 :: SWord8 = s24 | s4693 s4695 :: SWord8 = s26 & s4693 s4696 :: SWord8 = if s4669 then s4694 else s4695 s4697 :: SWord1 = choose [0:0] s4696 s4698 :: SBool = s19 /= s4697 s4699 :: SWord1 = choose [0:0] s4684 s4700 :: SBool = s19 /= s4699 s4701 :: SWord8 = s4689 >>> 1 s4702 :: SWord8 = s24 | s4701 s4703 :: SWord8 = s26 & s4701 s4704 :: SWord8 = if s4700 then s4702 else s4703 s4705 :: SWord8 = if s22 then s4704 else s4688 s4706 :: SWord8 = s4705 >>> 1 s4707 :: SWord8 = s24 | s4706 s4708 :: SWord8 = s26 & s4706 s4709 :: SWord8 = if s4698 then s4707 else s4708 s4710 :: SWord8 = if s22 then s4709 else s4704 s4711 :: SWord1 = choose [0:0] s4710 s4712 :: SBool = s19 /= s4711 s4713 :: SBool = s_2 == s4712 s4714 :: SWord8 = s4696 >>> 1 s4715 :: SWord8 = s24 | s4714 s4716 :: SWord8 = s26 & s4714 s4717 :: SWord8 = if s4691 then s4715 else s4716 s4718 :: SWord1 = choose [0:0] s4717 s4719 :: SBool = s19 /= s4718 s4720 :: SWord1 = choose [0:0] s4705 s4721 :: SBool = s19 /= s4720 s4722 :: SWord8 = s4710 >>> 1 s4723 :: SWord8 = s24 | s4722 s4724 :: SWord8 = s26 & s4722 s4725 :: SWord8 = if s4721 then s4723 else s4724 s4726 :: SWord8 = if s22 then s4725 else s4709 s4727 :: SWord8 = s4726 >>> 1 s4728 :: SWord8 = s24 | s4727 s4729 :: SWord8 = s26 & s4727 s4730 :: SWord8 = if s4719 then s4728 else s4729 s4731 :: SWord8 = if s22 then s4730 else s4725 s4732 :: SWord1 = choose [0:0] s4731 s4733 :: SBool = s19 /= s4732 s4734 :: SBool = s_2 == s4733 s4735 :: SWord8 = s4717 >>> 1 s4736 :: SWord8 = s24 | s4735 s4737 :: SWord8 = s26 & s4735 s4738 :: SWord8 = if s4712 then s4736 else s4737 s4739 :: SWord1 = choose [0:0] s4738 s4740 :: SBool = s19 /= s4739 s4741 :: SWord1 = choose [0:0] s4726 s4742 :: SBool = s19 /= s4741 s4743 :: SWord8 = s4731 >>> 1 s4744 :: SWord8 = s24 | s4743 s4745 :: SWord8 = s26 & s4743 s4746 :: SWord8 = if s4742 then s4744 else s4745 s4747 :: SWord8 = if s22 then s4746 else s4730 s4748 :: SWord8 = s4747 >>> 1 s4749 :: SWord8 = s24 | s4748 s4750 :: SWord8 = s26 & s4748 s4751 :: SWord8 = if s4740 then s4749 else s4750 s4752 :: SWord8 = if s22 then s4751 else s4746 s4753 :: SWord1 = choose [0:0] s4752 s4754 :: SBool = s19 /= s4753 s4755 :: SBool = s_2 == s4754 s4756 :: SWord8 = s4738 >>> 1 s4757 :: SWord8 = s24 | s4756 s4758 :: SWord8 = s26 & s4756 s4759 :: SWord8 = if s4733 then s4757 else s4758 s4760 :: SWord8 = s4759 >>> 1 s4761 :: SWord8 = s24 | s4760 s4762 :: SWord8 = s26 & s4760 s4763 :: SWord8 = if s4754 then s4761 else s4762 s4764 :: SWord1 = choose [0:0] s4747 s4765 :: SBool = s19 /= s4764 s4766 :: SWord8 = s4752 >>> 1 s4767 :: SWord8 = s24 | s4766 s4768 :: SWord8 = s26 & s4766 s4769 :: SWord8 = if s4765 then s4767 else s4768 s4770 :: SWord8 = if s29 then s4666 else s3865 s4771 :: SWord8 = if s170 then s4683 else s4770 s4772 :: SWord8 = if s29 then s4688 else s4771 s4773 :: SWord8 = if s170 then s4704 else s4772 s4774 :: SWord8 = if s29 then s4709 else s4773 s4775 :: SWord8 = if s170 then s4725 else s4774 s4776 :: SWord8 = if s29 then s4730 else s4775 s4777 :: SWord8 = if s170 then s4746 else s4776 s4778 :: SWord8 = if s29 then s4751 else s4777 s4779 :: SWord8 = if s170 then s4769 else s4778 s4780 :: SWord8 = s4759 + s4779 s4781 :: SBool = s4780 < s4779 s4782 :: SBool = s4780 < s4759 s4783 :: SBool = s4781 | s4782 s4784 :: SWord8 = s4780 >>> 1 s4785 :: SWord8 = s24 | s4784 s4786 :: SWord8 = s26 & s4784 s4787 :: SWord8 = if s4783 then s4785 else s4786 s4788 :: SWord8 = if s4755 then s4763 else s4787 s4789 :: SWord8 = s4738 + s4777 s4790 :: SWord1 = choose [0:0] s4789 s4791 :: SBool = s19 /= s4790 s4792 :: SWord8 = if s4791 then s4749 else s4750 s4793 :: SWord8 = if s22 then s4792 else s4746 s4794 :: SWord1 = choose [0:0] s4793 s4795 :: SBool = s19 /= s4794 s4796 :: SBool = s_2 == s4795 s4797 :: SBool = s4789 < s4777 s4798 :: SBool = s4789 < s4738 s4799 :: SBool = s4797 | s4798 s4800 :: SWord8 = s4789 >>> 1 s4801 :: SWord8 = s24 | s4800 s4802 :: SWord8 = s26 & s4800 s4803 :: SWord8 = if s4799 then s4801 else s4802 s4804 :: SWord8 = s4803 >>> 1 s4805 :: SWord8 = s24 | s4804 s4806 :: SWord8 = s26 & s4804 s4807 :: SWord8 = if s4795 then s4805 else s4806 s4808 :: SWord8 = s4793 >>> 1 s4809 :: SWord8 = s24 | s4808 s4810 :: SWord8 = s26 & s4808 s4811 :: SWord8 = if s4765 then s4809 else s4810 s4812 :: SWord8 = if s29 then s4792 else s4777 s4813 :: SWord8 = if s170 then s4811 else s4812 s4814 :: SWord8 = s4803 + s4813 s4815 :: SBool = s4814 < s4813 s4816 :: SBool = s4814 < s4803 s4817 :: SBool = s4815 | s4816 s4818 :: SWord8 = s4814 >>> 1 s4819 :: SWord8 = s24 | s4818 s4820 :: SWord8 = s26 & s4818 s4821 :: SWord8 = if s4817 then s4819 else s4820 s4822 :: SWord8 = if s4796 then s4807 else s4821 s4823 :: SWord8 = if s4734 then s4788 else s4822 s4824 :: SWord8 = s4717 + s4775 s4825 :: SWord1 = choose [0:0] s4824 s4826 :: SBool = s19 /= s4825 s4827 :: SWord8 = if s4826 then s4728 else s4729 s4828 :: SWord8 = if s22 then s4827 else s4725 s4829 :: SWord1 = choose [0:0] s4828 s4830 :: SBool = s19 /= s4829 s4831 :: SBool = s_2 == s4830 s4832 :: SBool = s4824 < s4775 s4833 :: SBool = s4824 < s4717 s4834 :: SBool = s4832 | s4833 s4835 :: SWord8 = s4824 >>> 1 s4836 :: SWord8 = s24 | s4835 s4837 :: SWord8 = s26 & s4835 s4838 :: SWord8 = if s4834 then s4836 else s4837 s4839 :: SWord1 = choose [0:0] s4838 s4840 :: SBool = s19 /= s4839 s4841 :: SWord8 = s4828 >>> 1 s4842 :: SWord8 = s24 | s4841 s4843 :: SWord8 = s26 & s4841 s4844 :: SWord8 = if s4742 then s4842 else s4843 s4845 :: SWord8 = if s22 then s4844 else s4827 s4846 :: SWord8 = s4845 >>> 1 s4847 :: SWord8 = s24 | s4846 s4848 :: SWord8 = s26 & s4846 s4849 :: SWord8 = if s4840 then s4847 else s4848 s4850 :: SWord8 = if s22 then s4849 else s4844 s4851 :: SWord1 = choose [0:0] s4850 s4852 :: SBool = s19 /= s4851 s4853 :: SBool = s_2 == s4852 s4854 :: SWord8 = s4838 >>> 1 s4855 :: SWord8 = s24 | s4854 s4856 :: SWord8 = s26 & s4854 s4857 :: SWord8 = if s4830 then s4855 else s4856 s4858 :: SWord8 = s4857 >>> 1 s4859 :: SWord8 = s24 | s4858 s4860 :: SWord8 = s26 & s4858 s4861 :: SWord8 = if s4852 then s4859 else s4860 s4862 :: SWord1 = choose [0:0] s4845 s4863 :: SBool = s19 /= s4862 s4864 :: SWord8 = s4850 >>> 1 s4865 :: SWord8 = s24 | s4864 s4866 :: SWord8 = s26 & s4864 s4867 :: SWord8 = if s4863 then s4865 else s4866 s4868 :: SWord8 = if s29 then s4827 else s4775 s4869 :: SWord8 = if s170 then s4844 else s4868 s4870 :: SWord8 = if s29 then s4849 else s4869 s4871 :: SWord8 = if s170 then s4867 else s4870 s4872 :: SWord8 = s4857 + s4871 s4873 :: SBool = s4872 < s4871 s4874 :: SBool = s4872 < s4857 s4875 :: SBool = s4873 | s4874 s4876 :: SWord8 = s4872 >>> 1 s4877 :: SWord8 = s24 | s4876 s4878 :: SWord8 = s26 & s4876 s4879 :: SWord8 = if s4875 then s4877 else s4878 s4880 :: SWord8 = if s4853 then s4861 else s4879 s4881 :: SWord8 = s4838 + s4869 s4882 :: SWord1 = choose [0:0] s4881 s4883 :: SBool = s19 /= s4882 s4884 :: SWord8 = if s4883 then s4847 else s4848 s4885 :: SWord8 = if s22 then s4884 else s4844 s4886 :: SWord1 = choose [0:0] s4885 s4887 :: SBool = s19 /= s4886 s4888 :: SBool = s_2 == s4887 s4889 :: SBool = s4881 < s4869 s4890 :: SBool = s4881 < s4838 s4891 :: SBool = s4889 | s4890 s4892 :: SWord8 = s4881 >>> 1 s4893 :: SWord8 = s24 | s4892 s4894 :: SWord8 = s26 & s4892 s4895 :: SWord8 = if s4891 then s4893 else s4894 s4896 :: SWord8 = s4895 >>> 1 s4897 :: SWord8 = s24 | s4896 s4898 :: SWord8 = s26 & s4896 s4899 :: SWord8 = if s4887 then s4897 else s4898 s4900 :: SWord8 = s4885 >>> 1 s4901 :: SWord8 = s24 | s4900 s4902 :: SWord8 = s26 & s4900 s4903 :: SWord8 = if s4863 then s4901 else s4902 s4904 :: SWord8 = if s29 then s4884 else s4869 s4905 :: SWord8 = if s170 then s4903 else s4904 s4906 :: SWord8 = s4895 + s4905 s4907 :: SBool = s4906 < s4905 s4908 :: SBool = s4906 < s4895 s4909 :: SBool = s4907 | s4908 s4910 :: SWord8 = s4906 >>> 1 s4911 :: SWord8 = s24 | s4910 s4912 :: SWord8 = s26 & s4910 s4913 :: SWord8 = if s4909 then s4911 else s4912 s4914 :: SWord8 = if s4888 then s4899 else s4913 s4915 :: SWord8 = if s4831 then s4880 else s4914 s4916 :: SWord8 = if s4713 then s4823 else s4915 s4917 :: SWord8 = s4696 + s4773 s4918 :: SWord1 = choose [0:0] s4917 s4919 :: SBool = s19 /= s4918 s4920 :: SWord8 = if s4919 then s4707 else s4708 s4921 :: SWord8 = if s22 then s4920 else s4704 s4922 :: SWord1 = choose [0:0] s4921 s4923 :: SBool = s19 /= s4922 s4924 :: SBool = s_2 == s4923 s4925 :: SBool = s4917 < s4773 s4926 :: SBool = s4917 < s4696 s4927 :: SBool = s4925 | s4926 s4928 :: SWord8 = s4917 >>> 1 s4929 :: SWord8 = s24 | s4928 s4930 :: SWord8 = s26 & s4928 s4931 :: SWord8 = if s4927 then s4929 else s4930 s4932 :: SWord1 = choose [0:0] s4931 s4933 :: SBool = s19 /= s4932 s4934 :: SWord8 = s4921 >>> 1 s4935 :: SWord8 = s24 | s4934 s4936 :: SWord8 = s26 & s4934 s4937 :: SWord8 = if s4721 then s4935 else s4936 s4938 :: SWord8 = if s22 then s4937 else s4920 s4939 :: SWord8 = s4938 >>> 1 s4940 :: SWord8 = s24 | s4939 s4941 :: SWord8 = s26 & s4939 s4942 :: SWord8 = if s4933 then s4940 else s4941 s4943 :: SWord8 = if s22 then s4942 else s4937 s4944 :: SWord1 = choose [0:0] s4943 s4945 :: SBool = s19 /= s4944 s4946 :: SBool = s_2 == s4945 s4947 :: SWord8 = s4931 >>> 1 s4948 :: SWord8 = s24 | s4947 s4949 :: SWord8 = s26 & s4947 s4950 :: SWord8 = if s4923 then s4948 else s4949 s4951 :: SWord1 = choose [0:0] s4950 s4952 :: SBool = s19 /= s4951 s4953 :: SWord1 = choose [0:0] s4938 s4954 :: SBool = s19 /= s4953 s4955 :: SWord8 = s4943 >>> 1 s4956 :: SWord8 = s24 | s4955 s4957 :: SWord8 = s26 & s4955 s4958 :: SWord8 = if s4954 then s4956 else s4957 s4959 :: SWord8 = if s22 then s4958 else s4942 s4960 :: SWord8 = s4959 >>> 1 s4961 :: SWord8 = s24 | s4960 s4962 :: SWord8 = s26 & s4960 s4963 :: SWord8 = if s4952 then s4961 else s4962 s4964 :: SWord8 = if s22 then s4963 else s4958 s4965 :: SWord1 = choose [0:0] s4964 s4966 :: SBool = s19 /= s4965 s4967 :: SBool = s_2 == s4966 s4968 :: SWord8 = s4950 >>> 1 s4969 :: SWord8 = s24 | s4968 s4970 :: SWord8 = s26 & s4968 s4971 :: SWord8 = if s4945 then s4969 else s4970 s4972 :: SWord8 = s4971 >>> 1 s4973 :: SWord8 = s24 | s4972 s4974 :: SWord8 = s26 & s4972 s4975 :: SWord8 = if s4966 then s4973 else s4974 s4976 :: SWord1 = choose [0:0] s4959 s4977 :: SBool = s19 /= s4976 s4978 :: SWord8 = s4964 >>> 1 s4979 :: SWord8 = s24 | s4978 s4980 :: SWord8 = s26 & s4978 s4981 :: SWord8 = if s4977 then s4979 else s4980 s4982 :: SWord8 = if s29 then s4920 else s4773 s4983 :: SWord8 = if s170 then s4937 else s4982 s4984 :: SWord8 = if s29 then s4942 else s4983 s4985 :: SWord8 = if s170 then s4958 else s4984 s4986 :: SWord8 = if s29 then s4963 else s4985 s4987 :: SWord8 = if s170 then s4981 else s4986 s4988 :: SWord8 = s4971 + s4987 s4989 :: SBool = s4988 < s4987 s4990 :: SBool = s4988 < s4971 s4991 :: SBool = s4989 | s4990 s4992 :: SWord8 = s4988 >>> 1 s4993 :: SWord8 = s24 | s4992 s4994 :: SWord8 = s26 & s4992 s4995 :: SWord8 = if s4991 then s4993 else s4994 s4996 :: SWord8 = if s4967 then s4975 else s4995 s4997 :: SWord8 = s4950 + s4985 s4998 :: SWord1 = choose [0:0] s4997 s4999 :: SBool = s19 /= s4998 s5000 :: SWord8 = if s4999 then s4961 else s4962 s5001 :: SWord8 = if s22 then s5000 else s4958 s5002 :: SWord1 = choose [0:0] s5001 s5003 :: SBool = s19 /= s5002 s5004 :: SBool = s_2 == s5003 s5005 :: SBool = s4997 < s4985 s5006 :: SBool = s4997 < s4950 s5007 :: SBool = s5005 | s5006 s5008 :: SWord8 = s4997 >>> 1 s5009 :: SWord8 = s24 | s5008 s5010 :: SWord8 = s26 & s5008 s5011 :: SWord8 = if s5007 then s5009 else s5010 s5012 :: SWord8 = s5011 >>> 1 s5013 :: SWord8 = s24 | s5012 s5014 :: SWord8 = s26 & s5012 s5015 :: SWord8 = if s5003 then s5013 else s5014 s5016 :: SWord8 = s5001 >>> 1 s5017 :: SWord8 = s24 | s5016 s5018 :: SWord8 = s26 & s5016 s5019 :: SWord8 = if s4977 then s5017 else s5018 s5020 :: SWord8 = if s29 then s5000 else s4985 s5021 :: SWord8 = if s170 then s5019 else s5020 s5022 :: SWord8 = s5011 + s5021 s5023 :: SBool = s5022 < s5021 s5024 :: SBool = s5022 < s5011 s5025 :: SBool = s5023 | s5024 s5026 :: SWord8 = s5022 >>> 1 s5027 :: SWord8 = s24 | s5026 s5028 :: SWord8 = s26 & s5026 s5029 :: SWord8 = if s5025 then s5027 else s5028 s5030 :: SWord8 = if s5004 then s5015 else s5029 s5031 :: SWord8 = if s4946 then s4996 else s5030 s5032 :: SWord8 = s4931 + s4983 s5033 :: SWord1 = choose [0:0] s5032 s5034 :: SBool = s19 /= s5033 s5035 :: SWord8 = if s5034 then s4940 else s4941 s5036 :: SWord8 = if s22 then s5035 else s4937 s5037 :: SWord1 = choose [0:0] s5036 s5038 :: SBool = s19 /= s5037 s5039 :: SBool = s_2 == s5038 s5040 :: SBool = s5032 < s4983 s5041 :: SBool = s5032 < s4931 s5042 :: SBool = s5040 | s5041 s5043 :: SWord8 = s5032 >>> 1 s5044 :: SWord8 = s24 | s5043 s5045 :: SWord8 = s26 & s5043 s5046 :: SWord8 = if s5042 then s5044 else s5045 s5047 :: SWord1 = choose [0:0] s5046 s5048 :: SBool = s19 /= s5047 s5049 :: SWord8 = s5036 >>> 1 s5050 :: SWord8 = s24 | s5049 s5051 :: SWord8 = s26 & s5049 s5052 :: SWord8 = if s4954 then s5050 else s5051 s5053 :: SWord8 = if s22 then s5052 else s5035 s5054 :: SWord8 = s5053 >>> 1 s5055 :: SWord8 = s24 | s5054 s5056 :: SWord8 = s26 & s5054 s5057 :: SWord8 = if s5048 then s5055 else s5056 s5058 :: SWord8 = if s22 then s5057 else s5052 s5059 :: SWord1 = choose [0:0] s5058 s5060 :: SBool = s19 /= s5059 s5061 :: SBool = s_2 == s5060 s5062 :: SWord8 = s5046 >>> 1 s5063 :: SWord8 = s24 | s5062 s5064 :: SWord8 = s26 & s5062 s5065 :: SWord8 = if s5038 then s5063 else s5064 s5066 :: SWord8 = s5065 >>> 1 s5067 :: SWord8 = s24 | s5066 s5068 :: SWord8 = s26 & s5066 s5069 :: SWord8 = if s5060 then s5067 else s5068 s5070 :: SWord1 = choose [0:0] s5053 s5071 :: SBool = s19 /= s5070 s5072 :: SWord8 = s5058 >>> 1 s5073 :: SWord8 = s24 | s5072 s5074 :: SWord8 = s26 & s5072 s5075 :: SWord8 = if s5071 then s5073 else s5074 s5076 :: SWord8 = if s29 then s5035 else s4983 s5077 :: SWord8 = if s170 then s5052 else s5076 s5078 :: SWord8 = if s29 then s5057 else s5077 s5079 :: SWord8 = if s170 then s5075 else s5078 s5080 :: SWord8 = s5065 + s5079 s5081 :: SBool = s5080 < s5079 s5082 :: SBool = s5080 < s5065 s5083 :: SBool = s5081 | s5082 s5084 :: SWord8 = s5080 >>> 1 s5085 :: SWord8 = s24 | s5084 s5086 :: SWord8 = s26 & s5084 s5087 :: SWord8 = if s5083 then s5085 else s5086 s5088 :: SWord8 = if s5061 then s5069 else s5087 s5089 :: SWord8 = s5046 + s5077 s5090 :: SWord1 = choose [0:0] s5089 s5091 :: SBool = s19 /= s5090 s5092 :: SWord8 = if s5091 then s5055 else s5056 s5093 :: SWord8 = if s22 then s5092 else s5052 s5094 :: SWord1 = choose [0:0] s5093 s5095 :: SBool = s19 /= s5094 s5096 :: SBool = s_2 == s5095 s5097 :: SBool = s5089 < s5077 s5098 :: SBool = s5089 < s5046 s5099 :: SBool = s5097 | s5098 s5100 :: SWord8 = s5089 >>> 1 s5101 :: SWord8 = s24 | s5100 s5102 :: SWord8 = s26 & s5100 s5103 :: SWord8 = if s5099 then s5101 else s5102 s5104 :: SWord8 = s5103 >>> 1 s5105 :: SWord8 = s24 | s5104 s5106 :: SWord8 = s26 & s5104 s5107 :: SWord8 = if s5095 then s5105 else s5106 s5108 :: SWord8 = s5093 >>> 1 s5109 :: SWord8 = s24 | s5108 s5110 :: SWord8 = s26 & s5108 s5111 :: SWord8 = if s5071 then s5109 else s5110 s5112 :: SWord8 = if s29 then s5092 else s5077 s5113 :: SWord8 = if s170 then s5111 else s5112 s5114 :: SWord8 = s5103 + s5113 s5115 :: SBool = s5114 < s5113 s5116 :: SBool = s5114 < s5103 s5117 :: SBool = s5115 | s5116 s5118 :: SWord8 = s5114 >>> 1 s5119 :: SWord8 = s24 | s5118 s5120 :: SWord8 = s26 & s5118 s5121 :: SWord8 = if s5117 then s5119 else s5120 s5122 :: SWord8 = if s5096 then s5107 else s5121 s5123 :: SWord8 = if s5039 then s5088 else s5122 s5124 :: SWord8 = if s4924 then s5031 else s5123 s5125 :: SWord8 = if s4692 then s4916 else s5124 s5126 :: SWord8 = s4677 + s4771 s5127 :: SWord1 = choose [0:0] s5126 s5128 :: SBool = s19 /= s5127 s5129 :: SWord8 = if s5128 then s4686 else s4687 s5130 :: SWord8 = if s22 then s5129 else s4683 s5131 :: SWord1 = choose [0:0] s5130 s5132 :: SBool = s19 /= s5131 s5133 :: SBool = s_2 == s5132 s5134 :: SBool = s5126 < s4771 s5135 :: SBool = s5126 < s4677 s5136 :: SBool = s5134 | s5135 s5137 :: SWord8 = s5126 >>> 1 s5138 :: SWord8 = s24 | s5137 s5139 :: SWord8 = s26 & s5137 s5140 :: SWord8 = if s5136 then s5138 else s5139 s5141 :: SWord1 = choose [0:0] s5140 s5142 :: SBool = s19 /= s5141 s5143 :: SWord8 = s5130 >>> 1 s5144 :: SWord8 = s24 | s5143 s5145 :: SWord8 = s26 & s5143 s5146 :: SWord8 = if s4700 then s5144 else s5145 s5147 :: SWord8 = if s22 then s5146 else s5129 s5148 :: SWord8 = s5147 >>> 1 s5149 :: SWord8 = s24 | s5148 s5150 :: SWord8 = s26 & s5148 s5151 :: SWord8 = if s5142 then s5149 else s5150 s5152 :: SWord8 = if s22 then s5151 else s5146 s5153 :: SWord1 = choose [0:0] s5152 s5154 :: SBool = s19 /= s5153 s5155 :: SBool = s_2 == s5154 s5156 :: SWord8 = s5140 >>> 1 s5157 :: SWord8 = s24 | s5156 s5158 :: SWord8 = s26 & s5156 s5159 :: SWord8 = if s5132 then s5157 else s5158 s5160 :: SWord1 = choose [0:0] s5159 s5161 :: SBool = s19 /= s5160 s5162 :: SWord1 = choose [0:0] s5147 s5163 :: SBool = s19 /= s5162 s5164 :: SWord8 = s5152 >>> 1 s5165 :: SWord8 = s24 | s5164 s5166 :: SWord8 = s26 & s5164 s5167 :: SWord8 = if s5163 then s5165 else s5166 s5168 :: SWord8 = if s22 then s5167 else s5151 s5169 :: SWord8 = s5168 >>> 1 s5170 :: SWord8 = s24 | s5169 s5171 :: SWord8 = s26 & s5169 s5172 :: SWord8 = if s5161 then s5170 else s5171 s5173 :: SWord8 = if s22 then s5172 else s5167 s5174 :: SWord1 = choose [0:0] s5173 s5175 :: SBool = s19 /= s5174 s5176 :: SBool = s_2 == s5175 s5177 :: SWord8 = s5159 >>> 1 s5178 :: SWord8 = s24 | s5177 s5179 :: SWord8 = s26 & s5177 s5180 :: SWord8 = if s5154 then s5178 else s5179 s5181 :: SWord1 = choose [0:0] s5180 s5182 :: SBool = s19 /= s5181 s5183 :: SWord1 = choose [0:0] s5168 s5184 :: SBool = s19 /= s5183 s5185 :: SWord8 = s5173 >>> 1 s5186 :: SWord8 = s24 | s5185 s5187 :: SWord8 = s26 & s5185 s5188 :: SWord8 = if s5184 then s5186 else s5187 s5189 :: SWord8 = if s22 then s5188 else s5172 s5190 :: SWord8 = s5189 >>> 1 s5191 :: SWord8 = s24 | s5190 s5192 :: SWord8 = s26 & s5190 s5193 :: SWord8 = if s5182 then s5191 else s5192 s5194 :: SWord8 = if s22 then s5193 else s5188 s5195 :: SWord1 = choose [0:0] s5194 s5196 :: SBool = s19 /= s5195 s5197 :: SBool = s_2 == s5196 s5198 :: SWord8 = s5180 >>> 1 s5199 :: SWord8 = s24 | s5198 s5200 :: SWord8 = s26 & s5198 s5201 :: SWord8 = if s5175 then s5199 else s5200 s5202 :: SWord8 = s5201 >>> 1 s5203 :: SWord8 = s24 | s5202 s5204 :: SWord8 = s26 & s5202 s5205 :: SWord8 = if s5196 then s5203 else s5204 s5206 :: SWord1 = choose [0:0] s5189 s5207 :: SBool = s19 /= s5206 s5208 :: SWord8 = s5194 >>> 1 s5209 :: SWord8 = s24 | s5208 s5210 :: SWord8 = s26 & s5208 s5211 :: SWord8 = if s5207 then s5209 else s5210 s5212 :: SWord8 = if s29 then s5129 else s4771 s5213 :: SWord8 = if s170 then s5146 else s5212 s5214 :: SWord8 = if s29 then s5151 else s5213 s5215 :: SWord8 = if s170 then s5167 else s5214 s5216 :: SWord8 = if s29 then s5172 else s5215 s5217 :: SWord8 = if s170 then s5188 else s5216 s5218 :: SWord8 = if s29 then s5193 else s5217 s5219 :: SWord8 = if s170 then s5211 else s5218 s5220 :: SWord8 = s5201 + s5219 s5221 :: SBool = s5220 < s5219 s5222 :: SBool = s5220 < s5201 s5223 :: SBool = s5221 | s5222 s5224 :: SWord8 = s5220 >>> 1 s5225 :: SWord8 = s24 | s5224 s5226 :: SWord8 = s26 & s5224 s5227 :: SWord8 = if s5223 then s5225 else s5226 s5228 :: SWord8 = if s5197 then s5205 else s5227 s5229 :: SWord8 = s5180 + s5217 s5230 :: SWord1 = choose [0:0] s5229 s5231 :: SBool = s19 /= s5230 s5232 :: SWord8 = if s5231 then s5191 else s5192 s5233 :: SWord8 = if s22 then s5232 else s5188 s5234 :: SWord1 = choose [0:0] s5233 s5235 :: SBool = s19 /= s5234 s5236 :: SBool = s_2 == s5235 s5237 :: SBool = s5229 < s5217 s5238 :: SBool = s5229 < s5180 s5239 :: SBool = s5237 | s5238 s5240 :: SWord8 = s5229 >>> 1 s5241 :: SWord8 = s24 | s5240 s5242 :: SWord8 = s26 & s5240 s5243 :: SWord8 = if s5239 then s5241 else s5242 s5244 :: SWord8 = s5243 >>> 1 s5245 :: SWord8 = s24 | s5244 s5246 :: SWord8 = s26 & s5244 s5247 :: SWord8 = if s5235 then s5245 else s5246 s5248 :: SWord8 = s5233 >>> 1 s5249 :: SWord8 = s24 | s5248 s5250 :: SWord8 = s26 & s5248 s5251 :: SWord8 = if s5207 then s5249 else s5250 s5252 :: SWord8 = if s29 then s5232 else s5217 s5253 :: SWord8 = if s170 then s5251 else s5252 s5254 :: SWord8 = s5243 + s5253 s5255 :: SBool = s5254 < s5253 s5256 :: SBool = s5254 < s5243 s5257 :: SBool = s5255 | s5256 s5258 :: SWord8 = s5254 >>> 1 s5259 :: SWord8 = s24 | s5258 s5260 :: SWord8 = s26 & s5258 s5261 :: SWord8 = if s5257 then s5259 else s5260 s5262 :: SWord8 = if s5236 then s5247 else s5261 s5263 :: SWord8 = if s5176 then s5228 else s5262 s5264 :: SWord8 = s5159 + s5215 s5265 :: SWord1 = choose [0:0] s5264 s5266 :: SBool = s19 /= s5265 s5267 :: SWord8 = if s5266 then s5170 else s5171 s5268 :: SWord8 = if s22 then s5267 else s5167 s5269 :: SWord1 = choose [0:0] s5268 s5270 :: SBool = s19 /= s5269 s5271 :: SBool = s_2 == s5270 s5272 :: SBool = s5264 < s5215 s5273 :: SBool = s5264 < s5159 s5274 :: SBool = s5272 | s5273 s5275 :: SWord8 = s5264 >>> 1 s5276 :: SWord8 = s24 | s5275 s5277 :: SWord8 = s26 & s5275 s5278 :: SWord8 = if s5274 then s5276 else s5277 s5279 :: SWord1 = choose [0:0] s5278 s5280 :: SBool = s19 /= s5279 s5281 :: SWord8 = s5268 >>> 1 s5282 :: SWord8 = s24 | s5281 s5283 :: SWord8 = s26 & s5281 s5284 :: SWord8 = if s5184 then s5282 else s5283 s5285 :: SWord8 = if s22 then s5284 else s5267 s5286 :: SWord8 = s5285 >>> 1 s5287 :: SWord8 = s24 | s5286 s5288 :: SWord8 = s26 & s5286 s5289 :: SWord8 = if s5280 then s5287 else s5288 s5290 :: SWord8 = if s22 then s5289 else s5284 s5291 :: SWord1 = choose [0:0] s5290 s5292 :: SBool = s19 /= s5291 s5293 :: SBool = s_2 == s5292 s5294 :: SWord8 = s5278 >>> 1 s5295 :: SWord8 = s24 | s5294 s5296 :: SWord8 = s26 & s5294 s5297 :: SWord8 = if s5270 then s5295 else s5296 s5298 :: SWord8 = s5297 >>> 1 s5299 :: SWord8 = s24 | s5298 s5300 :: SWord8 = s26 & s5298 s5301 :: SWord8 = if s5292 then s5299 else s5300 s5302 :: SWord1 = choose [0:0] s5285 s5303 :: SBool = s19 /= s5302 s5304 :: SWord8 = s5290 >>> 1 s5305 :: SWord8 = s24 | s5304 s5306 :: SWord8 = s26 & s5304 s5307 :: SWord8 = if s5303 then s5305 else s5306 s5308 :: SWord8 = if s29 then s5267 else s5215 s5309 :: SWord8 = if s170 then s5284 else s5308 s5310 :: SWord8 = if s29 then s5289 else s5309 s5311 :: SWord8 = if s170 then s5307 else s5310 s5312 :: SWord8 = s5297 + s5311 s5313 :: SBool = s5312 < s5311 s5314 :: SBool = s5312 < s5297 s5315 :: SBool = s5313 | s5314 s5316 :: SWord8 = s5312 >>> 1 s5317 :: SWord8 = s24 | s5316 s5318 :: SWord8 = s26 & s5316 s5319 :: SWord8 = if s5315 then s5317 else s5318 s5320 :: SWord8 = if s5293 then s5301 else s5319 s5321 :: SWord8 = s5278 + s5309 s5322 :: SWord1 = choose [0:0] s5321 s5323 :: SBool = s19 /= s5322 s5324 :: SWord8 = if s5323 then s5287 else s5288 s5325 :: SWord8 = if s22 then s5324 else s5284 s5326 :: SWord1 = choose [0:0] s5325 s5327 :: SBool = s19 /= s5326 s5328 :: SBool = s_2 == s5327 s5329 :: SBool = s5321 < s5309 s5330 :: SBool = s5321 < s5278 s5331 :: SBool = s5329 | s5330 s5332 :: SWord8 = s5321 >>> 1 s5333 :: SWord8 = s24 | s5332 s5334 :: SWord8 = s26 & s5332 s5335 :: SWord8 = if s5331 then s5333 else s5334 s5336 :: SWord8 = s5335 >>> 1 s5337 :: SWord8 = s24 | s5336 s5338 :: SWord8 = s26 & s5336 s5339 :: SWord8 = if s5327 then s5337 else s5338 s5340 :: SWord8 = s5325 >>> 1 s5341 :: SWord8 = s24 | s5340 s5342 :: SWord8 = s26 & s5340 s5343 :: SWord8 = if s5303 then s5341 else s5342 s5344 :: SWord8 = if s29 then s5324 else s5309 s5345 :: SWord8 = if s170 then s5343 else s5344 s5346 :: SWord8 = s5335 + s5345 s5347 :: SBool = s5346 < s5345 s5348 :: SBool = s5346 < s5335 s5349 :: SBool = s5347 | s5348 s5350 :: SWord8 = s5346 >>> 1 s5351 :: SWord8 = s24 | s5350 s5352 :: SWord8 = s26 & s5350 s5353 :: SWord8 = if s5349 then s5351 else s5352 s5354 :: SWord8 = if s5328 then s5339 else s5353 s5355 :: SWord8 = if s5271 then s5320 else s5354 s5356 :: SWord8 = if s5155 then s5263 else s5355 s5357 :: SWord8 = s5140 + s5213 s5358 :: SWord1 = choose [0:0] s5357 s5359 :: SBool = s19 /= s5358 s5360 :: SWord8 = if s5359 then s5149 else s5150 s5361 :: SWord8 = if s22 then s5360 else s5146 s5362 :: SWord1 = choose [0:0] s5361 s5363 :: SBool = s19 /= s5362 s5364 :: SBool = s_2 == s5363 s5365 :: SBool = s5357 < s5213 s5366 :: SBool = s5357 < s5140 s5367 :: SBool = s5365 | s5366 s5368 :: SWord8 = s5357 >>> 1 s5369 :: SWord8 = s24 | s5368 s5370 :: SWord8 = s26 & s5368 s5371 :: SWord8 = if s5367 then s5369 else s5370 s5372 :: SWord1 = choose [0:0] s5371 s5373 :: SBool = s19 /= s5372 s5374 :: SWord8 = s5361 >>> 1 s5375 :: SWord8 = s24 | s5374 s5376 :: SWord8 = s26 & s5374 s5377 :: SWord8 = if s5163 then s5375 else s5376 s5378 :: SWord8 = if s22 then s5377 else s5360 s5379 :: SWord8 = s5378 >>> 1 s5380 :: SWord8 = s24 | s5379 s5381 :: SWord8 = s26 & s5379 s5382 :: SWord8 = if s5373 then s5380 else s5381 s5383 :: SWord8 = if s22 then s5382 else s5377 s5384 :: SWord1 = choose [0:0] s5383 s5385 :: SBool = s19 /= s5384 s5386 :: SBool = s_2 == s5385 s5387 :: SWord8 = s5371 >>> 1 s5388 :: SWord8 = s24 | s5387 s5389 :: SWord8 = s26 & s5387 s5390 :: SWord8 = if s5363 then s5388 else s5389 s5391 :: SWord1 = choose [0:0] s5390 s5392 :: SBool = s19 /= s5391 s5393 :: SWord1 = choose [0:0] s5378 s5394 :: SBool = s19 /= s5393 s5395 :: SWord8 = s5383 >>> 1 s5396 :: SWord8 = s24 | s5395 s5397 :: SWord8 = s26 & s5395 s5398 :: SWord8 = if s5394 then s5396 else s5397 s5399 :: SWord8 = if s22 then s5398 else s5382 s5400 :: SWord8 = s5399 >>> 1 s5401 :: SWord8 = s24 | s5400 s5402 :: SWord8 = s26 & s5400 s5403 :: SWord8 = if s5392 then s5401 else s5402 s5404 :: SWord8 = if s22 then s5403 else s5398 s5405 :: SWord1 = choose [0:0] s5404 s5406 :: SBool = s19 /= s5405 s5407 :: SBool = s_2 == s5406 s5408 :: SWord8 = s5390 >>> 1 s5409 :: SWord8 = s24 | s5408 s5410 :: SWord8 = s26 & s5408 s5411 :: SWord8 = if s5385 then s5409 else s5410 s5412 :: SWord8 = s5411 >>> 1 s5413 :: SWord8 = s24 | s5412 s5414 :: SWord8 = s26 & s5412 s5415 :: SWord8 = if s5406 then s5413 else s5414 s5416 :: SWord1 = choose [0:0] s5399 s5417 :: SBool = s19 /= s5416 s5418 :: SWord8 = s5404 >>> 1 s5419 :: SWord8 = s24 | s5418 s5420 :: SWord8 = s26 & s5418 s5421 :: SWord8 = if s5417 then s5419 else s5420 s5422 :: SWord8 = if s29 then s5360 else s5213 s5423 :: SWord8 = if s170 then s5377 else s5422 s5424 :: SWord8 = if s29 then s5382 else s5423 s5425 :: SWord8 = if s170 then s5398 else s5424 s5426 :: SWord8 = if s29 then s5403 else s5425 s5427 :: SWord8 = if s170 then s5421 else s5426 s5428 :: SWord8 = s5411 + s5427 s5429 :: SBool = s5428 < s5427 s5430 :: SBool = s5428 < s5411 s5431 :: SBool = s5429 | s5430 s5432 :: SWord8 = s5428 >>> 1 s5433 :: SWord8 = s24 | s5432 s5434 :: SWord8 = s26 & s5432 s5435 :: SWord8 = if s5431 then s5433 else s5434 s5436 :: SWord8 = if s5407 then s5415 else s5435 s5437 :: SWord8 = s5390 + s5425 s5438 :: SWord1 = choose [0:0] s5437 s5439 :: SBool = s19 /= s5438 s5440 :: SWord8 = if s5439 then s5401 else s5402 s5441 :: SWord8 = if s22 then s5440 else s5398 s5442 :: SWord1 = choose [0:0] s5441 s5443 :: SBool = s19 /= s5442 s5444 :: SBool = s_2 == s5443 s5445 :: SBool = s5437 < s5425 s5446 :: SBool = s5437 < s5390 s5447 :: SBool = s5445 | s5446 s5448 :: SWord8 = s5437 >>> 1 s5449 :: SWord8 = s24 | s5448 s5450 :: SWord8 = s26 & s5448 s5451 :: SWord8 = if s5447 then s5449 else s5450 s5452 :: SWord8 = s5451 >>> 1 s5453 :: SWord8 = s24 | s5452 s5454 :: SWord8 = s26 & s5452 s5455 :: SWord8 = if s5443 then s5453 else s5454 s5456 :: SWord8 = s5441 >>> 1 s5457 :: SWord8 = s24 | s5456 s5458 :: SWord8 = s26 & s5456 s5459 :: SWord8 = if s5417 then s5457 else s5458 s5460 :: SWord8 = if s29 then s5440 else s5425 s5461 :: SWord8 = if s170 then s5459 else s5460 s5462 :: SWord8 = s5451 + s5461 s5463 :: SBool = s5462 < s5461 s5464 :: SBool = s5462 < s5451 s5465 :: SBool = s5463 | s5464 s5466 :: SWord8 = s5462 >>> 1 s5467 :: SWord8 = s24 | s5466 s5468 :: SWord8 = s26 & s5466 s5469 :: SWord8 = if s5465 then s5467 else s5468 s5470 :: SWord8 = if s5444 then s5455 else s5469 s5471 :: SWord8 = if s5386 then s5436 else s5470 s5472 :: SWord8 = s5371 + s5423 s5473 :: SWord1 = choose [0:0] s5472 s5474 :: SBool = s19 /= s5473 s5475 :: SWord8 = if s5474 then s5380 else s5381 s5476 :: SWord8 = if s22 then s5475 else s5377 s5477 :: SWord1 = choose [0:0] s5476 s5478 :: SBool = s19 /= s5477 s5479 :: SBool = s_2 == s5478 s5480 :: SBool = s5472 < s5423 s5481 :: SBool = s5472 < s5371 s5482 :: SBool = s5480 | s5481 s5483 :: SWord8 = s5472 >>> 1 s5484 :: SWord8 = s24 | s5483 s5485 :: SWord8 = s26 & s5483 s5486 :: SWord8 = if s5482 then s5484 else s5485 s5487 :: SWord1 = choose [0:0] s5486 s5488 :: SBool = s19 /= s5487 s5489 :: SWord8 = s5476 >>> 1 s5490 :: SWord8 = s24 | s5489 s5491 :: SWord8 = s26 & s5489 s5492 :: SWord8 = if s5394 then s5490 else s5491 s5493 :: SWord8 = if s22 then s5492 else s5475 s5494 :: SWord8 = s5493 >>> 1 s5495 :: SWord8 = s24 | s5494 s5496 :: SWord8 = s26 & s5494 s5497 :: SWord8 = if s5488 then s5495 else s5496 s5498 :: SWord8 = if s22 then s5497 else s5492 s5499 :: SWord1 = choose [0:0] s5498 s5500 :: SBool = s19 /= s5499 s5501 :: SBool = s_2 == s5500 s5502 :: SWord8 = s5486 >>> 1 s5503 :: SWord8 = s24 | s5502 s5504 :: SWord8 = s26 & s5502 s5505 :: SWord8 = if s5478 then s5503 else s5504 s5506 :: SWord8 = s5505 >>> 1 s5507 :: SWord8 = s24 | s5506 s5508 :: SWord8 = s26 & s5506 s5509 :: SWord8 = if s5500 then s5507 else s5508 s5510 :: SWord1 = choose [0:0] s5493 s5511 :: SBool = s19 /= s5510 s5512 :: SWord8 = s5498 >>> 1 s5513 :: SWord8 = s24 | s5512 s5514 :: SWord8 = s26 & s5512 s5515 :: SWord8 = if s5511 then s5513 else s5514 s5516 :: SWord8 = if s29 then s5475 else s5423 s5517 :: SWord8 = if s170 then s5492 else s5516 s5518 :: SWord8 = if s29 then s5497 else s5517 s5519 :: SWord8 = if s170 then s5515 else s5518 s5520 :: SWord8 = s5505 + s5519 s5521 :: SBool = s5520 < s5519 s5522 :: SBool = s5520 < s5505 s5523 :: SBool = s5521 | s5522 s5524 :: SWord8 = s5520 >>> 1 s5525 :: SWord8 = s24 | s5524 s5526 :: SWord8 = s26 & s5524 s5527 :: SWord8 = if s5523 then s5525 else s5526 s5528 :: SWord8 = if s5501 then s5509 else s5527 s5529 :: SWord8 = s5486 + s5517 s5530 :: SWord1 = choose [0:0] s5529 s5531 :: SBool = s19 /= s5530 s5532 :: SWord8 = if s5531 then s5495 else s5496 s5533 :: SWord8 = if s22 then s5532 else s5492 s5534 :: SWord1 = choose [0:0] s5533 s5535 :: SBool = s19 /= s5534 s5536 :: SBool = s_2 == s5535 s5537 :: SBool = s5529 < s5517 s5538 :: SBool = s5529 < s5486 s5539 :: SBool = s5537 | s5538 s5540 :: SWord8 = s5529 >>> 1 s5541 :: SWord8 = s24 | s5540 s5542 :: SWord8 = s26 & s5540 s5543 :: SWord8 = if s5539 then s5541 else s5542 s5544 :: SWord8 = s5543 >>> 1 s5545 :: SWord8 = s24 | s5544 s5546 :: SWord8 = s26 & s5544 s5547 :: SWord8 = if s5535 then s5545 else s5546 s5548 :: SWord8 = s5533 >>> 1 s5549 :: SWord8 = s24 | s5548 s5550 :: SWord8 = s26 & s5548 s5551 :: SWord8 = if s5511 then s5549 else s5550 s5552 :: SWord8 = if s29 then s5532 else s5517 s5553 :: SWord8 = if s170 then s5551 else s5552 s5554 :: SWord8 = s5543 + s5553 s5555 :: SBool = s5554 < s5553 s5556 :: SBool = s5554 < s5543 s5557 :: SBool = s5555 | s5556 s5558 :: SWord8 = s5554 >>> 1 s5559 :: SWord8 = s24 | s5558 s5560 :: SWord8 = s26 & s5558 s5561 :: SWord8 = if s5557 then s5559 else s5560 s5562 :: SWord8 = if s5536 then s5547 else s5561 s5563 :: SWord8 = if s5479 then s5528 else s5562 s5564 :: SWord8 = if s5364 then s5471 else s5563 s5565 :: SWord8 = if s5133 then s5356 else s5564 s5566 :: SWord8 = if s4670 then s5125 else s5565 s5567 :: SWord8 = if s3742 then s4662 else s5566 s5568 :: SWord8 = s3727 + s3863 s5569 :: SWord1 = choose [0:0] s5568 s5570 :: SBool = s19 /= s5569 s5571 :: SWord8 = if s5570 then s3736 else s3737 s5572 :: SWord8 = if s22 then s5571 else s3733 s5573 :: SWord1 = choose [0:0] s5572 s5574 :: SBool = s19 /= s5573 s5575 :: SBool = s_2 == s5574 s5576 :: SBool = s5568 < s3863 s5577 :: SBool = s5568 < s3727 s5578 :: SBool = s5576 | s5577 s5579 :: SWord8 = s5568 >>> 1 s5580 :: SWord8 = s24 | s5579 s5581 :: SWord8 = s26 & s5579 s5582 :: SWord8 = if s5578 then s5580 else s5581 s5583 :: SWord1 = choose [0:0] s5582 s5584 :: SBool = s19 /= s5583 s5585 :: SWord8 = s5572 >>> 1 s5586 :: SWord8 = s24 | s5585 s5587 :: SWord8 = s26 & s5585 s5588 :: SWord8 = if s3750 then s5586 else s5587 s5589 :: SWord8 = if s22 then s5588 else s5571 s5590 :: SWord8 = s5589 >>> 1 s5591 :: SWord8 = s24 | s5590 s5592 :: SWord8 = s26 & s5590 s5593 :: SWord8 = if s5584 then s5591 else s5592 s5594 :: SWord8 = if s22 then s5593 else s5588 s5595 :: SWord1 = choose [0:0] s5594 s5596 :: SBool = s19 /= s5595 s5597 :: SBool = s_2 == s5596 s5598 :: SWord8 = s5582 >>> 1 s5599 :: SWord8 = s24 | s5598 s5600 :: SWord8 = s26 & s5598 s5601 :: SWord8 = if s5574 then s5599 else s5600 s5602 :: SWord1 = choose [0:0] s5601 s5603 :: SBool = s19 /= s5602 s5604 :: SWord1 = choose [0:0] s5589 s5605 :: SBool = s19 /= s5604 s5606 :: SWord8 = s5594 >>> 1 s5607 :: SWord8 = s24 | s5606 s5608 :: SWord8 = s26 & s5606 s5609 :: SWord8 = if s5605 then s5607 else s5608 s5610 :: SWord8 = if s22 then s5609 else s5593 s5611 :: SWord8 = s5610 >>> 1 s5612 :: SWord8 = s24 | s5611 s5613 :: SWord8 = s26 & s5611 s5614 :: SWord8 = if s5603 then s5612 else s5613 s5615 :: SWord8 = if s22 then s5614 else s5609 s5616 :: SWord1 = choose [0:0] s5615 s5617 :: SBool = s19 /= s5616 s5618 :: SBool = s_2 == s5617 s5619 :: SWord8 = s5601 >>> 1 s5620 :: SWord8 = s24 | s5619 s5621 :: SWord8 = s26 & s5619 s5622 :: SWord8 = if s5596 then s5620 else s5621 s5623 :: SWord1 = choose [0:0] s5622 s5624 :: SBool = s19 /= s5623 s5625 :: SWord1 = choose [0:0] s5610 s5626 :: SBool = s19 /= s5625 s5627 :: SWord8 = s5615 >>> 1 s5628 :: SWord8 = s24 | s5627 s5629 :: SWord8 = s26 & s5627 s5630 :: SWord8 = if s5626 then s5628 else s5629 s5631 :: SWord8 = if s22 then s5630 else s5614 s5632 :: SWord8 = s5631 >>> 1 s5633 :: SWord8 = s24 | s5632 s5634 :: SWord8 = s26 & s5632 s5635 :: SWord8 = if s5624 then s5633 else s5634 s5636 :: SWord8 = if s22 then s5635 else s5630 s5637 :: SWord1 = choose [0:0] s5636 s5638 :: SBool = s19 /= s5637 s5639 :: SBool = s_2 == s5638 s5640 :: SWord8 = s5622 >>> 1 s5641 :: SWord8 = s24 | s5640 s5642 :: SWord8 = s26 & s5640 s5643 :: SWord8 = if s5617 then s5641 else s5642 s5644 :: SWord1 = choose [0:0] s5643 s5645 :: SBool = s19 /= s5644 s5646 :: SWord1 = choose [0:0] s5631 s5647 :: SBool = s19 /= s5646 s5648 :: SWord8 = s5636 >>> 1 s5649 :: SWord8 = s24 | s5648 s5650 :: SWord8 = s26 & s5648 s5651 :: SWord8 = if s5647 then s5649 else s5650 s5652 :: SWord8 = if s22 then s5651 else s5635 s5653 :: SWord8 = s5652 >>> 1 s5654 :: SWord8 = s24 | s5653 s5655 :: SWord8 = s26 & s5653 s5656 :: SWord8 = if s5645 then s5654 else s5655 s5657 :: SWord8 = if s22 then s5656 else s5651 s5658 :: SWord1 = choose [0:0] s5657 s5659 :: SBool = s19 /= s5658 s5660 :: SBool = s_2 == s5659 s5661 :: SWord8 = s5643 >>> 1 s5662 :: SWord8 = s24 | s5661 s5663 :: SWord8 = s26 & s5661 s5664 :: SWord8 = if s5638 then s5662 else s5663 s5665 :: SWord1 = choose [0:0] s5664 s5666 :: SBool = s19 /= s5665 s5667 :: SWord1 = choose [0:0] s5652 s5668 :: SBool = s19 /= s5667 s5669 :: SWord8 = s5657 >>> 1 s5670 :: SWord8 = s24 | s5669 s5671 :: SWord8 = s26 & s5669 s5672 :: SWord8 = if s5668 then s5670 else s5671 s5673 :: SWord8 = if s22 then s5672 else s5656 s5674 :: SWord8 = s5673 >>> 1 s5675 :: SWord8 = s24 | s5674 s5676 :: SWord8 = s26 & s5674 s5677 :: SWord8 = if s5666 then s5675 else s5676 s5678 :: SWord8 = if s22 then s5677 else s5672 s5679 :: SWord1 = choose [0:0] s5678 s5680 :: SBool = s19 /= s5679 s5681 :: SBool = s_2 == s5680 s5682 :: SWord8 = s5664 >>> 1 s5683 :: SWord8 = s24 | s5682 s5684 :: SWord8 = s26 & s5682 s5685 :: SWord8 = if s5659 then s5683 else s5684 s5686 :: SWord8 = s5685 >>> 1 s5687 :: SWord8 = s24 | s5686 s5688 :: SWord8 = s26 & s5686 s5689 :: SWord8 = if s5680 then s5687 else s5688 s5690 :: SWord1 = choose [0:0] s5673 s5691 :: SBool = s19 /= s5690 s5692 :: SWord8 = s5678 >>> 1 s5693 :: SWord8 = s24 | s5692 s5694 :: SWord8 = s26 & s5692 s5695 :: SWord8 = if s5691 then s5693 else s5694 s5696 :: SWord8 = if s29 then s5571 else s3863 s5697 :: SWord8 = if s170 then s5588 else s5696 s5698 :: SWord8 = if s29 then s5593 else s5697 s5699 :: SWord8 = if s170 then s5609 else s5698 s5700 :: SWord8 = if s29 then s5614 else s5699 s5701 :: SWord8 = if s170 then s5630 else s5700 s5702 :: SWord8 = if s29 then s5635 else s5701 s5703 :: SWord8 = if s170 then s5651 else s5702 s5704 :: SWord8 = if s29 then s5656 else s5703 s5705 :: SWord8 = if s170 then s5672 else s5704 s5706 :: SWord8 = if s29 then s5677 else s5705 s5707 :: SWord8 = if s170 then s5695 else s5706 s5708 :: SWord8 = s5685 + s5707 s5709 :: SBool = s5708 < s5707 s5710 :: SBool = s5708 < s5685 s5711 :: SBool = s5709 | s5710 s5712 :: SWord8 = s5708 >>> 1 s5713 :: SWord8 = s24 | s5712 s5714 :: SWord8 = s26 & s5712 s5715 :: SWord8 = if s5711 then s5713 else s5714 s5716 :: SWord8 = if s5681 then s5689 else s5715 s5717 :: SWord8 = s5664 + s5705 s5718 :: SWord1 = choose [0:0] s5717 s5719 :: SBool = s19 /= s5718 s5720 :: SWord8 = if s5719 then s5675 else s5676 s5721 :: SWord8 = if s22 then s5720 else s5672 s5722 :: SWord1 = choose [0:0] s5721 s5723 :: SBool = s19 /= s5722 s5724 :: SBool = s_2 == s5723 s5725 :: SBool = s5717 < s5705 s5726 :: SBool = s5717 < s5664 s5727 :: SBool = s5725 | s5726 s5728 :: SWord8 = s5717 >>> 1 s5729 :: SWord8 = s24 | s5728 s5730 :: SWord8 = s26 & s5728 s5731 :: SWord8 = if s5727 then s5729 else s5730 s5732 :: SWord8 = s5731 >>> 1 s5733 :: SWord8 = s24 | s5732 s5734 :: SWord8 = s26 & s5732 s5735 :: SWord8 = if s5723 then s5733 else s5734 s5736 :: SWord8 = s5721 >>> 1 s5737 :: SWord8 = s24 | s5736 s5738 :: SWord8 = s26 & s5736 s5739 :: SWord8 = if s5691 then s5737 else s5738 s5740 :: SWord8 = if s29 then s5720 else s5705 s5741 :: SWord8 = if s170 then s5739 else s5740 s5742 :: SWord8 = s5731 + s5741 s5743 :: SBool = s5742 < s5741 s5744 :: SBool = s5742 < s5731 s5745 :: SBool = s5743 | s5744 s5746 :: SWord8 = s5742 >>> 1 s5747 :: SWord8 = s24 | s5746 s5748 :: SWord8 = s26 & s5746 s5749 :: SWord8 = if s5745 then s5747 else s5748 s5750 :: SWord8 = if s5724 then s5735 else s5749 s5751 :: SWord8 = if s5660 then s5716 else s5750 s5752 :: SWord8 = s5643 + s5703 s5753 :: SWord1 = choose [0:0] s5752 s5754 :: SBool = s19 /= s5753 s5755 :: SWord8 = if s5754 then s5654 else s5655 s5756 :: SWord8 = if s22 then s5755 else s5651 s5757 :: SWord1 = choose [0:0] s5756 s5758 :: SBool = s19 /= s5757 s5759 :: SBool = s_2 == s5758 s5760 :: SBool = s5752 < s5703 s5761 :: SBool = s5752 < s5643 s5762 :: SBool = s5760 | s5761 s5763 :: SWord8 = s5752 >>> 1 s5764 :: SWord8 = s24 | s5763 s5765 :: SWord8 = s26 & s5763 s5766 :: SWord8 = if s5762 then s5764 else s5765 s5767 :: SWord1 = choose [0:0] s5766 s5768 :: SBool = s19 /= s5767 s5769 :: SWord8 = s5756 >>> 1 s5770 :: SWord8 = s24 | s5769 s5771 :: SWord8 = s26 & s5769 s5772 :: SWord8 = if s5668 then s5770 else s5771 s5773 :: SWord8 = if s22 then s5772 else s5755 s5774 :: SWord8 = s5773 >>> 1 s5775 :: SWord8 = s24 | s5774 s5776 :: SWord8 = s26 & s5774 s5777 :: SWord8 = if s5768 then s5775 else s5776 s5778 :: SWord8 = if s22 then s5777 else s5772 s5779 :: SWord1 = choose [0:0] s5778 s5780 :: SBool = s19 /= s5779 s5781 :: SBool = s_2 == s5780 s5782 :: SWord8 = s5766 >>> 1 s5783 :: SWord8 = s24 | s5782 s5784 :: SWord8 = s26 & s5782 s5785 :: SWord8 = if s5758 then s5783 else s5784 s5786 :: SWord8 = s5785 >>> 1 s5787 :: SWord8 = s24 | s5786 s5788 :: SWord8 = s26 & s5786 s5789 :: SWord8 = if s5780 then s5787 else s5788 s5790 :: SWord1 = choose [0:0] s5773 s5791 :: SBool = s19 /= s5790 s5792 :: SWord8 = s5778 >>> 1 s5793 :: SWord8 = s24 | s5792 s5794 :: SWord8 = s26 & s5792 s5795 :: SWord8 = if s5791 then s5793 else s5794 s5796 :: SWord8 = if s29 then s5755 else s5703 s5797 :: SWord8 = if s170 then s5772 else s5796 s5798 :: SWord8 = if s29 then s5777 else s5797 s5799 :: SWord8 = if s170 then s5795 else s5798 s5800 :: SWord8 = s5785 + s5799 s5801 :: SBool = s5800 < s5799 s5802 :: SBool = s5800 < s5785 s5803 :: SBool = s5801 | s5802 s5804 :: SWord8 = s5800 >>> 1 s5805 :: SWord8 = s24 | s5804 s5806 :: SWord8 = s26 & s5804 s5807 :: SWord8 = if s5803 then s5805 else s5806 s5808 :: SWord8 = if s5781 then s5789 else s5807 s5809 :: SWord8 = s5766 + s5797 s5810 :: SWord1 = choose [0:0] s5809 s5811 :: SBool = s19 /= s5810 s5812 :: SWord8 = if s5811 then s5775 else s5776 s5813 :: SWord8 = if s22 then s5812 else s5772 s5814 :: SWord1 = choose [0:0] s5813 s5815 :: SBool = s19 /= s5814 s5816 :: SBool = s_2 == s5815 s5817 :: SBool = s5809 < s5797 s5818 :: SBool = s5809 < s5766 s5819 :: SBool = s5817 | s5818 s5820 :: SWord8 = s5809 >>> 1 s5821 :: SWord8 = s24 | s5820 s5822 :: SWord8 = s26 & s5820 s5823 :: SWord8 = if s5819 then s5821 else s5822 s5824 :: SWord8 = s5823 >>> 1 s5825 :: SWord8 = s24 | s5824 s5826 :: SWord8 = s26 & s5824 s5827 :: SWord8 = if s5815 then s5825 else s5826 s5828 :: SWord8 = s5813 >>> 1 s5829 :: SWord8 = s24 | s5828 s5830 :: SWord8 = s26 & s5828 s5831 :: SWord8 = if s5791 then s5829 else s5830 s5832 :: SWord8 = if s29 then s5812 else s5797 s5833 :: SWord8 = if s170 then s5831 else s5832 s5834 :: SWord8 = s5823 + s5833 s5835 :: SBool = s5834 < s5833 s5836 :: SBool = s5834 < s5823 s5837 :: SBool = s5835 | s5836 s5838 :: SWord8 = s5834 >>> 1 s5839 :: SWord8 = s24 | s5838 s5840 :: SWord8 = s26 & s5838 s5841 :: SWord8 = if s5837 then s5839 else s5840 s5842 :: SWord8 = if s5816 then s5827 else s5841 s5843 :: SWord8 = if s5759 then s5808 else s5842 s5844 :: SWord8 = if s5639 then s5751 else s5843 s5845 :: SWord8 = s5622 + s5701 s5846 :: SWord1 = choose [0:0] s5845 s5847 :: SBool = s19 /= s5846 s5848 :: SWord8 = if s5847 then s5633 else s5634 s5849 :: SWord8 = if s22 then s5848 else s5630 s5850 :: SWord1 = choose [0:0] s5849 s5851 :: SBool = s19 /= s5850 s5852 :: SBool = s_2 == s5851 s5853 :: SBool = s5845 < s5701 s5854 :: SBool = s5845 < s5622 s5855 :: SBool = s5853 | s5854 s5856 :: SWord8 = s5845 >>> 1 s5857 :: SWord8 = s24 | s5856 s5858 :: SWord8 = s26 & s5856 s5859 :: SWord8 = if s5855 then s5857 else s5858 s5860 :: SWord1 = choose [0:0] s5859 s5861 :: SBool = s19 /= s5860 s5862 :: SWord8 = s5849 >>> 1 s5863 :: SWord8 = s24 | s5862 s5864 :: SWord8 = s26 & s5862 s5865 :: SWord8 = if s5647 then s5863 else s5864 s5866 :: SWord8 = if s22 then s5865 else s5848 s5867 :: SWord8 = s5866 >>> 1 s5868 :: SWord8 = s24 | s5867 s5869 :: SWord8 = s26 & s5867 s5870 :: SWord8 = if s5861 then s5868 else s5869 s5871 :: SWord8 = if s22 then s5870 else s5865 s5872 :: SWord1 = choose [0:0] s5871 s5873 :: SBool = s19 /= s5872 s5874 :: SBool = s_2 == s5873 s5875 :: SWord8 = s5859 >>> 1 s5876 :: SWord8 = s24 | s5875 s5877 :: SWord8 = s26 & s5875 s5878 :: SWord8 = if s5851 then s5876 else s5877 s5879 :: SWord1 = choose [0:0] s5878 s5880 :: SBool = s19 /= s5879 s5881 :: SWord1 = choose [0:0] s5866 s5882 :: SBool = s19 /= s5881 s5883 :: SWord8 = s5871 >>> 1 s5884 :: SWord8 = s24 | s5883 s5885 :: SWord8 = s26 & s5883 s5886 :: SWord8 = if s5882 then s5884 else s5885 s5887 :: SWord8 = if s22 then s5886 else s5870 s5888 :: SWord8 = s5887 >>> 1 s5889 :: SWord8 = s24 | s5888 s5890 :: SWord8 = s26 & s5888 s5891 :: SWord8 = if s5880 then s5889 else s5890 s5892 :: SWord8 = if s22 then s5891 else s5886 s5893 :: SWord1 = choose [0:0] s5892 s5894 :: SBool = s19 /= s5893 s5895 :: SBool = s_2 == s5894 s5896 :: SWord8 = s5878 >>> 1 s5897 :: SWord8 = s24 | s5896 s5898 :: SWord8 = s26 & s5896 s5899 :: SWord8 = if s5873 then s5897 else s5898 s5900 :: SWord8 = s5899 >>> 1 s5901 :: SWord8 = s24 | s5900 s5902 :: SWord8 = s26 & s5900 s5903 :: SWord8 = if s5894 then s5901 else s5902 s5904 :: SWord1 = choose [0:0] s5887 s5905 :: SBool = s19 /= s5904 s5906 :: SWord8 = s5892 >>> 1 s5907 :: SWord8 = s24 | s5906 s5908 :: SWord8 = s26 & s5906 s5909 :: SWord8 = if s5905 then s5907 else s5908 s5910 :: SWord8 = if s29 then s5848 else s5701 s5911 :: SWord8 = if s170 then s5865 else s5910 s5912 :: SWord8 = if s29 then s5870 else s5911 s5913 :: SWord8 = if s170 then s5886 else s5912 s5914 :: SWord8 = if s29 then s5891 else s5913 s5915 :: SWord8 = if s170 then s5909 else s5914 s5916 :: SWord8 = s5899 + s5915 s5917 :: SBool = s5916 < s5915 s5918 :: SBool = s5916 < s5899 s5919 :: SBool = s5917 | s5918 s5920 :: SWord8 = s5916 >>> 1 s5921 :: SWord8 = s24 | s5920 s5922 :: SWord8 = s26 & s5920 s5923 :: SWord8 = if s5919 then s5921 else s5922 s5924 :: SWord8 = if s5895 then s5903 else s5923 s5925 :: SWord8 = s5878 + s5913 s5926 :: SWord1 = choose [0:0] s5925 s5927 :: SBool = s19 /= s5926 s5928 :: SWord8 = if s5927 then s5889 else s5890 s5929 :: SWord8 = if s22 then s5928 else s5886 s5930 :: SWord1 = choose [0:0] s5929 s5931 :: SBool = s19 /= s5930 s5932 :: SBool = s_2 == s5931 s5933 :: SBool = s5925 < s5913 s5934 :: SBool = s5925 < s5878 s5935 :: SBool = s5933 | s5934 s5936 :: SWord8 = s5925 >>> 1 s5937 :: SWord8 = s24 | s5936 s5938 :: SWord8 = s26 & s5936 s5939 :: SWord8 = if s5935 then s5937 else s5938 s5940 :: SWord8 = s5939 >>> 1 s5941 :: SWord8 = s24 | s5940 s5942 :: SWord8 = s26 & s5940 s5943 :: SWord8 = if s5931 then s5941 else s5942 s5944 :: SWord8 = s5929 >>> 1 s5945 :: SWord8 = s24 | s5944 s5946 :: SWord8 = s26 & s5944 s5947 :: SWord8 = if s5905 then s5945 else s5946 s5948 :: SWord8 = if s29 then s5928 else s5913 s5949 :: SWord8 = if s170 then s5947 else s5948 s5950 :: SWord8 = s5939 + s5949 s5951 :: SBool = s5950 < s5949 s5952 :: SBool = s5950 < s5939 s5953 :: SBool = s5951 | s5952 s5954 :: SWord8 = s5950 >>> 1 s5955 :: SWord8 = s24 | s5954 s5956 :: SWord8 = s26 & s5954 s5957 :: SWord8 = if s5953 then s5955 else s5956 s5958 :: SWord8 = if s5932 then s5943 else s5957 s5959 :: SWord8 = if s5874 then s5924 else s5958 s5960 :: SWord8 = s5859 + s5911 s5961 :: SWord1 = choose [0:0] s5960 s5962 :: SBool = s19 /= s5961 s5963 :: SWord8 = if s5962 then s5868 else s5869 s5964 :: SWord8 = if s22 then s5963 else s5865 s5965 :: SWord1 = choose [0:0] s5964 s5966 :: SBool = s19 /= s5965 s5967 :: SBool = s_2 == s5966 s5968 :: SBool = s5960 < s5911 s5969 :: SBool = s5960 < s5859 s5970 :: SBool = s5968 | s5969 s5971 :: SWord8 = s5960 >>> 1 s5972 :: SWord8 = s24 | s5971 s5973 :: SWord8 = s26 & s5971 s5974 :: SWord8 = if s5970 then s5972 else s5973 s5975 :: SWord1 = choose [0:0] s5974 s5976 :: SBool = s19 /= s5975 s5977 :: SWord8 = s5964 >>> 1 s5978 :: SWord8 = s24 | s5977 s5979 :: SWord8 = s26 & s5977 s5980 :: SWord8 = if s5882 then s5978 else s5979 s5981 :: SWord8 = if s22 then s5980 else s5963 s5982 :: SWord8 = s5981 >>> 1 s5983 :: SWord8 = s24 | s5982 s5984 :: SWord8 = s26 & s5982 s5985 :: SWord8 = if s5976 then s5983 else s5984 s5986 :: SWord8 = if s22 then s5985 else s5980 s5987 :: SWord1 = choose [0:0] s5986 s5988 :: SBool = s19 /= s5987 s5989 :: SBool = s_2 == s5988 s5990 :: SWord8 = s5974 >>> 1 s5991 :: SWord8 = s24 | s5990 s5992 :: SWord8 = s26 & s5990 s5993 :: SWord8 = if s5966 then s5991 else s5992 s5994 :: SWord8 = s5993 >>> 1 s5995 :: SWord8 = s24 | s5994 s5996 :: SWord8 = s26 & s5994 s5997 :: SWord8 = if s5988 then s5995 else s5996 s5998 :: SWord1 = choose [0:0] s5981 s5999 :: SBool = s19 /= s5998 s6000 :: SWord8 = s5986 >>> 1 s6001 :: SWord8 = s24 | s6000 s6002 :: SWord8 = s26 & s6000 s6003 :: SWord8 = if s5999 then s6001 else s6002 s6004 :: SWord8 = if s29 then s5963 else s5911 s6005 :: SWord8 = if s170 then s5980 else s6004 s6006 :: SWord8 = if s29 then s5985 else s6005 s6007 :: SWord8 = if s170 then s6003 else s6006 s6008 :: SWord8 = s5993 + s6007 s6009 :: SBool = s6008 < s6007 s6010 :: SBool = s6008 < s5993 s6011 :: SBool = s6009 | s6010 s6012 :: SWord8 = s6008 >>> 1 s6013 :: SWord8 = s24 | s6012 s6014 :: SWord8 = s26 & s6012 s6015 :: SWord8 = if s6011 then s6013 else s6014 s6016 :: SWord8 = if s5989 then s5997 else s6015 s6017 :: SWord8 = s5974 + s6005 s6018 :: SWord1 = choose [0:0] s6017 s6019 :: SBool = s19 /= s6018 s6020 :: SWord8 = if s6019 then s5983 else s5984 s6021 :: SWord8 = if s22 then s6020 else s5980 s6022 :: SWord1 = choose [0:0] s6021 s6023 :: SBool = s19 /= s6022 s6024 :: SBool = s_2 == s6023 s6025 :: SBool = s6017 < s6005 s6026 :: SBool = s6017 < s5974 s6027 :: SBool = s6025 | s6026 s6028 :: SWord8 = s6017 >>> 1 s6029 :: SWord8 = s24 | s6028 s6030 :: SWord8 = s26 & s6028 s6031 :: SWord8 = if s6027 then s6029 else s6030 s6032 :: SWord8 = s6031 >>> 1 s6033 :: SWord8 = s24 | s6032 s6034 :: SWord8 = s26 & s6032 s6035 :: SWord8 = if s6023 then s6033 else s6034 s6036 :: SWord8 = s6021 >>> 1 s6037 :: SWord8 = s24 | s6036 s6038 :: SWord8 = s26 & s6036 s6039 :: SWord8 = if s5999 then s6037 else s6038 s6040 :: SWord8 = if s29 then s6020 else s6005 s6041 :: SWord8 = if s170 then s6039 else s6040 s6042 :: SWord8 = s6031 + s6041 s6043 :: SBool = s6042 < s6041 s6044 :: SBool = s6042 < s6031 s6045 :: SBool = s6043 | s6044 s6046 :: SWord8 = s6042 >>> 1 s6047 :: SWord8 = s24 | s6046 s6048 :: SWord8 = s26 & s6046 s6049 :: SWord8 = if s6045 then s6047 else s6048 s6050 :: SWord8 = if s6024 then s6035 else s6049 s6051 :: SWord8 = if s5967 then s6016 else s6050 s6052 :: SWord8 = if s5852 then s5959 else s6051 s6053 :: SWord8 = if s5618 then s5844 else s6052 s6054 :: SWord8 = s5601 + s5699 s6055 :: SWord1 = choose [0:0] s6054 s6056 :: SBool = s19 /= s6055 s6057 :: SWord8 = if s6056 then s5612 else s5613 s6058 :: SWord8 = if s22 then s6057 else s5609 s6059 :: SWord1 = choose [0:0] s6058 s6060 :: SBool = s19 /= s6059 s6061 :: SBool = s_2 == s6060 s6062 :: SBool = s6054 < s5699 s6063 :: SBool = s6054 < s5601 s6064 :: SBool = s6062 | s6063 s6065 :: SWord8 = s6054 >>> 1 s6066 :: SWord8 = s24 | s6065 s6067 :: SWord8 = s26 & s6065 s6068 :: SWord8 = if s6064 then s6066 else s6067 s6069 :: SWord1 = choose [0:0] s6068 s6070 :: SBool = s19 /= s6069 s6071 :: SWord8 = s6058 >>> 1 s6072 :: SWord8 = s24 | s6071 s6073 :: SWord8 = s26 & s6071 s6074 :: SWord8 = if s5626 then s6072 else s6073 s6075 :: SWord8 = if s22 then s6074 else s6057 s6076 :: SWord8 = s6075 >>> 1 s6077 :: SWord8 = s24 | s6076 s6078 :: SWord8 = s26 & s6076 s6079 :: SWord8 = if s6070 then s6077 else s6078 s6080 :: SWord8 = if s22 then s6079 else s6074 s6081 :: SWord1 = choose [0:0] s6080 s6082 :: SBool = s19 /= s6081 s6083 :: SBool = s_2 == s6082 s6084 :: SWord8 = s6068 >>> 1 s6085 :: SWord8 = s24 | s6084 s6086 :: SWord8 = s26 & s6084 s6087 :: SWord8 = if s6060 then s6085 else s6086 s6088 :: SWord1 = choose [0:0] s6087 s6089 :: SBool = s19 /= s6088 s6090 :: SWord1 = choose [0:0] s6075 s6091 :: SBool = s19 /= s6090 s6092 :: SWord8 = s6080 >>> 1 s6093 :: SWord8 = s24 | s6092 s6094 :: SWord8 = s26 & s6092 s6095 :: SWord8 = if s6091 then s6093 else s6094 s6096 :: SWord8 = if s22 then s6095 else s6079 s6097 :: SWord8 = s6096 >>> 1 s6098 :: SWord8 = s24 | s6097 s6099 :: SWord8 = s26 & s6097 s6100 :: SWord8 = if s6089 then s6098 else s6099 s6101 :: SWord8 = if s22 then s6100 else s6095 s6102 :: SWord1 = choose [0:0] s6101 s6103 :: SBool = s19 /= s6102 s6104 :: SBool = s_2 == s6103 s6105 :: SWord8 = s6087 >>> 1 s6106 :: SWord8 = s24 | s6105 s6107 :: SWord8 = s26 & s6105 s6108 :: SWord8 = if s6082 then s6106 else s6107 s6109 :: SWord1 = choose [0:0] s6108 s6110 :: SBool = s19 /= s6109 s6111 :: SWord1 = choose [0:0] s6096 s6112 :: SBool = s19 /= s6111 s6113 :: SWord8 = s6101 >>> 1 s6114 :: SWord8 = s24 | s6113 s6115 :: SWord8 = s26 & s6113 s6116 :: SWord8 = if s6112 then s6114 else s6115 s6117 :: SWord8 = if s22 then s6116 else s6100 s6118 :: SWord8 = s6117 >>> 1 s6119 :: SWord8 = s24 | s6118 s6120 :: SWord8 = s26 & s6118 s6121 :: SWord8 = if s6110 then s6119 else s6120 s6122 :: SWord8 = if s22 then s6121 else s6116 s6123 :: SWord1 = choose [0:0] s6122 s6124 :: SBool = s19 /= s6123 s6125 :: SBool = s_2 == s6124 s6126 :: SWord8 = s6108 >>> 1 s6127 :: SWord8 = s24 | s6126 s6128 :: SWord8 = s26 & s6126 s6129 :: SWord8 = if s6103 then s6127 else s6128 s6130 :: SWord8 = s6129 >>> 1 s6131 :: SWord8 = s24 | s6130 s6132 :: SWord8 = s26 & s6130 s6133 :: SWord8 = if s6124 then s6131 else s6132 s6134 :: SWord1 = choose [0:0] s6117 s6135 :: SBool = s19 /= s6134 s6136 :: SWord8 = s6122 >>> 1 s6137 :: SWord8 = s24 | s6136 s6138 :: SWord8 = s26 & s6136 s6139 :: SWord8 = if s6135 then s6137 else s6138 s6140 :: SWord8 = if s29 then s6057 else s5699 s6141 :: SWord8 = if s170 then s6074 else s6140 s6142 :: SWord8 = if s29 then s6079 else s6141 s6143 :: SWord8 = if s170 then s6095 else s6142 s6144 :: SWord8 = if s29 then s6100 else s6143 s6145 :: SWord8 = if s170 then s6116 else s6144 s6146 :: SWord8 = if s29 then s6121 else s6145 s6147 :: SWord8 = if s170 then s6139 else s6146 s6148 :: SWord8 = s6129 + s6147 s6149 :: SBool = s6148 < s6147 s6150 :: SBool = s6148 < s6129 s6151 :: SBool = s6149 | s6150 s6152 :: SWord8 = s6148 >>> 1 s6153 :: SWord8 = s24 | s6152 s6154 :: SWord8 = s26 & s6152 s6155 :: SWord8 = if s6151 then s6153 else s6154 s6156 :: SWord8 = if s6125 then s6133 else s6155 s6157 :: SWord8 = s6108 + s6145 s6158 :: SWord1 = choose [0:0] s6157 s6159 :: SBool = s19 /= s6158 s6160 :: SWord8 = if s6159 then s6119 else s6120 s6161 :: SWord8 = if s22 then s6160 else s6116 s6162 :: SWord1 = choose [0:0] s6161 s6163 :: SBool = s19 /= s6162 s6164 :: SBool = s_2 == s6163 s6165 :: SBool = s6157 < s6145 s6166 :: SBool = s6157 < s6108 s6167 :: SBool = s6165 | s6166 s6168 :: SWord8 = s6157 >>> 1 s6169 :: SWord8 = s24 | s6168 s6170 :: SWord8 = s26 & s6168 s6171 :: SWord8 = if s6167 then s6169 else s6170 s6172 :: SWord8 = s6171 >>> 1 s6173 :: SWord8 = s24 | s6172 s6174 :: SWord8 = s26 & s6172 s6175 :: SWord8 = if s6163 then s6173 else s6174 s6176 :: SWord8 = s6161 >>> 1 s6177 :: SWord8 = s24 | s6176 s6178 :: SWord8 = s26 & s6176 s6179 :: SWord8 = if s6135 then s6177 else s6178 s6180 :: SWord8 = if s29 then s6160 else s6145 s6181 :: SWord8 = if s170 then s6179 else s6180 s6182 :: SWord8 = s6171 + s6181 s6183 :: SBool = s6182 < s6181 s6184 :: SBool = s6182 < s6171 s6185 :: SBool = s6183 | s6184 s6186 :: SWord8 = s6182 >>> 1 s6187 :: SWord8 = s24 | s6186 s6188 :: SWord8 = s26 & s6186 s6189 :: SWord8 = if s6185 then s6187 else s6188 s6190 :: SWord8 = if s6164 then s6175 else s6189 s6191 :: SWord8 = if s6104 then s6156 else s6190 s6192 :: SWord8 = s6087 + s6143 s6193 :: SWord1 = choose [0:0] s6192 s6194 :: SBool = s19 /= s6193 s6195 :: SWord8 = if s6194 then s6098 else s6099 s6196 :: SWord8 = if s22 then s6195 else s6095 s6197 :: SWord1 = choose [0:0] s6196 s6198 :: SBool = s19 /= s6197 s6199 :: SBool = s_2 == s6198 s6200 :: SBool = s6192 < s6143 s6201 :: SBool = s6192 < s6087 s6202 :: SBool = s6200 | s6201 s6203 :: SWord8 = s6192 >>> 1 s6204 :: SWord8 = s24 | s6203 s6205 :: SWord8 = s26 & s6203 s6206 :: SWord8 = if s6202 then s6204 else s6205 s6207 :: SWord1 = choose [0:0] s6206 s6208 :: SBool = s19 /= s6207 s6209 :: SWord8 = s6196 >>> 1 s6210 :: SWord8 = s24 | s6209 s6211 :: SWord8 = s26 & s6209 s6212 :: SWord8 = if s6112 then s6210 else s6211 s6213 :: SWord8 = if s22 then s6212 else s6195 s6214 :: SWord8 = s6213 >>> 1 s6215 :: SWord8 = s24 | s6214 s6216 :: SWord8 = s26 & s6214 s6217 :: SWord8 = if s6208 then s6215 else s6216 s6218 :: SWord8 = if s22 then s6217 else s6212 s6219 :: SWord1 = choose [0:0] s6218 s6220 :: SBool = s19 /= s6219 s6221 :: SBool = s_2 == s6220 s6222 :: SWord8 = s6206 >>> 1 s6223 :: SWord8 = s24 | s6222 s6224 :: SWord8 = s26 & s6222 s6225 :: SWord8 = if s6198 then s6223 else s6224 s6226 :: SWord8 = s6225 >>> 1 s6227 :: SWord8 = s24 | s6226 s6228 :: SWord8 = s26 & s6226 s6229 :: SWord8 = if s6220 then s6227 else s6228 s6230 :: SWord1 = choose [0:0] s6213 s6231 :: SBool = s19 /= s6230 s6232 :: SWord8 = s6218 >>> 1 s6233 :: SWord8 = s24 | s6232 s6234 :: SWord8 = s26 & s6232 s6235 :: SWord8 = if s6231 then s6233 else s6234 s6236 :: SWord8 = if s29 then s6195 else s6143 s6237 :: SWord8 = if s170 then s6212 else s6236 s6238 :: SWord8 = if s29 then s6217 else s6237 s6239 :: SWord8 = if s170 then s6235 else s6238 s6240 :: SWord8 = s6225 + s6239 s6241 :: SBool = s6240 < s6239 s6242 :: SBool = s6240 < s6225 s6243 :: SBool = s6241 | s6242 s6244 :: SWord8 = s6240 >>> 1 s6245 :: SWord8 = s24 | s6244 s6246 :: SWord8 = s26 & s6244 s6247 :: SWord8 = if s6243 then s6245 else s6246 s6248 :: SWord8 = if s6221 then s6229 else s6247 s6249 :: SWord8 = s6206 + s6237 s6250 :: SWord1 = choose [0:0] s6249 s6251 :: SBool = s19 /= s6250 s6252 :: SWord8 = if s6251 then s6215 else s6216 s6253 :: SWord8 = if s22 then s6252 else s6212 s6254 :: SWord1 = choose [0:0] s6253 s6255 :: SBool = s19 /= s6254 s6256 :: SBool = s_2 == s6255 s6257 :: SBool = s6249 < s6237 s6258 :: SBool = s6249 < s6206 s6259 :: SBool = s6257 | s6258 s6260 :: SWord8 = s6249 >>> 1 s6261 :: SWord8 = s24 | s6260 s6262 :: SWord8 = s26 & s6260 s6263 :: SWord8 = if s6259 then s6261 else s6262 s6264 :: SWord8 = s6263 >>> 1 s6265 :: SWord8 = s24 | s6264 s6266 :: SWord8 = s26 & s6264 s6267 :: SWord8 = if s6255 then s6265 else s6266 s6268 :: SWord8 = s6253 >>> 1 s6269 :: SWord8 = s24 | s6268 s6270 :: SWord8 = s26 & s6268 s6271 :: SWord8 = if s6231 then s6269 else s6270 s6272 :: SWord8 = if s29 then s6252 else s6237 s6273 :: SWord8 = if s170 then s6271 else s6272 s6274 :: SWord8 = s6263 + s6273 s6275 :: SBool = s6274 < s6273 s6276 :: SBool = s6274 < s6263 s6277 :: SBool = s6275 | s6276 s6278 :: SWord8 = s6274 >>> 1 s6279 :: SWord8 = s24 | s6278 s6280 :: SWord8 = s26 & s6278 s6281 :: SWord8 = if s6277 then s6279 else s6280 s6282 :: SWord8 = if s6256 then s6267 else s6281 s6283 :: SWord8 = if s6199 then s6248 else s6282 s6284 :: SWord8 = if s6083 then s6191 else s6283 s6285 :: SWord8 = s6068 + s6141 s6286 :: SWord1 = choose [0:0] s6285 s6287 :: SBool = s19 /= s6286 s6288 :: SWord8 = if s6287 then s6077 else s6078 s6289 :: SWord8 = if s22 then s6288 else s6074 s6290 :: SWord1 = choose [0:0] s6289 s6291 :: SBool = s19 /= s6290 s6292 :: SBool = s_2 == s6291 s6293 :: SBool = s6285 < s6141 s6294 :: SBool = s6285 < s6068 s6295 :: SBool = s6293 | s6294 s6296 :: SWord8 = s6285 >>> 1 s6297 :: SWord8 = s24 | s6296 s6298 :: SWord8 = s26 & s6296 s6299 :: SWord8 = if s6295 then s6297 else s6298 s6300 :: SWord1 = choose [0:0] s6299 s6301 :: SBool = s19 /= s6300 s6302 :: SWord8 = s6289 >>> 1 s6303 :: SWord8 = s24 | s6302 s6304 :: SWord8 = s26 & s6302 s6305 :: SWord8 = if s6091 then s6303 else s6304 s6306 :: SWord8 = if s22 then s6305 else s6288 s6307 :: SWord8 = s6306 >>> 1 s6308 :: SWord8 = s24 | s6307 s6309 :: SWord8 = s26 & s6307 s6310 :: SWord8 = if s6301 then s6308 else s6309 s6311 :: SWord8 = if s22 then s6310 else s6305 s6312 :: SWord1 = choose [0:0] s6311 s6313 :: SBool = s19 /= s6312 s6314 :: SBool = s_2 == s6313 s6315 :: SWord8 = s6299 >>> 1 s6316 :: SWord8 = s24 | s6315 s6317 :: SWord8 = s26 & s6315 s6318 :: SWord8 = if s6291 then s6316 else s6317 s6319 :: SWord1 = choose [0:0] s6318 s6320 :: SBool = s19 /= s6319 s6321 :: SWord1 = choose [0:0] s6306 s6322 :: SBool = s19 /= s6321 s6323 :: SWord8 = s6311 >>> 1 s6324 :: SWord8 = s24 | s6323 s6325 :: SWord8 = s26 & s6323 s6326 :: SWord8 = if s6322 then s6324 else s6325 s6327 :: SWord8 = if s22 then s6326 else s6310 s6328 :: SWord8 = s6327 >>> 1 s6329 :: SWord8 = s24 | s6328 s6330 :: SWord8 = s26 & s6328 s6331 :: SWord8 = if s6320 then s6329 else s6330 s6332 :: SWord8 = if s22 then s6331 else s6326 s6333 :: SWord1 = choose [0:0] s6332 s6334 :: SBool = s19 /= s6333 s6335 :: SBool = s_2 == s6334 s6336 :: SWord8 = s6318 >>> 1 s6337 :: SWord8 = s24 | s6336 s6338 :: SWord8 = s26 & s6336 s6339 :: SWord8 = if s6313 then s6337 else s6338 s6340 :: SWord8 = s6339 >>> 1 s6341 :: SWord8 = s24 | s6340 s6342 :: SWord8 = s26 & s6340 s6343 :: SWord8 = if s6334 then s6341 else s6342 s6344 :: SWord1 = choose [0:0] s6327 s6345 :: SBool = s19 /= s6344 s6346 :: SWord8 = s6332 >>> 1 s6347 :: SWord8 = s24 | s6346 s6348 :: SWord8 = s26 & s6346 s6349 :: SWord8 = if s6345 then s6347 else s6348 s6350 :: SWord8 = if s29 then s6288 else s6141 s6351 :: SWord8 = if s170 then s6305 else s6350 s6352 :: SWord8 = if s29 then s6310 else s6351 s6353 :: SWord8 = if s170 then s6326 else s6352 s6354 :: SWord8 = if s29 then s6331 else s6353 s6355 :: SWord8 = if s170 then s6349 else s6354 s6356 :: SWord8 = s6339 + s6355 s6357 :: SBool = s6356 < s6355 s6358 :: SBool = s6356 < s6339 s6359 :: SBool = s6357 | s6358 s6360 :: SWord8 = s6356 >>> 1 s6361 :: SWord8 = s24 | s6360 s6362 :: SWord8 = s26 & s6360 s6363 :: SWord8 = if s6359 then s6361 else s6362 s6364 :: SWord8 = if s6335 then s6343 else s6363 s6365 :: SWord8 = s6318 + s6353 s6366 :: SWord1 = choose [0:0] s6365 s6367 :: SBool = s19 /= s6366 s6368 :: SWord8 = if s6367 then s6329 else s6330 s6369 :: SWord8 = if s22 then s6368 else s6326 s6370 :: SWord1 = choose [0:0] s6369 s6371 :: SBool = s19 /= s6370 s6372 :: SBool = s_2 == s6371 s6373 :: SBool = s6365 < s6353 s6374 :: SBool = s6365 < s6318 s6375 :: SBool = s6373 | s6374 s6376 :: SWord8 = s6365 >>> 1 s6377 :: SWord8 = s24 | s6376 s6378 :: SWord8 = s26 & s6376 s6379 :: SWord8 = if s6375 then s6377 else s6378 s6380 :: SWord8 = s6379 >>> 1 s6381 :: SWord8 = s24 | s6380 s6382 :: SWord8 = s26 & s6380 s6383 :: SWord8 = if s6371 then s6381 else s6382 s6384 :: SWord8 = s6369 >>> 1 s6385 :: SWord8 = s24 | s6384 s6386 :: SWord8 = s26 & s6384 s6387 :: SWord8 = if s6345 then s6385 else s6386 s6388 :: SWord8 = if s29 then s6368 else s6353 s6389 :: SWord8 = if s170 then s6387 else s6388 s6390 :: SWord8 = s6379 + s6389 s6391 :: SBool = s6390 < s6389 s6392 :: SBool = s6390 < s6379 s6393 :: SBool = s6391 | s6392 s6394 :: SWord8 = s6390 >>> 1 s6395 :: SWord8 = s24 | s6394 s6396 :: SWord8 = s26 & s6394 s6397 :: SWord8 = if s6393 then s6395 else s6396 s6398 :: SWord8 = if s6372 then s6383 else s6397 s6399 :: SWord8 = if s6314 then s6364 else s6398 s6400 :: SWord8 = s6299 + s6351 s6401 :: SWord1 = choose [0:0] s6400 s6402 :: SBool = s19 /= s6401 s6403 :: SWord8 = if s6402 then s6308 else s6309 s6404 :: SWord8 = if s22 then s6403 else s6305 s6405 :: SWord1 = choose [0:0] s6404 s6406 :: SBool = s19 /= s6405 s6407 :: SBool = s_2 == s6406 s6408 :: SBool = s6400 < s6351 s6409 :: SBool = s6400 < s6299 s6410 :: SBool = s6408 | s6409 s6411 :: SWord8 = s6400 >>> 1 s6412 :: SWord8 = s24 | s6411 s6413 :: SWord8 = s26 & s6411 s6414 :: SWord8 = if s6410 then s6412 else s6413 s6415 :: SWord1 = choose [0:0] s6414 s6416 :: SBool = s19 /= s6415 s6417 :: SWord8 = s6404 >>> 1 s6418 :: SWord8 = s24 | s6417 s6419 :: SWord8 = s26 & s6417 s6420 :: SWord8 = if s6322 then s6418 else s6419 s6421 :: SWord8 = if s22 then s6420 else s6403 s6422 :: SWord8 = s6421 >>> 1 s6423 :: SWord8 = s24 | s6422 s6424 :: SWord8 = s26 & s6422 s6425 :: SWord8 = if s6416 then s6423 else s6424 s6426 :: SWord8 = if s22 then s6425 else s6420 s6427 :: SWord1 = choose [0:0] s6426 s6428 :: SBool = s19 /= s6427 s6429 :: SBool = s_2 == s6428 s6430 :: SWord8 = s6414 >>> 1 s6431 :: SWord8 = s24 | s6430 s6432 :: SWord8 = s26 & s6430 s6433 :: SWord8 = if s6406 then s6431 else s6432 s6434 :: SWord8 = s6433 >>> 1 s6435 :: SWord8 = s24 | s6434 s6436 :: SWord8 = s26 & s6434 s6437 :: SWord8 = if s6428 then s6435 else s6436 s6438 :: SWord1 = choose [0:0] s6421 s6439 :: SBool = s19 /= s6438 s6440 :: SWord8 = s6426 >>> 1 s6441 :: SWord8 = s24 | s6440 s6442 :: SWord8 = s26 & s6440 s6443 :: SWord8 = if s6439 then s6441 else s6442 s6444 :: SWord8 = if s29 then s6403 else s6351 s6445 :: SWord8 = if s170 then s6420 else s6444 s6446 :: SWord8 = if s29 then s6425 else s6445 s6447 :: SWord8 = if s170 then s6443 else s6446 s6448 :: SWord8 = s6433 + s6447 s6449 :: SBool = s6448 < s6447 s6450 :: SBool = s6448 < s6433 s6451 :: SBool = s6449 | s6450 s6452 :: SWord8 = s6448 >>> 1 s6453 :: SWord8 = s24 | s6452 s6454 :: SWord8 = s26 & s6452 s6455 :: SWord8 = if s6451 then s6453 else s6454 s6456 :: SWord8 = if s6429 then s6437 else s6455 s6457 :: SWord8 = s6414 + s6445 s6458 :: SWord1 = choose [0:0] s6457 s6459 :: SBool = s19 /= s6458 s6460 :: SWord8 = if s6459 then s6423 else s6424 s6461 :: SWord8 = if s22 then s6460 else s6420 s6462 :: SWord1 = choose [0:0] s6461 s6463 :: SBool = s19 /= s6462 s6464 :: SBool = s_2 == s6463 s6465 :: SBool = s6457 < s6445 s6466 :: SBool = s6457 < s6414 s6467 :: SBool = s6465 | s6466 s6468 :: SWord8 = s6457 >>> 1 s6469 :: SWord8 = s24 | s6468 s6470 :: SWord8 = s26 & s6468 s6471 :: SWord8 = if s6467 then s6469 else s6470 s6472 :: SWord8 = s6471 >>> 1 s6473 :: SWord8 = s24 | s6472 s6474 :: SWord8 = s26 & s6472 s6475 :: SWord8 = if s6463 then s6473 else s6474 s6476 :: SWord8 = s6461 >>> 1 s6477 :: SWord8 = s24 | s6476 s6478 :: SWord8 = s26 & s6476 s6479 :: SWord8 = if s6439 then s6477 else s6478 s6480 :: SWord8 = if s29 then s6460 else s6445 s6481 :: SWord8 = if s170 then s6479 else s6480 s6482 :: SWord8 = s6471 + s6481 s6483 :: SBool = s6482 < s6481 s6484 :: SBool = s6482 < s6471 s6485 :: SBool = s6483 | s6484 s6486 :: SWord8 = s6482 >>> 1 s6487 :: SWord8 = s24 | s6486 s6488 :: SWord8 = s26 & s6486 s6489 :: SWord8 = if s6485 then s6487 else s6488 s6490 :: SWord8 = if s6464 then s6475 else s6489 s6491 :: SWord8 = if s6407 then s6456 else s6490 s6492 :: SWord8 = if s6292 then s6399 else s6491 s6493 :: SWord8 = if s6061 then s6284 else s6492 s6494 :: SWord8 = if s5597 then s6053 else s6493 s6495 :: SWord8 = s5582 + s5697 s6496 :: SWord1 = choose [0:0] s6495 s6497 :: SBool = s19 /= s6496 s6498 :: SWord8 = if s6497 then s5591 else s5592 s6499 :: SWord8 = if s22 then s6498 else s5588 s6500 :: SWord1 = choose [0:0] s6499 s6501 :: SBool = s19 /= s6500 s6502 :: SBool = s_2 == s6501 s6503 :: SBool = s6495 < s5697 s6504 :: SBool = s6495 < s5582 s6505 :: SBool = s6503 | s6504 s6506 :: SWord8 = s6495 >>> 1 s6507 :: SWord8 = s24 | s6506 s6508 :: SWord8 = s26 & s6506 s6509 :: SWord8 = if s6505 then s6507 else s6508 s6510 :: SWord1 = choose [0:0] s6509 s6511 :: SBool = s19 /= s6510 s6512 :: SWord8 = s6499 >>> 1 s6513 :: SWord8 = s24 | s6512 s6514 :: SWord8 = s26 & s6512 s6515 :: SWord8 = if s5605 then s6513 else s6514 s6516 :: SWord8 = if s22 then s6515 else s6498 s6517 :: SWord8 = s6516 >>> 1 s6518 :: SWord8 = s24 | s6517 s6519 :: SWord8 = s26 & s6517 s6520 :: SWord8 = if s6511 then s6518 else s6519 s6521 :: SWord8 = if s22 then s6520 else s6515 s6522 :: SWord1 = choose [0:0] s6521 s6523 :: SBool = s19 /= s6522 s6524 :: SBool = s_2 == s6523 s6525 :: SWord8 = s6509 >>> 1 s6526 :: SWord8 = s24 | s6525 s6527 :: SWord8 = s26 & s6525 s6528 :: SWord8 = if s6501 then s6526 else s6527 s6529 :: SWord1 = choose [0:0] s6528 s6530 :: SBool = s19 /= s6529 s6531 :: SWord1 = choose [0:0] s6516 s6532 :: SBool = s19 /= s6531 s6533 :: SWord8 = s6521 >>> 1 s6534 :: SWord8 = s24 | s6533 s6535 :: SWord8 = s26 & s6533 s6536 :: SWord8 = if s6532 then s6534 else s6535 s6537 :: SWord8 = if s22 then s6536 else s6520 s6538 :: SWord8 = s6537 >>> 1 s6539 :: SWord8 = s24 | s6538 s6540 :: SWord8 = s26 & s6538 s6541 :: SWord8 = if s6530 then s6539 else s6540 s6542 :: SWord8 = if s22 then s6541 else s6536 s6543 :: SWord1 = choose [0:0] s6542 s6544 :: SBool = s19 /= s6543 s6545 :: SBool = s_2 == s6544 s6546 :: SWord8 = s6528 >>> 1 s6547 :: SWord8 = s24 | s6546 s6548 :: SWord8 = s26 & s6546 s6549 :: SWord8 = if s6523 then s6547 else s6548 s6550 :: SWord1 = choose [0:0] s6549 s6551 :: SBool = s19 /= s6550 s6552 :: SWord1 = choose [0:0] s6537 s6553 :: SBool = s19 /= s6552 s6554 :: SWord8 = s6542 >>> 1 s6555 :: SWord8 = s24 | s6554 s6556 :: SWord8 = s26 & s6554 s6557 :: SWord8 = if s6553 then s6555 else s6556 s6558 :: SWord8 = if s22 then s6557 else s6541 s6559 :: SWord8 = s6558 >>> 1 s6560 :: SWord8 = s24 | s6559 s6561 :: SWord8 = s26 & s6559 s6562 :: SWord8 = if s6551 then s6560 else s6561 s6563 :: SWord8 = if s22 then s6562 else s6557 s6564 :: SWord1 = choose [0:0] s6563 s6565 :: SBool = s19 /= s6564 s6566 :: SBool = s_2 == s6565 s6567 :: SWord8 = s6549 >>> 1 s6568 :: SWord8 = s24 | s6567 s6569 :: SWord8 = s26 & s6567 s6570 :: SWord8 = if s6544 then s6568 else s6569 s6571 :: SWord1 = choose [0:0] s6570 s6572 :: SBool = s19 /= s6571 s6573 :: SWord1 = choose [0:0] s6558 s6574 :: SBool = s19 /= s6573 s6575 :: SWord8 = s6563 >>> 1 s6576 :: SWord8 = s24 | s6575 s6577 :: SWord8 = s26 & s6575 s6578 :: SWord8 = if s6574 then s6576 else s6577 s6579 :: SWord8 = if s22 then s6578 else s6562 s6580 :: SWord8 = s6579 >>> 1 s6581 :: SWord8 = s24 | s6580 s6582 :: SWord8 = s26 & s6580 s6583 :: SWord8 = if s6572 then s6581 else s6582 s6584 :: SWord8 = if s22 then s6583 else s6578 s6585 :: SWord1 = choose [0:0] s6584 s6586 :: SBool = s19 /= s6585 s6587 :: SBool = s_2 == s6586 s6588 :: SWord8 = s6570 >>> 1 s6589 :: SWord8 = s24 | s6588 s6590 :: SWord8 = s26 & s6588 s6591 :: SWord8 = if s6565 then s6589 else s6590 s6592 :: SWord8 = s6591 >>> 1 s6593 :: SWord8 = s24 | s6592 s6594 :: SWord8 = s26 & s6592 s6595 :: SWord8 = if s6586 then s6593 else s6594 s6596 :: SWord1 = choose [0:0] s6579 s6597 :: SBool = s19 /= s6596 s6598 :: SWord8 = s6584 >>> 1 s6599 :: SWord8 = s24 | s6598 s6600 :: SWord8 = s26 & s6598 s6601 :: SWord8 = if s6597 then s6599 else s6600 s6602 :: SWord8 = if s29 then s6498 else s5697 s6603 :: SWord8 = if s170 then s6515 else s6602 s6604 :: SWord8 = if s29 then s6520 else s6603 s6605 :: SWord8 = if s170 then s6536 else s6604 s6606 :: SWord8 = if s29 then s6541 else s6605 s6607 :: SWord8 = if s170 then s6557 else s6606 s6608 :: SWord8 = if s29 then s6562 else s6607 s6609 :: SWord8 = if s170 then s6578 else s6608 s6610 :: SWord8 = if s29 then s6583 else s6609 s6611 :: SWord8 = if s170 then s6601 else s6610 s6612 :: SWord8 = s6591 + s6611 s6613 :: SBool = s6612 < s6611 s6614 :: SBool = s6612 < s6591 s6615 :: SBool = s6613 | s6614 s6616 :: SWord8 = s6612 >>> 1 s6617 :: SWord8 = s24 | s6616 s6618 :: SWord8 = s26 & s6616 s6619 :: SWord8 = if s6615 then s6617 else s6618 s6620 :: SWord8 = if s6587 then s6595 else s6619 s6621 :: SWord8 = s6570 + s6609 s6622 :: SWord1 = choose [0:0] s6621 s6623 :: SBool = s19 /= s6622 s6624 :: SWord8 = if s6623 then s6581 else s6582 s6625 :: SWord8 = if s22 then s6624 else s6578 s6626 :: SWord1 = choose [0:0] s6625 s6627 :: SBool = s19 /= s6626 s6628 :: SBool = s_2 == s6627 s6629 :: SBool = s6621 < s6609 s6630 :: SBool = s6621 < s6570 s6631 :: SBool = s6629 | s6630 s6632 :: SWord8 = s6621 >>> 1 s6633 :: SWord8 = s24 | s6632 s6634 :: SWord8 = s26 & s6632 s6635 :: SWord8 = if s6631 then s6633 else s6634 s6636 :: SWord8 = s6635 >>> 1 s6637 :: SWord8 = s24 | s6636 s6638 :: SWord8 = s26 & s6636 s6639 :: SWord8 = if s6627 then s6637 else s6638 s6640 :: SWord8 = s6625 >>> 1 s6641 :: SWord8 = s24 | s6640 s6642 :: SWord8 = s26 & s6640 s6643 :: SWord8 = if s6597 then s6641 else s6642 s6644 :: SWord8 = if s29 then s6624 else s6609 s6645 :: SWord8 = if s170 then s6643 else s6644 s6646 :: SWord8 = s6635 + s6645 s6647 :: SBool = s6646 < s6645 s6648 :: SBool = s6646 < s6635 s6649 :: SBool = s6647 | s6648 s6650 :: SWord8 = s6646 >>> 1 s6651 :: SWord8 = s24 | s6650 s6652 :: SWord8 = s26 & s6650 s6653 :: SWord8 = if s6649 then s6651 else s6652 s6654 :: SWord8 = if s6628 then s6639 else s6653 s6655 :: SWord8 = if s6566 then s6620 else s6654 s6656 :: SWord8 = s6549 + s6607 s6657 :: SWord1 = choose [0:0] s6656 s6658 :: SBool = s19 /= s6657 s6659 :: SWord8 = if s6658 then s6560 else s6561 s6660 :: SWord8 = if s22 then s6659 else s6557 s6661 :: SWord1 = choose [0:0] s6660 s6662 :: SBool = s19 /= s6661 s6663 :: SBool = s_2 == s6662 s6664 :: SBool = s6656 < s6607 s6665 :: SBool = s6656 < s6549 s6666 :: SBool = s6664 | s6665 s6667 :: SWord8 = s6656 >>> 1 s6668 :: SWord8 = s24 | s6667 s6669 :: SWord8 = s26 & s6667 s6670 :: SWord8 = if s6666 then s6668 else s6669 s6671 :: SWord1 = choose [0:0] s6670 s6672 :: SBool = s19 /= s6671 s6673 :: SWord8 = s6660 >>> 1 s6674 :: SWord8 = s24 | s6673 s6675 :: SWord8 = s26 & s6673 s6676 :: SWord8 = if s6574 then s6674 else s6675 s6677 :: SWord8 = if s22 then s6676 else s6659 s6678 :: SWord8 = s6677 >>> 1 s6679 :: SWord8 = s24 | s6678 s6680 :: SWord8 = s26 & s6678 s6681 :: SWord8 = if s6672 then s6679 else s6680 s6682 :: SWord8 = if s22 then s6681 else s6676 s6683 :: SWord1 = choose [0:0] s6682 s6684 :: SBool = s19 /= s6683 s6685 :: SBool = s_2 == s6684 s6686 :: SWord8 = s6670 >>> 1 s6687 :: SWord8 = s24 | s6686 s6688 :: SWord8 = s26 & s6686 s6689 :: SWord8 = if s6662 then s6687 else s6688 s6690 :: SWord8 = s6689 >>> 1 s6691 :: SWord8 = s24 | s6690 s6692 :: SWord8 = s26 & s6690 s6693 :: SWord8 = if s6684 then s6691 else s6692 s6694 :: SWord1 = choose [0:0] s6677 s6695 :: SBool = s19 /= s6694 s6696 :: SWord8 = s6682 >>> 1 s6697 :: SWord8 = s24 | s6696 s6698 :: SWord8 = s26 & s6696 s6699 :: SWord8 = if s6695 then s6697 else s6698 s6700 :: SWord8 = if s29 then s6659 else s6607 s6701 :: SWord8 = if s170 then s6676 else s6700 s6702 :: SWord8 = if s29 then s6681 else s6701 s6703 :: SWord8 = if s170 then s6699 else s6702 s6704 :: SWord8 = s6689 + s6703 s6705 :: SBool = s6704 < s6703 s6706 :: SBool = s6704 < s6689 s6707 :: SBool = s6705 | s6706 s6708 :: SWord8 = s6704 >>> 1 s6709 :: SWord8 = s24 | s6708 s6710 :: SWord8 = s26 & s6708 s6711 :: SWord8 = if s6707 then s6709 else s6710 s6712 :: SWord8 = if s6685 then s6693 else s6711 s6713 :: SWord8 = s6670 + s6701 s6714 :: SWord1 = choose [0:0] s6713 s6715 :: SBool = s19 /= s6714 s6716 :: SWord8 = if s6715 then s6679 else s6680 s6717 :: SWord8 = if s22 then s6716 else s6676 s6718 :: SWord1 = choose [0:0] s6717 s6719 :: SBool = s19 /= s6718 s6720 :: SBool = s_2 == s6719 s6721 :: SBool = s6713 < s6701 s6722 :: SBool = s6713 < s6670 s6723 :: SBool = s6721 | s6722 s6724 :: SWord8 = s6713 >>> 1 s6725 :: SWord8 = s24 | s6724 s6726 :: SWord8 = s26 & s6724 s6727 :: SWord8 = if s6723 then s6725 else s6726 s6728 :: SWord8 = s6727 >>> 1 s6729 :: SWord8 = s24 | s6728 s6730 :: SWord8 = s26 & s6728 s6731 :: SWord8 = if s6719 then s6729 else s6730 s6732 :: SWord8 = s6717 >>> 1 s6733 :: SWord8 = s24 | s6732 s6734 :: SWord8 = s26 & s6732 s6735 :: SWord8 = if s6695 then s6733 else s6734 s6736 :: SWord8 = if s29 then s6716 else s6701 s6737 :: SWord8 = if s170 then s6735 else s6736 s6738 :: SWord8 = s6727 + s6737 s6739 :: SBool = s6738 < s6737 s6740 :: SBool = s6738 < s6727 s6741 :: SBool = s6739 | s6740 s6742 :: SWord8 = s6738 >>> 1 s6743 :: SWord8 = s24 | s6742 s6744 :: SWord8 = s26 & s6742 s6745 :: SWord8 = if s6741 then s6743 else s6744 s6746 :: SWord8 = if s6720 then s6731 else s6745 s6747 :: SWord8 = if s6663 then s6712 else s6746 s6748 :: SWord8 = if s6545 then s6655 else s6747 s6749 :: SWord8 = s6528 + s6605 s6750 :: SWord1 = choose [0:0] s6749 s6751 :: SBool = s19 /= s6750 s6752 :: SWord8 = if s6751 then s6539 else s6540 s6753 :: SWord8 = if s22 then s6752 else s6536 s6754 :: SWord1 = choose [0:0] s6753 s6755 :: SBool = s19 /= s6754 s6756 :: SBool = s_2 == s6755 s6757 :: SBool = s6749 < s6605 s6758 :: SBool = s6749 < s6528 s6759 :: SBool = s6757 | s6758 s6760 :: SWord8 = s6749 >>> 1 s6761 :: SWord8 = s24 | s6760 s6762 :: SWord8 = s26 & s6760 s6763 :: SWord8 = if s6759 then s6761 else s6762 s6764 :: SWord1 = choose [0:0] s6763 s6765 :: SBool = s19 /= s6764 s6766 :: SWord8 = s6753 >>> 1 s6767 :: SWord8 = s24 | s6766 s6768 :: SWord8 = s26 & s6766 s6769 :: SWord8 = if s6553 then s6767 else s6768 s6770 :: SWord8 = if s22 then s6769 else s6752 s6771 :: SWord8 = s6770 >>> 1 s6772 :: SWord8 = s24 | s6771 s6773 :: SWord8 = s26 & s6771 s6774 :: SWord8 = if s6765 then s6772 else s6773 s6775 :: SWord8 = if s22 then s6774 else s6769 s6776 :: SWord1 = choose [0:0] s6775 s6777 :: SBool = s19 /= s6776 s6778 :: SBool = s_2 == s6777 s6779 :: SWord8 = s6763 >>> 1 s6780 :: SWord8 = s24 | s6779 s6781 :: SWord8 = s26 & s6779 s6782 :: SWord8 = if s6755 then s6780 else s6781 s6783 :: SWord1 = choose [0:0] s6782 s6784 :: SBool = s19 /= s6783 s6785 :: SWord1 = choose [0:0] s6770 s6786 :: SBool = s19 /= s6785 s6787 :: SWord8 = s6775 >>> 1 s6788 :: SWord8 = s24 | s6787 s6789 :: SWord8 = s26 & s6787 s6790 :: SWord8 = if s6786 then s6788 else s6789 s6791 :: SWord8 = if s22 then s6790 else s6774 s6792 :: SWord8 = s6791 >>> 1 s6793 :: SWord8 = s24 | s6792 s6794 :: SWord8 = s26 & s6792 s6795 :: SWord8 = if s6784 then s6793 else s6794 s6796 :: SWord8 = if s22 then s6795 else s6790 s6797 :: SWord1 = choose [0:0] s6796 s6798 :: SBool = s19 /= s6797 s6799 :: SBool = s_2 == s6798 s6800 :: SWord8 = s6782 >>> 1 s6801 :: SWord8 = s24 | s6800 s6802 :: SWord8 = s26 & s6800 s6803 :: SWord8 = if s6777 then s6801 else s6802 s6804 :: SWord8 = s6803 >>> 1 s6805 :: SWord8 = s24 | s6804 s6806 :: SWord8 = s26 & s6804 s6807 :: SWord8 = if s6798 then s6805 else s6806 s6808 :: SWord1 = choose [0:0] s6791 s6809 :: SBool = s19 /= s6808 s6810 :: SWord8 = s6796 >>> 1 s6811 :: SWord8 = s24 | s6810 s6812 :: SWord8 = s26 & s6810 s6813 :: SWord8 = if s6809 then s6811 else s6812 s6814 :: SWord8 = if s29 then s6752 else s6605 s6815 :: SWord8 = if s170 then s6769 else s6814 s6816 :: SWord8 = if s29 then s6774 else s6815 s6817 :: SWord8 = if s170 then s6790 else s6816 s6818 :: SWord8 = if s29 then s6795 else s6817 s6819 :: SWord8 = if s170 then s6813 else s6818 s6820 :: SWord8 = s6803 + s6819 s6821 :: SBool = s6820 < s6819 s6822 :: SBool = s6820 < s6803 s6823 :: SBool = s6821 | s6822 s6824 :: SWord8 = s6820 >>> 1 s6825 :: SWord8 = s24 | s6824 s6826 :: SWord8 = s26 & s6824 s6827 :: SWord8 = if s6823 then s6825 else s6826 s6828 :: SWord8 = if s6799 then s6807 else s6827 s6829 :: SWord8 = s6782 + s6817 s6830 :: SWord1 = choose [0:0] s6829 s6831 :: SBool = s19 /= s6830 s6832 :: SWord8 = if s6831 then s6793 else s6794 s6833 :: SWord8 = if s22 then s6832 else s6790 s6834 :: SWord1 = choose [0:0] s6833 s6835 :: SBool = s19 /= s6834 s6836 :: SBool = s_2 == s6835 s6837 :: SBool = s6829 < s6817 s6838 :: SBool = s6829 < s6782 s6839 :: SBool = s6837 | s6838 s6840 :: SWord8 = s6829 >>> 1 s6841 :: SWord8 = s24 | s6840 s6842 :: SWord8 = s26 & s6840 s6843 :: SWord8 = if s6839 then s6841 else s6842 s6844 :: SWord8 = s6843 >>> 1 s6845 :: SWord8 = s24 | s6844 s6846 :: SWord8 = s26 & s6844 s6847 :: SWord8 = if s6835 then s6845 else s6846 s6848 :: SWord8 = s6833 >>> 1 s6849 :: SWord8 = s24 | s6848 s6850 :: SWord8 = s26 & s6848 s6851 :: SWord8 = if s6809 then s6849 else s6850 s6852 :: SWord8 = if s29 then s6832 else s6817 s6853 :: SWord8 = if s170 then s6851 else s6852 s6854 :: SWord8 = s6843 + s6853 s6855 :: SBool = s6854 < s6853 s6856 :: SBool = s6854 < s6843 s6857 :: SBool = s6855 | s6856 s6858 :: SWord8 = s6854 >>> 1 s6859 :: SWord8 = s24 | s6858 s6860 :: SWord8 = s26 & s6858 s6861 :: SWord8 = if s6857 then s6859 else s6860 s6862 :: SWord8 = if s6836 then s6847 else s6861 s6863 :: SWord8 = if s6778 then s6828 else s6862 s6864 :: SWord8 = s6763 + s6815 s6865 :: SWord1 = choose [0:0] s6864 s6866 :: SBool = s19 /= s6865 s6867 :: SWord8 = if s6866 then s6772 else s6773 s6868 :: SWord8 = if s22 then s6867 else s6769 s6869 :: SWord1 = choose [0:0] s6868 s6870 :: SBool = s19 /= s6869 s6871 :: SBool = s_2 == s6870 s6872 :: SBool = s6864 < s6815 s6873 :: SBool = s6864 < s6763 s6874 :: SBool = s6872 | s6873 s6875 :: SWord8 = s6864 >>> 1 s6876 :: SWord8 = s24 | s6875 s6877 :: SWord8 = s26 & s6875 s6878 :: SWord8 = if s6874 then s6876 else s6877 s6879 :: SWord1 = choose [0:0] s6878 s6880 :: SBool = s19 /= s6879 s6881 :: SWord8 = s6868 >>> 1 s6882 :: SWord8 = s24 | s6881 s6883 :: SWord8 = s26 & s6881 s6884 :: SWord8 = if s6786 then s6882 else s6883 s6885 :: SWord8 = if s22 then s6884 else s6867 s6886 :: SWord8 = s6885 >>> 1 s6887 :: SWord8 = s24 | s6886 s6888 :: SWord8 = s26 & s6886 s6889 :: SWord8 = if s6880 then s6887 else s6888 s6890 :: SWord8 = if s22 then s6889 else s6884 s6891 :: SWord1 = choose [0:0] s6890 s6892 :: SBool = s19 /= s6891 s6893 :: SBool = s_2 == s6892 s6894 :: SWord8 = s6878 >>> 1 s6895 :: SWord8 = s24 | s6894 s6896 :: SWord8 = s26 & s6894 s6897 :: SWord8 = if s6870 then s6895 else s6896 s6898 :: SWord8 = s6897 >>> 1 s6899 :: SWord8 = s24 | s6898 s6900 :: SWord8 = s26 & s6898 s6901 :: SWord8 = if s6892 then s6899 else s6900 s6902 :: SWord1 = choose [0:0] s6885 s6903 :: SBool = s19 /= s6902 s6904 :: SWord8 = s6890 >>> 1 s6905 :: SWord8 = s24 | s6904 s6906 :: SWord8 = s26 & s6904 s6907 :: SWord8 = if s6903 then s6905 else s6906 s6908 :: SWord8 = if s29 then s6867 else s6815 s6909 :: SWord8 = if s170 then s6884 else s6908 s6910 :: SWord8 = if s29 then s6889 else s6909 s6911 :: SWord8 = if s170 then s6907 else s6910 s6912 :: SWord8 = s6897 + s6911 s6913 :: SBool = s6912 < s6911 s6914 :: SBool = s6912 < s6897 s6915 :: SBool = s6913 | s6914 s6916 :: SWord8 = s6912 >>> 1 s6917 :: SWord8 = s24 | s6916 s6918 :: SWord8 = s26 & s6916 s6919 :: SWord8 = if s6915 then s6917 else s6918 s6920 :: SWord8 = if s6893 then s6901 else s6919 s6921 :: SWord8 = s6878 + s6909 s6922 :: SWord1 = choose [0:0] s6921 s6923 :: SBool = s19 /= s6922 s6924 :: SWord8 = if s6923 then s6887 else s6888 s6925 :: SWord8 = if s22 then s6924 else s6884 s6926 :: SWord1 = choose [0:0] s6925 s6927 :: SBool = s19 /= s6926 s6928 :: SBool = s_2 == s6927 s6929 :: SBool = s6921 < s6909 s6930 :: SBool = s6921 < s6878 s6931 :: SBool = s6929 | s6930 s6932 :: SWord8 = s6921 >>> 1 s6933 :: SWord8 = s24 | s6932 s6934 :: SWord8 = s26 & s6932 s6935 :: SWord8 = if s6931 then s6933 else s6934 s6936 :: SWord8 = s6935 >>> 1 s6937 :: SWord8 = s24 | s6936 s6938 :: SWord8 = s26 & s6936 s6939 :: SWord8 = if s6927 then s6937 else s6938 s6940 :: SWord8 = s6925 >>> 1 s6941 :: SWord8 = s24 | s6940 s6942 :: SWord8 = s26 & s6940 s6943 :: SWord8 = if s6903 then s6941 else s6942 s6944 :: SWord8 = if s29 then s6924 else s6909 s6945 :: SWord8 = if s170 then s6943 else s6944 s6946 :: SWord8 = s6935 + s6945 s6947 :: SBool = s6946 < s6945 s6948 :: SBool = s6946 < s6935 s6949 :: SBool = s6947 | s6948 s6950 :: SWord8 = s6946 >>> 1 s6951 :: SWord8 = s24 | s6950 s6952 :: SWord8 = s26 & s6950 s6953 :: SWord8 = if s6949 then s6951 else s6952 s6954 :: SWord8 = if s6928 then s6939 else s6953 s6955 :: SWord8 = if s6871 then s6920 else s6954 s6956 :: SWord8 = if s6756 then s6863 else s6955 s6957 :: SWord8 = if s6524 then s6748 else s6956 s6958 :: SWord8 = s6509 + s6603 s6959 :: SWord1 = choose [0:0] s6958 s6960 :: SBool = s19 /= s6959 s6961 :: SWord8 = if s6960 then s6518 else s6519 s6962 :: SWord8 = if s22 then s6961 else s6515 s6963 :: SWord1 = choose [0:0] s6962 s6964 :: SBool = s19 /= s6963 s6965 :: SBool = s_2 == s6964 s6966 :: SBool = s6958 < s6603 s6967 :: SBool = s6958 < s6509 s6968 :: SBool = s6966 | s6967 s6969 :: SWord8 = s6958 >>> 1 s6970 :: SWord8 = s24 | s6969 s6971 :: SWord8 = s26 & s6969 s6972 :: SWord8 = if s6968 then s6970 else s6971 s6973 :: SWord1 = choose [0:0] s6972 s6974 :: SBool = s19 /= s6973 s6975 :: SWord8 = s6962 >>> 1 s6976 :: SWord8 = s24 | s6975 s6977 :: SWord8 = s26 & s6975 s6978 :: SWord8 = if s6532 then s6976 else s6977 s6979 :: SWord8 = if s22 then s6978 else s6961 s6980 :: SWord8 = s6979 >>> 1 s6981 :: SWord8 = s24 | s6980 s6982 :: SWord8 = s26 & s6980 s6983 :: SWord8 = if s6974 then s6981 else s6982 s6984 :: SWord8 = if s22 then s6983 else s6978 s6985 :: SWord1 = choose [0:0] s6984 s6986 :: SBool = s19 /= s6985 s6987 :: SBool = s_2 == s6986 s6988 :: SWord8 = s6972 >>> 1 s6989 :: SWord8 = s24 | s6988 s6990 :: SWord8 = s26 & s6988 s6991 :: SWord8 = if s6964 then s6989 else s6990 s6992 :: SWord1 = choose [0:0] s6991 s6993 :: SBool = s19 /= s6992 s6994 :: SWord1 = choose [0:0] s6979 s6995 :: SBool = s19 /= s6994 s6996 :: SWord8 = s6984 >>> 1 s6997 :: SWord8 = s24 | s6996 s6998 :: SWord8 = s26 & s6996 s6999 :: SWord8 = if s6995 then s6997 else s6998 s7000 :: SWord8 = if s22 then s6999 else s6983 s7001 :: SWord8 = s7000 >>> 1 s7002 :: SWord8 = s24 | s7001 s7003 :: SWord8 = s26 & s7001 s7004 :: SWord8 = if s6993 then s7002 else s7003 s7005 :: SWord8 = if s22 then s7004 else s6999 s7006 :: SWord1 = choose [0:0] s7005 s7007 :: SBool = s19 /= s7006 s7008 :: SBool = s_2 == s7007 s7009 :: SWord8 = s6991 >>> 1 s7010 :: SWord8 = s24 | s7009 s7011 :: SWord8 = s26 & s7009 s7012 :: SWord8 = if s6986 then s7010 else s7011 s7013 :: SWord1 = choose [0:0] s7012 s7014 :: SBool = s19 /= s7013 s7015 :: SWord1 = choose [0:0] s7000 s7016 :: SBool = s19 /= s7015 s7017 :: SWord8 = s7005 >>> 1 s7018 :: SWord8 = s24 | s7017 s7019 :: SWord8 = s26 & s7017 s7020 :: SWord8 = if s7016 then s7018 else s7019 s7021 :: SWord8 = if s22 then s7020 else s7004 s7022 :: SWord8 = s7021 >>> 1 s7023 :: SWord8 = s24 | s7022 s7024 :: SWord8 = s26 & s7022 s7025 :: SWord8 = if s7014 then s7023 else s7024 s7026 :: SWord8 = if s22 then s7025 else s7020 s7027 :: SWord1 = choose [0:0] s7026 s7028 :: SBool = s19 /= s7027 s7029 :: SBool = s_2 == s7028 s7030 :: SWord8 = s7012 >>> 1 s7031 :: SWord8 = s24 | s7030 s7032 :: SWord8 = s26 & s7030 s7033 :: SWord8 = if s7007 then s7031 else s7032 s7034 :: SWord8 = s7033 >>> 1 s7035 :: SWord8 = s24 | s7034 s7036 :: SWord8 = s26 & s7034 s7037 :: SWord8 = if s7028 then s7035 else s7036 s7038 :: SWord1 = choose [0:0] s7021 s7039 :: SBool = s19 /= s7038 s7040 :: SWord8 = s7026 >>> 1 s7041 :: SWord8 = s24 | s7040 s7042 :: SWord8 = s26 & s7040 s7043 :: SWord8 = if s7039 then s7041 else s7042 s7044 :: SWord8 = if s29 then s6961 else s6603 s7045 :: SWord8 = if s170 then s6978 else s7044 s7046 :: SWord8 = if s29 then s6983 else s7045 s7047 :: SWord8 = if s170 then s6999 else s7046 s7048 :: SWord8 = if s29 then s7004 else s7047 s7049 :: SWord8 = if s170 then s7020 else s7048 s7050 :: SWord8 = if s29 then s7025 else s7049 s7051 :: SWord8 = if s170 then s7043 else s7050 s7052 :: SWord8 = s7033 + s7051 s7053 :: SBool = s7052 < s7051 s7054 :: SBool = s7052 < s7033 s7055 :: SBool = s7053 | s7054 s7056 :: SWord8 = s7052 >>> 1 s7057 :: SWord8 = s24 | s7056 s7058 :: SWord8 = s26 & s7056 s7059 :: SWord8 = if s7055 then s7057 else s7058 s7060 :: SWord8 = if s7029 then s7037 else s7059 s7061 :: SWord8 = s7012 + s7049 s7062 :: SWord1 = choose [0:0] s7061 s7063 :: SBool = s19 /= s7062 s7064 :: SWord8 = if s7063 then s7023 else s7024 s7065 :: SWord8 = if s22 then s7064 else s7020 s7066 :: SWord1 = choose [0:0] s7065 s7067 :: SBool = s19 /= s7066 s7068 :: SBool = s_2 == s7067 s7069 :: SBool = s7061 < s7049 s7070 :: SBool = s7061 < s7012 s7071 :: SBool = s7069 | s7070 s7072 :: SWord8 = s7061 >>> 1 s7073 :: SWord8 = s24 | s7072 s7074 :: SWord8 = s26 & s7072 s7075 :: SWord8 = if s7071 then s7073 else s7074 s7076 :: SWord8 = s7075 >>> 1 s7077 :: SWord8 = s24 | s7076 s7078 :: SWord8 = s26 & s7076 s7079 :: SWord8 = if s7067 then s7077 else s7078 s7080 :: SWord8 = s7065 >>> 1 s7081 :: SWord8 = s24 | s7080 s7082 :: SWord8 = s26 & s7080 s7083 :: SWord8 = if s7039 then s7081 else s7082 s7084 :: SWord8 = if s29 then s7064 else s7049 s7085 :: SWord8 = if s170 then s7083 else s7084 s7086 :: SWord8 = s7075 + s7085 s7087 :: SBool = s7086 < s7085 s7088 :: SBool = s7086 < s7075 s7089 :: SBool = s7087 | s7088 s7090 :: SWord8 = s7086 >>> 1 s7091 :: SWord8 = s24 | s7090 s7092 :: SWord8 = s26 & s7090 s7093 :: SWord8 = if s7089 then s7091 else s7092 s7094 :: SWord8 = if s7068 then s7079 else s7093 s7095 :: SWord8 = if s7008 then s7060 else s7094 s7096 :: SWord8 = s6991 + s7047 s7097 :: SWord1 = choose [0:0] s7096 s7098 :: SBool = s19 /= s7097 s7099 :: SWord8 = if s7098 then s7002 else s7003 s7100 :: SWord8 = if s22 then s7099 else s6999 s7101 :: SWord1 = choose [0:0] s7100 s7102 :: SBool = s19 /= s7101 s7103 :: SBool = s_2 == s7102 s7104 :: SBool = s7096 < s7047 s7105 :: SBool = s7096 < s6991 s7106 :: SBool = s7104 | s7105 s7107 :: SWord8 = s7096 >>> 1 s7108 :: SWord8 = s24 | s7107 s7109 :: SWord8 = s26 & s7107 s7110 :: SWord8 = if s7106 then s7108 else s7109 s7111 :: SWord1 = choose [0:0] s7110 s7112 :: SBool = s19 /= s7111 s7113 :: SWord8 = s7100 >>> 1 s7114 :: SWord8 = s24 | s7113 s7115 :: SWord8 = s26 & s7113 s7116 :: SWord8 = if s7016 then s7114 else s7115 s7117 :: SWord8 = if s22 then s7116 else s7099 s7118 :: SWord8 = s7117 >>> 1 s7119 :: SWord8 = s24 | s7118 s7120 :: SWord8 = s26 & s7118 s7121 :: SWord8 = if s7112 then s7119 else s7120 s7122 :: SWord8 = if s22 then s7121 else s7116 s7123 :: SWord1 = choose [0:0] s7122 s7124 :: SBool = s19 /= s7123 s7125 :: SBool = s_2 == s7124 s7126 :: SWord8 = s7110 >>> 1 s7127 :: SWord8 = s24 | s7126 s7128 :: SWord8 = s26 & s7126 s7129 :: SWord8 = if s7102 then s7127 else s7128 s7130 :: SWord8 = s7129 >>> 1 s7131 :: SWord8 = s24 | s7130 s7132 :: SWord8 = s26 & s7130 s7133 :: SWord8 = if s7124 then s7131 else s7132 s7134 :: SWord1 = choose [0:0] s7117 s7135 :: SBool = s19 /= s7134 s7136 :: SWord8 = s7122 >>> 1 s7137 :: SWord8 = s24 | s7136 s7138 :: SWord8 = s26 & s7136 s7139 :: SWord8 = if s7135 then s7137 else s7138 s7140 :: SWord8 = if s29 then s7099 else s7047 s7141 :: SWord8 = if s170 then s7116 else s7140 s7142 :: SWord8 = if s29 then s7121 else s7141 s7143 :: SWord8 = if s170 then s7139 else s7142 s7144 :: SWord8 = s7129 + s7143 s7145 :: SBool = s7144 < s7143 s7146 :: SBool = s7144 < s7129 s7147 :: SBool = s7145 | s7146 s7148 :: SWord8 = s7144 >>> 1 s7149 :: SWord8 = s24 | s7148 s7150 :: SWord8 = s26 & s7148 s7151 :: SWord8 = if s7147 then s7149 else s7150 s7152 :: SWord8 = if s7125 then s7133 else s7151 s7153 :: SWord8 = s7110 + s7141 s7154 :: SWord1 = choose [0:0] s7153 s7155 :: SBool = s19 /= s7154 s7156 :: SWord8 = if s7155 then s7119 else s7120 s7157 :: SWord8 = if s22 then s7156 else s7116 s7158 :: SWord1 = choose [0:0] s7157 s7159 :: SBool = s19 /= s7158 s7160 :: SBool = s_2 == s7159 s7161 :: SBool = s7153 < s7141 s7162 :: SBool = s7153 < s7110 s7163 :: SBool = s7161 | s7162 s7164 :: SWord8 = s7153 >>> 1 s7165 :: SWord8 = s24 | s7164 s7166 :: SWord8 = s26 & s7164 s7167 :: SWord8 = if s7163 then s7165 else s7166 s7168 :: SWord8 = s7167 >>> 1 s7169 :: SWord8 = s24 | s7168 s7170 :: SWord8 = s26 & s7168 s7171 :: SWord8 = if s7159 then s7169 else s7170 s7172 :: SWord8 = s7157 >>> 1 s7173 :: SWord8 = s24 | s7172 s7174 :: SWord8 = s26 & s7172 s7175 :: SWord8 = if s7135 then s7173 else s7174 s7176 :: SWord8 = if s29 then s7156 else s7141 s7177 :: SWord8 = if s170 then s7175 else s7176 s7178 :: SWord8 = s7167 + s7177 s7179 :: SBool = s7178 < s7177 s7180 :: SBool = s7178 < s7167 s7181 :: SBool = s7179 | s7180 s7182 :: SWord8 = s7178 >>> 1 s7183 :: SWord8 = s24 | s7182 s7184 :: SWord8 = s26 & s7182 s7185 :: SWord8 = if s7181 then s7183 else s7184 s7186 :: SWord8 = if s7160 then s7171 else s7185 s7187 :: SWord8 = if s7103 then s7152 else s7186 s7188 :: SWord8 = if s6987 then s7095 else s7187 s7189 :: SWord8 = s6972 + s7045 s7190 :: SWord1 = choose [0:0] s7189 s7191 :: SBool = s19 /= s7190 s7192 :: SWord8 = if s7191 then s6981 else s6982 s7193 :: SWord8 = if s22 then s7192 else s6978 s7194 :: SWord1 = choose [0:0] s7193 s7195 :: SBool = s19 /= s7194 s7196 :: SBool = s_2 == s7195 s7197 :: SBool = s7189 < s7045 s7198 :: SBool = s7189 < s6972 s7199 :: SBool = s7197 | s7198 s7200 :: SWord8 = s7189 >>> 1 s7201 :: SWord8 = s24 | s7200 s7202 :: SWord8 = s26 & s7200 s7203 :: SWord8 = if s7199 then s7201 else s7202 s7204 :: SWord1 = choose [0:0] s7203 s7205 :: SBool = s19 /= s7204 s7206 :: SWord8 = s7193 >>> 1 s7207 :: SWord8 = s24 | s7206 s7208 :: SWord8 = s26 & s7206 s7209 :: SWord8 = if s6995 then s7207 else s7208 s7210 :: SWord8 = if s22 then s7209 else s7192 s7211 :: SWord8 = s7210 >>> 1 s7212 :: SWord8 = s24 | s7211 s7213 :: SWord8 = s26 & s7211 s7214 :: SWord8 = if s7205 then s7212 else s7213 s7215 :: SWord8 = if s22 then s7214 else s7209 s7216 :: SWord1 = choose [0:0] s7215 s7217 :: SBool = s19 /= s7216 s7218 :: SBool = s_2 == s7217 s7219 :: SWord8 = s7203 >>> 1 s7220 :: SWord8 = s24 | s7219 s7221 :: SWord8 = s26 & s7219 s7222 :: SWord8 = if s7195 then s7220 else s7221 s7223 :: SWord1 = choose [0:0] s7222 s7224 :: SBool = s19 /= s7223 s7225 :: SWord1 = choose [0:0] s7210 s7226 :: SBool = s19 /= s7225 s7227 :: SWord8 = s7215 >>> 1 s7228 :: SWord8 = s24 | s7227 s7229 :: SWord8 = s26 & s7227 s7230 :: SWord8 = if s7226 then s7228 else s7229 s7231 :: SWord8 = if s22 then s7230 else s7214 s7232 :: SWord8 = s7231 >>> 1 s7233 :: SWord8 = s24 | s7232 s7234 :: SWord8 = s26 & s7232 s7235 :: SWord8 = if s7224 then s7233 else s7234 s7236 :: SWord8 = if s22 then s7235 else s7230 s7237 :: SWord1 = choose [0:0] s7236 s7238 :: SBool = s19 /= s7237 s7239 :: SBool = s_2 == s7238 s7240 :: SWord8 = s7222 >>> 1 s7241 :: SWord8 = s24 | s7240 s7242 :: SWord8 = s26 & s7240 s7243 :: SWord8 = if s7217 then s7241 else s7242 s7244 :: SWord8 = s7243 >>> 1 s7245 :: SWord8 = s24 | s7244 s7246 :: SWord8 = s26 & s7244 s7247 :: SWord8 = if s7238 then s7245 else s7246 s7248 :: SWord1 = choose [0:0] s7231 s7249 :: SBool = s19 /= s7248 s7250 :: SWord8 = s7236 >>> 1 s7251 :: SWord8 = s24 | s7250 s7252 :: SWord8 = s26 & s7250 s7253 :: SWord8 = if s7249 then s7251 else s7252 s7254 :: SWord8 = if s29 then s7192 else s7045 s7255 :: SWord8 = if s170 then s7209 else s7254 s7256 :: SWord8 = if s29 then s7214 else s7255 s7257 :: SWord8 = if s170 then s7230 else s7256 s7258 :: SWord8 = if s29 then s7235 else s7257 s7259 :: SWord8 = if s170 then s7253 else s7258 s7260 :: SWord8 = s7243 + s7259 s7261 :: SBool = s7260 < s7259 s7262 :: SBool = s7260 < s7243 s7263 :: SBool = s7261 | s7262 s7264 :: SWord8 = s7260 >>> 1 s7265 :: SWord8 = s24 | s7264 s7266 :: SWord8 = s26 & s7264 s7267 :: SWord8 = if s7263 then s7265 else s7266 s7268 :: SWord8 = if s7239 then s7247 else s7267 s7269 :: SWord8 = s7222 + s7257 s7270 :: SWord1 = choose [0:0] s7269 s7271 :: SBool = s19 /= s7270 s7272 :: SWord8 = if s7271 then s7233 else s7234 s7273 :: SWord8 = if s22 then s7272 else s7230 s7274 :: SWord1 = choose [0:0] s7273 s7275 :: SBool = s19 /= s7274 s7276 :: SBool = s_2 == s7275 s7277 :: SBool = s7269 < s7257 s7278 :: SBool = s7269 < s7222 s7279 :: SBool = s7277 | s7278 s7280 :: SWord8 = s7269 >>> 1 s7281 :: SWord8 = s24 | s7280 s7282 :: SWord8 = s26 & s7280 s7283 :: SWord8 = if s7279 then s7281 else s7282 s7284 :: SWord8 = s7283 >>> 1 s7285 :: SWord8 = s24 | s7284 s7286 :: SWord8 = s26 & s7284 s7287 :: SWord8 = if s7275 then s7285 else s7286 s7288 :: SWord8 = s7273 >>> 1 s7289 :: SWord8 = s24 | s7288 s7290 :: SWord8 = s26 & s7288 s7291 :: SWord8 = if s7249 then s7289 else s7290 s7292 :: SWord8 = if s29 then s7272 else s7257 s7293 :: SWord8 = if s170 then s7291 else s7292 s7294 :: SWord8 = s7283 + s7293 s7295 :: SBool = s7294 < s7293 s7296 :: SBool = s7294 < s7283 s7297 :: SBool = s7295 | s7296 s7298 :: SWord8 = s7294 >>> 1 s7299 :: SWord8 = s24 | s7298 s7300 :: SWord8 = s26 & s7298 s7301 :: SWord8 = if s7297 then s7299 else s7300 s7302 :: SWord8 = if s7276 then s7287 else s7301 s7303 :: SWord8 = if s7218 then s7268 else s7302 s7304 :: SWord8 = s7203 + s7255 s7305 :: SWord1 = choose [0:0] s7304 s7306 :: SBool = s19 /= s7305 s7307 :: SWord8 = if s7306 then s7212 else s7213 s7308 :: SWord8 = if s22 then s7307 else s7209 s7309 :: SWord1 = choose [0:0] s7308 s7310 :: SBool = s19 /= s7309 s7311 :: SBool = s_2 == s7310 s7312 :: SBool = s7304 < s7255 s7313 :: SBool = s7304 < s7203 s7314 :: SBool = s7312 | s7313 s7315 :: SWord8 = s7304 >>> 1 s7316 :: SWord8 = s24 | s7315 s7317 :: SWord8 = s26 & s7315 s7318 :: SWord8 = if s7314 then s7316 else s7317 s7319 :: SWord1 = choose [0:0] s7318 s7320 :: SBool = s19 /= s7319 s7321 :: SWord8 = s7308 >>> 1 s7322 :: SWord8 = s24 | s7321 s7323 :: SWord8 = s26 & s7321 s7324 :: SWord8 = if s7226 then s7322 else s7323 s7325 :: SWord8 = if s22 then s7324 else s7307 s7326 :: SWord8 = s7325 >>> 1 s7327 :: SWord8 = s24 | s7326 s7328 :: SWord8 = s26 & s7326 s7329 :: SWord8 = if s7320 then s7327 else s7328 s7330 :: SWord8 = if s22 then s7329 else s7324 s7331 :: SWord1 = choose [0:0] s7330 s7332 :: SBool = s19 /= s7331 s7333 :: SBool = s_2 == s7332 s7334 :: SWord8 = s7318 >>> 1 s7335 :: SWord8 = s24 | s7334 s7336 :: SWord8 = s26 & s7334 s7337 :: SWord8 = if s7310 then s7335 else s7336 s7338 :: SWord8 = s7337 >>> 1 s7339 :: SWord8 = s24 | s7338 s7340 :: SWord8 = s26 & s7338 s7341 :: SWord8 = if s7332 then s7339 else s7340 s7342 :: SWord1 = choose [0:0] s7325 s7343 :: SBool = s19 /= s7342 s7344 :: SWord8 = s7330 >>> 1 s7345 :: SWord8 = s24 | s7344 s7346 :: SWord8 = s26 & s7344 s7347 :: SWord8 = if s7343 then s7345 else s7346 s7348 :: SWord8 = if s29 then s7307 else s7255 s7349 :: SWord8 = if s170 then s7324 else s7348 s7350 :: SWord8 = if s29 then s7329 else s7349 s7351 :: SWord8 = if s170 then s7347 else s7350 s7352 :: SWord8 = s7337 + s7351 s7353 :: SBool = s7352 < s7351 s7354 :: SBool = s7352 < s7337 s7355 :: SBool = s7353 | s7354 s7356 :: SWord8 = s7352 >>> 1 s7357 :: SWord8 = s24 | s7356 s7358 :: SWord8 = s26 & s7356 s7359 :: SWord8 = if s7355 then s7357 else s7358 s7360 :: SWord8 = if s7333 then s7341 else s7359 s7361 :: SWord8 = s7318 + s7349 s7362 :: SWord1 = choose [0:0] s7361 s7363 :: SBool = s19 /= s7362 s7364 :: SWord8 = if s7363 then s7327 else s7328 s7365 :: SWord8 = if s22 then s7364 else s7324 s7366 :: SWord1 = choose [0:0] s7365 s7367 :: SBool = s19 /= s7366 s7368 :: SBool = s_2 == s7367 s7369 :: SBool = s7361 < s7349 s7370 :: SBool = s7361 < s7318 s7371 :: SBool = s7369 | s7370 s7372 :: SWord8 = s7361 >>> 1 s7373 :: SWord8 = s24 | s7372 s7374 :: SWord8 = s26 & s7372 s7375 :: SWord8 = if s7371 then s7373 else s7374 s7376 :: SWord8 = s7375 >>> 1 s7377 :: SWord8 = s24 | s7376 s7378 :: SWord8 = s26 & s7376 s7379 :: SWord8 = if s7367 then s7377 else s7378 s7380 :: SWord8 = s7365 >>> 1 s7381 :: SWord8 = s24 | s7380 s7382 :: SWord8 = s26 & s7380 s7383 :: SWord8 = if s7343 then s7381 else s7382 s7384 :: SWord8 = if s29 then s7364 else s7349 s7385 :: SWord8 = if s170 then s7383 else s7384 s7386 :: SWord8 = s7375 + s7385 s7387 :: SBool = s7386 < s7385 s7388 :: SBool = s7386 < s7375 s7389 :: SBool = s7387 | s7388 s7390 :: SWord8 = s7386 >>> 1 s7391 :: SWord8 = s24 | s7390 s7392 :: SWord8 = s26 & s7390 s7393 :: SWord8 = if s7389 then s7391 else s7392 s7394 :: SWord8 = if s7368 then s7379 else s7393 s7395 :: SWord8 = if s7311 then s7360 else s7394 s7396 :: SWord8 = if s7196 then s7303 else s7395 s7397 :: SWord8 = if s6965 then s7188 else s7396 s7398 :: SWord8 = if s6502 then s6957 else s7397 s7399 :: SWord8 = if s5575 then s6494 else s7398 s7400 :: SWord8 = if s3725 then s5567 else s7399 s7401 :: SWord8 = if s21 then s3717 else s7400 s7402 :: SWord16 = s17 # s7401 s7403 :: SWord16 = s16 * s7402 s7404 :: SWord1 = choose [0:0] s165 s7405 :: SBool = s19 /= s7404 s7406 :: SWord8 = if s22 then s176 else s157 s7407 :: SWord8 = s7406 >>> 1 s7408 :: SWord8 = s24 | s7407 s7409 :: SWord8 = s26 & s7407 s7410 :: SWord8 = if s7405 then s7408 else s7409 s7411 :: SWord1 = choose [0:0] s193 s7412 :: SBool = s19 /= s7411 s7413 :: SWord8 = if s7412 then s7408 else s7409 s7414 :: SWord8 = if s161 then s7410 else s7413 s7415 :: SWord1 = choose [0:0] s216 s7416 :: SBool = s19 /= s7415 s7417 :: SWord8 = if s22 then s224 else s205 s7418 :: SWord8 = s7417 >>> 1 s7419 :: SWord8 = s24 | s7418 s7420 :: SWord8 = s26 & s7418 s7421 :: SWord8 = if s7416 then s7419 else s7420 s7422 :: SWord1 = choose [0:0] s227 s7423 :: SBool = s19 /= s7422 s7424 :: SWord8 = if s7423 then s7419 else s7420 s7425 :: SWord8 = if s209 then s7421 else s7424 s7426 :: SWord8 = if s140 then s7414 else s7425 s7427 :: SWord1 = choose [0:0] s270 s7428 :: SBool = s19 /= s7427 s7429 :: SWord8 = if s22 then s280 else s262 s7430 :: SWord8 = s7429 >>> 1 s7431 :: SWord8 = s24 | s7430 s7432 :: SWord8 = s26 & s7430 s7433 :: SWord8 = if s7428 then s7431 else s7432 s7434 :: SWord1 = choose [0:0] s285 s7435 :: SBool = s19 /= s7434 s7436 :: SWord8 = if s7435 then s7431 else s7432 s7437 :: SWord8 = if s266 then s7433 else s7436 s7438 :: SWord1 = choose [0:0] s308 s7439 :: SBool = s19 /= s7438 s7440 :: SWord8 = if s22 then s316 else s297 s7441 :: SWord8 = s7440 >>> 1 s7442 :: SWord8 = s24 | s7441 s7443 :: SWord8 = s26 & s7441 s7444 :: SWord8 = if s7439 then s7442 else s7443 s7445 :: SWord1 = choose [0:0] s319 s7446 :: SBool = s19 /= s7445 s7447 :: SWord8 = if s7446 then s7442 else s7443 s7448 :: SWord8 = if s301 then s7444 else s7447 s7449 :: SWord8 = if s244 then s7437 else s7448 s7450 :: SWord8 = if s119 then s7426 else s7449 s7451 :: SWord1 = choose [0:0] s384 s7452 :: SBool = s19 /= s7451 s7453 :: SWord8 = if s22 then s394 else s376 s7454 :: SWord8 = s7453 >>> 1 s7455 :: SWord8 = s24 | s7454 s7456 :: SWord8 = s26 & s7454 s7457 :: SWord8 = if s7452 then s7455 else s7456 s7458 :: SWord1 = choose [0:0] s401 s7459 :: SBool = s19 /= s7458 s7460 :: SWord8 = if s7459 then s7455 else s7456 s7461 :: SWord8 = if s380 then s7457 else s7460 s7462 :: SWord1 = choose [0:0] s424 s7463 :: SBool = s19 /= s7462 s7464 :: SWord8 = if s22 then s432 else s413 s7465 :: SWord8 = s7464 >>> 1 s7466 :: SWord8 = s24 | s7465 s7467 :: SWord8 = s26 & s7465 s7468 :: SWord8 = if s7463 then s7466 else s7467 s7469 :: SWord1 = choose [0:0] s435 s7470 :: SBool = s19 /= s7469 s7471 :: SWord8 = if s7470 then s7466 else s7467 s7472 :: SWord8 = if s417 then s7468 else s7471 s7473 :: SWord8 = if s359 then s7461 else s7472 s7474 :: SWord1 = choose [0:0] s478 s7475 :: SBool = s19 /= s7474 s7476 :: SWord8 = if s22 then s488 else s470 s7477 :: SWord8 = s7476 >>> 1 s7478 :: SWord8 = s24 | s7477 s7479 :: SWord8 = s26 & s7477 s7480 :: SWord8 = if s7475 then s7478 else s7479 s7481 :: SWord1 = choose [0:0] s493 s7482 :: SBool = s19 /= s7481 s7483 :: SWord8 = if s7482 then s7478 else s7479 s7484 :: SWord8 = if s474 then s7480 else s7483 s7485 :: SWord1 = choose [0:0] s516 s7486 :: SBool = s19 /= s7485 s7487 :: SWord8 = if s22 then s524 else s505 s7488 :: SWord8 = s7487 >>> 1 s7489 :: SWord8 = s24 | s7488 s7490 :: SWord8 = s26 & s7488 s7491 :: SWord8 = if s7486 then s7489 else s7490 s7492 :: SWord1 = choose [0:0] s527 s7493 :: SBool = s19 /= s7492 s7494 :: SWord8 = if s7493 then s7489 else s7490 s7495 :: SWord8 = if s509 then s7491 else s7494 s7496 :: SWord8 = if s452 then s7484 else s7495 s7497 :: SWord8 = if s337 then s7473 else s7496 s7498 :: SWord8 = if s98 then s7450 else s7497 s7499 :: SWord1 = choose [0:0] s614 s7500 :: SBool = s19 /= s7499 s7501 :: SWord8 = if s22 then s624 else s606 s7502 :: SWord8 = s7501 >>> 1 s7503 :: SWord8 = s24 | s7502 s7504 :: SWord8 = s26 & s7502 s7505 :: SWord8 = if s7500 then s7503 else s7504 s7506 :: SWord1 = choose [0:0] s633 s7507 :: SBool = s19 /= s7506 s7508 :: SWord8 = if s7507 then s7503 else s7504 s7509 :: SWord8 = if s610 then s7505 else s7508 s7510 :: SWord1 = choose [0:0] s656 s7511 :: SBool = s19 /= s7510 s7512 :: SWord8 = if s22 then s664 else s645 s7513 :: SWord8 = s7512 >>> 1 s7514 :: SWord8 = s24 | s7513 s7515 :: SWord8 = s26 & s7513 s7516 :: SWord8 = if s7511 then s7514 else s7515 s7517 :: SWord1 = choose [0:0] s667 s7518 :: SBool = s19 /= s7517 s7519 :: SWord8 = if s7518 then s7514 else s7515 s7520 :: SWord8 = if s649 then s7516 else s7519 s7521 :: SWord8 = if s589 then s7509 else s7520 s7522 :: SWord1 = choose [0:0] s710 s7523 :: SBool = s19 /= s7522 s7524 :: SWord8 = if s22 then s720 else s702 s7525 :: SWord8 = s7524 >>> 1 s7526 :: SWord8 = s24 | s7525 s7527 :: SWord8 = s26 & s7525 s7528 :: SWord8 = if s7523 then s7526 else s7527 s7529 :: SWord1 = choose [0:0] s725 s7530 :: SBool = s19 /= s7529 s7531 :: SWord8 = if s7530 then s7526 else s7527 s7532 :: SWord8 = if s706 then s7528 else s7531 s7533 :: SWord1 = choose [0:0] s748 s7534 :: SBool = s19 /= s7533 s7535 :: SWord8 = if s22 then s756 else s737 s7536 :: SWord8 = s7535 >>> 1 s7537 :: SWord8 = s24 | s7536 s7538 :: SWord8 = s26 & s7536 s7539 :: SWord8 = if s7534 then s7537 else s7538 s7540 :: SWord1 = choose [0:0] s759 s7541 :: SBool = s19 /= s7540 s7542 :: SWord8 = if s7541 then s7537 else s7538 s7543 :: SWord8 = if s741 then s7539 else s7542 s7544 :: SWord8 = if s684 then s7532 else s7543 s7545 :: SWord8 = if s568 then s7521 else s7544 s7546 :: SWord1 = choose [0:0] s824 s7547 :: SBool = s19 /= s7546 s7548 :: SWord8 = if s22 then s834 else s816 s7549 :: SWord8 = s7548 >>> 1 s7550 :: SWord8 = s24 | s7549 s7551 :: SWord8 = s26 & s7549 s7552 :: SWord8 = if s7547 then s7550 else s7551 s7553 :: SWord1 = choose [0:0] s841 s7554 :: SBool = s19 /= s7553 s7555 :: SWord8 = if s7554 then s7550 else s7551 s7556 :: SWord8 = if s820 then s7552 else s7555 s7557 :: SWord1 = choose [0:0] s864 s7558 :: SBool = s19 /= s7557 s7559 :: SWord8 = if s22 then s872 else s853 s7560 :: SWord8 = s7559 >>> 1 s7561 :: SWord8 = s24 | s7560 s7562 :: SWord8 = s26 & s7560 s7563 :: SWord8 = if s7558 then s7561 else s7562 s7564 :: SWord1 = choose [0:0] s875 s7565 :: SBool = s19 /= s7564 s7566 :: SWord8 = if s7565 then s7561 else s7562 s7567 :: SWord8 = if s857 then s7563 else s7566 s7568 :: SWord8 = if s799 then s7556 else s7567 s7569 :: SWord1 = choose [0:0] s918 s7570 :: SBool = s19 /= s7569 s7571 :: SWord8 = if s22 then s928 else s910 s7572 :: SWord8 = s7571 >>> 1 s7573 :: SWord8 = s24 | s7572 s7574 :: SWord8 = s26 & s7572 s7575 :: SWord8 = if s7570 then s7573 else s7574 s7576 :: SWord1 = choose [0:0] s933 s7577 :: SBool = s19 /= s7576 s7578 :: SWord8 = if s7577 then s7573 else s7574 s7579 :: SWord8 = if s914 then s7575 else s7578 s7580 :: SWord1 = choose [0:0] s956 s7581 :: SBool = s19 /= s7580 s7582 :: SWord8 = if s22 then s964 else s945 s7583 :: SWord8 = s7582 >>> 1 s7584 :: SWord8 = s24 | s7583 s7585 :: SWord8 = s26 & s7583 s7586 :: SWord8 = if s7581 then s7584 else s7585 s7587 :: SWord1 = choose [0:0] s967 s7588 :: SBool = s19 /= s7587 s7589 :: SWord8 = if s7588 then s7584 else s7585 s7590 :: SWord8 = if s949 then s7586 else s7589 s7591 :: SWord8 = if s892 then s7579 else s7590 s7592 :: SWord8 = if s777 then s7568 else s7591 s7593 :: SWord8 = if s546 then s7545 else s7592 s7594 :: SWord8 = if s77 then s7498 else s7593 s7595 :: SWord1 = choose [0:0] s1076 s7596 :: SBool = s19 /= s7595 s7597 :: SWord8 = if s22 then s1086 else s1068 s7598 :: SWord8 = s7597 >>> 1 s7599 :: SWord8 = s24 | s7598 s7600 :: SWord8 = s26 & s7598 s7601 :: SWord8 = if s7596 then s7599 else s7600 s7602 :: SWord1 = choose [0:0] s1097 s7603 :: SBool = s19 /= s7602 s7604 :: SWord8 = if s7603 then s7599 else s7600 s7605 :: SWord8 = if s1072 then s7601 else s7604 s7606 :: SWord1 = choose [0:0] s1120 s7607 :: SBool = s19 /= s7606 s7608 :: SWord8 = if s22 then s1128 else s1109 s7609 :: SWord8 = s7608 >>> 1 s7610 :: SWord8 = s24 | s7609 s7611 :: SWord8 = s26 & s7609 s7612 :: SWord8 = if s7607 then s7610 else s7611 s7613 :: SWord1 = choose [0:0] s1131 s7614 :: SBool = s19 /= s7613 s7615 :: SWord8 = if s7614 then s7610 else s7611 s7616 :: SWord8 = if s1113 then s7612 else s7615 s7617 :: SWord8 = if s1051 then s7605 else s7616 s7618 :: SWord1 = choose [0:0] s1174 s7619 :: SBool = s19 /= s7618 s7620 :: SWord8 = if s22 then s1184 else s1166 s7621 :: SWord8 = s7620 >>> 1 s7622 :: SWord8 = s24 | s7621 s7623 :: SWord8 = s26 & s7621 s7624 :: SWord8 = if s7619 then s7622 else s7623 s7625 :: SWord1 = choose [0:0] s1189 s7626 :: SBool = s19 /= s7625 s7627 :: SWord8 = if s7626 then s7622 else s7623 s7628 :: SWord8 = if s1170 then s7624 else s7627 s7629 :: SWord1 = choose [0:0] s1212 s7630 :: SBool = s19 /= s7629 s7631 :: SWord8 = if s22 then s1220 else s1201 s7632 :: SWord8 = s7631 >>> 1 s7633 :: SWord8 = s24 | s7632 s7634 :: SWord8 = s26 & s7632 s7635 :: SWord8 = if s7630 then s7633 else s7634 s7636 :: SWord1 = choose [0:0] s1223 s7637 :: SBool = s19 /= s7636 s7638 :: SWord8 = if s7637 then s7633 else s7634 s7639 :: SWord8 = if s1205 then s7635 else s7638 s7640 :: SWord8 = if s1148 then s7628 else s7639 s7641 :: SWord8 = if s1030 then s7617 else s7640 s7642 :: SWord1 = choose [0:0] s1288 s7643 :: SBool = s19 /= s7642 s7644 :: SWord8 = if s22 then s1298 else s1280 s7645 :: SWord8 = s7644 >>> 1 s7646 :: SWord8 = s24 | s7645 s7647 :: SWord8 = s26 & s7645 s7648 :: SWord8 = if s7643 then s7646 else s7647 s7649 :: SWord1 = choose [0:0] s1305 s7650 :: SBool = s19 /= s7649 s7651 :: SWord8 = if s7650 then s7646 else s7647 s7652 :: SWord8 = if s1284 then s7648 else s7651 s7653 :: SWord1 = choose [0:0] s1328 s7654 :: SBool = s19 /= s7653 s7655 :: SWord8 = if s22 then s1336 else s1317 s7656 :: SWord8 = s7655 >>> 1 s7657 :: SWord8 = s24 | s7656 s7658 :: SWord8 = s26 & s7656 s7659 :: SWord8 = if s7654 then s7657 else s7658 s7660 :: SWord1 = choose [0:0] s1339 s7661 :: SBool = s19 /= s7660 s7662 :: SWord8 = if s7661 then s7657 else s7658 s7663 :: SWord8 = if s1321 then s7659 else s7662 s7664 :: SWord8 = if s1263 then s7652 else s7663 s7665 :: SWord1 = choose [0:0] s1382 s7666 :: SBool = s19 /= s7665 s7667 :: SWord8 = if s22 then s1392 else s1374 s7668 :: SWord8 = s7667 >>> 1 s7669 :: SWord8 = s24 | s7668 s7670 :: SWord8 = s26 & s7668 s7671 :: SWord8 = if s7666 then s7669 else s7670 s7672 :: SWord1 = choose [0:0] s1397 s7673 :: SBool = s19 /= s7672 s7674 :: SWord8 = if s7673 then s7669 else s7670 s7675 :: SWord8 = if s1378 then s7671 else s7674 s7676 :: SWord1 = choose [0:0] s1420 s7677 :: SBool = s19 /= s7676 s7678 :: SWord8 = if s22 then s1428 else s1409 s7679 :: SWord8 = s7678 >>> 1 s7680 :: SWord8 = s24 | s7679 s7681 :: SWord8 = s26 & s7679 s7682 :: SWord8 = if s7677 then s7680 else s7681 s7683 :: SWord1 = choose [0:0] s1431 s7684 :: SBool = s19 /= s7683 s7685 :: SWord8 = if s7684 then s7680 else s7681 s7686 :: SWord8 = if s1413 then s7682 else s7685 s7687 :: SWord8 = if s1356 then s7675 else s7686 s7688 :: SWord8 = if s1241 then s7664 else s7687 s7689 :: SWord8 = if s1009 then s7641 else s7688 s7690 :: SWord1 = choose [0:0] s1518 s7691 :: SBool = s19 /= s7690 s7692 :: SWord8 = if s22 then s1528 else s1510 s7693 :: SWord8 = s7692 >>> 1 s7694 :: SWord8 = s24 | s7693 s7695 :: SWord8 = s26 & s7693 s7696 :: SWord8 = if s7691 then s7694 else s7695 s7697 :: SWord1 = choose [0:0] s1537 s7698 :: SBool = s19 /= s7697 s7699 :: SWord8 = if s7698 then s7694 else s7695 s7700 :: SWord8 = if s1514 then s7696 else s7699 s7701 :: SWord1 = choose [0:0] s1560 s7702 :: SBool = s19 /= s7701 s7703 :: SWord8 = if s22 then s1568 else s1549 s7704 :: SWord8 = s7703 >>> 1 s7705 :: SWord8 = s24 | s7704 s7706 :: SWord8 = s26 & s7704 s7707 :: SWord8 = if s7702 then s7705 else s7706 s7708 :: SWord1 = choose [0:0] s1571 s7709 :: SBool = s19 /= s7708 s7710 :: SWord8 = if s7709 then s7705 else s7706 s7711 :: SWord8 = if s1553 then s7707 else s7710 s7712 :: SWord8 = if s1493 then s7700 else s7711 s7713 :: SWord1 = choose [0:0] s1614 s7714 :: SBool = s19 /= s7713 s7715 :: SWord8 = if s22 then s1624 else s1606 s7716 :: SWord8 = s7715 >>> 1 s7717 :: SWord8 = s24 | s7716 s7718 :: SWord8 = s26 & s7716 s7719 :: SWord8 = if s7714 then s7717 else s7718 s7720 :: SWord1 = choose [0:0] s1629 s7721 :: SBool = s19 /= s7720 s7722 :: SWord8 = if s7721 then s7717 else s7718 s7723 :: SWord8 = if s1610 then s7719 else s7722 s7724 :: SWord1 = choose [0:0] s1652 s7725 :: SBool = s19 /= s7724 s7726 :: SWord8 = if s22 then s1660 else s1641 s7727 :: SWord8 = s7726 >>> 1 s7728 :: SWord8 = s24 | s7727 s7729 :: SWord8 = s26 & s7727 s7730 :: SWord8 = if s7725 then s7728 else s7729 s7731 :: SWord1 = choose [0:0] s1663 s7732 :: SBool = s19 /= s7731 s7733 :: SWord8 = if s7732 then s7728 else s7729 s7734 :: SWord8 = if s1645 then s7730 else s7733 s7735 :: SWord8 = if s1588 then s7723 else s7734 s7736 :: SWord8 = if s1472 then s7712 else s7735 s7737 :: SWord1 = choose [0:0] s1728 s7738 :: SBool = s19 /= s7737 s7739 :: SWord8 = if s22 then s1738 else s1720 s7740 :: SWord8 = s7739 >>> 1 s7741 :: SWord8 = s24 | s7740 s7742 :: SWord8 = s26 & s7740 s7743 :: SWord8 = if s7738 then s7741 else s7742 s7744 :: SWord1 = choose [0:0] s1745 s7745 :: SBool = s19 /= s7744 s7746 :: SWord8 = if s7745 then s7741 else s7742 s7747 :: SWord8 = if s1724 then s7743 else s7746 s7748 :: SWord1 = choose [0:0] s1768 s7749 :: SBool = s19 /= s7748 s7750 :: SWord8 = if s22 then s1776 else s1757 s7751 :: SWord8 = s7750 >>> 1 s7752 :: SWord8 = s24 | s7751 s7753 :: SWord8 = s26 & s7751 s7754 :: SWord8 = if s7749 then s7752 else s7753 s7755 :: SWord1 = choose [0:0] s1779 s7756 :: SBool = s19 /= s7755 s7757 :: SWord8 = if s7756 then s7752 else s7753 s7758 :: SWord8 = if s1761 then s7754 else s7757 s7759 :: SWord8 = if s1703 then s7747 else s7758 s7760 :: SWord1 = choose [0:0] s1822 s7761 :: SBool = s19 /= s7760 s7762 :: SWord8 = if s22 then s1832 else s1814 s7763 :: SWord8 = s7762 >>> 1 s7764 :: SWord8 = s24 | s7763 s7765 :: SWord8 = s26 & s7763 s7766 :: SWord8 = if s7761 then s7764 else s7765 s7767 :: SWord1 = choose [0:0] s1837 s7768 :: SBool = s19 /= s7767 s7769 :: SWord8 = if s7768 then s7764 else s7765 s7770 :: SWord8 = if s1818 then s7766 else s7769 s7771 :: SWord1 = choose [0:0] s1860 s7772 :: SBool = s19 /= s7771 s7773 :: SWord8 = if s22 then s1868 else s1849 s7774 :: SWord8 = s7773 >>> 1 s7775 :: SWord8 = s24 | s7774 s7776 :: SWord8 = s26 & s7774 s7777 :: SWord8 = if s7772 then s7775 else s7776 s7778 :: SWord1 = choose [0:0] s1871 s7779 :: SBool = s19 /= s7778 s7780 :: SWord8 = if s7779 then s7775 else s7776 s7781 :: SWord8 = if s1853 then s7777 else s7780 s7782 :: SWord8 = if s1796 then s7770 else s7781 s7783 :: SWord8 = if s1681 then s7759 else s7782 s7784 :: SWord8 = if s1450 then s7736 else s7783 s7785 :: SWord8 = if s987 then s7689 else s7784 s7786 :: SWord8 = if s56 then s7594 else s7785 s7787 :: SWord1 = choose [0:0] s2002 s7788 :: SBool = s19 /= s7787 s7789 :: SWord8 = if s22 then s2012 else s1994 s7790 :: SWord8 = s7789 >>> 1 s7791 :: SWord8 = s24 | s7790 s7792 :: SWord8 = s26 & s7790 s7793 :: SWord8 = if s7788 then s7791 else s7792 s7794 :: SWord1 = choose [0:0] s2025 s7795 :: SBool = s19 /= s7794 s7796 :: SWord8 = if s7795 then s7791 else s7792 s7797 :: SWord8 = if s1998 then s7793 else s7796 s7798 :: SWord1 = choose [0:0] s2048 s7799 :: SBool = s19 /= s7798 s7800 :: SWord8 = if s22 then s2056 else s2037 s7801 :: SWord8 = s7800 >>> 1 s7802 :: SWord8 = s24 | s7801 s7803 :: SWord8 = s26 & s7801 s7804 :: SWord8 = if s7799 then s7802 else s7803 s7805 :: SWord1 = choose [0:0] s2059 s7806 :: SBool = s19 /= s7805 s7807 :: SWord8 = if s7806 then s7802 else s7803 s7808 :: SWord8 = if s2041 then s7804 else s7807 s7809 :: SWord8 = if s1977 then s7797 else s7808 s7810 :: SWord1 = choose [0:0] s2102 s7811 :: SBool = s19 /= s7810 s7812 :: SWord8 = if s22 then s2112 else s2094 s7813 :: SWord8 = s7812 >>> 1 s7814 :: SWord8 = s24 | s7813 s7815 :: SWord8 = s26 & s7813 s7816 :: SWord8 = if s7811 then s7814 else s7815 s7817 :: SWord1 = choose [0:0] s2117 s7818 :: SBool = s19 /= s7817 s7819 :: SWord8 = if s7818 then s7814 else s7815 s7820 :: SWord8 = if s2098 then s7816 else s7819 s7821 :: SWord1 = choose [0:0] s2140 s7822 :: SBool = s19 /= s7821 s7823 :: SWord8 = if s22 then s2148 else s2129 s7824 :: SWord8 = s7823 >>> 1 s7825 :: SWord8 = s24 | s7824 s7826 :: SWord8 = s26 & s7824 s7827 :: SWord8 = if s7822 then s7825 else s7826 s7828 :: SWord1 = choose [0:0] s2151 s7829 :: SBool = s19 /= s7828 s7830 :: SWord8 = if s7829 then s7825 else s7826 s7831 :: SWord8 = if s2133 then s7827 else s7830 s7832 :: SWord8 = if s2076 then s7820 else s7831 s7833 :: SWord8 = if s1956 then s7809 else s7832 s7834 :: SWord1 = choose [0:0] s2216 s7835 :: SBool = s19 /= s7834 s7836 :: SWord8 = if s22 then s2226 else s2208 s7837 :: SWord8 = s7836 >>> 1 s7838 :: SWord8 = s24 | s7837 s7839 :: SWord8 = s26 & s7837 s7840 :: SWord8 = if s7835 then s7838 else s7839 s7841 :: SWord1 = choose [0:0] s2233 s7842 :: SBool = s19 /= s7841 s7843 :: SWord8 = if s7842 then s7838 else s7839 s7844 :: SWord8 = if s2212 then s7840 else s7843 s7845 :: SWord1 = choose [0:0] s2256 s7846 :: SBool = s19 /= s7845 s7847 :: SWord8 = if s22 then s2264 else s2245 s7848 :: SWord8 = s7847 >>> 1 s7849 :: SWord8 = s24 | s7848 s7850 :: SWord8 = s26 & s7848 s7851 :: SWord8 = if s7846 then s7849 else s7850 s7852 :: SWord1 = choose [0:0] s2267 s7853 :: SBool = s19 /= s7852 s7854 :: SWord8 = if s7853 then s7849 else s7850 s7855 :: SWord8 = if s2249 then s7851 else s7854 s7856 :: SWord8 = if s2191 then s7844 else s7855 s7857 :: SWord1 = choose [0:0] s2310 s7858 :: SBool = s19 /= s7857 s7859 :: SWord8 = if s22 then s2320 else s2302 s7860 :: SWord8 = s7859 >>> 1 s7861 :: SWord8 = s24 | s7860 s7862 :: SWord8 = s26 & s7860 s7863 :: SWord8 = if s7858 then s7861 else s7862 s7864 :: SWord1 = choose [0:0] s2325 s7865 :: SBool = s19 /= s7864 s7866 :: SWord8 = if s7865 then s7861 else s7862 s7867 :: SWord8 = if s2306 then s7863 else s7866 s7868 :: SWord1 = choose [0:0] s2348 s7869 :: SBool = s19 /= s7868 s7870 :: SWord8 = if s22 then s2356 else s2337 s7871 :: SWord8 = s7870 >>> 1 s7872 :: SWord8 = s24 | s7871 s7873 :: SWord8 = s26 & s7871 s7874 :: SWord8 = if s7869 then s7872 else s7873 s7875 :: SWord1 = choose [0:0] s2359 s7876 :: SBool = s19 /= s7875 s7877 :: SWord8 = if s7876 then s7872 else s7873 s7878 :: SWord8 = if s2341 then s7874 else s7877 s7879 :: SWord8 = if s2284 then s7867 else s7878 s7880 :: SWord8 = if s2169 then s7856 else s7879 s7881 :: SWord8 = if s1935 then s7833 else s7880 s7882 :: SWord1 = choose [0:0] s2446 s7883 :: SBool = s19 /= s7882 s7884 :: SWord8 = if s22 then s2456 else s2438 s7885 :: SWord8 = s7884 >>> 1 s7886 :: SWord8 = s24 | s7885 s7887 :: SWord8 = s26 & s7885 s7888 :: SWord8 = if s7883 then s7886 else s7887 s7889 :: SWord1 = choose [0:0] s2465 s7890 :: SBool = s19 /= s7889 s7891 :: SWord8 = if s7890 then s7886 else s7887 s7892 :: SWord8 = if s2442 then s7888 else s7891 s7893 :: SWord1 = choose [0:0] s2488 s7894 :: SBool = s19 /= s7893 s7895 :: SWord8 = if s22 then s2496 else s2477 s7896 :: SWord8 = s7895 >>> 1 s7897 :: SWord8 = s24 | s7896 s7898 :: SWord8 = s26 & s7896 s7899 :: SWord8 = if s7894 then s7897 else s7898 s7900 :: SWord1 = choose [0:0] s2499 s7901 :: SBool = s19 /= s7900 s7902 :: SWord8 = if s7901 then s7897 else s7898 s7903 :: SWord8 = if s2481 then s7899 else s7902 s7904 :: SWord8 = if s2421 then s7892 else s7903 s7905 :: SWord1 = choose [0:0] s2542 s7906 :: SBool = s19 /= s7905 s7907 :: SWord8 = if s22 then s2552 else s2534 s7908 :: SWord8 = s7907 >>> 1 s7909 :: SWord8 = s24 | s7908 s7910 :: SWord8 = s26 & s7908 s7911 :: SWord8 = if s7906 then s7909 else s7910 s7912 :: SWord1 = choose [0:0] s2557 s7913 :: SBool = s19 /= s7912 s7914 :: SWord8 = if s7913 then s7909 else s7910 s7915 :: SWord8 = if s2538 then s7911 else s7914 s7916 :: SWord1 = choose [0:0] s2580 s7917 :: SBool = s19 /= s7916 s7918 :: SWord8 = if s22 then s2588 else s2569 s7919 :: SWord8 = s7918 >>> 1 s7920 :: SWord8 = s24 | s7919 s7921 :: SWord8 = s26 & s7919 s7922 :: SWord8 = if s7917 then s7920 else s7921 s7923 :: SWord1 = choose [0:0] s2591 s7924 :: SBool = s19 /= s7923 s7925 :: SWord8 = if s7924 then s7920 else s7921 s7926 :: SWord8 = if s2573 then s7922 else s7925 s7927 :: SWord8 = if s2516 then s7915 else s7926 s7928 :: SWord8 = if s2400 then s7904 else s7927 s7929 :: SWord1 = choose [0:0] s2656 s7930 :: SBool = s19 /= s7929 s7931 :: SWord8 = if s22 then s2666 else s2648 s7932 :: SWord8 = s7931 >>> 1 s7933 :: SWord8 = s24 | s7932 s7934 :: SWord8 = s26 & s7932 s7935 :: SWord8 = if s7930 then s7933 else s7934 s7936 :: SWord1 = choose [0:0] s2673 s7937 :: SBool = s19 /= s7936 s7938 :: SWord8 = if s7937 then s7933 else s7934 s7939 :: SWord8 = if s2652 then s7935 else s7938 s7940 :: SWord1 = choose [0:0] s2696 s7941 :: SBool = s19 /= s7940 s7942 :: SWord8 = if s22 then s2704 else s2685 s7943 :: SWord8 = s7942 >>> 1 s7944 :: SWord8 = s24 | s7943 s7945 :: SWord8 = s26 & s7943 s7946 :: SWord8 = if s7941 then s7944 else s7945 s7947 :: SWord1 = choose [0:0] s2707 s7948 :: SBool = s19 /= s7947 s7949 :: SWord8 = if s7948 then s7944 else s7945 s7950 :: SWord8 = if s2689 then s7946 else s7949 s7951 :: SWord8 = if s2631 then s7939 else s7950 s7952 :: SWord1 = choose [0:0] s2750 s7953 :: SBool = s19 /= s7952 s7954 :: SWord8 = if s22 then s2760 else s2742 s7955 :: SWord8 = s7954 >>> 1 s7956 :: SWord8 = s24 | s7955 s7957 :: SWord8 = s26 & s7955 s7958 :: SWord8 = if s7953 then s7956 else s7957 s7959 :: SWord1 = choose [0:0] s2765 s7960 :: SBool = s19 /= s7959 s7961 :: SWord8 = if s7960 then s7956 else s7957 s7962 :: SWord8 = if s2746 then s7958 else s7961 s7963 :: SWord1 = choose [0:0] s2788 s7964 :: SBool = s19 /= s7963 s7965 :: SWord8 = if s22 then s2796 else s2777 s7966 :: SWord8 = s7965 >>> 1 s7967 :: SWord8 = s24 | s7966 s7968 :: SWord8 = s26 & s7966 s7969 :: SWord8 = if s7964 then s7967 else s7968 s7970 :: SWord1 = choose [0:0] s2799 s7971 :: SBool = s19 /= s7970 s7972 :: SWord8 = if s7971 then s7967 else s7968 s7973 :: SWord8 = if s2781 then s7969 else s7972 s7974 :: SWord8 = if s2724 then s7962 else s7973 s7975 :: SWord8 = if s2609 then s7951 else s7974 s7976 :: SWord8 = if s2378 then s7928 else s7975 s7977 :: SWord8 = if s1914 then s7881 else s7976 s7978 :: SWord1 = choose [0:0] s2908 s7979 :: SBool = s19 /= s7978 s7980 :: SWord8 = if s22 then s2918 else s2900 s7981 :: SWord8 = s7980 >>> 1 s7982 :: SWord8 = s24 | s7981 s7983 :: SWord8 = s26 & s7981 s7984 :: SWord8 = if s7979 then s7982 else s7983 s7985 :: SWord1 = choose [0:0] s2929 s7986 :: SBool = s19 /= s7985 s7987 :: SWord8 = if s7986 then s7982 else s7983 s7988 :: SWord8 = if s2904 then s7984 else s7987 s7989 :: SWord1 = choose [0:0] s2952 s7990 :: SBool = s19 /= s7989 s7991 :: SWord8 = if s22 then s2960 else s2941 s7992 :: SWord8 = s7991 >>> 1 s7993 :: SWord8 = s24 | s7992 s7994 :: SWord8 = s26 & s7992 s7995 :: SWord8 = if s7990 then s7993 else s7994 s7996 :: SWord1 = choose [0:0] s2963 s7997 :: SBool = s19 /= s7996 s7998 :: SWord8 = if s7997 then s7993 else s7994 s7999 :: SWord8 = if s2945 then s7995 else s7998 s8000 :: SWord8 = if s2883 then s7988 else s7999 s8001 :: SWord1 = choose [0:0] s3006 s8002 :: SBool = s19 /= s8001 s8003 :: SWord8 = if s22 then s3016 else s2998 s8004 :: SWord8 = s8003 >>> 1 s8005 :: SWord8 = s24 | s8004 s8006 :: SWord8 = s26 & s8004 s8007 :: SWord8 = if s8002 then s8005 else s8006 s8008 :: SWord1 = choose [0:0] s3021 s8009 :: SBool = s19 /= s8008 s8010 :: SWord8 = if s8009 then s8005 else s8006 s8011 :: SWord8 = if s3002 then s8007 else s8010 s8012 :: SWord1 = choose [0:0] s3044 s8013 :: SBool = s19 /= s8012 s8014 :: SWord8 = if s22 then s3052 else s3033 s8015 :: SWord8 = s8014 >>> 1 s8016 :: SWord8 = s24 | s8015 s8017 :: SWord8 = s26 & s8015 s8018 :: SWord8 = if s8013 then s8016 else s8017 s8019 :: SWord1 = choose [0:0] s3055 s8020 :: SBool = s19 /= s8019 s8021 :: SWord8 = if s8020 then s8016 else s8017 s8022 :: SWord8 = if s3037 then s8018 else s8021 s8023 :: SWord8 = if s2980 then s8011 else s8022 s8024 :: SWord8 = if s2862 then s8000 else s8023 s8025 :: SWord1 = choose [0:0] s3120 s8026 :: SBool = s19 /= s8025 s8027 :: SWord8 = if s22 then s3130 else s3112 s8028 :: SWord8 = s8027 >>> 1 s8029 :: SWord8 = s24 | s8028 s8030 :: SWord8 = s26 & s8028 s8031 :: SWord8 = if s8026 then s8029 else s8030 s8032 :: SWord1 = choose [0:0] s3137 s8033 :: SBool = s19 /= s8032 s8034 :: SWord8 = if s8033 then s8029 else s8030 s8035 :: SWord8 = if s3116 then s8031 else s8034 s8036 :: SWord1 = choose [0:0] s3160 s8037 :: SBool = s19 /= s8036 s8038 :: SWord8 = if s22 then s3168 else s3149 s8039 :: SWord8 = s8038 >>> 1 s8040 :: SWord8 = s24 | s8039 s8041 :: SWord8 = s26 & s8039 s8042 :: SWord8 = if s8037 then s8040 else s8041 s8043 :: SWord1 = choose [0:0] s3171 s8044 :: SBool = s19 /= s8043 s8045 :: SWord8 = if s8044 then s8040 else s8041 s8046 :: SWord8 = if s3153 then s8042 else s8045 s8047 :: SWord8 = if s3095 then s8035 else s8046 s8048 :: SWord1 = choose [0:0] s3214 s8049 :: SBool = s19 /= s8048 s8050 :: SWord8 = if s22 then s3224 else s3206 s8051 :: SWord8 = s8050 >>> 1 s8052 :: SWord8 = s24 | s8051 s8053 :: SWord8 = s26 & s8051 s8054 :: SWord8 = if s8049 then s8052 else s8053 s8055 :: SWord1 = choose [0:0] s3229 s8056 :: SBool = s19 /= s8055 s8057 :: SWord8 = if s8056 then s8052 else s8053 s8058 :: SWord8 = if s3210 then s8054 else s8057 s8059 :: SWord1 = choose [0:0] s3252 s8060 :: SBool = s19 /= s8059 s8061 :: SWord8 = if s22 then s3260 else s3241 s8062 :: SWord8 = s8061 >>> 1 s8063 :: SWord8 = s24 | s8062 s8064 :: SWord8 = s26 & s8062 s8065 :: SWord8 = if s8060 then s8063 else s8064 s8066 :: SWord1 = choose [0:0] s3263 s8067 :: SBool = s19 /= s8066 s8068 :: SWord8 = if s8067 then s8063 else s8064 s8069 :: SWord8 = if s3245 then s8065 else s8068 s8070 :: SWord8 = if s3188 then s8058 else s8069 s8071 :: SWord8 = if s3073 then s8047 else s8070 s8072 :: SWord8 = if s2841 then s8024 else s8071 s8073 :: SWord1 = choose [0:0] s3350 s8074 :: SBool = s19 /= s8073 s8075 :: SWord8 = if s22 then s3360 else s3342 s8076 :: SWord8 = s8075 >>> 1 s8077 :: SWord8 = s24 | s8076 s8078 :: SWord8 = s26 & s8076 s8079 :: SWord8 = if s8074 then s8077 else s8078 s8080 :: SWord1 = choose [0:0] s3369 s8081 :: SBool = s19 /= s8080 s8082 :: SWord8 = if s8081 then s8077 else s8078 s8083 :: SWord8 = if s3346 then s8079 else s8082 s8084 :: SWord1 = choose [0:0] s3392 s8085 :: SBool = s19 /= s8084 s8086 :: SWord8 = if s22 then s3400 else s3381 s8087 :: SWord8 = s8086 >>> 1 s8088 :: SWord8 = s24 | s8087 s8089 :: SWord8 = s26 & s8087 s8090 :: SWord8 = if s8085 then s8088 else s8089 s8091 :: SWord1 = choose [0:0] s3403 s8092 :: SBool = s19 /= s8091 s8093 :: SWord8 = if s8092 then s8088 else s8089 s8094 :: SWord8 = if s3385 then s8090 else s8093 s8095 :: SWord8 = if s3325 then s8083 else s8094 s8096 :: SWord1 = choose [0:0] s3446 s8097 :: SBool = s19 /= s8096 s8098 :: SWord8 = if s22 then s3456 else s3438 s8099 :: SWord8 = s8098 >>> 1 s8100 :: SWord8 = s24 | s8099 s8101 :: SWord8 = s26 & s8099 s8102 :: SWord8 = if s8097 then s8100 else s8101 s8103 :: SWord1 = choose [0:0] s3461 s8104 :: SBool = s19 /= s8103 s8105 :: SWord8 = if s8104 then s8100 else s8101 s8106 :: SWord8 = if s3442 then s8102 else s8105 s8107 :: SWord1 = choose [0:0] s3484 s8108 :: SBool = s19 /= s8107 s8109 :: SWord8 = if s22 then s3492 else s3473 s8110 :: SWord8 = s8109 >>> 1 s8111 :: SWord8 = s24 | s8110 s8112 :: SWord8 = s26 & s8110 s8113 :: SWord8 = if s8108 then s8111 else s8112 s8114 :: SWord1 = choose [0:0] s3495 s8115 :: SBool = s19 /= s8114 s8116 :: SWord8 = if s8115 then s8111 else s8112 s8117 :: SWord8 = if s3477 then s8113 else s8116 s8118 :: SWord8 = if s3420 then s8106 else s8117 s8119 :: SWord8 = if s3304 then s8095 else s8118 s8120 :: SWord1 = choose [0:0] s3560 s8121 :: SBool = s19 /= s8120 s8122 :: SWord8 = if s22 then s3570 else s3552 s8123 :: SWord8 = s8122 >>> 1 s8124 :: SWord8 = s24 | s8123 s8125 :: SWord8 = s26 & s8123 s8126 :: SWord8 = if s8121 then s8124 else s8125 s8127 :: SWord1 = choose [0:0] s3577 s8128 :: SBool = s19 /= s8127 s8129 :: SWord8 = if s8128 then s8124 else s8125 s8130 :: SWord8 = if s3556 then s8126 else s8129 s8131 :: SWord1 = choose [0:0] s3600 s8132 :: SBool = s19 /= s8131 s8133 :: SWord8 = if s22 then s3608 else s3589 s8134 :: SWord8 = s8133 >>> 1 s8135 :: SWord8 = s24 | s8134 s8136 :: SWord8 = s26 & s8134 s8137 :: SWord8 = if s8132 then s8135 else s8136 s8138 :: SWord1 = choose [0:0] s3611 s8139 :: SBool = s19 /= s8138 s8140 :: SWord8 = if s8139 then s8135 else s8136 s8141 :: SWord8 = if s3593 then s8137 else s8140 s8142 :: SWord8 = if s3535 then s8130 else s8141 s8143 :: SWord1 = choose [0:0] s3654 s8144 :: SBool = s19 /= s8143 s8145 :: SWord8 = if s22 then s3664 else s3646 s8146 :: SWord8 = s8145 >>> 1 s8147 :: SWord8 = s24 | s8146 s8148 :: SWord8 = s26 & s8146 s8149 :: SWord8 = if s8144 then s8147 else s8148 s8150 :: SWord1 = choose [0:0] s3669 s8151 :: SBool = s19 /= s8150 s8152 :: SWord8 = if s8151 then s8147 else s8148 s8153 :: SWord8 = if s3650 then s8149 else s8152 s8154 :: SWord1 = choose [0:0] s3692 s8155 :: SBool = s19 /= s8154 s8156 :: SWord8 = if s22 then s3700 else s3681 s8157 :: SWord8 = s8156 >>> 1 s8158 :: SWord8 = s24 | s8157 s8159 :: SWord8 = s26 & s8157 s8160 :: SWord8 = if s8155 then s8158 else s8159 s8161 :: SWord1 = choose [0:0] s3703 s8162 :: SBool = s19 /= s8161 s8163 :: SWord8 = if s8162 then s8158 else s8159 s8164 :: SWord8 = if s3685 then s8160 else s8163 s8165 :: SWord8 = if s3628 then s8153 else s8164 s8166 :: SWord8 = if s3513 then s8142 else s8165 s8167 :: SWord8 = if s3282 then s8119 else s8166 s8168 :: SWord8 = if s2819 then s8072 else s8167 s8169 :: SWord8 = if s1892 then s7977 else s8168 s8170 :: SWord8 = if s38 then s7786 else s8169 s8171 :: SWord1 = choose [0:0] s3851 s8172 :: SBool = s19 /= s8171 s8173 :: SWord8 = if s22 then s3861 else s3843 s8174 :: SWord8 = s8173 >>> 1 s8175 :: SWord8 = s24 | s8174 s8176 :: SWord8 = s26 & s8174 s8177 :: SWord8 = if s8172 then s8175 else s8176 s8178 :: SWord1 = choose [0:0] s3876 s8179 :: SBool = s19 /= s8178 s8180 :: SWord8 = if s8179 then s8175 else s8176 s8181 :: SWord8 = if s3847 then s8177 else s8180 s8182 :: SWord1 = choose [0:0] s3899 s8183 :: SBool = s19 /= s8182 s8184 :: SWord8 = if s22 then s3907 else s3888 s8185 :: SWord8 = s8184 >>> 1 s8186 :: SWord8 = s24 | s8185 s8187 :: SWord8 = s26 & s8185 s8188 :: SWord8 = if s8183 then s8186 else s8187 s8189 :: SWord1 = choose [0:0] s3910 s8190 :: SBool = s19 /= s8189 s8191 :: SWord8 = if s8190 then s8186 else s8187 s8192 :: SWord8 = if s3892 then s8188 else s8191 s8193 :: SWord8 = if s3826 then s8181 else s8192 s8194 :: SWord1 = choose [0:0] s3953 s8195 :: SBool = s19 /= s8194 s8196 :: SWord8 = if s22 then s3963 else s3945 s8197 :: SWord8 = s8196 >>> 1 s8198 :: SWord8 = s24 | s8197 s8199 :: SWord8 = s26 & s8197 s8200 :: SWord8 = if s8195 then s8198 else s8199 s8201 :: SWord1 = choose [0:0] s3968 s8202 :: SBool = s19 /= s8201 s8203 :: SWord8 = if s8202 then s8198 else s8199 s8204 :: SWord8 = if s3949 then s8200 else s8203 s8205 :: SWord1 = choose [0:0] s3991 s8206 :: SBool = s19 /= s8205 s8207 :: SWord8 = if s22 then s3999 else s3980 s8208 :: SWord8 = s8207 >>> 1 s8209 :: SWord8 = s24 | s8208 s8210 :: SWord8 = s26 & s8208 s8211 :: SWord8 = if s8206 then s8209 else s8210 s8212 :: SWord1 = choose [0:0] s4002 s8213 :: SBool = s19 /= s8212 s8214 :: SWord8 = if s8213 then s8209 else s8210 s8215 :: SWord8 = if s3984 then s8211 else s8214 s8216 :: SWord8 = if s3927 then s8204 else s8215 s8217 :: SWord8 = if s3805 then s8193 else s8216 s8218 :: SWord1 = choose [0:0] s4067 s8219 :: SBool = s19 /= s8218 s8220 :: SWord8 = if s22 then s4077 else s4059 s8221 :: SWord8 = s8220 >>> 1 s8222 :: SWord8 = s24 | s8221 s8223 :: SWord8 = s26 & s8221 s8224 :: SWord8 = if s8219 then s8222 else s8223 s8225 :: SWord1 = choose [0:0] s4084 s8226 :: SBool = s19 /= s8225 s8227 :: SWord8 = if s8226 then s8222 else s8223 s8228 :: SWord8 = if s4063 then s8224 else s8227 s8229 :: SWord1 = choose [0:0] s4107 s8230 :: SBool = s19 /= s8229 s8231 :: SWord8 = if s22 then s4115 else s4096 s8232 :: SWord8 = s8231 >>> 1 s8233 :: SWord8 = s24 | s8232 s8234 :: SWord8 = s26 & s8232 s8235 :: SWord8 = if s8230 then s8233 else s8234 s8236 :: SWord1 = choose [0:0] s4118 s8237 :: SBool = s19 /= s8236 s8238 :: SWord8 = if s8237 then s8233 else s8234 s8239 :: SWord8 = if s4100 then s8235 else s8238 s8240 :: SWord8 = if s4042 then s8228 else s8239 s8241 :: SWord1 = choose [0:0] s4161 s8242 :: SBool = s19 /= s8241 s8243 :: SWord8 = if s22 then s4171 else s4153 s8244 :: SWord8 = s8243 >>> 1 s8245 :: SWord8 = s24 | s8244 s8246 :: SWord8 = s26 & s8244 s8247 :: SWord8 = if s8242 then s8245 else s8246 s8248 :: SWord1 = choose [0:0] s4176 s8249 :: SBool = s19 /= s8248 s8250 :: SWord8 = if s8249 then s8245 else s8246 s8251 :: SWord8 = if s4157 then s8247 else s8250 s8252 :: SWord1 = choose [0:0] s4199 s8253 :: SBool = s19 /= s8252 s8254 :: SWord8 = if s22 then s4207 else s4188 s8255 :: SWord8 = s8254 >>> 1 s8256 :: SWord8 = s24 | s8255 s8257 :: SWord8 = s26 & s8255 s8258 :: SWord8 = if s8253 then s8256 else s8257 s8259 :: SWord1 = choose [0:0] s4210 s8260 :: SBool = s19 /= s8259 s8261 :: SWord8 = if s8260 then s8256 else s8257 s8262 :: SWord8 = if s4192 then s8258 else s8261 s8263 :: SWord8 = if s4135 then s8251 else s8262 s8264 :: SWord8 = if s4020 then s8240 else s8263 s8265 :: SWord8 = if s3784 then s8217 else s8264 s8266 :: SWord1 = choose [0:0] s4297 s8267 :: SBool = s19 /= s8266 s8268 :: SWord8 = if s22 then s4307 else s4289 s8269 :: SWord8 = s8268 >>> 1 s8270 :: SWord8 = s24 | s8269 s8271 :: SWord8 = s26 & s8269 s8272 :: SWord8 = if s8267 then s8270 else s8271 s8273 :: SWord1 = choose [0:0] s4316 s8274 :: SBool = s19 /= s8273 s8275 :: SWord8 = if s8274 then s8270 else s8271 s8276 :: SWord8 = if s4293 then s8272 else s8275 s8277 :: SWord1 = choose [0:0] s4339 s8278 :: SBool = s19 /= s8277 s8279 :: SWord8 = if s22 then s4347 else s4328 s8280 :: SWord8 = s8279 >>> 1 s8281 :: SWord8 = s24 | s8280 s8282 :: SWord8 = s26 & s8280 s8283 :: SWord8 = if s8278 then s8281 else s8282 s8284 :: SWord1 = choose [0:0] s4350 s8285 :: SBool = s19 /= s8284 s8286 :: SWord8 = if s8285 then s8281 else s8282 s8287 :: SWord8 = if s4332 then s8283 else s8286 s8288 :: SWord8 = if s4272 then s8276 else s8287 s8289 :: SWord1 = choose [0:0] s4393 s8290 :: SBool = s19 /= s8289 s8291 :: SWord8 = if s22 then s4403 else s4385 s8292 :: SWord8 = s8291 >>> 1 s8293 :: SWord8 = s24 | s8292 s8294 :: SWord8 = s26 & s8292 s8295 :: SWord8 = if s8290 then s8293 else s8294 s8296 :: SWord1 = choose [0:0] s4408 s8297 :: SBool = s19 /= s8296 s8298 :: SWord8 = if s8297 then s8293 else s8294 s8299 :: SWord8 = if s4389 then s8295 else s8298 s8300 :: SWord1 = choose [0:0] s4431 s8301 :: SBool = s19 /= s8300 s8302 :: SWord8 = if s22 then s4439 else s4420 s8303 :: SWord8 = s8302 >>> 1 s8304 :: SWord8 = s24 | s8303 s8305 :: SWord8 = s26 & s8303 s8306 :: SWord8 = if s8301 then s8304 else s8305 s8307 :: SWord1 = choose [0:0] s4442 s8308 :: SBool = s19 /= s8307 s8309 :: SWord8 = if s8308 then s8304 else s8305 s8310 :: SWord8 = if s4424 then s8306 else s8309 s8311 :: SWord8 = if s4367 then s8299 else s8310 s8312 :: SWord8 = if s4251 then s8288 else s8311 s8313 :: SWord1 = choose [0:0] s4507 s8314 :: SBool = s19 /= s8313 s8315 :: SWord8 = if s22 then s4517 else s4499 s8316 :: SWord8 = s8315 >>> 1 s8317 :: SWord8 = s24 | s8316 s8318 :: SWord8 = s26 & s8316 s8319 :: SWord8 = if s8314 then s8317 else s8318 s8320 :: SWord1 = choose [0:0] s4524 s8321 :: SBool = s19 /= s8320 s8322 :: SWord8 = if s8321 then s8317 else s8318 s8323 :: SWord8 = if s4503 then s8319 else s8322 s8324 :: SWord1 = choose [0:0] s4547 s8325 :: SBool = s19 /= s8324 s8326 :: SWord8 = if s22 then s4555 else s4536 s8327 :: SWord8 = s8326 >>> 1 s8328 :: SWord8 = s24 | s8327 s8329 :: SWord8 = s26 & s8327 s8330 :: SWord8 = if s8325 then s8328 else s8329 s8331 :: SWord1 = choose [0:0] s4558 s8332 :: SBool = s19 /= s8331 s8333 :: SWord8 = if s8332 then s8328 else s8329 s8334 :: SWord8 = if s4540 then s8330 else s8333 s8335 :: SWord8 = if s4482 then s8323 else s8334 s8336 :: SWord1 = choose [0:0] s4601 s8337 :: SBool = s19 /= s8336 s8338 :: SWord8 = if s22 then s4611 else s4593 s8339 :: SWord8 = s8338 >>> 1 s8340 :: SWord8 = s24 | s8339 s8341 :: SWord8 = s26 & s8339 s8342 :: SWord8 = if s8337 then s8340 else s8341 s8343 :: SWord1 = choose [0:0] s4616 s8344 :: SBool = s19 /= s8343 s8345 :: SWord8 = if s8344 then s8340 else s8341 s8346 :: SWord8 = if s4597 then s8342 else s8345 s8347 :: SWord1 = choose [0:0] s4639 s8348 :: SBool = s19 /= s8347 s8349 :: SWord8 = if s22 then s4647 else s4628 s8350 :: SWord8 = s8349 >>> 1 s8351 :: SWord8 = s24 | s8350 s8352 :: SWord8 = s26 & s8350 s8353 :: SWord8 = if s8348 then s8351 else s8352 s8354 :: SWord1 = choose [0:0] s4650 s8355 :: SBool = s19 /= s8354 s8356 :: SWord8 = if s8355 then s8351 else s8352 s8357 :: SWord8 = if s4632 then s8353 else s8356 s8358 :: SWord8 = if s4575 then s8346 else s8357 s8359 :: SWord8 = if s4460 then s8335 else s8358 s8360 :: SWord8 = if s4229 then s8312 else s8359 s8361 :: SWord8 = if s3763 then s8265 else s8360 s8362 :: SWord1 = choose [0:0] s4759 s8363 :: SBool = s19 /= s8362 s8364 :: SWord8 = if s22 then s4769 else s4751 s8365 :: SWord8 = s8364 >>> 1 s8366 :: SWord8 = s24 | s8365 s8367 :: SWord8 = s26 & s8365 s8368 :: SWord8 = if s8363 then s8366 else s8367 s8369 :: SWord1 = choose [0:0] s4780 s8370 :: SBool = s19 /= s8369 s8371 :: SWord8 = if s8370 then s8366 else s8367 s8372 :: SWord8 = if s4755 then s8368 else s8371 s8373 :: SWord1 = choose [0:0] s4803 s8374 :: SBool = s19 /= s8373 s8375 :: SWord8 = if s22 then s4811 else s4792 s8376 :: SWord8 = s8375 >>> 1 s8377 :: SWord8 = s24 | s8376 s8378 :: SWord8 = s26 & s8376 s8379 :: SWord8 = if s8374 then s8377 else s8378 s8380 :: SWord1 = choose [0:0] s4814 s8381 :: SBool = s19 /= s8380 s8382 :: SWord8 = if s8381 then s8377 else s8378 s8383 :: SWord8 = if s4796 then s8379 else s8382 s8384 :: SWord8 = if s4734 then s8372 else s8383 s8385 :: SWord1 = choose [0:0] s4857 s8386 :: SBool = s19 /= s8385 s8387 :: SWord8 = if s22 then s4867 else s4849 s8388 :: SWord8 = s8387 >>> 1 s8389 :: SWord8 = s24 | s8388 s8390 :: SWord8 = s26 & s8388 s8391 :: SWord8 = if s8386 then s8389 else s8390 s8392 :: SWord1 = choose [0:0] s4872 s8393 :: SBool = s19 /= s8392 s8394 :: SWord8 = if s8393 then s8389 else s8390 s8395 :: SWord8 = if s4853 then s8391 else s8394 s8396 :: SWord1 = choose [0:0] s4895 s8397 :: SBool = s19 /= s8396 s8398 :: SWord8 = if s22 then s4903 else s4884 s8399 :: SWord8 = s8398 >>> 1 s8400 :: SWord8 = s24 | s8399 s8401 :: SWord8 = s26 & s8399 s8402 :: SWord8 = if s8397 then s8400 else s8401 s8403 :: SWord1 = choose [0:0] s4906 s8404 :: SBool = s19 /= s8403 s8405 :: SWord8 = if s8404 then s8400 else s8401 s8406 :: SWord8 = if s4888 then s8402 else s8405 s8407 :: SWord8 = if s4831 then s8395 else s8406 s8408 :: SWord8 = if s4713 then s8384 else s8407 s8409 :: SWord1 = choose [0:0] s4971 s8410 :: SBool = s19 /= s8409 s8411 :: SWord8 = if s22 then s4981 else s4963 s8412 :: SWord8 = s8411 >>> 1 s8413 :: SWord8 = s24 | s8412 s8414 :: SWord8 = s26 & s8412 s8415 :: SWord8 = if s8410 then s8413 else s8414 s8416 :: SWord1 = choose [0:0] s4988 s8417 :: SBool = s19 /= s8416 s8418 :: SWord8 = if s8417 then s8413 else s8414 s8419 :: SWord8 = if s4967 then s8415 else s8418 s8420 :: SWord1 = choose [0:0] s5011 s8421 :: SBool = s19 /= s8420 s8422 :: SWord8 = if s22 then s5019 else s5000 s8423 :: SWord8 = s8422 >>> 1 s8424 :: SWord8 = s24 | s8423 s8425 :: SWord8 = s26 & s8423 s8426 :: SWord8 = if s8421 then s8424 else s8425 s8427 :: SWord1 = choose [0:0] s5022 s8428 :: SBool = s19 /= s8427 s8429 :: SWord8 = if s8428 then s8424 else s8425 s8430 :: SWord8 = if s5004 then s8426 else s8429 s8431 :: SWord8 = if s4946 then s8419 else s8430 s8432 :: SWord1 = choose [0:0] s5065 s8433 :: SBool = s19 /= s8432 s8434 :: SWord8 = if s22 then s5075 else s5057 s8435 :: SWord8 = s8434 >>> 1 s8436 :: SWord8 = s24 | s8435 s8437 :: SWord8 = s26 & s8435 s8438 :: SWord8 = if s8433 then s8436 else s8437 s8439 :: SWord1 = choose [0:0] s5080 s8440 :: SBool = s19 /= s8439 s8441 :: SWord8 = if s8440 then s8436 else s8437 s8442 :: SWord8 = if s5061 then s8438 else s8441 s8443 :: SWord1 = choose [0:0] s5103 s8444 :: SBool = s19 /= s8443 s8445 :: SWord8 = if s22 then s5111 else s5092 s8446 :: SWord8 = s8445 >>> 1 s8447 :: SWord8 = s24 | s8446 s8448 :: SWord8 = s26 & s8446 s8449 :: SWord8 = if s8444 then s8447 else s8448 s8450 :: SWord1 = choose [0:0] s5114 s8451 :: SBool = s19 /= s8450 s8452 :: SWord8 = if s8451 then s8447 else s8448 s8453 :: SWord8 = if s5096 then s8449 else s8452 s8454 :: SWord8 = if s5039 then s8442 else s8453 s8455 :: SWord8 = if s4924 then s8431 else s8454 s8456 :: SWord8 = if s4692 then s8408 else s8455 s8457 :: SWord1 = choose [0:0] s5201 s8458 :: SBool = s19 /= s8457 s8459 :: SWord8 = if s22 then s5211 else s5193 s8460 :: SWord8 = s8459 >>> 1 s8461 :: SWord8 = s24 | s8460 s8462 :: SWord8 = s26 & s8460 s8463 :: SWord8 = if s8458 then s8461 else s8462 s8464 :: SWord1 = choose [0:0] s5220 s8465 :: SBool = s19 /= s8464 s8466 :: SWord8 = if s8465 then s8461 else s8462 s8467 :: SWord8 = if s5197 then s8463 else s8466 s8468 :: SWord1 = choose [0:0] s5243 s8469 :: SBool = s19 /= s8468 s8470 :: SWord8 = if s22 then s5251 else s5232 s8471 :: SWord8 = s8470 >>> 1 s8472 :: SWord8 = s24 | s8471 s8473 :: SWord8 = s26 & s8471 s8474 :: SWord8 = if s8469 then s8472 else s8473 s8475 :: SWord1 = choose [0:0] s5254 s8476 :: SBool = s19 /= s8475 s8477 :: SWord8 = if s8476 then s8472 else s8473 s8478 :: SWord8 = if s5236 then s8474 else s8477 s8479 :: SWord8 = if s5176 then s8467 else s8478 s8480 :: SWord1 = choose [0:0] s5297 s8481 :: SBool = s19 /= s8480 s8482 :: SWord8 = if s22 then s5307 else s5289 s8483 :: SWord8 = s8482 >>> 1 s8484 :: SWord8 = s24 | s8483 s8485 :: SWord8 = s26 & s8483 s8486 :: SWord8 = if s8481 then s8484 else s8485 s8487 :: SWord1 = choose [0:0] s5312 s8488 :: SBool = s19 /= s8487 s8489 :: SWord8 = if s8488 then s8484 else s8485 s8490 :: SWord8 = if s5293 then s8486 else s8489 s8491 :: SWord1 = choose [0:0] s5335 s8492 :: SBool = s19 /= s8491 s8493 :: SWord8 = if s22 then s5343 else s5324 s8494 :: SWord8 = s8493 >>> 1 s8495 :: SWord8 = s24 | s8494 s8496 :: SWord8 = s26 & s8494 s8497 :: SWord8 = if s8492 then s8495 else s8496 s8498 :: SWord1 = choose [0:0] s5346 s8499 :: SBool = s19 /= s8498 s8500 :: SWord8 = if s8499 then s8495 else s8496 s8501 :: SWord8 = if s5328 then s8497 else s8500 s8502 :: SWord8 = if s5271 then s8490 else s8501 s8503 :: SWord8 = if s5155 then s8479 else s8502 s8504 :: SWord1 = choose [0:0] s5411 s8505 :: SBool = s19 /= s8504 s8506 :: SWord8 = if s22 then s5421 else s5403 s8507 :: SWord8 = s8506 >>> 1 s8508 :: SWord8 = s24 | s8507 s8509 :: SWord8 = s26 & s8507 s8510 :: SWord8 = if s8505 then s8508 else s8509 s8511 :: SWord1 = choose [0:0] s5428 s8512 :: SBool = s19 /= s8511 s8513 :: SWord8 = if s8512 then s8508 else s8509 s8514 :: SWord8 = if s5407 then s8510 else s8513 s8515 :: SWord1 = choose [0:0] s5451 s8516 :: SBool = s19 /= s8515 s8517 :: SWord8 = if s22 then s5459 else s5440 s8518 :: SWord8 = s8517 >>> 1 s8519 :: SWord8 = s24 | s8518 s8520 :: SWord8 = s26 & s8518 s8521 :: SWord8 = if s8516 then s8519 else s8520 s8522 :: SWord1 = choose [0:0] s5462 s8523 :: SBool = s19 /= s8522 s8524 :: SWord8 = if s8523 then s8519 else s8520 s8525 :: SWord8 = if s5444 then s8521 else s8524 s8526 :: SWord8 = if s5386 then s8514 else s8525 s8527 :: SWord1 = choose [0:0] s5505 s8528 :: SBool = s19 /= s8527 s8529 :: SWord8 = if s22 then s5515 else s5497 s8530 :: SWord8 = s8529 >>> 1 s8531 :: SWord8 = s24 | s8530 s8532 :: SWord8 = s26 & s8530 s8533 :: SWord8 = if s8528 then s8531 else s8532 s8534 :: SWord1 = choose [0:0] s5520 s8535 :: SBool = s19 /= s8534 s8536 :: SWord8 = if s8535 then s8531 else s8532 s8537 :: SWord8 = if s5501 then s8533 else s8536 s8538 :: SWord1 = choose [0:0] s5543 s8539 :: SBool = s19 /= s8538 s8540 :: SWord8 = if s22 then s5551 else s5532 s8541 :: SWord8 = s8540 >>> 1 s8542 :: SWord8 = s24 | s8541 s8543 :: SWord8 = s26 & s8541 s8544 :: SWord8 = if s8539 then s8542 else s8543 s8545 :: SWord1 = choose [0:0] s5554 s8546 :: SBool = s19 /= s8545 s8547 :: SWord8 = if s8546 then s8542 else s8543 s8548 :: SWord8 = if s5536 then s8544 else s8547 s8549 :: SWord8 = if s5479 then s8537 else s8548 s8550 :: SWord8 = if s5364 then s8526 else s8549 s8551 :: SWord8 = if s5133 then s8503 else s8550 s8552 :: SWord8 = if s4670 then s8456 else s8551 s8553 :: SWord8 = if s3742 then s8361 else s8552 s8554 :: SWord1 = choose [0:0] s5685 s8555 :: SBool = s19 /= s8554 s8556 :: SWord8 = if s22 then s5695 else s5677 s8557 :: SWord8 = s8556 >>> 1 s8558 :: SWord8 = s24 | s8557 s8559 :: SWord8 = s26 & s8557 s8560 :: SWord8 = if s8555 then s8558 else s8559 s8561 :: SWord1 = choose [0:0] s5708 s8562 :: SBool = s19 /= s8561 s8563 :: SWord8 = if s8562 then s8558 else s8559 s8564 :: SWord8 = if s5681 then s8560 else s8563 s8565 :: SWord1 = choose [0:0] s5731 s8566 :: SBool = s19 /= s8565 s8567 :: SWord8 = if s22 then s5739 else s5720 s8568 :: SWord8 = s8567 >>> 1 s8569 :: SWord8 = s24 | s8568 s8570 :: SWord8 = s26 & s8568 s8571 :: SWord8 = if s8566 then s8569 else s8570 s8572 :: SWord1 = choose [0:0] s5742 s8573 :: SBool = s19 /= s8572 s8574 :: SWord8 = if s8573 then s8569 else s8570 s8575 :: SWord8 = if s5724 then s8571 else s8574 s8576 :: SWord8 = if s5660 then s8564 else s8575 s8577 :: SWord1 = choose [0:0] s5785 s8578 :: SBool = s19 /= s8577 s8579 :: SWord8 = if s22 then s5795 else s5777 s8580 :: SWord8 = s8579 >>> 1 s8581 :: SWord8 = s24 | s8580 s8582 :: SWord8 = s26 & s8580 s8583 :: SWord8 = if s8578 then s8581 else s8582 s8584 :: SWord1 = choose [0:0] s5800 s8585 :: SBool = s19 /= s8584 s8586 :: SWord8 = if s8585 then s8581 else s8582 s8587 :: SWord8 = if s5781 then s8583 else s8586 s8588 :: SWord1 = choose [0:0] s5823 s8589 :: SBool = s19 /= s8588 s8590 :: SWord8 = if s22 then s5831 else s5812 s8591 :: SWord8 = s8590 >>> 1 s8592 :: SWord8 = s24 | s8591 s8593 :: SWord8 = s26 & s8591 s8594 :: SWord8 = if s8589 then s8592 else s8593 s8595 :: SWord1 = choose [0:0] s5834 s8596 :: SBool = s19 /= s8595 s8597 :: SWord8 = if s8596 then s8592 else s8593 s8598 :: SWord8 = if s5816 then s8594 else s8597 s8599 :: SWord8 = if s5759 then s8587 else s8598 s8600 :: SWord8 = if s5639 then s8576 else s8599 s8601 :: SWord1 = choose [0:0] s5899 s8602 :: SBool = s19 /= s8601 s8603 :: SWord8 = if s22 then s5909 else s5891 s8604 :: SWord8 = s8603 >>> 1 s8605 :: SWord8 = s24 | s8604 s8606 :: SWord8 = s26 & s8604 s8607 :: SWord8 = if s8602 then s8605 else s8606 s8608 :: SWord1 = choose [0:0] s5916 s8609 :: SBool = s19 /= s8608 s8610 :: SWord8 = if s8609 then s8605 else s8606 s8611 :: SWord8 = if s5895 then s8607 else s8610 s8612 :: SWord1 = choose [0:0] s5939 s8613 :: SBool = s19 /= s8612 s8614 :: SWord8 = if s22 then s5947 else s5928 s8615 :: SWord8 = s8614 >>> 1 s8616 :: SWord8 = s24 | s8615 s8617 :: SWord8 = s26 & s8615 s8618 :: SWord8 = if s8613 then s8616 else s8617 s8619 :: SWord1 = choose [0:0] s5950 s8620 :: SBool = s19 /= s8619 s8621 :: SWord8 = if s8620 then s8616 else s8617 s8622 :: SWord8 = if s5932 then s8618 else s8621 s8623 :: SWord8 = if s5874 then s8611 else s8622 s8624 :: SWord1 = choose [0:0] s5993 s8625 :: SBool = s19 /= s8624 s8626 :: SWord8 = if s22 then s6003 else s5985 s8627 :: SWord8 = s8626 >>> 1 s8628 :: SWord8 = s24 | s8627 s8629 :: SWord8 = s26 & s8627 s8630 :: SWord8 = if s8625 then s8628 else s8629 s8631 :: SWord1 = choose [0:0] s6008 s8632 :: SBool = s19 /= s8631 s8633 :: SWord8 = if s8632 then s8628 else s8629 s8634 :: SWord8 = if s5989 then s8630 else s8633 s8635 :: SWord1 = choose [0:0] s6031 s8636 :: SBool = s19 /= s8635 s8637 :: SWord8 = if s22 then s6039 else s6020 s8638 :: SWord8 = s8637 >>> 1 s8639 :: SWord8 = s24 | s8638 s8640 :: SWord8 = s26 & s8638 s8641 :: SWord8 = if s8636 then s8639 else s8640 s8642 :: SWord1 = choose [0:0] s6042 s8643 :: SBool = s19 /= s8642 s8644 :: SWord8 = if s8643 then s8639 else s8640 s8645 :: SWord8 = if s6024 then s8641 else s8644 s8646 :: SWord8 = if s5967 then s8634 else s8645 s8647 :: SWord8 = if s5852 then s8623 else s8646 s8648 :: SWord8 = if s5618 then s8600 else s8647 s8649 :: SWord1 = choose [0:0] s6129 s8650 :: SBool = s19 /= s8649 s8651 :: SWord8 = if s22 then s6139 else s6121 s8652 :: SWord8 = s8651 >>> 1 s8653 :: SWord8 = s24 | s8652 s8654 :: SWord8 = s26 & s8652 s8655 :: SWord8 = if s8650 then s8653 else s8654 s8656 :: SWord1 = choose [0:0] s6148 s8657 :: SBool = s19 /= s8656 s8658 :: SWord8 = if s8657 then s8653 else s8654 s8659 :: SWord8 = if s6125 then s8655 else s8658 s8660 :: SWord1 = choose [0:0] s6171 s8661 :: SBool = s19 /= s8660 s8662 :: SWord8 = if s22 then s6179 else s6160 s8663 :: SWord8 = s8662 >>> 1 s8664 :: SWord8 = s24 | s8663 s8665 :: SWord8 = s26 & s8663 s8666 :: SWord8 = if s8661 then s8664 else s8665 s8667 :: SWord1 = choose [0:0] s6182 s8668 :: SBool = s19 /= s8667 s8669 :: SWord8 = if s8668 then s8664 else s8665 s8670 :: SWord8 = if s6164 then s8666 else s8669 s8671 :: SWord8 = if s6104 then s8659 else s8670 s8672 :: SWord1 = choose [0:0] s6225 s8673 :: SBool = s19 /= s8672 s8674 :: SWord8 = if s22 then s6235 else s6217 s8675 :: SWord8 = s8674 >>> 1 s8676 :: SWord8 = s24 | s8675 s8677 :: SWord8 = s26 & s8675 s8678 :: SWord8 = if s8673 then s8676 else s8677 s8679 :: SWord1 = choose [0:0] s6240 s8680 :: SBool = s19 /= s8679 s8681 :: SWord8 = if s8680 then s8676 else s8677 s8682 :: SWord8 = if s6221 then s8678 else s8681 s8683 :: SWord1 = choose [0:0] s6263 s8684 :: SBool = s19 /= s8683 s8685 :: SWord8 = if s22 then s6271 else s6252 s8686 :: SWord8 = s8685 >>> 1 s8687 :: SWord8 = s24 | s8686 s8688 :: SWord8 = s26 & s8686 s8689 :: SWord8 = if s8684 then s8687 else s8688 s8690 :: SWord1 = choose [0:0] s6274 s8691 :: SBool = s19 /= s8690 s8692 :: SWord8 = if s8691 then s8687 else s8688 s8693 :: SWord8 = if s6256 then s8689 else s8692 s8694 :: SWord8 = if s6199 then s8682 else s8693 s8695 :: SWord8 = if s6083 then s8671 else s8694 s8696 :: SWord1 = choose [0:0] s6339 s8697 :: SBool = s19 /= s8696 s8698 :: SWord8 = if s22 then s6349 else s6331 s8699 :: SWord8 = s8698 >>> 1 s8700 :: SWord8 = s24 | s8699 s8701 :: SWord8 = s26 & s8699 s8702 :: SWord8 = if s8697 then s8700 else s8701 s8703 :: SWord1 = choose [0:0] s6356 s8704 :: SBool = s19 /= s8703 s8705 :: SWord8 = if s8704 then s8700 else s8701 s8706 :: SWord8 = if s6335 then s8702 else s8705 s8707 :: SWord1 = choose [0:0] s6379 s8708 :: SBool = s19 /= s8707 s8709 :: SWord8 = if s22 then s6387 else s6368 s8710 :: SWord8 = s8709 >>> 1 s8711 :: SWord8 = s24 | s8710 s8712 :: SWord8 = s26 & s8710 s8713 :: SWord8 = if s8708 then s8711 else s8712 s8714 :: SWord1 = choose [0:0] s6390 s8715 :: SBool = s19 /= s8714 s8716 :: SWord8 = if s8715 then s8711 else s8712 s8717 :: SWord8 = if s6372 then s8713 else s8716 s8718 :: SWord8 = if s6314 then s8706 else s8717 s8719 :: SWord1 = choose [0:0] s6433 s8720 :: SBool = s19 /= s8719 s8721 :: SWord8 = if s22 then s6443 else s6425 s8722 :: SWord8 = s8721 >>> 1 s8723 :: SWord8 = s24 | s8722 s8724 :: SWord8 = s26 & s8722 s8725 :: SWord8 = if s8720 then s8723 else s8724 s8726 :: SWord1 = choose [0:0] s6448 s8727 :: SBool = s19 /= s8726 s8728 :: SWord8 = if s8727 then s8723 else s8724 s8729 :: SWord8 = if s6429 then s8725 else s8728 s8730 :: SWord1 = choose [0:0] s6471 s8731 :: SBool = s19 /= s8730 s8732 :: SWord8 = if s22 then s6479 else s6460 s8733 :: SWord8 = s8732 >>> 1 s8734 :: SWord8 = s24 | s8733 s8735 :: SWord8 = s26 & s8733 s8736 :: SWord8 = if s8731 then s8734 else s8735 s8737 :: SWord1 = choose [0:0] s6482 s8738 :: SBool = s19 /= s8737 s8739 :: SWord8 = if s8738 then s8734 else s8735 s8740 :: SWord8 = if s6464 then s8736 else s8739 s8741 :: SWord8 = if s6407 then s8729 else s8740 s8742 :: SWord8 = if s6292 then s8718 else s8741 s8743 :: SWord8 = if s6061 then s8695 else s8742 s8744 :: SWord8 = if s5597 then s8648 else s8743 s8745 :: SWord1 = choose [0:0] s6591 s8746 :: SBool = s19 /= s8745 s8747 :: SWord8 = if s22 then s6601 else s6583 s8748 :: SWord8 = s8747 >>> 1 s8749 :: SWord8 = s24 | s8748 s8750 :: SWord8 = s26 & s8748 s8751 :: SWord8 = if s8746 then s8749 else s8750 s8752 :: SWord1 = choose [0:0] s6612 s8753 :: SBool = s19 /= s8752 s8754 :: SWord8 = if s8753 then s8749 else s8750 s8755 :: SWord8 = if s6587 then s8751 else s8754 s8756 :: SWord1 = choose [0:0] s6635 s8757 :: SBool = s19 /= s8756 s8758 :: SWord8 = if s22 then s6643 else s6624 s8759 :: SWord8 = s8758 >>> 1 s8760 :: SWord8 = s24 | s8759 s8761 :: SWord8 = s26 & s8759 s8762 :: SWord8 = if s8757 then s8760 else s8761 s8763 :: SWord1 = choose [0:0] s6646 s8764 :: SBool = s19 /= s8763 s8765 :: SWord8 = if s8764 then s8760 else s8761 s8766 :: SWord8 = if s6628 then s8762 else s8765 s8767 :: SWord8 = if s6566 then s8755 else s8766 s8768 :: SWord1 = choose [0:0] s6689 s8769 :: SBool = s19 /= s8768 s8770 :: SWord8 = if s22 then s6699 else s6681 s8771 :: SWord8 = s8770 >>> 1 s8772 :: SWord8 = s24 | s8771 s8773 :: SWord8 = s26 & s8771 s8774 :: SWord8 = if s8769 then s8772 else s8773 s8775 :: SWord1 = choose [0:0] s6704 s8776 :: SBool = s19 /= s8775 s8777 :: SWord8 = if s8776 then s8772 else s8773 s8778 :: SWord8 = if s6685 then s8774 else s8777 s8779 :: SWord1 = choose [0:0] s6727 s8780 :: SBool = s19 /= s8779 s8781 :: SWord8 = if s22 then s6735 else s6716 s8782 :: SWord8 = s8781 >>> 1 s8783 :: SWord8 = s24 | s8782 s8784 :: SWord8 = s26 & s8782 s8785 :: SWord8 = if s8780 then s8783 else s8784 s8786 :: SWord1 = choose [0:0] s6738 s8787 :: SBool = s19 /= s8786 s8788 :: SWord8 = if s8787 then s8783 else s8784 s8789 :: SWord8 = if s6720 then s8785 else s8788 s8790 :: SWord8 = if s6663 then s8778 else s8789 s8791 :: SWord8 = if s6545 then s8767 else s8790 s8792 :: SWord1 = choose [0:0] s6803 s8793 :: SBool = s19 /= s8792 s8794 :: SWord8 = if s22 then s6813 else s6795 s8795 :: SWord8 = s8794 >>> 1 s8796 :: SWord8 = s24 | s8795 s8797 :: SWord8 = s26 & s8795 s8798 :: SWord8 = if s8793 then s8796 else s8797 s8799 :: SWord1 = choose [0:0] s6820 s8800 :: SBool = s19 /= s8799 s8801 :: SWord8 = if s8800 then s8796 else s8797 s8802 :: SWord8 = if s6799 then s8798 else s8801 s8803 :: SWord1 = choose [0:0] s6843 s8804 :: SBool = s19 /= s8803 s8805 :: SWord8 = if s22 then s6851 else s6832 s8806 :: SWord8 = s8805 >>> 1 s8807 :: SWord8 = s24 | s8806 s8808 :: SWord8 = s26 & s8806 s8809 :: SWord8 = if s8804 then s8807 else s8808 s8810 :: SWord1 = choose [0:0] s6854 s8811 :: SBool = s19 /= s8810 s8812 :: SWord8 = if s8811 then s8807 else s8808 s8813 :: SWord8 = if s6836 then s8809 else s8812 s8814 :: SWord8 = if s6778 then s8802 else s8813 s8815 :: SWord1 = choose [0:0] s6897 s8816 :: SBool = s19 /= s8815 s8817 :: SWord8 = if s22 then s6907 else s6889 s8818 :: SWord8 = s8817 >>> 1 s8819 :: SWord8 = s24 | s8818 s8820 :: SWord8 = s26 & s8818 s8821 :: SWord8 = if s8816 then s8819 else s8820 s8822 :: SWord1 = choose [0:0] s6912 s8823 :: SBool = s19 /= s8822 s8824 :: SWord8 = if s8823 then s8819 else s8820 s8825 :: SWord8 = if s6893 then s8821 else s8824 s8826 :: SWord1 = choose [0:0] s6935 s8827 :: SBool = s19 /= s8826 s8828 :: SWord8 = if s22 then s6943 else s6924 s8829 :: SWord8 = s8828 >>> 1 s8830 :: SWord8 = s24 | s8829 s8831 :: SWord8 = s26 & s8829 s8832 :: SWord8 = if s8827 then s8830 else s8831 s8833 :: SWord1 = choose [0:0] s6946 s8834 :: SBool = s19 /= s8833 s8835 :: SWord8 = if s8834 then s8830 else s8831 s8836 :: SWord8 = if s6928 then s8832 else s8835 s8837 :: SWord8 = if s6871 then s8825 else s8836 s8838 :: SWord8 = if s6756 then s8814 else s8837 s8839 :: SWord8 = if s6524 then s8791 else s8838 s8840 :: SWord1 = choose [0:0] s7033 s8841 :: SBool = s19 /= s8840 s8842 :: SWord8 = if s22 then s7043 else s7025 s8843 :: SWord8 = s8842 >>> 1 s8844 :: SWord8 = s24 | s8843 s8845 :: SWord8 = s26 & s8843 s8846 :: SWord8 = if s8841 then s8844 else s8845 s8847 :: SWord1 = choose [0:0] s7052 s8848 :: SBool = s19 /= s8847 s8849 :: SWord8 = if s8848 then s8844 else s8845 s8850 :: SWord8 = if s7029 then s8846 else s8849 s8851 :: SWord1 = choose [0:0] s7075 s8852 :: SBool = s19 /= s8851 s8853 :: SWord8 = if s22 then s7083 else s7064 s8854 :: SWord8 = s8853 >>> 1 s8855 :: SWord8 = s24 | s8854 s8856 :: SWord8 = s26 & s8854 s8857 :: SWord8 = if s8852 then s8855 else s8856 s8858 :: SWord1 = choose [0:0] s7086 s8859 :: SBool = s19 /= s8858 s8860 :: SWord8 = if s8859 then s8855 else s8856 s8861 :: SWord8 = if s7068 then s8857 else s8860 s8862 :: SWord8 = if s7008 then s8850 else s8861 s8863 :: SWord1 = choose [0:0] s7129 s8864 :: SBool = s19 /= s8863 s8865 :: SWord8 = if s22 then s7139 else s7121 s8866 :: SWord8 = s8865 >>> 1 s8867 :: SWord8 = s24 | s8866 s8868 :: SWord8 = s26 & s8866 s8869 :: SWord8 = if s8864 then s8867 else s8868 s8870 :: SWord1 = choose [0:0] s7144 s8871 :: SBool = s19 /= s8870 s8872 :: SWord8 = if s8871 then s8867 else s8868 s8873 :: SWord8 = if s7125 then s8869 else s8872 s8874 :: SWord1 = choose [0:0] s7167 s8875 :: SBool = s19 /= s8874 s8876 :: SWord8 = if s22 then s7175 else s7156 s8877 :: SWord8 = s8876 >>> 1 s8878 :: SWord8 = s24 | s8877 s8879 :: SWord8 = s26 & s8877 s8880 :: SWord8 = if s8875 then s8878 else s8879 s8881 :: SWord1 = choose [0:0] s7178 s8882 :: SBool = s19 /= s8881 s8883 :: SWord8 = if s8882 then s8878 else s8879 s8884 :: SWord8 = if s7160 then s8880 else s8883 s8885 :: SWord8 = if s7103 then s8873 else s8884 s8886 :: SWord8 = if s6987 then s8862 else s8885 s8887 :: SWord1 = choose [0:0] s7243 s8888 :: SBool = s19 /= s8887 s8889 :: SWord8 = if s22 then s7253 else s7235 s8890 :: SWord8 = s8889 >>> 1 s8891 :: SWord8 = s24 | s8890 s8892 :: SWord8 = s26 & s8890 s8893 :: SWord8 = if s8888 then s8891 else s8892 s8894 :: SWord1 = choose [0:0] s7260 s8895 :: SBool = s19 /= s8894 s8896 :: SWord8 = if s8895 then s8891 else s8892 s8897 :: SWord8 = if s7239 then s8893 else s8896 s8898 :: SWord1 = choose [0:0] s7283 s8899 :: SBool = s19 /= s8898 s8900 :: SWord8 = if s22 then s7291 else s7272 s8901 :: SWord8 = s8900 >>> 1 s8902 :: SWord8 = s24 | s8901 s8903 :: SWord8 = s26 & s8901 s8904 :: SWord8 = if s8899 then s8902 else s8903 s8905 :: SWord1 = choose [0:0] s7294 s8906 :: SBool = s19 /= s8905 s8907 :: SWord8 = if s8906 then s8902 else s8903 s8908 :: SWord8 = if s7276 then s8904 else s8907 s8909 :: SWord8 = if s7218 then s8897 else s8908 s8910 :: SWord1 = choose [0:0] s7337 s8911 :: SBool = s19 /= s8910 s8912 :: SWord8 = if s22 then s7347 else s7329 s8913 :: SWord8 = s8912 >>> 1 s8914 :: SWord8 = s24 | s8913 s8915 :: SWord8 = s26 & s8913 s8916 :: SWord8 = if s8911 then s8914 else s8915 s8917 :: SWord1 = choose [0:0] s7352 s8918 :: SBool = s19 /= s8917 s8919 :: SWord8 = if s8918 then s8914 else s8915 s8920 :: SWord8 = if s7333 then s8916 else s8919 s8921 :: SWord1 = choose [0:0] s7375 s8922 :: SBool = s19 /= s8921 s8923 :: SWord8 = if s22 then s7383 else s7364 s8924 :: SWord8 = s8923 >>> 1 s8925 :: SWord8 = s24 | s8924 s8926 :: SWord8 = s26 & s8924 s8927 :: SWord8 = if s8922 then s8925 else s8926 s8928 :: SWord1 = choose [0:0] s7386 s8929 :: SBool = s19 /= s8928 s8930 :: SWord8 = if s8929 then s8925 else s8926 s8931 :: SWord8 = if s7368 then s8927 else s8930 s8932 :: SWord8 = if s7311 then s8920 else s8931 s8933 :: SWord8 = if s7196 then s8909 else s8932 s8934 :: SWord8 = if s6965 then s8886 else s8933 s8935 :: SWord8 = if s6502 then s8839 else s8934 s8936 :: SWord8 = if s5575 then s8744 else s8935 s8937 :: SWord8 = if s3725 then s8553 else s8936 s8938 :: SWord8 = if s21 then s8170 else s8937 s8939 :: SWord16 = s17 # s8938 s8940 :: SWord16 = s7403 + s8939 s8941 :: SWord16 = s17 # s1 s8942 :: SWord16 = s17 # s3 s8943 :: SWord16 = s8941 * s8942 s8944 :: SBool = s8940 == s8943 s8945 :: SBool = s15 | s8944 CONSTRAINTS ASSERTIONS OUTPUTS s8945sbv-5.12/SBVUnitTest/GoldFiles/legato_c.gold0000644000000000000000000101257112725411266017064 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for legatoMult. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: legatoMult_driver legatoMult.o: legatoMult.c legatoMult.h ${CC} ${CCFLAGS} -c $< -o $@ legatoMult_driver.o: legatoMult_driver.c ${CC} ${CCFLAGS} -c $< -o $@ legatoMult_driver: legatoMult.o legatoMult_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f legatoMult_driver == END: "Makefile" ================== == BEGIN: "legatoMult.h" ================ /* Header file for legatoMult. Automatically generated by SBV. Do not edit! */ #ifndef __legatoMult__HEADER_INCLUDED__ #define __legatoMult__HEADER_INCLUDED__ #include #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 >> 0) & 1); const SBool s4 = s2 != false; const SBool s5 = false == s4; const SWord8 s6 = (s0 >> 1) | (s0 << 7); const SWord8 s8 = s6 & 127; const SBool s9 = (SBool) ((s8 >> 0) & 1); const SBool s10 = false != s9; const SBool s11 = false == s10; const SWord8 s12 = (s8 >> 1) | (s8 << 7); const SWord8 s13 = 127 & s12; const SBool s14 = (SBool) ((s13 >> 0) & 1); const SBool s15 = false != s14; const SBool s16 = false == s15; const SWord8 s17 = (s13 >> 1) | (s13 << 7); const SWord8 s18 = 127 & s17; const SBool s19 = (SBool) ((s18 >> 0) & 1); const SBool s20 = false != s19; const SBool s21 = false == s20; const SWord8 s24 = s4 ? 128 : 0; const SBool s25 = (SBool) ((s24 >> 0) & 1); const SBool s26 = false != s25; const SWord8 s27 = s26 ? 128 : 0; const SBool s28 = (SBool) ((s27 >> 0) & 1); const SBool s29 = false != s28; const SWord8 s30 = (s18 >> 1) | (s18 << 7); const SWord8 s31 = 128 | s30; const SWord8 s32 = 127 & s30; const SWord8 s33 = s29 ? s31 : s32; const SBool s34 = (SBool) ((s33 >> 0) & 1); const SBool s35 = false != s34; const SBool s36 = false == s35; const SWord8 s37 = (s24 >> 1) | (s24 << 7); const SWord8 s38 = 128 | s37; const SWord8 s39 = 127 & s37; const SWord8 s40 = s10 ? s38 : s39; const SBool s41 = (SBool) ((s40 >> 0) & 1); const SBool s42 = false != s41; const SWord8 s43 = (s27 >> 1) | (s27 << 7); const SWord8 s44 = 128 | s43; const SWord8 s45 = 127 & s43; const SWord8 s46 = s42 ? s44 : s45; const SBool s47 = (SBool) ((s46 >> 0) & 1); const SBool s48 = false != s47; const SWord8 s49 = (s33 >> 1) | (s33 << 7); const SWord8 s50 = 128 | s49; const SWord8 s51 = 127 & s49; const SWord8 s52 = s48 ? s50 : s51; const SBool s53 = (SBool) ((s52 >> 0) & 1); const SBool s54 = false != s53; const SBool s55 = false == s54; const SWord8 s56 = (s40 >> 1) | (s40 << 7); const SWord8 s57 = 128 | s56; const SWord8 s58 = 127 & s56; const SWord8 s59 = s15 ? s57 : s58; const SBool s60 = (SBool) ((s59 >> 0) & 1); const SBool s61 = false != s60; const SWord8 s62 = (s46 >> 1) | (s46 << 7); const SWord8 s63 = 128 | s62; const SWord8 s64 = 127 & s62; const SWord8 s65 = s61 ? s63 : s64; const SBool s66 = (SBool) ((s65 >> 0) & 1); const SBool s67 = false != s66; const SWord8 s68 = (s52 >> 1) | (s52 << 7); const SWord8 s69 = 128 | s68; const SWord8 s70 = 127 & s68; const SWord8 s71 = s67 ? s69 : s70; const SBool s72 = (SBool) ((s71 >> 0) & 1); const SBool s73 = false != s72; const SBool s74 = false == s73; const SWord8 s75 = (s59 >> 1) | (s59 << 7); const SWord8 s76 = 128 | s75; const SWord8 s77 = 127 & s75; const SWord8 s78 = s20 ? s76 : s77; const SBool s79 = (SBool) ((s78 >> 0) & 1); const SBool s80 = false != s79; const SWord8 s81 = (s65 >> 1) | (s65 << 7); const SWord8 s82 = 128 | s81; const SWord8 s83 = 127 & s81; const SWord8 s84 = s80 ? s82 : s83; const SBool s85 = (SBool) ((s84 >> 0) & 1); const SBool s86 = false != s85; const SWord8 s87 = (s71 >> 1) | (s71 << 7); const SWord8 s88 = 128 | s87; const SWord8 s89 = 127 & s87; const SWord8 s90 = s86 ? s88 : s89; const SBool s91 = (SBool) ((s90 >> 0) & 1); const SBool s92 = false != s91; const SBool s93 = false == s92; const SWord8 s94 = (s78 >> 1) | (s78 << 7); const SWord8 s95 = 128 | s94; const SWord8 s96 = 127 & s94; const SWord8 s97 = s35 ? s95 : s96; const SWord8 s98 = (s97 >> 1) | (s97 << 7); const SWord8 s99 = 128 | s98; const SWord8 s100 = 127 & s98; const SWord8 s101 = s54 ? s99 : s100; const SWord8 s102 = (s101 >> 1) | (s101 << 7); const SWord8 s103 = 128 | s102; const SWord8 s104 = 127 & s102; const SWord8 s105 = s73 ? s103 : s104; const SWord8 s106 = (s105 >> 1) | (s105 << 7); const SWord8 s107 = 128 | s106; const SWord8 s108 = 127 & s106; const SWord8 s109 = s92 ? s107 : s108; const SWord8 s110 = s1 + s105; const SBool s111 = s110 < s1; const SBool s112 = s110 < s105; const SBool s113 = s111 || s112; const SWord8 s114 = (s110 >> 1) | (s110 << 7); const SWord8 s115 = 128 | s114; const SWord8 s116 = 127 & s114; const SWord8 s117 = s113 ? s115 : s116; const SWord8 s118 = s93 ? s109 : s117; const SWord8 s119 = s1 + s101; const SBool s120 = s119 < s1; const SBool s121 = s119 < s101; const SBool s122 = s120 || s121; const SWord8 s123 = (s119 >> 1) | (s119 << 7); const SWord8 s124 = 128 | s123; const SWord8 s125 = 127 & s123; const SWord8 s126 = s122 ? s124 : s125; const SWord8 s127 = (s126 >> 1) | (s126 << 7); const SWord8 s128 = 128 | s127; const SWord8 s129 = 127 & s127; const SWord8 s130 = s92 ? s128 : s129; const SWord8 s131 = s1 + s126; const SBool s132 = s131 < s1; const SBool s133 = s131 < s126; const SBool s134 = s132 || s133; const SWord8 s135 = (s131 >> 1) | (s131 << 7); const SWord8 s136 = 128 | s135; const SWord8 s137 = 127 & s135; const SWord8 s138 = s134 ? s136 : s137; const SWord8 s139 = s93 ? s130 : s138; const SWord8 s140 = s74 ? s118 : s139; const SWord8 s141 = s1 + s97; const SBool s142 = s141 < s1; const SBool s143 = s141 < s97; const SBool s144 = s142 || s143; const SWord8 s145 = (s141 >> 1) | (s141 << 7); const SWord8 s146 = 128 | s145; const SWord8 s147 = 127 & s145; const SWord8 s148 = s144 ? s146 : s147; const SWord8 s149 = (s148 >> 1) | (s148 << 7); const SWord8 s150 = 128 | s149; const SWord8 s151 = 127 & s149; const SWord8 s152 = s73 ? s150 : s151; const SWord8 s153 = (s152 >> 1) | (s152 << 7); const SWord8 s154 = 128 | s153; const SWord8 s155 = 127 & s153; const SWord8 s156 = s92 ? s154 : s155; const SWord8 s157 = s1 + s152; const SBool s158 = s157 < s1; const SBool s159 = s157 < s152; const SBool s160 = s158 || s159; const SWord8 s161 = (s157 >> 1) | (s157 << 7); const SWord8 s162 = 128 | s161; const SWord8 s163 = 127 & s161; const SWord8 s164 = s160 ? s162 : s163; const SWord8 s165 = s93 ? s156 : s164; const SWord8 s166 = s1 + s148; const SBool s167 = s166 < s1; const SBool s168 = s166 < s148; const SBool s169 = s167 || s168; const SWord8 s170 = (s166 >> 1) | (s166 << 7); const SWord8 s171 = 128 | s170; const SWord8 s172 = 127 & s170; const SWord8 s173 = s169 ? s171 : s172; const SWord8 s174 = (s173 >> 1) | (s173 << 7); const SWord8 s175 = 128 | s174; const SWord8 s176 = 127 & s174; const SWord8 s177 = s92 ? s175 : s176; const SWord8 s178 = s1 + s173; const SBool s179 = s178 < s1; const SBool s180 = s178 < s173; const SBool s181 = s179 || s180; const SWord8 s182 = (s178 >> 1) | (s178 << 7); const SWord8 s183 = 128 | s182; const SWord8 s184 = 127 & s182; const SWord8 s185 = s181 ? s183 : s184; const SWord8 s186 = s93 ? s177 : s185; const SWord8 s187 = s74 ? s165 : s186; const SWord8 s188 = s55 ? s140 : s187; const SWord8 s189 = s1 + s78; const SBool s190 = (SBool) ((s189 >> 0) & 1); const SBool s191 = false != s190; const SWord8 s192 = s191 ? s82 : s83; const SBool s193 = (SBool) ((s192 >> 0) & 1); const SBool s194 = false != s193; const SWord8 s195 = s194 ? s88 : s89; const SBool s196 = (SBool) ((s195 >> 0) & 1); const SBool s197 = false != s196; const SBool s198 = false == s197; const SBool s199 = s189 < s1; const SBool s200 = s189 < s78; const SBool s201 = s199 || s200; const SWord8 s202 = (s189 >> 1) | (s189 << 7); const SWord8 s203 = 128 | s202; const SWord8 s204 = 127 & s202; const SWord8 s205 = s201 ? s203 : s204; const SWord8 s206 = (s205 >> 1) | (s205 << 7); const SWord8 s207 = 128 | s206; const SWord8 s208 = 127 & s206; const SWord8 s209 = s54 ? s207 : s208; const SWord8 s210 = (s209 >> 1) | (s209 << 7); const SWord8 s211 = 128 | s210; const SWord8 s212 = 127 & s210; const SWord8 s213 = s73 ? s211 : s212; const SWord8 s214 = (s213 >> 1) | (s213 << 7); const SWord8 s215 = 128 | s214; const SWord8 s216 = 127 & s214; const SWord8 s217 = s197 ? s215 : s216; const SWord8 s218 = s1 + s213; const SBool s219 = s218 < s1; const SBool s220 = s218 < s213; const SBool s221 = s219 || s220; const SWord8 s222 = (s218 >> 1) | (s218 << 7); const SWord8 s223 = 128 | s222; const SWord8 s224 = 127 & s222; const SWord8 s225 = s221 ? s223 : s224; const SWord8 s226 = s198 ? s217 : s225; const SWord8 s227 = s1 + s209; const SBool s228 = s227 < s1; const SBool s229 = s227 < s209; const SBool s230 = s228 || s229; const SWord8 s231 = (s227 >> 1) | (s227 << 7); const SWord8 s232 = 128 | s231; const SWord8 s233 = 127 & s231; const SWord8 s234 = s230 ? s232 : s233; const SWord8 s235 = (s234 >> 1) | (s234 << 7); const SWord8 s236 = 128 | s235; const SWord8 s237 = 127 & s235; const SWord8 s238 = s197 ? s236 : s237; const SWord8 s239 = s1 + s234; const SBool s240 = s239 < s1; const SBool s241 = s239 < s234; const SBool s242 = s240 || s241; const SWord8 s243 = (s239 >> 1) | (s239 << 7); const SWord8 s244 = 128 | s243; const SWord8 s245 = 127 & s243; const SWord8 s246 = s242 ? s244 : s245; const SWord8 s247 = s198 ? s238 : s246; const SWord8 s248 = s74 ? s226 : s247; const SWord8 s249 = s1 + s205; const SBool s250 = s249 < s1; const SBool s251 = s249 < s205; const SBool s252 = s250 || s251; const SWord8 s253 = (s249 >> 1) | (s249 << 7); const SWord8 s254 = 128 | s253; const SWord8 s255 = 127 & s253; const SWord8 s256 = s252 ? s254 : s255; const SWord8 s257 = (s256 >> 1) | (s256 << 7); const SWord8 s258 = 128 | s257; const SWord8 s259 = 127 & s257; const SWord8 s260 = s73 ? s258 : s259; const SWord8 s261 = (s260 >> 1) | (s260 << 7); const SWord8 s262 = 128 | s261; const SWord8 s263 = 127 & s261; const SWord8 s264 = s197 ? s262 : s263; const SWord8 s265 = s1 + s260; const SBool s266 = s265 < s1; const SBool s267 = s265 < s260; const SBool s268 = s266 || s267; const SWord8 s269 = (s265 >> 1) | (s265 << 7); const SWord8 s270 = 128 | s269; const SWord8 s271 = 127 & s269; const SWord8 s272 = s268 ? s270 : s271; const SWord8 s273 = s198 ? s264 : s272; const SWord8 s274 = s1 + s256; const SBool s275 = s274 < s1; const SBool s276 = s274 < s256; const SBool s277 = s275 || s276; const SWord8 s278 = (s274 >> 1) | (s274 << 7); const SWord8 s279 = 128 | s278; const SWord8 s280 = 127 & s278; const SWord8 s281 = s277 ? s279 : s280; const SWord8 s282 = (s281 >> 1) | (s281 << 7); const SWord8 s283 = 128 | s282; const SWord8 s284 = 127 & s282; const SWord8 s285 = s197 ? s283 : s284; const SWord8 s286 = s1 + s281; const SBool s287 = s286 < s1; const SBool s288 = s286 < s281; const SBool s289 = s287 || s288; const SWord8 s290 = (s286 >> 1) | (s286 << 7); const SWord8 s291 = 128 | s290; const SWord8 s292 = 127 & s290; const SWord8 s293 = s289 ? s291 : s292; const SWord8 s294 = s198 ? s285 : s293; const SWord8 s295 = s74 ? s273 : s294; const SWord8 s296 = s55 ? s248 : s295; const SWord8 s297 = s36 ? s188 : s296; const SWord8 s298 = s1 + s59; const SBool s299 = (SBool) ((s298 >> 0) & 1); const SBool s300 = false != s299; const SWord8 s301 = s300 ? s63 : s64; const SBool s302 = (SBool) ((s301 >> 0) & 1); const SBool s303 = false != s302; const SWord8 s304 = s303 ? s69 : s70; const SBool s305 = (SBool) ((s304 >> 0) & 1); const SBool s306 = false != s305; const SBool s307 = false == s306; const SBool s308 = s298 < s1; const SBool s309 = s298 < s59; const SBool s310 = s308 || s309; const SWord8 s311 = (s298 >> 1) | (s298 << 7); const SWord8 s312 = 128 | s311; const SWord8 s313 = 127 & s311; const SWord8 s314 = s310 ? s312 : s313; const SBool s315 = (SBool) ((s314 >> 0) & 1); const SBool s316 = false != s315; const SWord8 s317 = (s301 >> 1) | (s301 << 7); const SWord8 s318 = 128 | s317; const SWord8 s319 = 127 & s317; const SWord8 s320 = s316 ? s318 : s319; const SBool s321 = (SBool) ((s320 >> 0) & 1); const SBool s322 = false != s321; const SWord8 s323 = (s304 >> 1) | (s304 << 7); const SWord8 s324 = 128 | s323; const SWord8 s325 = 127 & s323; const SWord8 s326 = s322 ? s324 : s325; const SBool s327 = (SBool) ((s326 >> 0) & 1); const SBool s328 = false != s327; const SBool s329 = false == s328; const SWord8 s330 = (s314 >> 1) | (s314 << 7); const SWord8 s331 = 128 | s330; const SWord8 s332 = 127 & s330; const SWord8 s333 = s35 ? s331 : s332; const SWord8 s334 = (s333 >> 1) | (s333 << 7); const SWord8 s335 = 128 | s334; const SWord8 s336 = 127 & s334; const SWord8 s337 = s54 ? s335 : s336; const SWord8 s338 = (s337 >> 1) | (s337 << 7); const SWord8 s339 = 128 | s338; const SWord8 s340 = 127 & s338; const SWord8 s341 = s306 ? s339 : s340; const SWord8 s342 = (s341 >> 1) | (s341 << 7); const SWord8 s343 = 128 | s342; const SWord8 s344 = 127 & s342; const SWord8 s345 = s328 ? s343 : s344; const SWord8 s346 = s1 + s341; const SBool s347 = s346 < s1; const SBool s348 = s346 < s341; const SBool s349 = s347 || s348; const SWord8 s350 = (s346 >> 1) | (s346 << 7); const SWord8 s351 = 128 | s350; const SWord8 s352 = 127 & s350; const SWord8 s353 = s349 ? s351 : s352; const SWord8 s354 = s329 ? s345 : s353; const SWord8 s355 = s1 + s337; const SBool s356 = s355 < s1; const SBool s357 = s355 < s337; const SBool s358 = s356 || s357; const SWord8 s359 = (s355 >> 1) | (s355 << 7); const SWord8 s360 = 128 | s359; const SWord8 s361 = 127 & s359; const SWord8 s362 = s358 ? s360 : s361; const SWord8 s363 = (s362 >> 1) | (s362 << 7); const SWord8 s364 = 128 | s363; const SWord8 s365 = 127 & s363; const SWord8 s366 = s328 ? s364 : s365; const SWord8 s367 = s1 + s362; const SBool s368 = s367 < s1; const SBool s369 = s367 < s362; const SBool s370 = s368 || s369; const SWord8 s371 = (s367 >> 1) | (s367 << 7); const SWord8 s372 = 128 | s371; const SWord8 s373 = 127 & s371; const SWord8 s374 = s370 ? s372 : s373; const SWord8 s375 = s329 ? s366 : s374; const SWord8 s376 = s307 ? s354 : s375; const SWord8 s377 = s1 + s333; const SBool s378 = s377 < s1; const SBool s379 = s377 < s333; const SBool s380 = s378 || s379; const SWord8 s381 = (s377 >> 1) | (s377 << 7); const SWord8 s382 = 128 | s381; const SWord8 s383 = 127 & s381; const SWord8 s384 = s380 ? s382 : s383; const SWord8 s385 = (s384 >> 1) | (s384 << 7); const SWord8 s386 = 128 | s385; const SWord8 s387 = 127 & s385; const SWord8 s388 = s306 ? s386 : s387; const SWord8 s389 = (s388 >> 1) | (s388 << 7); const SWord8 s390 = 128 | s389; const SWord8 s391 = 127 & s389; const SWord8 s392 = s328 ? s390 : s391; const SWord8 s393 = s1 + s388; const SBool s394 = s393 < s1; const SBool s395 = s393 < s388; const SBool s396 = s394 || s395; const SWord8 s397 = (s393 >> 1) | (s393 << 7); const SWord8 s398 = 128 | s397; const SWord8 s399 = 127 & s397; const SWord8 s400 = s396 ? s398 : s399; const SWord8 s401 = s329 ? s392 : s400; const SWord8 s402 = s1 + s384; const SBool s403 = s402 < s1; const SBool s404 = s402 < s384; const SBool s405 = s403 || s404; const SWord8 s406 = (s402 >> 1) | (s402 << 7); const SWord8 s407 = 128 | s406; const SWord8 s408 = 127 & s406; const SWord8 s409 = s405 ? s407 : s408; const SWord8 s410 = (s409 >> 1) | (s409 << 7); const SWord8 s411 = 128 | s410; const SWord8 s412 = 127 & s410; const SWord8 s413 = s328 ? s411 : s412; const SWord8 s414 = s1 + s409; const SBool s415 = s414 < s1; const SBool s416 = s414 < s409; const SBool s417 = s415 || s416; const SWord8 s418 = (s414 >> 1) | (s414 << 7); const SWord8 s419 = 128 | s418; const SWord8 s420 = 127 & s418; const SWord8 s421 = s417 ? s419 : s420; const SWord8 s422 = s329 ? s413 : s421; const SWord8 s423 = s307 ? s401 : s422; const SWord8 s424 = s55 ? s376 : s423; const SWord8 s425 = s1 + s314; const SBool s426 = (SBool) ((s425 >> 0) & 1); const SBool s427 = false != s426; const SWord8 s428 = s427 ? s318 : s319; const SBool s429 = (SBool) ((s428 >> 0) & 1); const SBool s430 = false != s429; const SWord8 s431 = s430 ? s324 : s325; const SBool s432 = (SBool) ((s431 >> 0) & 1); const SBool s433 = false != s432; const SBool s434 = false == s433; const SBool s435 = s425 < s1; const SBool s436 = s425 < s314; const SBool s437 = s435 || s436; const SWord8 s438 = (s425 >> 1) | (s425 << 7); const SWord8 s439 = 128 | s438; const SWord8 s440 = 127 & s438; const SWord8 s441 = s437 ? s439 : s440; const SWord8 s442 = (s441 >> 1) | (s441 << 7); const SWord8 s443 = 128 | s442; const SWord8 s444 = 127 & s442; const SWord8 s445 = s54 ? s443 : s444; const SWord8 s446 = (s445 >> 1) | (s445 << 7); const SWord8 s447 = 128 | s446; const SWord8 s448 = 127 & s446; const SWord8 s449 = s306 ? s447 : s448; const SWord8 s450 = (s449 >> 1) | (s449 << 7); const SWord8 s451 = 128 | s450; const SWord8 s452 = 127 & s450; const SWord8 s453 = s433 ? s451 : s452; const SWord8 s454 = s1 + s449; const SBool s455 = s454 < s1; const SBool s456 = s454 < s449; const SBool s457 = s455 || s456; const SWord8 s458 = (s454 >> 1) | (s454 << 7); const SWord8 s459 = 128 | s458; const SWord8 s460 = 127 & s458; const SWord8 s461 = s457 ? s459 : s460; const SWord8 s462 = s434 ? s453 : s461; const SWord8 s463 = s1 + s445; const SBool s464 = s463 < s1; const SBool s465 = s463 < s445; const SBool s466 = s464 || s465; const SWord8 s467 = (s463 >> 1) | (s463 << 7); const SWord8 s468 = 128 | s467; const SWord8 s469 = 127 & s467; const SWord8 s470 = s466 ? s468 : s469; const SWord8 s471 = (s470 >> 1) | (s470 << 7); const SWord8 s472 = 128 | s471; const SWord8 s473 = 127 & s471; const SWord8 s474 = s433 ? s472 : s473; const SWord8 s475 = s1 + s470; const SBool s476 = s475 < s1; const SBool s477 = s475 < s470; const SBool s478 = s476 || s477; const SWord8 s479 = (s475 >> 1) | (s475 << 7); const SWord8 s480 = 128 | s479; const SWord8 s481 = 127 & s479; const SWord8 s482 = s478 ? s480 : s481; const SWord8 s483 = s434 ? s474 : s482; const SWord8 s484 = s307 ? s462 : s483; const SWord8 s485 = s1 + s441; const SBool s486 = s485 < s1; const SBool s487 = s485 < s441; const SBool s488 = s486 || s487; const SWord8 s489 = (s485 >> 1) | (s485 << 7); const SWord8 s490 = 128 | s489; const SWord8 s491 = 127 & s489; const SWord8 s492 = s488 ? s490 : s491; const SWord8 s493 = (s492 >> 1) | (s492 << 7); const SWord8 s494 = 128 | s493; const SWord8 s495 = 127 & s493; const SWord8 s496 = s306 ? s494 : s495; const SWord8 s497 = (s496 >> 1) | (s496 << 7); const SWord8 s498 = 128 | s497; const SWord8 s499 = 127 & s497; const SWord8 s500 = s433 ? s498 : s499; const SWord8 s501 = s1 + s496; const SBool s502 = s501 < s1; const SBool s503 = s501 < s496; const SBool s504 = s502 || s503; const SWord8 s505 = (s501 >> 1) | (s501 << 7); const SWord8 s506 = 128 | s505; const SWord8 s507 = 127 & s505; const SWord8 s508 = s504 ? s506 : s507; const SWord8 s509 = s434 ? s500 : s508; const SWord8 s510 = s1 + s492; const SBool s511 = s510 < s1; const SBool s512 = s510 < s492; const SBool s513 = s511 || s512; const SWord8 s514 = (s510 >> 1) | (s510 << 7); const SWord8 s515 = 128 | s514; const SWord8 s516 = 127 & s514; const SWord8 s517 = s513 ? s515 : s516; const SWord8 s518 = (s517 >> 1) | (s517 << 7); const SWord8 s519 = 128 | s518; const SWord8 s520 = 127 & s518; const SWord8 s521 = s433 ? s519 : s520; const SWord8 s522 = s1 + s517; const SBool s523 = s522 < s1; const SBool s524 = s522 < s517; const SBool s525 = s523 || s524; const SWord8 s526 = (s522 >> 1) | (s522 << 7); const SWord8 s527 = 128 | s526; const SWord8 s528 = 127 & s526; const SWord8 s529 = s525 ? s527 : s528; const SWord8 s530 = s434 ? s521 : s529; const SWord8 s531 = s307 ? s509 : s530; const SWord8 s532 = s55 ? s484 : s531; const SWord8 s533 = s36 ? s424 : s532; const SWord8 s534 = s21 ? s297 : s533; const SWord8 s535 = s1 + s40; const SBool s536 = (SBool) ((s535 >> 0) & 1); const SBool s537 = false != s536; const SWord8 s538 = s537 ? s44 : s45; const SBool s539 = (SBool) ((s538 >> 0) & 1); const SBool s540 = false != s539; const SWord8 s541 = s540 ? s50 : s51; const SBool s542 = (SBool) ((s541 >> 0) & 1); const SBool s543 = false != s542; const SBool s544 = false == s543; const SBool s545 = s535 < s1; const SBool s546 = s535 < s40; const SBool s547 = s545 || s546; const SWord8 s548 = (s535 >> 1) | (s535 << 7); const SWord8 s549 = 128 | s548; const SWord8 s550 = 127 & s548; const SWord8 s551 = s547 ? s549 : s550; const SBool s552 = (SBool) ((s551 >> 0) & 1); const SBool s553 = false != s552; const SWord8 s554 = (s538 >> 1) | (s538 << 7); const SWord8 s555 = 128 | s554; const SWord8 s556 = 127 & s554; const SWord8 s557 = s553 ? s555 : s556; const SBool s558 = (SBool) ((s557 >> 0) & 1); const SBool s559 = false != s558; const SWord8 s560 = (s541 >> 1) | (s541 << 7); const SWord8 s561 = 128 | s560; const SWord8 s562 = 127 & s560; const SWord8 s563 = s559 ? s561 : s562; const SBool s564 = (SBool) ((s563 >> 0) & 1); const SBool s565 = false != s564; const SBool s566 = false == s565; const SWord8 s567 = (s551 >> 1) | (s551 << 7); const SWord8 s568 = 128 | s567; const SWord8 s569 = 127 & s567; const SWord8 s570 = s20 ? s568 : s569; const SBool s571 = (SBool) ((s570 >> 0) & 1); const SBool s572 = false != s571; const SWord8 s573 = (s557 >> 1) | (s557 << 7); const SWord8 s574 = 128 | s573; const SWord8 s575 = 127 & s573; const SWord8 s576 = s572 ? s574 : s575; const SBool s577 = (SBool) ((s576 >> 0) & 1); const SBool s578 = false != s577; const SWord8 s579 = (s563 >> 1) | (s563 << 7); const SWord8 s580 = 128 | s579; const SWord8 s581 = 127 & s579; const SWord8 s582 = s578 ? s580 : s581; const SBool s583 = (SBool) ((s582 >> 0) & 1); const SBool s584 = false != s583; const SBool s585 = false == s584; const SWord8 s586 = (s570 >> 1) | (s570 << 7); const SWord8 s587 = 128 | s586; const SWord8 s588 = 127 & s586; const SWord8 s589 = s35 ? s587 : s588; const SWord8 s590 = (s589 >> 1) | (s589 << 7); const SWord8 s591 = 128 | s590; const SWord8 s592 = 127 & s590; const SWord8 s593 = s543 ? s591 : s592; const SWord8 s594 = (s593 >> 1) | (s593 << 7); const SWord8 s595 = 128 | s594; const SWord8 s596 = 127 & s594; const SWord8 s597 = s565 ? s595 : s596; const SWord8 s598 = (s597 >> 1) | (s597 << 7); const SWord8 s599 = 128 | s598; const SWord8 s600 = 127 & s598; const SWord8 s601 = s584 ? s599 : s600; const SWord8 s602 = s1 + s597; const SBool s603 = s602 < s1; const SBool s604 = s602 < s597; const SBool s605 = s603 || s604; const SWord8 s606 = (s602 >> 1) | (s602 << 7); const SWord8 s607 = 128 | s606; const SWord8 s608 = 127 & s606; const SWord8 s609 = s605 ? s607 : s608; const SWord8 s610 = s585 ? s601 : s609; const SWord8 s611 = s1 + s593; const SBool s612 = s611 < s1; const SBool s613 = s611 < s593; const SBool s614 = s612 || s613; const SWord8 s615 = (s611 >> 1) | (s611 << 7); const SWord8 s616 = 128 | s615; const SWord8 s617 = 127 & s615; const SWord8 s618 = s614 ? s616 : s617; const SWord8 s619 = (s618 >> 1) | (s618 << 7); const SWord8 s620 = 128 | s619; const SWord8 s621 = 127 & s619; const SWord8 s622 = s584 ? s620 : s621; const SWord8 s623 = s1 + s618; const SBool s624 = s623 < s1; const SBool s625 = s623 < s618; const SBool s626 = s624 || s625; const SWord8 s627 = (s623 >> 1) | (s623 << 7); const SWord8 s628 = 128 | s627; const SWord8 s629 = 127 & s627; const SWord8 s630 = s626 ? s628 : s629; const SWord8 s631 = s585 ? s622 : s630; const SWord8 s632 = s566 ? s610 : s631; const SWord8 s633 = s1 + s589; const SBool s634 = s633 < s1; const SBool s635 = s633 < s589; const SBool s636 = s634 || s635; const SWord8 s637 = (s633 >> 1) | (s633 << 7); const SWord8 s638 = 128 | s637; const SWord8 s639 = 127 & s637; const SWord8 s640 = s636 ? s638 : s639; const SWord8 s641 = (s640 >> 1) | (s640 << 7); const SWord8 s642 = 128 | s641; const SWord8 s643 = 127 & s641; const SWord8 s644 = s565 ? s642 : s643; const SWord8 s645 = (s644 >> 1) | (s644 << 7); const SWord8 s646 = 128 | s645; const SWord8 s647 = 127 & s645; const SWord8 s648 = s584 ? s646 : s647; const SWord8 s649 = s1 + s644; const SBool s650 = s649 < s1; const SBool s651 = s649 < s644; const SBool s652 = s650 || s651; const SWord8 s653 = (s649 >> 1) | (s649 << 7); const SWord8 s654 = 128 | s653; const SWord8 s655 = 127 & s653; const SWord8 s656 = s652 ? s654 : s655; const SWord8 s657 = s585 ? s648 : s656; const SWord8 s658 = s1 + s640; const SBool s659 = s658 < s1; const SBool s660 = s658 < s640; const SBool s661 = s659 || s660; const SWord8 s662 = (s658 >> 1) | (s658 << 7); const SWord8 s663 = 128 | s662; const SWord8 s664 = 127 & s662; const SWord8 s665 = s661 ? s663 : s664; const SWord8 s666 = (s665 >> 1) | (s665 << 7); const SWord8 s667 = 128 | s666; const SWord8 s668 = 127 & s666; const SWord8 s669 = s584 ? s667 : s668; const SWord8 s670 = s1 + s665; const SBool s671 = s670 < s1; const SBool s672 = s670 < s665; const SBool s673 = s671 || s672; const SWord8 s674 = (s670 >> 1) | (s670 << 7); const SWord8 s675 = 128 | s674; const SWord8 s676 = 127 & s674; const SWord8 s677 = s673 ? s675 : s676; const SWord8 s678 = s585 ? s669 : s677; const SWord8 s679 = s566 ? s657 : s678; const SWord8 s680 = s544 ? s632 : s679; const SWord8 s681 = s1 + s570; const SBool s682 = (SBool) ((s681 >> 0) & 1); const SBool s683 = false != s682; const SWord8 s684 = s683 ? s574 : s575; const SBool s685 = (SBool) ((s684 >> 0) & 1); const SBool s686 = false != s685; const SWord8 s687 = s686 ? s580 : s581; const SBool s688 = (SBool) ((s687 >> 0) & 1); const SBool s689 = false != s688; const SBool s690 = false == s689; const SBool s691 = s681 < s1; const SBool s692 = s681 < s570; const SBool s693 = s691 || s692; const SWord8 s694 = (s681 >> 1) | (s681 << 7); const SWord8 s695 = 128 | s694; const SWord8 s696 = 127 & s694; const SWord8 s697 = s693 ? s695 : s696; const SWord8 s698 = (s697 >> 1) | (s697 << 7); const SWord8 s699 = 128 | s698; const SWord8 s700 = 127 & s698; const SWord8 s701 = s543 ? s699 : s700; const SWord8 s702 = (s701 >> 1) | (s701 << 7); const SWord8 s703 = 128 | s702; const SWord8 s704 = 127 & s702; const SWord8 s705 = s565 ? s703 : s704; const SWord8 s706 = (s705 >> 1) | (s705 << 7); const SWord8 s707 = 128 | s706; const SWord8 s708 = 127 & s706; const SWord8 s709 = s689 ? s707 : s708; const SWord8 s710 = s1 + s705; const SBool s711 = s710 < s1; const SBool s712 = s710 < s705; const SBool s713 = s711 || s712; const SWord8 s714 = (s710 >> 1) | (s710 << 7); const SWord8 s715 = 128 | s714; const SWord8 s716 = 127 & s714; const SWord8 s717 = s713 ? s715 : s716; const SWord8 s718 = s690 ? s709 : s717; const SWord8 s719 = s1 + s701; const SBool s720 = s719 < s1; const SBool s721 = s719 < s701; const SBool s722 = s720 || s721; const SWord8 s723 = (s719 >> 1) | (s719 << 7); const SWord8 s724 = 128 | s723; const SWord8 s725 = 127 & s723; const SWord8 s726 = s722 ? s724 : s725; const SWord8 s727 = (s726 >> 1) | (s726 << 7); const SWord8 s728 = 128 | s727; const SWord8 s729 = 127 & s727; const SWord8 s730 = s689 ? s728 : s729; const SWord8 s731 = s1 + s726; const SBool s732 = s731 < s1; const SBool s733 = s731 < s726; const SBool s734 = s732 || s733; const SWord8 s735 = (s731 >> 1) | (s731 << 7); const SWord8 s736 = 128 | s735; const SWord8 s737 = 127 & s735; const SWord8 s738 = s734 ? s736 : s737; const SWord8 s739 = s690 ? s730 : s738; const SWord8 s740 = s566 ? s718 : s739; const SWord8 s741 = s1 + s697; const SBool s742 = s741 < s1; const SBool s743 = s741 < s697; const SBool s744 = s742 || s743; const SWord8 s745 = (s741 >> 1) | (s741 << 7); const SWord8 s746 = 128 | s745; const SWord8 s747 = 127 & s745; const SWord8 s748 = s744 ? s746 : s747; const SWord8 s749 = (s748 >> 1) | (s748 << 7); const SWord8 s750 = 128 | s749; const SWord8 s751 = 127 & s749; const SWord8 s752 = s565 ? s750 : s751; const SWord8 s753 = (s752 >> 1) | (s752 << 7); const SWord8 s754 = 128 | s753; const SWord8 s755 = 127 & s753; const SWord8 s756 = s689 ? s754 : s755; const SWord8 s757 = s1 + s752; const SBool s758 = s757 < s1; const SBool s759 = s757 < s752; const SBool s760 = s758 || s759; const SWord8 s761 = (s757 >> 1) | (s757 << 7); const SWord8 s762 = 128 | s761; const SWord8 s763 = 127 & s761; const SWord8 s764 = s760 ? s762 : s763; const SWord8 s765 = s690 ? s756 : s764; const SWord8 s766 = s1 + s748; const SBool s767 = s766 < s1; const SBool s768 = s766 < s748; const SBool s769 = s767 || s768; const SWord8 s770 = (s766 >> 1) | (s766 << 7); const SWord8 s771 = 128 | s770; const SWord8 s772 = 127 & s770; const SWord8 s773 = s769 ? s771 : s772; const SWord8 s774 = (s773 >> 1) | (s773 << 7); const SWord8 s775 = 128 | s774; const SWord8 s776 = 127 & s774; const SWord8 s777 = s689 ? s775 : s776; const SWord8 s778 = s1 + s773; const SBool s779 = s778 < s1; const SBool s780 = s778 < s773; const SBool s781 = s779 || s780; const SWord8 s782 = (s778 >> 1) | (s778 << 7); const SWord8 s783 = 128 | s782; const SWord8 s784 = 127 & s782; const SWord8 s785 = s781 ? s783 : s784; const SWord8 s786 = s690 ? s777 : s785; const SWord8 s787 = s566 ? s765 : s786; const SWord8 s788 = s544 ? s740 : s787; const SWord8 s789 = s36 ? s680 : s788; const SWord8 s790 = s1 + s551; const SBool s791 = (SBool) ((s790 >> 0) & 1); const SBool s792 = false != s791; const SWord8 s793 = s792 ? s555 : s556; const SBool s794 = (SBool) ((s793 >> 0) & 1); const SBool s795 = false != s794; const SWord8 s796 = s795 ? s561 : s562; const SBool s797 = (SBool) ((s796 >> 0) & 1); const SBool s798 = false != s797; const SBool s799 = false == s798; const SBool s800 = s790 < s1; const SBool s801 = s790 < s551; const SBool s802 = s800 || s801; const SWord8 s803 = (s790 >> 1) | (s790 << 7); const SWord8 s804 = 128 | s803; const SWord8 s805 = 127 & s803; const SWord8 s806 = s802 ? s804 : s805; const SBool s807 = (SBool) ((s806 >> 0) & 1); const SBool s808 = false != s807; const SWord8 s809 = (s793 >> 1) | (s793 << 7); const SWord8 s810 = 128 | s809; const SWord8 s811 = 127 & s809; const SWord8 s812 = s808 ? s810 : s811; const SBool s813 = (SBool) ((s812 >> 0) & 1); const SBool s814 = false != s813; const SWord8 s815 = (s796 >> 1) | (s796 << 7); const SWord8 s816 = 128 | s815; const SWord8 s817 = 127 & s815; const SWord8 s818 = s814 ? s816 : s817; const SBool s819 = (SBool) ((s818 >> 0) & 1); const SBool s820 = false != s819; const SBool s821 = false == s820; const SWord8 s822 = (s806 >> 1) | (s806 << 7); const SWord8 s823 = 128 | s822; const SWord8 s824 = 127 & s822; const SWord8 s825 = s35 ? s823 : s824; const SWord8 s826 = (s825 >> 1) | (s825 << 7); const SWord8 s827 = 128 | s826; const SWord8 s828 = 127 & s826; const SWord8 s829 = s543 ? s827 : s828; const SWord8 s830 = (s829 >> 1) | (s829 << 7); const SWord8 s831 = 128 | s830; const SWord8 s832 = 127 & s830; const SWord8 s833 = s798 ? s831 : s832; const SWord8 s834 = (s833 >> 1) | (s833 << 7); const SWord8 s835 = 128 | s834; const SWord8 s836 = 127 & s834; const SWord8 s837 = s820 ? s835 : s836; const SWord8 s838 = s1 + s833; const SBool s839 = s838 < s1; const SBool s840 = s838 < s833; const SBool s841 = s839 || s840; const SWord8 s842 = (s838 >> 1) | (s838 << 7); const SWord8 s843 = 128 | s842; const SWord8 s844 = 127 & s842; const SWord8 s845 = s841 ? s843 : s844; const SWord8 s846 = s821 ? s837 : s845; const SWord8 s847 = s1 + s829; const SBool s848 = s847 < s1; const SBool s849 = s847 < s829; const SBool s850 = s848 || s849; const SWord8 s851 = (s847 >> 1) | (s847 << 7); const SWord8 s852 = 128 | s851; const SWord8 s853 = 127 & s851; const SWord8 s854 = s850 ? s852 : s853; const SWord8 s855 = (s854 >> 1) | (s854 << 7); const SWord8 s856 = 128 | s855; const SWord8 s857 = 127 & s855; const SWord8 s858 = s820 ? s856 : s857; const SWord8 s859 = s1 + s854; const SBool s860 = s859 < s1; const SBool s861 = s859 < s854; const SBool s862 = s860 || s861; const SWord8 s863 = (s859 >> 1) | (s859 << 7); const SWord8 s864 = 128 | s863; const SWord8 s865 = 127 & s863; const SWord8 s866 = s862 ? s864 : s865; const SWord8 s867 = s821 ? s858 : s866; const SWord8 s868 = s799 ? s846 : s867; const SWord8 s869 = s1 + s825; const SBool s870 = s869 < s1; const SBool s871 = s869 < s825; const SBool s872 = s870 || s871; const SWord8 s873 = (s869 >> 1) | (s869 << 7); const SWord8 s874 = 128 | s873; const SWord8 s875 = 127 & s873; const SWord8 s876 = s872 ? s874 : s875; const SWord8 s877 = (s876 >> 1) | (s876 << 7); const SWord8 s878 = 128 | s877; const SWord8 s879 = 127 & s877; const SWord8 s880 = s798 ? s878 : s879; const SWord8 s881 = (s880 >> 1) | (s880 << 7); const SWord8 s882 = 128 | s881; const SWord8 s883 = 127 & s881; const SWord8 s884 = s820 ? s882 : s883; const SWord8 s885 = s1 + s880; const SBool s886 = s885 < s1; const SBool s887 = s885 < s880; const SBool s888 = s886 || s887; const SWord8 s889 = (s885 >> 1) | (s885 << 7); const SWord8 s890 = 128 | s889; const SWord8 s891 = 127 & s889; const SWord8 s892 = s888 ? s890 : s891; const SWord8 s893 = s821 ? s884 : s892; const SWord8 s894 = s1 + s876; const SBool s895 = s894 < s1; const SBool s896 = s894 < s876; const SBool s897 = s895 || s896; const SWord8 s898 = (s894 >> 1) | (s894 << 7); const SWord8 s899 = 128 | s898; const SWord8 s900 = 127 & s898; const SWord8 s901 = s897 ? s899 : s900; const SWord8 s902 = (s901 >> 1) | (s901 << 7); const SWord8 s903 = 128 | s902; const SWord8 s904 = 127 & s902; const SWord8 s905 = s820 ? s903 : s904; const SWord8 s906 = s1 + s901; const SBool s907 = s906 < s1; const SBool s908 = s906 < s901; const SBool s909 = s907 || s908; const SWord8 s910 = (s906 >> 1) | (s906 << 7); const SWord8 s911 = 128 | s910; const SWord8 s912 = 127 & s910; const SWord8 s913 = s909 ? s911 : s912; const SWord8 s914 = s821 ? s905 : s913; const SWord8 s915 = s799 ? s893 : s914; const SWord8 s916 = s544 ? s868 : s915; const SWord8 s917 = s1 + s806; const SBool s918 = (SBool) ((s917 >> 0) & 1); const SBool s919 = false != s918; const SWord8 s920 = s919 ? s810 : s811; const SBool s921 = (SBool) ((s920 >> 0) & 1); const SBool s922 = false != s921; const SWord8 s923 = s922 ? s816 : s817; const SBool s924 = (SBool) ((s923 >> 0) & 1); const SBool s925 = false != s924; const SBool s926 = false == s925; const SBool s927 = s917 < s1; const SBool s928 = s917 < s806; const SBool s929 = s927 || s928; const SWord8 s930 = (s917 >> 1) | (s917 << 7); const SWord8 s931 = 128 | s930; const SWord8 s932 = 127 & s930; const SWord8 s933 = s929 ? s931 : s932; const SWord8 s934 = (s933 >> 1) | (s933 << 7); const SWord8 s935 = 128 | s934; const SWord8 s936 = 127 & s934; const SWord8 s937 = s543 ? s935 : s936; const SWord8 s938 = (s937 >> 1) | (s937 << 7); const SWord8 s939 = 128 | s938; const SWord8 s940 = 127 & s938; const SWord8 s941 = s798 ? s939 : s940; const SWord8 s942 = (s941 >> 1) | (s941 << 7); const SWord8 s943 = 128 | s942; const SWord8 s944 = 127 & s942; const SWord8 s945 = s925 ? s943 : s944; const SWord8 s946 = s1 + s941; const SBool s947 = s946 < s1; const SBool s948 = s946 < s941; const SBool s949 = s947 || s948; const SWord8 s950 = (s946 >> 1) | (s946 << 7); const SWord8 s951 = 128 | s950; const SWord8 s952 = 127 & s950; const SWord8 s953 = s949 ? s951 : s952; const SWord8 s954 = s926 ? s945 : s953; const SWord8 s955 = s1 + s937; const SBool s956 = s955 < s1; const SBool s957 = s955 < s937; const SBool s958 = s956 || s957; const SWord8 s959 = (s955 >> 1) | (s955 << 7); const SWord8 s960 = 128 | s959; const SWord8 s961 = 127 & s959; const SWord8 s962 = s958 ? s960 : s961; const SWord8 s963 = (s962 >> 1) | (s962 << 7); const SWord8 s964 = 128 | s963; const SWord8 s965 = 127 & s963; const SWord8 s966 = s925 ? s964 : s965; const SWord8 s967 = s1 + s962; const SBool s968 = s967 < s1; const SBool s969 = s967 < s962; const SBool s970 = s968 || s969; const SWord8 s971 = (s967 >> 1) | (s967 << 7); const SWord8 s972 = 128 | s971; const SWord8 s973 = 127 & s971; const SWord8 s974 = s970 ? s972 : s973; const SWord8 s975 = s926 ? s966 : s974; const SWord8 s976 = s799 ? s954 : s975; const SWord8 s977 = s1 + s933; const SBool s978 = s977 < s1; const SBool s979 = s977 < s933; const SBool s980 = s978 || s979; const SWord8 s981 = (s977 >> 1) | (s977 << 7); const SWord8 s982 = 128 | s981; const SWord8 s983 = 127 & s981; const SWord8 s984 = s980 ? s982 : s983; const SWord8 s985 = (s984 >> 1) | (s984 << 7); const SWord8 s986 = 128 | s985; const SWord8 s987 = 127 & s985; const SWord8 s988 = s798 ? s986 : s987; const SWord8 s989 = (s988 >> 1) | (s988 << 7); const SWord8 s990 = 128 | s989; const SWord8 s991 = 127 & s989; const SWord8 s992 = s925 ? s990 : s991; const SWord8 s993 = s1 + s988; const SBool s994 = s993 < s1; const SBool s995 = s993 < s988; const SBool s996 = s994 || s995; const SWord8 s997 = (s993 >> 1) | (s993 << 7); const SWord8 s998 = 128 | s997; const SWord8 s999 = 127 & s997; const SWord8 s1000 = s996 ? s998 : s999; const SWord8 s1001 = s926 ? s992 : s1000; const SWord8 s1002 = s1 + s984; const SBool s1003 = s1002 < s1; const SBool s1004 = s1002 < s984; const SBool s1005 = s1003 || s1004; const SWord8 s1006 = (s1002 >> 1) | (s1002 << 7); const SWord8 s1007 = 128 | s1006; const SWord8 s1008 = 127 & s1006; const SWord8 s1009 = s1005 ? s1007 : s1008; const SWord8 s1010 = (s1009 >> 1) | (s1009 << 7); const SWord8 s1011 = 128 | s1010; const SWord8 s1012 = 127 & s1010; const SWord8 s1013 = s925 ? s1011 : s1012; const SWord8 s1014 = s1 + s1009; const SBool s1015 = s1014 < s1; const SBool s1016 = s1014 < s1009; const SBool s1017 = s1015 || s1016; const SWord8 s1018 = (s1014 >> 1) | (s1014 << 7); const SWord8 s1019 = 128 | s1018; const SWord8 s1020 = 127 & s1018; const SWord8 s1021 = s1017 ? s1019 : s1020; const SWord8 s1022 = s926 ? s1013 : s1021; const SWord8 s1023 = s799 ? s1001 : s1022; const SWord8 s1024 = s544 ? s976 : s1023; const SWord8 s1025 = s36 ? s916 : s1024; const SWord8 s1026 = s21 ? s789 : s1025; const SWord8 s1027 = s16 ? s534 : s1026; const SWord8 s1028 = s1 + s24; const SBool s1029 = (SBool) ((s1028 >> 0) & 1); const SBool s1030 = false != s1029; const SWord8 s1031 = s1030 ? 128 : 0; const SBool s1032 = (SBool) ((s1031 >> 0) & 1); const SBool s1033 = false != s1032; const SWord8 s1034 = s1033 ? s31 : s32; const SBool s1035 = (SBool) ((s1034 >> 0) & 1); const SBool s1036 = false != s1035; const SBool s1037 = false == s1036; const SBool s1038 = s1028 < s1; const SBool s1039 = s1028 < s24; const SBool s1040 = s1038 || s1039; const SWord8 s1041 = (s1028 >> 1) | (s1028 << 7); const SWord8 s1042 = 128 | s1041; const SWord8 s1043 = 127 & s1041; const SWord8 s1044 = s1040 ? s1042 : s1043; const SBool s1045 = (SBool) ((s1044 >> 0) & 1); const SBool s1046 = false != s1045; const SWord8 s1047 = (s1031 >> 1) | (s1031 << 7); const SWord8 s1048 = 128 | s1047; const SWord8 s1049 = 127 & s1047; const SWord8 s1050 = s1046 ? s1048 : s1049; const SBool s1051 = (SBool) ((s1050 >> 0) & 1); const SBool s1052 = false != s1051; const SWord8 s1053 = (s1034 >> 1) | (s1034 << 7); const SWord8 s1054 = 128 | s1053; const SWord8 s1055 = 127 & s1053; const SWord8 s1056 = s1052 ? s1054 : s1055; const SBool s1057 = (SBool) ((s1056 >> 0) & 1); const SBool s1058 = false != s1057; const SBool s1059 = false == s1058; const SWord8 s1060 = (s1044 >> 1) | (s1044 << 7); const SWord8 s1061 = 128 | s1060; const SWord8 s1062 = 127 & s1060; const SWord8 s1063 = s15 ? s1061 : s1062; const SBool s1064 = (SBool) ((s1063 >> 0) & 1); const SBool s1065 = false != s1064; const SWord8 s1066 = (s1050 >> 1) | (s1050 << 7); const SWord8 s1067 = 128 | s1066; const SWord8 s1068 = 127 & s1066; const SWord8 s1069 = s1065 ? s1067 : s1068; const SBool s1070 = (SBool) ((s1069 >> 0) & 1); const SBool s1071 = false != s1070; const SWord8 s1072 = (s1056 >> 1) | (s1056 << 7); const SWord8 s1073 = 128 | s1072; const SWord8 s1074 = 127 & s1072; const SWord8 s1075 = s1071 ? s1073 : s1074; const SBool s1076 = (SBool) ((s1075 >> 0) & 1); const SBool s1077 = false != s1076; const SBool s1078 = false == s1077; const SWord8 s1079 = (s1063 >> 1) | (s1063 << 7); const SWord8 s1080 = 128 | s1079; const SWord8 s1081 = 127 & s1079; const SWord8 s1082 = s20 ? s1080 : s1081; const SBool s1083 = (SBool) ((s1082 >> 0) & 1); const SBool s1084 = false != s1083; const SWord8 s1085 = (s1069 >> 1) | (s1069 << 7); const SWord8 s1086 = 128 | s1085; const SWord8 s1087 = 127 & s1085; const SWord8 s1088 = s1084 ? s1086 : s1087; const SBool s1089 = (SBool) ((s1088 >> 0) & 1); const SBool s1090 = false != s1089; const SWord8 s1091 = (s1075 >> 1) | (s1075 << 7); const SWord8 s1092 = 128 | s1091; const SWord8 s1093 = 127 & s1091; const SWord8 s1094 = s1090 ? s1092 : s1093; const SBool s1095 = (SBool) ((s1094 >> 0) & 1); const SBool s1096 = false != s1095; const SBool s1097 = false == s1096; const SWord8 s1098 = (s1082 >> 1) | (s1082 << 7); const SWord8 s1099 = 128 | s1098; const SWord8 s1100 = 127 & s1098; const SWord8 s1101 = s1036 ? s1099 : s1100; const SWord8 s1102 = (s1101 >> 1) | (s1101 << 7); const SWord8 s1103 = 128 | s1102; const SWord8 s1104 = 127 & s1102; const SWord8 s1105 = s1058 ? s1103 : s1104; const SWord8 s1106 = (s1105 >> 1) | (s1105 << 7); const SWord8 s1107 = 128 | s1106; const SWord8 s1108 = 127 & s1106; const SWord8 s1109 = s1077 ? s1107 : s1108; const SWord8 s1110 = (s1109 >> 1) | (s1109 << 7); const SWord8 s1111 = 128 | s1110; const SWord8 s1112 = 127 & s1110; const SWord8 s1113 = s1096 ? s1111 : s1112; const SWord8 s1114 = s1 + s1109; const SBool s1115 = s1114 < s1; const SBool s1116 = s1114 < s1109; const SBool s1117 = s1115 || s1116; const SWord8 s1118 = (s1114 >> 1) | (s1114 << 7); const SWord8 s1119 = 128 | s1118; const SWord8 s1120 = 127 & s1118; const SWord8 s1121 = s1117 ? s1119 : s1120; const SWord8 s1122 = s1097 ? s1113 : s1121; const SWord8 s1123 = s1 + s1105; const SBool s1124 = s1123 < s1; const SBool s1125 = s1123 < s1105; const SBool s1126 = s1124 || s1125; const SWord8 s1127 = (s1123 >> 1) | (s1123 << 7); const SWord8 s1128 = 128 | s1127; const SWord8 s1129 = 127 & s1127; const SWord8 s1130 = s1126 ? s1128 : s1129; const SWord8 s1131 = (s1130 >> 1) | (s1130 << 7); const SWord8 s1132 = 128 | s1131; const SWord8 s1133 = 127 & s1131; const SWord8 s1134 = s1096 ? s1132 : s1133; const SWord8 s1135 = s1 + s1130; const SBool s1136 = s1135 < s1; const SBool s1137 = s1135 < s1130; const SBool s1138 = s1136 || s1137; const SWord8 s1139 = (s1135 >> 1) | (s1135 << 7); const SWord8 s1140 = 128 | s1139; const SWord8 s1141 = 127 & s1139; const SWord8 s1142 = s1138 ? s1140 : s1141; const SWord8 s1143 = s1097 ? s1134 : s1142; const SWord8 s1144 = s1078 ? s1122 : s1143; const SWord8 s1145 = s1 + s1101; const SBool s1146 = s1145 < s1; const SBool s1147 = s1145 < s1101; const SBool s1148 = s1146 || s1147; const SWord8 s1149 = (s1145 >> 1) | (s1145 << 7); const SWord8 s1150 = 128 | s1149; const SWord8 s1151 = 127 & s1149; const SWord8 s1152 = s1148 ? s1150 : s1151; const SWord8 s1153 = (s1152 >> 1) | (s1152 << 7); const SWord8 s1154 = 128 | s1153; const SWord8 s1155 = 127 & s1153; const SWord8 s1156 = s1077 ? s1154 : s1155; const SWord8 s1157 = (s1156 >> 1) | (s1156 << 7); const SWord8 s1158 = 128 | s1157; const SWord8 s1159 = 127 & s1157; const SWord8 s1160 = s1096 ? s1158 : s1159; const SWord8 s1161 = s1 + s1156; const SBool s1162 = s1161 < s1; const SBool s1163 = s1161 < s1156; const SBool s1164 = s1162 || s1163; const SWord8 s1165 = (s1161 >> 1) | (s1161 << 7); const SWord8 s1166 = 128 | s1165; const SWord8 s1167 = 127 & s1165; const SWord8 s1168 = s1164 ? s1166 : s1167; const SWord8 s1169 = s1097 ? s1160 : s1168; const SWord8 s1170 = s1 + s1152; const SBool s1171 = s1170 < s1; const SBool s1172 = s1170 < s1152; const SBool s1173 = s1171 || s1172; const SWord8 s1174 = (s1170 >> 1) | (s1170 << 7); const SWord8 s1175 = 128 | s1174; const SWord8 s1176 = 127 & s1174; const SWord8 s1177 = s1173 ? s1175 : s1176; const SWord8 s1178 = (s1177 >> 1) | (s1177 << 7); const SWord8 s1179 = 128 | s1178; const SWord8 s1180 = 127 & s1178; const SWord8 s1181 = s1096 ? s1179 : s1180; const SWord8 s1182 = s1 + s1177; const SBool s1183 = s1182 < s1; const SBool s1184 = s1182 < s1177; const SBool s1185 = s1183 || s1184; const SWord8 s1186 = (s1182 >> 1) | (s1182 << 7); const SWord8 s1187 = 128 | s1186; const SWord8 s1188 = 127 & s1186; const SWord8 s1189 = s1185 ? s1187 : s1188; const SWord8 s1190 = s1097 ? s1181 : s1189; const SWord8 s1191 = s1078 ? s1169 : s1190; const SWord8 s1192 = s1059 ? s1144 : s1191; const SWord8 s1193 = s1 + s1082; const SBool s1194 = (SBool) ((s1193 >> 0) & 1); const SBool s1195 = false != s1194; const SWord8 s1196 = s1195 ? s1086 : s1087; const SBool s1197 = (SBool) ((s1196 >> 0) & 1); const SBool s1198 = false != s1197; const SWord8 s1199 = s1198 ? s1092 : s1093; const SBool s1200 = (SBool) ((s1199 >> 0) & 1); const SBool s1201 = false != s1200; const SBool s1202 = false == s1201; const SBool s1203 = s1193 < s1; const SBool s1204 = s1193 < s1082; const SBool s1205 = s1203 || s1204; const SWord8 s1206 = (s1193 >> 1) | (s1193 << 7); const SWord8 s1207 = 128 | s1206; const SWord8 s1208 = 127 & s1206; const SWord8 s1209 = s1205 ? s1207 : s1208; const SWord8 s1210 = (s1209 >> 1) | (s1209 << 7); const SWord8 s1211 = 128 | s1210; const SWord8 s1212 = 127 & s1210; const SWord8 s1213 = s1058 ? s1211 : s1212; const SWord8 s1214 = (s1213 >> 1) | (s1213 << 7); const SWord8 s1215 = 128 | s1214; const SWord8 s1216 = 127 & s1214; const SWord8 s1217 = s1077 ? s1215 : s1216; const SWord8 s1218 = (s1217 >> 1) | (s1217 << 7); const SWord8 s1219 = 128 | s1218; const SWord8 s1220 = 127 & s1218; const SWord8 s1221 = s1201 ? s1219 : s1220; const SWord8 s1222 = s1 + s1217; const SBool s1223 = s1222 < s1; const SBool s1224 = s1222 < s1217; const SBool s1225 = s1223 || s1224; const SWord8 s1226 = (s1222 >> 1) | (s1222 << 7); const SWord8 s1227 = 128 | s1226; const SWord8 s1228 = 127 & s1226; const SWord8 s1229 = s1225 ? s1227 : s1228; const SWord8 s1230 = s1202 ? s1221 : s1229; const SWord8 s1231 = s1 + s1213; const SBool s1232 = s1231 < s1; const SBool s1233 = s1231 < s1213; const SBool s1234 = s1232 || s1233; const SWord8 s1235 = (s1231 >> 1) | (s1231 << 7); const SWord8 s1236 = 128 | s1235; const SWord8 s1237 = 127 & s1235; const SWord8 s1238 = s1234 ? s1236 : s1237; const SWord8 s1239 = (s1238 >> 1) | (s1238 << 7); const SWord8 s1240 = 128 | s1239; const SWord8 s1241 = 127 & s1239; const SWord8 s1242 = s1201 ? s1240 : s1241; const SWord8 s1243 = s1 + s1238; const SBool s1244 = s1243 < s1; const SBool s1245 = s1243 < s1238; const SBool s1246 = s1244 || s1245; const SWord8 s1247 = (s1243 >> 1) | (s1243 << 7); const SWord8 s1248 = 128 | s1247; const SWord8 s1249 = 127 & s1247; const SWord8 s1250 = s1246 ? s1248 : s1249; const SWord8 s1251 = s1202 ? s1242 : s1250; const SWord8 s1252 = s1078 ? s1230 : s1251; const SWord8 s1253 = s1 + s1209; const SBool s1254 = s1253 < s1; const SBool s1255 = s1253 < s1209; const SBool s1256 = s1254 || s1255; const SWord8 s1257 = (s1253 >> 1) | (s1253 << 7); const SWord8 s1258 = 128 | s1257; const SWord8 s1259 = 127 & s1257; const SWord8 s1260 = s1256 ? s1258 : s1259; const SWord8 s1261 = (s1260 >> 1) | (s1260 << 7); const SWord8 s1262 = 128 | s1261; const SWord8 s1263 = 127 & s1261; const SWord8 s1264 = s1077 ? s1262 : s1263; const SWord8 s1265 = (s1264 >> 1) | (s1264 << 7); const SWord8 s1266 = 128 | s1265; const SWord8 s1267 = 127 & s1265; const SWord8 s1268 = s1201 ? s1266 : s1267; const SWord8 s1269 = s1 + s1264; const SBool s1270 = s1269 < s1; const SBool s1271 = s1269 < s1264; const SBool s1272 = s1270 || s1271; const SWord8 s1273 = (s1269 >> 1) | (s1269 << 7); const SWord8 s1274 = 128 | s1273; const SWord8 s1275 = 127 & s1273; const SWord8 s1276 = s1272 ? s1274 : s1275; const SWord8 s1277 = s1202 ? s1268 : s1276; const SWord8 s1278 = s1 + s1260; const SBool s1279 = s1278 < s1; const SBool s1280 = s1278 < s1260; const SBool s1281 = s1279 || s1280; const SWord8 s1282 = (s1278 >> 1) | (s1278 << 7); const SWord8 s1283 = 128 | s1282; const SWord8 s1284 = 127 & s1282; const SWord8 s1285 = s1281 ? s1283 : s1284; const SWord8 s1286 = (s1285 >> 1) | (s1285 << 7); const SWord8 s1287 = 128 | s1286; const SWord8 s1288 = 127 & s1286; const SWord8 s1289 = s1201 ? s1287 : s1288; const SWord8 s1290 = s1 + s1285; const SBool s1291 = s1290 < s1; const SBool s1292 = s1290 < s1285; const SBool s1293 = s1291 || s1292; const SWord8 s1294 = (s1290 >> 1) | (s1290 << 7); const SWord8 s1295 = 128 | s1294; const SWord8 s1296 = 127 & s1294; const SWord8 s1297 = s1293 ? s1295 : s1296; const SWord8 s1298 = s1202 ? s1289 : s1297; const SWord8 s1299 = s1078 ? s1277 : s1298; const SWord8 s1300 = s1059 ? s1252 : s1299; const SWord8 s1301 = s1037 ? s1192 : s1300; const SWord8 s1302 = s1 + s1063; const SBool s1303 = (SBool) ((s1302 >> 0) & 1); const SBool s1304 = false != s1303; const SWord8 s1305 = s1304 ? s1067 : s1068; const SBool s1306 = (SBool) ((s1305 >> 0) & 1); const SBool s1307 = false != s1306; const SWord8 s1308 = s1307 ? s1073 : s1074; const SBool s1309 = (SBool) ((s1308 >> 0) & 1); const SBool s1310 = false != s1309; const SBool s1311 = false == s1310; const SBool s1312 = s1302 < s1; const SBool s1313 = s1302 < s1063; const SBool s1314 = s1312 || s1313; const SWord8 s1315 = (s1302 >> 1) | (s1302 << 7); const SWord8 s1316 = 128 | s1315; const SWord8 s1317 = 127 & s1315; const SWord8 s1318 = s1314 ? s1316 : s1317; const SBool s1319 = (SBool) ((s1318 >> 0) & 1); const SBool s1320 = false != s1319; const SWord8 s1321 = (s1305 >> 1) | (s1305 << 7); const SWord8 s1322 = 128 | s1321; const SWord8 s1323 = 127 & s1321; const SWord8 s1324 = s1320 ? s1322 : s1323; const SBool s1325 = (SBool) ((s1324 >> 0) & 1); const SBool s1326 = false != s1325; const SWord8 s1327 = (s1308 >> 1) | (s1308 << 7); const SWord8 s1328 = 128 | s1327; const SWord8 s1329 = 127 & s1327; const SWord8 s1330 = s1326 ? s1328 : s1329; const SBool s1331 = (SBool) ((s1330 >> 0) & 1); const SBool s1332 = false != s1331; const SBool s1333 = false == s1332; const SWord8 s1334 = (s1318 >> 1) | (s1318 << 7); const SWord8 s1335 = 128 | s1334; const SWord8 s1336 = 127 & s1334; const SWord8 s1337 = s1036 ? s1335 : s1336; const SWord8 s1338 = (s1337 >> 1) | (s1337 << 7); const SWord8 s1339 = 128 | s1338; const SWord8 s1340 = 127 & s1338; const SWord8 s1341 = s1058 ? s1339 : s1340; const SWord8 s1342 = (s1341 >> 1) | (s1341 << 7); const SWord8 s1343 = 128 | s1342; const SWord8 s1344 = 127 & s1342; const SWord8 s1345 = s1310 ? s1343 : s1344; const SWord8 s1346 = (s1345 >> 1) | (s1345 << 7); const SWord8 s1347 = 128 | s1346; const SWord8 s1348 = 127 & s1346; const SWord8 s1349 = s1332 ? s1347 : s1348; const SWord8 s1350 = s1 + s1345; const SBool s1351 = s1350 < s1; const SBool s1352 = s1350 < s1345; const SBool s1353 = s1351 || s1352; const SWord8 s1354 = (s1350 >> 1) | (s1350 << 7); const SWord8 s1355 = 128 | s1354; const SWord8 s1356 = 127 & s1354; const SWord8 s1357 = s1353 ? s1355 : s1356; const SWord8 s1358 = s1333 ? s1349 : s1357; const SWord8 s1359 = s1 + s1341; const SBool s1360 = s1359 < s1; const SBool s1361 = s1359 < s1341; const SBool s1362 = s1360 || s1361; const SWord8 s1363 = (s1359 >> 1) | (s1359 << 7); const SWord8 s1364 = 128 | s1363; const SWord8 s1365 = 127 & s1363; const SWord8 s1366 = s1362 ? s1364 : s1365; const SWord8 s1367 = (s1366 >> 1) | (s1366 << 7); const SWord8 s1368 = 128 | s1367; const SWord8 s1369 = 127 & s1367; const SWord8 s1370 = s1332 ? s1368 : s1369; const SWord8 s1371 = s1 + s1366; const SBool s1372 = s1371 < s1; const SBool s1373 = s1371 < s1366; const SBool s1374 = s1372 || s1373; const SWord8 s1375 = (s1371 >> 1) | (s1371 << 7); const SWord8 s1376 = 128 | s1375; const SWord8 s1377 = 127 & s1375; const SWord8 s1378 = s1374 ? s1376 : s1377; const SWord8 s1379 = s1333 ? s1370 : s1378; const SWord8 s1380 = s1311 ? s1358 : s1379; const SWord8 s1381 = s1 + s1337; const SBool s1382 = s1381 < s1; const SBool s1383 = s1381 < s1337; const SBool s1384 = s1382 || s1383; const SWord8 s1385 = (s1381 >> 1) | (s1381 << 7); const SWord8 s1386 = 128 | s1385; const SWord8 s1387 = 127 & s1385; const SWord8 s1388 = s1384 ? s1386 : s1387; const SWord8 s1389 = (s1388 >> 1) | (s1388 << 7); const SWord8 s1390 = 128 | s1389; const SWord8 s1391 = 127 & s1389; const SWord8 s1392 = s1310 ? s1390 : s1391; const SWord8 s1393 = (s1392 >> 1) | (s1392 << 7); const SWord8 s1394 = 128 | s1393; const SWord8 s1395 = 127 & s1393; const SWord8 s1396 = s1332 ? s1394 : s1395; const SWord8 s1397 = s1 + s1392; const SBool s1398 = s1397 < s1; const SBool s1399 = s1397 < s1392; const SBool s1400 = s1398 || s1399; const SWord8 s1401 = (s1397 >> 1) | (s1397 << 7); const SWord8 s1402 = 128 | s1401; const SWord8 s1403 = 127 & s1401; const SWord8 s1404 = s1400 ? s1402 : s1403; const SWord8 s1405 = s1333 ? s1396 : s1404; const SWord8 s1406 = s1 + s1388; const SBool s1407 = s1406 < s1; const SBool s1408 = s1406 < s1388; const SBool s1409 = s1407 || s1408; const SWord8 s1410 = (s1406 >> 1) | (s1406 << 7); const SWord8 s1411 = 128 | s1410; const SWord8 s1412 = 127 & s1410; const SWord8 s1413 = s1409 ? s1411 : s1412; const SWord8 s1414 = (s1413 >> 1) | (s1413 << 7); const SWord8 s1415 = 128 | s1414; const SWord8 s1416 = 127 & s1414; const SWord8 s1417 = s1332 ? s1415 : s1416; const SWord8 s1418 = s1 + s1413; const SBool s1419 = s1418 < s1; const SBool s1420 = s1418 < s1413; const SBool s1421 = s1419 || s1420; const SWord8 s1422 = (s1418 >> 1) | (s1418 << 7); const SWord8 s1423 = 128 | s1422; const SWord8 s1424 = 127 & s1422; const SWord8 s1425 = s1421 ? s1423 : s1424; const SWord8 s1426 = s1333 ? s1417 : s1425; const SWord8 s1427 = s1311 ? s1405 : s1426; const SWord8 s1428 = s1059 ? s1380 : s1427; const SWord8 s1429 = s1 + s1318; const SBool s1430 = (SBool) ((s1429 >> 0) & 1); const SBool s1431 = false != s1430; const SWord8 s1432 = s1431 ? s1322 : s1323; const SBool s1433 = (SBool) ((s1432 >> 0) & 1); const SBool s1434 = false != s1433; const SWord8 s1435 = s1434 ? s1328 : s1329; const SBool s1436 = (SBool) ((s1435 >> 0) & 1); const SBool s1437 = false != s1436; const SBool s1438 = false == s1437; const SBool s1439 = s1429 < s1; const SBool s1440 = s1429 < s1318; const SBool s1441 = s1439 || s1440; const SWord8 s1442 = (s1429 >> 1) | (s1429 << 7); const SWord8 s1443 = 128 | s1442; const SWord8 s1444 = 127 & s1442; const SWord8 s1445 = s1441 ? s1443 : s1444; const SWord8 s1446 = (s1445 >> 1) | (s1445 << 7); const SWord8 s1447 = 128 | s1446; const SWord8 s1448 = 127 & s1446; const SWord8 s1449 = s1058 ? s1447 : s1448; const SWord8 s1450 = (s1449 >> 1) | (s1449 << 7); const SWord8 s1451 = 128 | s1450; const SWord8 s1452 = 127 & s1450; const SWord8 s1453 = s1310 ? s1451 : s1452; const SWord8 s1454 = (s1453 >> 1) | (s1453 << 7); const SWord8 s1455 = 128 | s1454; const SWord8 s1456 = 127 & s1454; const SWord8 s1457 = s1437 ? s1455 : s1456; const SWord8 s1458 = s1 + s1453; const SBool s1459 = s1458 < s1; const SBool s1460 = s1458 < s1453; const SBool s1461 = s1459 || s1460; const SWord8 s1462 = (s1458 >> 1) | (s1458 << 7); const SWord8 s1463 = 128 | s1462; const SWord8 s1464 = 127 & s1462; const SWord8 s1465 = s1461 ? s1463 : s1464; const SWord8 s1466 = s1438 ? s1457 : s1465; const SWord8 s1467 = s1 + s1449; const SBool s1468 = s1467 < s1; const SBool s1469 = s1467 < s1449; const SBool s1470 = s1468 || s1469; const SWord8 s1471 = (s1467 >> 1) | (s1467 << 7); const SWord8 s1472 = 128 | s1471; const SWord8 s1473 = 127 & s1471; const SWord8 s1474 = s1470 ? s1472 : s1473; const SWord8 s1475 = (s1474 >> 1) | (s1474 << 7); const SWord8 s1476 = 128 | s1475; const SWord8 s1477 = 127 & s1475; const SWord8 s1478 = s1437 ? s1476 : s1477; const SWord8 s1479 = s1 + s1474; const SBool s1480 = s1479 < s1; const SBool s1481 = s1479 < s1474; const SBool s1482 = s1480 || s1481; const SWord8 s1483 = (s1479 >> 1) | (s1479 << 7); const SWord8 s1484 = 128 | s1483; const SWord8 s1485 = 127 & s1483; const SWord8 s1486 = s1482 ? s1484 : s1485; const SWord8 s1487 = s1438 ? s1478 : s1486; const SWord8 s1488 = s1311 ? s1466 : s1487; const SWord8 s1489 = s1 + s1445; const SBool s1490 = s1489 < s1; const SBool s1491 = s1489 < s1445; const SBool s1492 = s1490 || s1491; const SWord8 s1493 = (s1489 >> 1) | (s1489 << 7); const SWord8 s1494 = 128 | s1493; const SWord8 s1495 = 127 & s1493; const SWord8 s1496 = s1492 ? s1494 : s1495; const SWord8 s1497 = (s1496 >> 1) | (s1496 << 7); const SWord8 s1498 = 128 | s1497; const SWord8 s1499 = 127 & s1497; const SWord8 s1500 = s1310 ? s1498 : s1499; const SWord8 s1501 = (s1500 >> 1) | (s1500 << 7); const SWord8 s1502 = 128 | s1501; const SWord8 s1503 = 127 & s1501; const SWord8 s1504 = s1437 ? s1502 : s1503; const SWord8 s1505 = s1 + s1500; const SBool s1506 = s1505 < s1; const SBool s1507 = s1505 < s1500; const SBool s1508 = s1506 || s1507; const SWord8 s1509 = (s1505 >> 1) | (s1505 << 7); const SWord8 s1510 = 128 | s1509; const SWord8 s1511 = 127 & s1509; const SWord8 s1512 = s1508 ? s1510 : s1511; const SWord8 s1513 = s1438 ? s1504 : s1512; const SWord8 s1514 = s1 + s1496; const SBool s1515 = s1514 < s1; const SBool s1516 = s1514 < s1496; const SBool s1517 = s1515 || s1516; const SWord8 s1518 = (s1514 >> 1) | (s1514 << 7); const SWord8 s1519 = 128 | s1518; const SWord8 s1520 = 127 & s1518; const SWord8 s1521 = s1517 ? s1519 : s1520; const SWord8 s1522 = (s1521 >> 1) | (s1521 << 7); const SWord8 s1523 = 128 | s1522; const SWord8 s1524 = 127 & s1522; const SWord8 s1525 = s1437 ? s1523 : s1524; const SWord8 s1526 = s1 + s1521; const SBool s1527 = s1526 < s1; const SBool s1528 = s1526 < s1521; const SBool s1529 = s1527 || s1528; const SWord8 s1530 = (s1526 >> 1) | (s1526 << 7); const SWord8 s1531 = 128 | s1530; const SWord8 s1532 = 127 & s1530; const SWord8 s1533 = s1529 ? s1531 : s1532; const SWord8 s1534 = s1438 ? s1525 : s1533; const SWord8 s1535 = s1311 ? s1513 : s1534; const SWord8 s1536 = s1059 ? s1488 : s1535; const SWord8 s1537 = s1037 ? s1428 : s1536; const SWord8 s1538 = s21 ? s1301 : s1537; const SWord8 s1539 = s1 + s1044; const SBool s1540 = (SBool) ((s1539 >> 0) & 1); const SBool s1541 = false != s1540; const SWord8 s1542 = s1541 ? s1048 : s1049; const SBool s1543 = (SBool) ((s1542 >> 0) & 1); const SBool s1544 = false != s1543; const SWord8 s1545 = s1544 ? s1054 : s1055; const SBool s1546 = (SBool) ((s1545 >> 0) & 1); const SBool s1547 = false != s1546; const SBool s1548 = false == s1547; const SBool s1549 = s1539 < s1; const SBool s1550 = s1539 < s1044; const SBool s1551 = s1549 || s1550; const SWord8 s1552 = (s1539 >> 1) | (s1539 << 7); const SWord8 s1553 = 128 | s1552; const SWord8 s1554 = 127 & s1552; const SWord8 s1555 = s1551 ? s1553 : s1554; const SBool s1556 = (SBool) ((s1555 >> 0) & 1); const SBool s1557 = false != s1556; const SWord8 s1558 = (s1542 >> 1) | (s1542 << 7); const SWord8 s1559 = 128 | s1558; const SWord8 s1560 = 127 & s1558; const SWord8 s1561 = s1557 ? s1559 : s1560; const SBool s1562 = (SBool) ((s1561 >> 0) & 1); const SBool s1563 = false != s1562; const SWord8 s1564 = (s1545 >> 1) | (s1545 << 7); const SWord8 s1565 = 128 | s1564; const SWord8 s1566 = 127 & s1564; const SWord8 s1567 = s1563 ? s1565 : s1566; const SBool s1568 = (SBool) ((s1567 >> 0) & 1); const SBool s1569 = false != s1568; const SBool s1570 = false == s1569; const SWord8 s1571 = (s1555 >> 1) | (s1555 << 7); const SWord8 s1572 = 128 | s1571; const SWord8 s1573 = 127 & s1571; const SWord8 s1574 = s20 ? s1572 : s1573; const SBool s1575 = (SBool) ((s1574 >> 0) & 1); const SBool s1576 = false != s1575; const SWord8 s1577 = (s1561 >> 1) | (s1561 << 7); const SWord8 s1578 = 128 | s1577; const SWord8 s1579 = 127 & s1577; const SWord8 s1580 = s1576 ? s1578 : s1579; const SBool s1581 = (SBool) ((s1580 >> 0) & 1); const SBool s1582 = false != s1581; const SWord8 s1583 = (s1567 >> 1) | (s1567 << 7); const SWord8 s1584 = 128 | s1583; const SWord8 s1585 = 127 & s1583; const SWord8 s1586 = s1582 ? s1584 : s1585; const SBool s1587 = (SBool) ((s1586 >> 0) & 1); const SBool s1588 = false != s1587; const SBool s1589 = false == s1588; const SWord8 s1590 = (s1574 >> 1) | (s1574 << 7); const SWord8 s1591 = 128 | s1590; const SWord8 s1592 = 127 & s1590; const SWord8 s1593 = s1036 ? s1591 : s1592; const SWord8 s1594 = (s1593 >> 1) | (s1593 << 7); const SWord8 s1595 = 128 | s1594; const SWord8 s1596 = 127 & s1594; const SWord8 s1597 = s1547 ? s1595 : s1596; const SWord8 s1598 = (s1597 >> 1) | (s1597 << 7); const SWord8 s1599 = 128 | s1598; const SWord8 s1600 = 127 & s1598; const SWord8 s1601 = s1569 ? s1599 : s1600; const SWord8 s1602 = (s1601 >> 1) | (s1601 << 7); const SWord8 s1603 = 128 | s1602; const SWord8 s1604 = 127 & s1602; const SWord8 s1605 = s1588 ? s1603 : s1604; const SWord8 s1606 = s1 + s1601; const SBool s1607 = s1606 < s1; const SBool s1608 = s1606 < s1601; const SBool s1609 = s1607 || s1608; const SWord8 s1610 = (s1606 >> 1) | (s1606 << 7); const SWord8 s1611 = 128 | s1610; const SWord8 s1612 = 127 & s1610; const SWord8 s1613 = s1609 ? s1611 : s1612; const SWord8 s1614 = s1589 ? s1605 : s1613; const SWord8 s1615 = s1 + s1597; const SBool s1616 = s1615 < s1; const SBool s1617 = s1615 < s1597; const SBool s1618 = s1616 || s1617; const SWord8 s1619 = (s1615 >> 1) | (s1615 << 7); const SWord8 s1620 = 128 | s1619; const SWord8 s1621 = 127 & s1619; const SWord8 s1622 = s1618 ? s1620 : s1621; const SWord8 s1623 = (s1622 >> 1) | (s1622 << 7); const SWord8 s1624 = 128 | s1623; const SWord8 s1625 = 127 & s1623; const SWord8 s1626 = s1588 ? s1624 : s1625; const SWord8 s1627 = s1 + s1622; const SBool s1628 = s1627 < s1; const SBool s1629 = s1627 < s1622; const SBool s1630 = s1628 || s1629; const SWord8 s1631 = (s1627 >> 1) | (s1627 << 7); const SWord8 s1632 = 128 | s1631; const SWord8 s1633 = 127 & s1631; const SWord8 s1634 = s1630 ? s1632 : s1633; const SWord8 s1635 = s1589 ? s1626 : s1634; const SWord8 s1636 = s1570 ? s1614 : s1635; const SWord8 s1637 = s1 + s1593; const SBool s1638 = s1637 < s1; const SBool s1639 = s1637 < s1593; const SBool s1640 = s1638 || s1639; const SWord8 s1641 = (s1637 >> 1) | (s1637 << 7); const SWord8 s1642 = 128 | s1641; const SWord8 s1643 = 127 & s1641; const SWord8 s1644 = s1640 ? s1642 : s1643; const SWord8 s1645 = (s1644 >> 1) | (s1644 << 7); const SWord8 s1646 = 128 | s1645; const SWord8 s1647 = 127 & s1645; const SWord8 s1648 = s1569 ? s1646 : s1647; const SWord8 s1649 = (s1648 >> 1) | (s1648 << 7); const SWord8 s1650 = 128 | s1649; const SWord8 s1651 = 127 & s1649; const SWord8 s1652 = s1588 ? s1650 : s1651; const SWord8 s1653 = s1 + s1648; const SBool s1654 = s1653 < s1; const SBool s1655 = s1653 < s1648; const SBool s1656 = s1654 || s1655; const SWord8 s1657 = (s1653 >> 1) | (s1653 << 7); const SWord8 s1658 = 128 | s1657; const SWord8 s1659 = 127 & s1657; const SWord8 s1660 = s1656 ? s1658 : s1659; const SWord8 s1661 = s1589 ? s1652 : s1660; const SWord8 s1662 = s1 + s1644; const SBool s1663 = s1662 < s1; const SBool s1664 = s1662 < s1644; const SBool s1665 = s1663 || s1664; const SWord8 s1666 = (s1662 >> 1) | (s1662 << 7); const SWord8 s1667 = 128 | s1666; const SWord8 s1668 = 127 & s1666; const SWord8 s1669 = s1665 ? s1667 : s1668; const SWord8 s1670 = (s1669 >> 1) | (s1669 << 7); const SWord8 s1671 = 128 | s1670; const SWord8 s1672 = 127 & s1670; const SWord8 s1673 = s1588 ? s1671 : s1672; const SWord8 s1674 = s1 + s1669; const SBool s1675 = s1674 < s1; const SBool s1676 = s1674 < s1669; const SBool s1677 = s1675 || s1676; const SWord8 s1678 = (s1674 >> 1) | (s1674 << 7); const SWord8 s1679 = 128 | s1678; const SWord8 s1680 = 127 & s1678; const SWord8 s1681 = s1677 ? s1679 : s1680; const SWord8 s1682 = s1589 ? s1673 : s1681; const SWord8 s1683 = s1570 ? s1661 : s1682; const SWord8 s1684 = s1548 ? s1636 : s1683; const SWord8 s1685 = s1 + s1574; const SBool s1686 = (SBool) ((s1685 >> 0) & 1); const SBool s1687 = false != s1686; const SWord8 s1688 = s1687 ? s1578 : s1579; const SBool s1689 = (SBool) ((s1688 >> 0) & 1); const SBool s1690 = false != s1689; const SWord8 s1691 = s1690 ? s1584 : s1585; const SBool s1692 = (SBool) ((s1691 >> 0) & 1); const SBool s1693 = false != s1692; const SBool s1694 = false == s1693; const SBool s1695 = s1685 < s1; const SBool s1696 = s1685 < s1574; const SBool s1697 = s1695 || s1696; const SWord8 s1698 = (s1685 >> 1) | (s1685 << 7); const SWord8 s1699 = 128 | s1698; const SWord8 s1700 = 127 & s1698; const SWord8 s1701 = s1697 ? s1699 : s1700; const SWord8 s1702 = (s1701 >> 1) | (s1701 << 7); const SWord8 s1703 = 128 | s1702; const SWord8 s1704 = 127 & s1702; const SWord8 s1705 = s1547 ? s1703 : s1704; const SWord8 s1706 = (s1705 >> 1) | (s1705 << 7); const SWord8 s1707 = 128 | s1706; const SWord8 s1708 = 127 & s1706; const SWord8 s1709 = s1569 ? s1707 : s1708; const SWord8 s1710 = (s1709 >> 1) | (s1709 << 7); const SWord8 s1711 = 128 | s1710; const SWord8 s1712 = 127 & s1710; const SWord8 s1713 = s1693 ? s1711 : s1712; const SWord8 s1714 = s1 + s1709; const SBool s1715 = s1714 < s1; const SBool s1716 = s1714 < s1709; const SBool s1717 = s1715 || s1716; const SWord8 s1718 = (s1714 >> 1) | (s1714 << 7); const SWord8 s1719 = 128 | s1718; const SWord8 s1720 = 127 & s1718; const SWord8 s1721 = s1717 ? s1719 : s1720; const SWord8 s1722 = s1694 ? s1713 : s1721; const SWord8 s1723 = s1 + s1705; const SBool s1724 = s1723 < s1; const SBool s1725 = s1723 < s1705; const SBool s1726 = s1724 || s1725; const SWord8 s1727 = (s1723 >> 1) | (s1723 << 7); const SWord8 s1728 = 128 | s1727; const SWord8 s1729 = 127 & s1727; const SWord8 s1730 = s1726 ? s1728 : s1729; const SWord8 s1731 = (s1730 >> 1) | (s1730 << 7); const SWord8 s1732 = 128 | s1731; const SWord8 s1733 = 127 & s1731; const SWord8 s1734 = s1693 ? s1732 : s1733; const SWord8 s1735 = s1 + s1730; const SBool s1736 = s1735 < s1; const SBool s1737 = s1735 < s1730; const SBool s1738 = s1736 || s1737; const SWord8 s1739 = (s1735 >> 1) | (s1735 << 7); const SWord8 s1740 = 128 | s1739; const SWord8 s1741 = 127 & s1739; const SWord8 s1742 = s1738 ? s1740 : s1741; const SWord8 s1743 = s1694 ? s1734 : s1742; const SWord8 s1744 = s1570 ? s1722 : s1743; const SWord8 s1745 = s1 + s1701; const SBool s1746 = s1745 < s1; const SBool s1747 = s1745 < s1701; const SBool s1748 = s1746 || s1747; const SWord8 s1749 = (s1745 >> 1) | (s1745 << 7); const SWord8 s1750 = 128 | s1749; const SWord8 s1751 = 127 & s1749; const SWord8 s1752 = s1748 ? s1750 : s1751; const SWord8 s1753 = (s1752 >> 1) | (s1752 << 7); const SWord8 s1754 = 128 | s1753; const SWord8 s1755 = 127 & s1753; const SWord8 s1756 = s1569 ? s1754 : s1755; const SWord8 s1757 = (s1756 >> 1) | (s1756 << 7); const SWord8 s1758 = 128 | s1757; const SWord8 s1759 = 127 & s1757; const SWord8 s1760 = s1693 ? s1758 : s1759; const SWord8 s1761 = s1 + s1756; const SBool s1762 = s1761 < s1; const SBool s1763 = s1761 < s1756; const SBool s1764 = s1762 || s1763; const SWord8 s1765 = (s1761 >> 1) | (s1761 << 7); const SWord8 s1766 = 128 | s1765; const SWord8 s1767 = 127 & s1765; const SWord8 s1768 = s1764 ? s1766 : s1767; const SWord8 s1769 = s1694 ? s1760 : s1768; const SWord8 s1770 = s1 + s1752; const SBool s1771 = s1770 < s1; const SBool s1772 = s1770 < s1752; const SBool s1773 = s1771 || s1772; const SWord8 s1774 = (s1770 >> 1) | (s1770 << 7); const SWord8 s1775 = 128 | s1774; const SWord8 s1776 = 127 & s1774; const SWord8 s1777 = s1773 ? s1775 : s1776; const SWord8 s1778 = (s1777 >> 1) | (s1777 << 7); const SWord8 s1779 = 128 | s1778; const SWord8 s1780 = 127 & s1778; const SWord8 s1781 = s1693 ? s1779 : s1780; const SWord8 s1782 = s1 + s1777; const SBool s1783 = s1782 < s1; const SBool s1784 = s1782 < s1777; const SBool s1785 = s1783 || s1784; const SWord8 s1786 = (s1782 >> 1) | (s1782 << 7); const SWord8 s1787 = 128 | s1786; const SWord8 s1788 = 127 & s1786; const SWord8 s1789 = s1785 ? s1787 : s1788; const SWord8 s1790 = s1694 ? s1781 : s1789; const SWord8 s1791 = s1570 ? s1769 : s1790; const SWord8 s1792 = s1548 ? s1744 : s1791; const SWord8 s1793 = s1037 ? s1684 : s1792; const SWord8 s1794 = s1 + s1555; const SBool s1795 = (SBool) ((s1794 >> 0) & 1); const SBool s1796 = false != s1795; const SWord8 s1797 = s1796 ? s1559 : s1560; const SBool s1798 = (SBool) ((s1797 >> 0) & 1); const SBool s1799 = false != s1798; const SWord8 s1800 = s1799 ? s1565 : s1566; const SBool s1801 = (SBool) ((s1800 >> 0) & 1); const SBool s1802 = false != s1801; const SBool s1803 = false == s1802; const SBool s1804 = s1794 < s1; const SBool s1805 = s1794 < s1555; const SBool s1806 = s1804 || s1805; const SWord8 s1807 = (s1794 >> 1) | (s1794 << 7); const SWord8 s1808 = 128 | s1807; const SWord8 s1809 = 127 & s1807; const SWord8 s1810 = s1806 ? s1808 : s1809; const SBool s1811 = (SBool) ((s1810 >> 0) & 1); const SBool s1812 = false != s1811; const SWord8 s1813 = (s1797 >> 1) | (s1797 << 7); const SWord8 s1814 = 128 | s1813; const SWord8 s1815 = 127 & s1813; const SWord8 s1816 = s1812 ? s1814 : s1815; const SBool s1817 = (SBool) ((s1816 >> 0) & 1); const SBool s1818 = false != s1817; const SWord8 s1819 = (s1800 >> 1) | (s1800 << 7); const SWord8 s1820 = 128 | s1819; const SWord8 s1821 = 127 & s1819; const SWord8 s1822 = s1818 ? s1820 : s1821; const SBool s1823 = (SBool) ((s1822 >> 0) & 1); const SBool s1824 = false != s1823; const SBool s1825 = false == s1824; const SWord8 s1826 = (s1810 >> 1) | (s1810 << 7); const SWord8 s1827 = 128 | s1826; const SWord8 s1828 = 127 & s1826; const SWord8 s1829 = s1036 ? s1827 : s1828; const SWord8 s1830 = (s1829 >> 1) | (s1829 << 7); const SWord8 s1831 = 128 | s1830; const SWord8 s1832 = 127 & s1830; const SWord8 s1833 = s1547 ? s1831 : s1832; const SWord8 s1834 = (s1833 >> 1) | (s1833 << 7); const SWord8 s1835 = 128 | s1834; const SWord8 s1836 = 127 & s1834; const SWord8 s1837 = s1802 ? s1835 : s1836; const SWord8 s1838 = (s1837 >> 1) | (s1837 << 7); const SWord8 s1839 = 128 | s1838; const SWord8 s1840 = 127 & s1838; const SWord8 s1841 = s1824 ? s1839 : s1840; const SWord8 s1842 = s1 + s1837; const SBool s1843 = s1842 < s1; const SBool s1844 = s1842 < s1837; const SBool s1845 = s1843 || s1844; const SWord8 s1846 = (s1842 >> 1) | (s1842 << 7); const SWord8 s1847 = 128 | s1846; const SWord8 s1848 = 127 & s1846; const SWord8 s1849 = s1845 ? s1847 : s1848; const SWord8 s1850 = s1825 ? s1841 : s1849; const SWord8 s1851 = s1 + s1833; const SBool s1852 = s1851 < s1; const SBool s1853 = s1851 < s1833; const SBool s1854 = s1852 || s1853; const SWord8 s1855 = (s1851 >> 1) | (s1851 << 7); const SWord8 s1856 = 128 | s1855; const SWord8 s1857 = 127 & s1855; const SWord8 s1858 = s1854 ? s1856 : s1857; const SWord8 s1859 = (s1858 >> 1) | (s1858 << 7); const SWord8 s1860 = 128 | s1859; const SWord8 s1861 = 127 & s1859; const SWord8 s1862 = s1824 ? s1860 : s1861; const SWord8 s1863 = s1 + s1858; const SBool s1864 = s1863 < s1; const SBool s1865 = s1863 < s1858; const SBool s1866 = s1864 || s1865; const SWord8 s1867 = (s1863 >> 1) | (s1863 << 7); const SWord8 s1868 = 128 | s1867; const SWord8 s1869 = 127 & s1867; const SWord8 s1870 = s1866 ? s1868 : s1869; const SWord8 s1871 = s1825 ? s1862 : s1870; const SWord8 s1872 = s1803 ? s1850 : s1871; const SWord8 s1873 = s1 + s1829; const SBool s1874 = s1873 < s1; const SBool s1875 = s1873 < s1829; const SBool s1876 = s1874 || s1875; const SWord8 s1877 = (s1873 >> 1) | (s1873 << 7); const SWord8 s1878 = 128 | s1877; const SWord8 s1879 = 127 & s1877; const SWord8 s1880 = s1876 ? s1878 : s1879; const SWord8 s1881 = (s1880 >> 1) | (s1880 << 7); const SWord8 s1882 = 128 | s1881; const SWord8 s1883 = 127 & s1881; const SWord8 s1884 = s1802 ? s1882 : s1883; const SWord8 s1885 = (s1884 >> 1) | (s1884 << 7); const SWord8 s1886 = 128 | s1885; const SWord8 s1887 = 127 & s1885; const SWord8 s1888 = s1824 ? s1886 : s1887; const SWord8 s1889 = s1 + s1884; const SBool s1890 = s1889 < s1; const SBool s1891 = s1889 < s1884; const SBool s1892 = s1890 || s1891; const SWord8 s1893 = (s1889 >> 1) | (s1889 << 7); const SWord8 s1894 = 128 | s1893; const SWord8 s1895 = 127 & s1893; const SWord8 s1896 = s1892 ? s1894 : s1895; const SWord8 s1897 = s1825 ? s1888 : s1896; const SWord8 s1898 = s1 + s1880; const SBool s1899 = s1898 < s1; const SBool s1900 = s1898 < s1880; const SBool s1901 = s1899 || s1900; const SWord8 s1902 = (s1898 >> 1) | (s1898 << 7); const SWord8 s1903 = 128 | s1902; const SWord8 s1904 = 127 & s1902; const SWord8 s1905 = s1901 ? s1903 : s1904; const SWord8 s1906 = (s1905 >> 1) | (s1905 << 7); const SWord8 s1907 = 128 | s1906; const SWord8 s1908 = 127 & s1906; const SWord8 s1909 = s1824 ? s1907 : s1908; const SWord8 s1910 = s1 + s1905; const SBool s1911 = s1910 < s1; const SBool s1912 = s1910 < s1905; const SBool s1913 = s1911 || s1912; const SWord8 s1914 = (s1910 >> 1) | (s1910 << 7); const SWord8 s1915 = 128 | s1914; const SWord8 s1916 = 127 & s1914; const SWord8 s1917 = s1913 ? s1915 : s1916; const SWord8 s1918 = s1825 ? s1909 : s1917; const SWord8 s1919 = s1803 ? s1897 : s1918; const SWord8 s1920 = s1548 ? s1872 : s1919; const SWord8 s1921 = s1 + s1810; const SBool s1922 = (SBool) ((s1921 >> 0) & 1); const SBool s1923 = false != s1922; const SWord8 s1924 = s1923 ? s1814 : s1815; const SBool s1925 = (SBool) ((s1924 >> 0) & 1); const SBool s1926 = false != s1925; const SWord8 s1927 = s1926 ? s1820 : s1821; const SBool s1928 = (SBool) ((s1927 >> 0) & 1); const SBool s1929 = false != s1928; const SBool s1930 = false == s1929; const SBool s1931 = s1921 < s1; const SBool s1932 = s1921 < s1810; const SBool s1933 = s1931 || s1932; const SWord8 s1934 = (s1921 >> 1) | (s1921 << 7); const SWord8 s1935 = 128 | s1934; const SWord8 s1936 = 127 & s1934; const SWord8 s1937 = s1933 ? s1935 : s1936; const SWord8 s1938 = (s1937 >> 1) | (s1937 << 7); const SWord8 s1939 = 128 | s1938; const SWord8 s1940 = 127 & s1938; const SWord8 s1941 = s1547 ? s1939 : s1940; const SWord8 s1942 = (s1941 >> 1) | (s1941 << 7); const SWord8 s1943 = 128 | s1942; const SWord8 s1944 = 127 & s1942; const SWord8 s1945 = s1802 ? s1943 : s1944; const SWord8 s1946 = (s1945 >> 1) | (s1945 << 7); const SWord8 s1947 = 128 | s1946; const SWord8 s1948 = 127 & s1946; const SWord8 s1949 = s1929 ? s1947 : s1948; const SWord8 s1950 = s1 + s1945; const SBool s1951 = s1950 < s1; const SBool s1952 = s1950 < s1945; const SBool s1953 = s1951 || s1952; const SWord8 s1954 = (s1950 >> 1) | (s1950 << 7); const SWord8 s1955 = 128 | s1954; const SWord8 s1956 = 127 & s1954; const SWord8 s1957 = s1953 ? s1955 : s1956; const SWord8 s1958 = s1930 ? s1949 : s1957; const SWord8 s1959 = s1 + s1941; const SBool s1960 = s1959 < s1; const SBool s1961 = s1959 < s1941; const SBool s1962 = s1960 || s1961; const SWord8 s1963 = (s1959 >> 1) | (s1959 << 7); const SWord8 s1964 = 128 | s1963; const SWord8 s1965 = 127 & s1963; const SWord8 s1966 = s1962 ? s1964 : s1965; const SWord8 s1967 = (s1966 >> 1) | (s1966 << 7); const SWord8 s1968 = 128 | s1967; const SWord8 s1969 = 127 & s1967; const SWord8 s1970 = s1929 ? s1968 : s1969; const SWord8 s1971 = s1 + s1966; const SBool s1972 = s1971 < s1; const SBool s1973 = s1971 < s1966; const SBool s1974 = s1972 || s1973; const SWord8 s1975 = (s1971 >> 1) | (s1971 << 7); const SWord8 s1976 = 128 | s1975; const SWord8 s1977 = 127 & s1975; const SWord8 s1978 = s1974 ? s1976 : s1977; const SWord8 s1979 = s1930 ? s1970 : s1978; const SWord8 s1980 = s1803 ? s1958 : s1979; const SWord8 s1981 = s1 + s1937; const SBool s1982 = s1981 < s1; const SBool s1983 = s1981 < s1937; const SBool s1984 = s1982 || s1983; const SWord8 s1985 = (s1981 >> 1) | (s1981 << 7); const SWord8 s1986 = 128 | s1985; const SWord8 s1987 = 127 & s1985; const SWord8 s1988 = s1984 ? s1986 : s1987; const SWord8 s1989 = (s1988 >> 1) | (s1988 << 7); const SWord8 s1990 = 128 | s1989; const SWord8 s1991 = 127 & s1989; const SWord8 s1992 = s1802 ? s1990 : s1991; const SWord8 s1993 = (s1992 >> 1) | (s1992 << 7); const SWord8 s1994 = 128 | s1993; const SWord8 s1995 = 127 & s1993; const SWord8 s1996 = s1929 ? s1994 : s1995; const SWord8 s1997 = s1 + s1992; const SBool s1998 = s1997 < s1; const SBool s1999 = s1997 < s1992; const SBool s2000 = s1998 || s1999; const SWord8 s2001 = (s1997 >> 1) | (s1997 << 7); const SWord8 s2002 = 128 | s2001; const SWord8 s2003 = 127 & s2001; const SWord8 s2004 = s2000 ? s2002 : s2003; const SWord8 s2005 = s1930 ? s1996 : s2004; const SWord8 s2006 = s1 + s1988; const SBool s2007 = s2006 < s1; const SBool s2008 = s2006 < s1988; const SBool s2009 = s2007 || s2008; const SWord8 s2010 = (s2006 >> 1) | (s2006 << 7); const SWord8 s2011 = 128 | s2010; const SWord8 s2012 = 127 & s2010; const SWord8 s2013 = s2009 ? s2011 : s2012; const SWord8 s2014 = (s2013 >> 1) | (s2013 << 7); const SWord8 s2015 = 128 | s2014; const SWord8 s2016 = 127 & s2014; const SWord8 s2017 = s1929 ? s2015 : s2016; const SWord8 s2018 = s1 + s2013; const SBool s2019 = s2018 < s1; const SBool s2020 = s2018 < s2013; const SBool s2021 = s2019 || s2020; const SWord8 s2022 = (s2018 >> 1) | (s2018 << 7); const SWord8 s2023 = 128 | s2022; const SWord8 s2024 = 127 & s2022; const SWord8 s2025 = s2021 ? s2023 : s2024; const SWord8 s2026 = s1930 ? s2017 : s2025; const SWord8 s2027 = s1803 ? s2005 : s2026; const SWord8 s2028 = s1548 ? s1980 : s2027; const SWord8 s2029 = s1037 ? s1920 : s2028; const SWord8 s2030 = s21 ? s1793 : s2029; const SWord8 s2031 = s16 ? s1538 : s2030; const SWord8 s2032 = s11 ? s1027 : s2031; const SBool s2033 = (SBool) ((s1 >> 0) & 1); const SBool s2034 = false != s2033; const SWord8 s2035 = s2034 ? 128 : 0; const SBool s2036 = (SBool) ((s2035 >> 0) & 1); const SBool s2037 = false != s2036; const SWord8 s2038 = s17 | 128; const SWord8 s2039 = s2037 ? s2038 : s18; const SBool s2040 = (SBool) ((s2039 >> 0) & 1); const SBool s2041 = false != s2040; const SBool s2042 = false == s2041; const SWord8 s2043 = (s1 >> 1) | (s1 << 7); const SWord8 s2044 = 127 & s2043; const SBool s2045 = (SBool) ((s2044 >> 0) & 1); const SBool s2046 = false != s2045; const SWord8 s2047 = (s2035 >> 1) | (s2035 << 7); const SWord8 s2048 = 128 | s2047; const SWord8 s2049 = 127 & s2047; const SWord8 s2050 = s2046 ? s2048 : s2049; const SBool s2051 = (SBool) ((s2050 >> 0) & 1); const SBool s2052 = false != s2051; const SWord8 s2053 = (s2039 >> 1) | (s2039 << 7); const SWord8 s2054 = 128 | s2053; const SWord8 s2055 = 127 & s2053; const SWord8 s2056 = s2052 ? s2054 : s2055; const SBool s2057 = (SBool) ((s2056 >> 0) & 1); const SBool s2058 = false != s2057; const SBool s2059 = false == s2058; const SWord8 s2060 = (s2044 >> 1) | (s2044 << 7); const SWord8 s2061 = 128 | s2060; const SWord8 s2062 = 127 & s2060; const SWord8 s2063 = s10 ? s2061 : s2062; const SBool s2064 = (SBool) ((s2063 >> 0) & 1); const SBool s2065 = false != s2064; const SWord8 s2066 = (s2050 >> 1) | (s2050 << 7); const SWord8 s2067 = 128 | s2066; const SWord8 s2068 = 127 & s2066; const SWord8 s2069 = s2065 ? s2067 : s2068; const SBool s2070 = (SBool) ((s2069 >> 0) & 1); const SBool s2071 = false != s2070; const SWord8 s2072 = (s2056 >> 1) | (s2056 << 7); const SWord8 s2073 = 128 | s2072; const SWord8 s2074 = 127 & s2072; const SWord8 s2075 = s2071 ? s2073 : s2074; const SBool s2076 = (SBool) ((s2075 >> 0) & 1); const SBool s2077 = false != s2076; const SBool s2078 = false == s2077; const SWord8 s2079 = (s2063 >> 1) | (s2063 << 7); const SWord8 s2080 = 128 | s2079; const SWord8 s2081 = 127 & s2079; const SWord8 s2082 = s15 ? s2080 : s2081; const SBool s2083 = (SBool) ((s2082 >> 0) & 1); const SBool s2084 = false != s2083; const SWord8 s2085 = (s2069 >> 1) | (s2069 << 7); const SWord8 s2086 = 128 | s2085; const SWord8 s2087 = 127 & s2085; const SWord8 s2088 = s2084 ? s2086 : s2087; const SBool s2089 = (SBool) ((s2088 >> 0) & 1); const SBool s2090 = false != s2089; const SWord8 s2091 = (s2075 >> 1) | (s2075 << 7); const SWord8 s2092 = 128 | s2091; const SWord8 s2093 = 127 & s2091; const SWord8 s2094 = s2090 ? s2092 : s2093; const SBool s2095 = (SBool) ((s2094 >> 0) & 1); const SBool s2096 = false != s2095; const SBool s2097 = false == s2096; const SWord8 s2098 = (s2082 >> 1) | (s2082 << 7); const SWord8 s2099 = 128 | s2098; const SWord8 s2100 = 127 & s2098; const SWord8 s2101 = s2041 ? s2099 : s2100; const SBool s2102 = (SBool) ((s2101 >> 0) & 1); const SBool s2103 = false != s2102; const SWord8 s2104 = (s2088 >> 1) | (s2088 << 7); const SWord8 s2105 = 128 | s2104; const SWord8 s2106 = 127 & s2104; const SWord8 s2107 = s2103 ? s2105 : s2106; const SBool s2108 = (SBool) ((s2107 >> 0) & 1); const SBool s2109 = false != s2108; const SWord8 s2110 = (s2094 >> 1) | (s2094 << 7); const SWord8 s2111 = 128 | s2110; const SWord8 s2112 = 127 & s2110; const SWord8 s2113 = s2109 ? s2111 : s2112; const SBool s2114 = (SBool) ((s2113 >> 0) & 1); const SBool s2115 = false != s2114; const SBool s2116 = false == s2115; const SWord8 s2117 = (s2101 >> 1) | (s2101 << 7); const SWord8 s2118 = 128 | s2117; const SWord8 s2119 = 127 & s2117; const SWord8 s2120 = s2058 ? s2118 : s2119; const SWord8 s2121 = (s2120 >> 1) | (s2120 << 7); const SWord8 s2122 = 128 | s2121; const SWord8 s2123 = 127 & s2121; const SWord8 s2124 = s2077 ? s2122 : s2123; const SWord8 s2125 = (s2124 >> 1) | (s2124 << 7); const SWord8 s2126 = 128 | s2125; const SWord8 s2127 = 127 & s2125; const SWord8 s2128 = s2096 ? s2126 : s2127; const SWord8 s2129 = (s2128 >> 1) | (s2128 << 7); const SWord8 s2130 = 128 | s2129; const SWord8 s2131 = 127 & s2129; const SWord8 s2132 = s2115 ? s2130 : s2131; const SWord8 s2133 = s1 + s2128; const SBool s2134 = s2133 < s1; const SBool s2135 = s2133 < s2128; const SBool s2136 = s2134 || s2135; const SWord8 s2137 = (s2133 >> 1) | (s2133 << 7); const SWord8 s2138 = 128 | s2137; const SWord8 s2139 = 127 & s2137; const SWord8 s2140 = s2136 ? s2138 : s2139; const SWord8 s2141 = s2116 ? s2132 : s2140; const SWord8 s2142 = s1 + s2124; const SBool s2143 = s2142 < s1; const SBool s2144 = s2142 < s2124; const SBool s2145 = s2143 || s2144; const SWord8 s2146 = (s2142 >> 1) | (s2142 << 7); const SWord8 s2147 = 128 | s2146; const SWord8 s2148 = 127 & s2146; const SWord8 s2149 = s2145 ? s2147 : s2148; const SWord8 s2150 = (s2149 >> 1) | (s2149 << 7); const SWord8 s2151 = 128 | s2150; const SWord8 s2152 = 127 & s2150; const SWord8 s2153 = s2115 ? s2151 : s2152; const SWord8 s2154 = s1 + s2149; const SBool s2155 = s2154 < s1; const SBool s2156 = s2154 < s2149; const SBool s2157 = s2155 || s2156; const SWord8 s2158 = (s2154 >> 1) | (s2154 << 7); const SWord8 s2159 = 128 | s2158; const SWord8 s2160 = 127 & s2158; const SWord8 s2161 = s2157 ? s2159 : s2160; const SWord8 s2162 = s2116 ? s2153 : s2161; const SWord8 s2163 = s2097 ? s2141 : s2162; const SWord8 s2164 = s1 + s2120; const SBool s2165 = s2164 < s1; const SBool s2166 = s2164 < s2120; const SBool s2167 = s2165 || s2166; const SWord8 s2168 = (s2164 >> 1) | (s2164 << 7); const SWord8 s2169 = 128 | s2168; const SWord8 s2170 = 127 & s2168; const SWord8 s2171 = s2167 ? s2169 : s2170; const SWord8 s2172 = (s2171 >> 1) | (s2171 << 7); const SWord8 s2173 = 128 | s2172; const SWord8 s2174 = 127 & s2172; const SWord8 s2175 = s2096 ? s2173 : s2174; const SWord8 s2176 = (s2175 >> 1) | (s2175 << 7); const SWord8 s2177 = 128 | s2176; const SWord8 s2178 = 127 & s2176; const SWord8 s2179 = s2115 ? s2177 : s2178; const SWord8 s2180 = s1 + s2175; const SBool s2181 = s2180 < s1; const SBool s2182 = s2180 < s2175; const SBool s2183 = s2181 || s2182; const SWord8 s2184 = (s2180 >> 1) | (s2180 << 7); const SWord8 s2185 = 128 | s2184; const SWord8 s2186 = 127 & s2184; const SWord8 s2187 = s2183 ? s2185 : s2186; const SWord8 s2188 = s2116 ? s2179 : s2187; const SWord8 s2189 = s1 + s2171; const SBool s2190 = s2189 < s1; const SBool s2191 = s2189 < s2171; const SBool s2192 = s2190 || s2191; const SWord8 s2193 = (s2189 >> 1) | (s2189 << 7); const SWord8 s2194 = 128 | s2193; const SWord8 s2195 = 127 & s2193; const SWord8 s2196 = s2192 ? s2194 : s2195; const SWord8 s2197 = (s2196 >> 1) | (s2196 << 7); const SWord8 s2198 = 128 | s2197; const SWord8 s2199 = 127 & s2197; const SWord8 s2200 = s2115 ? s2198 : s2199; const SWord8 s2201 = s1 + s2196; const SBool s2202 = s2201 < s1; const SBool s2203 = s2201 < s2196; const SBool s2204 = s2202 || s2203; const SWord8 s2205 = (s2201 >> 1) | (s2201 << 7); const SWord8 s2206 = 128 | s2205; const SWord8 s2207 = 127 & s2205; const SWord8 s2208 = s2204 ? s2206 : s2207; const SWord8 s2209 = s2116 ? s2200 : s2208; const SWord8 s2210 = s2097 ? s2188 : s2209; const SWord8 s2211 = s2078 ? s2163 : s2210; const SWord8 s2212 = s1 + s2101; const SBool s2213 = (SBool) ((s2212 >> 0) & 1); const SBool s2214 = false != s2213; const SWord8 s2215 = s2214 ? s2105 : s2106; const SBool s2216 = (SBool) ((s2215 >> 0) & 1); const SBool s2217 = false != s2216; const SWord8 s2218 = s2217 ? s2111 : s2112; const SBool s2219 = (SBool) ((s2218 >> 0) & 1); const SBool s2220 = false != s2219; const SBool s2221 = false == s2220; const SBool s2222 = s2212 < s1; const SBool s2223 = s2212 < s2101; const SBool s2224 = s2222 || s2223; const SWord8 s2225 = (s2212 >> 1) | (s2212 << 7); const SWord8 s2226 = 128 | s2225; const SWord8 s2227 = 127 & s2225; const SWord8 s2228 = s2224 ? s2226 : s2227; const SWord8 s2229 = (s2228 >> 1) | (s2228 << 7); const SWord8 s2230 = 128 | s2229; const SWord8 s2231 = 127 & s2229; const SWord8 s2232 = s2077 ? s2230 : s2231; const SWord8 s2233 = (s2232 >> 1) | (s2232 << 7); const SWord8 s2234 = 128 | s2233; const SWord8 s2235 = 127 & s2233; const SWord8 s2236 = s2096 ? s2234 : s2235; const SWord8 s2237 = (s2236 >> 1) | (s2236 << 7); const SWord8 s2238 = 128 | s2237; const SWord8 s2239 = 127 & s2237; const SWord8 s2240 = s2220 ? s2238 : s2239; const SWord8 s2241 = s1 + s2236; const SBool s2242 = s2241 < s1; const SBool s2243 = s2241 < s2236; const SBool s2244 = s2242 || s2243; const SWord8 s2245 = (s2241 >> 1) | (s2241 << 7); const SWord8 s2246 = 128 | s2245; const SWord8 s2247 = 127 & s2245; const SWord8 s2248 = s2244 ? s2246 : s2247; const SWord8 s2249 = s2221 ? s2240 : s2248; const SWord8 s2250 = s1 + s2232; const SBool s2251 = s2250 < s1; const SBool s2252 = s2250 < s2232; const SBool s2253 = s2251 || s2252; const SWord8 s2254 = (s2250 >> 1) | (s2250 << 7); const SWord8 s2255 = 128 | s2254; const SWord8 s2256 = 127 & s2254; const SWord8 s2257 = s2253 ? s2255 : s2256; const SWord8 s2258 = (s2257 >> 1) | (s2257 << 7); const SWord8 s2259 = 128 | s2258; const SWord8 s2260 = 127 & s2258; const SWord8 s2261 = s2220 ? s2259 : s2260; const SWord8 s2262 = s1 + s2257; const SBool s2263 = s2262 < s1; const SBool s2264 = s2262 < s2257; const SBool s2265 = s2263 || s2264; const SWord8 s2266 = (s2262 >> 1) | (s2262 << 7); const SWord8 s2267 = 128 | s2266; const SWord8 s2268 = 127 & s2266; const SWord8 s2269 = s2265 ? s2267 : s2268; const SWord8 s2270 = s2221 ? s2261 : s2269; const SWord8 s2271 = s2097 ? s2249 : s2270; const SWord8 s2272 = s1 + s2228; const SBool s2273 = s2272 < s1; const SBool s2274 = s2272 < s2228; const SBool s2275 = s2273 || s2274; const SWord8 s2276 = (s2272 >> 1) | (s2272 << 7); const SWord8 s2277 = 128 | s2276; const SWord8 s2278 = 127 & s2276; const SWord8 s2279 = s2275 ? s2277 : s2278; const SWord8 s2280 = (s2279 >> 1) | (s2279 << 7); const SWord8 s2281 = 128 | s2280; const SWord8 s2282 = 127 & s2280; const SWord8 s2283 = s2096 ? s2281 : s2282; const SWord8 s2284 = (s2283 >> 1) | (s2283 << 7); const SWord8 s2285 = 128 | s2284; const SWord8 s2286 = 127 & s2284; const SWord8 s2287 = s2220 ? s2285 : s2286; const SWord8 s2288 = s1 + s2283; const SBool s2289 = s2288 < s1; const SBool s2290 = s2288 < s2283; const SBool s2291 = s2289 || s2290; const SWord8 s2292 = (s2288 >> 1) | (s2288 << 7); const SWord8 s2293 = 128 | s2292; const SWord8 s2294 = 127 & s2292; const SWord8 s2295 = s2291 ? s2293 : s2294; const SWord8 s2296 = s2221 ? s2287 : s2295; const SWord8 s2297 = s1 + s2279; const SBool s2298 = s2297 < s1; const SBool s2299 = s2297 < s2279; const SBool s2300 = s2298 || s2299; const SWord8 s2301 = (s2297 >> 1) | (s2297 << 7); const SWord8 s2302 = 128 | s2301; const SWord8 s2303 = 127 & s2301; const SWord8 s2304 = s2300 ? s2302 : s2303; const SWord8 s2305 = (s2304 >> 1) | (s2304 << 7); const SWord8 s2306 = 128 | s2305; const SWord8 s2307 = 127 & s2305; const SWord8 s2308 = s2220 ? s2306 : s2307; const SWord8 s2309 = s1 + s2304; const SBool s2310 = s2309 < s1; const SBool s2311 = s2309 < s2304; const SBool s2312 = s2310 || s2311; const SWord8 s2313 = (s2309 >> 1) | (s2309 << 7); const SWord8 s2314 = 128 | s2313; const SWord8 s2315 = 127 & s2313; const SWord8 s2316 = s2312 ? s2314 : s2315; const SWord8 s2317 = s2221 ? s2308 : s2316; const SWord8 s2318 = s2097 ? s2296 : s2317; const SWord8 s2319 = s2078 ? s2271 : s2318; const SWord8 s2320 = s2059 ? s2211 : s2319; const SWord8 s2321 = s1 + s2082; const SBool s2322 = (SBool) ((s2321 >> 0) & 1); const SBool s2323 = false != s2322; const SWord8 s2324 = s2323 ? s2086 : s2087; const SBool s2325 = (SBool) ((s2324 >> 0) & 1); const SBool s2326 = false != s2325; const SWord8 s2327 = s2326 ? s2092 : s2093; const SBool s2328 = (SBool) ((s2327 >> 0) & 1); const SBool s2329 = false != s2328; const SBool s2330 = false == s2329; const SBool s2331 = s2321 < s1; const SBool s2332 = s2321 < s2082; const SBool s2333 = s2331 || s2332; const SWord8 s2334 = (s2321 >> 1) | (s2321 << 7); const SWord8 s2335 = 128 | s2334; const SWord8 s2336 = 127 & s2334; const SWord8 s2337 = s2333 ? s2335 : s2336; const SBool s2338 = (SBool) ((s2337 >> 0) & 1); const SBool s2339 = false != s2338; const SWord8 s2340 = (s2324 >> 1) | (s2324 << 7); const SWord8 s2341 = 128 | s2340; const SWord8 s2342 = 127 & s2340; const SWord8 s2343 = s2339 ? s2341 : s2342; const SBool s2344 = (SBool) ((s2343 >> 0) & 1); const SBool s2345 = false != s2344; const SWord8 s2346 = (s2327 >> 1) | (s2327 << 7); const SWord8 s2347 = 128 | s2346; const SWord8 s2348 = 127 & s2346; const SWord8 s2349 = s2345 ? s2347 : s2348; const SBool s2350 = (SBool) ((s2349 >> 0) & 1); const SBool s2351 = false != s2350; const SBool s2352 = false == s2351; const SWord8 s2353 = (s2337 >> 1) | (s2337 << 7); const SWord8 s2354 = 128 | s2353; const SWord8 s2355 = 127 & s2353; const SWord8 s2356 = s2058 ? s2354 : s2355; const SWord8 s2357 = (s2356 >> 1) | (s2356 << 7); const SWord8 s2358 = 128 | s2357; const SWord8 s2359 = 127 & s2357; const SWord8 s2360 = s2077 ? s2358 : s2359; const SWord8 s2361 = (s2360 >> 1) | (s2360 << 7); const SWord8 s2362 = 128 | s2361; const SWord8 s2363 = 127 & s2361; const SWord8 s2364 = s2329 ? s2362 : s2363; const SWord8 s2365 = (s2364 >> 1) | (s2364 << 7); const SWord8 s2366 = 128 | s2365; const SWord8 s2367 = 127 & s2365; const SWord8 s2368 = s2351 ? s2366 : s2367; const SWord8 s2369 = s1 + s2364; const SBool s2370 = s2369 < s1; const SBool s2371 = s2369 < s2364; const SBool s2372 = s2370 || s2371; const SWord8 s2373 = (s2369 >> 1) | (s2369 << 7); const SWord8 s2374 = 128 | s2373; const SWord8 s2375 = 127 & s2373; const SWord8 s2376 = s2372 ? s2374 : s2375; const SWord8 s2377 = s2352 ? s2368 : s2376; const SWord8 s2378 = s1 + s2360; const SBool s2379 = s2378 < s1; const SBool s2380 = s2378 < s2360; const SBool s2381 = s2379 || s2380; const SWord8 s2382 = (s2378 >> 1) | (s2378 << 7); const SWord8 s2383 = 128 | s2382; const SWord8 s2384 = 127 & s2382; const SWord8 s2385 = s2381 ? s2383 : s2384; const SWord8 s2386 = (s2385 >> 1) | (s2385 << 7); const SWord8 s2387 = 128 | s2386; const SWord8 s2388 = 127 & s2386; const SWord8 s2389 = s2351 ? s2387 : s2388; const SWord8 s2390 = s1 + s2385; const SBool s2391 = s2390 < s1; const SBool s2392 = s2390 < s2385; const SBool s2393 = s2391 || s2392; const SWord8 s2394 = (s2390 >> 1) | (s2390 << 7); const SWord8 s2395 = 128 | s2394; const SWord8 s2396 = 127 & s2394; const SWord8 s2397 = s2393 ? s2395 : s2396; const SWord8 s2398 = s2352 ? s2389 : s2397; const SWord8 s2399 = s2330 ? s2377 : s2398; const SWord8 s2400 = s1 + s2356; const SBool s2401 = s2400 < s1; const SBool s2402 = s2400 < s2356; const SBool s2403 = s2401 || s2402; const SWord8 s2404 = (s2400 >> 1) | (s2400 << 7); const SWord8 s2405 = 128 | s2404; const SWord8 s2406 = 127 & s2404; const SWord8 s2407 = s2403 ? s2405 : s2406; const SWord8 s2408 = (s2407 >> 1) | (s2407 << 7); const SWord8 s2409 = 128 | s2408; const SWord8 s2410 = 127 & s2408; const SWord8 s2411 = s2329 ? s2409 : s2410; const SWord8 s2412 = (s2411 >> 1) | (s2411 << 7); const SWord8 s2413 = 128 | s2412; const SWord8 s2414 = 127 & s2412; const SWord8 s2415 = s2351 ? s2413 : s2414; const SWord8 s2416 = s1 + s2411; const SBool s2417 = s2416 < s1; const SBool s2418 = s2416 < s2411; const SBool s2419 = s2417 || s2418; const SWord8 s2420 = (s2416 >> 1) | (s2416 << 7); const SWord8 s2421 = 128 | s2420; const SWord8 s2422 = 127 & s2420; const SWord8 s2423 = s2419 ? s2421 : s2422; const SWord8 s2424 = s2352 ? s2415 : s2423; const SWord8 s2425 = s1 + s2407; const SBool s2426 = s2425 < s1; const SBool s2427 = s2425 < s2407; const SBool s2428 = s2426 || s2427; const SWord8 s2429 = (s2425 >> 1) | (s2425 << 7); const SWord8 s2430 = 128 | s2429; const SWord8 s2431 = 127 & s2429; const SWord8 s2432 = s2428 ? s2430 : s2431; const SWord8 s2433 = (s2432 >> 1) | (s2432 << 7); const SWord8 s2434 = 128 | s2433; const SWord8 s2435 = 127 & s2433; const SWord8 s2436 = s2351 ? s2434 : s2435; const SWord8 s2437 = s1 + s2432; const SBool s2438 = s2437 < s1; const SBool s2439 = s2437 < s2432; const SBool s2440 = s2438 || s2439; const SWord8 s2441 = (s2437 >> 1) | (s2437 << 7); const SWord8 s2442 = 128 | s2441; const SWord8 s2443 = 127 & s2441; const SWord8 s2444 = s2440 ? s2442 : s2443; const SWord8 s2445 = s2352 ? s2436 : s2444; const SWord8 s2446 = s2330 ? s2424 : s2445; const SWord8 s2447 = s2078 ? s2399 : s2446; const SWord8 s2448 = s1 + s2337; const SBool s2449 = (SBool) ((s2448 >> 0) & 1); const SBool s2450 = false != s2449; const SWord8 s2451 = s2450 ? s2341 : s2342; const SBool s2452 = (SBool) ((s2451 >> 0) & 1); const SBool s2453 = false != s2452; const SWord8 s2454 = s2453 ? s2347 : s2348; const SBool s2455 = (SBool) ((s2454 >> 0) & 1); const SBool s2456 = false != s2455; const SBool s2457 = false == s2456; const SBool s2458 = s2448 < s1; const SBool s2459 = s2448 < s2337; const SBool s2460 = s2458 || s2459; const SWord8 s2461 = (s2448 >> 1) | (s2448 << 7); const SWord8 s2462 = 128 | s2461; const SWord8 s2463 = 127 & s2461; const SWord8 s2464 = s2460 ? s2462 : s2463; const SWord8 s2465 = (s2464 >> 1) | (s2464 << 7); const SWord8 s2466 = 128 | s2465; const SWord8 s2467 = 127 & s2465; const SWord8 s2468 = s2077 ? s2466 : s2467; const SWord8 s2469 = (s2468 >> 1) | (s2468 << 7); const SWord8 s2470 = 128 | s2469; const SWord8 s2471 = 127 & s2469; const SWord8 s2472 = s2329 ? s2470 : s2471; const SWord8 s2473 = (s2472 >> 1) | (s2472 << 7); const SWord8 s2474 = 128 | s2473; const SWord8 s2475 = 127 & s2473; const SWord8 s2476 = s2456 ? s2474 : s2475; const SWord8 s2477 = s1 + s2472; const SBool s2478 = s2477 < s1; const SBool s2479 = s2477 < s2472; const SBool s2480 = s2478 || s2479; const SWord8 s2481 = (s2477 >> 1) | (s2477 << 7); const SWord8 s2482 = 128 | s2481; const SWord8 s2483 = 127 & s2481; const SWord8 s2484 = s2480 ? s2482 : s2483; const SWord8 s2485 = s2457 ? s2476 : s2484; const SWord8 s2486 = s1 + s2468; const SBool s2487 = s2486 < s1; const SBool s2488 = s2486 < s2468; const SBool s2489 = s2487 || s2488; const SWord8 s2490 = (s2486 >> 1) | (s2486 << 7); const SWord8 s2491 = 128 | s2490; const SWord8 s2492 = 127 & s2490; const SWord8 s2493 = s2489 ? s2491 : s2492; const SWord8 s2494 = (s2493 >> 1) | (s2493 << 7); const SWord8 s2495 = 128 | s2494; const SWord8 s2496 = 127 & s2494; const SWord8 s2497 = s2456 ? s2495 : s2496; const SWord8 s2498 = s1 + s2493; const SBool s2499 = s2498 < s1; const SBool s2500 = s2498 < s2493; const SBool s2501 = s2499 || s2500; const SWord8 s2502 = (s2498 >> 1) | (s2498 << 7); const SWord8 s2503 = 128 | s2502; const SWord8 s2504 = 127 & s2502; const SWord8 s2505 = s2501 ? s2503 : s2504; const SWord8 s2506 = s2457 ? s2497 : s2505; const SWord8 s2507 = s2330 ? s2485 : s2506; const SWord8 s2508 = s1 + s2464; const SBool s2509 = s2508 < s1; const SBool s2510 = s2508 < s2464; const SBool s2511 = s2509 || s2510; const SWord8 s2512 = (s2508 >> 1) | (s2508 << 7); const SWord8 s2513 = 128 | s2512; const SWord8 s2514 = 127 & s2512; const SWord8 s2515 = s2511 ? s2513 : s2514; const SWord8 s2516 = (s2515 >> 1) | (s2515 << 7); const SWord8 s2517 = 128 | s2516; const SWord8 s2518 = 127 & s2516; const SWord8 s2519 = s2329 ? s2517 : s2518; const SWord8 s2520 = (s2519 >> 1) | (s2519 << 7); const SWord8 s2521 = 128 | s2520; const SWord8 s2522 = 127 & s2520; const SWord8 s2523 = s2456 ? s2521 : s2522; const SWord8 s2524 = s1 + s2519; const SBool s2525 = s2524 < s1; const SBool s2526 = s2524 < s2519; const SBool s2527 = s2525 || s2526; const SWord8 s2528 = (s2524 >> 1) | (s2524 << 7); const SWord8 s2529 = 128 | s2528; const SWord8 s2530 = 127 & s2528; const SWord8 s2531 = s2527 ? s2529 : s2530; const SWord8 s2532 = s2457 ? s2523 : s2531; const SWord8 s2533 = s1 + s2515; const SBool s2534 = s2533 < s1; const SBool s2535 = s2533 < s2515; const SBool s2536 = s2534 || s2535; const SWord8 s2537 = (s2533 >> 1) | (s2533 << 7); const SWord8 s2538 = 128 | s2537; const SWord8 s2539 = 127 & s2537; const SWord8 s2540 = s2536 ? s2538 : s2539; const SWord8 s2541 = (s2540 >> 1) | (s2540 << 7); const SWord8 s2542 = 128 | s2541; const SWord8 s2543 = 127 & s2541; const SWord8 s2544 = s2456 ? s2542 : s2543; const SWord8 s2545 = s1 + s2540; const SBool s2546 = s2545 < s1; const SBool s2547 = s2545 < s2540; const SBool s2548 = s2546 || s2547; const SWord8 s2549 = (s2545 >> 1) | (s2545 << 7); const SWord8 s2550 = 128 | s2549; const SWord8 s2551 = 127 & s2549; const SWord8 s2552 = s2548 ? s2550 : s2551; const SWord8 s2553 = s2457 ? s2544 : s2552; const SWord8 s2554 = s2330 ? s2532 : s2553; const SWord8 s2555 = s2078 ? s2507 : s2554; const SWord8 s2556 = s2059 ? s2447 : s2555; const SWord8 s2557 = s2042 ? s2320 : s2556; const SWord8 s2558 = s1 + s2063; const SBool s2559 = (SBool) ((s2558 >> 0) & 1); const SBool s2560 = false != s2559; const SWord8 s2561 = s2560 ? s2067 : s2068; const SBool s2562 = (SBool) ((s2561 >> 0) & 1); const SBool s2563 = false != s2562; const SWord8 s2564 = s2563 ? s2073 : s2074; const SBool s2565 = (SBool) ((s2564 >> 0) & 1); const SBool s2566 = false != s2565; const SBool s2567 = false == s2566; const SBool s2568 = s2558 < s1; const SBool s2569 = s2558 < s2063; const SBool s2570 = s2568 || s2569; const SWord8 s2571 = (s2558 >> 1) | (s2558 << 7); const SWord8 s2572 = 128 | s2571; const SWord8 s2573 = 127 & s2571; const SWord8 s2574 = s2570 ? s2572 : s2573; const SBool s2575 = (SBool) ((s2574 >> 0) & 1); const SBool s2576 = false != s2575; const SWord8 s2577 = (s2561 >> 1) | (s2561 << 7); const SWord8 s2578 = 128 | s2577; const SWord8 s2579 = 127 & s2577; const SWord8 s2580 = s2576 ? s2578 : s2579; const SBool s2581 = (SBool) ((s2580 >> 0) & 1); const SBool s2582 = false != s2581; const SWord8 s2583 = (s2564 >> 1) | (s2564 << 7); const SWord8 s2584 = 128 | s2583; const SWord8 s2585 = 127 & s2583; const SWord8 s2586 = s2582 ? s2584 : s2585; const SBool s2587 = (SBool) ((s2586 >> 0) & 1); const SBool s2588 = false != s2587; const SBool s2589 = false == s2588; const SWord8 s2590 = (s2574 >> 1) | (s2574 << 7); const SWord8 s2591 = 128 | s2590; const SWord8 s2592 = 127 & s2590; const SWord8 s2593 = s2041 ? s2591 : s2592; const SBool s2594 = (SBool) ((s2593 >> 0) & 1); const SBool s2595 = false != s2594; const SWord8 s2596 = (s2580 >> 1) | (s2580 << 7); const SWord8 s2597 = 128 | s2596; const SWord8 s2598 = 127 & s2596; const SWord8 s2599 = s2595 ? s2597 : s2598; const SBool s2600 = (SBool) ((s2599 >> 0) & 1); const SBool s2601 = false != s2600; const SWord8 s2602 = (s2586 >> 1) | (s2586 << 7); const SWord8 s2603 = 128 | s2602; const SWord8 s2604 = 127 & s2602; const SWord8 s2605 = s2601 ? s2603 : s2604; const SBool s2606 = (SBool) ((s2605 >> 0) & 1); const SBool s2607 = false != s2606; const SBool s2608 = false == s2607; const SWord8 s2609 = (s2593 >> 1) | (s2593 << 7); const SWord8 s2610 = 128 | s2609; const SWord8 s2611 = 127 & s2609; const SWord8 s2612 = s2058 ? s2610 : s2611; const SWord8 s2613 = (s2612 >> 1) | (s2612 << 7); const SWord8 s2614 = 128 | s2613; const SWord8 s2615 = 127 & s2613; const SWord8 s2616 = s2566 ? s2614 : s2615; const SWord8 s2617 = (s2616 >> 1) | (s2616 << 7); const SWord8 s2618 = 128 | s2617; const SWord8 s2619 = 127 & s2617; const SWord8 s2620 = s2588 ? s2618 : s2619; const SWord8 s2621 = (s2620 >> 1) | (s2620 << 7); const SWord8 s2622 = 128 | s2621; const SWord8 s2623 = 127 & s2621; const SWord8 s2624 = s2607 ? s2622 : s2623; const SWord8 s2625 = s1 + s2620; const SBool s2626 = s2625 < s1; const SBool s2627 = s2625 < s2620; const SBool s2628 = s2626 || s2627; const SWord8 s2629 = (s2625 >> 1) | (s2625 << 7); const SWord8 s2630 = 128 | s2629; const SWord8 s2631 = 127 & s2629; const SWord8 s2632 = s2628 ? s2630 : s2631; const SWord8 s2633 = s2608 ? s2624 : s2632; const SWord8 s2634 = s1 + s2616; const SBool s2635 = s2634 < s1; const SBool s2636 = s2634 < s2616; const SBool s2637 = s2635 || s2636; const SWord8 s2638 = (s2634 >> 1) | (s2634 << 7); const SWord8 s2639 = 128 | s2638; const SWord8 s2640 = 127 & s2638; const SWord8 s2641 = s2637 ? s2639 : s2640; const SWord8 s2642 = (s2641 >> 1) | (s2641 << 7); const SWord8 s2643 = 128 | s2642; const SWord8 s2644 = 127 & s2642; const SWord8 s2645 = s2607 ? s2643 : s2644; const SWord8 s2646 = s1 + s2641; const SBool s2647 = s2646 < s1; const SBool s2648 = s2646 < s2641; const SBool s2649 = s2647 || s2648; const SWord8 s2650 = (s2646 >> 1) | (s2646 << 7); const SWord8 s2651 = 128 | s2650; const SWord8 s2652 = 127 & s2650; const SWord8 s2653 = s2649 ? s2651 : s2652; const SWord8 s2654 = s2608 ? s2645 : s2653; const SWord8 s2655 = s2589 ? s2633 : s2654; const SWord8 s2656 = s1 + s2612; const SBool s2657 = s2656 < s1; const SBool s2658 = s2656 < s2612; const SBool s2659 = s2657 || s2658; const SWord8 s2660 = (s2656 >> 1) | (s2656 << 7); const SWord8 s2661 = 128 | s2660; const SWord8 s2662 = 127 & s2660; const SWord8 s2663 = s2659 ? s2661 : s2662; const SWord8 s2664 = (s2663 >> 1) | (s2663 << 7); const SWord8 s2665 = 128 | s2664; const SWord8 s2666 = 127 & s2664; const SWord8 s2667 = s2588 ? s2665 : s2666; const SWord8 s2668 = (s2667 >> 1) | (s2667 << 7); const SWord8 s2669 = 128 | s2668; const SWord8 s2670 = 127 & s2668; const SWord8 s2671 = s2607 ? s2669 : s2670; const SWord8 s2672 = s1 + s2667; const SBool s2673 = s2672 < s1; const SBool s2674 = s2672 < s2667; const SBool s2675 = s2673 || s2674; const SWord8 s2676 = (s2672 >> 1) | (s2672 << 7); const SWord8 s2677 = 128 | s2676; const SWord8 s2678 = 127 & s2676; const SWord8 s2679 = s2675 ? s2677 : s2678; const SWord8 s2680 = s2608 ? s2671 : s2679; const SWord8 s2681 = s1 + s2663; const SBool s2682 = s2681 < s1; const SBool s2683 = s2681 < s2663; const SBool s2684 = s2682 || s2683; const SWord8 s2685 = (s2681 >> 1) | (s2681 << 7); const SWord8 s2686 = 128 | s2685; const SWord8 s2687 = 127 & s2685; const SWord8 s2688 = s2684 ? s2686 : s2687; const SWord8 s2689 = (s2688 >> 1) | (s2688 << 7); const SWord8 s2690 = 128 | s2689; const SWord8 s2691 = 127 & s2689; const SWord8 s2692 = s2607 ? s2690 : s2691; const SWord8 s2693 = s1 + s2688; const SBool s2694 = s2693 < s1; const SBool s2695 = s2693 < s2688; const SBool s2696 = s2694 || s2695; const SWord8 s2697 = (s2693 >> 1) | (s2693 << 7); const SWord8 s2698 = 128 | s2697; const SWord8 s2699 = 127 & s2697; const SWord8 s2700 = s2696 ? s2698 : s2699; const SWord8 s2701 = s2608 ? s2692 : s2700; const SWord8 s2702 = s2589 ? s2680 : s2701; const SWord8 s2703 = s2567 ? s2655 : s2702; const SWord8 s2704 = s1 + s2593; const SBool s2705 = (SBool) ((s2704 >> 0) & 1); const SBool s2706 = false != s2705; const SWord8 s2707 = s2706 ? s2597 : s2598; const SBool s2708 = (SBool) ((s2707 >> 0) & 1); const SBool s2709 = false != s2708; const SWord8 s2710 = s2709 ? s2603 : s2604; const SBool s2711 = (SBool) ((s2710 >> 0) & 1); const SBool s2712 = false != s2711; const SBool s2713 = false == s2712; const SBool s2714 = s2704 < s1; const SBool s2715 = s2704 < s2593; const SBool s2716 = s2714 || s2715; const SWord8 s2717 = (s2704 >> 1) | (s2704 << 7); const SWord8 s2718 = 128 | s2717; const SWord8 s2719 = 127 & s2717; const SWord8 s2720 = s2716 ? s2718 : s2719; const SWord8 s2721 = (s2720 >> 1) | (s2720 << 7); const SWord8 s2722 = 128 | s2721; const SWord8 s2723 = 127 & s2721; const SWord8 s2724 = s2566 ? s2722 : s2723; const SWord8 s2725 = (s2724 >> 1) | (s2724 << 7); const SWord8 s2726 = 128 | s2725; const SWord8 s2727 = 127 & s2725; const SWord8 s2728 = s2588 ? s2726 : s2727; const SWord8 s2729 = (s2728 >> 1) | (s2728 << 7); const SWord8 s2730 = 128 | s2729; const SWord8 s2731 = 127 & s2729; const SWord8 s2732 = s2712 ? s2730 : s2731; const SWord8 s2733 = s1 + s2728; const SBool s2734 = s2733 < s1; const SBool s2735 = s2733 < s2728; const SBool s2736 = s2734 || s2735; const SWord8 s2737 = (s2733 >> 1) | (s2733 << 7); const SWord8 s2738 = 128 | s2737; const SWord8 s2739 = 127 & s2737; const SWord8 s2740 = s2736 ? s2738 : s2739; const SWord8 s2741 = s2713 ? s2732 : s2740; const SWord8 s2742 = s1 + s2724; const SBool s2743 = s2742 < s1; const SBool s2744 = s2742 < s2724; const SBool s2745 = s2743 || s2744; const SWord8 s2746 = (s2742 >> 1) | (s2742 << 7); const SWord8 s2747 = 128 | s2746; const SWord8 s2748 = 127 & s2746; const SWord8 s2749 = s2745 ? s2747 : s2748; const SWord8 s2750 = (s2749 >> 1) | (s2749 << 7); const SWord8 s2751 = 128 | s2750; const SWord8 s2752 = 127 & s2750; const SWord8 s2753 = s2712 ? s2751 : s2752; const SWord8 s2754 = s1 + s2749; const SBool s2755 = s2754 < s1; const SBool s2756 = s2754 < s2749; const SBool s2757 = s2755 || s2756; const SWord8 s2758 = (s2754 >> 1) | (s2754 << 7); const SWord8 s2759 = 128 | s2758; const SWord8 s2760 = 127 & s2758; const SWord8 s2761 = s2757 ? s2759 : s2760; const SWord8 s2762 = s2713 ? s2753 : s2761; const SWord8 s2763 = s2589 ? s2741 : s2762; const SWord8 s2764 = s1 + s2720; const SBool s2765 = s2764 < s1; const SBool s2766 = s2764 < s2720; const SBool s2767 = s2765 || s2766; const SWord8 s2768 = (s2764 >> 1) | (s2764 << 7); const SWord8 s2769 = 128 | s2768; const SWord8 s2770 = 127 & s2768; const SWord8 s2771 = s2767 ? s2769 : s2770; const SWord8 s2772 = (s2771 >> 1) | (s2771 << 7); const SWord8 s2773 = 128 | s2772; const SWord8 s2774 = 127 & s2772; const SWord8 s2775 = s2588 ? s2773 : s2774; const SWord8 s2776 = (s2775 >> 1) | (s2775 << 7); const SWord8 s2777 = 128 | s2776; const SWord8 s2778 = 127 & s2776; const SWord8 s2779 = s2712 ? s2777 : s2778; const SWord8 s2780 = s1 + s2775; const SBool s2781 = s2780 < s1; const SBool s2782 = s2780 < s2775; const SBool s2783 = s2781 || s2782; const SWord8 s2784 = (s2780 >> 1) | (s2780 << 7); const SWord8 s2785 = 128 | s2784; const SWord8 s2786 = 127 & s2784; const SWord8 s2787 = s2783 ? s2785 : s2786; const SWord8 s2788 = s2713 ? s2779 : s2787; const SWord8 s2789 = s1 + s2771; const SBool s2790 = s2789 < s1; const SBool s2791 = s2789 < s2771; const SBool s2792 = s2790 || s2791; const SWord8 s2793 = (s2789 >> 1) | (s2789 << 7); const SWord8 s2794 = 128 | s2793; const SWord8 s2795 = 127 & s2793; const SWord8 s2796 = s2792 ? s2794 : s2795; const SWord8 s2797 = (s2796 >> 1) | (s2796 << 7); const SWord8 s2798 = 128 | s2797; const SWord8 s2799 = 127 & s2797; const SWord8 s2800 = s2712 ? s2798 : s2799; const SWord8 s2801 = s1 + s2796; const SBool s2802 = s2801 < s1; const SBool s2803 = s2801 < s2796; const SBool s2804 = s2802 || s2803; const SWord8 s2805 = (s2801 >> 1) | (s2801 << 7); const SWord8 s2806 = 128 | s2805; const SWord8 s2807 = 127 & s2805; const SWord8 s2808 = s2804 ? s2806 : s2807; const SWord8 s2809 = s2713 ? s2800 : s2808; const SWord8 s2810 = s2589 ? s2788 : s2809; const SWord8 s2811 = s2567 ? s2763 : s2810; const SWord8 s2812 = s2059 ? s2703 : s2811; const SWord8 s2813 = s1 + s2574; const SBool s2814 = (SBool) ((s2813 >> 0) & 1); const SBool s2815 = false != s2814; const SWord8 s2816 = s2815 ? s2578 : s2579; const SBool s2817 = (SBool) ((s2816 >> 0) & 1); const SBool s2818 = false != s2817; const SWord8 s2819 = s2818 ? s2584 : s2585; const SBool s2820 = (SBool) ((s2819 >> 0) & 1); const SBool s2821 = false != s2820; const SBool s2822 = false == s2821; const SBool s2823 = s2813 < s1; const SBool s2824 = s2813 < s2574; const SBool s2825 = s2823 || s2824; const SWord8 s2826 = (s2813 >> 1) | (s2813 << 7); const SWord8 s2827 = 128 | s2826; const SWord8 s2828 = 127 & s2826; const SWord8 s2829 = s2825 ? s2827 : s2828; const SBool s2830 = (SBool) ((s2829 >> 0) & 1); const SBool s2831 = false != s2830; const SWord8 s2832 = (s2816 >> 1) | (s2816 << 7); const SWord8 s2833 = 128 | s2832; const SWord8 s2834 = 127 & s2832; const SWord8 s2835 = s2831 ? s2833 : s2834; const SBool s2836 = (SBool) ((s2835 >> 0) & 1); const SBool s2837 = false != s2836; const SWord8 s2838 = (s2819 >> 1) | (s2819 << 7); const SWord8 s2839 = 128 | s2838; const SWord8 s2840 = 127 & s2838; const SWord8 s2841 = s2837 ? s2839 : s2840; const SBool s2842 = (SBool) ((s2841 >> 0) & 1); const SBool s2843 = false != s2842; const SBool s2844 = false == s2843; const SWord8 s2845 = (s2829 >> 1) | (s2829 << 7); const SWord8 s2846 = 128 | s2845; const SWord8 s2847 = 127 & s2845; const SWord8 s2848 = s2058 ? s2846 : s2847; const SWord8 s2849 = (s2848 >> 1) | (s2848 << 7); const SWord8 s2850 = 128 | s2849; const SWord8 s2851 = 127 & s2849; const SWord8 s2852 = s2566 ? s2850 : s2851; const SWord8 s2853 = (s2852 >> 1) | (s2852 << 7); const SWord8 s2854 = 128 | s2853; const SWord8 s2855 = 127 & s2853; const SWord8 s2856 = s2821 ? s2854 : s2855; const SWord8 s2857 = (s2856 >> 1) | (s2856 << 7); const SWord8 s2858 = 128 | s2857; const SWord8 s2859 = 127 & s2857; const SWord8 s2860 = s2843 ? s2858 : s2859; const SWord8 s2861 = s1 + s2856; const SBool s2862 = s2861 < s1; const SBool s2863 = s2861 < s2856; const SBool s2864 = s2862 || s2863; const SWord8 s2865 = (s2861 >> 1) | (s2861 << 7); const SWord8 s2866 = 128 | s2865; const SWord8 s2867 = 127 & s2865; const SWord8 s2868 = s2864 ? s2866 : s2867; const SWord8 s2869 = s2844 ? s2860 : s2868; const SWord8 s2870 = s1 + s2852; const SBool s2871 = s2870 < s1; const SBool s2872 = s2870 < s2852; const SBool s2873 = s2871 || s2872; const SWord8 s2874 = (s2870 >> 1) | (s2870 << 7); const SWord8 s2875 = 128 | s2874; const SWord8 s2876 = 127 & s2874; const SWord8 s2877 = s2873 ? s2875 : s2876; const SWord8 s2878 = (s2877 >> 1) | (s2877 << 7); const SWord8 s2879 = 128 | s2878; const SWord8 s2880 = 127 & s2878; const SWord8 s2881 = s2843 ? s2879 : s2880; const SWord8 s2882 = s1 + s2877; const SBool s2883 = s2882 < s1; const SBool s2884 = s2882 < s2877; const SBool s2885 = s2883 || s2884; const SWord8 s2886 = (s2882 >> 1) | (s2882 << 7); const SWord8 s2887 = 128 | s2886; const SWord8 s2888 = 127 & s2886; const SWord8 s2889 = s2885 ? s2887 : s2888; const SWord8 s2890 = s2844 ? s2881 : s2889; const SWord8 s2891 = s2822 ? s2869 : s2890; const SWord8 s2892 = s1 + s2848; const SBool s2893 = s2892 < s1; const SBool s2894 = s2892 < s2848; const SBool s2895 = s2893 || s2894; const SWord8 s2896 = (s2892 >> 1) | (s2892 << 7); const SWord8 s2897 = 128 | s2896; const SWord8 s2898 = 127 & s2896; const SWord8 s2899 = s2895 ? s2897 : s2898; const SWord8 s2900 = (s2899 >> 1) | (s2899 << 7); const SWord8 s2901 = 128 | s2900; const SWord8 s2902 = 127 & s2900; const SWord8 s2903 = s2821 ? s2901 : s2902; const SWord8 s2904 = (s2903 >> 1) | (s2903 << 7); const SWord8 s2905 = 128 | s2904; const SWord8 s2906 = 127 & s2904; const SWord8 s2907 = s2843 ? s2905 : s2906; const SWord8 s2908 = s1 + s2903; const SBool s2909 = s2908 < s1; const SBool s2910 = s2908 < s2903; const SBool s2911 = s2909 || s2910; const SWord8 s2912 = (s2908 >> 1) | (s2908 << 7); const SWord8 s2913 = 128 | s2912; const SWord8 s2914 = 127 & s2912; const SWord8 s2915 = s2911 ? s2913 : s2914; const SWord8 s2916 = s2844 ? s2907 : s2915; const SWord8 s2917 = s1 + s2899; const SBool s2918 = s2917 < s1; const SBool s2919 = s2917 < s2899; const SBool s2920 = s2918 || s2919; const SWord8 s2921 = (s2917 >> 1) | (s2917 << 7); const SWord8 s2922 = 128 | s2921; const SWord8 s2923 = 127 & s2921; const SWord8 s2924 = s2920 ? s2922 : s2923; const SWord8 s2925 = (s2924 >> 1) | (s2924 << 7); const SWord8 s2926 = 128 | s2925; const SWord8 s2927 = 127 & s2925; const SWord8 s2928 = s2843 ? s2926 : s2927; const SWord8 s2929 = s1 + s2924; const SBool s2930 = s2929 < s1; const SBool s2931 = s2929 < s2924; const SBool s2932 = s2930 || s2931; const SWord8 s2933 = (s2929 >> 1) | (s2929 << 7); const SWord8 s2934 = 128 | s2933; const SWord8 s2935 = 127 & s2933; const SWord8 s2936 = s2932 ? s2934 : s2935; const SWord8 s2937 = s2844 ? s2928 : s2936; const SWord8 s2938 = s2822 ? s2916 : s2937; const SWord8 s2939 = s2567 ? s2891 : s2938; const SWord8 s2940 = s1 + s2829; const SBool s2941 = (SBool) ((s2940 >> 0) & 1); const SBool s2942 = false != s2941; const SWord8 s2943 = s2942 ? s2833 : s2834; const SBool s2944 = (SBool) ((s2943 >> 0) & 1); const SBool s2945 = false != s2944; const SWord8 s2946 = s2945 ? s2839 : s2840; const SBool s2947 = (SBool) ((s2946 >> 0) & 1); const SBool s2948 = false != s2947; const SBool s2949 = false == s2948; const SBool s2950 = s2940 < s1; const SBool s2951 = s2940 < s2829; const SBool s2952 = s2950 || s2951; const SWord8 s2953 = (s2940 >> 1) | (s2940 << 7); const SWord8 s2954 = 128 | s2953; const SWord8 s2955 = 127 & s2953; const SWord8 s2956 = s2952 ? s2954 : s2955; const SWord8 s2957 = (s2956 >> 1) | (s2956 << 7); const SWord8 s2958 = 128 | s2957; const SWord8 s2959 = 127 & s2957; const SWord8 s2960 = s2566 ? s2958 : s2959; const SWord8 s2961 = (s2960 >> 1) | (s2960 << 7); const SWord8 s2962 = 128 | s2961; const SWord8 s2963 = 127 & s2961; const SWord8 s2964 = s2821 ? s2962 : s2963; const SWord8 s2965 = (s2964 >> 1) | (s2964 << 7); const SWord8 s2966 = 128 | s2965; const SWord8 s2967 = 127 & s2965; const SWord8 s2968 = s2948 ? s2966 : s2967; const SWord8 s2969 = s1 + s2964; const SBool s2970 = s2969 < s1; const SBool s2971 = s2969 < s2964; const SBool s2972 = s2970 || s2971; const SWord8 s2973 = (s2969 >> 1) | (s2969 << 7); const SWord8 s2974 = 128 | s2973; const SWord8 s2975 = 127 & s2973; const SWord8 s2976 = s2972 ? s2974 : s2975; const SWord8 s2977 = s2949 ? s2968 : s2976; const SWord8 s2978 = s1 + s2960; const SBool s2979 = s2978 < s1; const SBool s2980 = s2978 < s2960; const SBool s2981 = s2979 || s2980; const SWord8 s2982 = (s2978 >> 1) | (s2978 << 7); const SWord8 s2983 = 128 | s2982; const SWord8 s2984 = 127 & s2982; const SWord8 s2985 = s2981 ? s2983 : s2984; const SWord8 s2986 = (s2985 >> 1) | (s2985 << 7); const SWord8 s2987 = 128 | s2986; const SWord8 s2988 = 127 & s2986; const SWord8 s2989 = s2948 ? s2987 : s2988; const SWord8 s2990 = s1 + s2985; const SBool s2991 = s2990 < s1; const SBool s2992 = s2990 < s2985; const SBool s2993 = s2991 || s2992; const SWord8 s2994 = (s2990 >> 1) | (s2990 << 7); const SWord8 s2995 = 128 | s2994; const SWord8 s2996 = 127 & s2994; const SWord8 s2997 = s2993 ? s2995 : s2996; const SWord8 s2998 = s2949 ? s2989 : s2997; const SWord8 s2999 = s2822 ? s2977 : s2998; const SWord8 s3000 = s1 + s2956; const SBool s3001 = s3000 < s1; const SBool s3002 = s3000 < s2956; const SBool s3003 = s3001 || s3002; const SWord8 s3004 = (s3000 >> 1) | (s3000 << 7); const SWord8 s3005 = 128 | s3004; const SWord8 s3006 = 127 & s3004; const SWord8 s3007 = s3003 ? s3005 : s3006; const SWord8 s3008 = (s3007 >> 1) | (s3007 << 7); const SWord8 s3009 = 128 | s3008; const SWord8 s3010 = 127 & s3008; const SWord8 s3011 = s2821 ? s3009 : s3010; const SWord8 s3012 = (s3011 >> 1) | (s3011 << 7); const SWord8 s3013 = 128 | s3012; const SWord8 s3014 = 127 & s3012; const SWord8 s3015 = s2948 ? s3013 : s3014; const SWord8 s3016 = s1 + s3011; const SBool s3017 = s3016 < s1; const SBool s3018 = s3016 < s3011; const SBool s3019 = s3017 || s3018; const SWord8 s3020 = (s3016 >> 1) | (s3016 << 7); const SWord8 s3021 = 128 | s3020; const SWord8 s3022 = 127 & s3020; const SWord8 s3023 = s3019 ? s3021 : s3022; const SWord8 s3024 = s2949 ? s3015 : s3023; const SWord8 s3025 = s1 + s3007; const SBool s3026 = s3025 < s1; const SBool s3027 = s3025 < s3007; const SBool s3028 = s3026 || s3027; const SWord8 s3029 = (s3025 >> 1) | (s3025 << 7); const SWord8 s3030 = 128 | s3029; const SWord8 s3031 = 127 & s3029; const SWord8 s3032 = s3028 ? s3030 : s3031; const SWord8 s3033 = (s3032 >> 1) | (s3032 << 7); const SWord8 s3034 = 128 | s3033; const SWord8 s3035 = 127 & s3033; const SWord8 s3036 = s2948 ? s3034 : s3035; const SWord8 s3037 = s1 + s3032; const SBool s3038 = s3037 < s1; const SBool s3039 = s3037 < s3032; const SBool s3040 = s3038 || s3039; const SWord8 s3041 = (s3037 >> 1) | (s3037 << 7); const SWord8 s3042 = 128 | s3041; const SWord8 s3043 = 127 & s3041; const SWord8 s3044 = s3040 ? s3042 : s3043; const SWord8 s3045 = s2949 ? s3036 : s3044; const SWord8 s3046 = s2822 ? s3024 : s3045; const SWord8 s3047 = s2567 ? s2999 : s3046; const SWord8 s3048 = s2059 ? s2939 : s3047; const SWord8 s3049 = s2042 ? s2812 : s3048; const SWord8 s3050 = s16 ? s2557 : s3049; const SWord8 s3051 = s1 + s2044; const SBool s3052 = (SBool) ((s3051 >> 0) & 1); const SBool s3053 = false != s3052; const SWord8 s3054 = s3053 ? s2048 : s2049; const SBool s3055 = (SBool) ((s3054 >> 0) & 1); const SBool s3056 = false != s3055; const SWord8 s3057 = s3056 ? s2054 : s2055; const SBool s3058 = (SBool) ((s3057 >> 0) & 1); const SBool s3059 = false != s3058; const SBool s3060 = false == s3059; const SBool s3061 = s3051 < s1; const SBool s3062 = s3051 < s2044; const SBool s3063 = s3061 || s3062; const SWord8 s3064 = (s3051 >> 1) | (s3051 << 7); const SWord8 s3065 = 128 | s3064; const SWord8 s3066 = 127 & s3064; const SWord8 s3067 = s3063 ? s3065 : s3066; const SBool s3068 = (SBool) ((s3067 >> 0) & 1); const SBool s3069 = false != s3068; const SWord8 s3070 = (s3054 >> 1) | (s3054 << 7); const SWord8 s3071 = 128 | s3070; const SWord8 s3072 = 127 & s3070; const SWord8 s3073 = s3069 ? s3071 : s3072; const SBool s3074 = (SBool) ((s3073 >> 0) & 1); const SBool s3075 = false != s3074; const SWord8 s3076 = (s3057 >> 1) | (s3057 << 7); const SWord8 s3077 = 128 | s3076; const SWord8 s3078 = 127 & s3076; const SWord8 s3079 = s3075 ? s3077 : s3078; const SBool s3080 = (SBool) ((s3079 >> 0) & 1); const SBool s3081 = false != s3080; const SBool s3082 = false == s3081; const SWord8 s3083 = (s3067 >> 1) | (s3067 << 7); const SWord8 s3084 = 128 | s3083; const SWord8 s3085 = 127 & s3083; const SWord8 s3086 = s15 ? s3084 : s3085; const SBool s3087 = (SBool) ((s3086 >> 0) & 1); const SBool s3088 = false != s3087; const SWord8 s3089 = (s3073 >> 1) | (s3073 << 7); const SWord8 s3090 = 128 | s3089; const SWord8 s3091 = 127 & s3089; const SWord8 s3092 = s3088 ? s3090 : s3091; const SBool s3093 = (SBool) ((s3092 >> 0) & 1); const SBool s3094 = false != s3093; const SWord8 s3095 = (s3079 >> 1) | (s3079 << 7); const SWord8 s3096 = 128 | s3095; const SWord8 s3097 = 127 & s3095; const SWord8 s3098 = s3094 ? s3096 : s3097; const SBool s3099 = (SBool) ((s3098 >> 0) & 1); const SBool s3100 = false != s3099; const SBool s3101 = false == s3100; const SWord8 s3102 = (s3086 >> 1) | (s3086 << 7); const SWord8 s3103 = 128 | s3102; const SWord8 s3104 = 127 & s3102; const SWord8 s3105 = s2041 ? s3103 : s3104; const SBool s3106 = (SBool) ((s3105 >> 0) & 1); const SBool s3107 = false != s3106; const SWord8 s3108 = (s3092 >> 1) | (s3092 << 7); const SWord8 s3109 = 128 | s3108; const SWord8 s3110 = 127 & s3108; const SWord8 s3111 = s3107 ? s3109 : s3110; const SBool s3112 = (SBool) ((s3111 >> 0) & 1); const SBool s3113 = false != s3112; const SWord8 s3114 = (s3098 >> 1) | (s3098 << 7); const SWord8 s3115 = 128 | s3114; const SWord8 s3116 = 127 & s3114; const SWord8 s3117 = s3113 ? s3115 : s3116; const SBool s3118 = (SBool) ((s3117 >> 0) & 1); const SBool s3119 = false != s3118; const SBool s3120 = false == s3119; const SWord8 s3121 = (s3105 >> 1) | (s3105 << 7); const SWord8 s3122 = 128 | s3121; const SWord8 s3123 = 127 & s3121; const SWord8 s3124 = s3059 ? s3122 : s3123; const SWord8 s3125 = (s3124 >> 1) | (s3124 << 7); const SWord8 s3126 = 128 | s3125; const SWord8 s3127 = 127 & s3125; const SWord8 s3128 = s3081 ? s3126 : s3127; const SWord8 s3129 = (s3128 >> 1) | (s3128 << 7); const SWord8 s3130 = 128 | s3129; const SWord8 s3131 = 127 & s3129; const SWord8 s3132 = s3100 ? s3130 : s3131; const SWord8 s3133 = (s3132 >> 1) | (s3132 << 7); const SWord8 s3134 = 128 | s3133; const SWord8 s3135 = 127 & s3133; const SWord8 s3136 = s3119 ? s3134 : s3135; const SWord8 s3137 = s1 + s3132; const SBool s3138 = s3137 < s1; const SBool s3139 = s3137 < s3132; const SBool s3140 = s3138 || s3139; const SWord8 s3141 = (s3137 >> 1) | (s3137 << 7); const SWord8 s3142 = 128 | s3141; const SWord8 s3143 = 127 & s3141; const SWord8 s3144 = s3140 ? s3142 : s3143; const SWord8 s3145 = s3120 ? s3136 : s3144; const SWord8 s3146 = s1 + s3128; const SBool s3147 = s3146 < s1; const SBool s3148 = s3146 < s3128; const SBool s3149 = s3147 || s3148; const SWord8 s3150 = (s3146 >> 1) | (s3146 << 7); const SWord8 s3151 = 128 | s3150; const SWord8 s3152 = 127 & s3150; const SWord8 s3153 = s3149 ? s3151 : s3152; const SWord8 s3154 = (s3153 >> 1) | (s3153 << 7); const SWord8 s3155 = 128 | s3154; const SWord8 s3156 = 127 & s3154; const SWord8 s3157 = s3119 ? s3155 : s3156; const SWord8 s3158 = s1 + s3153; const SBool s3159 = s3158 < s1; const SBool s3160 = s3158 < s3153; const SBool s3161 = s3159 || s3160; const SWord8 s3162 = (s3158 >> 1) | (s3158 << 7); const SWord8 s3163 = 128 | s3162; const SWord8 s3164 = 127 & s3162; const SWord8 s3165 = s3161 ? s3163 : s3164; const SWord8 s3166 = s3120 ? s3157 : s3165; const SWord8 s3167 = s3101 ? s3145 : s3166; const SWord8 s3168 = s1 + s3124; const SBool s3169 = s3168 < s1; const SBool s3170 = s3168 < s3124; const SBool s3171 = s3169 || s3170; const SWord8 s3172 = (s3168 >> 1) | (s3168 << 7); const SWord8 s3173 = 128 | s3172; const SWord8 s3174 = 127 & s3172; const SWord8 s3175 = s3171 ? s3173 : s3174; const SWord8 s3176 = (s3175 >> 1) | (s3175 << 7); const SWord8 s3177 = 128 | s3176; const SWord8 s3178 = 127 & s3176; const SWord8 s3179 = s3100 ? s3177 : s3178; const SWord8 s3180 = (s3179 >> 1) | (s3179 << 7); const SWord8 s3181 = 128 | s3180; const SWord8 s3182 = 127 & s3180; const SWord8 s3183 = s3119 ? s3181 : s3182; const SWord8 s3184 = s1 + s3179; const SBool s3185 = s3184 < s1; const SBool s3186 = s3184 < s3179; const SBool s3187 = s3185 || s3186; const SWord8 s3188 = (s3184 >> 1) | (s3184 << 7); const SWord8 s3189 = 128 | s3188; const SWord8 s3190 = 127 & s3188; const SWord8 s3191 = s3187 ? s3189 : s3190; const SWord8 s3192 = s3120 ? s3183 : s3191; const SWord8 s3193 = s1 + s3175; const SBool s3194 = s3193 < s1; const SBool s3195 = s3193 < s3175; const SBool s3196 = s3194 || s3195; const SWord8 s3197 = (s3193 >> 1) | (s3193 << 7); const SWord8 s3198 = 128 | s3197; const SWord8 s3199 = 127 & s3197; const SWord8 s3200 = s3196 ? s3198 : s3199; const SWord8 s3201 = (s3200 >> 1) | (s3200 << 7); const SWord8 s3202 = 128 | s3201; const SWord8 s3203 = 127 & s3201; const SWord8 s3204 = s3119 ? s3202 : s3203; const SWord8 s3205 = s1 + s3200; const SBool s3206 = s3205 < s1; const SBool s3207 = s3205 < s3200; const SBool s3208 = s3206 || s3207; const SWord8 s3209 = (s3205 >> 1) | (s3205 << 7); const SWord8 s3210 = 128 | s3209; const SWord8 s3211 = 127 & s3209; const SWord8 s3212 = s3208 ? s3210 : s3211; const SWord8 s3213 = s3120 ? s3204 : s3212; const SWord8 s3214 = s3101 ? s3192 : s3213; const SWord8 s3215 = s3082 ? s3167 : s3214; const SWord8 s3216 = s1 + s3105; const SBool s3217 = (SBool) ((s3216 >> 0) & 1); const SBool s3218 = false != s3217; const SWord8 s3219 = s3218 ? s3109 : s3110; const SBool s3220 = (SBool) ((s3219 >> 0) & 1); const SBool s3221 = false != s3220; const SWord8 s3222 = s3221 ? s3115 : s3116; const SBool s3223 = (SBool) ((s3222 >> 0) & 1); const SBool s3224 = false != s3223; const SBool s3225 = false == s3224; const SBool s3226 = s3216 < s1; const SBool s3227 = s3216 < s3105; const SBool s3228 = s3226 || s3227; const SWord8 s3229 = (s3216 >> 1) | (s3216 << 7); const SWord8 s3230 = 128 | s3229; const SWord8 s3231 = 127 & s3229; const SWord8 s3232 = s3228 ? s3230 : s3231; const SWord8 s3233 = (s3232 >> 1) | (s3232 << 7); const SWord8 s3234 = 128 | s3233; const SWord8 s3235 = 127 & s3233; const SWord8 s3236 = s3081 ? s3234 : s3235; const SWord8 s3237 = (s3236 >> 1) | (s3236 << 7); const SWord8 s3238 = 128 | s3237; const SWord8 s3239 = 127 & s3237; const SWord8 s3240 = s3100 ? s3238 : s3239; const SWord8 s3241 = (s3240 >> 1) | (s3240 << 7); const SWord8 s3242 = 128 | s3241; const SWord8 s3243 = 127 & s3241; const SWord8 s3244 = s3224 ? s3242 : s3243; const SWord8 s3245 = s1 + s3240; const SBool s3246 = s3245 < s1; const SBool s3247 = s3245 < s3240; const SBool s3248 = s3246 || s3247; const SWord8 s3249 = (s3245 >> 1) | (s3245 << 7); const SWord8 s3250 = 128 | s3249; const SWord8 s3251 = 127 & s3249; const SWord8 s3252 = s3248 ? s3250 : s3251; const SWord8 s3253 = s3225 ? s3244 : s3252; const SWord8 s3254 = s1 + s3236; const SBool s3255 = s3254 < s1; const SBool s3256 = s3254 < s3236; const SBool s3257 = s3255 || s3256; const SWord8 s3258 = (s3254 >> 1) | (s3254 << 7); const SWord8 s3259 = 128 | s3258; const SWord8 s3260 = 127 & s3258; const SWord8 s3261 = s3257 ? s3259 : s3260; const SWord8 s3262 = (s3261 >> 1) | (s3261 << 7); const SWord8 s3263 = 128 | s3262; const SWord8 s3264 = 127 & s3262; const SWord8 s3265 = s3224 ? s3263 : s3264; const SWord8 s3266 = s1 + s3261; const SBool s3267 = s3266 < s1; const SBool s3268 = s3266 < s3261; const SBool s3269 = s3267 || s3268; const SWord8 s3270 = (s3266 >> 1) | (s3266 << 7); const SWord8 s3271 = 128 | s3270; const SWord8 s3272 = 127 & s3270; const SWord8 s3273 = s3269 ? s3271 : s3272; const SWord8 s3274 = s3225 ? s3265 : s3273; const SWord8 s3275 = s3101 ? s3253 : s3274; const SWord8 s3276 = s1 + s3232; const SBool s3277 = s3276 < s1; const SBool s3278 = s3276 < s3232; const SBool s3279 = s3277 || s3278; const SWord8 s3280 = (s3276 >> 1) | (s3276 << 7); const SWord8 s3281 = 128 | s3280; const SWord8 s3282 = 127 & s3280; const SWord8 s3283 = s3279 ? s3281 : s3282; const SWord8 s3284 = (s3283 >> 1) | (s3283 << 7); const SWord8 s3285 = 128 | s3284; const SWord8 s3286 = 127 & s3284; const SWord8 s3287 = s3100 ? s3285 : s3286; const SWord8 s3288 = (s3287 >> 1) | (s3287 << 7); const SWord8 s3289 = 128 | s3288; const SWord8 s3290 = 127 & s3288; const SWord8 s3291 = s3224 ? s3289 : s3290; const SWord8 s3292 = s1 + s3287; const SBool s3293 = s3292 < s1; const SBool s3294 = s3292 < s3287; const SBool s3295 = s3293 || s3294; const SWord8 s3296 = (s3292 >> 1) | (s3292 << 7); const SWord8 s3297 = 128 | s3296; const SWord8 s3298 = 127 & s3296; const SWord8 s3299 = s3295 ? s3297 : s3298; const SWord8 s3300 = s3225 ? s3291 : s3299; const SWord8 s3301 = s1 + s3283; const SBool s3302 = s3301 < s1; const SBool s3303 = s3301 < s3283; const SBool s3304 = s3302 || s3303; const SWord8 s3305 = (s3301 >> 1) | (s3301 << 7); const SWord8 s3306 = 128 | s3305; const SWord8 s3307 = 127 & s3305; const SWord8 s3308 = s3304 ? s3306 : s3307; const SWord8 s3309 = (s3308 >> 1) | (s3308 << 7); const SWord8 s3310 = 128 | s3309; const SWord8 s3311 = 127 & s3309; const SWord8 s3312 = s3224 ? s3310 : s3311; const SWord8 s3313 = s1 + s3308; const SBool s3314 = s3313 < s1; const SBool s3315 = s3313 < s3308; const SBool s3316 = s3314 || s3315; const SWord8 s3317 = (s3313 >> 1) | (s3313 << 7); const SWord8 s3318 = 128 | s3317; const SWord8 s3319 = 127 & s3317; const SWord8 s3320 = s3316 ? s3318 : s3319; const SWord8 s3321 = s3225 ? s3312 : s3320; const SWord8 s3322 = s3101 ? s3300 : s3321; const SWord8 s3323 = s3082 ? s3275 : s3322; const SWord8 s3324 = s3060 ? s3215 : s3323; const SWord8 s3325 = s1 + s3086; const SBool s3326 = (SBool) ((s3325 >> 0) & 1); const SBool s3327 = false != s3326; const SWord8 s3328 = s3327 ? s3090 : s3091; const SBool s3329 = (SBool) ((s3328 >> 0) & 1); const SBool s3330 = false != s3329; const SWord8 s3331 = s3330 ? s3096 : s3097; const SBool s3332 = (SBool) ((s3331 >> 0) & 1); const SBool s3333 = false != s3332; const SBool s3334 = false == s3333; const SBool s3335 = s3325 < s1; const SBool s3336 = s3325 < s3086; const SBool s3337 = s3335 || s3336; const SWord8 s3338 = (s3325 >> 1) | (s3325 << 7); const SWord8 s3339 = 128 | s3338; const SWord8 s3340 = 127 & s3338; const SWord8 s3341 = s3337 ? s3339 : s3340; const SBool s3342 = (SBool) ((s3341 >> 0) & 1); const SBool s3343 = false != s3342; const SWord8 s3344 = (s3328 >> 1) | (s3328 << 7); const SWord8 s3345 = 128 | s3344; const SWord8 s3346 = 127 & s3344; const SWord8 s3347 = s3343 ? s3345 : s3346; const SBool s3348 = (SBool) ((s3347 >> 0) & 1); const SBool s3349 = false != s3348; const SWord8 s3350 = (s3331 >> 1) | (s3331 << 7); const SWord8 s3351 = 128 | s3350; const SWord8 s3352 = 127 & s3350; const SWord8 s3353 = s3349 ? s3351 : s3352; const SBool s3354 = (SBool) ((s3353 >> 0) & 1); const SBool s3355 = false != s3354; const SBool s3356 = false == s3355; const SWord8 s3357 = (s3341 >> 1) | (s3341 << 7); const SWord8 s3358 = 128 | s3357; const SWord8 s3359 = 127 & s3357; const SWord8 s3360 = s3059 ? s3358 : s3359; const SWord8 s3361 = (s3360 >> 1) | (s3360 << 7); const SWord8 s3362 = 128 | s3361; const SWord8 s3363 = 127 & s3361; const SWord8 s3364 = s3081 ? s3362 : s3363; const SWord8 s3365 = (s3364 >> 1) | (s3364 << 7); const SWord8 s3366 = 128 | s3365; const SWord8 s3367 = 127 & s3365; const SWord8 s3368 = s3333 ? s3366 : s3367; const SWord8 s3369 = (s3368 >> 1) | (s3368 << 7); const SWord8 s3370 = 128 | s3369; const SWord8 s3371 = 127 & s3369; const SWord8 s3372 = s3355 ? s3370 : s3371; const SWord8 s3373 = s1 + s3368; const SBool s3374 = s3373 < s1; const SBool s3375 = s3373 < s3368; const SBool s3376 = s3374 || s3375; const SWord8 s3377 = (s3373 >> 1) | (s3373 << 7); const SWord8 s3378 = 128 | s3377; const SWord8 s3379 = 127 & s3377; const SWord8 s3380 = s3376 ? s3378 : s3379; const SWord8 s3381 = s3356 ? s3372 : s3380; const SWord8 s3382 = s1 + s3364; const SBool s3383 = s3382 < s1; const SBool s3384 = s3382 < s3364; const SBool s3385 = s3383 || s3384; const SWord8 s3386 = (s3382 >> 1) | (s3382 << 7); const SWord8 s3387 = 128 | s3386; const SWord8 s3388 = 127 & s3386; const SWord8 s3389 = s3385 ? s3387 : s3388; const SWord8 s3390 = (s3389 >> 1) | (s3389 << 7); const SWord8 s3391 = 128 | s3390; const SWord8 s3392 = 127 & s3390; const SWord8 s3393 = s3355 ? s3391 : s3392; const SWord8 s3394 = s1 + s3389; const SBool s3395 = s3394 < s1; const SBool s3396 = s3394 < s3389; const SBool s3397 = s3395 || s3396; const SWord8 s3398 = (s3394 >> 1) | (s3394 << 7); const SWord8 s3399 = 128 | s3398; const SWord8 s3400 = 127 & s3398; const SWord8 s3401 = s3397 ? s3399 : s3400; const SWord8 s3402 = s3356 ? s3393 : s3401; const SWord8 s3403 = s3334 ? s3381 : s3402; const SWord8 s3404 = s1 + s3360; const SBool s3405 = s3404 < s1; const SBool s3406 = s3404 < s3360; const SBool s3407 = s3405 || s3406; const SWord8 s3408 = (s3404 >> 1) | (s3404 << 7); const SWord8 s3409 = 128 | s3408; const SWord8 s3410 = 127 & s3408; const SWord8 s3411 = s3407 ? s3409 : s3410; const SWord8 s3412 = (s3411 >> 1) | (s3411 << 7); const SWord8 s3413 = 128 | s3412; const SWord8 s3414 = 127 & s3412; const SWord8 s3415 = s3333 ? s3413 : s3414; const SWord8 s3416 = (s3415 >> 1) | (s3415 << 7); const SWord8 s3417 = 128 | s3416; const SWord8 s3418 = 127 & s3416; const SWord8 s3419 = s3355 ? s3417 : s3418; const SWord8 s3420 = s1 + s3415; const SBool s3421 = s3420 < s1; const SBool s3422 = s3420 < s3415; const SBool s3423 = s3421 || s3422; const SWord8 s3424 = (s3420 >> 1) | (s3420 << 7); const SWord8 s3425 = 128 | s3424; const SWord8 s3426 = 127 & s3424; const SWord8 s3427 = s3423 ? s3425 : s3426; const SWord8 s3428 = s3356 ? s3419 : s3427; const SWord8 s3429 = s1 + s3411; const SBool s3430 = s3429 < s1; const SBool s3431 = s3429 < s3411; const SBool s3432 = s3430 || s3431; const SWord8 s3433 = (s3429 >> 1) | (s3429 << 7); const SWord8 s3434 = 128 | s3433; const SWord8 s3435 = 127 & s3433; const SWord8 s3436 = s3432 ? s3434 : s3435; const SWord8 s3437 = (s3436 >> 1) | (s3436 << 7); const SWord8 s3438 = 128 | s3437; const SWord8 s3439 = 127 & s3437; const SWord8 s3440 = s3355 ? s3438 : s3439; const SWord8 s3441 = s1 + s3436; const SBool s3442 = s3441 < s1; const SBool s3443 = s3441 < s3436; const SBool s3444 = s3442 || s3443; const SWord8 s3445 = (s3441 >> 1) | (s3441 << 7); const SWord8 s3446 = 128 | s3445; const SWord8 s3447 = 127 & s3445; const SWord8 s3448 = s3444 ? s3446 : s3447; const SWord8 s3449 = s3356 ? s3440 : s3448; const SWord8 s3450 = s3334 ? s3428 : s3449; const SWord8 s3451 = s3082 ? s3403 : s3450; const SWord8 s3452 = s1 + s3341; const SBool s3453 = (SBool) ((s3452 >> 0) & 1); const SBool s3454 = false != s3453; const SWord8 s3455 = s3454 ? s3345 : s3346; const SBool s3456 = (SBool) ((s3455 >> 0) & 1); const SBool s3457 = false != s3456; const SWord8 s3458 = s3457 ? s3351 : s3352; const SBool s3459 = (SBool) ((s3458 >> 0) & 1); const SBool s3460 = false != s3459; const SBool s3461 = false == s3460; const SBool s3462 = s3452 < s1; const SBool s3463 = s3452 < s3341; const SBool s3464 = s3462 || s3463; const SWord8 s3465 = (s3452 >> 1) | (s3452 << 7); const SWord8 s3466 = 128 | s3465; const SWord8 s3467 = 127 & s3465; const SWord8 s3468 = s3464 ? s3466 : s3467; const SWord8 s3469 = (s3468 >> 1) | (s3468 << 7); const SWord8 s3470 = 128 | s3469; const SWord8 s3471 = 127 & s3469; const SWord8 s3472 = s3081 ? s3470 : s3471; const SWord8 s3473 = (s3472 >> 1) | (s3472 << 7); const SWord8 s3474 = 128 | s3473; const SWord8 s3475 = 127 & s3473; const SWord8 s3476 = s3333 ? s3474 : s3475; const SWord8 s3477 = (s3476 >> 1) | (s3476 << 7); const SWord8 s3478 = 128 | s3477; const SWord8 s3479 = 127 & s3477; const SWord8 s3480 = s3460 ? s3478 : s3479; const SWord8 s3481 = s1 + s3476; const SBool s3482 = s3481 < s1; const SBool s3483 = s3481 < s3476; const SBool s3484 = s3482 || s3483; const SWord8 s3485 = (s3481 >> 1) | (s3481 << 7); const SWord8 s3486 = 128 | s3485; const SWord8 s3487 = 127 & s3485; const SWord8 s3488 = s3484 ? s3486 : s3487; const SWord8 s3489 = s3461 ? s3480 : s3488; const SWord8 s3490 = s1 + s3472; const SBool s3491 = s3490 < s1; const SBool s3492 = s3490 < s3472; const SBool s3493 = s3491 || s3492; const SWord8 s3494 = (s3490 >> 1) | (s3490 << 7); const SWord8 s3495 = 128 | s3494; const SWord8 s3496 = 127 & s3494; const SWord8 s3497 = s3493 ? s3495 : s3496; const SWord8 s3498 = (s3497 >> 1) | (s3497 << 7); const SWord8 s3499 = 128 | s3498; const SWord8 s3500 = 127 & s3498; const SWord8 s3501 = s3460 ? s3499 : s3500; const SWord8 s3502 = s1 + s3497; const SBool s3503 = s3502 < s1; const SBool s3504 = s3502 < s3497; const SBool s3505 = s3503 || s3504; const SWord8 s3506 = (s3502 >> 1) | (s3502 << 7); const SWord8 s3507 = 128 | s3506; const SWord8 s3508 = 127 & s3506; const SWord8 s3509 = s3505 ? s3507 : s3508; const SWord8 s3510 = s3461 ? s3501 : s3509; const SWord8 s3511 = s3334 ? s3489 : s3510; const SWord8 s3512 = s1 + s3468; const SBool s3513 = s3512 < s1; const SBool s3514 = s3512 < s3468; const SBool s3515 = s3513 || s3514; const SWord8 s3516 = (s3512 >> 1) | (s3512 << 7); const SWord8 s3517 = 128 | s3516; const SWord8 s3518 = 127 & s3516; const SWord8 s3519 = s3515 ? s3517 : s3518; const SWord8 s3520 = (s3519 >> 1) | (s3519 << 7); const SWord8 s3521 = 128 | s3520; const SWord8 s3522 = 127 & s3520; const SWord8 s3523 = s3333 ? s3521 : s3522; const SWord8 s3524 = (s3523 >> 1) | (s3523 << 7); const SWord8 s3525 = 128 | s3524; const SWord8 s3526 = 127 & s3524; const SWord8 s3527 = s3460 ? s3525 : s3526; const SWord8 s3528 = s1 + s3523; const SBool s3529 = s3528 < s1; const SBool s3530 = s3528 < s3523; const SBool s3531 = s3529 || s3530; const SWord8 s3532 = (s3528 >> 1) | (s3528 << 7); const SWord8 s3533 = 128 | s3532; const SWord8 s3534 = 127 & s3532; const SWord8 s3535 = s3531 ? s3533 : s3534; const SWord8 s3536 = s3461 ? s3527 : s3535; const SWord8 s3537 = s1 + s3519; const SBool s3538 = s3537 < s1; const SBool s3539 = s3537 < s3519; const SBool s3540 = s3538 || s3539; const SWord8 s3541 = (s3537 >> 1) | (s3537 << 7); const SWord8 s3542 = 128 | s3541; const SWord8 s3543 = 127 & s3541; const SWord8 s3544 = s3540 ? s3542 : s3543; const SWord8 s3545 = (s3544 >> 1) | (s3544 << 7); const SWord8 s3546 = 128 | s3545; const SWord8 s3547 = 127 & s3545; const SWord8 s3548 = s3460 ? s3546 : s3547; const SWord8 s3549 = s1 + s3544; const SBool s3550 = s3549 < s1; const SBool s3551 = s3549 < s3544; const SBool s3552 = s3550 || s3551; const SWord8 s3553 = (s3549 >> 1) | (s3549 << 7); const SWord8 s3554 = 128 | s3553; const SWord8 s3555 = 127 & s3553; const SWord8 s3556 = s3552 ? s3554 : s3555; const SWord8 s3557 = s3461 ? s3548 : s3556; const SWord8 s3558 = s3334 ? s3536 : s3557; const SWord8 s3559 = s3082 ? s3511 : s3558; const SWord8 s3560 = s3060 ? s3451 : s3559; const SWord8 s3561 = s2042 ? s3324 : s3560; const SWord8 s3562 = s1 + s3067; const SBool s3563 = (SBool) ((s3562 >> 0) & 1); const SBool s3564 = false != s3563; const SWord8 s3565 = s3564 ? s3071 : s3072; const SBool s3566 = (SBool) ((s3565 >> 0) & 1); const SBool s3567 = false != s3566; const SWord8 s3568 = s3567 ? s3077 : s3078; const SBool s3569 = (SBool) ((s3568 >> 0) & 1); const SBool s3570 = false != s3569; const SBool s3571 = false == s3570; const SBool s3572 = s3562 < s1; const SBool s3573 = s3562 < s3067; const SBool s3574 = s3572 || s3573; const SWord8 s3575 = (s3562 >> 1) | (s3562 << 7); const SWord8 s3576 = 128 | s3575; const SWord8 s3577 = 127 & s3575; const SWord8 s3578 = s3574 ? s3576 : s3577; const SBool s3579 = (SBool) ((s3578 >> 0) & 1); const SBool s3580 = false != s3579; const SWord8 s3581 = (s3565 >> 1) | (s3565 << 7); const SWord8 s3582 = 128 | s3581; const SWord8 s3583 = 127 & s3581; const SWord8 s3584 = s3580 ? s3582 : s3583; const SBool s3585 = (SBool) ((s3584 >> 0) & 1); const SBool s3586 = false != s3585; const SWord8 s3587 = (s3568 >> 1) | (s3568 << 7); const SWord8 s3588 = 128 | s3587; const SWord8 s3589 = 127 & s3587; const SWord8 s3590 = s3586 ? s3588 : s3589; const SBool s3591 = (SBool) ((s3590 >> 0) & 1); const SBool s3592 = false != s3591; const SBool s3593 = false == s3592; const SWord8 s3594 = (s3578 >> 1) | (s3578 << 7); const SWord8 s3595 = 128 | s3594; const SWord8 s3596 = 127 & s3594; const SWord8 s3597 = s2041 ? s3595 : s3596; const SBool s3598 = (SBool) ((s3597 >> 0) & 1); const SBool s3599 = false != s3598; const SWord8 s3600 = (s3584 >> 1) | (s3584 << 7); const SWord8 s3601 = 128 | s3600; const SWord8 s3602 = 127 & s3600; const SWord8 s3603 = s3599 ? s3601 : s3602; const SBool s3604 = (SBool) ((s3603 >> 0) & 1); const SBool s3605 = false != s3604; const SWord8 s3606 = (s3590 >> 1) | (s3590 << 7); const SWord8 s3607 = 128 | s3606; const SWord8 s3608 = 127 & s3606; const SWord8 s3609 = s3605 ? s3607 : s3608; const SBool s3610 = (SBool) ((s3609 >> 0) & 1); const SBool s3611 = false != s3610; const SBool s3612 = false == s3611; const SWord8 s3613 = (s3597 >> 1) | (s3597 << 7); const SWord8 s3614 = 128 | s3613; const SWord8 s3615 = 127 & s3613; const SWord8 s3616 = s3059 ? s3614 : s3615; const SWord8 s3617 = (s3616 >> 1) | (s3616 << 7); const SWord8 s3618 = 128 | s3617; const SWord8 s3619 = 127 & s3617; const SWord8 s3620 = s3570 ? s3618 : s3619; const SWord8 s3621 = (s3620 >> 1) | (s3620 << 7); const SWord8 s3622 = 128 | s3621; const SWord8 s3623 = 127 & s3621; const SWord8 s3624 = s3592 ? s3622 : s3623; const SWord8 s3625 = (s3624 >> 1) | (s3624 << 7); const SWord8 s3626 = 128 | s3625; const SWord8 s3627 = 127 & s3625; const SWord8 s3628 = s3611 ? s3626 : s3627; const SWord8 s3629 = s1 + s3624; const SBool s3630 = s3629 < s1; const SBool s3631 = s3629 < s3624; const SBool s3632 = s3630 || s3631; const SWord8 s3633 = (s3629 >> 1) | (s3629 << 7); const SWord8 s3634 = 128 | s3633; const SWord8 s3635 = 127 & s3633; const SWord8 s3636 = s3632 ? s3634 : s3635; const SWord8 s3637 = s3612 ? s3628 : s3636; const SWord8 s3638 = s1 + s3620; const SBool s3639 = s3638 < s1; const SBool s3640 = s3638 < s3620; const SBool s3641 = s3639 || s3640; const SWord8 s3642 = (s3638 >> 1) | (s3638 << 7); const SWord8 s3643 = 128 | s3642; const SWord8 s3644 = 127 & s3642; const SWord8 s3645 = s3641 ? s3643 : s3644; const SWord8 s3646 = (s3645 >> 1) | (s3645 << 7); const SWord8 s3647 = 128 | s3646; const SWord8 s3648 = 127 & s3646; const SWord8 s3649 = s3611 ? s3647 : s3648; const SWord8 s3650 = s1 + s3645; const SBool s3651 = s3650 < s1; const SBool s3652 = s3650 < s3645; const SBool s3653 = s3651 || s3652; const SWord8 s3654 = (s3650 >> 1) | (s3650 << 7); const SWord8 s3655 = 128 | s3654; const SWord8 s3656 = 127 & s3654; const SWord8 s3657 = s3653 ? s3655 : s3656; const SWord8 s3658 = s3612 ? s3649 : s3657; const SWord8 s3659 = s3593 ? s3637 : s3658; const SWord8 s3660 = s1 + s3616; const SBool s3661 = s3660 < s1; const SBool s3662 = s3660 < s3616; const SBool s3663 = s3661 || s3662; const SWord8 s3664 = (s3660 >> 1) | (s3660 << 7); const SWord8 s3665 = 128 | s3664; const SWord8 s3666 = 127 & s3664; const SWord8 s3667 = s3663 ? s3665 : s3666; const SWord8 s3668 = (s3667 >> 1) | (s3667 << 7); const SWord8 s3669 = 128 | s3668; const SWord8 s3670 = 127 & s3668; const SWord8 s3671 = s3592 ? s3669 : s3670; const SWord8 s3672 = (s3671 >> 1) | (s3671 << 7); const SWord8 s3673 = 128 | s3672; const SWord8 s3674 = 127 & s3672; const SWord8 s3675 = s3611 ? s3673 : s3674; const SWord8 s3676 = s1 + s3671; const SBool s3677 = s3676 < s1; const SBool s3678 = s3676 < s3671; const SBool s3679 = s3677 || s3678; const SWord8 s3680 = (s3676 >> 1) | (s3676 << 7); const SWord8 s3681 = 128 | s3680; const SWord8 s3682 = 127 & s3680; const SWord8 s3683 = s3679 ? s3681 : s3682; const SWord8 s3684 = s3612 ? s3675 : s3683; const SWord8 s3685 = s1 + s3667; const SBool s3686 = s3685 < s1; const SBool s3687 = s3685 < s3667; const SBool s3688 = s3686 || s3687; const SWord8 s3689 = (s3685 >> 1) | (s3685 << 7); const SWord8 s3690 = 128 | s3689; const SWord8 s3691 = 127 & s3689; const SWord8 s3692 = s3688 ? s3690 : s3691; const SWord8 s3693 = (s3692 >> 1) | (s3692 << 7); const SWord8 s3694 = 128 | s3693; const SWord8 s3695 = 127 & s3693; const SWord8 s3696 = s3611 ? s3694 : s3695; const SWord8 s3697 = s1 + s3692; const SBool s3698 = s3697 < s1; const SBool s3699 = s3697 < s3692; const SBool s3700 = s3698 || s3699; const SWord8 s3701 = (s3697 >> 1) | (s3697 << 7); const SWord8 s3702 = 128 | s3701; const SWord8 s3703 = 127 & s3701; const SWord8 s3704 = s3700 ? s3702 : s3703; const SWord8 s3705 = s3612 ? s3696 : s3704; const SWord8 s3706 = s3593 ? s3684 : s3705; const SWord8 s3707 = s3571 ? s3659 : s3706; const SWord8 s3708 = s1 + s3597; const SBool s3709 = (SBool) ((s3708 >> 0) & 1); const SBool s3710 = false != s3709; const SWord8 s3711 = s3710 ? s3601 : s3602; const SBool s3712 = (SBool) ((s3711 >> 0) & 1); const SBool s3713 = false != s3712; const SWord8 s3714 = s3713 ? s3607 : s3608; const SBool s3715 = (SBool) ((s3714 >> 0) & 1); const SBool s3716 = false != s3715; const SBool s3717 = false == s3716; const SBool s3718 = s3708 < s1; const SBool s3719 = s3708 < s3597; const SBool s3720 = s3718 || s3719; const SWord8 s3721 = (s3708 >> 1) | (s3708 << 7); const SWord8 s3722 = 128 | s3721; const SWord8 s3723 = 127 & s3721; const SWord8 s3724 = s3720 ? s3722 : s3723; const SWord8 s3725 = (s3724 >> 1) | (s3724 << 7); const SWord8 s3726 = 128 | s3725; const SWord8 s3727 = 127 & s3725; const SWord8 s3728 = s3570 ? s3726 : s3727; const SWord8 s3729 = (s3728 >> 1) | (s3728 << 7); const SWord8 s3730 = 128 | s3729; const SWord8 s3731 = 127 & s3729; const SWord8 s3732 = s3592 ? s3730 : s3731; const SWord8 s3733 = (s3732 >> 1) | (s3732 << 7); const SWord8 s3734 = 128 | s3733; const SWord8 s3735 = 127 & s3733; const SWord8 s3736 = s3716 ? s3734 : s3735; const SWord8 s3737 = s1 + s3732; const SBool s3738 = s3737 < s1; const SBool s3739 = s3737 < s3732; const SBool s3740 = s3738 || s3739; const SWord8 s3741 = (s3737 >> 1) | (s3737 << 7); const SWord8 s3742 = 128 | s3741; const SWord8 s3743 = 127 & s3741; const SWord8 s3744 = s3740 ? s3742 : s3743; const SWord8 s3745 = s3717 ? s3736 : s3744; const SWord8 s3746 = s1 + s3728; const SBool s3747 = s3746 < s1; const SBool s3748 = s3746 < s3728; const SBool s3749 = s3747 || s3748; const SWord8 s3750 = (s3746 >> 1) | (s3746 << 7); const SWord8 s3751 = 128 | s3750; const SWord8 s3752 = 127 & s3750; const SWord8 s3753 = s3749 ? s3751 : s3752; const SWord8 s3754 = (s3753 >> 1) | (s3753 << 7); const SWord8 s3755 = 128 | s3754; const SWord8 s3756 = 127 & s3754; const SWord8 s3757 = s3716 ? s3755 : s3756; const SWord8 s3758 = s1 + s3753; const SBool s3759 = s3758 < s1; const SBool s3760 = s3758 < s3753; const SBool s3761 = s3759 || s3760; const SWord8 s3762 = (s3758 >> 1) | (s3758 << 7); const SWord8 s3763 = 128 | s3762; const SWord8 s3764 = 127 & s3762; const SWord8 s3765 = s3761 ? s3763 : s3764; const SWord8 s3766 = s3717 ? s3757 : s3765; const SWord8 s3767 = s3593 ? s3745 : s3766; const SWord8 s3768 = s1 + s3724; const SBool s3769 = s3768 < s1; const SBool s3770 = s3768 < s3724; const SBool s3771 = s3769 || s3770; const SWord8 s3772 = (s3768 >> 1) | (s3768 << 7); const SWord8 s3773 = 128 | s3772; const SWord8 s3774 = 127 & s3772; const SWord8 s3775 = s3771 ? s3773 : s3774; const SWord8 s3776 = (s3775 >> 1) | (s3775 << 7); const SWord8 s3777 = 128 | s3776; const SWord8 s3778 = 127 & s3776; const SWord8 s3779 = s3592 ? s3777 : s3778; const SWord8 s3780 = (s3779 >> 1) | (s3779 << 7); const SWord8 s3781 = 128 | s3780; const SWord8 s3782 = 127 & s3780; const SWord8 s3783 = s3716 ? s3781 : s3782; const SWord8 s3784 = s1 + s3779; const SBool s3785 = s3784 < s1; const SBool s3786 = s3784 < s3779; const SBool s3787 = s3785 || s3786; const SWord8 s3788 = (s3784 >> 1) | (s3784 << 7); const SWord8 s3789 = 128 | s3788; const SWord8 s3790 = 127 & s3788; const SWord8 s3791 = s3787 ? s3789 : s3790; const SWord8 s3792 = s3717 ? s3783 : s3791; const SWord8 s3793 = s1 + s3775; const SBool s3794 = s3793 < s1; const SBool s3795 = s3793 < s3775; const SBool s3796 = s3794 || s3795; const SWord8 s3797 = (s3793 >> 1) | (s3793 << 7); const SWord8 s3798 = 128 | s3797; const SWord8 s3799 = 127 & s3797; const SWord8 s3800 = s3796 ? s3798 : s3799; const SWord8 s3801 = (s3800 >> 1) | (s3800 << 7); const SWord8 s3802 = 128 | s3801; const SWord8 s3803 = 127 & s3801; const SWord8 s3804 = s3716 ? s3802 : s3803; const SWord8 s3805 = s1 + s3800; const SBool s3806 = s3805 < s1; const SBool s3807 = s3805 < s3800; const SBool s3808 = s3806 || s3807; const SWord8 s3809 = (s3805 >> 1) | (s3805 << 7); const SWord8 s3810 = 128 | s3809; const SWord8 s3811 = 127 & s3809; const SWord8 s3812 = s3808 ? s3810 : s3811; const SWord8 s3813 = s3717 ? s3804 : s3812; const SWord8 s3814 = s3593 ? s3792 : s3813; const SWord8 s3815 = s3571 ? s3767 : s3814; const SWord8 s3816 = s3060 ? s3707 : s3815; const SWord8 s3817 = s1 + s3578; const SBool s3818 = (SBool) ((s3817 >> 0) & 1); const SBool s3819 = false != s3818; const SWord8 s3820 = s3819 ? s3582 : s3583; const SBool s3821 = (SBool) ((s3820 >> 0) & 1); const SBool s3822 = false != s3821; const SWord8 s3823 = s3822 ? s3588 : s3589; const SBool s3824 = (SBool) ((s3823 >> 0) & 1); const SBool s3825 = false != s3824; const SBool s3826 = false == s3825; const SBool s3827 = s3817 < s1; const SBool s3828 = s3817 < s3578; const SBool s3829 = s3827 || s3828; const SWord8 s3830 = (s3817 >> 1) | (s3817 << 7); const SWord8 s3831 = 128 | s3830; const SWord8 s3832 = 127 & s3830; const SWord8 s3833 = s3829 ? s3831 : s3832; const SBool s3834 = (SBool) ((s3833 >> 0) & 1); const SBool s3835 = false != s3834; const SWord8 s3836 = (s3820 >> 1) | (s3820 << 7); const SWord8 s3837 = 128 | s3836; const SWord8 s3838 = 127 & s3836; const SWord8 s3839 = s3835 ? s3837 : s3838; const SBool s3840 = (SBool) ((s3839 >> 0) & 1); const SBool s3841 = false != s3840; const SWord8 s3842 = (s3823 >> 1) | (s3823 << 7); const SWord8 s3843 = 128 | s3842; const SWord8 s3844 = 127 & s3842; const SWord8 s3845 = s3841 ? s3843 : s3844; const SBool s3846 = (SBool) ((s3845 >> 0) & 1); const SBool s3847 = false != s3846; const SBool s3848 = false == s3847; const SWord8 s3849 = (s3833 >> 1) | (s3833 << 7); const SWord8 s3850 = 128 | s3849; const SWord8 s3851 = 127 & s3849; const SWord8 s3852 = s3059 ? s3850 : s3851; const SWord8 s3853 = (s3852 >> 1) | (s3852 << 7); const SWord8 s3854 = 128 | s3853; const SWord8 s3855 = 127 & s3853; const SWord8 s3856 = s3570 ? s3854 : s3855; const SWord8 s3857 = (s3856 >> 1) | (s3856 << 7); const SWord8 s3858 = 128 | s3857; const SWord8 s3859 = 127 & s3857; const SWord8 s3860 = s3825 ? s3858 : s3859; const SWord8 s3861 = (s3860 >> 1) | (s3860 << 7); const SWord8 s3862 = 128 | s3861; const SWord8 s3863 = 127 & s3861; const SWord8 s3864 = s3847 ? s3862 : s3863; const SWord8 s3865 = s1 + s3860; const SBool s3866 = s3865 < s1; const SBool s3867 = s3865 < s3860; const SBool s3868 = s3866 || s3867; const SWord8 s3869 = (s3865 >> 1) | (s3865 << 7); const SWord8 s3870 = 128 | s3869; const SWord8 s3871 = 127 & s3869; const SWord8 s3872 = s3868 ? s3870 : s3871; const SWord8 s3873 = s3848 ? s3864 : s3872; const SWord8 s3874 = s1 + s3856; const SBool s3875 = s3874 < s1; const SBool s3876 = s3874 < s3856; const SBool s3877 = s3875 || s3876; const SWord8 s3878 = (s3874 >> 1) | (s3874 << 7); const SWord8 s3879 = 128 | s3878; const SWord8 s3880 = 127 & s3878; const SWord8 s3881 = s3877 ? s3879 : s3880; const SWord8 s3882 = (s3881 >> 1) | (s3881 << 7); const SWord8 s3883 = 128 | s3882; const SWord8 s3884 = 127 & s3882; const SWord8 s3885 = s3847 ? s3883 : s3884; const SWord8 s3886 = s1 + s3881; const SBool s3887 = s3886 < s1; const SBool s3888 = s3886 < s3881; const SBool s3889 = s3887 || s3888; const SWord8 s3890 = (s3886 >> 1) | (s3886 << 7); const SWord8 s3891 = 128 | s3890; const SWord8 s3892 = 127 & s3890; const SWord8 s3893 = s3889 ? s3891 : s3892; const SWord8 s3894 = s3848 ? s3885 : s3893; const SWord8 s3895 = s3826 ? s3873 : s3894; const SWord8 s3896 = s1 + s3852; const SBool s3897 = s3896 < s1; const SBool s3898 = s3896 < s3852; const SBool s3899 = s3897 || s3898; const SWord8 s3900 = (s3896 >> 1) | (s3896 << 7); const SWord8 s3901 = 128 | s3900; const SWord8 s3902 = 127 & s3900; const SWord8 s3903 = s3899 ? s3901 : s3902; const SWord8 s3904 = (s3903 >> 1) | (s3903 << 7); const SWord8 s3905 = 128 | s3904; const SWord8 s3906 = 127 & s3904; const SWord8 s3907 = s3825 ? s3905 : s3906; const SWord8 s3908 = (s3907 >> 1) | (s3907 << 7); const SWord8 s3909 = 128 | s3908; const SWord8 s3910 = 127 & s3908; const SWord8 s3911 = s3847 ? s3909 : s3910; const SWord8 s3912 = s1 + s3907; const SBool s3913 = s3912 < s1; const SBool s3914 = s3912 < s3907; const SBool s3915 = s3913 || s3914; const SWord8 s3916 = (s3912 >> 1) | (s3912 << 7); const SWord8 s3917 = 128 | s3916; const SWord8 s3918 = 127 & s3916; const SWord8 s3919 = s3915 ? s3917 : s3918; const SWord8 s3920 = s3848 ? s3911 : s3919; const SWord8 s3921 = s1 + s3903; const SBool s3922 = s3921 < s1; const SBool s3923 = s3921 < s3903; const SBool s3924 = s3922 || s3923; const SWord8 s3925 = (s3921 >> 1) | (s3921 << 7); const SWord8 s3926 = 128 | s3925; const SWord8 s3927 = 127 & s3925; const SWord8 s3928 = s3924 ? s3926 : s3927; const SWord8 s3929 = (s3928 >> 1) | (s3928 << 7); const SWord8 s3930 = 128 | s3929; const SWord8 s3931 = 127 & s3929; const SWord8 s3932 = s3847 ? s3930 : s3931; const SWord8 s3933 = s1 + s3928; const SBool s3934 = s3933 < s1; const SBool s3935 = s3933 < s3928; const SBool s3936 = s3934 || s3935; const SWord8 s3937 = (s3933 >> 1) | (s3933 << 7); const SWord8 s3938 = 128 | s3937; const SWord8 s3939 = 127 & s3937; const SWord8 s3940 = s3936 ? s3938 : s3939; const SWord8 s3941 = s3848 ? s3932 : s3940; const SWord8 s3942 = s3826 ? s3920 : s3941; const SWord8 s3943 = s3571 ? s3895 : s3942; const SWord8 s3944 = s1 + s3833; const SBool s3945 = (SBool) ((s3944 >> 0) & 1); const SBool s3946 = false != s3945; const SWord8 s3947 = s3946 ? s3837 : s3838; const SBool s3948 = (SBool) ((s3947 >> 0) & 1); const SBool s3949 = false != s3948; const SWord8 s3950 = s3949 ? s3843 : s3844; const SBool s3951 = (SBool) ((s3950 >> 0) & 1); const SBool s3952 = false != s3951; const SBool s3953 = false == s3952; const SBool s3954 = s3944 < s1; const SBool s3955 = s3944 < s3833; const SBool s3956 = s3954 || s3955; const SWord8 s3957 = (s3944 >> 1) | (s3944 << 7); const SWord8 s3958 = 128 | s3957; const SWord8 s3959 = 127 & s3957; const SWord8 s3960 = s3956 ? s3958 : s3959; const SWord8 s3961 = (s3960 >> 1) | (s3960 << 7); const SWord8 s3962 = 128 | s3961; const SWord8 s3963 = 127 & s3961; const SWord8 s3964 = s3570 ? s3962 : s3963; const SWord8 s3965 = (s3964 >> 1) | (s3964 << 7); const SWord8 s3966 = 128 | s3965; const SWord8 s3967 = 127 & s3965; const SWord8 s3968 = s3825 ? s3966 : s3967; const SWord8 s3969 = (s3968 >> 1) | (s3968 << 7); const SWord8 s3970 = 128 | s3969; const SWord8 s3971 = 127 & s3969; const SWord8 s3972 = s3952 ? s3970 : s3971; const SWord8 s3973 = s1 + s3968; const SBool s3974 = s3973 < s1; const SBool s3975 = s3973 < s3968; const SBool s3976 = s3974 || s3975; const SWord8 s3977 = (s3973 >> 1) | (s3973 << 7); const SWord8 s3978 = 128 | s3977; const SWord8 s3979 = 127 & s3977; const SWord8 s3980 = s3976 ? s3978 : s3979; const SWord8 s3981 = s3953 ? s3972 : s3980; const SWord8 s3982 = s1 + s3964; const SBool s3983 = s3982 < s1; const SBool s3984 = s3982 < s3964; const SBool s3985 = s3983 || s3984; const SWord8 s3986 = (s3982 >> 1) | (s3982 << 7); const SWord8 s3987 = 128 | s3986; const SWord8 s3988 = 127 & s3986; const SWord8 s3989 = s3985 ? s3987 : s3988; const SWord8 s3990 = (s3989 >> 1) | (s3989 << 7); const SWord8 s3991 = 128 | s3990; const SWord8 s3992 = 127 & s3990; const SWord8 s3993 = s3952 ? s3991 : s3992; const SWord8 s3994 = s1 + s3989; const SBool s3995 = s3994 < s1; const SBool s3996 = s3994 < s3989; const SBool s3997 = s3995 || s3996; const SWord8 s3998 = (s3994 >> 1) | (s3994 << 7); const SWord8 s3999 = 128 | s3998; const SWord8 s4000 = 127 & s3998; const SWord8 s4001 = s3997 ? s3999 : s4000; const SWord8 s4002 = s3953 ? s3993 : s4001; const SWord8 s4003 = s3826 ? s3981 : s4002; const SWord8 s4004 = s1 + s3960; const SBool s4005 = s4004 < s1; const SBool s4006 = s4004 < s3960; const SBool s4007 = s4005 || s4006; const SWord8 s4008 = (s4004 >> 1) | (s4004 << 7); const SWord8 s4009 = 128 | s4008; const SWord8 s4010 = 127 & s4008; const SWord8 s4011 = s4007 ? s4009 : s4010; const SWord8 s4012 = (s4011 >> 1) | (s4011 << 7); const SWord8 s4013 = 128 | s4012; const SWord8 s4014 = 127 & s4012; const SWord8 s4015 = s3825 ? s4013 : s4014; const SWord8 s4016 = (s4015 >> 1) | (s4015 << 7); const SWord8 s4017 = 128 | s4016; const SWord8 s4018 = 127 & s4016; const SWord8 s4019 = s3952 ? s4017 : s4018; const SWord8 s4020 = s1 + s4015; const SBool s4021 = s4020 < s1; const SBool s4022 = s4020 < s4015; const SBool s4023 = s4021 || s4022; const SWord8 s4024 = (s4020 >> 1) | (s4020 << 7); const SWord8 s4025 = 128 | s4024; const SWord8 s4026 = 127 & s4024; const SWord8 s4027 = s4023 ? s4025 : s4026; const SWord8 s4028 = s3953 ? s4019 : s4027; const SWord8 s4029 = s1 + s4011; const SBool s4030 = s4029 < s1; const SBool s4031 = s4029 < s4011; const SBool s4032 = s4030 || s4031; const SWord8 s4033 = (s4029 >> 1) | (s4029 << 7); const SWord8 s4034 = 128 | s4033; const SWord8 s4035 = 127 & s4033; const SWord8 s4036 = s4032 ? s4034 : s4035; const SWord8 s4037 = (s4036 >> 1) | (s4036 << 7); const SWord8 s4038 = 128 | s4037; const SWord8 s4039 = 127 & s4037; const SWord8 s4040 = s3952 ? s4038 : s4039; const SWord8 s4041 = s1 + s4036; const SBool s4042 = s4041 < s1; const SBool s4043 = s4041 < s4036; const SBool s4044 = s4042 || s4043; const SWord8 s4045 = (s4041 >> 1) | (s4041 << 7); const SWord8 s4046 = 128 | s4045; const SWord8 s4047 = 127 & s4045; const SWord8 s4048 = s4044 ? s4046 : s4047; const SWord8 s4049 = s3953 ? s4040 : s4048; const SWord8 s4050 = s3826 ? s4028 : s4049; const SWord8 s4051 = s3571 ? s4003 : s4050; const SWord8 s4052 = s3060 ? s3943 : s4051; const SWord8 s4053 = s2042 ? s3816 : s4052; const SWord8 s4054 = s16 ? s3561 : s4053; const SWord8 s4055 = s11 ? s3050 : s4054; const SWord8 s4056 = s5 ? s2032 : s4055; const SBool s4057 = (SBool) ((s105 >> 0) & 1); const SBool s4058 = false != s4057; const SBool s4059 = (SBool) ((s101 >> 0) & 1); const SBool s4060 = false != s4059; const SBool s4061 = (SBool) ((s97 >> 0) & 1); const SBool s4062 = false != s4061; const SWord8 s4063 = (s84 >> 1) | (s84 << 7); const SWord8 s4064 = 128 | s4063; const SWord8 s4065 = 127 & s4063; const SWord8 s4066 = s4062 ? s4064 : s4065; const SWord8 s4067 = (s4066 >> 1) | (s4066 << 7); const SWord8 s4068 = 128 | s4067; const SWord8 s4069 = 127 & s4067; const SWord8 s4070 = s4060 ? s4068 : s4069; const SWord8 s4071 = (s4070 >> 1) | (s4070 << 7); const SWord8 s4072 = 128 | s4071; const SWord8 s4073 = 127 & s4071; const SWord8 s4074 = s4058 ? s4072 : s4073; const SBool s4075 = (SBool) ((s110 >> 0) & 1); const SBool s4076 = false != s4075; const SWord8 s4077 = s4076 ? s4072 : s4073; const SWord8 s4078 = s93 ? s4074 : s4077; const SBool s4079 = (SBool) ((s126 >> 0) & 1); const SBool s4080 = false != s4079; const SBool s4081 = (SBool) ((s119 >> 0) & 1); const SBool s4082 = false != s4081; const SWord8 s4083 = s4082 ? s4068 : s4069; const SWord8 s4084 = (s4083 >> 1) | (s4083 << 7); const SWord8 s4085 = 128 | s4084; const SWord8 s4086 = 127 & s4084; const SWord8 s4087 = s4080 ? s4085 : s4086; const SBool s4088 = (SBool) ((s131 >> 0) & 1); const SBool s4089 = false != s4088; const SWord8 s4090 = s4089 ? s4085 : s4086; const SWord8 s4091 = s93 ? s4087 : s4090; const SWord8 s4092 = s74 ? s4078 : s4091; const SBool s4093 = (SBool) ((s152 >> 0) & 1); const SBool s4094 = false != s4093; const SBool s4095 = (SBool) ((s148 >> 0) & 1); const SBool s4096 = false != s4095; const SBool s4097 = (SBool) ((s141 >> 0) & 1); const SBool s4098 = false != s4097; const SWord8 s4099 = s4098 ? s4064 : s4065; const SWord8 s4100 = (s4099 >> 1) | (s4099 << 7); const SWord8 s4101 = 128 | s4100; const SWord8 s4102 = 127 & s4100; const SWord8 s4103 = s4096 ? s4101 : s4102; const SWord8 s4104 = (s4103 >> 1) | (s4103 << 7); const SWord8 s4105 = 128 | s4104; const SWord8 s4106 = 127 & s4104; const SWord8 s4107 = s4094 ? s4105 : s4106; const SBool s4108 = (SBool) ((s157 >> 0) & 1); const SBool s4109 = false != s4108; const SWord8 s4110 = s4109 ? s4105 : s4106; const SWord8 s4111 = s93 ? s4107 : s4110; const SBool s4112 = (SBool) ((s173 >> 0) & 1); const SBool s4113 = false != s4112; const SBool s4114 = (SBool) ((s166 >> 0) & 1); const SBool s4115 = false != s4114; const SWord8 s4116 = s4115 ? s4101 : s4102; const SWord8 s4117 = (s4116 >> 1) | (s4116 << 7); const SWord8 s4118 = 128 | s4117; const SWord8 s4119 = 127 & s4117; const SWord8 s4120 = s4113 ? s4118 : s4119; const SBool s4121 = (SBool) ((s178 >> 0) & 1); const SBool s4122 = false != s4121; const SWord8 s4123 = s4122 ? s4118 : s4119; const SWord8 s4124 = s93 ? s4120 : s4123; const SWord8 s4125 = s74 ? s4111 : s4124; const SWord8 s4126 = s55 ? s4092 : s4125; const SBool s4127 = (SBool) ((s213 >> 0) & 1); const SBool s4128 = false != s4127; const SBool s4129 = (SBool) ((s209 >> 0) & 1); const SBool s4130 = false != s4129; const SBool s4131 = (SBool) ((s205 >> 0) & 1); const SBool s4132 = false != s4131; const SWord8 s4133 = (s192 >> 1) | (s192 << 7); const SWord8 s4134 = 128 | s4133; const SWord8 s4135 = 127 & s4133; const SWord8 s4136 = s4132 ? s4134 : s4135; const SWord8 s4137 = (s4136 >> 1) | (s4136 << 7); const SWord8 s4138 = 128 | s4137; const SWord8 s4139 = 127 & s4137; const SWord8 s4140 = s4130 ? s4138 : s4139; const SWord8 s4141 = (s4140 >> 1) | (s4140 << 7); const SWord8 s4142 = 128 | s4141; const SWord8 s4143 = 127 & s4141; const SWord8 s4144 = s4128 ? s4142 : s4143; const SBool s4145 = (SBool) ((s218 >> 0) & 1); const SBool s4146 = false != s4145; const SWord8 s4147 = s4146 ? s4142 : s4143; const SWord8 s4148 = s198 ? s4144 : s4147; const SBool s4149 = (SBool) ((s234 >> 0) & 1); const SBool s4150 = false != s4149; const SBool s4151 = (SBool) ((s227 >> 0) & 1); const SBool s4152 = false != s4151; const SWord8 s4153 = s4152 ? s4138 : s4139; const SWord8 s4154 = (s4153 >> 1) | (s4153 << 7); const SWord8 s4155 = 128 | s4154; const SWord8 s4156 = 127 & s4154; const SWord8 s4157 = s4150 ? s4155 : s4156; const SBool s4158 = (SBool) ((s239 >> 0) & 1); const SBool s4159 = false != s4158; const SWord8 s4160 = s4159 ? s4155 : s4156; const SWord8 s4161 = s198 ? s4157 : s4160; const SWord8 s4162 = s74 ? s4148 : s4161; const SBool s4163 = (SBool) ((s260 >> 0) & 1); const SBool s4164 = false != s4163; const SBool s4165 = (SBool) ((s256 >> 0) & 1); const SBool s4166 = false != s4165; const SBool s4167 = (SBool) ((s249 >> 0) & 1); const SBool s4168 = false != s4167; const SWord8 s4169 = s4168 ? s4134 : s4135; const SWord8 s4170 = (s4169 >> 1) | (s4169 << 7); const SWord8 s4171 = 128 | s4170; const SWord8 s4172 = 127 & s4170; const SWord8 s4173 = s4166 ? s4171 : s4172; const SWord8 s4174 = (s4173 >> 1) | (s4173 << 7); const SWord8 s4175 = 128 | s4174; const SWord8 s4176 = 127 & s4174; const SWord8 s4177 = s4164 ? s4175 : s4176; const SBool s4178 = (SBool) ((s265 >> 0) & 1); const SBool s4179 = false != s4178; const SWord8 s4180 = s4179 ? s4175 : s4176; const SWord8 s4181 = s198 ? s4177 : s4180; const SBool s4182 = (SBool) ((s281 >> 0) & 1); const SBool s4183 = false != s4182; const SBool s4184 = (SBool) ((s274 >> 0) & 1); const SBool s4185 = false != s4184; const SWord8 s4186 = s4185 ? s4171 : s4172; const SWord8 s4187 = (s4186 >> 1) | (s4186 << 7); const SWord8 s4188 = 128 | s4187; const SWord8 s4189 = 127 & s4187; const SWord8 s4190 = s4183 ? s4188 : s4189; const SBool s4191 = (SBool) ((s286 >> 0) & 1); const SBool s4192 = false != s4191; const SWord8 s4193 = s4192 ? s4188 : s4189; const SWord8 s4194 = s198 ? s4190 : s4193; const SWord8 s4195 = s74 ? s4181 : s4194; const SWord8 s4196 = s55 ? s4162 : s4195; const SWord8 s4197 = s36 ? s4126 : s4196; const SBool s4198 = (SBool) ((s341 >> 0) & 1); const SBool s4199 = false != s4198; const SBool s4200 = (SBool) ((s337 >> 0) & 1); const SBool s4201 = false != s4200; const SBool s4202 = (SBool) ((s333 >> 0) & 1); const SBool s4203 = false != s4202; const SWord8 s4204 = (s320 >> 1) | (s320 << 7); const SWord8 s4205 = 128 | s4204; const SWord8 s4206 = 127 & s4204; const SWord8 s4207 = s4203 ? s4205 : s4206; const SWord8 s4208 = (s4207 >> 1) | (s4207 << 7); const SWord8 s4209 = 128 | s4208; const SWord8 s4210 = 127 & s4208; const SWord8 s4211 = s4201 ? s4209 : s4210; const SWord8 s4212 = (s4211 >> 1) | (s4211 << 7); const SWord8 s4213 = 128 | s4212; const SWord8 s4214 = 127 & s4212; const SWord8 s4215 = s4199 ? s4213 : s4214; const SBool s4216 = (SBool) ((s346 >> 0) & 1); const SBool s4217 = false != s4216; const SWord8 s4218 = s4217 ? s4213 : s4214; const SWord8 s4219 = s329 ? s4215 : s4218; const SBool s4220 = (SBool) ((s362 >> 0) & 1); const SBool s4221 = false != s4220; const SBool s4222 = (SBool) ((s355 >> 0) & 1); const SBool s4223 = false != s4222; const SWord8 s4224 = s4223 ? s4209 : s4210; const SWord8 s4225 = (s4224 >> 1) | (s4224 << 7); const SWord8 s4226 = 128 | s4225; const SWord8 s4227 = 127 & s4225; const SWord8 s4228 = s4221 ? s4226 : s4227; const SBool s4229 = (SBool) ((s367 >> 0) & 1); const SBool s4230 = false != s4229; const SWord8 s4231 = s4230 ? s4226 : s4227; const SWord8 s4232 = s329 ? s4228 : s4231; const SWord8 s4233 = s307 ? s4219 : s4232; const SBool s4234 = (SBool) ((s388 >> 0) & 1); const SBool s4235 = false != s4234; const SBool s4236 = (SBool) ((s384 >> 0) & 1); const SBool s4237 = false != s4236; const SBool s4238 = (SBool) ((s377 >> 0) & 1); const SBool s4239 = false != s4238; const SWord8 s4240 = s4239 ? s4205 : s4206; const SWord8 s4241 = (s4240 >> 1) | (s4240 << 7); const SWord8 s4242 = 128 | s4241; const SWord8 s4243 = 127 & s4241; const SWord8 s4244 = s4237 ? s4242 : s4243; const SWord8 s4245 = (s4244 >> 1) | (s4244 << 7); const SWord8 s4246 = 128 | s4245; const SWord8 s4247 = 127 & s4245; const SWord8 s4248 = s4235 ? s4246 : s4247; const SBool s4249 = (SBool) ((s393 >> 0) & 1); const SBool s4250 = false != s4249; const SWord8 s4251 = s4250 ? s4246 : s4247; const SWord8 s4252 = s329 ? s4248 : s4251; const SBool s4253 = (SBool) ((s409 >> 0) & 1); const SBool s4254 = false != s4253; const SBool s4255 = (SBool) ((s402 >> 0) & 1); const SBool s4256 = false != s4255; const SWord8 s4257 = s4256 ? s4242 : s4243; const SWord8 s4258 = (s4257 >> 1) | (s4257 << 7); const SWord8 s4259 = 128 | s4258; const SWord8 s4260 = 127 & s4258; const SWord8 s4261 = s4254 ? s4259 : s4260; const SBool s4262 = (SBool) ((s414 >> 0) & 1); const SBool s4263 = false != s4262; const SWord8 s4264 = s4263 ? s4259 : s4260; const SWord8 s4265 = s329 ? s4261 : s4264; const SWord8 s4266 = s307 ? s4252 : s4265; const SWord8 s4267 = s55 ? s4233 : s4266; const SBool s4268 = (SBool) ((s449 >> 0) & 1); const SBool s4269 = false != s4268; const SBool s4270 = (SBool) ((s445 >> 0) & 1); const SBool s4271 = false != s4270; const SBool s4272 = (SBool) ((s441 >> 0) & 1); const SBool s4273 = false != s4272; const SWord8 s4274 = (s428 >> 1) | (s428 << 7); const SWord8 s4275 = 128 | s4274; const SWord8 s4276 = 127 & s4274; const SWord8 s4277 = s4273 ? s4275 : s4276; const SWord8 s4278 = (s4277 >> 1) | (s4277 << 7); const SWord8 s4279 = 128 | s4278; const SWord8 s4280 = 127 & s4278; const SWord8 s4281 = s4271 ? s4279 : s4280; const SWord8 s4282 = (s4281 >> 1) | (s4281 << 7); const SWord8 s4283 = 128 | s4282; const SWord8 s4284 = 127 & s4282; const SWord8 s4285 = s4269 ? s4283 : s4284; const SBool s4286 = (SBool) ((s454 >> 0) & 1); const SBool s4287 = false != s4286; const SWord8 s4288 = s4287 ? s4283 : s4284; const SWord8 s4289 = s434 ? s4285 : s4288; const SBool s4290 = (SBool) ((s470 >> 0) & 1); const SBool s4291 = false != s4290; const SBool s4292 = (SBool) ((s463 >> 0) & 1); const SBool s4293 = false != s4292; const SWord8 s4294 = s4293 ? s4279 : s4280; const SWord8 s4295 = (s4294 >> 1) | (s4294 << 7); const SWord8 s4296 = 128 | s4295; const SWord8 s4297 = 127 & s4295; const SWord8 s4298 = s4291 ? s4296 : s4297; const SBool s4299 = (SBool) ((s475 >> 0) & 1); const SBool s4300 = false != s4299; const SWord8 s4301 = s4300 ? s4296 : s4297; const SWord8 s4302 = s434 ? s4298 : s4301; const SWord8 s4303 = s307 ? s4289 : s4302; const SBool s4304 = (SBool) ((s496 >> 0) & 1); const SBool s4305 = false != s4304; const SBool s4306 = (SBool) ((s492 >> 0) & 1); const SBool s4307 = false != s4306; const SBool s4308 = (SBool) ((s485 >> 0) & 1); const SBool s4309 = false != s4308; const SWord8 s4310 = s4309 ? s4275 : s4276; const SWord8 s4311 = (s4310 >> 1) | (s4310 << 7); const SWord8 s4312 = 128 | s4311; const SWord8 s4313 = 127 & s4311; const SWord8 s4314 = s4307 ? s4312 : s4313; const SWord8 s4315 = (s4314 >> 1) | (s4314 << 7); const SWord8 s4316 = 128 | s4315; const SWord8 s4317 = 127 & s4315; const SWord8 s4318 = s4305 ? s4316 : s4317; const SBool s4319 = (SBool) ((s501 >> 0) & 1); const SBool s4320 = false != s4319; const SWord8 s4321 = s4320 ? s4316 : s4317; const SWord8 s4322 = s434 ? s4318 : s4321; const SBool s4323 = (SBool) ((s517 >> 0) & 1); const SBool s4324 = false != s4323; const SBool s4325 = (SBool) ((s510 >> 0) & 1); const SBool s4326 = false != s4325; const SWord8 s4327 = s4326 ? s4312 : s4313; const SWord8 s4328 = (s4327 >> 1) | (s4327 << 7); const SWord8 s4329 = 128 | s4328; const SWord8 s4330 = 127 & s4328; const SWord8 s4331 = s4324 ? s4329 : s4330; const SBool s4332 = (SBool) ((s522 >> 0) & 1); const SBool s4333 = false != s4332; const SWord8 s4334 = s4333 ? s4329 : s4330; const SWord8 s4335 = s434 ? s4331 : s4334; const SWord8 s4336 = s307 ? s4322 : s4335; const SWord8 s4337 = s55 ? s4303 : s4336; const SWord8 s4338 = s36 ? s4267 : s4337; const SWord8 s4339 = s21 ? s4197 : s4338; const SBool s4340 = (SBool) ((s597 >> 0) & 1); const SBool s4341 = false != s4340; const SBool s4342 = (SBool) ((s593 >> 0) & 1); const SBool s4343 = false != s4342; const SBool s4344 = (SBool) ((s589 >> 0) & 1); const SBool s4345 = false != s4344; const SWord8 s4346 = (s576 >> 1) | (s576 << 7); const SWord8 s4347 = 128 | s4346; const SWord8 s4348 = 127 & s4346; const SWord8 s4349 = s4345 ? s4347 : s4348; const SWord8 s4350 = (s4349 >> 1) | (s4349 << 7); const SWord8 s4351 = 128 | s4350; const SWord8 s4352 = 127 & s4350; const SWord8 s4353 = s4343 ? s4351 : s4352; const SWord8 s4354 = (s4353 >> 1) | (s4353 << 7); const SWord8 s4355 = 128 | s4354; const SWord8 s4356 = 127 & s4354; const SWord8 s4357 = s4341 ? s4355 : s4356; const SBool s4358 = (SBool) ((s602 >> 0) & 1); const SBool s4359 = false != s4358; const SWord8 s4360 = s4359 ? s4355 : s4356; const SWord8 s4361 = s585 ? s4357 : s4360; const SBool s4362 = (SBool) ((s618 >> 0) & 1); const SBool s4363 = false != s4362; const SBool s4364 = (SBool) ((s611 >> 0) & 1); const SBool s4365 = false != s4364; const SWord8 s4366 = s4365 ? s4351 : s4352; const SWord8 s4367 = (s4366 >> 1) | (s4366 << 7); const SWord8 s4368 = 128 | s4367; const SWord8 s4369 = 127 & s4367; const SWord8 s4370 = s4363 ? s4368 : s4369; const SBool s4371 = (SBool) ((s623 >> 0) & 1); const SBool s4372 = false != s4371; const SWord8 s4373 = s4372 ? s4368 : s4369; const SWord8 s4374 = s585 ? s4370 : s4373; const SWord8 s4375 = s566 ? s4361 : s4374; const SBool s4376 = (SBool) ((s644 >> 0) & 1); const SBool s4377 = false != s4376; const SBool s4378 = (SBool) ((s640 >> 0) & 1); const SBool s4379 = false != s4378; const SBool s4380 = (SBool) ((s633 >> 0) & 1); const SBool s4381 = false != s4380; const SWord8 s4382 = s4381 ? s4347 : s4348; const SWord8 s4383 = (s4382 >> 1) | (s4382 << 7); const SWord8 s4384 = 128 | s4383; const SWord8 s4385 = 127 & s4383; const SWord8 s4386 = s4379 ? s4384 : s4385; const SWord8 s4387 = (s4386 >> 1) | (s4386 << 7); const SWord8 s4388 = 128 | s4387; const SWord8 s4389 = 127 & s4387; const SWord8 s4390 = s4377 ? s4388 : s4389; const SBool s4391 = (SBool) ((s649 >> 0) & 1); const SBool s4392 = false != s4391; const SWord8 s4393 = s4392 ? s4388 : s4389; const SWord8 s4394 = s585 ? s4390 : s4393; const SBool s4395 = (SBool) ((s665 >> 0) & 1); const SBool s4396 = false != s4395; const SBool s4397 = (SBool) ((s658 >> 0) & 1); const SBool s4398 = false != s4397; const SWord8 s4399 = s4398 ? s4384 : s4385; const SWord8 s4400 = (s4399 >> 1) | (s4399 << 7); const SWord8 s4401 = 128 | s4400; const SWord8 s4402 = 127 & s4400; const SWord8 s4403 = s4396 ? s4401 : s4402; const SBool s4404 = (SBool) ((s670 >> 0) & 1); const SBool s4405 = false != s4404; const SWord8 s4406 = s4405 ? s4401 : s4402; const SWord8 s4407 = s585 ? s4403 : s4406; const SWord8 s4408 = s566 ? s4394 : s4407; const SWord8 s4409 = s544 ? s4375 : s4408; const SBool s4410 = (SBool) ((s705 >> 0) & 1); const SBool s4411 = false != s4410; const SBool s4412 = (SBool) ((s701 >> 0) & 1); const SBool s4413 = false != s4412; const SBool s4414 = (SBool) ((s697 >> 0) & 1); const SBool s4415 = false != s4414; const SWord8 s4416 = (s684 >> 1) | (s684 << 7); const SWord8 s4417 = 128 | s4416; const SWord8 s4418 = 127 & s4416; const SWord8 s4419 = s4415 ? s4417 : s4418; const SWord8 s4420 = (s4419 >> 1) | (s4419 << 7); const SWord8 s4421 = 128 | s4420; const SWord8 s4422 = 127 & s4420; const SWord8 s4423 = s4413 ? s4421 : s4422; const SWord8 s4424 = (s4423 >> 1) | (s4423 << 7); const SWord8 s4425 = 128 | s4424; const SWord8 s4426 = 127 & s4424; const SWord8 s4427 = s4411 ? s4425 : s4426; const SBool s4428 = (SBool) ((s710 >> 0) & 1); const SBool s4429 = false != s4428; const SWord8 s4430 = s4429 ? s4425 : s4426; const SWord8 s4431 = s690 ? s4427 : s4430; const SBool s4432 = (SBool) ((s726 >> 0) & 1); const SBool s4433 = false != s4432; const SBool s4434 = (SBool) ((s719 >> 0) & 1); const SBool s4435 = false != s4434; const SWord8 s4436 = s4435 ? s4421 : s4422; const SWord8 s4437 = (s4436 >> 1) | (s4436 << 7); const SWord8 s4438 = 128 | s4437; const SWord8 s4439 = 127 & s4437; const SWord8 s4440 = s4433 ? s4438 : s4439; const SBool s4441 = (SBool) ((s731 >> 0) & 1); const SBool s4442 = false != s4441; const SWord8 s4443 = s4442 ? s4438 : s4439; const SWord8 s4444 = s690 ? s4440 : s4443; const SWord8 s4445 = s566 ? s4431 : s4444; const SBool s4446 = (SBool) ((s752 >> 0) & 1); const SBool s4447 = false != s4446; const SBool s4448 = (SBool) ((s748 >> 0) & 1); const SBool s4449 = false != s4448; const SBool s4450 = (SBool) ((s741 >> 0) & 1); const SBool s4451 = false != s4450; const SWord8 s4452 = s4451 ? s4417 : s4418; const SWord8 s4453 = (s4452 >> 1) | (s4452 << 7); const SWord8 s4454 = 128 | s4453; const SWord8 s4455 = 127 & s4453; const SWord8 s4456 = s4449 ? s4454 : s4455; const SWord8 s4457 = (s4456 >> 1) | (s4456 << 7); const SWord8 s4458 = 128 | s4457; const SWord8 s4459 = 127 & s4457; const SWord8 s4460 = s4447 ? s4458 : s4459; const SBool s4461 = (SBool) ((s757 >> 0) & 1); const SBool s4462 = false != s4461; const SWord8 s4463 = s4462 ? s4458 : s4459; const SWord8 s4464 = s690 ? s4460 : s4463; const SBool s4465 = (SBool) ((s773 >> 0) & 1); const SBool s4466 = false != s4465; const SBool s4467 = (SBool) ((s766 >> 0) & 1); const SBool s4468 = false != s4467; const SWord8 s4469 = s4468 ? s4454 : s4455; const SWord8 s4470 = (s4469 >> 1) | (s4469 << 7); const SWord8 s4471 = 128 | s4470; const SWord8 s4472 = 127 & s4470; const SWord8 s4473 = s4466 ? s4471 : s4472; const SBool s4474 = (SBool) ((s778 >> 0) & 1); const SBool s4475 = false != s4474; const SWord8 s4476 = s4475 ? s4471 : s4472; const SWord8 s4477 = s690 ? s4473 : s4476; const SWord8 s4478 = s566 ? s4464 : s4477; const SWord8 s4479 = s544 ? s4445 : s4478; const SWord8 s4480 = s36 ? s4409 : s4479; const SBool s4481 = (SBool) ((s833 >> 0) & 1); const SBool s4482 = false != s4481; const SBool s4483 = (SBool) ((s829 >> 0) & 1); const SBool s4484 = false != s4483; const SBool s4485 = (SBool) ((s825 >> 0) & 1); const SBool s4486 = false != s4485; const SWord8 s4487 = (s812 >> 1) | (s812 << 7); const SWord8 s4488 = 128 | s4487; const SWord8 s4489 = 127 & s4487; const SWord8 s4490 = s4486 ? s4488 : s4489; const SWord8 s4491 = (s4490 >> 1) | (s4490 << 7); const SWord8 s4492 = 128 | s4491; const SWord8 s4493 = 127 & s4491; const SWord8 s4494 = s4484 ? s4492 : s4493; const SWord8 s4495 = (s4494 >> 1) | (s4494 << 7); const SWord8 s4496 = 128 | s4495; const SWord8 s4497 = 127 & s4495; const SWord8 s4498 = s4482 ? s4496 : s4497; const SBool s4499 = (SBool) ((s838 >> 0) & 1); const SBool s4500 = false != s4499; const SWord8 s4501 = s4500 ? s4496 : s4497; const SWord8 s4502 = s821 ? s4498 : s4501; const SBool s4503 = (SBool) ((s854 >> 0) & 1); const SBool s4504 = false != s4503; const SBool s4505 = (SBool) ((s847 >> 0) & 1); const SBool s4506 = false != s4505; const SWord8 s4507 = s4506 ? s4492 : s4493; const SWord8 s4508 = (s4507 >> 1) | (s4507 << 7); const SWord8 s4509 = 128 | s4508; const SWord8 s4510 = 127 & s4508; const SWord8 s4511 = s4504 ? s4509 : s4510; const SBool s4512 = (SBool) ((s859 >> 0) & 1); const SBool s4513 = false != s4512; const SWord8 s4514 = s4513 ? s4509 : s4510; const SWord8 s4515 = s821 ? s4511 : s4514; const SWord8 s4516 = s799 ? s4502 : s4515; const SBool s4517 = (SBool) ((s880 >> 0) & 1); const SBool s4518 = false != s4517; const SBool s4519 = (SBool) ((s876 >> 0) & 1); const SBool s4520 = false != s4519; const SBool s4521 = (SBool) ((s869 >> 0) & 1); const SBool s4522 = false != s4521; const SWord8 s4523 = s4522 ? s4488 : s4489; const SWord8 s4524 = (s4523 >> 1) | (s4523 << 7); const SWord8 s4525 = 128 | s4524; const SWord8 s4526 = 127 & s4524; const SWord8 s4527 = s4520 ? s4525 : s4526; const SWord8 s4528 = (s4527 >> 1) | (s4527 << 7); const SWord8 s4529 = 128 | s4528; const SWord8 s4530 = 127 & s4528; const SWord8 s4531 = s4518 ? s4529 : s4530; const SBool s4532 = (SBool) ((s885 >> 0) & 1); const SBool s4533 = false != s4532; const SWord8 s4534 = s4533 ? s4529 : s4530; const SWord8 s4535 = s821 ? s4531 : s4534; const SBool s4536 = (SBool) ((s901 >> 0) & 1); const SBool s4537 = false != s4536; const SBool s4538 = (SBool) ((s894 >> 0) & 1); const SBool s4539 = false != s4538; const SWord8 s4540 = s4539 ? s4525 : s4526; const SWord8 s4541 = (s4540 >> 1) | (s4540 << 7); const SWord8 s4542 = 128 | s4541; const SWord8 s4543 = 127 & s4541; const SWord8 s4544 = s4537 ? s4542 : s4543; const SBool s4545 = (SBool) ((s906 >> 0) & 1); const SBool s4546 = false != s4545; const SWord8 s4547 = s4546 ? s4542 : s4543; const SWord8 s4548 = s821 ? s4544 : s4547; const SWord8 s4549 = s799 ? s4535 : s4548; const SWord8 s4550 = s544 ? s4516 : s4549; const SBool s4551 = (SBool) ((s941 >> 0) & 1); const SBool s4552 = false != s4551; const SBool s4553 = (SBool) ((s937 >> 0) & 1); const SBool s4554 = false != s4553; const SBool s4555 = (SBool) ((s933 >> 0) & 1); const SBool s4556 = false != s4555; const SWord8 s4557 = (s920 >> 1) | (s920 << 7); const SWord8 s4558 = 128 | s4557; const SWord8 s4559 = 127 & s4557; const SWord8 s4560 = s4556 ? s4558 : s4559; const SWord8 s4561 = (s4560 >> 1) | (s4560 << 7); const SWord8 s4562 = 128 | s4561; const SWord8 s4563 = 127 & s4561; const SWord8 s4564 = s4554 ? s4562 : s4563; const SWord8 s4565 = (s4564 >> 1) | (s4564 << 7); const SWord8 s4566 = 128 | s4565; const SWord8 s4567 = 127 & s4565; const SWord8 s4568 = s4552 ? s4566 : s4567; const SBool s4569 = (SBool) ((s946 >> 0) & 1); const SBool s4570 = false != s4569; const SWord8 s4571 = s4570 ? s4566 : s4567; const SWord8 s4572 = s926 ? s4568 : s4571; const SBool s4573 = (SBool) ((s962 >> 0) & 1); const SBool s4574 = false != s4573; const SBool s4575 = (SBool) ((s955 >> 0) & 1); const SBool s4576 = false != s4575; const SWord8 s4577 = s4576 ? s4562 : s4563; const SWord8 s4578 = (s4577 >> 1) | (s4577 << 7); const SWord8 s4579 = 128 | s4578; const SWord8 s4580 = 127 & s4578; const SWord8 s4581 = s4574 ? s4579 : s4580; const SBool s4582 = (SBool) ((s967 >> 0) & 1); const SBool s4583 = false != s4582; const SWord8 s4584 = s4583 ? s4579 : s4580; const SWord8 s4585 = s926 ? s4581 : s4584; const SWord8 s4586 = s799 ? s4572 : s4585; const SBool s4587 = (SBool) ((s988 >> 0) & 1); const SBool s4588 = false != s4587; const SBool s4589 = (SBool) ((s984 >> 0) & 1); const SBool s4590 = false != s4589; const SBool s4591 = (SBool) ((s977 >> 0) & 1); const SBool s4592 = false != s4591; const SWord8 s4593 = s4592 ? s4558 : s4559; const SWord8 s4594 = (s4593 >> 1) | (s4593 << 7); const SWord8 s4595 = 128 | s4594; const SWord8 s4596 = 127 & s4594; const SWord8 s4597 = s4590 ? s4595 : s4596; const SWord8 s4598 = (s4597 >> 1) | (s4597 << 7); const SWord8 s4599 = 128 | s4598; const SWord8 s4600 = 127 & s4598; const SWord8 s4601 = s4588 ? s4599 : s4600; const SBool s4602 = (SBool) ((s993 >> 0) & 1); const SBool s4603 = false != s4602; const SWord8 s4604 = s4603 ? s4599 : s4600; const SWord8 s4605 = s926 ? s4601 : s4604; const SBool s4606 = (SBool) ((s1009 >> 0) & 1); const SBool s4607 = false != s4606; const SBool s4608 = (SBool) ((s1002 >> 0) & 1); const SBool s4609 = false != s4608; const SWord8 s4610 = s4609 ? s4595 : s4596; const SWord8 s4611 = (s4610 >> 1) | (s4610 << 7); const SWord8 s4612 = 128 | s4611; const SWord8 s4613 = 127 & s4611; const SWord8 s4614 = s4607 ? s4612 : s4613; const SBool s4615 = (SBool) ((s1014 >> 0) & 1); const SBool s4616 = false != s4615; const SWord8 s4617 = s4616 ? s4612 : s4613; const SWord8 s4618 = s926 ? s4614 : s4617; const SWord8 s4619 = s799 ? s4605 : s4618; const SWord8 s4620 = s544 ? s4586 : s4619; const SWord8 s4621 = s36 ? s4550 : s4620; const SWord8 s4622 = s21 ? s4480 : s4621; const SWord8 s4623 = s16 ? s4339 : s4622; const SBool s4624 = (SBool) ((s1109 >> 0) & 1); const SBool s4625 = false != s4624; const SBool s4626 = (SBool) ((s1105 >> 0) & 1); const SBool s4627 = false != s4626; const SBool s4628 = (SBool) ((s1101 >> 0) & 1); const SBool s4629 = false != s4628; const SWord8 s4630 = (s1088 >> 1) | (s1088 << 7); const SWord8 s4631 = 128 | s4630; const SWord8 s4632 = 127 & s4630; const SWord8 s4633 = s4629 ? s4631 : s4632; const SWord8 s4634 = (s4633 >> 1) | (s4633 << 7); const SWord8 s4635 = 128 | s4634; const SWord8 s4636 = 127 & s4634; const SWord8 s4637 = s4627 ? s4635 : s4636; const SWord8 s4638 = (s4637 >> 1) | (s4637 << 7); const SWord8 s4639 = 128 | s4638; const SWord8 s4640 = 127 & s4638; const SWord8 s4641 = s4625 ? s4639 : s4640; const SBool s4642 = (SBool) ((s1114 >> 0) & 1); const SBool s4643 = false != s4642; const SWord8 s4644 = s4643 ? s4639 : s4640; const SWord8 s4645 = s1097 ? s4641 : s4644; const SBool s4646 = (SBool) ((s1130 >> 0) & 1); const SBool s4647 = false != s4646; const SBool s4648 = (SBool) ((s1123 >> 0) & 1); const SBool s4649 = false != s4648; const SWord8 s4650 = s4649 ? s4635 : s4636; const SWord8 s4651 = (s4650 >> 1) | (s4650 << 7); const SWord8 s4652 = 128 | s4651; const SWord8 s4653 = 127 & s4651; const SWord8 s4654 = s4647 ? s4652 : s4653; const SBool s4655 = (SBool) ((s1135 >> 0) & 1); const SBool s4656 = false != s4655; const SWord8 s4657 = s4656 ? s4652 : s4653; const SWord8 s4658 = s1097 ? s4654 : s4657; const SWord8 s4659 = s1078 ? s4645 : s4658; const SBool s4660 = (SBool) ((s1156 >> 0) & 1); const SBool s4661 = false != s4660; const SBool s4662 = (SBool) ((s1152 >> 0) & 1); const SBool s4663 = false != s4662; const SBool s4664 = (SBool) ((s1145 >> 0) & 1); const SBool s4665 = false != s4664; const SWord8 s4666 = s4665 ? s4631 : s4632; const SWord8 s4667 = (s4666 >> 1) | (s4666 << 7); const SWord8 s4668 = 128 | s4667; const SWord8 s4669 = 127 & s4667; const SWord8 s4670 = s4663 ? s4668 : s4669; const SWord8 s4671 = (s4670 >> 1) | (s4670 << 7); const SWord8 s4672 = 128 | s4671; const SWord8 s4673 = 127 & s4671; const SWord8 s4674 = s4661 ? s4672 : s4673; const SBool s4675 = (SBool) ((s1161 >> 0) & 1); const SBool s4676 = false != s4675; const SWord8 s4677 = s4676 ? s4672 : s4673; const SWord8 s4678 = s1097 ? s4674 : s4677; const SBool s4679 = (SBool) ((s1177 >> 0) & 1); const SBool s4680 = false != s4679; const SBool s4681 = (SBool) ((s1170 >> 0) & 1); const SBool s4682 = false != s4681; const SWord8 s4683 = s4682 ? s4668 : s4669; const SWord8 s4684 = (s4683 >> 1) | (s4683 << 7); const SWord8 s4685 = 128 | s4684; const SWord8 s4686 = 127 & s4684; const SWord8 s4687 = s4680 ? s4685 : s4686; const SBool s4688 = (SBool) ((s1182 >> 0) & 1); const SBool s4689 = false != s4688; const SWord8 s4690 = s4689 ? s4685 : s4686; const SWord8 s4691 = s1097 ? s4687 : s4690; const SWord8 s4692 = s1078 ? s4678 : s4691; const SWord8 s4693 = s1059 ? s4659 : s4692; const SBool s4694 = (SBool) ((s1217 >> 0) & 1); const SBool s4695 = false != s4694; const SBool s4696 = (SBool) ((s1213 >> 0) & 1); const SBool s4697 = false != s4696; const SBool s4698 = (SBool) ((s1209 >> 0) & 1); const SBool s4699 = false != s4698; const SWord8 s4700 = (s1196 >> 1) | (s1196 << 7); const SWord8 s4701 = 128 | s4700; const SWord8 s4702 = 127 & s4700; const SWord8 s4703 = s4699 ? s4701 : s4702; const SWord8 s4704 = (s4703 >> 1) | (s4703 << 7); const SWord8 s4705 = 128 | s4704; const SWord8 s4706 = 127 & s4704; const SWord8 s4707 = s4697 ? s4705 : s4706; const SWord8 s4708 = (s4707 >> 1) | (s4707 << 7); const SWord8 s4709 = 128 | s4708; const SWord8 s4710 = 127 & s4708; const SWord8 s4711 = s4695 ? s4709 : s4710; const SBool s4712 = (SBool) ((s1222 >> 0) & 1); const SBool s4713 = false != s4712; const SWord8 s4714 = s4713 ? s4709 : s4710; const SWord8 s4715 = s1202 ? s4711 : s4714; const SBool s4716 = (SBool) ((s1238 >> 0) & 1); const SBool s4717 = false != s4716; const SBool s4718 = (SBool) ((s1231 >> 0) & 1); const SBool s4719 = false != s4718; const SWord8 s4720 = s4719 ? s4705 : s4706; const SWord8 s4721 = (s4720 >> 1) | (s4720 << 7); const SWord8 s4722 = 128 | s4721; const SWord8 s4723 = 127 & s4721; const SWord8 s4724 = s4717 ? s4722 : s4723; const SBool s4725 = (SBool) ((s1243 >> 0) & 1); const SBool s4726 = false != s4725; const SWord8 s4727 = s4726 ? s4722 : s4723; const SWord8 s4728 = s1202 ? s4724 : s4727; const SWord8 s4729 = s1078 ? s4715 : s4728; const SBool s4730 = (SBool) ((s1264 >> 0) & 1); const SBool s4731 = false != s4730; const SBool s4732 = (SBool) ((s1260 >> 0) & 1); const SBool s4733 = false != s4732; const SBool s4734 = (SBool) ((s1253 >> 0) & 1); const SBool s4735 = false != s4734; const SWord8 s4736 = s4735 ? s4701 : s4702; const SWord8 s4737 = (s4736 >> 1) | (s4736 << 7); const SWord8 s4738 = 128 | s4737; const SWord8 s4739 = 127 & s4737; const SWord8 s4740 = s4733 ? s4738 : s4739; const SWord8 s4741 = (s4740 >> 1) | (s4740 << 7); const SWord8 s4742 = 128 | s4741; const SWord8 s4743 = 127 & s4741; const SWord8 s4744 = s4731 ? s4742 : s4743; const SBool s4745 = (SBool) ((s1269 >> 0) & 1); const SBool s4746 = false != s4745; const SWord8 s4747 = s4746 ? s4742 : s4743; const SWord8 s4748 = s1202 ? s4744 : s4747; const SBool s4749 = (SBool) ((s1285 >> 0) & 1); const SBool s4750 = false != s4749; const SBool s4751 = (SBool) ((s1278 >> 0) & 1); const SBool s4752 = false != s4751; const SWord8 s4753 = s4752 ? s4738 : s4739; const SWord8 s4754 = (s4753 >> 1) | (s4753 << 7); const SWord8 s4755 = 128 | s4754; const SWord8 s4756 = 127 & s4754; const SWord8 s4757 = s4750 ? s4755 : s4756; const SBool s4758 = (SBool) ((s1290 >> 0) & 1); const SBool s4759 = false != s4758; const SWord8 s4760 = s4759 ? s4755 : s4756; const SWord8 s4761 = s1202 ? s4757 : s4760; const SWord8 s4762 = s1078 ? s4748 : s4761; const SWord8 s4763 = s1059 ? s4729 : s4762; const SWord8 s4764 = s1037 ? s4693 : s4763; const SBool s4765 = (SBool) ((s1345 >> 0) & 1); const SBool s4766 = false != s4765; const SBool s4767 = (SBool) ((s1341 >> 0) & 1); const SBool s4768 = false != s4767; const SBool s4769 = (SBool) ((s1337 >> 0) & 1); const SBool s4770 = false != s4769; const SWord8 s4771 = (s1324 >> 1) | (s1324 << 7); const SWord8 s4772 = 128 | s4771; const SWord8 s4773 = 127 & s4771; const SWord8 s4774 = s4770 ? s4772 : s4773; const SWord8 s4775 = (s4774 >> 1) | (s4774 << 7); const SWord8 s4776 = 128 | s4775; const SWord8 s4777 = 127 & s4775; const SWord8 s4778 = s4768 ? s4776 : s4777; const SWord8 s4779 = (s4778 >> 1) | (s4778 << 7); const SWord8 s4780 = 128 | s4779; const SWord8 s4781 = 127 & s4779; const SWord8 s4782 = s4766 ? s4780 : s4781; const SBool s4783 = (SBool) ((s1350 >> 0) & 1); const SBool s4784 = false != s4783; const SWord8 s4785 = s4784 ? s4780 : s4781; const SWord8 s4786 = s1333 ? s4782 : s4785; const SBool s4787 = (SBool) ((s1366 >> 0) & 1); const SBool s4788 = false != s4787; const SBool s4789 = (SBool) ((s1359 >> 0) & 1); const SBool s4790 = false != s4789; const SWord8 s4791 = s4790 ? s4776 : s4777; const SWord8 s4792 = (s4791 >> 1) | (s4791 << 7); const SWord8 s4793 = 128 | s4792; const SWord8 s4794 = 127 & s4792; const SWord8 s4795 = s4788 ? s4793 : s4794; const SBool s4796 = (SBool) ((s1371 >> 0) & 1); const SBool s4797 = false != s4796; const SWord8 s4798 = s4797 ? s4793 : s4794; const SWord8 s4799 = s1333 ? s4795 : s4798; const SWord8 s4800 = s1311 ? s4786 : s4799; const SBool s4801 = (SBool) ((s1392 >> 0) & 1); const SBool s4802 = false != s4801; const SBool s4803 = (SBool) ((s1388 >> 0) & 1); const SBool s4804 = false != s4803; const SBool s4805 = (SBool) ((s1381 >> 0) & 1); const SBool s4806 = false != s4805; const SWord8 s4807 = s4806 ? s4772 : s4773; const SWord8 s4808 = (s4807 >> 1) | (s4807 << 7); const SWord8 s4809 = 128 | s4808; const SWord8 s4810 = 127 & s4808; const SWord8 s4811 = s4804 ? s4809 : s4810; const SWord8 s4812 = (s4811 >> 1) | (s4811 << 7); const SWord8 s4813 = 128 | s4812; const SWord8 s4814 = 127 & s4812; const SWord8 s4815 = s4802 ? s4813 : s4814; const SBool s4816 = (SBool) ((s1397 >> 0) & 1); const SBool s4817 = false != s4816; const SWord8 s4818 = s4817 ? s4813 : s4814; const SWord8 s4819 = s1333 ? s4815 : s4818; const SBool s4820 = (SBool) ((s1413 >> 0) & 1); const SBool s4821 = false != s4820; const SBool s4822 = (SBool) ((s1406 >> 0) & 1); const SBool s4823 = false != s4822; const SWord8 s4824 = s4823 ? s4809 : s4810; const SWord8 s4825 = (s4824 >> 1) | (s4824 << 7); const SWord8 s4826 = 128 | s4825; const SWord8 s4827 = 127 & s4825; const SWord8 s4828 = s4821 ? s4826 : s4827; const SBool s4829 = (SBool) ((s1418 >> 0) & 1); const SBool s4830 = false != s4829; const SWord8 s4831 = s4830 ? s4826 : s4827; const SWord8 s4832 = s1333 ? s4828 : s4831; const SWord8 s4833 = s1311 ? s4819 : s4832; const SWord8 s4834 = s1059 ? s4800 : s4833; const SBool s4835 = (SBool) ((s1453 >> 0) & 1); const SBool s4836 = false != s4835; const SBool s4837 = (SBool) ((s1449 >> 0) & 1); const SBool s4838 = false != s4837; const SBool s4839 = (SBool) ((s1445 >> 0) & 1); const SBool s4840 = false != s4839; const SWord8 s4841 = (s1432 >> 1) | (s1432 << 7); const SWord8 s4842 = 128 | s4841; const SWord8 s4843 = 127 & s4841; const SWord8 s4844 = s4840 ? s4842 : s4843; const SWord8 s4845 = (s4844 >> 1) | (s4844 << 7); const SWord8 s4846 = 128 | s4845; const SWord8 s4847 = 127 & s4845; const SWord8 s4848 = s4838 ? s4846 : s4847; const SWord8 s4849 = (s4848 >> 1) | (s4848 << 7); const SWord8 s4850 = 128 | s4849; const SWord8 s4851 = 127 & s4849; const SWord8 s4852 = s4836 ? s4850 : s4851; const SBool s4853 = (SBool) ((s1458 >> 0) & 1); const SBool s4854 = false != s4853; const SWord8 s4855 = s4854 ? s4850 : s4851; const SWord8 s4856 = s1438 ? s4852 : s4855; const SBool s4857 = (SBool) ((s1474 >> 0) & 1); const SBool s4858 = false != s4857; const SBool s4859 = (SBool) ((s1467 >> 0) & 1); const SBool s4860 = false != s4859; const SWord8 s4861 = s4860 ? s4846 : s4847; const SWord8 s4862 = (s4861 >> 1) | (s4861 << 7); const SWord8 s4863 = 128 | s4862; const SWord8 s4864 = 127 & s4862; const SWord8 s4865 = s4858 ? s4863 : s4864; const SBool s4866 = (SBool) ((s1479 >> 0) & 1); const SBool s4867 = false != s4866; const SWord8 s4868 = s4867 ? s4863 : s4864; const SWord8 s4869 = s1438 ? s4865 : s4868; const SWord8 s4870 = s1311 ? s4856 : s4869; const SBool s4871 = (SBool) ((s1500 >> 0) & 1); const SBool s4872 = false != s4871; const SBool s4873 = (SBool) ((s1496 >> 0) & 1); const SBool s4874 = false != s4873; const SBool s4875 = (SBool) ((s1489 >> 0) & 1); const SBool s4876 = false != s4875; const SWord8 s4877 = s4876 ? s4842 : s4843; const SWord8 s4878 = (s4877 >> 1) | (s4877 << 7); const SWord8 s4879 = 128 | s4878; const SWord8 s4880 = 127 & s4878; const SWord8 s4881 = s4874 ? s4879 : s4880; const SWord8 s4882 = (s4881 >> 1) | (s4881 << 7); const SWord8 s4883 = 128 | s4882; const SWord8 s4884 = 127 & s4882; const SWord8 s4885 = s4872 ? s4883 : s4884; const SBool s4886 = (SBool) ((s1505 >> 0) & 1); const SBool s4887 = false != s4886; const SWord8 s4888 = s4887 ? s4883 : s4884; const SWord8 s4889 = s1438 ? s4885 : s4888; const SBool s4890 = (SBool) ((s1521 >> 0) & 1); const SBool s4891 = false != s4890; const SBool s4892 = (SBool) ((s1514 >> 0) & 1); const SBool s4893 = false != s4892; const SWord8 s4894 = s4893 ? s4879 : s4880; const SWord8 s4895 = (s4894 >> 1) | (s4894 << 7); const SWord8 s4896 = 128 | s4895; const SWord8 s4897 = 127 & s4895; const SWord8 s4898 = s4891 ? s4896 : s4897; const SBool s4899 = (SBool) ((s1526 >> 0) & 1); const SBool s4900 = false != s4899; const SWord8 s4901 = s4900 ? s4896 : s4897; const SWord8 s4902 = s1438 ? s4898 : s4901; const SWord8 s4903 = s1311 ? s4889 : s4902; const SWord8 s4904 = s1059 ? s4870 : s4903; const SWord8 s4905 = s1037 ? s4834 : s4904; const SWord8 s4906 = s21 ? s4764 : s4905; const SBool s4907 = (SBool) ((s1601 >> 0) & 1); const SBool s4908 = false != s4907; const SBool s4909 = (SBool) ((s1597 >> 0) & 1); const SBool s4910 = false != s4909; const SBool s4911 = (SBool) ((s1593 >> 0) & 1); const SBool s4912 = false != s4911; const SWord8 s4913 = (s1580 >> 1) | (s1580 << 7); const SWord8 s4914 = 128 | s4913; const SWord8 s4915 = 127 & s4913; const SWord8 s4916 = s4912 ? s4914 : s4915; const SWord8 s4917 = (s4916 >> 1) | (s4916 << 7); const SWord8 s4918 = 128 | s4917; const SWord8 s4919 = 127 & s4917; const SWord8 s4920 = s4910 ? s4918 : s4919; const SWord8 s4921 = (s4920 >> 1) | (s4920 << 7); const SWord8 s4922 = 128 | s4921; const SWord8 s4923 = 127 & s4921; const SWord8 s4924 = s4908 ? s4922 : s4923; const SBool s4925 = (SBool) ((s1606 >> 0) & 1); const SBool s4926 = false != s4925; const SWord8 s4927 = s4926 ? s4922 : s4923; const SWord8 s4928 = s1589 ? s4924 : s4927; const SBool s4929 = (SBool) ((s1622 >> 0) & 1); const SBool s4930 = false != s4929; const SBool s4931 = (SBool) ((s1615 >> 0) & 1); const SBool s4932 = false != s4931; const SWord8 s4933 = s4932 ? s4918 : s4919; const SWord8 s4934 = (s4933 >> 1) | (s4933 << 7); const SWord8 s4935 = 128 | s4934; const SWord8 s4936 = 127 & s4934; const SWord8 s4937 = s4930 ? s4935 : s4936; const SBool s4938 = (SBool) ((s1627 >> 0) & 1); const SBool s4939 = false != s4938; const SWord8 s4940 = s4939 ? s4935 : s4936; const SWord8 s4941 = s1589 ? s4937 : s4940; const SWord8 s4942 = s1570 ? s4928 : s4941; const SBool s4943 = (SBool) ((s1648 >> 0) & 1); const SBool s4944 = false != s4943; const SBool s4945 = (SBool) ((s1644 >> 0) & 1); const SBool s4946 = false != s4945; const SBool s4947 = (SBool) ((s1637 >> 0) & 1); const SBool s4948 = false != s4947; const SWord8 s4949 = s4948 ? s4914 : s4915; const SWord8 s4950 = (s4949 >> 1) | (s4949 << 7); const SWord8 s4951 = 128 | s4950; const SWord8 s4952 = 127 & s4950; const SWord8 s4953 = s4946 ? s4951 : s4952; const SWord8 s4954 = (s4953 >> 1) | (s4953 << 7); const SWord8 s4955 = 128 | s4954; const SWord8 s4956 = 127 & s4954; const SWord8 s4957 = s4944 ? s4955 : s4956; const SBool s4958 = (SBool) ((s1653 >> 0) & 1); const SBool s4959 = false != s4958; const SWord8 s4960 = s4959 ? s4955 : s4956; const SWord8 s4961 = s1589 ? s4957 : s4960; const SBool s4962 = (SBool) ((s1669 >> 0) & 1); const SBool s4963 = false != s4962; const SBool s4964 = (SBool) ((s1662 >> 0) & 1); const SBool s4965 = false != s4964; const SWord8 s4966 = s4965 ? s4951 : s4952; const SWord8 s4967 = (s4966 >> 1) | (s4966 << 7); const SWord8 s4968 = 128 | s4967; const SWord8 s4969 = 127 & s4967; const SWord8 s4970 = s4963 ? s4968 : s4969; const SBool s4971 = (SBool) ((s1674 >> 0) & 1); const SBool s4972 = false != s4971; const SWord8 s4973 = s4972 ? s4968 : s4969; const SWord8 s4974 = s1589 ? s4970 : s4973; const SWord8 s4975 = s1570 ? s4961 : s4974; const SWord8 s4976 = s1548 ? s4942 : s4975; const SBool s4977 = (SBool) ((s1709 >> 0) & 1); const SBool s4978 = false != s4977; const SBool s4979 = (SBool) ((s1705 >> 0) & 1); const SBool s4980 = false != s4979; const SBool s4981 = (SBool) ((s1701 >> 0) & 1); const SBool s4982 = false != s4981; const SWord8 s4983 = (s1688 >> 1) | (s1688 << 7); const SWord8 s4984 = 128 | s4983; const SWord8 s4985 = 127 & s4983; const SWord8 s4986 = s4982 ? s4984 : s4985; const SWord8 s4987 = (s4986 >> 1) | (s4986 << 7); const SWord8 s4988 = 128 | s4987; const SWord8 s4989 = 127 & s4987; const SWord8 s4990 = s4980 ? s4988 : s4989; const SWord8 s4991 = (s4990 >> 1) | (s4990 << 7); const SWord8 s4992 = 128 | s4991; const SWord8 s4993 = 127 & s4991; const SWord8 s4994 = s4978 ? s4992 : s4993; const SBool s4995 = (SBool) ((s1714 >> 0) & 1); const SBool s4996 = false != s4995; const SWord8 s4997 = s4996 ? s4992 : s4993; const SWord8 s4998 = s1694 ? s4994 : s4997; const SBool s4999 = (SBool) ((s1730 >> 0) & 1); const SBool s5000 = false != s4999; const SBool s5001 = (SBool) ((s1723 >> 0) & 1); const SBool s5002 = false != s5001; const SWord8 s5003 = s5002 ? s4988 : s4989; const SWord8 s5004 = (s5003 >> 1) | (s5003 << 7); const SWord8 s5005 = 128 | s5004; const SWord8 s5006 = 127 & s5004; const SWord8 s5007 = s5000 ? s5005 : s5006; const SBool s5008 = (SBool) ((s1735 >> 0) & 1); const SBool s5009 = false != s5008; const SWord8 s5010 = s5009 ? s5005 : s5006; const SWord8 s5011 = s1694 ? s5007 : s5010; const SWord8 s5012 = s1570 ? s4998 : s5011; const SBool s5013 = (SBool) ((s1756 >> 0) & 1); const SBool s5014 = false != s5013; const SBool s5015 = (SBool) ((s1752 >> 0) & 1); const SBool s5016 = false != s5015; const SBool s5017 = (SBool) ((s1745 >> 0) & 1); const SBool s5018 = false != s5017; const SWord8 s5019 = s5018 ? s4984 : s4985; const SWord8 s5020 = (s5019 >> 1) | (s5019 << 7); const SWord8 s5021 = 128 | s5020; const SWord8 s5022 = 127 & s5020; const SWord8 s5023 = s5016 ? s5021 : s5022; const SWord8 s5024 = (s5023 >> 1) | (s5023 << 7); const SWord8 s5025 = 128 | s5024; const SWord8 s5026 = 127 & s5024; const SWord8 s5027 = s5014 ? s5025 : s5026; const SBool s5028 = (SBool) ((s1761 >> 0) & 1); const SBool s5029 = false != s5028; const SWord8 s5030 = s5029 ? s5025 : s5026; const SWord8 s5031 = s1694 ? s5027 : s5030; const SBool s5032 = (SBool) ((s1777 >> 0) & 1); const SBool s5033 = false != s5032; const SBool s5034 = (SBool) ((s1770 >> 0) & 1); const SBool s5035 = false != s5034; const SWord8 s5036 = s5035 ? s5021 : s5022; const SWord8 s5037 = (s5036 >> 1) | (s5036 << 7); const SWord8 s5038 = 128 | s5037; const SWord8 s5039 = 127 & s5037; const SWord8 s5040 = s5033 ? s5038 : s5039; const SBool s5041 = (SBool) ((s1782 >> 0) & 1); const SBool s5042 = false != s5041; const SWord8 s5043 = s5042 ? s5038 : s5039; const SWord8 s5044 = s1694 ? s5040 : s5043; const SWord8 s5045 = s1570 ? s5031 : s5044; const SWord8 s5046 = s1548 ? s5012 : s5045; const SWord8 s5047 = s1037 ? s4976 : s5046; const SBool s5048 = (SBool) ((s1837 >> 0) & 1); const SBool s5049 = false != s5048; const SBool s5050 = (SBool) ((s1833 >> 0) & 1); const SBool s5051 = false != s5050; const SBool s5052 = (SBool) ((s1829 >> 0) & 1); const SBool s5053 = false != s5052; const SWord8 s5054 = (s1816 >> 1) | (s1816 << 7); const SWord8 s5055 = 128 | s5054; const SWord8 s5056 = 127 & s5054; const SWord8 s5057 = s5053 ? s5055 : s5056; const SWord8 s5058 = (s5057 >> 1) | (s5057 << 7); const SWord8 s5059 = 128 | s5058; const SWord8 s5060 = 127 & s5058; const SWord8 s5061 = s5051 ? s5059 : s5060; const SWord8 s5062 = (s5061 >> 1) | (s5061 << 7); const SWord8 s5063 = 128 | s5062; const SWord8 s5064 = 127 & s5062; const SWord8 s5065 = s5049 ? s5063 : s5064; const SBool s5066 = (SBool) ((s1842 >> 0) & 1); const SBool s5067 = false != s5066; const SWord8 s5068 = s5067 ? s5063 : s5064; const SWord8 s5069 = s1825 ? s5065 : s5068; const SBool s5070 = (SBool) ((s1858 >> 0) & 1); const SBool s5071 = false != s5070; const SBool s5072 = (SBool) ((s1851 >> 0) & 1); const SBool s5073 = false != s5072; const SWord8 s5074 = s5073 ? s5059 : s5060; const SWord8 s5075 = (s5074 >> 1) | (s5074 << 7); const SWord8 s5076 = 128 | s5075; const SWord8 s5077 = 127 & s5075; const SWord8 s5078 = s5071 ? s5076 : s5077; const SBool s5079 = (SBool) ((s1863 >> 0) & 1); const SBool s5080 = false != s5079; const SWord8 s5081 = s5080 ? s5076 : s5077; const SWord8 s5082 = s1825 ? s5078 : s5081; const SWord8 s5083 = s1803 ? s5069 : s5082; const SBool s5084 = (SBool) ((s1884 >> 0) & 1); const SBool s5085 = false != s5084; const SBool s5086 = (SBool) ((s1880 >> 0) & 1); const SBool s5087 = false != s5086; const SBool s5088 = (SBool) ((s1873 >> 0) & 1); const SBool s5089 = false != s5088; const SWord8 s5090 = s5089 ? s5055 : s5056; const SWord8 s5091 = (s5090 >> 1) | (s5090 << 7); const SWord8 s5092 = 128 | s5091; const SWord8 s5093 = 127 & s5091; const SWord8 s5094 = s5087 ? s5092 : s5093; const SWord8 s5095 = (s5094 >> 1) | (s5094 << 7); const SWord8 s5096 = 128 | s5095; const SWord8 s5097 = 127 & s5095; const SWord8 s5098 = s5085 ? s5096 : s5097; const SBool s5099 = (SBool) ((s1889 >> 0) & 1); const SBool s5100 = false != s5099; const SWord8 s5101 = s5100 ? s5096 : s5097; const SWord8 s5102 = s1825 ? s5098 : s5101; const SBool s5103 = (SBool) ((s1905 >> 0) & 1); const SBool s5104 = false != s5103; const SBool s5105 = (SBool) ((s1898 >> 0) & 1); const SBool s5106 = false != s5105; const SWord8 s5107 = s5106 ? s5092 : s5093; const SWord8 s5108 = (s5107 >> 1) | (s5107 << 7); const SWord8 s5109 = 128 | s5108; const SWord8 s5110 = 127 & s5108; const SWord8 s5111 = s5104 ? s5109 : s5110; const SBool s5112 = (SBool) ((s1910 >> 0) & 1); const SBool s5113 = false != s5112; const SWord8 s5114 = s5113 ? s5109 : s5110; const SWord8 s5115 = s1825 ? s5111 : s5114; const SWord8 s5116 = s1803 ? s5102 : s5115; const SWord8 s5117 = s1548 ? s5083 : s5116; const SBool s5118 = (SBool) ((s1945 >> 0) & 1); const SBool s5119 = false != s5118; const SBool s5120 = (SBool) ((s1941 >> 0) & 1); const SBool s5121 = false != s5120; const SBool s5122 = (SBool) ((s1937 >> 0) & 1); const SBool s5123 = false != s5122; const SWord8 s5124 = (s1924 >> 1) | (s1924 << 7); const SWord8 s5125 = 128 | s5124; const SWord8 s5126 = 127 & s5124; const SWord8 s5127 = s5123 ? s5125 : s5126; const SWord8 s5128 = (s5127 >> 1) | (s5127 << 7); const SWord8 s5129 = 128 | s5128; const SWord8 s5130 = 127 & s5128; const SWord8 s5131 = s5121 ? s5129 : s5130; const SWord8 s5132 = (s5131 >> 1) | (s5131 << 7); const SWord8 s5133 = 128 | s5132; const SWord8 s5134 = 127 & s5132; const SWord8 s5135 = s5119 ? s5133 : s5134; const SBool s5136 = (SBool) ((s1950 >> 0) & 1); const SBool s5137 = false != s5136; const SWord8 s5138 = s5137 ? s5133 : s5134; const SWord8 s5139 = s1930 ? s5135 : s5138; const SBool s5140 = (SBool) ((s1966 >> 0) & 1); const SBool s5141 = false != s5140; const SBool s5142 = (SBool) ((s1959 >> 0) & 1); const SBool s5143 = false != s5142; const SWord8 s5144 = s5143 ? s5129 : s5130; const SWord8 s5145 = (s5144 >> 1) | (s5144 << 7); const SWord8 s5146 = 128 | s5145; const SWord8 s5147 = 127 & s5145; const SWord8 s5148 = s5141 ? s5146 : s5147; const SBool s5149 = (SBool) ((s1971 >> 0) & 1); const SBool s5150 = false != s5149; const SWord8 s5151 = s5150 ? s5146 : s5147; const SWord8 s5152 = s1930 ? s5148 : s5151; const SWord8 s5153 = s1803 ? s5139 : s5152; const SBool s5154 = (SBool) ((s1992 >> 0) & 1); const SBool s5155 = false != s5154; const SBool s5156 = (SBool) ((s1988 >> 0) & 1); const SBool s5157 = false != s5156; const SBool s5158 = (SBool) ((s1981 >> 0) & 1); const SBool s5159 = false != s5158; const SWord8 s5160 = s5159 ? s5125 : s5126; const SWord8 s5161 = (s5160 >> 1) | (s5160 << 7); const SWord8 s5162 = 128 | s5161; const SWord8 s5163 = 127 & s5161; const SWord8 s5164 = s5157 ? s5162 : s5163; const SWord8 s5165 = (s5164 >> 1) | (s5164 << 7); const SWord8 s5166 = 128 | s5165; const SWord8 s5167 = 127 & s5165; const SWord8 s5168 = s5155 ? s5166 : s5167; const SBool s5169 = (SBool) ((s1997 >> 0) & 1); const SBool s5170 = false != s5169; const SWord8 s5171 = s5170 ? s5166 : s5167; const SWord8 s5172 = s1930 ? s5168 : s5171; const SBool s5173 = (SBool) ((s2013 >> 0) & 1); const SBool s5174 = false != s5173; const SBool s5175 = (SBool) ((s2006 >> 0) & 1); const SBool s5176 = false != s5175; const SWord8 s5177 = s5176 ? s5162 : s5163; const SWord8 s5178 = (s5177 >> 1) | (s5177 << 7); const SWord8 s5179 = 128 | s5178; const SWord8 s5180 = 127 & s5178; const SWord8 s5181 = s5174 ? s5179 : s5180; const SBool s5182 = (SBool) ((s2018 >> 0) & 1); const SBool s5183 = false != s5182; const SWord8 s5184 = s5183 ? s5179 : s5180; const SWord8 s5185 = s1930 ? s5181 : s5184; const SWord8 s5186 = s1803 ? s5172 : s5185; const SWord8 s5187 = s1548 ? s5153 : s5186; const SWord8 s5188 = s1037 ? s5117 : s5187; const SWord8 s5189 = s21 ? s5047 : s5188; const SWord8 s5190 = s16 ? s4906 : s5189; const SWord8 s5191 = s11 ? s4623 : s5190; const SBool s5192 = (SBool) ((s2128 >> 0) & 1); const SBool s5193 = false != s5192; const SBool s5194 = (SBool) ((s2124 >> 0) & 1); const SBool s5195 = false != s5194; const SBool s5196 = (SBool) ((s2120 >> 0) & 1); const SBool s5197 = false != s5196; const SWord8 s5198 = (s2107 >> 1) | (s2107 << 7); const SWord8 s5199 = 128 | s5198; const SWord8 s5200 = 127 & s5198; const SWord8 s5201 = s5197 ? s5199 : s5200; const SWord8 s5202 = (s5201 >> 1) | (s5201 << 7); const SWord8 s5203 = 128 | s5202; const SWord8 s5204 = 127 & s5202; const SWord8 s5205 = s5195 ? s5203 : s5204; const SWord8 s5206 = (s5205 >> 1) | (s5205 << 7); const SWord8 s5207 = 128 | s5206; const SWord8 s5208 = 127 & s5206; const SWord8 s5209 = s5193 ? s5207 : s5208; const SBool s5210 = (SBool) ((s2133 >> 0) & 1); const SBool s5211 = false != s5210; const SWord8 s5212 = s5211 ? s5207 : s5208; const SWord8 s5213 = s2116 ? s5209 : s5212; const SBool s5214 = (SBool) ((s2149 >> 0) & 1); const SBool s5215 = false != s5214; const SBool s5216 = (SBool) ((s2142 >> 0) & 1); const SBool s5217 = false != s5216; const SWord8 s5218 = s5217 ? s5203 : s5204; const SWord8 s5219 = (s5218 >> 1) | (s5218 << 7); const SWord8 s5220 = 128 | s5219; const SWord8 s5221 = 127 & s5219; const SWord8 s5222 = s5215 ? s5220 : s5221; const SBool s5223 = (SBool) ((s2154 >> 0) & 1); const SBool s5224 = false != s5223; const SWord8 s5225 = s5224 ? s5220 : s5221; const SWord8 s5226 = s2116 ? s5222 : s5225; const SWord8 s5227 = s2097 ? s5213 : s5226; const SBool s5228 = (SBool) ((s2175 >> 0) & 1); const SBool s5229 = false != s5228; const SBool s5230 = (SBool) ((s2171 >> 0) & 1); const SBool s5231 = false != s5230; const SBool s5232 = (SBool) ((s2164 >> 0) & 1); const SBool s5233 = false != s5232; const SWord8 s5234 = s5233 ? s5199 : s5200; const SWord8 s5235 = (s5234 >> 1) | (s5234 << 7); const SWord8 s5236 = 128 | s5235; const SWord8 s5237 = 127 & s5235; const SWord8 s5238 = s5231 ? s5236 : s5237; const SWord8 s5239 = (s5238 >> 1) | (s5238 << 7); const SWord8 s5240 = 128 | s5239; const SWord8 s5241 = 127 & s5239; const SWord8 s5242 = s5229 ? s5240 : s5241; const SBool s5243 = (SBool) ((s2180 >> 0) & 1); const SBool s5244 = false != s5243; const SWord8 s5245 = s5244 ? s5240 : s5241; const SWord8 s5246 = s2116 ? s5242 : s5245; const SBool s5247 = (SBool) ((s2196 >> 0) & 1); const SBool s5248 = false != s5247; const SBool s5249 = (SBool) ((s2189 >> 0) & 1); const SBool s5250 = false != s5249; const SWord8 s5251 = s5250 ? s5236 : s5237; const SWord8 s5252 = (s5251 >> 1) | (s5251 << 7); const SWord8 s5253 = 128 | s5252; const SWord8 s5254 = 127 & s5252; const SWord8 s5255 = s5248 ? s5253 : s5254; const SBool s5256 = (SBool) ((s2201 >> 0) & 1); const SBool s5257 = false != s5256; const SWord8 s5258 = s5257 ? s5253 : s5254; const SWord8 s5259 = s2116 ? s5255 : s5258; const SWord8 s5260 = s2097 ? s5246 : s5259; const SWord8 s5261 = s2078 ? s5227 : s5260; const SBool s5262 = (SBool) ((s2236 >> 0) & 1); const SBool s5263 = false != s5262; const SBool s5264 = (SBool) ((s2232 >> 0) & 1); const SBool s5265 = false != s5264; const SBool s5266 = (SBool) ((s2228 >> 0) & 1); const SBool s5267 = false != s5266; const SWord8 s5268 = (s2215 >> 1) | (s2215 << 7); const SWord8 s5269 = 128 | s5268; const SWord8 s5270 = 127 & s5268; const SWord8 s5271 = s5267 ? s5269 : s5270; const SWord8 s5272 = (s5271 >> 1) | (s5271 << 7); const SWord8 s5273 = 128 | s5272; const SWord8 s5274 = 127 & s5272; const SWord8 s5275 = s5265 ? s5273 : s5274; const SWord8 s5276 = (s5275 >> 1) | (s5275 << 7); const SWord8 s5277 = 128 | s5276; const SWord8 s5278 = 127 & s5276; const SWord8 s5279 = s5263 ? s5277 : s5278; const SBool s5280 = (SBool) ((s2241 >> 0) & 1); const SBool s5281 = false != s5280; const SWord8 s5282 = s5281 ? s5277 : s5278; const SWord8 s5283 = s2221 ? s5279 : s5282; const SBool s5284 = (SBool) ((s2257 >> 0) & 1); const SBool s5285 = false != s5284; const SBool s5286 = (SBool) ((s2250 >> 0) & 1); const SBool s5287 = false != s5286; const SWord8 s5288 = s5287 ? s5273 : s5274; const SWord8 s5289 = (s5288 >> 1) | (s5288 << 7); const SWord8 s5290 = 128 | s5289; const SWord8 s5291 = 127 & s5289; const SWord8 s5292 = s5285 ? s5290 : s5291; const SBool s5293 = (SBool) ((s2262 >> 0) & 1); const SBool s5294 = false != s5293; const SWord8 s5295 = s5294 ? s5290 : s5291; const SWord8 s5296 = s2221 ? s5292 : s5295; const SWord8 s5297 = s2097 ? s5283 : s5296; const SBool s5298 = (SBool) ((s2283 >> 0) & 1); const SBool s5299 = false != s5298; const SBool s5300 = (SBool) ((s2279 >> 0) & 1); const SBool s5301 = false != s5300; const SBool s5302 = (SBool) ((s2272 >> 0) & 1); const SBool s5303 = false != s5302; const SWord8 s5304 = s5303 ? s5269 : s5270; const SWord8 s5305 = (s5304 >> 1) | (s5304 << 7); const SWord8 s5306 = 128 | s5305; const SWord8 s5307 = 127 & s5305; const SWord8 s5308 = s5301 ? s5306 : s5307; const SWord8 s5309 = (s5308 >> 1) | (s5308 << 7); const SWord8 s5310 = 128 | s5309; const SWord8 s5311 = 127 & s5309; const SWord8 s5312 = s5299 ? s5310 : s5311; const SBool s5313 = (SBool) ((s2288 >> 0) & 1); const SBool s5314 = false != s5313; const SWord8 s5315 = s5314 ? s5310 : s5311; const SWord8 s5316 = s2221 ? s5312 : s5315; const SBool s5317 = (SBool) ((s2304 >> 0) & 1); const SBool s5318 = false != s5317; const SBool s5319 = (SBool) ((s2297 >> 0) & 1); const SBool s5320 = false != s5319; const SWord8 s5321 = s5320 ? s5306 : s5307; const SWord8 s5322 = (s5321 >> 1) | (s5321 << 7); const SWord8 s5323 = 128 | s5322; const SWord8 s5324 = 127 & s5322; const SWord8 s5325 = s5318 ? s5323 : s5324; const SBool s5326 = (SBool) ((s2309 >> 0) & 1); const SBool s5327 = false != s5326; const SWord8 s5328 = s5327 ? s5323 : s5324; const SWord8 s5329 = s2221 ? s5325 : s5328; const SWord8 s5330 = s2097 ? s5316 : s5329; const SWord8 s5331 = s2078 ? s5297 : s5330; const SWord8 s5332 = s2059 ? s5261 : s5331; const SBool s5333 = (SBool) ((s2364 >> 0) & 1); const SBool s5334 = false != s5333; const SBool s5335 = (SBool) ((s2360 >> 0) & 1); const SBool s5336 = false != s5335; const SBool s5337 = (SBool) ((s2356 >> 0) & 1); const SBool s5338 = false != s5337; const SWord8 s5339 = (s2343 >> 1) | (s2343 << 7); const SWord8 s5340 = 128 | s5339; const SWord8 s5341 = 127 & s5339; const SWord8 s5342 = s5338 ? s5340 : s5341; const SWord8 s5343 = (s5342 >> 1) | (s5342 << 7); const SWord8 s5344 = 128 | s5343; const SWord8 s5345 = 127 & s5343; const SWord8 s5346 = s5336 ? s5344 : s5345; const SWord8 s5347 = (s5346 >> 1) | (s5346 << 7); const SWord8 s5348 = 128 | s5347; const SWord8 s5349 = 127 & s5347; const SWord8 s5350 = s5334 ? s5348 : s5349; const SBool s5351 = (SBool) ((s2369 >> 0) & 1); const SBool s5352 = false != s5351; const SWord8 s5353 = s5352 ? s5348 : s5349; const SWord8 s5354 = s2352 ? s5350 : s5353; const SBool s5355 = (SBool) ((s2385 >> 0) & 1); const SBool s5356 = false != s5355; const SBool s5357 = (SBool) ((s2378 >> 0) & 1); const SBool s5358 = false != s5357; const SWord8 s5359 = s5358 ? s5344 : s5345; const SWord8 s5360 = (s5359 >> 1) | (s5359 << 7); const SWord8 s5361 = 128 | s5360; const SWord8 s5362 = 127 & s5360; const SWord8 s5363 = s5356 ? s5361 : s5362; const SBool s5364 = (SBool) ((s2390 >> 0) & 1); const SBool s5365 = false != s5364; const SWord8 s5366 = s5365 ? s5361 : s5362; const SWord8 s5367 = s2352 ? s5363 : s5366; const SWord8 s5368 = s2330 ? s5354 : s5367; const SBool s5369 = (SBool) ((s2411 >> 0) & 1); const SBool s5370 = false != s5369; const SBool s5371 = (SBool) ((s2407 >> 0) & 1); const SBool s5372 = false != s5371; const SBool s5373 = (SBool) ((s2400 >> 0) & 1); const SBool s5374 = false != s5373; const SWord8 s5375 = s5374 ? s5340 : s5341; const SWord8 s5376 = (s5375 >> 1) | (s5375 << 7); const SWord8 s5377 = 128 | s5376; const SWord8 s5378 = 127 & s5376; const SWord8 s5379 = s5372 ? s5377 : s5378; const SWord8 s5380 = (s5379 >> 1) | (s5379 << 7); const SWord8 s5381 = 128 | s5380; const SWord8 s5382 = 127 & s5380; const SWord8 s5383 = s5370 ? s5381 : s5382; const SBool s5384 = (SBool) ((s2416 >> 0) & 1); const SBool s5385 = false != s5384; const SWord8 s5386 = s5385 ? s5381 : s5382; const SWord8 s5387 = s2352 ? s5383 : s5386; const SBool s5388 = (SBool) ((s2432 >> 0) & 1); const SBool s5389 = false != s5388; const SBool s5390 = (SBool) ((s2425 >> 0) & 1); const SBool s5391 = false != s5390; const SWord8 s5392 = s5391 ? s5377 : s5378; const SWord8 s5393 = (s5392 >> 1) | (s5392 << 7); const SWord8 s5394 = 128 | s5393; const SWord8 s5395 = 127 & s5393; const SWord8 s5396 = s5389 ? s5394 : s5395; const SBool s5397 = (SBool) ((s2437 >> 0) & 1); const SBool s5398 = false != s5397; const SWord8 s5399 = s5398 ? s5394 : s5395; const SWord8 s5400 = s2352 ? s5396 : s5399; const SWord8 s5401 = s2330 ? s5387 : s5400; const SWord8 s5402 = s2078 ? s5368 : s5401; const SBool s5403 = (SBool) ((s2472 >> 0) & 1); const SBool s5404 = false != s5403; const SBool s5405 = (SBool) ((s2468 >> 0) & 1); const SBool s5406 = false != s5405; const SBool s5407 = (SBool) ((s2464 >> 0) & 1); const SBool s5408 = false != s5407; const SWord8 s5409 = (s2451 >> 1) | (s2451 << 7); const SWord8 s5410 = 128 | s5409; const SWord8 s5411 = 127 & s5409; const SWord8 s5412 = s5408 ? s5410 : s5411; const SWord8 s5413 = (s5412 >> 1) | (s5412 << 7); const SWord8 s5414 = 128 | s5413; const SWord8 s5415 = 127 & s5413; const SWord8 s5416 = s5406 ? s5414 : s5415; const SWord8 s5417 = (s5416 >> 1) | (s5416 << 7); const SWord8 s5418 = 128 | s5417; const SWord8 s5419 = 127 & s5417; const SWord8 s5420 = s5404 ? s5418 : s5419; const SBool s5421 = (SBool) ((s2477 >> 0) & 1); const SBool s5422 = false != s5421; const SWord8 s5423 = s5422 ? s5418 : s5419; const SWord8 s5424 = s2457 ? s5420 : s5423; const SBool s5425 = (SBool) ((s2493 >> 0) & 1); const SBool s5426 = false != s5425; const SBool s5427 = (SBool) ((s2486 >> 0) & 1); const SBool s5428 = false != s5427; const SWord8 s5429 = s5428 ? s5414 : s5415; const SWord8 s5430 = (s5429 >> 1) | (s5429 << 7); const SWord8 s5431 = 128 | s5430; const SWord8 s5432 = 127 & s5430; const SWord8 s5433 = s5426 ? s5431 : s5432; const SBool s5434 = (SBool) ((s2498 >> 0) & 1); const SBool s5435 = false != s5434; const SWord8 s5436 = s5435 ? s5431 : s5432; const SWord8 s5437 = s2457 ? s5433 : s5436; const SWord8 s5438 = s2330 ? s5424 : s5437; const SBool s5439 = (SBool) ((s2519 >> 0) & 1); const SBool s5440 = false != s5439; const SBool s5441 = (SBool) ((s2515 >> 0) & 1); const SBool s5442 = false != s5441; const SBool s5443 = (SBool) ((s2508 >> 0) & 1); const SBool s5444 = false != s5443; const SWord8 s5445 = s5444 ? s5410 : s5411; const SWord8 s5446 = (s5445 >> 1) | (s5445 << 7); const SWord8 s5447 = 128 | s5446; const SWord8 s5448 = 127 & s5446; const SWord8 s5449 = s5442 ? s5447 : s5448; const SWord8 s5450 = (s5449 >> 1) | (s5449 << 7); const SWord8 s5451 = 128 | s5450; const SWord8 s5452 = 127 & s5450; const SWord8 s5453 = s5440 ? s5451 : s5452; const SBool s5454 = (SBool) ((s2524 >> 0) & 1); const SBool s5455 = false != s5454; const SWord8 s5456 = s5455 ? s5451 : s5452; const SWord8 s5457 = s2457 ? s5453 : s5456; const SBool s5458 = (SBool) ((s2540 >> 0) & 1); const SBool s5459 = false != s5458; const SBool s5460 = (SBool) ((s2533 >> 0) & 1); const SBool s5461 = false != s5460; const SWord8 s5462 = s5461 ? s5447 : s5448; const SWord8 s5463 = (s5462 >> 1) | (s5462 << 7); const SWord8 s5464 = 128 | s5463; const SWord8 s5465 = 127 & s5463; const SWord8 s5466 = s5459 ? s5464 : s5465; const SBool s5467 = (SBool) ((s2545 >> 0) & 1); const SBool s5468 = false != s5467; const SWord8 s5469 = s5468 ? s5464 : s5465; const SWord8 s5470 = s2457 ? s5466 : s5469; const SWord8 s5471 = s2330 ? s5457 : s5470; const SWord8 s5472 = s2078 ? s5438 : s5471; const SWord8 s5473 = s2059 ? s5402 : s5472; const SWord8 s5474 = s2042 ? s5332 : s5473; const SBool s5475 = (SBool) ((s2620 >> 0) & 1); const SBool s5476 = false != s5475; const SBool s5477 = (SBool) ((s2616 >> 0) & 1); const SBool s5478 = false != s5477; const SBool s5479 = (SBool) ((s2612 >> 0) & 1); const SBool s5480 = false != s5479; const SWord8 s5481 = (s2599 >> 1) | (s2599 << 7); const SWord8 s5482 = 128 | s5481; const SWord8 s5483 = 127 & s5481; const SWord8 s5484 = s5480 ? s5482 : s5483; const SWord8 s5485 = (s5484 >> 1) | (s5484 << 7); const SWord8 s5486 = 128 | s5485; const SWord8 s5487 = 127 & s5485; const SWord8 s5488 = s5478 ? s5486 : s5487; const SWord8 s5489 = (s5488 >> 1) | (s5488 << 7); const SWord8 s5490 = 128 | s5489; const SWord8 s5491 = 127 & s5489; const SWord8 s5492 = s5476 ? s5490 : s5491; const SBool s5493 = (SBool) ((s2625 >> 0) & 1); const SBool s5494 = false != s5493; const SWord8 s5495 = s5494 ? s5490 : s5491; const SWord8 s5496 = s2608 ? s5492 : s5495; const SBool s5497 = (SBool) ((s2641 >> 0) & 1); const SBool s5498 = false != s5497; const SBool s5499 = (SBool) ((s2634 >> 0) & 1); const SBool s5500 = false != s5499; const SWord8 s5501 = s5500 ? s5486 : s5487; const SWord8 s5502 = (s5501 >> 1) | (s5501 << 7); const SWord8 s5503 = 128 | s5502; const SWord8 s5504 = 127 & s5502; const SWord8 s5505 = s5498 ? s5503 : s5504; const SBool s5506 = (SBool) ((s2646 >> 0) & 1); const SBool s5507 = false != s5506; const SWord8 s5508 = s5507 ? s5503 : s5504; const SWord8 s5509 = s2608 ? s5505 : s5508; const SWord8 s5510 = s2589 ? s5496 : s5509; const SBool s5511 = (SBool) ((s2667 >> 0) & 1); const SBool s5512 = false != s5511; const SBool s5513 = (SBool) ((s2663 >> 0) & 1); const SBool s5514 = false != s5513; const SBool s5515 = (SBool) ((s2656 >> 0) & 1); const SBool s5516 = false != s5515; const SWord8 s5517 = s5516 ? s5482 : s5483; const SWord8 s5518 = (s5517 >> 1) | (s5517 << 7); const SWord8 s5519 = 128 | s5518; const SWord8 s5520 = 127 & s5518; const SWord8 s5521 = s5514 ? s5519 : s5520; const SWord8 s5522 = (s5521 >> 1) | (s5521 << 7); const SWord8 s5523 = 128 | s5522; const SWord8 s5524 = 127 & s5522; const SWord8 s5525 = s5512 ? s5523 : s5524; const SBool s5526 = (SBool) ((s2672 >> 0) & 1); const SBool s5527 = false != s5526; const SWord8 s5528 = s5527 ? s5523 : s5524; const SWord8 s5529 = s2608 ? s5525 : s5528; const SBool s5530 = (SBool) ((s2688 >> 0) & 1); const SBool s5531 = false != s5530; const SBool s5532 = (SBool) ((s2681 >> 0) & 1); const SBool s5533 = false != s5532; const SWord8 s5534 = s5533 ? s5519 : s5520; const SWord8 s5535 = (s5534 >> 1) | (s5534 << 7); const SWord8 s5536 = 128 | s5535; const SWord8 s5537 = 127 & s5535; const SWord8 s5538 = s5531 ? s5536 : s5537; const SBool s5539 = (SBool) ((s2693 >> 0) & 1); const SBool s5540 = false != s5539; const SWord8 s5541 = s5540 ? s5536 : s5537; const SWord8 s5542 = s2608 ? s5538 : s5541; const SWord8 s5543 = s2589 ? s5529 : s5542; const SWord8 s5544 = s2567 ? s5510 : s5543; const SBool s5545 = (SBool) ((s2728 >> 0) & 1); const SBool s5546 = false != s5545; const SBool s5547 = (SBool) ((s2724 >> 0) & 1); const SBool s5548 = false != s5547; const SBool s5549 = (SBool) ((s2720 >> 0) & 1); const SBool s5550 = false != s5549; const SWord8 s5551 = (s2707 >> 1) | (s2707 << 7); const SWord8 s5552 = 128 | s5551; const SWord8 s5553 = 127 & s5551; const SWord8 s5554 = s5550 ? s5552 : s5553; const SWord8 s5555 = (s5554 >> 1) | (s5554 << 7); const SWord8 s5556 = 128 | s5555; const SWord8 s5557 = 127 & s5555; const SWord8 s5558 = s5548 ? s5556 : s5557; const SWord8 s5559 = (s5558 >> 1) | (s5558 << 7); const SWord8 s5560 = 128 | s5559; const SWord8 s5561 = 127 & s5559; const SWord8 s5562 = s5546 ? s5560 : s5561; const SBool s5563 = (SBool) ((s2733 >> 0) & 1); const SBool s5564 = false != s5563; const SWord8 s5565 = s5564 ? s5560 : s5561; const SWord8 s5566 = s2713 ? s5562 : s5565; const SBool s5567 = (SBool) ((s2749 >> 0) & 1); const SBool s5568 = false != s5567; const SBool s5569 = (SBool) ((s2742 >> 0) & 1); const SBool s5570 = false != s5569; const SWord8 s5571 = s5570 ? s5556 : s5557; const SWord8 s5572 = (s5571 >> 1) | (s5571 << 7); const SWord8 s5573 = 128 | s5572; const SWord8 s5574 = 127 & s5572; const SWord8 s5575 = s5568 ? s5573 : s5574; const SBool s5576 = (SBool) ((s2754 >> 0) & 1); const SBool s5577 = false != s5576; const SWord8 s5578 = s5577 ? s5573 : s5574; const SWord8 s5579 = s2713 ? s5575 : s5578; const SWord8 s5580 = s2589 ? s5566 : s5579; const SBool s5581 = (SBool) ((s2775 >> 0) & 1); const SBool s5582 = false != s5581; const SBool s5583 = (SBool) ((s2771 >> 0) & 1); const SBool s5584 = false != s5583; const SBool s5585 = (SBool) ((s2764 >> 0) & 1); const SBool s5586 = false != s5585; const SWord8 s5587 = s5586 ? s5552 : s5553; const SWord8 s5588 = (s5587 >> 1) | (s5587 << 7); const SWord8 s5589 = 128 | s5588; const SWord8 s5590 = 127 & s5588; const SWord8 s5591 = s5584 ? s5589 : s5590; const SWord8 s5592 = (s5591 >> 1) | (s5591 << 7); const SWord8 s5593 = 128 | s5592; const SWord8 s5594 = 127 & s5592; const SWord8 s5595 = s5582 ? s5593 : s5594; const SBool s5596 = (SBool) ((s2780 >> 0) & 1); const SBool s5597 = false != s5596; const SWord8 s5598 = s5597 ? s5593 : s5594; const SWord8 s5599 = s2713 ? s5595 : s5598; const SBool s5600 = (SBool) ((s2796 >> 0) & 1); const SBool s5601 = false != s5600; const SBool s5602 = (SBool) ((s2789 >> 0) & 1); const SBool s5603 = false != s5602; const SWord8 s5604 = s5603 ? s5589 : s5590; const SWord8 s5605 = (s5604 >> 1) | (s5604 << 7); const SWord8 s5606 = 128 | s5605; const SWord8 s5607 = 127 & s5605; const SWord8 s5608 = s5601 ? s5606 : s5607; const SBool s5609 = (SBool) ((s2801 >> 0) & 1); const SBool s5610 = false != s5609; const SWord8 s5611 = s5610 ? s5606 : s5607; const SWord8 s5612 = s2713 ? s5608 : s5611; const SWord8 s5613 = s2589 ? s5599 : s5612; const SWord8 s5614 = s2567 ? s5580 : s5613; const SWord8 s5615 = s2059 ? s5544 : s5614; const SBool s5616 = (SBool) ((s2856 >> 0) & 1); const SBool s5617 = false != s5616; const SBool s5618 = (SBool) ((s2852 >> 0) & 1); const SBool s5619 = false != s5618; const SBool s5620 = (SBool) ((s2848 >> 0) & 1); const SBool s5621 = false != s5620; const SWord8 s5622 = (s2835 >> 1) | (s2835 << 7); const SWord8 s5623 = 128 | s5622; const SWord8 s5624 = 127 & s5622; const SWord8 s5625 = s5621 ? s5623 : s5624; const SWord8 s5626 = (s5625 >> 1) | (s5625 << 7); const SWord8 s5627 = 128 | s5626; const SWord8 s5628 = 127 & s5626; const SWord8 s5629 = s5619 ? s5627 : s5628; const SWord8 s5630 = (s5629 >> 1) | (s5629 << 7); const SWord8 s5631 = 128 | s5630; const SWord8 s5632 = 127 & s5630; const SWord8 s5633 = s5617 ? s5631 : s5632; const SBool s5634 = (SBool) ((s2861 >> 0) & 1); const SBool s5635 = false != s5634; const SWord8 s5636 = s5635 ? s5631 : s5632; const SWord8 s5637 = s2844 ? s5633 : s5636; const SBool s5638 = (SBool) ((s2877 >> 0) & 1); const SBool s5639 = false != s5638; const SBool s5640 = (SBool) ((s2870 >> 0) & 1); const SBool s5641 = false != s5640; const SWord8 s5642 = s5641 ? s5627 : s5628; const SWord8 s5643 = (s5642 >> 1) | (s5642 << 7); const SWord8 s5644 = 128 | s5643; const SWord8 s5645 = 127 & s5643; const SWord8 s5646 = s5639 ? s5644 : s5645; const SBool s5647 = (SBool) ((s2882 >> 0) & 1); const SBool s5648 = false != s5647; const SWord8 s5649 = s5648 ? s5644 : s5645; const SWord8 s5650 = s2844 ? s5646 : s5649; const SWord8 s5651 = s2822 ? s5637 : s5650; const SBool s5652 = (SBool) ((s2903 >> 0) & 1); const SBool s5653 = false != s5652; const SBool s5654 = (SBool) ((s2899 >> 0) & 1); const SBool s5655 = false != s5654; const SBool s5656 = (SBool) ((s2892 >> 0) & 1); const SBool s5657 = false != s5656; const SWord8 s5658 = s5657 ? s5623 : s5624; const SWord8 s5659 = (s5658 >> 1) | (s5658 << 7); const SWord8 s5660 = 128 | s5659; const SWord8 s5661 = 127 & s5659; const SWord8 s5662 = s5655 ? s5660 : s5661; const SWord8 s5663 = (s5662 >> 1) | (s5662 << 7); const SWord8 s5664 = 128 | s5663; const SWord8 s5665 = 127 & s5663; const SWord8 s5666 = s5653 ? s5664 : s5665; const SBool s5667 = (SBool) ((s2908 >> 0) & 1); const SBool s5668 = false != s5667; const SWord8 s5669 = s5668 ? s5664 : s5665; const SWord8 s5670 = s2844 ? s5666 : s5669; const SBool s5671 = (SBool) ((s2924 >> 0) & 1); const SBool s5672 = false != s5671; const SBool s5673 = (SBool) ((s2917 >> 0) & 1); const SBool s5674 = false != s5673; const SWord8 s5675 = s5674 ? s5660 : s5661; const SWord8 s5676 = (s5675 >> 1) | (s5675 << 7); const SWord8 s5677 = 128 | s5676; const SWord8 s5678 = 127 & s5676; const SWord8 s5679 = s5672 ? s5677 : s5678; const SBool s5680 = (SBool) ((s2929 >> 0) & 1); const SBool s5681 = false != s5680; const SWord8 s5682 = s5681 ? s5677 : s5678; const SWord8 s5683 = s2844 ? s5679 : s5682; const SWord8 s5684 = s2822 ? s5670 : s5683; const SWord8 s5685 = s2567 ? s5651 : s5684; const SBool s5686 = (SBool) ((s2964 >> 0) & 1); const SBool s5687 = false != s5686; const SBool s5688 = (SBool) ((s2960 >> 0) & 1); const SBool s5689 = false != s5688; const SBool s5690 = (SBool) ((s2956 >> 0) & 1); const SBool s5691 = false != s5690; const SWord8 s5692 = (s2943 >> 1) | (s2943 << 7); const SWord8 s5693 = 128 | s5692; const SWord8 s5694 = 127 & s5692; const SWord8 s5695 = s5691 ? s5693 : s5694; const SWord8 s5696 = (s5695 >> 1) | (s5695 << 7); const SWord8 s5697 = 128 | s5696; const SWord8 s5698 = 127 & s5696; const SWord8 s5699 = s5689 ? s5697 : s5698; const SWord8 s5700 = (s5699 >> 1) | (s5699 << 7); const SWord8 s5701 = 128 | s5700; const SWord8 s5702 = 127 & s5700; const SWord8 s5703 = s5687 ? s5701 : s5702; const SBool s5704 = (SBool) ((s2969 >> 0) & 1); const SBool s5705 = false != s5704; const SWord8 s5706 = s5705 ? s5701 : s5702; const SWord8 s5707 = s2949 ? s5703 : s5706; const SBool s5708 = (SBool) ((s2985 >> 0) & 1); const SBool s5709 = false != s5708; const SBool s5710 = (SBool) ((s2978 >> 0) & 1); const SBool s5711 = false != s5710; const SWord8 s5712 = s5711 ? s5697 : s5698; const SWord8 s5713 = (s5712 >> 1) | (s5712 << 7); const SWord8 s5714 = 128 | s5713; const SWord8 s5715 = 127 & s5713; const SWord8 s5716 = s5709 ? s5714 : s5715; const SBool s5717 = (SBool) ((s2990 >> 0) & 1); const SBool s5718 = false != s5717; const SWord8 s5719 = s5718 ? s5714 : s5715; const SWord8 s5720 = s2949 ? s5716 : s5719; const SWord8 s5721 = s2822 ? s5707 : s5720; const SBool s5722 = (SBool) ((s3011 >> 0) & 1); const SBool s5723 = false != s5722; const SBool s5724 = (SBool) ((s3007 >> 0) & 1); const SBool s5725 = false != s5724; const SBool s5726 = (SBool) ((s3000 >> 0) & 1); const SBool s5727 = false != s5726; const SWord8 s5728 = s5727 ? s5693 : s5694; const SWord8 s5729 = (s5728 >> 1) | (s5728 << 7); const SWord8 s5730 = 128 | s5729; const SWord8 s5731 = 127 & s5729; const SWord8 s5732 = s5725 ? s5730 : s5731; const SWord8 s5733 = (s5732 >> 1) | (s5732 << 7); const SWord8 s5734 = 128 | s5733; const SWord8 s5735 = 127 & s5733; const SWord8 s5736 = s5723 ? s5734 : s5735; const SBool s5737 = (SBool) ((s3016 >> 0) & 1); const SBool s5738 = false != s5737; const SWord8 s5739 = s5738 ? s5734 : s5735; const SWord8 s5740 = s2949 ? s5736 : s5739; const SBool s5741 = (SBool) ((s3032 >> 0) & 1); const SBool s5742 = false != s5741; const SBool s5743 = (SBool) ((s3025 >> 0) & 1); const SBool s5744 = false != s5743; const SWord8 s5745 = s5744 ? s5730 : s5731; const SWord8 s5746 = (s5745 >> 1) | (s5745 << 7); const SWord8 s5747 = 128 | s5746; const SWord8 s5748 = 127 & s5746; const SWord8 s5749 = s5742 ? s5747 : s5748; const SBool s5750 = (SBool) ((s3037 >> 0) & 1); const SBool s5751 = false != s5750; const SWord8 s5752 = s5751 ? s5747 : s5748; const SWord8 s5753 = s2949 ? s5749 : s5752; const SWord8 s5754 = s2822 ? s5740 : s5753; const SWord8 s5755 = s2567 ? s5721 : s5754; const SWord8 s5756 = s2059 ? s5685 : s5755; const SWord8 s5757 = s2042 ? s5615 : s5756; const SWord8 s5758 = s16 ? s5474 : s5757; const SBool s5759 = (SBool) ((s3132 >> 0) & 1); const SBool s5760 = false != s5759; const SBool s5761 = (SBool) ((s3128 >> 0) & 1); const SBool s5762 = false != s5761; const SBool s5763 = (SBool) ((s3124 >> 0) & 1); const SBool s5764 = false != s5763; const SWord8 s5765 = (s3111 >> 1) | (s3111 << 7); const SWord8 s5766 = 128 | s5765; const SWord8 s5767 = 127 & s5765; const SWord8 s5768 = s5764 ? s5766 : s5767; const SWord8 s5769 = (s5768 >> 1) | (s5768 << 7); const SWord8 s5770 = 128 | s5769; const SWord8 s5771 = 127 & s5769; const SWord8 s5772 = s5762 ? s5770 : s5771; const SWord8 s5773 = (s5772 >> 1) | (s5772 << 7); const SWord8 s5774 = 128 | s5773; const SWord8 s5775 = 127 & s5773; const SWord8 s5776 = s5760 ? s5774 : s5775; const SBool s5777 = (SBool) ((s3137 >> 0) & 1); const SBool s5778 = false != s5777; const SWord8 s5779 = s5778 ? s5774 : s5775; const SWord8 s5780 = s3120 ? s5776 : s5779; const SBool s5781 = (SBool) ((s3153 >> 0) & 1); const SBool s5782 = false != s5781; const SBool s5783 = (SBool) ((s3146 >> 0) & 1); const SBool s5784 = false != s5783; const SWord8 s5785 = s5784 ? s5770 : s5771; const SWord8 s5786 = (s5785 >> 1) | (s5785 << 7); const SWord8 s5787 = 128 | s5786; const SWord8 s5788 = 127 & s5786; const SWord8 s5789 = s5782 ? s5787 : s5788; const SBool s5790 = (SBool) ((s3158 >> 0) & 1); const SBool s5791 = false != s5790; const SWord8 s5792 = s5791 ? s5787 : s5788; const SWord8 s5793 = s3120 ? s5789 : s5792; const SWord8 s5794 = s3101 ? s5780 : s5793; const SBool s5795 = (SBool) ((s3179 >> 0) & 1); const SBool s5796 = false != s5795; const SBool s5797 = (SBool) ((s3175 >> 0) & 1); const SBool s5798 = false != s5797; const SBool s5799 = (SBool) ((s3168 >> 0) & 1); const SBool s5800 = false != s5799; const SWord8 s5801 = s5800 ? s5766 : s5767; const SWord8 s5802 = (s5801 >> 1) | (s5801 << 7); const SWord8 s5803 = 128 | s5802; const SWord8 s5804 = 127 & s5802; const SWord8 s5805 = s5798 ? s5803 : s5804; const SWord8 s5806 = (s5805 >> 1) | (s5805 << 7); const SWord8 s5807 = 128 | s5806; const SWord8 s5808 = 127 & s5806; const SWord8 s5809 = s5796 ? s5807 : s5808; const SBool s5810 = (SBool) ((s3184 >> 0) & 1); const SBool s5811 = false != s5810; const SWord8 s5812 = s5811 ? s5807 : s5808; const SWord8 s5813 = s3120 ? s5809 : s5812; const SBool s5814 = (SBool) ((s3200 >> 0) & 1); const SBool s5815 = false != s5814; const SBool s5816 = (SBool) ((s3193 >> 0) & 1); const SBool s5817 = false != s5816; const SWord8 s5818 = s5817 ? s5803 : s5804; const SWord8 s5819 = (s5818 >> 1) | (s5818 << 7); const SWord8 s5820 = 128 | s5819; const SWord8 s5821 = 127 & s5819; const SWord8 s5822 = s5815 ? s5820 : s5821; const SBool s5823 = (SBool) ((s3205 >> 0) & 1); const SBool s5824 = false != s5823; const SWord8 s5825 = s5824 ? s5820 : s5821; const SWord8 s5826 = s3120 ? s5822 : s5825; const SWord8 s5827 = s3101 ? s5813 : s5826; const SWord8 s5828 = s3082 ? s5794 : s5827; const SBool s5829 = (SBool) ((s3240 >> 0) & 1); const SBool s5830 = false != s5829; const SBool s5831 = (SBool) ((s3236 >> 0) & 1); const SBool s5832 = false != s5831; const SBool s5833 = (SBool) ((s3232 >> 0) & 1); const SBool s5834 = false != s5833; const SWord8 s5835 = (s3219 >> 1) | (s3219 << 7); const SWord8 s5836 = 128 | s5835; const SWord8 s5837 = 127 & s5835; const SWord8 s5838 = s5834 ? s5836 : s5837; const SWord8 s5839 = (s5838 >> 1) | (s5838 << 7); const SWord8 s5840 = 128 | s5839; const SWord8 s5841 = 127 & s5839; const SWord8 s5842 = s5832 ? s5840 : s5841; const SWord8 s5843 = (s5842 >> 1) | (s5842 << 7); const SWord8 s5844 = 128 | s5843; const SWord8 s5845 = 127 & s5843; const SWord8 s5846 = s5830 ? s5844 : s5845; const SBool s5847 = (SBool) ((s3245 >> 0) & 1); const SBool s5848 = false != s5847; const SWord8 s5849 = s5848 ? s5844 : s5845; const SWord8 s5850 = s3225 ? s5846 : s5849; const SBool s5851 = (SBool) ((s3261 >> 0) & 1); const SBool s5852 = false != s5851; const SBool s5853 = (SBool) ((s3254 >> 0) & 1); const SBool s5854 = false != s5853; const SWord8 s5855 = s5854 ? s5840 : s5841; const SWord8 s5856 = (s5855 >> 1) | (s5855 << 7); const SWord8 s5857 = 128 | s5856; const SWord8 s5858 = 127 & s5856; const SWord8 s5859 = s5852 ? s5857 : s5858; const SBool s5860 = (SBool) ((s3266 >> 0) & 1); const SBool s5861 = false != s5860; const SWord8 s5862 = s5861 ? s5857 : s5858; const SWord8 s5863 = s3225 ? s5859 : s5862; const SWord8 s5864 = s3101 ? s5850 : s5863; const SBool s5865 = (SBool) ((s3287 >> 0) & 1); const SBool s5866 = false != s5865; const SBool s5867 = (SBool) ((s3283 >> 0) & 1); const SBool s5868 = false != s5867; const SBool s5869 = (SBool) ((s3276 >> 0) & 1); const SBool s5870 = false != s5869; const SWord8 s5871 = s5870 ? s5836 : s5837; const SWord8 s5872 = (s5871 >> 1) | (s5871 << 7); const SWord8 s5873 = 128 | s5872; const SWord8 s5874 = 127 & s5872; const SWord8 s5875 = s5868 ? s5873 : s5874; const SWord8 s5876 = (s5875 >> 1) | (s5875 << 7); const SWord8 s5877 = 128 | s5876; const SWord8 s5878 = 127 & s5876; const SWord8 s5879 = s5866 ? s5877 : s5878; const SBool s5880 = (SBool) ((s3292 >> 0) & 1); const SBool s5881 = false != s5880; const SWord8 s5882 = s5881 ? s5877 : s5878; const SWord8 s5883 = s3225 ? s5879 : s5882; const SBool s5884 = (SBool) ((s3308 >> 0) & 1); const SBool s5885 = false != s5884; const SBool s5886 = (SBool) ((s3301 >> 0) & 1); const SBool s5887 = false != s5886; const SWord8 s5888 = s5887 ? s5873 : s5874; const SWord8 s5889 = (s5888 >> 1) | (s5888 << 7); const SWord8 s5890 = 128 | s5889; const SWord8 s5891 = 127 & s5889; const SWord8 s5892 = s5885 ? s5890 : s5891; const SBool s5893 = (SBool) ((s3313 >> 0) & 1); const SBool s5894 = false != s5893; const SWord8 s5895 = s5894 ? s5890 : s5891; const SWord8 s5896 = s3225 ? s5892 : s5895; const SWord8 s5897 = s3101 ? s5883 : s5896; const SWord8 s5898 = s3082 ? s5864 : s5897; const SWord8 s5899 = s3060 ? s5828 : s5898; const SBool s5900 = (SBool) ((s3368 >> 0) & 1); const SBool s5901 = false != s5900; const SBool s5902 = (SBool) ((s3364 >> 0) & 1); const SBool s5903 = false != s5902; const SBool s5904 = (SBool) ((s3360 >> 0) & 1); const SBool s5905 = false != s5904; const SWord8 s5906 = (s3347 >> 1) | (s3347 << 7); const SWord8 s5907 = 128 | s5906; const SWord8 s5908 = 127 & s5906; const SWord8 s5909 = s5905 ? s5907 : s5908; const SWord8 s5910 = (s5909 >> 1) | (s5909 << 7); const SWord8 s5911 = 128 | s5910; const SWord8 s5912 = 127 & s5910; const SWord8 s5913 = s5903 ? s5911 : s5912; const SWord8 s5914 = (s5913 >> 1) | (s5913 << 7); const SWord8 s5915 = 128 | s5914; const SWord8 s5916 = 127 & s5914; const SWord8 s5917 = s5901 ? s5915 : s5916; const SBool s5918 = (SBool) ((s3373 >> 0) & 1); const SBool s5919 = false != s5918; const SWord8 s5920 = s5919 ? s5915 : s5916; const SWord8 s5921 = s3356 ? s5917 : s5920; const SBool s5922 = (SBool) ((s3389 >> 0) & 1); const SBool s5923 = false != s5922; const SBool s5924 = (SBool) ((s3382 >> 0) & 1); const SBool s5925 = false != s5924; const SWord8 s5926 = s5925 ? s5911 : s5912; const SWord8 s5927 = (s5926 >> 1) | (s5926 << 7); const SWord8 s5928 = 128 | s5927; const SWord8 s5929 = 127 & s5927; const SWord8 s5930 = s5923 ? s5928 : s5929; const SBool s5931 = (SBool) ((s3394 >> 0) & 1); const SBool s5932 = false != s5931; const SWord8 s5933 = s5932 ? s5928 : s5929; const SWord8 s5934 = s3356 ? s5930 : s5933; const SWord8 s5935 = s3334 ? s5921 : s5934; const SBool s5936 = (SBool) ((s3415 >> 0) & 1); const SBool s5937 = false != s5936; const SBool s5938 = (SBool) ((s3411 >> 0) & 1); const SBool s5939 = false != s5938; const SBool s5940 = (SBool) ((s3404 >> 0) & 1); const SBool s5941 = false != s5940; const SWord8 s5942 = s5941 ? s5907 : s5908; const SWord8 s5943 = (s5942 >> 1) | (s5942 << 7); const SWord8 s5944 = 128 | s5943; const SWord8 s5945 = 127 & s5943; const SWord8 s5946 = s5939 ? s5944 : s5945; const SWord8 s5947 = (s5946 >> 1) | (s5946 << 7); const SWord8 s5948 = 128 | s5947; const SWord8 s5949 = 127 & s5947; const SWord8 s5950 = s5937 ? s5948 : s5949; const SBool s5951 = (SBool) ((s3420 >> 0) & 1); const SBool s5952 = false != s5951; const SWord8 s5953 = s5952 ? s5948 : s5949; const SWord8 s5954 = s3356 ? s5950 : s5953; const SBool s5955 = (SBool) ((s3436 >> 0) & 1); const SBool s5956 = false != s5955; const SBool s5957 = (SBool) ((s3429 >> 0) & 1); const SBool s5958 = false != s5957; const SWord8 s5959 = s5958 ? s5944 : s5945; const SWord8 s5960 = (s5959 >> 1) | (s5959 << 7); const SWord8 s5961 = 128 | s5960; const SWord8 s5962 = 127 & s5960; const SWord8 s5963 = s5956 ? s5961 : s5962; const SBool s5964 = (SBool) ((s3441 >> 0) & 1); const SBool s5965 = false != s5964; const SWord8 s5966 = s5965 ? s5961 : s5962; const SWord8 s5967 = s3356 ? s5963 : s5966; const SWord8 s5968 = s3334 ? s5954 : s5967; const SWord8 s5969 = s3082 ? s5935 : s5968; const SBool s5970 = (SBool) ((s3476 >> 0) & 1); const SBool s5971 = false != s5970; const SBool s5972 = (SBool) ((s3472 >> 0) & 1); const SBool s5973 = false != s5972; const SBool s5974 = (SBool) ((s3468 >> 0) & 1); const SBool s5975 = false != s5974; const SWord8 s5976 = (s3455 >> 1) | (s3455 << 7); const SWord8 s5977 = 128 | s5976; const SWord8 s5978 = 127 & s5976; const SWord8 s5979 = s5975 ? s5977 : s5978; const SWord8 s5980 = (s5979 >> 1) | (s5979 << 7); const SWord8 s5981 = 128 | s5980; const SWord8 s5982 = 127 & s5980; const SWord8 s5983 = s5973 ? s5981 : s5982; const SWord8 s5984 = (s5983 >> 1) | (s5983 << 7); const SWord8 s5985 = 128 | s5984; const SWord8 s5986 = 127 & s5984; const SWord8 s5987 = s5971 ? s5985 : s5986; const SBool s5988 = (SBool) ((s3481 >> 0) & 1); const SBool s5989 = false != s5988; const SWord8 s5990 = s5989 ? s5985 : s5986; const SWord8 s5991 = s3461 ? s5987 : s5990; const SBool s5992 = (SBool) ((s3497 >> 0) & 1); const SBool s5993 = false != s5992; const SBool s5994 = (SBool) ((s3490 >> 0) & 1); const SBool s5995 = false != s5994; const SWord8 s5996 = s5995 ? s5981 : s5982; const SWord8 s5997 = (s5996 >> 1) | (s5996 << 7); const SWord8 s5998 = 128 | s5997; const SWord8 s5999 = 127 & s5997; const SWord8 s6000 = s5993 ? s5998 : s5999; const SBool s6001 = (SBool) ((s3502 >> 0) & 1); const SBool s6002 = false != s6001; const SWord8 s6003 = s6002 ? s5998 : s5999; const SWord8 s6004 = s3461 ? s6000 : s6003; const SWord8 s6005 = s3334 ? s5991 : s6004; const SBool s6006 = (SBool) ((s3523 >> 0) & 1); const SBool s6007 = false != s6006; const SBool s6008 = (SBool) ((s3519 >> 0) & 1); const SBool s6009 = false != s6008; const SBool s6010 = (SBool) ((s3512 >> 0) & 1); const SBool s6011 = false != s6010; const SWord8 s6012 = s6011 ? s5977 : s5978; const SWord8 s6013 = (s6012 >> 1) | (s6012 << 7); const SWord8 s6014 = 128 | s6013; const SWord8 s6015 = 127 & s6013; const SWord8 s6016 = s6009 ? s6014 : s6015; const SWord8 s6017 = (s6016 >> 1) | (s6016 << 7); const SWord8 s6018 = 128 | s6017; const SWord8 s6019 = 127 & s6017; const SWord8 s6020 = s6007 ? s6018 : s6019; const SBool s6021 = (SBool) ((s3528 >> 0) & 1); const SBool s6022 = false != s6021; const SWord8 s6023 = s6022 ? s6018 : s6019; const SWord8 s6024 = s3461 ? s6020 : s6023; const SBool s6025 = (SBool) ((s3544 >> 0) & 1); const SBool s6026 = false != s6025; const SBool s6027 = (SBool) ((s3537 >> 0) & 1); const SBool s6028 = false != s6027; const SWord8 s6029 = s6028 ? s6014 : s6015; const SWord8 s6030 = (s6029 >> 1) | (s6029 << 7); const SWord8 s6031 = 128 | s6030; const SWord8 s6032 = 127 & s6030; const SWord8 s6033 = s6026 ? s6031 : s6032; const SBool s6034 = (SBool) ((s3549 >> 0) & 1); const SBool s6035 = false != s6034; const SWord8 s6036 = s6035 ? s6031 : s6032; const SWord8 s6037 = s3461 ? s6033 : s6036; const SWord8 s6038 = s3334 ? s6024 : s6037; const SWord8 s6039 = s3082 ? s6005 : s6038; const SWord8 s6040 = s3060 ? s5969 : s6039; const SWord8 s6041 = s2042 ? s5899 : s6040; const SBool s6042 = (SBool) ((s3624 >> 0) & 1); const SBool s6043 = false != s6042; const SBool s6044 = (SBool) ((s3620 >> 0) & 1); const SBool s6045 = false != s6044; const SBool s6046 = (SBool) ((s3616 >> 0) & 1); const SBool s6047 = false != s6046; const SWord8 s6048 = (s3603 >> 1) | (s3603 << 7); const SWord8 s6049 = 128 | s6048; const SWord8 s6050 = 127 & s6048; const SWord8 s6051 = s6047 ? s6049 : s6050; const SWord8 s6052 = (s6051 >> 1) | (s6051 << 7); const SWord8 s6053 = 128 | s6052; const SWord8 s6054 = 127 & s6052; const SWord8 s6055 = s6045 ? s6053 : s6054; const SWord8 s6056 = (s6055 >> 1) | (s6055 << 7); const SWord8 s6057 = 128 | s6056; const SWord8 s6058 = 127 & s6056; const SWord8 s6059 = s6043 ? s6057 : s6058; const SBool s6060 = (SBool) ((s3629 >> 0) & 1); const SBool s6061 = false != s6060; const SWord8 s6062 = s6061 ? s6057 : s6058; const SWord8 s6063 = s3612 ? s6059 : s6062; const SBool s6064 = (SBool) ((s3645 >> 0) & 1); const SBool s6065 = false != s6064; const SBool s6066 = (SBool) ((s3638 >> 0) & 1); const SBool s6067 = false != s6066; const SWord8 s6068 = s6067 ? s6053 : s6054; const SWord8 s6069 = (s6068 >> 1) | (s6068 << 7); const SWord8 s6070 = 128 | s6069; const SWord8 s6071 = 127 & s6069; const SWord8 s6072 = s6065 ? s6070 : s6071; const SBool s6073 = (SBool) ((s3650 >> 0) & 1); const SBool s6074 = false != s6073; const SWord8 s6075 = s6074 ? s6070 : s6071; const SWord8 s6076 = s3612 ? s6072 : s6075; const SWord8 s6077 = s3593 ? s6063 : s6076; const SBool s6078 = (SBool) ((s3671 >> 0) & 1); const SBool s6079 = false != s6078; const SBool s6080 = (SBool) ((s3667 >> 0) & 1); const SBool s6081 = false != s6080; const SBool s6082 = (SBool) ((s3660 >> 0) & 1); const SBool s6083 = false != s6082; const SWord8 s6084 = s6083 ? s6049 : s6050; const SWord8 s6085 = (s6084 >> 1) | (s6084 << 7); const SWord8 s6086 = 128 | s6085; const SWord8 s6087 = 127 & s6085; const SWord8 s6088 = s6081 ? s6086 : s6087; const SWord8 s6089 = (s6088 >> 1) | (s6088 << 7); const SWord8 s6090 = 128 | s6089; const SWord8 s6091 = 127 & s6089; const SWord8 s6092 = s6079 ? s6090 : s6091; const SBool s6093 = (SBool) ((s3676 >> 0) & 1); const SBool s6094 = false != s6093; const SWord8 s6095 = s6094 ? s6090 : s6091; const SWord8 s6096 = s3612 ? s6092 : s6095; const SBool s6097 = (SBool) ((s3692 >> 0) & 1); const SBool s6098 = false != s6097; const SBool s6099 = (SBool) ((s3685 >> 0) & 1); const SBool s6100 = false != s6099; const SWord8 s6101 = s6100 ? s6086 : s6087; const SWord8 s6102 = (s6101 >> 1) | (s6101 << 7); const SWord8 s6103 = 128 | s6102; const SWord8 s6104 = 127 & s6102; const SWord8 s6105 = s6098 ? s6103 : s6104; const SBool s6106 = (SBool) ((s3697 >> 0) & 1); const SBool s6107 = false != s6106; const SWord8 s6108 = s6107 ? s6103 : s6104; const SWord8 s6109 = s3612 ? s6105 : s6108; const SWord8 s6110 = s3593 ? s6096 : s6109; const SWord8 s6111 = s3571 ? s6077 : s6110; const SBool s6112 = (SBool) ((s3732 >> 0) & 1); const SBool s6113 = false != s6112; const SBool s6114 = (SBool) ((s3728 >> 0) & 1); const SBool s6115 = false != s6114; const SBool s6116 = (SBool) ((s3724 >> 0) & 1); const SBool s6117 = false != s6116; const SWord8 s6118 = (s3711 >> 1) | (s3711 << 7); const SWord8 s6119 = 128 | s6118; const SWord8 s6120 = 127 & s6118; const SWord8 s6121 = s6117 ? s6119 : s6120; const SWord8 s6122 = (s6121 >> 1) | (s6121 << 7); const SWord8 s6123 = 128 | s6122; const SWord8 s6124 = 127 & s6122; const SWord8 s6125 = s6115 ? s6123 : s6124; const SWord8 s6126 = (s6125 >> 1) | (s6125 << 7); const SWord8 s6127 = 128 | s6126; const SWord8 s6128 = 127 & s6126; const SWord8 s6129 = s6113 ? s6127 : s6128; const SBool s6130 = (SBool) ((s3737 >> 0) & 1); const SBool s6131 = false != s6130; const SWord8 s6132 = s6131 ? s6127 : s6128; const SWord8 s6133 = s3717 ? s6129 : s6132; const SBool s6134 = (SBool) ((s3753 >> 0) & 1); const SBool s6135 = false != s6134; const SBool s6136 = (SBool) ((s3746 >> 0) & 1); const SBool s6137 = false != s6136; const SWord8 s6138 = s6137 ? s6123 : s6124; const SWord8 s6139 = (s6138 >> 1) | (s6138 << 7); const SWord8 s6140 = 128 | s6139; const SWord8 s6141 = 127 & s6139; const SWord8 s6142 = s6135 ? s6140 : s6141; const SBool s6143 = (SBool) ((s3758 >> 0) & 1); const SBool s6144 = false != s6143; const SWord8 s6145 = s6144 ? s6140 : s6141; const SWord8 s6146 = s3717 ? s6142 : s6145; const SWord8 s6147 = s3593 ? s6133 : s6146; const SBool s6148 = (SBool) ((s3779 >> 0) & 1); const SBool s6149 = false != s6148; const SBool s6150 = (SBool) ((s3775 >> 0) & 1); const SBool s6151 = false != s6150; const SBool s6152 = (SBool) ((s3768 >> 0) & 1); const SBool s6153 = false != s6152; const SWord8 s6154 = s6153 ? s6119 : s6120; const SWord8 s6155 = (s6154 >> 1) | (s6154 << 7); const SWord8 s6156 = 128 | s6155; const SWord8 s6157 = 127 & s6155; const SWord8 s6158 = s6151 ? s6156 : s6157; const SWord8 s6159 = (s6158 >> 1) | (s6158 << 7); const SWord8 s6160 = 128 | s6159; const SWord8 s6161 = 127 & s6159; const SWord8 s6162 = s6149 ? s6160 : s6161; const SBool s6163 = (SBool) ((s3784 >> 0) & 1); const SBool s6164 = false != s6163; const SWord8 s6165 = s6164 ? s6160 : s6161; const SWord8 s6166 = s3717 ? s6162 : s6165; const SBool s6167 = (SBool) ((s3800 >> 0) & 1); const SBool s6168 = false != s6167; const SBool s6169 = (SBool) ((s3793 >> 0) & 1); const SBool s6170 = false != s6169; const SWord8 s6171 = s6170 ? s6156 : s6157; const SWord8 s6172 = (s6171 >> 1) | (s6171 << 7); const SWord8 s6173 = 128 | s6172; const SWord8 s6174 = 127 & s6172; const SWord8 s6175 = s6168 ? s6173 : s6174; const SBool s6176 = (SBool) ((s3805 >> 0) & 1); const SBool s6177 = false != s6176; const SWord8 s6178 = s6177 ? s6173 : s6174; const SWord8 s6179 = s3717 ? s6175 : s6178; const SWord8 s6180 = s3593 ? s6166 : s6179; const SWord8 s6181 = s3571 ? s6147 : s6180; const SWord8 s6182 = s3060 ? s6111 : s6181; const SBool s6183 = (SBool) ((s3860 >> 0) & 1); const SBool s6184 = false != s6183; const SBool s6185 = (SBool) ((s3856 >> 0) & 1); const SBool s6186 = false != s6185; const SBool s6187 = (SBool) ((s3852 >> 0) & 1); const SBool s6188 = false != s6187; const SWord8 s6189 = (s3839 >> 1) | (s3839 << 7); const SWord8 s6190 = 128 | s6189; const SWord8 s6191 = 127 & s6189; const SWord8 s6192 = s6188 ? s6190 : s6191; const SWord8 s6193 = (s6192 >> 1) | (s6192 << 7); const SWord8 s6194 = 128 | s6193; const SWord8 s6195 = 127 & s6193; const SWord8 s6196 = s6186 ? s6194 : s6195; const SWord8 s6197 = (s6196 >> 1) | (s6196 << 7); const SWord8 s6198 = 128 | s6197; const SWord8 s6199 = 127 & s6197; const SWord8 s6200 = s6184 ? s6198 : s6199; const SBool s6201 = (SBool) ((s3865 >> 0) & 1); const SBool s6202 = false != s6201; const SWord8 s6203 = s6202 ? s6198 : s6199; const SWord8 s6204 = s3848 ? s6200 : s6203; const SBool s6205 = (SBool) ((s3881 >> 0) & 1); const SBool s6206 = false != s6205; const SBool s6207 = (SBool) ((s3874 >> 0) & 1); const SBool s6208 = false != s6207; const SWord8 s6209 = s6208 ? s6194 : s6195; const SWord8 s6210 = (s6209 >> 1) | (s6209 << 7); const SWord8 s6211 = 128 | s6210; const SWord8 s6212 = 127 & s6210; const SWord8 s6213 = s6206 ? s6211 : s6212; const SBool s6214 = (SBool) ((s3886 >> 0) & 1); const SBool s6215 = false != s6214; const SWord8 s6216 = s6215 ? s6211 : s6212; const SWord8 s6217 = s3848 ? s6213 : s6216; const SWord8 s6218 = s3826 ? s6204 : s6217; const SBool s6219 = (SBool) ((s3907 >> 0) & 1); const SBool s6220 = false != s6219; const SBool s6221 = (SBool) ((s3903 >> 0) & 1); const SBool s6222 = false != s6221; const SBool s6223 = (SBool) ((s3896 >> 0) & 1); const SBool s6224 = false != s6223; const SWord8 s6225 = s6224 ? s6190 : s6191; const SWord8 s6226 = (s6225 >> 1) | (s6225 << 7); const SWord8 s6227 = 128 | s6226; const SWord8 s6228 = 127 & s6226; const SWord8 s6229 = s6222 ? s6227 : s6228; const SWord8 s6230 = (s6229 >> 1) | (s6229 << 7); const SWord8 s6231 = 128 | s6230; const SWord8 s6232 = 127 & s6230; const SWord8 s6233 = s6220 ? s6231 : s6232; const SBool s6234 = (SBool) ((s3912 >> 0) & 1); const SBool s6235 = false != s6234; const SWord8 s6236 = s6235 ? s6231 : s6232; const SWord8 s6237 = s3848 ? s6233 : s6236; const SBool s6238 = (SBool) ((s3928 >> 0) & 1); const SBool s6239 = false != s6238; const SBool s6240 = (SBool) ((s3921 >> 0) & 1); const SBool s6241 = false != s6240; const SWord8 s6242 = s6241 ? s6227 : s6228; const SWord8 s6243 = (s6242 >> 1) | (s6242 << 7); const SWord8 s6244 = 128 | s6243; const SWord8 s6245 = 127 & s6243; const SWord8 s6246 = s6239 ? s6244 : s6245; const SBool s6247 = (SBool) ((s3933 >> 0) & 1); const SBool s6248 = false != s6247; const SWord8 s6249 = s6248 ? s6244 : s6245; const SWord8 s6250 = s3848 ? s6246 : s6249; const SWord8 s6251 = s3826 ? s6237 : s6250; const SWord8 s6252 = s3571 ? s6218 : s6251; const SBool s6253 = (SBool) ((s3968 >> 0) & 1); const SBool s6254 = false != s6253; const SBool s6255 = (SBool) ((s3964 >> 0) & 1); const SBool s6256 = false != s6255; const SBool s6257 = (SBool) ((s3960 >> 0) & 1); const SBool s6258 = false != s6257; const SWord8 s6259 = (s3947 >> 1) | (s3947 << 7); const SWord8 s6260 = 128 | s6259; const SWord8 s6261 = 127 & s6259; const SWord8 s6262 = s6258 ? s6260 : s6261; const SWord8 s6263 = (s6262 >> 1) | (s6262 << 7); const SWord8 s6264 = 128 | s6263; const SWord8 s6265 = 127 & s6263; const SWord8 s6266 = s6256 ? s6264 : s6265; const SWord8 s6267 = (s6266 >> 1) | (s6266 << 7); const SWord8 s6268 = 128 | s6267; const SWord8 s6269 = 127 & s6267; const SWord8 s6270 = s6254 ? s6268 : s6269; const SBool s6271 = (SBool) ((s3973 >> 0) & 1); const SBool s6272 = false != s6271; const SWord8 s6273 = s6272 ? s6268 : s6269; const SWord8 s6274 = s3953 ? s6270 : s6273; const SBool s6275 = (SBool) ((s3989 >> 0) & 1); const SBool s6276 = false != s6275; const SBool s6277 = (SBool) ((s3982 >> 0) & 1); const SBool s6278 = false != s6277; const SWord8 s6279 = s6278 ? s6264 : s6265; const SWord8 s6280 = (s6279 >> 1) | (s6279 << 7); const SWord8 s6281 = 128 | s6280; const SWord8 s6282 = 127 & s6280; const SWord8 s6283 = s6276 ? s6281 : s6282; const SBool s6284 = (SBool) ((s3994 >> 0) & 1); const SBool s6285 = false != s6284; const SWord8 s6286 = s6285 ? s6281 : s6282; const SWord8 s6287 = s3953 ? s6283 : s6286; const SWord8 s6288 = s3826 ? s6274 : s6287; const SBool s6289 = (SBool) ((s4015 >> 0) & 1); const SBool s6290 = false != s6289; const SBool s6291 = (SBool) ((s4011 >> 0) & 1); const SBool s6292 = false != s6291; const SBool s6293 = (SBool) ((s4004 >> 0) & 1); const SBool s6294 = false != s6293; const SWord8 s6295 = s6294 ? s6260 : s6261; const SWord8 s6296 = (s6295 >> 1) | (s6295 << 7); const SWord8 s6297 = 128 | s6296; const SWord8 s6298 = 127 & s6296; const SWord8 s6299 = s6292 ? s6297 : s6298; const SWord8 s6300 = (s6299 >> 1) | (s6299 << 7); const SWord8 s6301 = 128 | s6300; const SWord8 s6302 = 127 & s6300; const SWord8 s6303 = s6290 ? s6301 : s6302; const SBool s6304 = (SBool) ((s4020 >> 0) & 1); const SBool s6305 = false != s6304; const SWord8 s6306 = s6305 ? s6301 : s6302; const SWord8 s6307 = s3953 ? s6303 : s6306; const SBool s6308 = (SBool) ((s4036 >> 0) & 1); const SBool s6309 = false != s6308; const SBool s6310 = (SBool) ((s4029 >> 0) & 1); const SBool s6311 = false != s6310; const SWord8 s6312 = s6311 ? s6297 : s6298; const SWord8 s6313 = (s6312 >> 1) | (s6312 << 7); const SWord8 s6314 = 128 | s6313; const SWord8 s6315 = 127 & s6313; const SWord8 s6316 = s6309 ? s6314 : s6315; const SBool s6317 = (SBool) ((s4041 >> 0) & 1); const SBool s6318 = false != s6317; const SWord8 s6319 = s6318 ? s6314 : s6315; const SWord8 s6320 = s3953 ? s6316 : s6319; const SWord8 s6321 = s3826 ? s6307 : s6320; const SWord8 s6322 = s3571 ? s6288 : s6321; const SWord8 s6323 = s3060 ? s6252 : s6322; const SWord8 s6324 = s2042 ? s6182 : s6323; const SWord8 s6325 = s16 ? s6041 : s6324; const SWord8 s6326 = s11 ? s5758 : s6325; const SWord8 s6327 = s5 ? s5191 : s6326; *hi = s4056; *lo = s6327; } == END: "legatoMult.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/merge.gold0000644000000000000000000000746012725411266016406 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for merge. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: merge_driver merge.o: merge.c merge.h ${CC} ${CCFLAGS} -c $< -o $@ merge_driver.o: merge_driver.c ${CC} ${CCFLAGS} -c $< -o $@ merge_driver: merge.o merge_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f merge_driver == END: "Makefile" ================== == BEGIN: "merge.h" ================ /* Header file for merge. Automatically generated by SBV. Do not edit! */ #ifndef __merge__HEADER_INCLUDED__ #define __merge__HEADER_INCLUDED__ #include #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 merge(const SWord8 *xs, SWord8 *ys); #endif /* __merge__HEADER_INCLUDED__ */ == END: "merge.h" ================== == BEGIN: "merge_driver.c" ================ /* Example driver program for merge. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "merge.h" int main(void) { const SWord8 xs[5] = { 10, 6, 4, 82, 71 }; printf("Contents of input array xs:\n"); int xs_ctr; for(xs_ctr = 0; xs_ctr < 5 ; ++xs_ctr) printf(" xs[%d] = %"PRIu8"\n", xs_ctr ,xs[xs_ctr]); SWord8 ys[5]; merge(xs, ys); printf("merge(xs, ys) ->\n"); int ys_ctr; for(ys_ctr = 0; ys_ctr < 5 ; ++ys_ctr) printf(" ys[%d] = %"PRIu8"\n", ys_ctr ,ys[ys_ctr]); return 0; } == END: "merge_driver.c" ================== == BEGIN: "merge.c" ================ /* File: "merge.c". Automatically generated by SBV. Do not edit! */ #include "merge.h" void merge(const SWord8 *xs, SWord8 *ys) { const SWord8 s0 = xs[0]; const SWord8 s1 = xs[1]; const SWord8 s2 = xs[2]; const SWord8 s3 = xs[3]; const SWord8 s4 = xs[4]; const SBool s5 = s0 < s1; const SWord8 s6 = s5 ? s0 : s1; const SBool s7 = s3 < s4; const SWord8 s8 = s7 ? s3 : s4; const SBool s9 = s2 < s8; const SWord8 s10 = s9 ? s2 : s8; const SBool s11 = s6 < s10; const SWord8 s12 = s11 ? s6 : s10; const SWord8 s13 = s5 ? s1 : s0; const SBool s14 = s13 < s10; const SWord8 s15 = s14 ? s13 : s10; const SWord8 s16 = s7 ? s4 : s3; const SBool s17 = s2 < s16; const SWord8 s18 = s17 ? s2 : s16; const SWord8 s19 = s9 ? s8 : s18; const SBool s20 = s6 < s19; const SWord8 s21 = s20 ? s6 : s19; const SWord8 s22 = s11 ? s15 : s21; const SBool s23 = s13 < s19; const SWord8 s24 = s23 ? s13 : s19; const SWord8 s25 = s14 ? s10 : s24; const SWord8 s26 = s17 ? s16 : s2; const SWord8 s27 = s9 ? s16 : s26; const SBool s28 = s6 < s27; const SWord8 s29 = s28 ? s6 : s27; const SWord8 s30 = s20 ? s24 : s29; const SWord8 s31 = s11 ? s25 : s30; const SBool s32 = s13 < s27; const SWord8 s33 = s32 ? s13 : s27; const SWord8 s34 = s23 ? s19 : s33; const SWord8 s35 = s14 ? s19 : s34; const SWord8 s36 = s28 ? s33 : s6; const SWord8 s37 = s20 ? s34 : s36; const SWord8 s38 = s11 ? s35 : s37; const SWord8 s39 = s32 ? s27 : s13; const SWord8 s40 = s23 ? s27 : s39; const SWord8 s41 = s14 ? s27 : s40; const SWord8 s42 = s28 ? s39 : s13; const SWord8 s43 = s20 ? s40 : s42; const SWord8 s44 = s11 ? s41 : s43; ys[0] = s12; ys[1] = s22; ys[2] = s31; ys[3] = s38; ys[4] = s44; } == END: "merge.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/popCount1.gold0000644000000000000000000001001712725411266017167 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for popCount. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: popCount_driver popCount.o: popCount.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver.o: popCount_driver.c ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver: popCount.o popCount_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f popCount_driver == END: "Makefile" ================== == BEGIN: "popCount.h" ================ /* Header file for popCount. Automatically generated by SBV. Do not edit! */ #ifndef __popCount__HEADER_INCLUDED__ #define __popCount__HEADER_INCLUDED__ #include #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: */ SWord8 popCount(const SWord64 x); #endif /* __popCount__HEADER_INCLUDED__ */ == END: "popCount.h" ================== == BEGIN: "popCount_driver.c" ================ /* Example driver program for popCount. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "popCount.h" int main(void) { const SWord8 __result = popCount(0x0123456789abcdefULL); printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result); return 0; } == END: "popCount_driver.c" ================== == BEGIN: "popCount.c" ================ /* File: "popCount.c". Automatically generated by SBV. Do not edit! */ #include "popCount.h" SWord8 popCount(const SWord64 x) { const SWord64 s0 = x; static const SWord8 table0[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; const SWord64 s11 = s0 & 0x00000000000000ffULL; const SWord8 s12 = table0[s11]; const SWord64 s13 = s0 >> 8; const SWord64 s14 = 0x00000000000000ffULL & s13; const SWord8 s15 = table0[s14]; const SWord8 s16 = s12 + s15; const SWord64 s17 = s13 >> 8; const SWord64 s18 = 0x00000000000000ffULL & s17; const SWord8 s19 = table0[s18]; const SWord8 s20 = s16 + s19; const SWord64 s21 = s17 >> 8; const SWord64 s22 = 0x00000000000000ffULL & s21; const SWord8 s23 = table0[s22]; const SWord8 s24 = s20 + s23; const SWord64 s25 = s21 >> 8; const SWord64 s26 = 0x00000000000000ffULL & s25; const SWord8 s27 = table0[s26]; const SWord8 s28 = s24 + s27; const SWord64 s29 = s25 >> 8; const SWord64 s30 = 0x00000000000000ffULL & s29; const SWord8 s31 = table0[s30]; const SWord8 s32 = s28 + s31; const SWord64 s33 = s29 >> 8; const SWord64 s34 = 0x00000000000000ffULL & s33; const SWord8 s35 = table0[s34]; const SWord8 s36 = s32 + s35; const SWord64 s37 = s33 >> 8; const SWord64 s38 = 0x00000000000000ffULL & s37; const SWord8 s39 = table0[s38]; const SWord8 s40 = s36 + s39; return s40; } == END: "popCount.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/popCount2.gold0000644000000000000000000001022712725411266017173 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for popCount. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: popCount_driver popCount.o: popCount.c popCount.h ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver.o: popCount_driver.c ${CC} ${CCFLAGS} -c $< -o $@ popCount_driver: popCount.o popCount_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f popCount_driver == END: "Makefile" ================== == BEGIN: "popCount.h" ================ /* Header file for popCount. Automatically generated by SBV. Do not edit! */ #ifndef __popCount__HEADER_INCLUDED__ #define __popCount__HEADER_INCLUDED__ #include #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: */ SWord8 popCount(const SWord64 x); #endif /* __popCount__HEADER_INCLUDED__ */ == END: "popCount.h" ================== == BEGIN: "popCount_driver.c" ================ /* Example driver program for popCount. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "popCount.h" int main(void) { const SWord8 __result = popCount(0x0123456789abcdefULL); printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result); return 0; } == END: "popCount_driver.c" ================== == BEGIN: "popCount.c" ================ /* File: "popCount.c". Automatically generated by SBV. Do not edit! */ #include "popCount.h" SWord8 popCount(const SWord64 x) { const SWord64 s0 = x; static const SWord8 table0[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; const SWord64 s11 = s0 & 0x00000000000000ffULL; const SWord8 s12 = s11 >= 256 ? 0 : table0[s11]; const SWord64 s13 = s0 >> 8; const SWord64 s14 = 0x00000000000000ffULL & s13; const SWord8 s15 = s14 >= 256 ? 0 : table0[s14]; const SWord8 s16 = s12 + s15; const SWord64 s17 = s13 >> 8; const SWord64 s18 = 0x00000000000000ffULL & s17; const SWord8 s19 = s18 >= 256 ? 0 : table0[s18]; const SWord8 s20 = s16 + s19; const SWord64 s21 = s17 >> 8; const SWord64 s22 = 0x00000000000000ffULL & s21; const SWord8 s23 = s22 >= 256 ? 0 : table0[s22]; const SWord8 s24 = s20 + s23; const SWord64 s25 = s21 >> 8; const SWord64 s26 = 0x00000000000000ffULL & s25; const SWord8 s27 = s26 >= 256 ? 0 : table0[s26]; const SWord8 s28 = s24 + s27; const SWord64 s29 = s25 >> 8; const SWord64 s30 = 0x00000000000000ffULL & s29; const SWord8 s31 = s30 >= 256 ? 0 : table0[s30]; const SWord8 s32 = s28 + s31; const SWord64 s33 = s29 >> 8; const SWord64 s34 = 0x00000000000000ffULL & s33; const SWord8 s35 = s34 >= 256 ? 0 : table0[s34]; const SWord8 s36 = s32 + s35; const SWord64 s37 = s33 >> 8; const SWord64 s38 = 0x00000000000000ffULL & s37; const SWord8 s39 = s38 >= 256 ? 0 : table0[s38]; const SWord8 s40 = s36 + s39; return s40; } == END: "popCount.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/selChecked.gold0000644000000000000000000000426312725411266017337 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for selChecked. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: selChecked_driver selChecked.o: selChecked.c selChecked.h ${CC} ${CCFLAGS} -c $< -o $@ selChecked_driver.o: selChecked_driver.c ${CC} ${CCFLAGS} -c $< -o $@ selChecked_driver: selChecked.o selChecked_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f selChecked_driver == END: "Makefile" ================== == BEGIN: "selChecked.h" ================ /* Header file for selChecked. Automatically generated by SBV. Do not edit! */ #ifndef __selChecked__HEADER_INCLUDED__ #define __selChecked__HEADER_INCLUDED__ #include #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: */ SWord8 selChecked(const SWord8 x); #endif /* __selChecked__HEADER_INCLUDED__ */ == END: "selChecked.h" ================== == BEGIN: "selChecked_driver.c" ================ /* Example driver program for selChecked. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "selChecked.h" int main(void) { const SWord8 __result = selChecked(65); printf("selChecked(65) = %"PRIu8"\n", __result); return 0; } == END: "selChecked_driver.c" ================== == BEGIN: "selChecked.c" ================ /* File: "selChecked.c". Automatically generated by SBV. Do not edit! */ #include "selChecked.h" SWord8 selChecked(const SWord8 x) { const SWord8 s0 = x; const SWord8 s3 = s0 + 2; const SWord8 table0[] = { 1, s3 }; const SWord8 s5 = s0 >= 2 ? 3 : table0[s0]; return s5; } == END: "selChecked.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/selUnchecked.gold0000644000000000000000000000433712725411266017704 0ustar0000000000000000== BEGIN: "Makefile" ================ # Makefile for selUnChecked. Automatically generated by SBV. Do not edit! # include any user-defined .mk file in the current directory. -include *.mk CC?=gcc CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer all: selUnChecked_driver selUnChecked.o: selUnChecked.c selUnChecked.h ${CC} ${CCFLAGS} -c $< -o $@ selUnChecked_driver.o: selUnChecked_driver.c ${CC} ${CCFLAGS} -c $< -o $@ selUnChecked_driver: selUnChecked.o selUnChecked_driver.o ${CC} ${CCFLAGS} $^ -o $@ clean: rm -f *.o veryclean: clean rm -f selUnChecked_driver == END: "Makefile" ================== == BEGIN: "selUnChecked.h" ================ /* Header file for selUnChecked. Automatically generated by SBV. Do not edit! */ #ifndef __selUnChecked__HEADER_INCLUDED__ #define __selUnChecked__HEADER_INCLUDED__ #include #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: */ SWord8 selUnChecked(const SWord8 x); #endif /* __selUnChecked__HEADER_INCLUDED__ */ == END: "selUnChecked.h" ================== == BEGIN: "selUnChecked_driver.c" ================ /* Example driver program for selUnChecked. */ /* Automatically generated by SBV. Edit as you see fit! */ #include #include "selUnChecked.h" int main(void) { const SWord8 __result = selUnChecked(65); printf("selUnChecked(65) = %"PRIu8"\n", __result); return 0; } == END: "selUnChecked_driver.c" ================== == BEGIN: "selUnChecked.c" ================ /* File: "selUnChecked.c". Automatically generated by SBV. Do not edit! */ #include "selUnChecked.h" SWord8 selUnChecked(const SWord8 x) { const SWord8 s0 = x; const SWord8 s3 = s0 + 2; const SWord8 table0[] = { 1, s3 }; const SWord8 s5 = table0[s0]; return s5; } == END: "selUnChecked.c" ==================sbv-5.12/SBVUnitTest/GoldFiles/temperature.gold0000644000000000000000000000014012725411266017630 0ustar0000000000000000Solution #1: s0 = 16 :: Integer Solution #2: s0 = 28 :: Integer Found 2 different solutions.sbv-5.12/SBVUnitTest/GoldFiles/U2Bridge.gold0000644000000000000000000000060512725411266016704 0ustar0000000000000000Satisfiable. Model: s0 = False :: Bool s1 = Edge :: U2Member s2 = Bono :: U2Member s3 = True :: Bool s4 = Bono :: U2Member s5 = Bono :: U2Member s6 = False :: Bool s7 = Larry :: U2Member s8 = Adam :: U2Member s9 = True :: Bool s10 = Edge :: U2Member s11 = Bono :: U2Member s12 = False :: Bool s13 = Edge :: U2Member s14 = Bono :: U2Membersbv-5.12/SBVUnitTest/TestSuite/0000755000000000000000000000000012725411265014511 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Arrays/0000755000000000000000000000000012725411266015753 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Arrays/Memory.hs0000644000000000000000000000257612725411266017571 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Arrays.Memory -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Arrays.Memory ----------------------------------------------------------------------------- module TestSuite.Arrays.Memory(testSuite) where import Examples.Arrays.Memory import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "memory-raw" ~: assert =<< isThm t1 , "memory-waw" ~: assert =<< isThm t2 , "memory-wcommute-good" ~: assert =<< isThm t3 , "memory-wcommute-bad" ~: assert . not =<< isThm t4 ] where t1 = free "a" >>= \a -> free "x" >>= \x -> newArray "m" Nothing >>= return . raw a x t2 = free "a" >>= \a -> free "x" >>= \x -> free "y" >>= \y -> newArray "m" Nothing >>= return . waw a x y t3 = free "a" >>= \a -> free "x" >>= \x -> free "b" >>= \b -> free "y" >>= \y -> newArray "m" Nothing >>= return . wcommutesGood (a, x) (b, y) t4 = free "a" >>= \a -> free "x" >>= \x -> free "b" >>= \b -> free "y" >>= \y -> newArray "m" Nothing >>= return . wcommutesBad (a, x) (b, y) {-# ANN module ("HLint: ignore Use fmap" :: String) #-} sbv-5.12/SBVUnitTest/TestSuite/Basics/0000755000000000000000000000000012725411266015716 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Basics/ArithNoSolver.hs0000644000000000000000000010463012725411266021015 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.ArithNoSolver -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for basic concrete arithmetic, i.e., testing all -- the constant folding based arithmetic implementation in SBV ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE TupleSections #-} module TestSuite.Basics.ArithNoSolver(testSuite) where import Data.SBV import Data.SBV.Internals import Data.Maybe(fromJust, fromMaybe) import SBVTest import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord) ghcBitSize :: Bits a => a -> Int ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x) -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test $ genReals ++ genFloats ++ genQRems ++ genBinTest "+" (+) ++ genBinTest "-" (-) ++ genBinTest "*" (*) ++ genUnTest "negate" negate ++ genUnTest "abs" abs ++ genUnTest "signum" signum ++ genBinTest ".&." (.&.) ++ genBinTest ".|." (.|.) ++ genBoolTest "<" (<) (.<) ++ genBoolTest "<=" (<=) (.<=) ++ genBoolTest ">" (>) (.>) ++ genBoolTest ">=" (>=) (.>=) ++ genBoolTest "==" (==) (.==) ++ genBoolTest "/=" (/=) (./=) ++ genBinTest "xor" xor ++ genUnTest "complement" complement ++ genIntTest "shift" shift ++ genIntTest "rotate" rotate ++ genIntTestS "setBit" setBit ++ genIntTestS "clearBit" clearBit ++ genIntTestS "complementBit" complementBit ++ genIntTest "shift" shift ++ genIntTestS "shiftL" shiftL ++ genIntTestS "shiftR" shiftR ++ genIntTest "rotate" rotate ++ genIntTestS "rotateL" rotateL ++ genIntTestS "rotateR" rotateR ++ genBlasts ++ genIntCasts genBinTest :: String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [Test] genBinTest nm op = map mkTest $ zipWith pair [(show x, show y, x `op` y) | x <- w8s, y <- w8s ] [x `op` y | x <- sw8s, y <- sw8s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `op` y | x <- sw16s, y <- sw16s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `op` y | x <- sw32s, y <- sw32s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `op` y | x <- sw64s, y <- sw64s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s, y <- i8s ] [x `op` y | x <- si8s, y <- si8s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `op` y | x <- si16s, y <- si16s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `op` y | x <- si32s, y <- si32s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `op` y | x <- si64s, y <- si64s] ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `op` y | x <- siUBs, y <- siUBs] where pair (x, y, a) b = (x, y, show (fromIntegral a `asTypeOf` b) == show b) mkTest (x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y ~: s `showsAs` "True" genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [Test] genBoolTest nm op opS = map mkTest $ zipWith pair [(show x, show y, x `op` y) | x <- w8s, y <- w8s ] [x `opS` y | x <- sw8s, y <- sw8s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `opS` y | x <- sw16s, y <- sw16s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `opS` y | x <- sw32s, y <- sw32s] ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `opS` y | x <- sw64s, y <- sw64s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s, y <- i8s ] [x `opS` y | x <- si8s, y <- si8s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `opS` y | x <- si16s, y <- si16s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `opS` y | x <- si32s, y <- si32s] ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `opS` y | x <- si64s, y <- si64s] ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `opS` y | x <- siUBs, y <- siUBs] where pair (x, y, a) b = (x, y, Just a == unliteral b) mkTest (x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y ~: s `showsAs` "True" genUnTest :: String -> (forall a. (Num a, Bits a) => a -> a) -> [Test] genUnTest nm op = map mkTest $ zipWith pair [(show x, op x) | x <- w8s ] [op x | x <- sw8s ] ++ zipWith pair [(show x, op x) | x <- w16s] [op x | x <- sw16s] ++ zipWith pair [(show x, op x) | x <- w32s] [op x | x <- sw32s] ++ zipWith pair [(show x, op x) | x <- w64s] [op x | x <- sw64s] ++ zipWith pair [(show x, op x) | x <- i8s ] [op x | x <- si8s ] ++ zipWith pair [(show x, op x) | x <- i16s] [op x | x <- si16s] ++ zipWith pair [(show x, op x) | x <- i32s] [op x | x <- si32s] ++ zipWith pair [(show x, op x) | x <- i64s] [op x | x <- si64s] ++ zipWith pair [(show x, op x) | x <- iUBs] [op x | x <- siUBs] where pair (x, a) b = (x, show (fromIntegral a `asTypeOf` b) == show b) mkTest (x, s) = "arithCF-" ++ nm ++ "." ++ x ~: s `showsAs` "True" genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test] genIntTest nm op = map mkTest $ zipWith pair [("u8", show x, show y, x `op` y) | x <- w8s, y <- is] [x `op` y | x <- sw8s, y <- is] ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- is] [x `op` y | x <- sw16s, y <- is] ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- is] [x `op` y | x <- sw32s, y <- is] ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- is] [x `op` y | x <- sw64s, y <- is] ++ zipWith pair [("s8", show x, show y, x `op` y) | x <- i8s, y <- is] [x `op` y | x <- si8s, y <- is] ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- is] [x `op` y | x <- si16s, y <- is] ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- is] [x `op` y | x <- si32s, y <- is] ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- is] [x `op` y | x <- si64s, y <- is] ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- is] [x `op` y | x <- siUBs, y <- is] where pair (t, x, y, a) b = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b) mkTest (t, x, y, a, b, s) = "arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b ~: s `showsAs` "True" is = [-10 .. 10] genIntTestS :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test] genIntTestS nm op = map mkTest $ zipWith pair [("u8", show x, show y, x `op` y) | x <- w8s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw8s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw16s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw32s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw64s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("s8", show x, show y, x `op` y) | x <- i8s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si8s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si16s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si32s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si64s, y <- [0 .. (ghcBitSize x - 1)]] ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- [0 .. 10]] [x `op` y | x <- siUBs, y <- [0 .. 10 ]] where pair (t, x, y, a) b = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b) mkTest (t, x, y, a, b, s) = "arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b ~: s `showsAs` "True" genBlasts :: [Test] genBlasts = map mkTest $ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw8s ] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw8s ] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si8s ] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si8s ] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw16s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw16s] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si16s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si16s] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw32s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw32s] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si32s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si32s] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw64s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw64s] ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si64s] ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si64s] where mkTest (x, r) = "blast-" ++ x ~: r `showsAs` "True" genIntCasts :: [Test] genIntCasts = map mkTest $ cast w8s ++ cast w16s ++ cast w32s ++ cast w64s ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s ++ cast iUBs where mkTest (x, r) = "intCast-" ++ x ~: r `showsAs` "True" lhs x = sFromIntegral (literal x) rhs x = literal (fromIntegral x) cast :: forall a. (Show a, Integral a, Bits a, SymWord a) => [a] -> [(String, SBool)] cast xs = toWords xs ++ toInts xs toWords xs = [(show x, lhs x .== (rhs x :: SWord8 )) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SWord16)) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SWord32)) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SWord64)) | x <- xs] toInts xs = [(show x, lhs x .== (rhs x :: SInt8 )) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SInt16)) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SInt32)) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SInt64)) | x <- xs] ++ [(show x, lhs x .== (rhs x :: SInteger)) | x <- xs] genQRems :: [Test] genQRems = map mkTest $ zipWith pair [("divMod", show x, show y, x `divMod0` y) | x <- w8s, y <- w8s ] [x `sDivMod` y | x <- sw8s, y <- sw8s ] ++ zipWith pair [("divMod", show x, show y, x `divMod0` y) | x <- w16s, y <- w16s] [x `sDivMod` y | x <- sw16s, y <- sw16s] ++ zipWith pair [("divMod", show x, show y, x `divMod0` y) | x <- w32s, y <- w32s] [x `sDivMod` y | x <- sw32s, y <- sw32s] ++ zipWith pair [("divMod", show x, show y, x `divMod0` y) | x <- w64s, y <- w64s] [x `sDivMod` y | x <- sw64s, y <- sw64s] ++ zipWith pair [("divMod", show x, show y, x `divMod1` y) | x <- i8s, y <- i8s ] [x `sDivMod` y | x <- si8s, y <- si8s ] ++ zipWith pair [("divMod", show x, show y, x `divMod1` y) | x <- i16s, y <- i16s] [x `sDivMod` y | x <- si16s, y <- si16s] ++ zipWith pair [("divMod", show x, show y, x `divMod1` y) | x <- i32s, y <- i32s] [x `sDivMod` y | x <- si32s, y <- si32s] ++ zipWith pair [("divMod", show x, show y, x `divMod1` y) | x <- i64s, y <- i64s] [x `sDivMod` y | x <- si64s, y <- si64s] ++ zipWith pair [("divMod", show x, show y, x `divMod0` y) | x <- iUBs, y <- iUBs] [x `sDivMod` y | x <- siUBs, y <- siUBs] ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w8s, y <- w8s ] [x `sQuotRem` y | x <- sw8s, y <- sw8s ] ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w16s, y <- w16s] [x `sQuotRem` y | x <- sw16s, y <- sw16s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w32s, y <- w32s] [x `sQuotRem` y | x <- sw32s, y <- sw32s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w64s, y <- w64s] [x `sQuotRem` y | x <- sw64s, y <- sw64s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i8s, y <- i8s ] [x `sQuotRem` y | x <- si8s, y <- si8s ] ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i16s, y <- i16s] [x `sQuotRem` y | x <- si16s, y <- si16s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i32s, y <- i32s] [x `sQuotRem` y | x <- si32s, y <- si32s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i64s, y <- i64s] [x `sQuotRem` y | x <- si64s, y <- si64s] ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- iUBs, y <- iUBs] [x `sQuotRem` y | x <- siUBs, y <- siUBs] where pair (nm, x, y, (r1, r2)) (e1, e2) = (nm, x, y, show (fromIntegral r1 `asTypeOf` e1, fromIntegral r2 `asTypeOf` e2) == show (e1, e2)) mkTest (nm, x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y ~: s `showsAs` "True" -- Haskell's divMod and quotRem differs from SBV's in two ways: -- - when y is 0, Haskell throws an exception, SBV sets the result to 0; like in division -- - Haskell overflows if x == minBound and y == -1 for bounded signed types; but SBV returns minBound, 0; which is more meaningful -- NB. There was a ticket filed against the second anomaly above, See: https://ghc.haskell.org/trac/ghc/ticket/8695 -- But the Haskell folks decided not to fix it. Sigh.. overflow x y = x == minBound && y == -1 divMod0 x y = if y == 0 then (0, x) else x `divMod` y divMod1 x y = if overflow x y then (x, 0) else x `divMod0` y quotRem0 x y = if y == 0 then (0, x) else x `quotRem` y quotRem1 x y = if overflow x y then (x, 0) else x `quotRem0` y genReals :: [Test] genReals = map mkTest $ map ("+",) (zipWith pair [(show x, show y, x + y) | x <- rs, y <- rs ] [x + y | x <- srs, y <- srs ]) ++ map ("-",) (zipWith pair [(show x, show y, x - y) | x <- rs, y <- rs ] [x - y | x <- srs, y <- srs ]) ++ map ("*",) (zipWith pair [(show x, show y, x * y) | x <- rs, y <- rs ] [x * y | x <- srs, y <- srs ]) ++ map ("<",) (zipWith pair [(show x, show y, x < y) | x <- rs, y <- rs ] [x .< y | x <- srs, y <- srs ]) ++ map ("<=",) (zipWith pair [(show x, show y, x <= y) | x <- rs, y <- rs ] [x .<= y | x <- srs, y <- srs ]) ++ map (">",) (zipWith pair [(show x, show y, x > y) | x <- rs, y <- rs ] [x .> y | x <- srs, y <- srs ]) ++ map (">=",) (zipWith pair [(show x, show y, x >= y) | x <- rs, y <- rs ] [x .>= y | x <- srs, y <- srs ]) ++ map ("==",) (zipWith pair [(show x, show y, x == y) | x <- rs, y <- rs ] [x .== y | x <- srs, y <- srs ]) ++ map ("/=",) (zipWith pair [(show x, show y, x /= y) | x <- rs, y <- rs ] [x ./= y | x <- srs, y <- srs ]) ++ map ("/",) (zipWith pair [(show x, show y, x / y) | x <- rs, y <- rs, y /= 0] [x / y | x <- srs, y <- srs, unliteral y /= Just 0]) where pair (x, y, a) b = (x, y, Just a == unliteral b) mkTest (nm, (x, y, s)) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y ~: s `showsAs` "True" genFloats :: [Test] genFloats = bTests ++ uTests ++ fpTests1 ++ fpTests2 ++ converts where bTests = map mkTest2 $ floatRun2 "+" (+) (+) comb ++ doubleRun2 "+" (+) (+) comb ++ floatRun2 "-" (-) (-) comb ++ doubleRun2 "-" (-) (-) comb ++ floatRun2 "*" (*) (*) comb ++ doubleRun2 "*" (*) (*) comb ++ floatRun2 "/" (/) (/) comb ++ doubleRun2 "/" (/) (/) comb ++ floatRun2 "<" (<) (.<) combB ++ doubleRun2 "<" (<) (.<) combB ++ floatRun2 "<=" (<=) (.<=) combB ++ doubleRun2 "<=" (<=) (.<=) combB ++ floatRun2 ">" (>) (.>) combB ++ doubleRun2 ">" (>) (.>) combB ++ floatRun2 ">=" (>=) (.>=) combB ++ doubleRun2 ">=" (>=) (.>=) combB ++ floatRun2 "==" (==) (.==) combB ++ doubleRun2 "==" (==) (.==) combB ++ floatRun2 "/=" (/=) (./=) combN ++ doubleRun2 "/=" (/=) (./=) combN fpTests1 = map mkTest1 $ floatRun1 "abs" abs abs comb1 ++ floatRun1 "fpAbs" abs fpAbs comb1 ++ doubleRun1 "abs" abs abs comb1 ++ doubleRun1 "fpAbs" abs fpAbs comb1 ++ floatRun1 "negate" negate negate comb1 ++ floatRun1 "fpNeg" negate fpNeg comb1 ++ doubleRun1 "negate" negate negate comb1 ++ doubleRun1 "fpNeg" negate fpNeg comb1 ++ floatRun1M "fpSqrt" sqrt fpSqrt comb1 ++ doubleRun1M "fpSqrt" sqrt fpSqrt comb1 ++ floatRun1M "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1 ++ doubleRun1M "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1 ++ floatRun1 "signum" signum signum comb1 ++ doubleRun1 "signum" signum signum comb1 -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being fpTests2 = map mkTest2 $ floatRun2M "fpAdd" (+) fpAdd comb ++ doubleRun2M "fpAdd" (+) fpAdd comb ++ floatRun2M "fpSub" (-) fpSub comb ++ doubleRun2M "fpSub" (-) fpSub comb ++ floatRun2M "fpMul" (*) fpMul comb ++ doubleRun2M "fpMul" (*) fpMul comb ++ floatRun2M "fpDiv" (/) fpDiv comb ++ doubleRun2M "fpDiv" (/) fpDiv comb ++ floatRunMM "fpMin" fpMinH fpMin comb ++ doubleRunMM "fpMin" fpMinH fpMin comb ++ floatRunMM "fpMax" fpMaxH fpMax comb ++ doubleRunMM "fpMax" fpMaxH fpMax comb ++ floatRun2 "fpRem" fpRemH fpRem comb ++ doubleRun2 "fpRem" fpRemH fpRem comb ++ floatRun2 "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE ++ doubleRun2 "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE converts = map cvtTest [("toFP_Int8_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- i8s ] ++ map cvtTest [("toFP_Int16_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- i16s] ++ map cvtTest [("toFP_Int32_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- i32s] ++ map cvtTest [("toFP_Int64_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- i64s] ++ map cvtTest [("toFP_Word8_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- w8s ] ++ map cvtTest [("toFP_Word16_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- w16s] ++ map cvtTest [("toFP_Word32_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- w32s] ++ map cvtTest [("toFP_Word64_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- w64s] ++ map cvtTest [("toFP_Float_ToFloat", show x, toSFloat sRNE (literal x), literal x ) | x <- fs ] ++ map cvtTest [("toFP_Double_ToFloat", show x, toSFloat sRNE (literal x), literal (fp2fp x)) | x <- ds ] ++ map cvtTest [("toFP_Integer_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- iUBs] ++ map cvtTest [("toFP_Real_ToFloat", show x, toSFloat sRNE (literal x), fromRational (toRational x)) | x <- rs ] ++ map cvtTest [("toFP_Int8_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i8s ] ++ map cvtTest [("toFP_Int16_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i16s] ++ map cvtTest [("toFP_Int32_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i32s] ++ map cvtTest [("toFP_Int64_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i64s] ++ map cvtTest [("toFP_Word8_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w8s ] ++ map cvtTest [("toFP_Word16_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w16s] ++ map cvtTest [("toFP_Word32_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w32s] ++ map cvtTest [("toFP_Word64_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w64s] ++ map cvtTest [("toFP_Float_ToDouble", show x, toSDouble sRNE (literal x), literal (fp2fp x)) | x <- fs ] ++ map cvtTest [("toFP_Double_ToDouble", show x, toSDouble sRNE (literal x), literal x) | x <- ds ] ++ map cvtTest [("toFP_Integer_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- iUBs] ++ map cvtTest [("toFP_Real_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- rs ] ++ map cvtTestI [("fromFP_Float_ToInt8", show x, (fromSFloat sRNE :: SFloat -> SInt8) (literal x), ((fromIntegral :: Integer -> SInt8) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToInt16", show x, (fromSFloat sRNE :: SFloat -> SInt16) (literal x), ((fromIntegral :: Integer -> SInt16) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToInt32", show x, (fromSFloat sRNE :: SFloat -> SInt32) (literal x), ((fromIntegral :: Integer -> SInt32) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToInt64", show x, (fromSFloat sRNE :: SFloat -> SInt64) (literal x), ((fromIntegral :: Integer -> SInt64) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToWord8", show x, (fromSFloat sRNE :: SFloat -> SWord8) (literal x), ((fromIntegral :: Integer -> SWord8) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToWord16", show x, (fromSFloat sRNE :: SFloat -> SWord16) (literal x), ((fromIntegral :: Integer -> SWord16) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToWord32", show x, (fromSFloat sRNE :: SFloat -> SWord32) (literal x), ((fromIntegral :: Integer -> SWord32) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToWord64", show x, (fromSFloat sRNE :: SFloat -> SWord64) (literal x), ((fromIntegral :: Integer -> SWord64) . fpRound0) x) | x <- fs] ++ map cvtTest [("fromFP_Float_ToFloat", show x, (fromSFloat sRNE :: SFloat -> SFloat) (literal x), literal x) | x <- fs] ++ map cvtTest [("fromFP_Float_ToDouble", show x, (fromSFloat sRNE :: SFloat -> SDouble) (literal x), (literal . fp2fp) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToInteger", show x, (fromSFloat sRNE :: SFloat -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- fs] ++ map cvtTestI [("fromFP_Float_ToReal", show x, (fromSFloat sRNE :: SFloat -> SReal) (literal x), (fromRational . fpRatio0) x) | x <- fs] ++ map cvtTestI [("fromFP_Double_ToInt8", show x, (fromSDouble sRNE :: SDouble -> SInt8) (literal x), ((fromIntegral :: Integer -> SInt8) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToInt16", show x, (fromSDouble sRNE :: SDouble -> SInt16) (literal x), ((fromIntegral :: Integer -> SInt16) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToInt32", show x, (fromSDouble sRNE :: SDouble -> SInt32) (literal x), ((fromIntegral :: Integer -> SInt32) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToInt64", show x, (fromSDouble sRNE :: SDouble -> SInt64) (literal x), ((fromIntegral :: Integer -> SInt64) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToWord8", show x, (fromSDouble sRNE :: SDouble -> SWord8) (literal x), ((fromIntegral :: Integer -> SWord8) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToWord16", show x, (fromSDouble sRNE :: SDouble -> SWord16) (literal x), ((fromIntegral :: Integer -> SWord16) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToWord32", show x, (fromSDouble sRNE :: SDouble -> SWord32) (literal x), ((fromIntegral :: Integer -> SWord32) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToWord64", show x, (fromSDouble sRNE :: SDouble -> SWord64) (literal x), ((fromIntegral :: Integer -> SWord64) . fpRound0) x) | x <- ds] ++ map cvtTest [("fromFP_Double_ToFloat", show x, (fromSDouble sRNE :: SDouble -> SFloat) (literal x), (literal . fp2fp) x) | x <- ds] ++ map cvtTest [("fromFP_Double_ToDouble", show x, (fromSDouble sRNE :: SDouble -> SDouble) (literal x), literal x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToInteger", show x, (fromSDouble sRNE :: SDouble -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- ds] ++ map cvtTestI [("fromFP_Double_ToReal", show x, (fromSDouble sRNE :: SDouble -> SReal) (literal x), (fromRational . fpRatio0) x) | x <- ds] ++ map cvtTest [("reinterp_Word32_Float", show x, sWord32AsSFloat (literal x), literal (DB.wordToFloat x)) | x <- w32s] ++ map cvtTest [("reinterp_Word64_Double", show x, sWord64AsSDouble (literal x), literal (DB.wordToDouble x)) | x <- w64s] ++ map cvtTestI [("reinterp_Float_Word32", show x, sFloatAsSWord32 (literal x), literal (DB.floatToWord x)) | x <- fs, not (isNaN x)] -- Not unique for NaN ++ map cvtTestI [("reinterp_Double_Word64", show x, sDoubleAsSWord64 (literal x), literal (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN floatRun1 nm f g cmb = map (nm,) [cmb (x, f x, extract (g (literal x))) | x <- fs] doubleRun1 nm f g cmb = map (nm,) [cmb (x, f x, extract (g (literal x))) | x <- ds] floatRun1M nm f g cmb = map (nm,) [cmb (x, f x, extract (g sRNE (literal x))) | x <- fs] doubleRun1M nm f g cmb = map (nm,) [cmb (x, f x, extract (g sRNE (literal x))) | x <- ds] floatRun2 nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g (literal x) (literal y))) | x <- fs, y <- fs] doubleRun2 nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g (literal x) (literal y))) | x <- ds, y <- ds] floatRun2M nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- fs, y <- fs] doubleRun2M nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- ds, y <- ds] floatRunMM nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g (literal x) (literal y))) | x <- fs, y <- fs, not (alt0 x y || alt0 y x)] doubleRunMM nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g (literal x) (literal y))) | x <- ds, y <- ds, not (alt0 x y || alt0 y x)] -- fpMin/fpMax: skip +0/-0 case as this is underspecified alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y) uTests = map mkTest1 $ concatMap (checkPred fs sfs) predicates ++ concatMap (checkPred ds sds) predicates extract :: SymWord a => SBV a -> a extract = fromJust . unliteral comb (x, y, a, b) = (show x, show y, same a b) combB (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w = not (v || w) -- All comparisons except /=: Both should be False if we have a NaN argument combN (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w = v && w -- /=: Both should be True combE (x, y, a, b) = (show x, show y, a == b) comb1 (x, a, b) = (show x, same a b) same a b = (isNaN a &&& isNaN b) || (a == b) checkNaN f x y a b | isNaN x || isNaN y = f a b | True = a == b cvtTest (nm, x, a, b) = "arithCF-" ++ nm ++ "." ++ x ~: same (extract a) (extract b) `showsAs` "True" cvtTestI (nm, x, a, b) = "arithCF-" ++ nm ++ "." ++ x ~: (a == b) `showsAs` "True" mkTest1 (nm, (x, s)) = "arithCF-" ++ nm ++ "." ++ x ~: s `showsAs` "True" mkTest2 (nm, (x, y, s)) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y ~: s `showsAs` "True" checkPred :: Show a => [a] -> [SBV a] -> (String, SBV a -> SBool, a -> Bool) -> [(String, (String, Bool))] checkPred xs sxs (n, ps, p) = zipWith (chk n) (map (\x -> (x, p x)) xs) (map ps sxs) where chk nm (x, v) sv = (nm, (show x, Just v == unliteral sv)) predicates :: IEEEFloating a => [(String, SBV a -> SBool, a -> Bool)] predicates = [ ("fpIsNormal", fpIsNormal, fpIsNormalizedH) , ("fpIsSubnormal", fpIsSubnormal, isDenormalized) , ("fpIsZero", fpIsZero, (== 0)) , ("fpIsInfinite", fpIsInfinite, isInfinite) , ("fpIsNaN", fpIsNaN, isNaN) , ("fpIsNegative", fpIsNegative, \x -> x < 0 || isNegativeZero x) , ("fpIsPositive", fpIsPositive, \x -> x >= 0 && not (isNegativeZero x)) , ("fpIsNegativeZero", fpIsNegativeZero, isNegativeZero) , ("fpIsPositiveZero", fpIsPositiveZero, \x -> x == 0 && not (isNegativeZero x)) , ("fpIsPoint", fpIsPoint, \x -> not (isNaN x || isInfinite x)) ] -- Concrete test data xsUnsigned :: (Num a, Bounded a) => [a] xsUnsigned = take 5 (iterate (1+) minBound) ++ take 5 (iterate (\x -> x-1) maxBound) xsSigned :: (Num a, Enum a, Bounded a) => [a] xsSigned = xsUnsigned ++ [-5 .. 5] w8s :: [Word8] w8s = xsUnsigned sw8s :: [SWord8] sw8s = xsUnsigned w16s :: [Word16] w16s = xsUnsigned sw16s :: [SWord16] sw16s = xsUnsigned w32s :: [Word32] w32s = xsUnsigned sw32s :: [SWord32] sw32s = xsUnsigned w64s :: [Word64] w64s = xsUnsigned sw64s :: [SWord64] sw64s = xsUnsigned i8s :: [Int8] i8s = xsSigned si8s :: [SInt8] si8s = xsSigned i16s :: [Int16] i16s = xsSigned si16s :: [SInt16] si16s = xsSigned i32s :: [Int32] i32s = xsSigned si32s :: [SInt32] si32s = xsSigned i64s :: [Int64] i64s = xsSigned si64s :: [SInt64] si64s = xsSigned iUBs :: [Integer] iUBs = [-1000000 .. -999995] ++ [-5 .. 5] ++ [999995 .. 1000000] siUBs :: [SInteger] siUBs = map literal iUBs rs :: [AlgReal] rs = [fromRational (i % d) | i <- nums, d <- dens] where nums = [-1000000 .. -999998] ++ [-2 .. 2] ++ [999998 .. 1000001] dens = [2 .. 5] ++ [98 .. 102] ++ [999998 .. 1000000] srs :: [SReal] srs = map literal rs fs :: [Float] fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45] sfs :: [SFloat] sfs = map literal fs ds :: [Double] ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 7.518897767550192e-2, 1.1656043286207285e-2, 5.0e-324] sds :: [SDouble] sds = map literal ds sbv-5.12/SBVUnitTest/TestSuite/Basics/ArithSolver.hs0000644000000000000000000010320112725411266020511 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.ArithSolver -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for basic non-concrete arithmetic, i.e., testing all -- basic arithmetic reasoning using an SMT solver without any -- constant folding. ----------------------------------------------------------------------------- {-# LANGUAGE Rank2Types #-} {-# LANGUAGE TupleSections #-} module TestSuite.Basics.ArithSolver(testSuite) where import Data.Maybe (fromMaybe, fromJust) import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord) import Data.SBV import Data.SBV.Internals import SBVTest ghcBitSize :: Bits a => a -> Int ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x) -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test $ genReals ++ genFloats ++ genDoubles ++ genFPConverts ++ genQRems ++ genBinTest True "+" (+) ++ genBinTest True "-" (-) ++ genBinTest True "*" (*) ++ genUnTest True "negate" negate ++ genUnTest True "abs" abs ++ genUnTest True "signum" signum ++ genBinTest False ".&." (.&.) ++ genBinTest False ".|." (.|.) ++ genBoolTest "<" (<) (.<) ++ genBoolTest "<=" (<=) (.<=) ++ genBoolTest ">" (>) (.>) ++ genBoolTest ">=" (>=) (.>=) ++ genBoolTest "==" (==) (.==) ++ genBoolTest "/=" (/=) (./=) ++ genBinTest False "xor" xor ++ genUnTest False "complement" complement ++ genIntTest "shift" shift ++ genIntTest "rotate" rotate ++ genIntTestS False "setBit" setBit ++ genIntTestS False "clearBit" clearBit ++ genIntTestS False "complementBit" complementBit ++ genIntTest "shift" shift ++ genIntTestS True "shiftL" shiftL ++ genIntTestS True "shiftR" shiftR ++ genIntTest "rotate" rotate ++ genIntTestS True "rotateL" rotateL ++ genIntTestS True "rotateR" rotateR ++ genBlasts ++ genIntCasts genBinTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [Test] genBinTest unboundedOK nm op = map mkTest $ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s, y <- w8s ] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s, y <- i8s ] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- iUBs] where mkTest (x, y, t) = "genBinTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y ~: assert t mkThm2 x y r = isThm $ do [a, b] <- mapM free ["x", "y"] constrain $ a .== literal x constrain $ b .== literal y return $ literal r .== a `op` b genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [Test] genBoolTest nm op opS = map mkTest $ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s, y <- w8s ] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s, y <- i8s ] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s] ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- iUBs] where mkTest (x, y, t) = "genBoolTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y ~: assert t mkThm2 x y r = isThm $ do [a, b] <- mapM free ["x", "y"] constrain $ a .== literal x constrain $ b .== literal y return $ literal r .== a `opS` b genUnTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a) -> [Test] genUnTest unboundedOK nm op = map mkTest $ [(show x, mkThm x (op x)) | x <- w8s ] ++ [(show x, mkThm x (op x)) | x <- w16s] ++ [(show x, mkThm x (op x)) | x <- w32s] ++ [(show x, mkThm x (op x)) | x <- w64s] ++ [(show x, mkThm x (op x)) | x <- i8s ] ++ [(show x, mkThm x (op x)) | x <- i16s] ++ [(show x, mkThm x (op x)) | x <- i32s] ++ [(show x, mkThm x (op x)) | x <- i64s] ++ [(show x, mkThm x (op x)) | unboundedOK, x <- iUBs] where mkTest (x, t) = "genUnTest.arithmetic-" ++ nm ++ "." ++ x ~: assert t mkThm x r = isThm $ do a <- free "x" constrain $ a .== literal x return $ literal r .== op a genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test] genIntTest nm op = map mkTest $ [("u8", show x, show y, mkThm2 x y (x `op` y)) | x <- w8s, y <- is] ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- is] ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- is] ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- is] ++ [("s8", show x, show y, mkThm2 x y (x `op` y)) | x <- i8s, y <- is] ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- is] ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- is] ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- is] ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- is] where mkTest (l, x, y, t) = "genIntTest.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y ~: assert t is = [-10 .. 10] mkThm2 x y r = isThm $ do a <- free "x" constrain $ a .== literal x return $ literal r .== a `op` y genIntTestS :: Bool -> String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test] genIntTestS unboundedOK nm op = map mkTest $ [("u8", show x, show y, mkThm2 x y (x `op` y)) | x <- w8s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("s8", show x, show y, mkThm2 x y (x `op` y)) | x <- i8s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]] ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- [0 .. 10]] where mkTest (l, x, y, t) = "genIntTestS.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y ~: assert t mkThm2 x y r = isThm $ do a <- free "x" constrain $ a .== literal x return $ literal r .== a `op` y genBlasts :: [Test] genBlasts = map mkTest $ [(show x, mkThm fromBitsLE blastLE x) | x <- w8s ] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w8s ] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i8s ] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i8s ] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w16s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w16s] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i16s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i16s] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w32s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w32s] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i32s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i32s] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w64s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w64s] ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i64s] ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i64s] where mkTest (x, t) = "genBlasts.blast-" ++ show x ~: assert t mkThm from to v = isThm $ do a <- free "x" constrain $ a .== literal v return $ a .== from (to a) genIntCasts :: [Test] genIntCasts = map mkTest $ cast w8s ++ cast w16s ++ cast w32s ++ cast w64s ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s ++ cast iUBs where mkTest (x, t) = "sIntCast-" ++ x ~: assert t cast :: forall a. (Show a, Integral a, Bits a, SymWord a) => [a] -> [(String, IO Bool)] cast xs = toWords xs ++ toInts xs toWords xs = [(show x, mkThm x (fromIntegral x :: Word8 )) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Word16)) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Word32)) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Word64)) | x <- xs] toInts xs = [(show x, mkThm x (fromIntegral x :: Int8 )) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Int16)) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Int32)) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Int64)) | x <- xs] ++ [(show x, mkThm x (fromIntegral x :: Integer)) | x <- xs] mkThm v res = isThm $ do a <- free "x" constrain $ a .== literal v return $ literal res .== sFromIntegral a genReals :: [Test] genReals = map mkTest $ [("+", show x, show y, mkThm2 (+) x y (x + y)) | x <- rs, y <- rs ] ++ [("-", show x, show y, mkThm2 (-) x y (x - y)) | x <- rs, y <- rs ] ++ [("*", show x, show y, mkThm2 (*) x y (x * y)) | x <- rs, y <- rs ] ++ [("/", show x, show y, mkThm2 (/) x y (x / y)) | x <- rs, y <- rs, y /= 0] ++ [("<", show x, show y, mkThm2 (.<) x y (x < y)) | x <- rs, y <- rs ] ++ [("<=", show x, show y, mkThm2 (.<=) x y (x <= y)) | x <- rs, y <- rs ] ++ [(">", show x, show y, mkThm2 (.>) x y (x > y)) | x <- rs, y <- rs ] ++ [(">=", show x, show y, mkThm2 (.>=) x y (x >= y)) | x <- rs, y <- rs ] ++ [("==", show x, show y, mkThm2 (.==) x y (x == y)) | x <- rs, y <- rs ] ++ [("/=", show x, show y, mkThm2 (./=) x y (x /= y)) | x <- rs, y <- rs ] where mkTest (nm, x, y, t) = "genReals.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y ~: assert t mkThm2 op x y r = isThm $ do [a, b] <- mapM free ["x", "y"] constrain $ a .== literal x constrain $ b .== literal y return $ literal r .== a `op` b genFloats :: [Test] genFloats = genIEEE754 "genFloats" fs genDoubles :: [Test] genDoubles = genIEEE754 "genDoubles" ds genIEEE754 :: (IEEEFloating a, Show a, Ord a) => String -> [a] -> [Test] genIEEE754 origin vs = map tst1 [("pred_" ++ nm, x, y) | (nm, x, y) <- preds] ++ map tst1 [("unary_" ++ nm, x, y) | (nm, x, y) <- uns] ++ map tst2 [("binary_" ++ nm, x, y, r) | (nm, x, y, r) <- bins] where uns = [("abs", show x, mkThm1 abs x (abs x)) | x <- vs] ++ [("negate", show x, mkThm1 negate x (negate x)) | x <- vs] ++ [("signum", show x, mkThm1 signum x (signum x)) | x <- vs] ++ [("fpAbs", show x, mkThm1 fpAbs x (abs x)) | x <- vs] ++ [("fpNeg", show x, mkThm1 fpNeg x (negate x)) | x <- vs] ++ [("fpSqrt", show x, mkThm1 (m fpSqrt) x (sqrt x)) | x <- vs] ++ [("fpRoundToIntegral", show x, mkThm1 (m fpRoundToIntegral) x (fpRoundToIntegralH x)) | x <- vs] bins = [("+", show x, show y, mkThm2 (+) x y (x + y)) | x <- vs, y <- vs] ++ [("-", show x, show y, mkThm2 (-) x y (x - y)) | x <- vs, y <- vs] ++ [("*", show x, show y, mkThm2 (*) x y (x * y)) | x <- vs, y <- vs] ++ [("/", show x, show y, mkThm2 (/) x y (x / y)) | x <- vs, y <- vs] ++ [("<", show x, show y, mkThm2C False (.<) x y (x < y)) | x <- vs, y <- vs] ++ [("<=", show x, show y, mkThm2C False (.<=) x y (x <= y)) | x <- vs, y <- vs] ++ [(">", show x, show y, mkThm2C False (.>) x y (x > y)) | x <- vs, y <- vs] ++ [(">=", show x, show y, mkThm2C False (.>=) x y (x >= y)) | x <- vs, y <- vs] ++ [("==", show x, show y, mkThm2C False (.==) x y (x == y)) | x <- vs, y <- vs] ++ [("/=", show x, show y, mkThm2C True (./=) x y (x /= y)) | x <- vs, y <- vs] -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being ++ [("fpAdd", show x, show y, mkThm2 (m fpAdd) x y ((+) x y)) | x <- vs, y <- vs] ++ [("fpSub", show x, show y, mkThm2 (m fpSub) x y ((-) x y)) | x <- vs, y <- vs] ++ [("fpMul", show x, show y, mkThm2 (m fpMul) x y ((*) x y)) | x <- vs, y <- vs] ++ [("fpDiv", show x, show y, mkThm2 (m fpDiv) x y ((/) x y)) | x <- vs, y <- vs] ++ [("fpMin", show x, show y, mkThm2 fpMin x y (fpMinH x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)] ++ [("fpMax", show x, show y, mkThm2 fpMax x y (fpMaxH x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)] ++ [("fpIsEqualObject", show x, show y, mkThm2P fpIsEqualObject x y (fpIsEqualObjectH x y)) | x <- vs, y <- vs] ++ [("fpRem", show x, show y, mkThm2 fpRem x y (fpRemH x y)) | x <- vsFPRem, y <- vsFPRem] -- TODO: For doubles fpRem takes too long, so we only do a subset vsFPRem | origin == "genDoubles" = [nan, infinity, 0, 0.5, -infinity, -0, -0.5] | True = vs -- fpMin/fpMax: skip +0/-0 case as this is underspecified alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y) m f = f sRNE preds = [(pn, show x, mkThmP ps x (pc x)) | (pn, ps, pc) <- predicates, x <- vs] tst2 (nm, x, y, t) = origin ++ ".arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y ~: assert t tst1 (nm, x, t) = origin ++ ".arithmetic-" ++ nm ++ "." ++ x ~: assert t eqF v val | isNaN val = constrain $ fpIsNaN v | isNegativeZero val = constrain $ fpIsNegativeZero v | val == 0 = constrain $ fpIsPositiveZero v | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v | True = constrain $ v .== literal val -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP fpProver :: SMTConfig fpProver = z3 -- mathSAT fpThm :: Provable a => a -> IO Bool fpThm p = fromJust `fmap` isTheoremWith fpProver Nothing p mkThmP op x r = fpThm $ do a <- free "x" eqF a x return $ literal r .== op a mkThm2P op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"] eqF a x eqF b y return $ literal r .== a `op` b mkThm1 op x r = fpThm $ do a <- free "x" eqF a x return $ literal r `fpIsEqualObject` op a mkThm2 op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"] eqF a x eqF b y return $ literal r `fpIsEqualObject` (a `op` b) mkThm2C neq op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"] eqF a x eqF b y return $ if isNaN x || isNaN y then (if neq then a `op` b else bnot (a `op` b)) else literal r .== a `op` b predicates :: (IEEEFloating a) => [(String, SBV a -> SBool, a -> Bool)] predicates = [ ("fpIsNormal", fpIsNormal, fpIsNormalizedH) , ("fpIsSubnormal", fpIsSubnormal, isDenormalized) , ("fpIsZero", fpIsZero, (== 0)) , ("fpIsInfinite", fpIsInfinite, isInfinite) , ("fpIsNaN", fpIsNaN, isNaN) , ("fpIsNegative", fpIsNegative, \x -> x < 0 || isNegativeZero x) , ("fpIsPositive", fpIsPositive, \x -> x >= 0 && not (isNegativeZero x)) , ("fpIsNegativeZero", fpIsNegativeZero, isNegativeZero) , ("fpIsPositiveZero", fpIsPositiveZero, \x -> x == 0 && not (isNegativeZero x)) , ("fpIsPoint", fpIsPoint, \x -> not (isNaN x || isInfinite x)) ] genFPConverts :: [Test] genFPConverts = map tst1 [("fpCast_" ++ nm, x, y) | (nm, x, y) <- converts] where converts = [("toFP_Int8_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i8s ] ++ [("toFP_Int16_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i16s] ++ [("toFP_Int32_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i32s] ++ [("toFP_Int64_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i64s] ++ [("toFP_Word8_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w8s ] ++ [("toFP_Word16_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w16s] ++ [("toFP_Word32_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w32s] ++ [("toFP_Word64_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w64s] ++ [("toFP_Float_ToFloat", show x, mkThm1 (m toSFloat) x x ) | x <- fs ] ++ [("toFP_Double_ToFloat", show x, mkThm1 (m toSFloat) x ( fp2fp x )) | x <- ds ] ++ [("toFP_Integer_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- iUBs] ++ [("toFP_Real_ToFloat", show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- rs ] ++ [("toFP_Int8_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i8s ] ++ [("toFP_Int16_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i16s] ++ [("toFP_Int32_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i32s] ++ [("toFP_Int64_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i64s] ++ [("toFP_Word8_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w8s ] ++ [("toFP_Word16_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w16s] ++ [("toFP_Word32_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w32s] ++ [("toFP_Word64_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w64s] ++ [("toFP_Float_ToDouble", show x, mkThm1 (m toSDouble) x ( fp2fp x )) | x <- fs ] ++ [("toFP_Double_ToDouble", show x, mkThm1 (m toSDouble) x x ) | x <- ds ] ++ [("toFP_Integer_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- iUBs] ++ [("toFP_Real_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- rs ] ++ [("fromFP_Float_ToInt8", show x, mkThmC' (m fromSFloat :: SFloat -> SInt8) x (((fromIntegral :: Integer -> Int8) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToInt16", show x, mkThmC' (m fromSFloat :: SFloat -> SInt16) x (((fromIntegral :: Integer -> Int16) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToInt32", show x, mkThmC' (m fromSFloat :: SFloat -> SInt32) x (((fromIntegral :: Integer -> Int32) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToInt64", show x, mkThmC' (m fromSFloat :: SFloat -> SInt64) x (((fromIntegral :: Integer -> Int64) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToWord8", show x, mkThmC' (m fromSFloat :: SFloat -> SWord8) x (((fromIntegral :: Integer -> Word8) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToWord16", show x, mkThmC' (m fromSFloat :: SFloat -> SWord16) x (((fromIntegral :: Integer -> Word16) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToWord32", show x, mkThmC' (m fromSFloat :: SFloat -> SWord32) x (((fromIntegral :: Integer -> Word32) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToWord64", show x, mkThmC' (m fromSFloat :: SFloat -> SWord64) x (((fromIntegral :: Integer -> Word64) . fpRound0) x)) | x <- fs] ++ [("fromFP_Float_ToFloat", show x, mkThm1 (m fromSFloat :: SFloat -> SFloat) x x ) | x <- fs] ++ [("fromFP_Float_ToDouble", show x, mkThm1 (m fromSFloat :: SFloat -> SDouble) x ( fp2fp x)) | x <- fs] -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out. -- See GitHub issue: #191 -- ++ [("fromFP_Float_ToInteger", show x, mkThmC' (m fromSFloat :: SFloat -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- fs] -- ++ [("fromFP_Float_ToReal", show x, mkThmC' (m fromSFloat :: SFloat -> SReal) x ( (fromRational . fpRatio0) x)) | x <- fs] ++ [("fromFP_Double_ToInt8", show x, mkThmC' (m fromSDouble :: SDouble -> SInt8) x (((fromIntegral :: Integer -> Int8) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToInt16", show x, mkThmC' (m fromSDouble :: SDouble -> SInt16) x (((fromIntegral :: Integer -> Int16) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToInt32", show x, mkThmC' (m fromSDouble :: SDouble -> SInt32) x (((fromIntegral :: Integer -> Int32) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToInt64", show x, mkThmC' (m fromSDouble :: SDouble -> SInt64) x (((fromIntegral :: Integer -> Int64) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToWord8", show x, mkThmC' (m fromSDouble :: SDouble -> SWord8) x (((fromIntegral :: Integer -> Word8) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToWord16", show x, mkThmC' (m fromSDouble :: SDouble -> SWord16) x (((fromIntegral :: Integer -> Word16) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToWord32", show x, mkThmC' (m fromSDouble :: SDouble -> SWord32) x (((fromIntegral :: Integer -> Word32) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToWord64", show x, mkThmC' (m fromSDouble :: SDouble -> SWord64) x (((fromIntegral :: Integer -> Word64) . fpRound0) x)) | x <- ds] ++ [("fromFP_Double_ToFloat", show x, mkThm1 (m fromSDouble :: SDouble -> SFloat) x ( fp2fp x)) | x <- ds] ++ [("fromFP_Double_ToDouble", show x, mkThm1 (m fromSDouble :: SDouble -> SDouble) x x ) | x <- ds] -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out. -- See GitHub issue: #191 -- ++ [("fromFP_Double_ToInteger", show x, mkThmC' (m fromSDouble :: SDouble -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- ds] -- ++ [("fromFP_Double_ToReal", show x, mkThmC' (m fromSDouble :: SDouble -> SReal) x ( (fromRational . fpRatio0) x)) | x <- ds] ++ [("reinterp_Word32_Float", show x, mkThmC sWord32AsSFloat x (DB.wordToFloat x)) | x <- w32s] ++ [("reinterp_Word64_Double", show x, mkThmC sWord64AsSDouble x (DB.wordToDouble x)) | x <- w64s] ++ [("reinterp_Float_Word32", show x, mkThmP sFloatAsSWord32 x (DB.floatToWord x)) | x <- fs, not (isNaN x)] -- Not unique for NaN ++ [("reinterp_Double_Word64", show x, mkThmP sDoubleAsSWord64 x (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN m f = f sRNE tst1 (nm, x, t) = "fpConverts.arithmetic-" ++ nm ++ "." ++ x ~: assert t eqF v val | isNaN val = constrain $ fpIsNaN v | isNegativeZero val = constrain $ fpIsNegativeZero v | val == 0 = constrain $ fpIsPositiveZero v | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v | True = constrain $ v .== literal val -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP fpProver :: SMTConfig fpProver = z3 -- mathSAT fpThm :: Provable a => a -> IO Bool fpThm p = fromJust `fmap` isTheoremWith fpProver Nothing p mkThmP op x r = fpThm $ do a <- free "x" eqF a x return $ literal r .== op a mkThm1 op x r = fpThm $ do a <- free "x" eqF a x return $ literal r `fpIsEqualObject` op a mkThmC op x r = fpThm $ do a <- free "x" constrain $ a .== literal x return $ literal r `fpIsEqualObject` op a mkThmC' op x r = fpThm $ do a <- free "x" eqF a x return $ literal r .== op a genQRems :: [Test] genQRems = map mkTest $ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- w8s, y <- w8s ] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- w16s, y <- w16s] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- w32s, y <- w32s] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- w64s, y <- w64s] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- i8s, y <- i8s , noOverflow x y] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- i16s, y <- i16s, noOverflow x y] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- i32s, y <- i32s, noOverflow x y] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- i64s, y <- i64s, noOverflow x y] ++ [("divMod", show x, show y, mkThm2 sDivMod x y (x `divMod'` y)) | x <- iUBs, y <- iUBs] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w8s, y <- w8s ] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w16s, y <- w16s] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w32s, y <- w32s] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w64s, y <- w64s] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i8s, y <- i8s , noOverflow x y] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i16s, y <- i16s, noOverflow x y] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i32s, y <- i32s, noOverflow x y] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i64s, y <- i64s, noOverflow x y] ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- iUBs, y <- iUBs] where divMod' x y = if y == 0 then (0, x) else x `divMod` y quotRem' x y = if y == 0 then (0, x) else x `quotRem` y mkTest (nm, x, y, t) = "genQRems.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y ~: assert t mkThm2 op x y (e1, e2) = isThm $ do [a, b] <- mapM free ["x", "y"] constrain $ a .== literal x constrain $ b .== literal y return $ (literal e1, literal e2) .== a `op` b -- Haskell's divMod and quotRem overflows if x == minBound and y == -1 for signed types; so avoid that case noOverflow x y = not (x == minBound && y == -1) -- Concrete test data xsSigned, xsUnsigned :: (Num a, Bounded a) => [a] xsUnsigned = [0, 1, maxBound - 1, maxBound] xsSigned = xsUnsigned ++ [minBound, minBound + 1, -1] w8s :: [Word8] w8s = xsUnsigned w16s :: [Word16] w16s = xsUnsigned w32s :: [Word32] w32s = xsUnsigned w64s :: [Word64] w64s = xsUnsigned i8s :: [Int8] i8s = xsSigned i16s :: [Int16] i16s = xsSigned i32s :: [Int32] i32s = xsSigned i64s :: [Int64] i64s = xsSigned iUBs :: [Integer] iUBs = [-1000000] ++ [-1 .. 1] ++ [1000000] rs :: [AlgReal] rs = [fromRational (i % d) | i <- is, d <- dens] where is = [-1000000] ++ [-1 .. 1] ++ [10000001] dens = [5,100,1000000] -- Admittedly paltry test-cases for float/double fs :: [Float] fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45] ds :: [Double] ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 5.0e-324] {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/SBVUnitTest/TestSuite/Basics/BasicTests.hs0000644000000000000000000000420412725411266020316 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.BasicTests -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Basics.BasicTests ----------------------------------------------------------------------------- module TestSuite.Basics.BasicTests(testSuite) where import Examples.Basics.BasicTests import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "basic-0.1" ~: test0 f1 `showsAs` "5" , "basic-0.2" ~: test0 f2 `showsAs` "5" , "basic-0.3" ~: test0 f3 `showsAs` "25" , "basic-0.4" ~: test0 f4 `showsAs` "25" , "basic-0.5" ~: test0 f5 `showsAs` "4" , "basic-1.1" ~: test1 f1 `goldCheck` "basic-1_1.gold" , "basic-1.2" ~: test1 f2 `goldCheck` "basic-1_2.gold" , "basic-1.3" ~: test1 f3 `goldCheck` "basic-1_3.gold" , "basic-1.4" ~: test1 f4 `goldCheck` "basic-1_4.gold" , "basic-1.5" ~: test1 f5 `goldCheck` "basic-1_5.gold" , "basic-2.1" ~: test2 f1 `goldCheck` "basic-2_1.gold" , "basic-2.2" ~: test2 f2 `goldCheck` "basic-2_2.gold" , "basic-2.3" ~: test2 f3 `goldCheck` "basic-2_3.gold" , "basic-2.4" ~: test2 f4 `goldCheck` "basic-2_4.gold" , "basic-2.5" ~: test2 f5 `goldCheck` "basic-2_5.gold" , "basic-3.1" ~: test3 f1 `goldCheck` "basic-3_1.gold" , "basic-3.2" ~: test3 f2 `goldCheck` "basic-3_2.gold" , "basic-3.3" ~: test3 f3 `goldCheck` "basic-3_3.gold" , "basic-3.4" ~: test3 f4 `goldCheck` "basic-3_4.gold" , "basic-3.5" ~: test3 f5 `goldCheck` "basic-3_5.gold" , "basic-4.1" ~: test4 f1 `goldCheck` "basic-4_1.gold" , "basic-4.2" ~: test4 f2 `goldCheck` "basic-4_2.gold" , "basic-4.3" ~: test4 f3 `goldCheck` "basic-4_3.gold" , "basic-4.4" ~: test4 f4 `goldCheck` "basic-4_4.gold" , "basic-4.5" ~: test4 f5 `goldCheck` "basic-4_5.gold" , "basic-5.1" ~: test5 f1 `goldCheck` "basic-5_1.gold" , "basic-5.2" ~: test5 f2 `goldCheck` "basic-5_2.gold" , "basic-5.3" ~: test5 f3 `goldCheck` "basic-5_3.gold" , "basic-5.4" ~: test5 f4 `goldCheck` "basic-5_4.gold" , "basic-5.5" ~: test5 f5 `goldCheck` "basic-5_5.gold" ] sbv-5.12/SBVUnitTest/TestSuite/Basics/Higher.hs0000644000000000000000000000236012725411266017461 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.Higher -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Basics.Higher ----------------------------------------------------------------------------- module TestSuite.Basics.Higher(testSuite) where import Data.SBV import Examples.Basics.Higher import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "higher-1" ~: (f11 === f11) `goldCheck` "higher-1.gold" , "higher-2" ~: (f12 === f12) `goldCheck` "higher-2.gold" , "higher-3" ~: (f21 === f21) `goldCheck` "higher-3.gold" , "higher-4" ~: (f22 === f22) `goldCheck` "higher-4.gold" , "higher-5" ~: (f31 === f31) `goldCheck` "higher-5.gold" , "higher-6" ~: (f32 === f32) `goldCheck` "higher-6.gold" , "higher-7" ~: (f33 === f33) `goldCheck` "higher-7.gold" , "higher-8" ~: double `goldCheck` "higher-8.gold" , "higher-9" ~: onlyFailsFor128 `goldCheck` "higher-9.gold" ] where double = (2*) === (\x -> x+(x::SWord8)) onlyFailsFor128 = (2*) === (\x -> ite (x .== 128) 5 (x+(x::SWord8))) sbv-5.12/SBVUnitTest/TestSuite/Basics/Index.hs0000644000000000000000000000124512725411266017323 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.Index -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Basics.Index ----------------------------------------------------------------------------- module TestSuite.Basics.Index(testSuite) where import Examples.Basics.Index import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test $ zipWith tst [f x | f <- [test1, test2, test3], x <- [0..13]] [(0::Int)..] where tst t i = "index-" ++ show i ~: t `ioShowsAs` "True" sbv-5.12/SBVUnitTest/TestSuite/Basics/IteTest.hs0000644000000000000000000000244112725411266017634 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.IteTest -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test various incarnations of ite/iteLazy/sBranch ----------------------------------------------------------------------------- module TestSuite.Basics.IteTest(testSuite) where import Data.SBV import SBVTest chk1 :: (SBool -> SBool -> SBool -> SBool) -> SWord8 -> SBool chk1 cond x = cond (x .== x) true undefined chk2 :: (SBool -> [SBool] -> [SBool] -> [SBool]) -> SWord8 -> SBool chk2 cond x = head (cond (x .== x) [true] [undefined]) chk3 :: (SBool -> (SBool, SBool) -> (SBool, SBool) -> (SBool, SBool)) -> SWord8 -> SBool chk3 cond x = fst (cond (x .== x) (true, undefined::SBool) (undefined, undefined)) -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "ite-1" ~: rs (chk1 ite) `goldCheck` "iteTest1.gold" , "ite-2" ~: rs (chk2 ite) `goldCheck` "iteTest2.gold" , "ite-3" ~: rs (chk3 ite) `goldCheck` "iteTest3.gold" , "ite-4" ~: assert =<< isThm (chk1 iteLazy) , "ite-5" ~: assert =<< isThm (chk2 iteLazy) , "ite-6" ~: assert =<< isThm (chk3 iteLazy) ] where rs f = runSAT $ forAll ["x"] f sbv-5.12/SBVUnitTest/TestSuite/Basics/ProofTests.hs0000644000000000000000000000245112725411266020364 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.ProofTests -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Basics.ProofTests ----------------------------------------------------------------------------- module TestSuite.Basics.ProofTests(testSuite) where import Data.SBV import Examples.Basics.ProofTests import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "proofs-1" ~: assert =<< isThm f1eqf2 , "proofs-2" ~: assert . not =<< isThm f1eqf3 , "proofs-3" ~: assert =<< isThm f3eqf4 , "proofs-4" ~: assert =<< isThm f1Single , "proofs-5" ~: assert =<< isSat (f1 `xyEq` f2) , "proofs-6" ~: assert =<< isSat (f1 `xyEq` f3) , "proofs-7" ~: assert . not =<< isSat (exists "x" >>= \x -> return (x .== x + (1 :: SWord16))) , "proofs-8" ~: assert =<< isSat (exists "x" >>= \x -> return (x :: SBool)) , "proofs-9" ~: assert =<< isSat (exists "x" >>= \x -> return x :: Predicate) ] where func1 `xyEq` func2 = do x <- exists_ y <- exists_ return $ func1 x y .== func2 x (y :: SWord8) sbv-5.12/SBVUnitTest/TestSuite/Basics/QRem.hs0000644000000000000000000000140612725411266017117 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Basics.QRem -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Basics.QRem ----------------------------------------------------------------------------- module TestSuite.Basics.QRem(testSuite) where import Data.SBV import Examples.Basics.QRem import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "qremW8" ~: assert =<< isThm (qrem :: SWord8 -> SWord8 -> SBool) , "qremI8" ~: assert =<< isThm (qrem :: SInt8 -> SInt8 -> SBool) , "qremI" ~: assert =<< isThm (qrem :: SInteger -> SInteger -> SBool) ] sbv-5.12/SBVUnitTest/TestSuite/BitPrecise/0000755000000000000000000000000012725411266016543 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/BitPrecise/BitTricks.hs0000644000000000000000000000163712725411266021004 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.BitPrecise.BitTricks -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.BitPrecise.BitTricks ----------------------------------------------------------------------------- module TestSuite.BitPrecise.BitTricks(testSuite) where import Data.SBV.Examples.BitPrecise.BitTricks import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "fast min" ~: assert =<< isThm fastMinCorrect , "fast max" ~: assert =<< isThm fastMaxCorrect , "opposite signs" ~: assert =<< isThm oppositeSignsCorrect , "conditional set clear" ~: assert =<< isThm conditionalSetClearCorrect , "power of two" ~: assert =<< isThm powerOfTwoCorrect ] sbv-5.12/SBVUnitTest/TestSuite/BitPrecise/Legato.hs0000644000000000000000000000342612725411266020317 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.BitPrecise.Legato -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.BitPrecise.Legato ----------------------------------------------------------------------------- module TestSuite.BitPrecise.Legato(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.BitPrecise.Legato import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "legato-1" ~: legatoPgm `goldCheck` "legato.gold" , "legato-2" ~: legatoC `goldCheck` "legato_c.gold" ] where legatoPgm = runSAT $ do mem <- newArray "mem" Nothing addrX <- free "addrX" x <- free "x" addrY <- free "addrY" y <- free "y" addrLow <- free "addrLow" regX <- free "regX" regA <- free "regA" memVals <- free "memVals" flagC <- free "flagC" flagZ <- free "flagZ" output $ legatoIsCorrect mem (addrX, x) (addrY, y) addrLow (regX, regA, memVals, flagC, flagZ) legatoC = compileToC' "legatoMult" $ do cgSetDriverValues [87, 92] cgPerformRTCs True x <- cgInput "x" y <- cgInput "y" let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, 0, false, false)) cgOutput "hi" hi cgOutput "lo" lo sbv-5.12/SBVUnitTest/TestSuite/BitPrecise/MergeSort.hs0000644000000000000000000000155412725411266021013 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.BitPrecise.MergeSort -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.BitPrecise.MergeSort ----------------------------------------------------------------------------- module TestSuite.BitPrecise.MergeSort where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.BitPrecise.MergeSort import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "mergeSort" ~: mergeC `goldCheck` "merge.gold" ] where mergeC = compileToC' "merge" $ do cgSetDriverValues [10, 6, 4, 82, 71] xs <- cgInputArr 5 "xs" cgOutputArr "ys" (mergeSort xs) sbv-5.12/SBVUnitTest/TestSuite/BitPrecise/PrefixSum.hs0000644000000000000000000000134312725411266021022 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.BitPrecise.PrefixSum -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.PrefixSum.PrefixSum ----------------------------------------------------------------------------- module TestSuite.BitPrecise.PrefixSum(testSuite) where import Data.SBV import Data.SBV.Examples.BitPrecise.PrefixSum import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "prefixSum1" ~: assert =<< isThm (flIsCorrect 8 (0, (+))) , "prefixSum2" ~: assert =<< isThm (flIsCorrect 16 (0, smax)) ] sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/0000755000000000000000000000000012725411266017400 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/AddSub.hs0000644000000000000000000000173212725411266021101 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.AddSub -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.AddSub ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.AddSub(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.AddSub import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "addSub" ~: code `goldCheck` "addSub.gold" ] where code = compileToC' "addSub" $ do cgSetDriverValues [76, 92] cgPerformRTCs True x <- cgInput "x" y <- cgInput "y" let (s, d) = addSub x y cgOutput "sum" s cgOutput "dif" d sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/CgTests.hs0000644000000000000000000000305212725411266021310 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.CgTests -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for code-generation features ----------------------------------------------------------------------------- {-# LANGUAGE ScopedTypeVariables #-} module TestSuite.CodeGeneration.CgTests(testSuite) where import Data.SBV import Data.SBV.Internals import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "selChecked" ~: genSelect True "selChecked" `goldCheck` "selChecked.gold" , "selUnchecked" ~: genSelect False "selUnChecked" `goldCheck` "selUnchecked.gold" , "codegen1" ~: foo `goldCheck` "codeGen1.gold" ] where genSelect b n = compileToC' n $ do cgSetDriverValues [65] cgPerformRTCs b let sel :: SWord8 -> SWord8 sel x = select [1, x+2] 3 x x <- cgInput "x" cgReturn $ sel x foo = compileToC' "foo" $ do cgSetDriverValues $ repeat 0 (x::SInt16) <- cgInput "x" (ys::[SInt64]) <- cgInputArr 45 "xArr" cgOutput "z" (5 :: SWord16) cgOutputArr "zArr" (replicate 7 (x+1)) cgOutputArr "yArr" ys cgReturn (x*2) sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/CRC_USB5.hs0000644000000000000000000000165712725411266021152 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.CRC_USB5 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.CRC_USB5 ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.CRC_USB5(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.CRC_USB5 import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "crcUSB5-1" ~: genC crcUSB `goldCheck` "crcUSB5_1.gold" , "crcUSB5-2" ~: genC crcUSB' `goldCheck` "crcUSB5_2.gold" ] where genC f = compileToC' "crcUSB5" $ do cgSetDriverValues [0xFEDC] msg <- cgInput "msg" cgReturn $ f msg sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/Fibonacci.hs0000644000000000000000000000200012725411266021601 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.Fibonacci -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.Fibonacci ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.Fibonacci(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.Fibonacci import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "fib1" ~: tst [12] "fib1" (fib1 64) `goldCheck` "fib1.gold" , "fib2" ~: tst [20] "fib2" (fib2 64) `goldCheck` "fib2.gold" ] where tst vs nm f = compileToC' nm $ do cgPerformRTCs True cgSetDriverValues vs n <- cgInput "n" cgReturn $ f n sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/Floats.hs0000644000000000000000000002414212725411266021167 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.Floats -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test-suite for generating floating-point related C code ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.Floats(testSuite) where import Data.SBV import Data.SBV.Internals import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "floats_cgen" ~: code `goldCheck` "floats_cgen.gold" ] where code = compileToCLib' "floatCodeGen" cases setup = do cgSRealType CgLongDouble cgIntegerSize 64 cgSetDriverValues [42, 43, 44] test1 nm f = (nm, do setup a <- cgInput "a" cgReturn (f a)) test2 nm f = (nm, do setup a <- cgInput "a" b <- cgInput "b" cgReturn (f a b)) test3 nm f = (nm, do setup a <- cgInput "a" b <- cgInput "b" c <- cgInput "c" cgReturn (f a b c)) cases = [ test1 "toFP_Int8_ToFloat" (toSFloat sRoundNearestTiesToEven :: SInt8 -> SFloat) , test1 "toFP_Int16_ToFloat" (toSFloat sRoundNearestTiesToEven :: SInt16 -> SFloat) , test1 "toFP_Int32_ToFloat" (toSFloat sRoundNearestTiesToEven :: SInt32 -> SFloat) , test1 "toFP_Int64_ToFloat" (toSFloat sRoundNearestTiesToEven :: SInt64 -> SFloat) , test1 "toFP_Word8_ToFloat" (toSFloat sRoundNearestTiesToEven :: SWord8 -> SFloat) , test1 "toFP_Word16_ToFloat" (toSFloat sRoundNearestTiesToEven :: SWord16 -> SFloat) , test1 "toFP_Word32_ToFloat" (toSFloat sRoundNearestTiesToEven :: SWord32 -> SFloat) , test1 "toFP_Word64_ToFloat" (toSFloat sRoundNearestTiesToEven :: SWord64 -> SFloat) , test1 "toFP_Float_ToFloat" (toSFloat sRoundNearestTiesToEven :: SFloat -> SFloat) , test1 "toFP_Double_ToFloat" (toSFloat sRoundNearestTiesToEven :: SDouble -> SFloat) , test1 "toFP_Integer_ToFloat" (toSFloat sRoundNearestTiesToEven :: SInteger -> SFloat) , test1 "toFP_Real_ToFloat" (toSFloat sRoundNearestTiesToEven :: SReal -> SFloat) , test1 "toFP_Int8_ToDouble" (toSDouble sRoundNearestTiesToEven :: SInt8 -> SDouble) , test1 "toFP_Int16_ToDouble" (toSDouble sRoundNearestTiesToEven :: SInt16 -> SDouble) , test1 "toFP_Int32_ToDouble" (toSDouble sRoundNearestTiesToEven :: SInt32 -> SDouble) , test1 "toFP_Int64_ToDouble" (toSDouble sRoundNearestTiesToEven :: SInt64 -> SDouble) , test1 "toFP_Word8_ToDouble" (toSDouble sRoundNearestTiesToEven :: SWord8 -> SDouble) , test1 "toFP_Word16_ToDouble" (toSDouble sRoundNearestTiesToEven :: SWord16 -> SDouble) , test1 "toFP_Word32_ToDouble" (toSDouble sRoundNearestTiesToEven :: SWord32 -> SDouble) , test1 "toFP_Word64_ToDouble" (toSDouble sRoundNearestTiesToEven :: SWord64 -> SDouble) , test1 "toFP_Float_ToDouble" (toSDouble sRoundNearestTiesToEven :: SFloat -> SDouble) , test1 "toFP_Double_ToDouble" (toSDouble sRoundNearestTiesToEven :: SDouble -> SDouble) , test1 "toFP_Integer_ToDouble" (toSDouble sRoundNearestTiesToEven :: SInteger -> SDouble) , test1 "toFP_Real_ToDouble" (toSDouble sRoundNearestTiesToEven :: SReal -> SDouble) , test1 "fromFP_Float_ToInt8" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt8) , test1 "fromFP_Float_ToInt16" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt16) , test1 "fromFP_Float_ToInt32" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt32) , test1 "fromFP_Float_ToInt64" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt64) , test1 "fromFP_Float_ToWord8" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord8) , test1 "fromFP_Float_ToWord16" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord16) , test1 "fromFP_Float_ToWord32" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord32) , test1 "fromFP_Float_ToWord64" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord64) , test1 "fromFP_Float_ToFloat" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SFloat) , test1 "fromFP_Float_ToDouble" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SDouble) , test1 "fromFP_Float_ToInteger" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInteger) , test1 "fromFP_Float_ToReal" (fromSFloat sRoundNearestTiesToEven :: SFloat -> SReal) , test1 "fromFP_DoubleTo_Int8" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt8) , test1 "fromFP_DoubleTo_Int16" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt16) , test1 "fromFP_DoubleTo_Int32" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt32) , test1 "fromFP_DoubleTo_Int64" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt64) , test1 "fromFP_DoubleTo_Word8" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord8) , test1 "fromFP_DoubleTo_Word16" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord16) , test1 "fromFP_DoubleTo_Word32" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord32) , test1 "fromFP_DoubleTo_Word64" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord64) , test1 "fromFP_DoubleTo_Float" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SFloat) , test1 "fromFP_DoubleTo_Double" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SDouble) , test1 "fromFP_DoubleTo_Integer" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInteger) , test1 "fromFP_DoubleTo_Real" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SReal) , test1 "fromFP_SWord32_SFloat" (sWord32AsSFloat :: SWord32 -> SFloat) , test1 "fromFP_SWord64_SDouble" (sWord64AsSDouble :: SWord64 -> SDouble) , test1 "fromFP_SFloat_SWord32" (sFloatAsSWord32 :: SFloat -> SWord32) , test1 "fromFP_SDouble_SWord64" (sDoubleAsSWord64 :: SDouble -> SWord64) , test1 "f_FP_Abs" (abs :: SFloat -> SFloat) , test1 "d_FP_Abs" (abs :: SDouble -> SDouble) , test1 "f_FP_Neg" (negate :: SFloat -> SFloat) , test1 "d_FP_Neg" (negate :: SDouble -> SDouble) , test2 "f_FP_Add" (fpAdd sRoundNearestTiesToEven :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Add" (fpAdd sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble) , test2 "f_FP_Sub" (fpSub sRoundNearestTiesToEven :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Sub" (fpSub sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble) , test2 "f_FP_Mul" (fpMul sRoundNearestTiesToEven :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Mul" (fpMul sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble) , test2 "f_FP_Div" (fpDiv sRoundNearestTiesToEven :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Div" (fpDiv sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble) , test3 "f_FP_FMA" (fpFMA sRoundNearestTiesToEven :: SFloat -> SFloat -> SFloat -> SFloat) , test3 "d_FP_FMA" (fpFMA sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble -> SDouble) , test1 "f_FP_Sqrt" (fpSqrt sRoundNearestTiesToEven :: SFloat -> SFloat) , test1 "d_FP_Sqrt" (fpSqrt sRoundNearestTiesToEven :: SDouble -> SDouble) , test2 "f_FP_Rem" (fpRem :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Rem" (fpRem :: SDouble -> SDouble -> SDouble) , test1 "f_FP_RoundToIntegral" (fpRoundToIntegral sRoundNearestTiesToEven :: SFloat -> SFloat) , test1 "d_FP_RoundToIntegral" (fpRoundToIntegral sRoundNearestTiesToEven :: SDouble -> SDouble) , test2 "f_FP_Min" (fpMin :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Min" (fpMin :: SDouble -> SDouble -> SDouble) , test2 "f_FP_Max" (fpMax :: SFloat -> SFloat -> SFloat) , test2 "d_FP_Max" (fpMax :: SDouble -> SDouble -> SDouble) , test2 "f_FP_IsEqualObject" (fpIsEqualObject :: SFloat -> SFloat -> SBool) , test2 "d_FP_IsEqualObject" (fpIsEqualObject :: SDouble -> SDouble -> SBool) , test1 "f_FP_IsNormal" (fpIsNormal :: SFloat -> SBool) , test1 "d_FP_IsNormal" (fpIsNormal :: SDouble -> SBool) , test1 "f_FP_IsZero" (fpIsZero :: SFloat -> SBool) , test1 "d_FP_IsZero" (fpIsZero :: SDouble -> SBool) , test1 "f_FP_IsSubnormal" (fpIsSubnormal :: SFloat -> SBool) , test1 "d_FP_IsSubnormal" (fpIsSubnormal :: SDouble -> SBool) , test1 "f_FP_IsInfinite" (fpIsInfinite :: SFloat -> SBool) , test1 "d_FP_IsInfinite" (fpIsInfinite :: SDouble -> SBool) , test1 "f_FP_IsNaN" (fpIsNaN :: SFloat -> SBool) , test1 "d_FP_IsNaN" (fpIsNaN :: SDouble -> SBool) , test1 "f_FP_IsNegative" (fpIsNegative :: SFloat -> SBool) , test1 "d_FP_IsNegative" (fpIsNegative :: SDouble -> SBool) , test1 "f_FP_IsPositive" (fpIsPositive :: SFloat -> SBool) , test1 "d_FP_IsPositive" (fpIsPositive :: SDouble -> SBool) ] {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/GCD.hs0000644000000000000000000000153512725411266020335 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.GCD -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.GCD ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.GCD(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.GCD import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "gcd" ~: gcdC `goldCheck` "gcd.gold" ] where gcdC = compileToC' "sgcd" $ do cgSetDriverValues [55,154] x <- cgInput "x" y <- cgInput "y" cgReturn $ sgcd x y sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/PopulationCount.hs0000644000000000000000000000177212725411266023106 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.PopulationCount -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.PopulationCount ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.PopulationCount(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.PopulationCount import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "popCount-1" ~: genC False `goldCheck` "popCount1.gold" , "popCount-2" ~: genC True `goldCheck` "popCount2.gold" ] where genC b = compileToC' "popCount" $ do cgSetDriverValues [0x0123456789ABCDEF] cgPerformRTCs b x <- cgInput "x" cgReturn $ popCountFast x sbv-5.12/SBVUnitTest/TestSuite/CodeGeneration/Uninterpreted.hs0000644000000000000000000000163712725411266022573 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CodeGeneration.Uninterpreted -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.CodeGeneration.Uninterpreted ----------------------------------------------------------------------------- module TestSuite.CodeGeneration.Uninterpreted(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.CodeGeneration.Uninterpreted import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "cgUninterpret" ~: genC `goldCheck` "cgUninterpret.gold" ] where genC = compileToC' "tstShiftLeft" $ do cgSetDriverValues [1, 2, 3] [x, y, z] <- cgInputArr 3 "vs" cgReturn $ tstShiftLeft x y z sbv-5.12/SBVUnitTest/TestSuite/CRC/0000755000000000000000000000000012725411266015121 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/CRC/CCITT.hs0000644000000000000000000000121712725411266016324 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CRC.CCITT -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.CRC.CCITT ----------------------------------------------------------------------------- module TestSuite.CRC.CCITT(testSuite) where import Data.SBV import Examples.CRC.CCITT import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "ccitt" ~: crcPgm `goldCheck` "ccitt.gold" ] where crcPgm = runSAT $ forAll_ crcGood >>= output sbv-5.12/SBVUnitTest/TestSuite/CRC/CCITT_Unidir.hs0000644000000000000000000000124112725411266017633 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CRC.CCITT_Unidir -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.CRC.CCITT_Unidir ----------------------------------------------------------------------------- module TestSuite.CRC.CCITT_Unidir(testSuite) where import Examples.CRC.CCITT_Unidir import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "ccitHDis3" ~: assert =<< isThm (crcUniGood 3) , "ccitHDis4" ~: assert . not =<< isThm (crcUniGood 4) ] sbv-5.12/SBVUnitTest/TestSuite/CRC/GenPoly.hs0000644000000000000000000000153212725411266017033 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CRC.GenPoly -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.CRC.GenPoly ----------------------------------------------------------------------------- module TestSuite.CRC.GenPoly(testSuite) where import Data.SBV import Examples.CRC.GenPoly import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "crcGood" ~: assert =<< isSat crcGoodE , "crcGood" ~: assert . not =<< isThm (crcGood 3 12) ] where crcGoodE = do x1 <- exists_ x2 <- exists_ y1 <- exists_ y2 <- exists_ return (crcGood 3 0 (x1,x2) (y1,y2)) sbv-5.12/SBVUnitTest/TestSuite/CRC/Parity.hs0000644000000000000000000000110212725411266016717 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CRC.Parity -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.CRC.Parity ----------------------------------------------------------------------------- module TestSuite.CRC.Parity(testSuite) where import Examples.CRC.Parity import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "parity" ~: assert =<< isThm parityOK ] sbv-5.12/SBVUnitTest/TestSuite/CRC/USB5.hs0000644000000000000000000000107212725411266016173 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.CRC.USB5 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.CRC.USB5 ----------------------------------------------------------------------------- module TestSuite.CRC.USB5(testSuite) where import Examples.CRC.USB5 import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "usbGood" ~: assert =<< isThm usbGood ] sbv-5.12/SBVUnitTest/TestSuite/Crypto/0000755000000000000000000000000012725411266015772 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Crypto/AES.hs0000644000000000000000000000261212725411266016737 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Crypto.AES -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Crypto.AES ----------------------------------------------------------------------------- module TestSuite.Crypto.AES(testSuite) where import Data.SBV import Data.SBV.Internals import Data.SBV.Examples.Crypto.AES import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "aes128Enc" ~: compileToC' "aes128Enc" (aes128EncDec True) `goldCheck` "aes128Enc.gold" , "aes128Dec" ~: compileToC' "aes128Dec" (aes128EncDec False) `goldCheck` "aes128Dec.gold" , "aes128Lib" ~: compileToCLib' "aes128Lib" aes128Comps `goldCheck` "aes128Lib.gold" ] where aes128EncDec d = do pt <- cgInputArr 4 "pt" key <- cgInputArr 4 "key" cgSetDriverValues $ repeat 0 let (encKs, decKs) = aesKeySchedule key res | d = aesEncrypt pt encKs | True = aesDecrypt pt decKs cgOutputArr "ct" res aes128Comps = [(f, setVals c) | (f, c) <- aes128LibComponents] setVals c = cgSetDriverValues (repeat 0) >> c sbv-5.12/SBVUnitTest/TestSuite/Crypto/RC4.hs0000644000000000000000000000124712725411266016722 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Crypto.RC4 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Crypto.RC4 ----------------------------------------------------------------------------- module TestSuite.Crypto.RC4(testSuite) where import Data.SBV import Data.SBV.Examples.Crypto.RC4 import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "rc4swap" ~: assert =<< isThm readWrite ] where readWrite i j = readSTree (writeSTree initS i j) i .== j sbv-5.12/SBVUnitTest/TestSuite/Existentials/0000755000000000000000000000000012725411266017166 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Existentials/CRCPolynomial.hs0000644000000000000000000000205212725411266022174 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Existentials.CRCPolynomial -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Existentials.CRCPolynomial ----------------------------------------------------------------------------- module TestSuite.Existentials.CRCPolynomial(testSuite) where import Data.SBV import Data.SBV.Examples.Existentials.CRCPolynomial import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "crcPolyExist" ~: pgm `goldCheck` "crcPolyExist.gold" ] where pgm = runSAT $ do p <- exists "poly" s <- do sh <- forall "sh" sl <- forall "sl" return (sh, sl) r <- do rh <- forall "rh" rl <- forall "rl" return (rh, rl) output $ sTestBit p 0 &&& crcGood 4 p s r sbv-5.12/SBVUnitTest/TestSuite/Polynomials/0000755000000000000000000000000012725411266017020 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Polynomials/Polynomials.hs0000644000000000000000000000135712725411266021670 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Polynomials.Polynomials -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Polynomials.Polynomials ----------------------------------------------------------------------------- module TestSuite.Polynomials.Polynomials(testSuite) where import Data.SBV.Examples.Polynomials.Polynomials import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "polynomial-1" ~: assert =<< isThm multUnit , "polynomial-2" ~: assert =<< isThm multComm , "polynomial-3" ~: assert =<< isThm polyDivMod ] sbv-5.12/SBVUnitTest/TestSuite/Puzzles/0000755000000000000000000000000012725411266016166 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Puzzles/Coins.hs0000644000000000000000000000166112725411266017601 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.Coins -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.Coins ----------------------------------------------------------------------------- module TestSuite.Puzzles.Coins(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.Coins import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "coins" ~: coinsPgm `goldCheck` "coins.gold" ] where coinsPgm = runSAT $ do cs <- mapM mkCoin [1..6] mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]] constrain $ bAnd $ zipWith (.>=) cs (tail cs) output $ sum cs .== 115 sbv-5.12/SBVUnitTest/TestSuite/Puzzles/Counts.hs0000644000000000000000000000143212725411266017775 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.Counts -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.Counts ----------------------------------------------------------------------------- module TestSuite.Puzzles.Counts(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.Counts import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "counts" ~: countPgm `goldCheck` "counts.gold" ] where countPgm = runSAT $ forAll_ puzzle' >>= output puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9] sbv-5.12/SBVUnitTest/TestSuite/Puzzles/DogCatMouse.hs0000644000000000000000000000242612725411266020700 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.DogCatMouse -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.DogCatMouse ----------------------------------------------------------------------------- module TestSuite.Puzzles.DogCatMouse(testSuite) where import Data.SBV -- import Data.SBV.Examples.Puzzles.DogCatMouse -- everything defined here import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "dog_cat_mouse" ~: allSat p `goldCheck` "dogCatMouse.gold" ] where p = do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"] solve [ dog .>= 1 -- at least one dog , cat .>= 1 -- at least one cat , mouse .>= 1 -- at least one mouse , dog + cat + mouse .== 100 -- buy precisely 100 animals , 1500 * dog + 100 * cat + 25 * mouse .== 10000 -- spend exactly 100 dollars (use cents since we don't have fractions) ] sbv-5.12/SBVUnitTest/TestSuite/Puzzles/Euler185.hs0000644000000000000000000000123012725411266020030 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.Euler185 -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.Euler185 ----------------------------------------------------------------------------- module TestSuite.Puzzles.Euler185(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.Euler185 import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "euler185" ~: allSat euler185 `goldCheck` "euler185.gold" ] sbv-5.12/SBVUnitTest/TestSuite/Puzzles/MagicSquare.hs0000644000000000000000000000140612725411266020724 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.MagicSquare -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.MagicSquare ----------------------------------------------------------------------------- module TestSuite.Puzzles.MagicSquare(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.MagicSquare import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "magic 2" ~: assert . not =<< isSat (mkMagic 2) , "magic 3" ~: assert =<< isSat (mkMagic 3) ] where mkMagic n = (isMagic . chunk n) `fmap` mkExistVars (n*n) sbv-5.12/SBVUnitTest/TestSuite/Puzzles/NQueens.hs0000644000000000000000000000242512725411266020103 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.NQueens -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.NQueens ----------------------------------------------------------------------------- module TestSuite.Puzzles.NQueens(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.NQueens import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ -- number of *distinct* solutions is given in http://en.wikipedia.org/wiki/Eight_queens_puzzle "nQueens 1" ~: assert $ (== 1) `fmap` numberOfModels (mkQueens 1) , "nQueens 2" ~: assert $ (== 0) `fmap` numberOfModels (mkQueens 2) , "nQueens 3" ~: assert $ (== 0) `fmap` numberOfModels (mkQueens 3) , "nQueens 4" ~: assert $ (== 2) `fmap` numberOfModels (mkQueens 4) , "nQueens 5" ~: assert $ (== 10) `fmap` numberOfModels (mkQueens 5) , "nQueens 6" ~: assert $ (== 4) `fmap` numberOfModels (mkQueens 6) , "nQueens 7" ~: assert $ (== 40) `fmap` numberOfModels (mkQueens 7) , "nQueens 8" ~: assert $ (== 92) `fmap` numberOfModels (mkQueens 8) ] where mkQueens n = isValid n `fmap` mkExistVars n sbv-5.12/SBVUnitTest/TestSuite/Puzzles/PowerSet.hs0000644000000000000000000000141312725411266020271 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.PowerSet -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Puzzles.PowerSet ----------------------------------------------------------------------------- module TestSuite.Puzzles.PowerSet(testSuite) where import Data.SBV import Examples.Puzzles.PowerSet import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "powerSet " ++ show i ~: assert (pSet i) | i <- [0 .. 7] ] where pSet :: Int -> IO Bool pSet n = do cnt <- numberOfModels $ genPowerSet `fmap` mkExistVars n return (cnt == 2^n) sbv-5.12/SBVUnitTest/TestSuite/Puzzles/Sudoku.hs0000644000000000000000000000144312725411266017776 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.Sudoku -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.Sudoku ----------------------------------------------------------------------------- module TestSuite.Puzzles.Sudoku(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.Sudoku import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "sudoku " ++ show n ~: assert (checkPuzzle s) | (n, s) <- zip [(0::Int)..] [puzzle0, puzzle1, puzzle2, puzzle3, puzzle4, puzzle5, puzzle6] ] where checkPuzzle (i, f) = isSat $ (valid . f) `fmap` mkExistVars i sbv-5.12/SBVUnitTest/TestSuite/Puzzles/Temperature.hs0000644000000000000000000000124612725411266021022 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.Temperature -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Puzzles.Temperature ----------------------------------------------------------------------------- module TestSuite.Puzzles.Temperature(testSuite) where import Data.SBV import Examples.Puzzles.Temperature import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "temperature" ~: allSat (revOf `fmap` exists_) `goldCheck` "temperature.gold" ] sbv-5.12/SBVUnitTest/TestSuite/Puzzles/U2Bridge.hs0000644000000000000000000000216312725411266020127 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Puzzles.U2Bridge -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Puzzles.U2Bridge ----------------------------------------------------------------------------- module TestSuite.Puzzles.U2Bridge(testSuite) where import Data.SBV import Data.SBV.Examples.Puzzles.U2Bridge import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "U2Bridge-1" ~: assert $ (0 ==) `fmap` count 1 , "U2Bridge-2" ~: assert $ (0 ==) `fmap` count 2 , "U2Bridge-3" ~: assert $ (0 ==) `fmap` count 3 , "U2Bridge-4" ~: assert $ (0 ==) `fmap` count 4 , "U2Bridge-5" ~: slv 5 `goldCheck` "U2Bridge.gold" , "U2Bridge-6" ~: assert $ (0 ==) `fmap` count 6 ] where act = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2) count n = numberOfModels $ isValid `fmap` mapM (const act) [1..(n::Int)] slv n = sat $ isValid `fmap` mapM (const act) [1..(n::Int)] sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/0000755000000000000000000000000012725411266017342 5ustar0000000000000000sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/AUF.hs0000644000000000000000000000214512725411266020313 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Uninterpreted.AUF -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Data.SBV.Examples.Uninterpreted.AUF ----------------------------------------------------------------------------- module TestSuite.Uninterpreted.AUF where import Data.SBV import Data.SBV.Examples.Uninterpreted.AUF import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \goldCheck -> test [ "auf-0" ~: assert =<< isThm (newArray "a" Nothing >>= \a -> free "x" >>= \x -> free "y" >>= \y -> free "i" >>= \i -> return (thm1 x y a i)) , "auf-1" ~: assert =<< isThm (newArray "b" Nothing >>= \b -> free "x" >>= \x -> free "y" >>= \y -> return (thm2 x y b)) , "auf-2" ~: pgm `goldCheck` "auf-1.gold" ] where pgm = runSAT $ do x <- free "x" y <- free "y" a <- newArray "a" Nothing i <- free "initVal" output $ thm1 x y a i sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/Axioms.hs0000644000000000000000000000243212725411266021137 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Uninterpreted.Axioms -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for basic axioms and uninterpreted functions ----------------------------------------------------------------------------- {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} module TestSuite.Uninterpreted.Axioms(testSuite) where import Data.SBV import SBVTest import Data.Generics -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "unint-axioms" ~: assert =<< isThm p0 ] -- Example provided by Thomas DuBuisson: data Bitstring = Bitstring () deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind) type SBitstring = SBV Bitstring a :: SBitstring -> SBool a = uninterpret "a" e :: SBitstring -> SBitstring -> SBitstring e = uninterpret "e" axE :: [String] axE = [ "(assert (forall ((p Bitstring) (k Bitstring))" , " (=> (and (a k) (a p)) (a (e k p)))))" ] p0 :: Symbolic SBool p0 = do p <- free "p" :: Symbolic SBitstring k <- free "k" :: Symbolic SBitstring addAxiom "axE" axE constrain $ a p constrain $ a k return $ a (e k p) sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/Function.hs0000644000000000000000000000117212725411266021464 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Uninterpreted.Function -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Testsuite for Data.SBV.Examples.Uninterpreted.Function ----------------------------------------------------------------------------- module TestSuite.Uninterpreted.Function where import Data.SBV.Examples.Uninterpreted.Function import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "aufunc-0" ~: assert =<< isThm thmGood ] sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/Sort.hs0000644000000000000000000000235012725411266020625 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : TestSuite.Uninterpreted.Sort -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for uninterpreted sorts ----------------------------------------------------------------------------- {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE ScopedTypeVariables #-} module TestSuite.Uninterpreted.Sort where import Data.SBV import SBVTest import Data.Generics -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "unint-sort" ~: assert . (==4) . length . (extractModels :: AllSatResult -> [L]) =<< allSat p0 ] data L = Nil | Cons Int L deriving (Eq, Ord, Data, Read, Show) instance SymWord L instance HasKind L instance SatModel L where parseCWs = undefined -- make GHC shut up about the missing method, we won't actually call it type SList = SBV L len :: SList -> SInteger len = uninterpret "len" p0 :: Symbolic SBool p0 = do [l, l0, l1] <- symbolics ["l", "l0", "l1"] constrain $ len l0 .== 0 constrain $ len l1 .== 1 x :: SInteger <- symbolic "x" constrain $ x .== 0 ||| x.== 1 return $ l .== l0 ||| l .== l1 sbv-5.12/SBVUnitTest/TestSuite/Uninterpreted/Uninterpreted.hs0000644000000000000000000000134312725411266022527 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Examples.TestSuite.Uninterpreted -- Copyright : (c) Levent Erkok -- License : BSD3 -- Maintainer : erkokl@gmail.com -- Stability : experimental -- -- Test suite for Examples.Uninterpreted.Uninterpreted ----------------------------------------------------------------------------- module TestSuite.Uninterpreted.Uninterpreted where import Examples.Uninterpreted.Uninterpreted import SBVTest -- Test suite testSuite :: SBVTestSuite testSuite = mkTestSuite $ \_ -> test [ "uninterpreted-0" ~: assert =<< isThm p0 , "uninterpreted-1" ~: assert =<< isThm p1 , "uninterpreted-2" ~: assert . not =<< isThm p2 ]