Cheng Shao pushed to branch wip/foundation-improve-coverage at Glasgow Haskell Compiler / GHC

Commits:

3 changed files:

Changes:

  • testsuite/tests/numeric/should_run/all.T
    ... ... @@ -3,6 +3,8 @@
    3 3 
     #	extra run flags
    4 4 
     #	expected process return value, if not zero
    5 5
    6 
    +import random
    7 
    +
    6 8 
     test('arith001', normal, compile_and_run, [''])
    7 9 
     test('arith002', normal, compile_and_run, [''])
    8 10 
     test('arith003', normal, compile_and_run, [''])
    ... ... @@ -82,7 +84,7 @@ test('IntegerToFloat', normal, compile_and_run, [''])
    82 84 
     test('T20291', normal, compile_and_run, [''])
    83 85 
     test('T22282', normal, compile_and_run, [''])
    84 86 
     test('T22671', js_fragile(24259), compile_and_run, [''])
    85 
    -test('foundation', [when(js_arch(), run_timeout_multiplier(2)), js_fragile(24259), extra_ways(['optasm','ghci','ghci-opt'])], compile_and_run, ['-package transformers -fno-break-points'])
    87 
    +test('foundation', [run_timeout_multiplier(2), js_fragile(24259), extra_ways(['optasm','ghci','ghci-opt']), extra_run_opts(str(random.getrandbits(64)))], compile_and_run, ['-fno-break-points'])
    86 88 
     test('T24066', normal, compile_and_run, [''])
    87 89 
     test('div01', normal, compile_and_run, [''])
    88 90 
     test('T24245', normal, compile_and_run, [''])

  • testsuite/tests/numeric/should_run/foundation.hs
    ... ... @@ -10,9 +10,7 @@
    10 10 
       compare the result of the primop wrappers with the results of interpretation.
    11 11 
     -}
    12 12
    13 
    -{-# LANGUAGE FlexibleContexts    #-}
    14 13 
     {-# LANGUAGE OverloadedStrings   #-}
    15 
    -{-# LANGUAGE ScopedTypeVariables #-}
    16 14 
     {-# LANGUAGE TypeAbstractions #-}
    17 15 
     {-# LANGUAGE TypeFamilies        #-}
    18 16 
     {-# LANGUAGE DerivingStrategies #-}
    ... ... @@ -25,28 +23,23 @@ module Main
    25 23 
         ( main
    26 24 
         ) where
    27 25
    26 
    +import Data.Array.Byte
    28 27 
     import Data.Bits (Bits((.&.), bit), FiniteBits, finiteBitSize)
    29 28 
     import Data.Word
    30 29 
     import Data.Int
    31 30 
     import GHC.Natural
    32 31 
     import Data.Typeable
    33 
    -import Data.Proxy
    34 32 
     import GHC.Int
    35 33 
     import GHC.Word
    36 
    -import GHC.Word
    37 34 
     import Data.Function
    38 35 
     import GHC.Prim
    39 36 
     import Control.Monad.Reader
    40 
    -import System.IO
    41 
    -import Foreign.Marshal.Alloc
    42 
    -import Foreign.Storable
    43 
    -import Foreign.Ptr
    44 37 
     import Data.List (intercalate)
    45 
    -import Data.IORef
    38 
    +import System.Environment (getArgs)
    39 
    +import Text.Read (readMaybe)
    46 40 
     import Unsafe.Coerce
    47 41 
     import GHC.Types
    48 42 
     import Data.Char
    49 
    -import Data.Semigroup
    50 43 
     import System.Exit
    51 44
    52 45 
     import qualified GHC.Internal.PrimopWrappers as Wrapper
    ... ... @@ -194,11 +187,16 @@ newtype LCGGen = LCGGen { randomWord64 :: IO Word64 }
    194 187 
     data LCGParams = LCGParams { seed :: Word64, a :: Word64, c :: Word64, m :: Word64 }
    195 188
    196 189 
     newLCGGen :: LCGParams -> IO LCGGen
    197 
    -newLCGGen LCGParams{..}  = do
    198 
    -  var <- newIORef (fromIntegral seed)
    199 
    -  return $ LCGGen $ do
    200 
    -    atomicModifyIORef' var (\old_v -> let new_val = (old_v * a + c) `mod` m in (new_val, new_val))
    201 
    -
    190 
    +newLCGGen LCGParams {seed = W64# seed#, ..} = do
    191 
    +  MutableByteArray mba# <- IO $ \s0 -> case newByteArray# 8# s0 of
    192 
    +    (# s1, mba# #) -> case writeWord64Array# mba# 0# seed# s1 of
    193 
    +      s2 -> (# s2, MutableByteArray mba# #)
    194 
    +  pure $ LCGGen $ IO $ \s0 -> case readWord64Array# mba# 0# s0 of
    195 
    +    (# s1, old_val# #) ->
    196 
    +      let old_val = W64# old_val#
    197 
    +          !new_val@(W64# new_val#) = (old_val * a + c) `mod` m
    198 
    +       in case writeWord64Array# mba# 0# new_val# s1 of
    199 
    +            s2 -> (# s2, new_val #)
    202 200
    203 201 
     runPropertyCheck (PropertyBinaryOp res desc s1 s2) =
    204 202 
       if res then return Success
    ... ... @@ -211,7 +209,7 @@ runPropertyCheck (PropertyAnd a1 a2) = (<>) <$> runPropertyCheck a1 <*> runPrope
    211 209
    212 210 
     runProperty :: Property -> ReaderT RunS IO Result
    213 211 
     runProperty (Prop p) = do
    214 
    -  let iterations = 100
    212 
    +  let iterations = 1000 :: Int
    215 213 
       loop iterations iterations
    216 214 
       where
    217 215 
         loop iterations 0 = do
    ... ... @@ -257,14 +255,15 @@ runTestInternal (Property name p) = do
    257 255 
       nest label $ runProperty (property p)
    258 256
    259 257
    260 
    -runTests :: Test -> IO ()
    261 
    -runTests t = do
    258 
    +runTests :: Word64 -> Test -> IO ()
    259 
    +runTests seed t = do
    262 260 
       -- These params are the same ones as glibc uses.
    263 
    -  h <- newLCGGen (LCGParams { seed = 1238123213, m = 2^31, a = 1103515245, c = 12345 })
    261 
    +  h <- newLCGGen (LCGParams { seed, m = 2 ^ (31 :: Int), a = 1103515245, c = 12345 })
    264 262 
       res <- runReaderT  (runTestInternal t) (RunS 0 h [])
    265 263 
       case res of
    266 264 
         Success -> return ()
    267 265 
         Failure tests -> do
    266 
    +      putStrLn $ "Seed: " ++ show seed
    268 267 
           putStrLn $ "These tests failed:  \n" ++ intercalate "  \n" (map (showStack 0 . reverse) tests)
    269 268 
           exitFailure
    270 269
    ... ... @@ -455,7 +454,19 @@ instance TestPrimop LowerBitsAreDefined where
    455 454 
     twoNonZero :: (a -> a -> b) -> a -> NonZero a -> b
    456 455 
     twoNonZero f x (NonZero y) = f x y
    457 456
    458 
    -main = runTests (Group "ALL" [testNumberRefs, testPrimops])
    457 
    +getSeedFromArgs :: IO Word64
    458 
    +getSeedFromArgs = do
    459 
    +  args <- getArgs
    460 
    +  case args of
    461 
    +    [arg] -> case readMaybe arg of
    462 
    +      Just seed -> pure seed
    463 
    +      Nothing -> die $ "Invalid seed (expected Word64): " ++ show arg
    464 
    +    _ -> die "Usage: foundation <seed>"
    465 
    +
    466 
    +main :: IO ()
    467 
    +main = do
    468 
    +  seed <- getSeedFromArgs
    469 
    +  runTests seed (Group "ALL" [testNumberRefs, testPrimops])
    459 470
    460 471 
     -- Test an interpreted primop vs a compiled primop
    461 472 
     testPrimops = Group "primop"

  • testsuite/tests/numeric/should_run/foundation.stdout
    ... ... @@ -3,1048 +3,1048 @@ Group ALL
    3 3 
         Group Int
    4 4 
           Group Integral
    5 5 
             Running FromIntegral(Integer(a)) == a
    6 
    -          Passed 100 iterations
    6 
    +          Passed 1000 iterations
    7 7 
           Group Property
    8 8 
             Running Eq
    9 
    -          Passed 100 iterations
    9 
    +          Passed 1000 iterations
    10 10 
             Running Show
    11 
    -          Passed 100 iterations
    11 
    +          Passed 1000 iterations
    12 12 
             Running Ord
    13 
    -          Passed 100 iterations
    13 
    +          Passed 1000 iterations
    14 14 
             Running <
    15 
    -          Passed 100 iterations
    15 
    +          Passed 1000 iterations
    16 16 
           Group Additive
    17 17 
             Running a + azero == a
    18 
    -          Passed 100 iterations
    18 
    +          Passed 1000 iterations
    19 19 
             Running azero + a == a
    20 
    -          Passed 100 iterations
    20 
    +          Passed 1000 iterations
    21 21 
             Running a + b == b + a
    22 
    -          Passed 100 iterations
    22 
    +          Passed 1000 iterations
    23 23 
           Group Multiplicative
    24 24 
             Running a * 1 == a
    25 
    -          Passed 100 iterations
    25 
    +          Passed 1000 iterations
    26 26 
             Running 1 * a == a
    27 
    -          Passed 100 iterations
    27 
    +          Passed 1000 iterations
    28 28 
             Running multiplication commutative
    29 
    -          Passed 100 iterations
    29 
    +          Passed 1000 iterations
    30 30 
             Running a * b == Integer(a) * Integer(b)
    31 
    -          Passed 100 iterations
    31 
    +          Passed 1000 iterations
    32 32 
           Group Divisible
    33 33 
             Running (x `div` y) * y + (x `mod` y) == x
    34 
    -          Passed 100 iterations
    34 
    +          Passed 1000 iterations
    35 35 
           Group Precedence
    36 36 
             Running + and - (1)
    37 
    -          Passed 100 iterations
    37 
    +          Passed 1000 iterations
    38 38 
             Running + and - (2)
    39 
    -          Passed 100 iterations
    39 
    +          Passed 1000 iterations
    40 40 
             Running + and * (1)
    41 
    -          Passed 100 iterations
    41 
    +          Passed 1000 iterations
    42 42 
             Running + and * (2)
    43 
    -          Passed 100 iterations
    43 
    +          Passed 1000 iterations
    44 44 
             Running - and * (1)
    45 
    -          Passed 100 iterations
    45 
    +          Passed 1000 iterations
    46 46 
             Running - and * (2)
    47 
    -          Passed 100 iterations
    47 
    +          Passed 1000 iterations
    48 48 
             Running * and ^ (1)
    49 
    -          Passed 100 iterations
    49 
    +          Passed 1000 iterations
    50 50 
             Running * and ^ (2)
    51 
    -          Passed 100 iterations
    51 
    +          Passed 1000 iterations
    52 52 
         Group Int8
    53 53 
           Group Integral
    54 54 
             Running FromIntegral(Integer(a)) == a
    55 
    -          Passed 100 iterations
    55 
    +          Passed 1000 iterations
    56 56 
           Group Property
    57 57 
             Running Eq
    58 
    -          Passed 100 iterations
    58 
    +          Passed 1000 iterations
    59 59 
             Running Show
    60 
    -          Passed 100 iterations
    60 
    +          Passed 1000 iterations
    61 61 
             Running Ord
    62 
    -          Passed 100 iterations
    62 
    +          Passed 1000 iterations
    63 63 
             Running <
    64 
    -          Passed 100 iterations
    64 
    +          Passed 1000 iterations
    65 65 
           Group Additive
    66 66 
             Running a + azero == a
    67 
    -          Passed 100 iterations
    67 
    +          Passed 1000 iterations
    68 68 
             Running azero + a == a
    69 
    -          Passed 100 iterations
    69 
    +          Passed 1000 iterations
    70 70 
             Running a + b == b + a
    71 
    -          Passed 100 iterations
    71 
    +          Passed 1000 iterations
    72 72 
           Group Multiplicative
    73 73 
             Running a * 1 == a
    74 
    -          Passed 100 iterations
    74 
    +          Passed 1000 iterations
    75 75 
             Running 1 * a == a
    76 
    -          Passed 100 iterations
    76 
    +          Passed 1000 iterations
    77 77 
             Running multiplication commutative
    78 
    -          Passed 100 iterations
    78 
    +          Passed 1000 iterations
    79 79 
             Running a * b == Integer(a) * Integer(b)
    80 
    -          Passed 100 iterations
    80 
    +          Passed 1000 iterations
    81 81 
           Group Divisible
    82 82 
             Running (x `div` y) * y + (x `mod` y) == x
    83 
    -          Passed 100 iterations
    83 
    +          Passed 1000 iterations
    84 84 
           Group Precedence
    85 85 
             Running + and - (1)
    86 
    -          Passed 100 iterations
    86 
    +          Passed 1000 iterations
    87 87 
             Running + and - (2)
    88 
    -          Passed 100 iterations
    88 
    +          Passed 1000 iterations
    89 89 
             Running + and * (1)
    90 
    -          Passed 100 iterations
    90 
    +          Passed 1000 iterations
    91 91 
             Running + and * (2)
    92 
    -          Passed 100 iterations
    92 
    +          Passed 1000 iterations
    93 93 
             Running - and * (1)
    94 
    -          Passed 100 iterations
    94 
    +          Passed 1000 iterations
    95 95 
             Running - and * (2)
    96 
    -          Passed 100 iterations
    96 
    +          Passed 1000 iterations
    97 97 
             Running * and ^ (1)
    98 
    -          Passed 100 iterations
    98 
    +          Passed 1000 iterations
    99 99 
             Running * and ^ (2)
    100 
    -          Passed 100 iterations
    100 
    +          Passed 1000 iterations
    101 101 
         Group Int16
    102 102 
           Group Integral
    103 103 
             Running FromIntegral(Integer(a)) == a
    104 
    -          Passed 100 iterations
    104 
    +          Passed 1000 iterations
    105 105 
           Group Property
    106 106 
             Running Eq
    107 
    -          Passed 100 iterations
    107 
    +          Passed 1000 iterations
    108 108 
             Running Show
    109 
    -          Passed 100 iterations
    109 
    +          Passed 1000 iterations
    110 110 
             Running Ord
    111 
    -          Passed 100 iterations
    111 
    +          Passed 1000 iterations
    112 112 
             Running <
    113 
    -          Passed 100 iterations
    113 
    +          Passed 1000 iterations
    114 114 
           Group Additive
    115 115 
             Running a + azero == a
    116 
    -          Passed 100 iterations
    116 
    +          Passed 1000 iterations
    117 117 
             Running azero + a == a
    118 
    -          Passed 100 iterations
    118 
    +          Passed 1000 iterations
    119 119 
             Running a + b == b + a
    120 
    -          Passed 100 iterations
    120 
    +          Passed 1000 iterations
    121 121 
           Group Multiplicative
    122 122 
             Running a * 1 == a
    123 
    -          Passed 100 iterations
    123 
    +          Passed 1000 iterations
    124 124 
             Running 1 * a == a
    125 
    -          Passed 100 iterations
    125 
    +          Passed 1000 iterations
    126 126 
             Running multiplication commutative
    127 
    -          Passed 100 iterations
    127 
    +          Passed 1000 iterations
    128 128 
             Running a * b == Integer(a) * Integer(b)
    129 
    -          Passed 100 iterations
    129 
    +          Passed 1000 iterations
    130 130 
           Group Divisible
    131 131 
             Running (x `div` y) * y + (x `mod` y) == x
    132 
    -          Passed 100 iterations
    132 
    +          Passed 1000 iterations
    133 133 
           Group Precedence
    134 134 
             Running + and - (1)
    135 
    -          Passed 100 iterations
    135 
    +          Passed 1000 iterations
    136 136 
             Running + and - (2)
    137 
    -          Passed 100 iterations
    137 
    +          Passed 1000 iterations
    138 138 
             Running + and * (1)
    139 
    -          Passed 100 iterations
    139 
    +          Passed 1000 iterations
    140 140 
             Running + and * (2)
    141 
    -          Passed 100 iterations
    141 
    +          Passed 1000 iterations
    142 142 
             Running - and * (1)
    143 
    -          Passed 100 iterations
    143 
    +          Passed 1000 iterations
    144 144 
             Running - and * (2)
    145 
    -          Passed 100 iterations
    145 
    +          Passed 1000 iterations
    146 146 
             Running * and ^ (1)
    147 
    -          Passed 100 iterations
    147 
    +          Passed 1000 iterations
    148 148 
             Running * and ^ (2)
    149 
    -          Passed 100 iterations
    149 
    +          Passed 1000 iterations
    150 150 
         Group Int32
    151 151 
           Group Integral
    152 152 
             Running FromIntegral(Integer(a)) == a
    153 
    -          Passed 100 iterations
    153 
    +          Passed 1000 iterations
    154 154 
           Group Property
    155 155 
             Running Eq
    156 
    -          Passed 100 iterations
    156 
    +          Passed 1000 iterations
    157 157 
             Running Show
    158 
    -          Passed 100 iterations
    158 
    +          Passed 1000 iterations
    159 159 
             Running Ord
    160 
    -          Passed 100 iterations
    160 
    +          Passed 1000 iterations
    161 161 
             Running <
    162 
    -          Passed 100 iterations
    162 
    +          Passed 1000 iterations
    163 163 
           Group Additive
    164 164 
             Running a + azero == a
    165 
    -          Passed 100 iterations
    165 
    +          Passed 1000 iterations
    166 166 
             Running azero + a == a
    167 
    -          Passed 100 iterations
    167 
    +          Passed 1000 iterations
    168 168 
             Running a + b == b + a
    169 
    -          Passed 100 iterations
    169 
    +          Passed 1000 iterations
    170 170 
           Group Multiplicative
    171 171 
             Running a * 1 == a
    172 
    -          Passed 100 iterations
    172 
    +          Passed 1000 iterations
    173 173 
             Running 1 * a == a
    174 
    -          Passed 100 iterations
    174 
    +          Passed 1000 iterations
    175 175 
             Running multiplication commutative
    176 
    -          Passed 100 iterations
    176 
    +          Passed 1000 iterations
    177 177 
             Running a * b == Integer(a) * Integer(b)
    178 
    -          Passed 100 iterations
    178 
    +          Passed 1000 iterations
    179 179 
           Group Divisible
    180 180 
             Running (x `div` y) * y + (x `mod` y) == x
    181 
    -          Passed 100 iterations
    181 
    +          Passed 1000 iterations
    182 182 
           Group Precedence
    183 183 
             Running + and - (1)
    184 
    -          Passed 100 iterations
    184 
    +          Passed 1000 iterations
    185 185 
             Running + and - (2)
    186 
    -          Passed 100 iterations
    186 
    +          Passed 1000 iterations
    187 187 
             Running + and * (1)
    188 
    -          Passed 100 iterations
    188 
    +          Passed 1000 iterations
    189 189 
             Running + and * (2)
    190 
    -          Passed 100 iterations
    190 
    +          Passed 1000 iterations
    191 191 
             Running - and * (1)
    192 
    -          Passed 100 iterations
    192 
    +          Passed 1000 iterations
    193 193 
             Running - and * (2)
    194 
    -          Passed 100 iterations
    194 
    +          Passed 1000 iterations
    195 195 
             Running * and ^ (1)
    196 
    -          Passed 100 iterations
    196 
    +          Passed 1000 iterations
    197 197 
             Running * and ^ (2)
    198 
    -          Passed 100 iterations
    198 
    +          Passed 1000 iterations
    199 199 
         Group Int64
    200 200 
           Group Integral
    201 201 
             Running FromIntegral(Integer(a)) == a
    202 
    -          Passed 100 iterations
    202 
    +          Passed 1000 iterations
    203 203 
           Group Property
    204 204 
             Running Eq
    205 
    -          Passed 100 iterations
    205 
    +          Passed 1000 iterations
    206 206 
             Running Show
    207 
    -          Passed 100 iterations
    207 
    +          Passed 1000 iterations
    208 208 
             Running Ord
    209 
    -          Passed 100 iterations
    209 
    +          Passed 1000 iterations
    210 210 
             Running <
    211 
    -          Passed 100 iterations
    211 
    +          Passed 1000 iterations
    212 212 
           Group Additive
    213 213 
             Running a + azero == a
    214 
    -          Passed 100 iterations
    214 
    +          Passed 1000 iterations
    215 215 
             Running azero + a == a
    216 
    -          Passed 100 iterations
    216 
    +          Passed 1000 iterations
    217 217 
             Running a + b == b + a
    218 
    -          Passed 100 iterations
    218 
    +          Passed 1000 iterations
    219 219 
           Group Multiplicative
    220 220 
             Running a * 1 == a
    221 
    -          Passed 100 iterations
    221 
    +          Passed 1000 iterations
    222 222 
             Running 1 * a == a
    223 
    -          Passed 100 iterations
    223 
    +          Passed 1000 iterations
    224 224 
             Running multiplication commutative
    225 
    -          Passed 100 iterations
    225 
    +          Passed 1000 iterations
    226 226 
             Running a * b == Integer(a) * Integer(b)
    227 
    -          Passed 100 iterations
    227 
    +          Passed 1000 iterations
    228 228 
           Group Divisible
    229 229 
             Running (x `div` y) * y + (x `mod` y) == x
    230 
    -          Passed 100 iterations
    230 
    +          Passed 1000 iterations
    231 231 
           Group Precedence
    232 232 
             Running + and - (1)
    233 
    -          Passed 100 iterations
    233 
    +          Passed 1000 iterations
    234 234 
             Running + and - (2)
    235 
    -          Passed 100 iterations
    235 
    +          Passed 1000 iterations
    236 236 
             Running + and * (1)
    237 
    -          Passed 100 iterations
    237 
    +          Passed 1000 iterations
    238 238 
             Running + and * (2)
    239 
    -          Passed 100 iterations
    239 
    +          Passed 1000 iterations
    240 240 
             Running - and * (1)
    241 
    -          Passed 100 iterations
    241 
    +          Passed 1000 iterations
    242 242 
             Running - and * (2)
    243 
    -          Passed 100 iterations
    243 
    +          Passed 1000 iterations
    244 244 
             Running * and ^ (1)
    245 
    -          Passed 100 iterations
    245 
    +          Passed 1000 iterations
    246 246 
             Running * and ^ (2)
    247 
    -          Passed 100 iterations
    247 
    +          Passed 1000 iterations
    248 248 
         Group Integer
    249 249 
           Group Integral
    250 250 
             Running FromIntegral(Integer(a)) == a
    251 
    -          Passed 100 iterations
    251 
    +          Passed 1000 iterations
    252 252 
           Group Property
    253 253 
             Running Eq
    254 
    -          Passed 100 iterations
    254 
    +          Passed 1000 iterations
    255 255 
             Running Show
    256 
    -          Passed 100 iterations
    256 
    +          Passed 1000 iterations
    257 257 
             Running Ord
    258 
    -          Passed 100 iterations
    258 
    +          Passed 1000 iterations
    259 259 
             Running <
    260 
    -          Passed 100 iterations
    260 
    +          Passed 1000 iterations
    261 261 
           Group Additive
    262 262 
             Running a + azero == a
    263 
    -          Passed 100 iterations
    263 
    +          Passed 1000 iterations
    264 264 
             Running azero + a == a
    265 
    -          Passed 100 iterations
    265 
    +          Passed 1000 iterations
    266 266 
             Running a + b == b + a
    267 
    -          Passed 100 iterations
    267 
    +          Passed 1000 iterations
    268 268 
           Group Multiplicative
    269 269 
             Running a * 1 == a
    270 
    -          Passed 100 iterations
    270 
    +          Passed 1000 iterations
    271 271 
             Running 1 * a == a
    272 
    -          Passed 100 iterations
    272 
    +          Passed 1000 iterations
    273 273 
             Running multiplication commutative
    274 
    -          Passed 100 iterations
    274 
    +          Passed 1000 iterations
    275 275 
             Running a * b == Integer(a) * Integer(b)
    276 
    -          Passed 100 iterations
    276 
    +          Passed 1000 iterations
    277 277 
           Group Divisible
    278 278 
             Running (x `div` y) * y + (x `mod` y) == x
    279 
    -          Passed 100 iterations
    279 
    +          Passed 1000 iterations
    280 280 
           Group Precedence
    281 281 
             Running + and - (1)
    282 
    -          Passed 100 iterations
    282 
    +          Passed 1000 iterations
    283 283 
             Running + and - (2)
    284 
    -          Passed 100 iterations
    284 
    +          Passed 1000 iterations
    285 285 
             Running + and * (1)
    286 
    -          Passed 100 iterations
    286 
    +          Passed 1000 iterations
    287 287 
             Running + and * (2)
    288 
    -          Passed 100 iterations
    288 
    +          Passed 1000 iterations
    289 289 
             Running - and * (1)
    290 
    -          Passed 100 iterations
    290 
    +          Passed 1000 iterations
    291 291 
             Running - and * (2)
    292 
    -          Passed 100 iterations
    292 
    +          Passed 1000 iterations
    293 293 
             Running * and ^ (1)
    294 
    -          Passed 100 iterations
    294 
    +          Passed 1000 iterations
    295 295 
             Running * and ^ (2)
    296 
    -          Passed 100 iterations
    296 
    +          Passed 1000 iterations
    297 297 
         Group Word
    298 298 
           Group Integral
    299 299 
             Running FromIntegral(Integer(a)) == a
    300 
    -          Passed 100 iterations
    300 
    +          Passed 1000 iterations
    301 301 
           Group Property
    302 302 
             Running Eq
    303 
    -          Passed 100 iterations
    303 
    +          Passed 1000 iterations
    304 304 
             Running Show
    305 
    -          Passed 100 iterations
    305 
    +          Passed 1000 iterations
    306 306 
             Running Ord
    307 
    -          Passed 100 iterations
    307 
    +          Passed 1000 iterations
    308 308 
             Running <
    309 
    -          Passed 100 iterations
    309 
    +          Passed 1000 iterations
    310 310 
           Group Additive
    311 311 
             Running a + azero == a
    312 
    -          Passed 100 iterations
    312 
    +          Passed 1000 iterations
    313 313 
             Running azero + a == a
    314 
    -          Passed 100 iterations
    314 
    +          Passed 1000 iterations
    315 315 
             Running a + b == b + a
    316 
    -          Passed 100 iterations
    316 
    +          Passed 1000 iterations
    317 317 
           Group Multiplicative
    318 318 
             Running a * 1 == a
    319 
    -          Passed 100 iterations
    319 
    +          Passed 1000 iterations
    320 320 
             Running 1 * a == a
    321 
    -          Passed 100 iterations
    321 
    +          Passed 1000 iterations
    322 322 
             Running multiplication commutative
    323 
    -          Passed 100 iterations
    323 
    +          Passed 1000 iterations
    324 324 
             Running a * b == Integer(a) * Integer(b)
    325 
    -          Passed 100 iterations
    325 
    +          Passed 1000 iterations
    326 326 
           Group Divisible
    327 327 
             Running (x `div` y) * y + (x `mod` y) == x
    328 
    -          Passed 100 iterations
    328 
    +          Passed 1000 iterations
    329 329 
           Group Precedence
    330 330 
             Running + and - (1)
    331 
    -          Passed 100 iterations
    331 
    +          Passed 1000 iterations
    332 332 
             Running + and - (2)
    333 
    -          Passed 100 iterations
    333 
    +          Passed 1000 iterations
    334 334 
             Running + and * (1)
    335 
    -          Passed 100 iterations
    335 
    +          Passed 1000 iterations
    336 336 
             Running + and * (2)
    337 
    -          Passed 100 iterations
    337 
    +          Passed 1000 iterations
    338 338 
             Running - and * (1)
    339 
    -          Passed 100 iterations
    339 
    +          Passed 1000 iterations
    340 340 
             Running - and * (2)
    341 
    -          Passed 100 iterations
    341 
    +          Passed 1000 iterations
    342 342 
             Running * and ^ (1)
    343 
    -          Passed 100 iterations
    343 
    +          Passed 1000 iterations
    344 344 
             Running * and ^ (2)
    345 
    -          Passed 100 iterations
    345 
    +          Passed 1000 iterations
    346 346 
         Group Word8
    347 347 
           Group Integral
    348 348 
             Running FromIntegral(Integer(a)) == a
    349 
    -          Passed 100 iterations
    349 
    +          Passed 1000 iterations
    350 350 
           Group Property
    351 351 
             Running Eq
    352 
    -          Passed 100 iterations
    352 
    +          Passed 1000 iterations
    353 353 
             Running Show
    354 
    -          Passed 100 iterations
    354 
    +          Passed 1000 iterations
    355 355 
             Running Ord
    356 
    -          Passed 100 iterations
    356 
    +          Passed 1000 iterations
    357 357 
             Running <
    358 
    -          Passed 100 iterations
    358 
    +          Passed 1000 iterations
    359 359 
           Group Additive
    360 360 
             Running a + azero == a
    361 
    -          Passed 100 iterations
    361 
    +          Passed 1000 iterations
    362 362 
             Running azero + a == a
    363 
    -          Passed 100 iterations
    363 
    +          Passed 1000 iterations
    364 364 
             Running a + b == b + a
    365 
    -          Passed 100 iterations
    365 
    +          Passed 1000 iterations
    366 366 
           Group Multiplicative
    367 367 
             Running a * 1 == a
    368 
    -          Passed 100 iterations
    368 
    +          Passed 1000 iterations
    369 369 
             Running 1 * a == a
    370 
    -          Passed 100 iterations
    370 
    +          Passed 1000 iterations
    371 371 
             Running multiplication commutative
    372 
    -          Passed 100 iterations
    372 
    +          Passed 1000 iterations
    373 373 
             Running a * b == Integer(a) * Integer(b)
    374 
    -          Passed 100 iterations
    374 
    +          Passed 1000 iterations
    375 375 
           Group Divisible
    376 376 
             Running (x `div` y) * y + (x `mod` y) == x
    377 
    -          Passed 100 iterations
    377 
    +          Passed 1000 iterations
    378 378 
           Group Precedence
    379 379 
             Running + and - (1)
    380 
    -          Passed 100 iterations
    380 
    +          Passed 1000 iterations
    381 381 
             Running + and - (2)
    382 
    -          Passed 100 iterations
    382 
    +          Passed 1000 iterations
    383 383 
             Running + and * (1)
    384 
    -          Passed 100 iterations
    384 
    +          Passed 1000 iterations
    385 385 
             Running + and * (2)
    386 
    -          Passed 100 iterations
    386 
    +          Passed 1000 iterations
    387 387 
             Running - and * (1)
    388 
    -          Passed 100 iterations
    388 
    +          Passed 1000 iterations
    389 389 
             Running - and * (2)
    390 
    -          Passed 100 iterations
    390 
    +          Passed 1000 iterations
    391 391 
             Running * and ^ (1)
    392 
    -          Passed 100 iterations
    392 
    +          Passed 1000 iterations
    393 393 
             Running * and ^ (2)
    394 
    -          Passed 100 iterations
    394 
    +          Passed 1000 iterations
    395 395 
         Group Word16
    396 396 
           Group Integral
    397 397 
             Running FromIntegral(Integer(a)) == a
    398 
    -          Passed 100 iterations
    398 
    +          Passed 1000 iterations
    399 399 
           Group Property
    400 400 
             Running Eq
    401 
    -          Passed 100 iterations
    401 
    +          Passed 1000 iterations
    402 402 
             Running Show
    403 
    -          Passed 100 iterations
    403 
    +          Passed 1000 iterations
    404 404 
             Running Ord
    405 
    -          Passed 100 iterations
    405 
    +          Passed 1000 iterations
    406 406 
             Running <
    407 
    -          Passed 100 iterations
    407 
    +          Passed 1000 iterations
    408 408 
           Group Additive
    409 409 
             Running a + azero == a
    410 
    -          Passed 100 iterations
    410 
    +          Passed 1000 iterations
    411 411 
             Running azero + a == a
    412 
    -          Passed 100 iterations
    412 
    +          Passed 1000 iterations
    413 413 
             Running a + b == b + a
    414 
    -          Passed 100 iterations
    414 
    +          Passed 1000 iterations
    415 415 
           Group Multiplicative
    416 416 
             Running a * 1 == a
    417 
    -          Passed 100 iterations
    417 
    +          Passed 1000 iterations
    418 418 
             Running 1 * a == a
    419 
    -          Passed 100 iterations
    419 
    +          Passed 1000 iterations
    420 420 
             Running multiplication commutative
    421 
    -          Passed 100 iterations
    421 
    +          Passed 1000 iterations
    422 422 
             Running a * b == Integer(a) * Integer(b)
    423 
    -          Passed 100 iterations
    423 
    +          Passed 1000 iterations
    424 424 
           Group Divisible
    425 425 
             Running (x `div` y) * y + (x `mod` y) == x
    426 
    -          Passed 100 iterations
    426 
    +          Passed 1000 iterations
    427 427 
           Group Precedence
    428 428 
             Running + and - (1)
    429 
    -          Passed 100 iterations
    429 
    +          Passed 1000 iterations
    430 430 
             Running + and - (2)
    431 
    -          Passed 100 iterations
    431 
    +          Passed 1000 iterations
    432 432 
             Running + and * (1)
    433 
    -          Passed 100 iterations
    433 
    +          Passed 1000 iterations
    434 434 
             Running + and * (2)
    435 
    -          Passed 100 iterations
    435 
    +          Passed 1000 iterations
    436 436 
             Running - and * (1)
    437 
    -          Passed 100 iterations
    437 
    +          Passed 1000 iterations
    438 438 
             Running - and * (2)
    439 
    -          Passed 100 iterations
    439 
    +          Passed 1000 iterations
    440 440 
             Running * and ^ (1)
    441 
    -          Passed 100 iterations
    441 
    +          Passed 1000 iterations
    442 442 
             Running * and ^ (2)
    443 
    -          Passed 100 iterations
    443 
    +          Passed 1000 iterations
    444 444 
         Group Word32
    445 445 
           Group Integral
    446 446 
             Running FromIntegral(Integer(a)) == a
    447 
    -          Passed 100 iterations
    447 
    +          Passed 1000 iterations
    448 448 
           Group Property
    449 449 
             Running Eq
    450 
    -          Passed 100 iterations
    450 
    +          Passed 1000 iterations
    451 451 
             Running Show
    452 
    -          Passed 100 iterations
    452 
    +          Passed 1000 iterations
    453 453 
             Running Ord
    454 
    -          Passed 100 iterations
    454 
    +          Passed 1000 iterations
    455 455 
             Running <
    456 
    -          Passed 100 iterations
    456 
    +          Passed 1000 iterations
    457 457 
           Group Additive
    458 458 
             Running a + azero == a
    459 
    -          Passed 100 iterations
    459 
    +          Passed 1000 iterations
    460 460 
             Running azero + a == a
    461 
    -          Passed 100 iterations
    461 
    +          Passed 1000 iterations
    462 462 
             Running a + b == b + a
    463 
    -          Passed 100 iterations
    463 
    +          Passed 1000 iterations
    464 464 
           Group Multiplicative
    465 465 
             Running a * 1 == a
    466 
    -          Passed 100 iterations
    466 
    +          Passed 1000 iterations
    467 467 
             Running 1 * a == a
    468 
    -          Passed 100 iterations
    468 
    +          Passed 1000 iterations
    469 469 
             Running multiplication commutative
    470 
    -          Passed 100 iterations
    470 
    +          Passed 1000 iterations
    471 471 
             Running a * b == Integer(a) * Integer(b)
    472 
    -          Passed 100 iterations
    472 
    +          Passed 1000 iterations
    473 473 
           Group Divisible
    474 474 
             Running (x `div` y) * y + (x `mod` y) == x
    475 
    -          Passed 100 iterations
    475 
    +          Passed 1000 iterations
    476 476 
           Group Precedence
    477 477 
             Running + and - (1)
    478 
    -          Passed 100 iterations
    478 
    +          Passed 1000 iterations
    479 479 
             Running + and - (2)
    480 
    -          Passed 100 iterations
    480 
    +          Passed 1000 iterations
    481 481 
             Running + and * (1)
    482 
    -          Passed 100 iterations
    482 
    +          Passed 1000 iterations
    483 483 
             Running + and * (2)
    484 
    -          Passed 100 iterations
    484 
    +          Passed 1000 iterations
    485 485 
             Running - and * (1)
    486 
    -          Passed 100 iterations
    486 
    +          Passed 1000 iterations
    487 487 
             Running - and * (2)
    488 
    -          Passed 100 iterations
    488 
    +          Passed 1000 iterations
    489 489 
             Running * and ^ (1)
    490 
    -          Passed 100 iterations
    490 
    +          Passed 1000 iterations
    491 491 
             Running * and ^ (2)
    492 
    -          Passed 100 iterations
    492 
    +          Passed 1000 iterations
    493 493 
         Group Word64
    494 494 
           Group Integral
    495 495 
             Running FromIntegral(Integer(a)) == a
    496 
    -          Passed 100 iterations
    496 
    +          Passed 1000 iterations
    497 497 
           Group Property
    498 498 
             Running Eq
    499 
    -          Passed 100 iterations
    499 
    +          Passed 1000 iterations
    500 500 
             Running Show
    501 
    -          Passed 100 iterations
    501 
    +          Passed 1000 iterations
    502 502 
             Running Ord
    503 
    -          Passed 100 iterations
    503 
    +          Passed 1000 iterations
    504 504 
             Running <
    505 
    -          Passed 100 iterations
    505 
    +          Passed 1000 iterations
    506 506 
           Group Additive
    507 507 
             Running a + azero == a
    508 
    -          Passed 100 iterations
    508 
    +          Passed 1000 iterations
    509 509 
             Running azero + a == a
    510 
    -          Passed 100 iterations
    510 
    +          Passed 1000 iterations
    511 511 
             Running a + b == b + a
    512 
    -          Passed 100 iterations
    512 
    +          Passed 1000 iterations
    513 513 
           Group Multiplicative
    514 514 
             Running a * 1 == a
    515 
    -          Passed 100 iterations
    515 
    +          Passed 1000 iterations
    516 516 
             Running 1 * a == a
    517 
    -          Passed 100 iterations
    517 
    +          Passed 1000 iterations
    518 518 
             Running multiplication commutative
    519 
    -          Passed 100 iterations
    519 
    +          Passed 1000 iterations
    520 520 
             Running a * b == Integer(a) * Integer(b)
    521 
    -          Passed 100 iterations
    521 
    +          Passed 1000 iterations
    522 522 
           Group Divisible
    523 523 
             Running (x `div` y) * y + (x `mod` y) == x
    524 
    -          Passed 100 iterations
    524 
    +          Passed 1000 iterations
    525 525 
           Group Precedence
    526 526 
             Running + and - (1)
    527 
    -          Passed 100 iterations
    527 
    +          Passed 1000 iterations
    528 528 
             Running + and - (2)
    529 
    -          Passed 100 iterations
    529 
    +          Passed 1000 iterations
    530 530 
             Running + and * (1)
    531 
    -          Passed 100 iterations
    531 
    +          Passed 1000 iterations
    532 532 
             Running + and * (2)
    533 
    -          Passed 100 iterations
    533 
    +          Passed 1000 iterations
    534 534 
             Running - and * (1)
    535 
    -          Passed 100 iterations
    535 
    +          Passed 1000 iterations
    536 536 
             Running - and * (2)
    537 
    -          Passed 100 iterations
    537 
    +          Passed 1000 iterations
    538 538 
             Running * and ^ (1)
    539 
    -          Passed 100 iterations
    539 
    +          Passed 1000 iterations
    540 540 
             Running * and ^ (2)
    541 
    -          Passed 100 iterations
    541 
    +          Passed 1000 iterations
    542 542 
       Group primop
    543 543 
         Running gtChar#
    544 
    -      Passed 100 iterations
    544 
    +      Passed 1000 iterations
    545 545 
         Running geChar#
    546 
    -      Passed 100 iterations
    546 
    +      Passed 1000 iterations
    547 547 
         Running eqChar#
    548 
    -      Passed 100 iterations
    548 
    +      Passed 1000 iterations
    549 549 
         Running neChar#
    550 
    -      Passed 100 iterations
    550 
    +      Passed 1000 iterations
    551 551 
         Running ltChar#
    552 
    -      Passed 100 iterations
    552 
    +      Passed 1000 iterations
    553 553 
         Running leChar#
    554 
    -      Passed 100 iterations
    554 
    +      Passed 1000 iterations
    555 555 
         Running ord#
    556 
    -      Passed 100 iterations
    556 
    +      Passed 1000 iterations
    557 557 
         Running int8ToInt#
    558 
    -      Passed 100 iterations
    558 
    +      Passed 1000 iterations
    559 559 
         Running intToInt8#
    560 
    -      Passed 100 iterations
    560 
    +      Passed 1000 iterations
    561 561 
         Running negateInt8#
    562 
    -      Passed 100 iterations
    562 
    +      Passed 1000 iterations
    563 563 
         Running plusInt8#
    564 
    -      Passed 100 iterations
    564 
    +      Passed 1000 iterations
    565 565 
         Running subInt8#
    566 
    -      Passed 100 iterations
    566 
    +      Passed 1000 iterations
    567 567 
         Running timesInt8#
    568 
    -      Passed 100 iterations
    568 
    +      Passed 1000 iterations
    569 569 
         Running quotInt8#
    570 
    -      Passed 100 iterations
    570 
    +      Passed 1000 iterations
    571 571 
         Running remInt8#
    572 
    -      Passed 100 iterations
    572 
    +      Passed 1000 iterations
    573 573 
         Running quotRemInt8#
    574 
    -      Passed 100 iterations
    574 
    +      Passed 1000 iterations
    575 575 
         Running uncheckedShiftLInt8#
    576 
    -      Passed 100 iterations
    576 
    +      Passed 1000 iterations
    577 577 
         Running uncheckedShiftRAInt8#
    578 
    -      Passed 100 iterations
    578 
    +      Passed 1000 iterations
    579 579 
         Running uncheckedShiftRLInt8#
    580 
    -      Passed 100 iterations
    580 
    +      Passed 1000 iterations
    581 581 
         Running int8ToWord8#
    582 
    -      Passed 100 iterations
    582 
    +      Passed 1000 iterations
    583 583 
         Running eqInt8#
    584 
    -      Passed 100 iterations
    584 
    +      Passed 1000 iterations
    585 585 
         Running geInt8#
    586 
    -      Passed 100 iterations
    586 
    +      Passed 1000 iterations
    587 587 
         Running gtInt8#
    588 
    -      Passed 100 iterations
    588 
    +      Passed 1000 iterations
    589 589 
         Running leInt8#
    590 
    -      Passed 100 iterations
    590 
    +      Passed 1000 iterations
    591 591 
         Running ltInt8#
    592 
    -      Passed 100 iterations
    592 
    +      Passed 1000 iterations
    593 593 
         Running neInt8#
    594 
    -      Passed 100 iterations
    594 
    +      Passed 1000 iterations
    595 595 
         Running word8ToWord#
    596 
    -      Passed 100 iterations
    596 
    +      Passed 1000 iterations
    597 597 
         Running wordToWord8#
    598 
    -      Passed 100 iterations
    598 
    +      Passed 1000 iterations
    599 599 
         Running plusWord8#
    600 
    -      Passed 100 iterations
    600 
    +      Passed 1000 iterations
    601 601 
         Running subWord8#
    602 
    -      Passed 100 iterations
    602 
    +      Passed 1000 iterations
    603 603 
         Running timesWord8#
    604 
    -      Passed 100 iterations
    604 
    +      Passed 1000 iterations
    605 605 
         Running quotWord8#
    606 
    -      Passed 100 iterations
    606 
    +      Passed 1000 iterations
    607 607 
         Running remWord8#
    608 
    -      Passed 100 iterations
    608 
    +      Passed 1000 iterations
    609 609 
         Running quotRemWord8#
    610 
    -      Passed 100 iterations
    610 
    +      Passed 1000 iterations
    611 611 
         Running andWord8#
    612 
    -      Passed 100 iterations
    612 
    +      Passed 1000 iterations
    613 613 
         Running orWord8#
    614 
    -      Passed 100 iterations
    614 
    +      Passed 1000 iterations
    615 615 
         Running xorWord8#
    616 
    -      Passed 100 iterations
    616 
    +      Passed 1000 iterations
    617 617 
         Running notWord8#
    618 
    -      Passed 100 iterations
    618 
    +      Passed 1000 iterations
    619 619 
         Running uncheckedShiftLWord8#
    620 
    -      Passed 100 iterations
    620 
    +      Passed 1000 iterations
    621 621 
         Running uncheckedShiftRLWord8#
    622 
    -      Passed 100 iterations
    622 
    +      Passed 1000 iterations
    623 623 
         Running word8ToInt8#
    624 
    -      Passed 100 iterations
    624 
    +      Passed 1000 iterations
    625 625 
         Running eqWord8#
    626 
    -      Passed 100 iterations
    626 
    +      Passed 1000 iterations
    627 627 
         Running geWord8#
    628 
    -      Passed 100 iterations
    628 
    +      Passed 1000 iterations
    629 629 
         Running gtWord8#
    630 
    -      Passed 100 iterations
    630 
    +      Passed 1000 iterations
    631 631 
         Running leWord8#
    632 
    -      Passed 100 iterations
    632 
    +      Passed 1000 iterations
    633 633 
         Running ltWord8#
    634 
    -      Passed 100 iterations
    634 
    +      Passed 1000 iterations
    635 635 
         Running neWord8#
    636 
    -      Passed 100 iterations
    636 
    +      Passed 1000 iterations
    637 637 
         Running int16ToInt#
    638 
    -      Passed 100 iterations
    638 
    +      Passed 1000 iterations
    639 639 
         Running intToInt16#
    640 
    -      Passed 100 iterations
    640 
    +      Passed 1000 iterations
    641 641 
         Running negateInt16#
    642 
    -      Passed 100 iterations
    642 
    +      Passed 1000 iterations
    643 643 
         Running plusInt16#
    644 
    -      Passed 100 iterations
    644 
    +      Passed 1000 iterations
    645 645 
         Running subInt16#
    646 
    -      Passed 100 iterations
    646 
    +      Passed 1000 iterations
    647 647 
         Running timesInt16#
    648 
    -      Passed 100 iterations
    648 
    +      Passed 1000 iterations
    649 649 
         Running quotInt16#
    650 
    -      Passed 100 iterations
    650 
    +      Passed 1000 iterations
    651 651 
         Running remInt16#
    652 
    -      Passed 100 iterations
    652 
    +      Passed 1000 iterations
    653 653 
         Running quotRemInt16#
    654 
    -      Passed 100 iterations
    654 
    +      Passed 1000 iterations
    655 655 
         Running uncheckedShiftLInt16#
    656 
    -      Passed 100 iterations
    656 
    +      Passed 1000 iterations
    657 657 
         Running uncheckedShiftRAInt16#
    658 
    -      Passed 100 iterations
    658 
    +      Passed 1000 iterations
    659 659 
         Running uncheckedShiftRLInt16#
    660 
    -      Passed 100 iterations
    660 
    +      Passed 1000 iterations
    661 661 
         Running int16ToWord16#
    662 
    -      Passed 100 iterations
    662 
    +      Passed 1000 iterations
    663 663 
         Running eqInt16#
    664 
    -      Passed 100 iterations
    664 
    +      Passed 1000 iterations
    665 665 
         Running geInt16#
    666 
    -      Passed 100 iterations
    666 
    +      Passed 1000 iterations
    667 667 
         Running gtInt16#
    668 
    -      Passed 100 iterations
    668 
    +      Passed 1000 iterations
    669 669 
         Running leInt16#
    670 
    -      Passed 100 iterations
    670 
    +      Passed 1000 iterations
    671 671 
         Running ltInt16#
    672 
    -      Passed 100 iterations
    672 
    +      Passed 1000 iterations
    673 673 
         Running neInt16#
    674 
    -      Passed 100 iterations
    674 
    +      Passed 1000 iterations
    675 675 
         Running word16ToWord#
    676 
    -      Passed 100 iterations
    676 
    +      Passed 1000 iterations
    677 677 
         Running wordToWord16#
    678 
    -      Passed 100 iterations
    678 
    +      Passed 1000 iterations
    679 679 
         Running plusWord16#
    680 
    -      Passed 100 iterations
    680 
    +      Passed 1000 iterations
    681 681 
         Running subWord16#
    682 
    -      Passed 100 iterations
    682 
    +      Passed 1000 iterations
    683 683 
         Running timesWord16#
    684 
    -      Passed 100 iterations
    684 
    +      Passed 1000 iterations
    685 685 
         Running quotWord16#
    686 
    -      Passed 100 iterations
    686 
    +      Passed 1000 iterations
    687 687 
         Running remWord16#
    688 
    -      Passed 100 iterations
    688 
    +      Passed 1000 iterations
    689 689 
         Running quotRemWord16#
    690 
    -      Passed 100 iterations
    690 
    +      Passed 1000 iterations
    691 691 
         Running andWord16#
    692 
    -      Passed 100 iterations
    692 
    +      Passed 1000 iterations
    693 693 
         Running orWord16#
    694 
    -      Passed 100 iterations
    694 
    +      Passed 1000 iterations
    695 695 
         Running xorWord16#
    696 
    -      Passed 100 iterations
    696 
    +      Passed 1000 iterations
    697 697 
         Running notWord16#
    698 
    -      Passed 100 iterations
    698 
    +      Passed 1000 iterations
    699 699 
         Running uncheckedShiftLWord16#
    700 
    -      Passed 100 iterations
    700 
    +      Passed 1000 iterations
    701 701 
         Running uncheckedShiftRLWord16#
    702 
    -      Passed 100 iterations
    702 
    +      Passed 1000 iterations
    703 703 
         Running word16ToInt16#
    704 
    -      Passed 100 iterations
    704 
    +      Passed 1000 iterations
    705 705 
         Running eqWord16#
    706 
    -      Passed 100 iterations
    706 
    +      Passed 1000 iterations
    707 707 
         Running geWord16#
    708 
    -      Passed 100 iterations
    708 
    +      Passed 1000 iterations
    709 709 
         Running gtWord16#
    710 
    -      Passed 100 iterations
    710 
    +      Passed 1000 iterations
    711 711 
         Running leWord16#
    712 
    -      Passed 100 iterations
    712 
    +      Passed 1000 iterations
    713 713 
         Running ltWord16#
    714 
    -      Passed 100 iterations
    714 
    +      Passed 1000 iterations
    715 715 
         Running neWord16#
    716 
    -      Passed 100 iterations
    716 
    +      Passed 1000 iterations
    717 717 
         Running int32ToInt#
    718 
    -      Passed 100 iterations
    718 
    +      Passed 1000 iterations
    719 719 
         Running intToInt32#
    720 
    -      Passed 100 iterations
    720 
    +      Passed 1000 iterations
    721 721 
         Running negateInt32#
    722 
    -      Passed 100 iterations
    722 
    +      Passed 1000 iterations
    723 723 
         Running plusInt32#
    724 
    -      Passed 100 iterations
    724 
    +      Passed 1000 iterations
    725 725 
         Running subInt32#
    726 
    -      Passed 100 iterations
    726 
    +      Passed 1000 iterations
    727 727 
         Running timesInt32#
    728 
    -      Passed 100 iterations
    728 
    +      Passed 1000 iterations
    729 729 
         Running quotInt32#
    730 
    -      Passed 100 iterations
    730 
    +      Passed 1000 iterations
    731 731 
         Running remInt32#
    732 
    -      Passed 100 iterations
    732 
    +      Passed 1000 iterations
    733 733 
         Running quotRemInt32#
    734 
    -      Passed 100 iterations
    734 
    +      Passed 1000 iterations
    735 735 
         Running uncheckedShiftLInt32#
    736 
    -      Passed 100 iterations
    736 
    +      Passed 1000 iterations
    737 737 
         Running uncheckedShiftRAInt32#
    738 
    -      Passed 100 iterations
    738 
    +      Passed 1000 iterations
    739 739 
         Running uncheckedShiftRLInt32#
    740 
    -      Passed 100 iterations
    740 
    +      Passed 1000 iterations
    741 741 
         Running int32ToWord32#
    742 
    -      Passed 100 iterations
    742 
    +      Passed 1000 iterations
    743 743 
         Running eqInt32#
    744 
    -      Passed 100 iterations
    744 
    +      Passed 1000 iterations
    745 745 
         Running geInt32#
    746 
    -      Passed 100 iterations
    746 
    +      Passed 1000 iterations
    747 747 
         Running gtInt32#
    748 
    -      Passed 100 iterations
    748 
    +      Passed 1000 iterations
    749 749 
         Running leInt32#
    750 
    -      Passed 100 iterations
    750 
    +      Passed 1000 iterations
    751 751 
         Running ltInt32#
    752 
    -      Passed 100 iterations
    752 
    +      Passed 1000 iterations
    753 753 
         Running neInt32#
    754 
    -      Passed 100 iterations
    754 
    +      Passed 1000 iterations
    755 755 
         Running word32ToWord#
    756 
    -      Passed 100 iterations
    756 
    +      Passed 1000 iterations
    757 757 
         Running wordToWord32#
    758 
    -      Passed 100 iterations
    758 
    +      Passed 1000 iterations
    759 759 
         Running plusWord32#
    760 
    -      Passed 100 iterations
    760 
    +      Passed 1000 iterations
    761 761 
         Running subWord32#
    762 
    -      Passed 100 iterations
    762 
    +      Passed 1000 iterations
    763 763 
         Running timesWord32#
    764 
    -      Passed 100 iterations
    764 
    +      Passed 1000 iterations
    765 765 
         Running quotWord32#
    766 
    -      Passed 100 iterations
    766 
    +      Passed 1000 iterations
    767 767 
         Running remWord32#
    768 
    -      Passed 100 iterations
    768 
    +      Passed 1000 iterations
    769 769 
         Running quotRemWord32#
    770 
    -      Passed 100 iterations
    770 
    +      Passed 1000 iterations
    771 771 
         Running andWord32#
    772 
    -      Passed 100 iterations
    772 
    +      Passed 1000 iterations
    773 773 
         Running orWord32#
    774 
    -      Passed 100 iterations
    774 
    +      Passed 1000 iterations
    775 775 
         Running xorWord32#
    776 
    -      Passed 100 iterations
    776 
    +      Passed 1000 iterations
    777 777 
         Running notWord32#
    778 
    -      Passed 100 iterations
    778 
    +      Passed 1000 iterations
    779 779 
         Running uncheckedShiftLWord32#
    780 
    -      Passed 100 iterations
    780 
    +      Passed 1000 iterations
    781 781 
         Running uncheckedShiftRLWord32#
    782 
    -      Passed 100 iterations
    782 
    +      Passed 1000 iterations
    783 783 
         Running word32ToInt32#
    784 
    -      Passed 100 iterations
    784 
    +      Passed 1000 iterations
    785 785 
         Running eqWord32#
    786 
    -      Passed 100 iterations
    786 
    +      Passed 1000 iterations
    787 787 
         Running geWord32#
    788 
    -      Passed 100 iterations
    788 
    +      Passed 1000 iterations
    789 789 
         Running gtWord32#
    790 
    -      Passed 100 iterations
    790 
    +      Passed 1000 iterations
    791 791 
         Running leWord32#
    792 
    -      Passed 100 iterations
    792 
    +      Passed 1000 iterations
    793 793 
         Running ltWord32#
    794 
    -      Passed 100 iterations
    794 
    +      Passed 1000 iterations
    795 795 
         Running neWord32#
    796 
    -      Passed 100 iterations
    796 
    +      Passed 1000 iterations
    797 797 
         Running int64ToInt#
    798 
    -      Passed 100 iterations
    798 
    +      Passed 1000 iterations
    799 799 
         Running intToInt64#
    800 
    -      Passed 100 iterations
    800 
    +      Passed 1000 iterations
    801 801 
         Running negateInt64#
    802 
    -      Passed 100 iterations
    802 
    +      Passed 1000 iterations
    803 803 
         Running plusInt64#
    804 
    -      Passed 100 iterations
    804 
    +      Passed 1000 iterations
    805 805 
         Running subInt64#
    806 
    -      Passed 100 iterations
    806 
    +      Passed 1000 iterations
    807 807 
         Running timesInt64#
    808 
    -      Passed 100 iterations
    808 
    +      Passed 1000 iterations
    809 809 
         Running quotInt64#
    810 
    -      Passed 100 iterations
    810 
    +      Passed 1000 iterations
    811 811 
         Running remInt64#
    812 
    -      Passed 100 iterations
    812 
    +      Passed 1000 iterations
    813 813 
         Running uncheckedIShiftL64#
    814 
    -      Passed 100 iterations
    814 
    +      Passed 1000 iterations
    815 815 
         Running uncheckedIShiftRA64#
    816 
    -      Passed 100 iterations
    816 
    +      Passed 1000 iterations
    817 817 
         Running uncheckedIShiftRL64#
    818 
    -      Passed 100 iterations
    818 
    +      Passed 1000 iterations
    819 819 
         Running int64ToWord64#
    820 
    -      Passed 100 iterations
    820 
    +      Passed 1000 iterations
    821 821 
         Running eqInt64#
    822 
    -      Passed 100 iterations
    822 
    +      Passed 1000 iterations
    823 823 
         Running geInt64#
    824 
    -      Passed 100 iterations
    824 
    +      Passed 1000 iterations
    825 825 
         Running gtInt64#
    826 
    -      Passed 100 iterations
    826 
    +      Passed 1000 iterations
    827 827 
         Running leInt64#
    828 
    -      Passed 100 iterations
    828 
    +      Passed 1000 iterations
    829 829 
         Running ltInt64#
    830 
    -      Passed 100 iterations
    830 
    +      Passed 1000 iterations
    831 831 
         Running neInt64#
    832 
    -      Passed 100 iterations
    832 
    +      Passed 1000 iterations
    833 833 
         Running word64ToWord#
    834 
    -      Passed 100 iterations
    834 
    +      Passed 1000 iterations
    835 835 
         Running wordToWord64#
    836 
    -      Passed 100 iterations
    836 
    +      Passed 1000 iterations
    837 837 
         Running plusWord64#
    838 
    -      Passed 100 iterations
    838 
    +      Passed 1000 iterations
    839 839 
         Running subWord64#
    840 
    -      Passed 100 iterations
    840 
    +      Passed 1000 iterations
    841 841 
         Running timesWord64#
    842 
    -      Passed 100 iterations
    842 
    +      Passed 1000 iterations
    843 843 
         Running quotWord64#
    844 
    -      Passed 100 iterations
    844 
    +      Passed 1000 iterations
    845 845 
         Running remWord64#
    846 
    -      Passed 100 iterations
    846 
    +      Passed 1000 iterations
    847 847 
         Running and64#
    848 
    -      Passed 100 iterations
    848 
    +      Passed 1000 iterations
    849 849 
         Running or64#
    850 
    -      Passed 100 iterations
    850 
    +      Passed 1000 iterations
    851 851 
         Running xor64#
    852 
    -      Passed 100 iterations
    852 
    +      Passed 1000 iterations
    853 853 
         Running not64#
    854 
    -      Passed 100 iterations
    854 
    +      Passed 1000 iterations
    855 855 
         Running uncheckedShiftL64#
    856 
    -      Passed 100 iterations
    856 
    +      Passed 1000 iterations
    857 857 
         Running uncheckedShiftRL64#
    858 
    -      Passed 100 iterations
    858 
    +      Passed 1000 iterations
    859 859 
         Running word64ToInt64#
    860 
    -      Passed 100 iterations
    860 
    +      Passed 1000 iterations
    861 861 
         Running eqWord64#
    862 
    -      Passed 100 iterations
    862 
    +      Passed 1000 iterations
    863 863 
         Running geWord64#
    864 
    -      Passed 100 iterations
    864 
    +      Passed 1000 iterations
    865 865 
         Running gtWord64#
    866 
    -      Passed 100 iterations
    866 
    +      Passed 1000 iterations
    867 867 
         Running leWord64#
    868 
    -      Passed 100 iterations
    868 
    +      Passed 1000 iterations
    869 869 
         Running ltWord64#
    870 
    -      Passed 100 iterations
    870 
    +      Passed 1000 iterations
    871 871 
         Running neWord64#
    872 
    -      Passed 100 iterations
    872 
    +      Passed 1000 iterations
    873 873 
         Running +#
    874 
    -      Passed 100 iterations
    874 
    +      Passed 1000 iterations
    875 875 
         Running -#
    876 
    -      Passed 100 iterations
    876 
    +      Passed 1000 iterations
    877 877 
         Running *#
    878 
    -      Passed 100 iterations
    878 
    +      Passed 1000 iterations
    879 879 
         Running timesInt2#
    880 
    -      Passed 100 iterations
    880 
    +      Passed 1000 iterations
    881 881 
         Running mulIntMayOflo#
    882 
    -      Passed 100 iterations
    882 
    +      Passed 1000 iterations
    883 883 
         Running quotInt#
    884 
    -      Passed 100 iterations
    884 
    +      Passed 1000 iterations
    885 885 
         Running remInt#
    886 
    -      Passed 100 iterations
    886 
    +      Passed 1000 iterations
    887 887 
         Running quotRemInt#
    888 
    -      Passed 100 iterations
    888 
    +      Passed 1000 iterations
    889 889 
         Running andI#
    890 
    -      Passed 100 iterations
    890 
    +      Passed 1000 iterations
    891 891 
         Running orI#
    892 
    -      Passed 100 iterations
    892 
    +      Passed 1000 iterations
    893 893 
         Running xorI#
    894 
    -      Passed 100 iterations
    894 
    +      Passed 1000 iterations
    895 895 
         Running notI#
    896 
    -      Passed 100 iterations
    896 
    +      Passed 1000 iterations
    897 897 
         Running negateInt#
    898 
    -      Passed 100 iterations
    898 
    +      Passed 1000 iterations
    899 899 
         Running addIntC#
    900 
    -      Passed 100 iterations
    900 
    +      Passed 1000 iterations
    901 901 
         Running subIntC#
    902 
    -      Passed 100 iterations
    902 
    +      Passed 1000 iterations
    903 903 
         Running >#
    904 
    -      Passed 100 iterations
    904 
    +      Passed 1000 iterations
    905 905 
         Running >=#
    906 
    -      Passed 100 iterations
    906 
    +      Passed 1000 iterations
    907 907 
         Running ==#
    908 
    -      Passed 100 iterations
    908 
    +      Passed 1000 iterations
    909 909 
         Running /=#
    910 
    -      Passed 100 iterations
    910 
    +      Passed 1000 iterations
    911 911 
         Running <#
    912 
    -      Passed 100 iterations
    912 
    +      Passed 1000 iterations
    913 913 
         Running <=#
    914 
    -      Passed 100 iterations
    914 
    +      Passed 1000 iterations
    915 915 
         Running chr#
    916 
    -      Passed 100 iterations
    916 
    +      Passed 1000 iterations
    917 917 
         Running int2Word#
    918 
    -      Passed 100 iterations
    918 
    +      Passed 1000 iterations
    919 919 
         Running uncheckedIShiftL#
    920 
    -      Passed 100 iterations
    920 
    +      Passed 1000 iterations
    921 921 
         Running uncheckedIShiftRA#
    922 
    -      Passed 100 iterations
    922 
    +      Passed 1000 iterations
    923 923 
         Running uncheckedIShiftRL#
    924 
    -      Passed 100 iterations
    924 
    +      Passed 1000 iterations
    925 925 
         Running plusWord#
    926 
    -      Passed 100 iterations
    926 
    +      Passed 1000 iterations
    927 927 
         Running addWordC#
    928 
    -      Passed 100 iterations
    928 
    +      Passed 1000 iterations
    929 929 
         Running subWordC#
    930 
    -      Passed 100 iterations
    930 
    +      Passed 1000 iterations
    931 931 
         Running plusWord2#
    932 
    -      Passed 100 iterations
    932 
    +      Passed 1000 iterations
    933 933 
         Running minusWord#
    934 
    -      Passed 100 iterations
    934 
    +      Passed 1000 iterations
    935 935 
         Running timesWord#
    936 
    -      Passed 100 iterations
    936 
    +      Passed 1000 iterations
    937 937 
         Running timesWord2#
    938 
    -      Passed 100 iterations
    938 
    +      Passed 1000 iterations
    939 939 
         Running quotWord#
    940 
    -      Passed 100 iterations
    940 
    +      Passed 1000 iterations
    941 941 
         Running remWord#
    942 
    -      Passed 100 iterations
    942 
    +      Passed 1000 iterations
    943 943 
         Running quotRemWord#
    944 
    -      Passed 100 iterations
    944 
    +      Passed 1000 iterations
    945 945 
         Running and#
    946 
    -      Passed 100 iterations
    946 
    +      Passed 1000 iterations
    947 947 
         Running or#
    948 
    -      Passed 100 iterations
    948 
    +      Passed 1000 iterations
    949 949 
         Running xor#
    950 
    -      Passed 100 iterations
    950 
    +      Passed 1000 iterations
    951 951 
         Running not#
    952 
    -      Passed 100 iterations
    952 
    +      Passed 1000 iterations
    953 953 
         Running uncheckedShiftL#
    954 
    -      Passed 100 iterations
    954 
    +      Passed 1000 iterations
    955 955 
         Running uncheckedShiftRL#
    956 
    -      Passed 100 iterations
    956 
    +      Passed 1000 iterations
    957 957 
         Running word2Int#
    958 
    -      Passed 100 iterations
    958 
    +      Passed 1000 iterations
    959 959 
         Running gtWord#
    960 
    -      Passed 100 iterations
    960 
    +      Passed 1000 iterations
    961 961 
         Running geWord#
    962 
    -      Passed 100 iterations
    962 
    +      Passed 1000 iterations
    963 963 
         Running eqWord#
    964 
    -      Passed 100 iterations
    964 
    +      Passed 1000 iterations
    965 965 
         Running neWord#
    966 
    -      Passed 100 iterations
    966 
    +      Passed 1000 iterations
    967 967 
         Running ltWord#
    968 
    -      Passed 100 iterations
    968 
    +      Passed 1000 iterations
    969 969 
         Running leWord#
    970 
    -      Passed 100 iterations
    970 
    +      Passed 1000 iterations
    971 971 
         Running popCnt8#
    972 
    -      Passed 100 iterations
    972 
    +      Passed 1000 iterations
    973 973 
         Running popCnt16#
    974 
    -      Passed 100 iterations
    974 
    +      Passed 1000 iterations
    975 975 
         Running popCnt32#
    976 
    -      Passed 100 iterations
    976 
    +      Passed 1000 iterations
    977 977 
         Running popCnt64#
    978 
    -      Passed 100 iterations
    978 
    +      Passed 1000 iterations
    979 979 
         Running popCnt#
    980 
    -      Passed 100 iterations
    980 
    +      Passed 1000 iterations
    981 981 
         Running pdep8#
    982 
    -      Passed 100 iterations
    982 
    +      Passed 1000 iterations
    983 983 
         Running pdep16#
    984 
    -      Passed 100 iterations
    984 
    +      Passed 1000 iterations
    985 985 
         Running pdep32#
    986 
    -      Passed 100 iterations
    986 
    +      Passed 1000 iterations
    987 987 
         Running pdep64#
    988 
    -      Passed 100 iterations
    988 
    +      Passed 1000 iterations
    989 989 
         Running pdep#
    990 
    -      Passed 100 iterations
    990 
    +      Passed 1000 iterations
    991 991 
         Running pext8#
    992 
    -      Passed 100 iterations
    992 
    +      Passed 1000 iterations
    993 993 
         Running pext16#
    994 
    -      Passed 100 iterations
    994 
    +      Passed 1000 iterations
    995 995 
         Running pext32#
    996 
    -      Passed 100 iterations
    996 
    +      Passed 1000 iterations
    997 997 
         Running pext64#
    998 
    -      Passed 100 iterations
    998 
    +      Passed 1000 iterations
    999 999 
         Running pext#
    1000 
    -      Passed 100 iterations
    1000 
    +      Passed 1000 iterations
    1001 1001 
         Running clz8#
    1002 
    -      Passed 100 iterations
    1002 
    +      Passed 1000 iterations
    1003 1003 
         Running clz16#
    1004 
    -      Passed 100 iterations
    1004 
    +      Passed 1000 iterations
    1005 1005 
         Running clz32#
    1006 
    -      Passed 100 iterations
    1006 
    +      Passed 1000 iterations
    1007 1007 
         Running clz64#
    1008 
    -      Passed 100 iterations
    1008 
    +      Passed 1000 iterations
    1009 1009 
         Running clz#
    1010 
    -      Passed 100 iterations
    1010 
    +      Passed 1000 iterations
    1011 1011 
         Running ctz8#
    1012 
    -      Passed 100 iterations
    1012 
    +      Passed 1000 iterations
    1013 1013 
         Running ctz16#
    1014 
    -      Passed 100 iterations
    1014 
    +      Passed 1000 iterations
    1015 1015 
         Running ctz32#
    1016 
    -      Passed 100 iterations
    1016 
    +      Passed 1000 iterations
    1017 1017 
         Running ctz64#
    1018 
    -      Passed 100 iterations
    1018 
    +      Passed 1000 iterations
    1019 1019 
         Running ctz#
    1020 
    -      Passed 100 iterations
    1020 
    +      Passed 1000 iterations
    1021 1021 
         Running byteSwap16#
    1022 
    -      Passed 100 iterations
    1022 
    +      Passed 1000 iterations
    1023 1023 
         Running byteSwap32#
    1024 
    -      Passed 100 iterations
    1024 
    +      Passed 1000 iterations
    1025 1025 
         Running byteSwap64#
    1026 
    -      Passed 100 iterations
    1026 
    +      Passed 1000 iterations
    1027 1027 
         Running byteSwap#
    1028 
    -      Passed 100 iterations
    1028 
    +      Passed 1000 iterations
    1029 1029 
         Running bitReverse8#
    1030 
    -      Passed 100 iterations
    1030 
    +      Passed 1000 iterations
    1031 1031 
         Running bitReverse16#
    1032 
    -      Passed 100 iterations
    1032 
    +      Passed 1000 iterations
    1033 1033 
         Running bitReverse32#
    1034 
    -      Passed 100 iterations
    1034 
    +      Passed 1000 iterations
    1035 1035 
         Running bitReverse64#
    1036 
    -      Passed 100 iterations
    1036 
    +      Passed 1000 iterations
    1037 1037 
         Running bitReverse#
    1038 
    -      Passed 100 iterations
    1038 
    +      Passed 1000 iterations
    1039 1039 
         Running narrow8Int#
    1040 
    -      Passed 100 iterations
    1040 
    +      Passed 1000 iterations
    1041 1041 
         Running narrow16Int#
    1042 
    -      Passed 100 iterations
    1042 
    +      Passed 1000 iterations
    1043 1043 
         Running narrow32Int#
    1044 
    -      Passed 100 iterations
    1044 
    +      Passed 1000 iterations
    1045 1045 
         Running narrow8Word#
    1046 
    -      Passed 100 iterations
    1046 
    +      Passed 1000 iterations
    1047 1047 
         Running narrow16Word#
    1048 
    -      Passed 100 iterations
    1048 
    +      Passed 1000 iterations
    1049 1049 
         Running narrow32Word#
    1050 
    -      Passed 100 iterations
    1050 
    +      Passed 1000 iterations

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.haskell.org. Manage all notifications · Help