{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE CPP, NoImplicitPrelude, BangPatterns, MagicHash, UnboxedTuples #-}
{-# OPTIONS_HADDOCK not-home #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.Word
-- Copyright   :  (c) The University of Glasgow, 1997-2002
-- License     :  see libraries/base/LICENSE
--
-- Maintainer  :  ghc-devs@haskell.org
-- Stability   :  internal
-- Portability :  non-portable (GHC Extensions)
--
-- Sized unsigned integral types: 'Word', 'Word8', 'Word16', 'Word32', and
-- 'Word64'.
--
-----------------------------------------------------------------------------

#include "MachDeps.h"

module GHC.Internal.Word (
    Word(..), Word8(..), Word16(..), Word32(..), Word64(..),

    -- * Shifts
    uncheckedShiftL64#,
    uncheckedShiftRL64#,

    -- * Byte swapping
    byteSwap16,
    byteSwap32,
    byteSwap64,

    -- * Bit reversal
    bitReverse8,
    bitReverse16,
    bitReverse32,
    bitReverse64,

    -- * Equality operators
    -- | See GHC.Classes#matching_overloaded_methods_in_rules
    eqWord, neWord, gtWord, geWord, ltWord, leWord,
    eqWord8, neWord8, gtWord8, geWord8, ltWord8, leWord8,
    eqWord16, neWord16, gtWord16, geWord16, ltWord16, leWord16,
    eqWord32, neWord32, gtWord32, geWord32, ltWord32, leWord32,
    eqWord64, neWord64, gtWord64, geWord64, ltWord64, leWord64
    ) where

import GHC.Internal.Data.Maybe

import GHC.Prim
import GHC.Internal.Base

import GHC.Internal.Bits
import GHC.Internal.Enum
import GHC.Internal.Num
import GHC.Internal.Real
import GHC.Internal.Ix
import GHC.Internal.Show

------------------------------------------------------------------------
-- type Word8
------------------------------------------------------------------------

-- Word8 is represented in the same way as Word. Operations may assume
-- and must ensure that it holds only values from its logical range.

data {-# CTYPE "HsWord8" #-} Word8
    = W8# Word8#


-- ^ 8-bit unsigned integer type

-- See GHC.Classes#matching_overloaded_methods_in_rules
-- | @since base-2.01
instance Eq Word8 where
    == :: Word8 -> Word8 -> Bool
(==) = Word8 -> Word8 -> Bool
eqWord8
    /= :: Word8 -> Word8 -> Bool
(/=) = Word8 -> Word8 -> Bool
neWord8

eqWord8, neWord8 :: Word8 -> Word8 -> Bool
eqWord8 :: Word8 -> Word8 -> Bool
eqWord8 (W8# Word8#
x) (W8# Word8#
y) = Int# -> Bool
isTrue# ((Word8# -> Word#
word8ToWord# Word8#
x) Word# -> Word# -> Int#
`eqWord#` (Word8# -> Word#
word8ToWord# Word8#
y))
neWord8 :: Word8 -> Word8 -> Bool
neWord8 (W8# Word8#
x) (W8# Word8#
y) = Int# -> Bool
isTrue# ((Word8# -> Word#
word8ToWord# Word8#
x) Word# -> Word# -> Int#
`neWord#` (Word8# -> Word#
word8ToWord# Word8#
y))
{-# INLINE [1] eqWord8 #-}
{-# INLINE [1] neWord8 #-}

-- | @since base-2.01
instance Ord Word8 where
    < :: Word8 -> Word8 -> Bool
(<)  = Word8 -> Word8 -> Bool
ltWord8
    <= :: Word8 -> Word8 -> Bool
(<=) = Word8 -> Word8 -> Bool
leWord8
    >= :: Word8 -> Word8 -> Bool
(>=) = Word8 -> Word8 -> Bool
geWord8
    > :: Word8 -> Word8 -> Bool
(>)  = Word8 -> Word8 -> Bool
gtWord8

{-# INLINE [1] gtWord8 #-}
{-# INLINE [1] geWord8 #-}
{-# INLINE [1] ltWord8 #-}
{-# INLINE [1] leWord8 #-}
gtWord8, geWord8, ltWord8, leWord8 :: Word8 -> Word8 -> Bool
(W8# Word8#
x) gtWord8 :: Word8 -> Word8 -> Bool
`gtWord8` (W8# Word8#
y) = Int# -> Bool
isTrue# (Word8#
x Word8# -> Word8# -> Int#
`gtWord8#` Word8#
y)
(W8# Word8#
x) geWord8 :: Word8 -> Word8 -> Bool
`geWord8` (W8# Word8#
y) = Int# -> Bool
isTrue# (Word8#
x Word8# -> Word8# -> Int#
`geWord8#` Word8#
y)
(W8# Word8#
x) ltWord8 :: Word8 -> Word8 -> Bool
`ltWord8` (W8# Word8#
y) = Int# -> Bool
isTrue# (Word8#
x Word8# -> Word8# -> Int#
`ltWord8#` Word8#
y)
(W8# Word8#
x) leWord8 :: Word8 -> Word8 -> Bool
`leWord8` (W8# Word8#
y) = Int# -> Bool
isTrue# (Word8#
x Word8# -> Word8# -> Int#
`leWord8#` Word8#
y)

-- | @since base-2.01
instance Show Word8 where
    showsPrec :: Int -> Word8 -> ShowS
showsPrec Int
p Word8
x = Int -> Int -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x :: Int)

-- | @since base-2.01
instance Num Word8 where
    (W8# Word8#
x#) + :: Word8 -> Word8 -> Word8
+ (W8# Word8#
y#)    = Word8# -> Word8
W8# (Word8#
x# Word8# -> Word8# -> Word8#
`plusWord8#` Word8#
y#)
    (W8# Word8#
x#) - :: Word8 -> Word8 -> Word8
- (W8# Word8#
y#)    = Word8# -> Word8
W8# (Word8#
x# Word8# -> Word8# -> Word8#
`subWord8#` Word8#
y#)
    (W8# Word8#
x#) * :: Word8 -> Word8 -> Word8
* (W8# Word8#
y#)    = Word8# -> Word8
W8# (Word8#
x# Word8# -> Word8# -> Word8#
`timesWord8#` Word8#
y#)
    negate :: Word8 -> Word8
negate (W8# Word8#
x#)        = Word8# -> Word8
W8# (Int8# -> Word8#
int8ToWord8# (Int8# -> Int8#
negateInt8# (Word8# -> Int8#
word8ToInt8# Word8#
x#)))
    abs :: Word8 -> Word8
abs Word8
x                  = Word8
x
    signum :: Word8 -> Word8
signum Word8
0               = Word8
0
    signum Word8
_               = Word8
1
    fromInteger :: Integer -> Word8
fromInteger Integer
i          = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (Integer -> Word#
integerToWord# Integer
i))

-- | @since base-2.01
instance Real Word8 where
    toRational :: Word8 -> Rational
toRational Word8
x = Word8 -> Integer
forall a. Integral a => a -> Integer
toInteger Word8
x Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1

-- | @since base-2.01
instance Enum Word8 where
    succ :: Word8 -> Word8
succ Word8
x
        | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
forall a. Bounded a => a
maxBound = Word8
x Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
1
        | Bool
otherwise     = String -> Word8
forall a. String -> a
succError String
"Word8"
    pred :: Word8 -> Word8
pred Word8
x
        | Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
forall a. Bounded a => a
minBound = Word8
x Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
1
        | Bool
otherwise     = String -> Word8
forall a. String -> a
predError String
"Word8"
    toEnum :: Int -> Word8
toEnum i :: Int
i@(I# Int#
i#)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
forall a. Bounded a => a
maxBound::Word8)
                        = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (Int# -> Word#
int2Word# Int#
i#))
        | Bool
otherwise     = String -> Int -> (Word8, Word8) -> Word8
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Word8" Int
i (Word8
forall a. Bounded a => a
minBound::Word8, Word8
forall a. Bounded a => a
maxBound::Word8)
    fromEnum :: Word8 -> Int
fromEnum (W8# Word8#
x#)   = Int# -> Int
I# (Word# -> Int#
word2Int# (Word8# -> Word#
word8ToWord# Word8#
x#))
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFrom #-}
    enumFrom :: Word8 -> [Word8]
enumFrom            = Word8 -> [Word8]
forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromThen #-}
    enumFromThen :: Word8 -> Word8 -> [Word8]
enumFromThen        = Word8 -> Word8 -> [Word8]
forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen

-- | @since base-2.01
instance Integral Word8 where
    -- see Note [INLINE division wrappers] in GHC.Internal.Base
    {-# INLINE quot    #-}
    {-# INLINE rem     #-}
    {-# INLINE quotRem #-}
    {-# INLINE div     #-}
    {-# INLINE mod     #-}
    {-# INLINE divMod  #-}

    quot :: Word8 -> Word8 -> Word8
quot    (W8# Word8#
x#) y :: Word8
y@(W8# Word8#
y#)
        | Word8
y Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0                  = Word8# -> Word8
W8# (Word8#
x# Word8# -> Word8# -> Word8#
`quotWord8#` Word8#
y#)
        | Bool
otherwise               = Word8
forall a. a
divZeroError
    rem :: Word8 -> Word8 -> Word8
rem     (W8# Word8#
x#) y :: Word8
y@(W8# Word8#
y#)
        | Word8
y Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0                  = Word8# -> Word8
W8# (Word8#
x# Word8# -> Word8# -> Word8#
`remWord8#` Word8#
y#)
        | Bool
otherwise               = Word8
forall a. a
divZeroError
    quotRem :: Word8 -> Word8 -> (Word8, Word8)
quotRem (W8# Word8#
x#) y :: Word8
y@(W8# Word8#
y#)
        | Word8
y Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0                  = case Word8#
x# Word8# -> Word8# -> (# Word8#, Word8# #)
`quotRemWord8#` Word8#
y# of
                                      (# Word8#
q, Word8#
r #) -> (Word8# -> Word8
W8# Word8#
q, Word8# -> Word8
W8# Word8#
r)
        | Bool
otherwise               = (Word8, Word8)
forall a. a
divZeroError

    div :: Word8 -> Word8 -> Word8
div    Word8
x Word8
y = Word8 -> Word8 -> Word8
forall a. Integral a => a -> a -> a
quot Word8
x Word8
y
    mod :: Word8 -> Word8 -> Word8
mod    Word8
x Word8
y = Word8 -> Word8 -> Word8
forall a. Integral a => a -> a -> a
rem Word8
x Word8
y
    divMod :: Word8 -> Word8 -> (Word8, Word8)
divMod Word8
x Word8
y = Word8 -> Word8 -> (Word8, Word8)
forall a. Integral a => a -> a -> (a, a)
quotRem Word8
x Word8
y

    toInteger :: Word8 -> Integer
toInteger (W8# Word8#
x#)            = Int# -> Integer
IS (Word# -> Int#
word2Int# (Word8# -> Word#
word8ToWord# Word8#
x#))

-- | @since base-2.01
instance Bounded Word8 where
    minBound :: Word8
minBound = Word8
0
    maxBound :: Word8
maxBound = Word8
0xFF

-- | @since base-2.01
instance Ix Word8 where
    range :: (Word8, Word8) -> [Word8]
range (Word8
m,Word8
n)         = [Word8
m..Word8
n]
    unsafeIndex :: (Word8, Word8) -> Word8 -> Int
unsafeIndex (Word8
m,Word8
_) Word8
i = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
i Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
m)
    inRange :: (Word8, Word8) -> Word8 -> Bool
inRange (Word8
m,Word8
n) Word8
i     = Word8
m Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
i Bool -> Bool -> Bool
&& Word8
i Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
n

-- | @since base-2.01
instance Bits Word8 where
    {-# INLINE shift #-}
    {-# INLINE bit #-}
    {-# INLINE testBit #-}
    {-# INLINE popCount #-}

    (W8# Word8#
x#) .&. :: Word8 -> Word8 -> Word8
.&.   (W8# Word8#
y#)   = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Word# -> Word#
`and#` (Word8# -> Word#
word8ToWord# Word8#
y#)))
    (W8# Word8#
x#) .|. :: Word8 -> Word8 -> Word8
.|.   (W8# Word8#
y#)   = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Word# -> Word#
`or#`  (Word8# -> Word#
word8ToWord# Word8#
y#)))
    (W8# Word8#
x#) xor :: Word8 -> Word8 -> Word8
`xor` (W8# Word8#
y#)   = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Word# -> Word#
`xor#` (Word8# -> Word#
word8ToWord# Word8#
y#)))
    complement :: Word8 -> Word8
complement (W8# Word8#
x#)       = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (Word# -> Word#
not# (Word8# -> Word#
word8ToWord# Word8#
x#)))
    (W8# Word8#
x#) shift :: Word8 -> Int -> Word8
`shift` (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise           = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`shiftRL#` Int# -> Int#
negateInt# Int#
i#))
    (W8# Word8#
x#) shiftL :: Word8 -> Int -> Word8
`shiftL`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise           = Word8
forall a. a
overflowError
    (W8# Word8#
x#) unsafeShiftL :: Word8 -> Int -> Word8
`unsafeShiftL` (I# Int#
i#) =
        Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i#))
    (W8# Word8#
x#) shiftR :: Word8 -> Int -> Word8
`shiftR`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`shiftRL#` Int#
i#))
        | Bool
otherwise           = Word8
forall a. a
overflowError
    (W8# Word8#
x#) unsafeShiftR :: Word8 -> Int -> Word8
`unsafeShiftR` (I# Int#
i#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` Int#
i#))
    (W8# Word8#
x#) rotate :: Word8 -> Int -> Word8
`rotate`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i'# Int# -> Int# -> Int#
==# Int#
0#) = Word8# -> Word8
W8# Word8#
x#
        | Bool
otherwise  = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i'#) Word# -> Word# -> Word#
`or#`
                                          ((Word8# -> Word#
word8ToWord# Word8#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` (Int#
8# Int# -> Int# -> Int#
-# Int#
i'#))))
        where
        !i'# :: Int#
i'# = Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
i# Word# -> Word# -> Word#
`and#` Word#
7##)
    bitSizeMaybe :: Word8 -> Maybe Int
bitSizeMaybe Word8
i            = Int -> Maybe Int
forall a. a -> Maybe a
Just (Word8 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word8
i)
    bitSize :: Word8 -> Int
bitSize Word8
i                 = Word8 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word8
i
    isSigned :: Word8 -> Bool
isSigned Word8
_                = Bool
False
    popCount :: Word8 -> Int
popCount (W8# Word8#
x#)         = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
popCnt8# (Word8# -> Word#
word8ToWord# Word8#
x#)))
    bit :: Int -> Word8
bit Int
i                     = Int -> Word8
forall a. (Bits a, Num a) => Int -> a
bitDefault Int
i
    testBit :: Word8 -> Int -> Bool
testBit Word8
a Int
i               = Word8 -> Int -> Bool
forall a. (Bits a, Num a) => a -> Int -> Bool
testBitDefault Word8
a Int
i

-- | @since base-4.6.0.0
instance FiniteBits Word8 where
    {-# INLINE countLeadingZeros #-}
    {-# INLINE countTrailingZeros #-}
    finiteBitSize :: Word8 -> Int
finiteBitSize Word8
_ = Int
8
    countLeadingZeros :: Word8 -> Int
countLeadingZeros  (W8# Word8#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
clz8# (Word8# -> Word#
word8ToWord# Word8#
x#)))
    countTrailingZeros :: Word8 -> Int
countTrailingZeros (W8# Word8#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
ctz8# (Word8# -> Word#
word8ToWord# Word8#
x#)))

{-# RULES
"properFraction/Float->(Word8,Float)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word8) n, y :: Float) }
"truncate/Float->Word8"
    truncate = (fromIntegral :: Int -> Word8) . (truncate :: Float -> Int)
"floor/Float->Word8"
    floor    = (fromIntegral :: Int -> Word8) . (floor :: Float -> Int)
"ceiling/Float->Word8"
    ceiling  = (fromIntegral :: Int -> Word8) . (ceiling :: Float -> Int)
"round/Float->Word8"
    round    = (fromIntegral :: Int -> Word8) . (round  :: Float -> Int)
  #-}

{-# RULES
"properFraction/Double->(Word8,Double)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word8) n, y :: Double) }
"truncate/Double->Word8"
    truncate = (fromIntegral :: Int -> Word8) . (truncate :: Double -> Int)
"floor/Double->Word8"
    floor    = (fromIntegral :: Int -> Word8) . (floor :: Double -> Int)
"ceiling/Double->Word8"
    ceiling  = (fromIntegral :: Int -> Word8) . (ceiling :: Double -> Int)
"round/Double->Word8"
    round    = (fromIntegral :: Int -> Word8) . (round  :: Double -> Int)
  #-}

------------------------------------------------------------------------
-- type Word16
------------------------------------------------------------------------

-- Word16 is represented in the same way as Word. Operations may assume
-- and must ensure that it holds only values from its logical range.

data {-# CTYPE "HsWord16" #-} Word16 = W16# Word16#
-- ^ 16-bit unsigned integer type

-- See GHC.Classes#matching_overloaded_methods_in_rules
-- | @since base-2.01
instance Eq Word16 where
    == :: Word16 -> Word16 -> Bool
(==) = Word16 -> Word16 -> Bool
eqWord16
    /= :: Word16 -> Word16 -> Bool
(/=) = Word16 -> Word16 -> Bool
neWord16

eqWord16, neWord16 :: Word16 -> Word16 -> Bool
eqWord16 :: Word16 -> Word16 -> Bool
eqWord16 (W16# Word16#
x) (W16# Word16#
y) = Int# -> Bool
isTrue# ((Word16# -> Word#
word16ToWord# Word16#
x) Word# -> Word# -> Int#
`eqWord#` (Word16# -> Word#
word16ToWord# Word16#
y))
neWord16 :: Word16 -> Word16 -> Bool
neWord16 (W16# Word16#
x) (W16# Word16#
y) = Int# -> Bool
isTrue# ((Word16# -> Word#
word16ToWord# Word16#
x) Word# -> Word# -> Int#
`neWord#` (Word16# -> Word#
word16ToWord# Word16#
y))
{-# INLINE [1] eqWord16 #-}
{-# INLINE [1] neWord16 #-}

-- | @since base-2.01
instance Ord Word16 where
    < :: Word16 -> Word16 -> Bool
(<)  = Word16 -> Word16 -> Bool
ltWord16
    <= :: Word16 -> Word16 -> Bool
(<=) = Word16 -> Word16 -> Bool
leWord16
    >= :: Word16 -> Word16 -> Bool
(>=) = Word16 -> Word16 -> Bool
geWord16
    > :: Word16 -> Word16 -> Bool
(>)  = Word16 -> Word16 -> Bool
gtWord16

{-# INLINE [1] gtWord16 #-}
{-# INLINE [1] geWord16 #-}
{-# INLINE [1] ltWord16 #-}
{-# INLINE [1] leWord16 #-}
gtWord16, geWord16, ltWord16, leWord16 :: Word16 -> Word16 -> Bool
(W16# Word16#
x) gtWord16 :: Word16 -> Word16 -> Bool
`gtWord16` (W16# Word16#
y) = Int# -> Bool
isTrue# (Word16#
x Word16# -> Word16# -> Int#
`gtWord16#` Word16#
y)
(W16# Word16#
x) geWord16 :: Word16 -> Word16 -> Bool
`geWord16` (W16# Word16#
y) = Int# -> Bool
isTrue# (Word16#
x Word16# -> Word16# -> Int#
`geWord16#` Word16#
y)
(W16# Word16#
x) ltWord16 :: Word16 -> Word16 -> Bool
`ltWord16` (W16# Word16#
y) = Int# -> Bool
isTrue# (Word16#
x Word16# -> Word16# -> Int#
`ltWord16#` Word16#
y)
(W16# Word16#
x) leWord16 :: Word16 -> Word16 -> Bool
`leWord16` (W16# Word16#
y) = Int# -> Bool
isTrue# (Word16#
x Word16# -> Word16# -> Int#
`leWord16#` Word16#
y)

-- | @since base-2.01
instance Show Word16 where
    showsPrec :: Int -> Word16 -> ShowS
showsPrec Int
p Word16
x = Int -> Int -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
x :: Int)

-- | @since base-2.01
instance Num Word16 where
    (W16# Word16#
x#) + :: Word16 -> Word16 -> Word16
+ (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word16#
x# Word16# -> Word16# -> Word16#
`plusWord16#` Word16#
y#)
    (W16# Word16#
x#) - :: Word16 -> Word16 -> Word16
- (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word16#
x# Word16# -> Word16# -> Word16#
`subWord16#` Word16#
y#)
    (W16# Word16#
x#) * :: Word16 -> Word16 -> Word16
* (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word16#
x# Word16# -> Word16# -> Word16#
`timesWord16#` Word16#
y#)
    negate :: Word16 -> Word16
negate (W16# Word16#
x#)       = Word16# -> Word16
W16# (Int16# -> Word16#
int16ToWord16# (Int16# -> Int16#
negateInt16# (Word16# -> Int16#
word16ToInt16# Word16#
x#)))
    abs :: Word16 -> Word16
abs Word16
x                  = Word16
x
    signum :: Word16 -> Word16
signum Word16
0               = Word16
0
    signum Word16
_               = Word16
1
    fromInteger :: Integer -> Word16
fromInteger Integer
i          = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (Integer -> Word#
integerToWord# Integer
i))

-- | @since base-2.01
instance Real Word16 where
    toRational :: Word16 -> Rational
toRational Word16
x = Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger Word16
x Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1

-- | @since base-2.01
instance Enum Word16 where
    succ :: Word16 -> Word16
succ Word16
x
        | Word16
x Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
forall a. Bounded a => a
maxBound = Word16
x Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
+ Word16
1
        | Bool
otherwise     = String -> Word16
forall a. String -> a
succError String
"Word16"
    pred :: Word16 -> Word16
pred Word16
x
        | Word16
x Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
forall a. Bounded a => a
minBound = Word16
x Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
- Word16
1
        | Bool
otherwise     = String -> Word16
forall a. String -> a
predError String
"Word16"
    toEnum :: Int -> Word16
toEnum i :: Int
i@(I# Int#
i#)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16
forall a. Bounded a => a
maxBound::Word16)
                        = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (Int# -> Word#
int2Word# Int#
i#))
        | Bool
otherwise     = String -> Int -> (Word16, Word16) -> Word16
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Word16" Int
i (Word16
forall a. Bounded a => a
minBound::Word16, Word16
forall a. Bounded a => a
maxBound::Word16)
    fromEnum :: Word16 -> Int
fromEnum (W16# Word16#
x#)  = Int# -> Int
I# (Word# -> Int#
word2Int# (Word16# -> Word#
word16ToWord# Word16#
x#))
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFrom #-}
    enumFrom :: Word16 -> [Word16]
enumFrom            = Word16 -> [Word16]
forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromThen #-}
    enumFromThen :: Word16 -> Word16 -> [Word16]
enumFromThen        = Word16 -> Word16 -> [Word16]
forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen

-- | @since base-2.01
instance Integral Word16 where
    -- see Note [INLINE division wrappers] in GHC.Internal.Base
    {-# INLINE quot    #-}
    {-# INLINE rem     #-}
    {-# INLINE quotRem #-}
    {-# INLINE div     #-}
    {-# INLINE mod     #-}
    {-# INLINE divMod  #-}

    quot :: Word16 -> Word16 -> Word16
quot    (W16# Word16#
x#) y :: Word16
y@(W16# Word16#
y#)
        | Word16
y Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
0                    = Word16# -> Word16
W16# (Word16#
x# Word16# -> Word16# -> Word16#
`quotWord16#` Word16#
y#)
        | Bool
otherwise                 = Word16
forall a. a
divZeroError
    rem :: Word16 -> Word16 -> Word16
rem     (W16# Word16#
x#) y :: Word16
y@(W16# Word16#
y#)
        | Word16
y Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
0                    = Word16# -> Word16
W16# (Word16#
x# Word16# -> Word16# -> Word16#
`remWord16#` Word16#
y#)
        | Bool
otherwise                 = Word16
forall a. a
divZeroError
    quotRem :: Word16 -> Word16 -> (Word16, Word16)
quotRem (W16# Word16#
x#) y :: Word16
y@(W16# Word16#
y#)
        | Word16
y Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word16
0                    = case Word16#
x# Word16# -> Word16# -> (# Word16#, Word16# #)
`quotRemWord16#` Word16#
y# of
                                        (# Word16#
q, Word16#
r #) -> (Word16# -> Word16
W16# Word16#
q, Word16# -> Word16
W16# Word16#
r)
        | Bool
otherwise                 = (Word16, Word16)
forall a. a
divZeroError

    div :: Word16 -> Word16 -> Word16
div    Word16
x Word16
y = Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
quot Word16
x Word16
y
    mod :: Word16 -> Word16 -> Word16
mod    Word16
x Word16
y = Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
rem Word16
x Word16
y
    divMod :: Word16 -> Word16 -> (Word16, Word16)
divMod Word16
x Word16
y = Word16 -> Word16 -> (Word16, Word16)
forall a. Integral a => a -> a -> (a, a)
quotRem Word16
x Word16
y

    toInteger :: Word16 -> Integer
toInteger (W16# Word16#
x#)             = Int# -> Integer
IS (Word# -> Int#
word2Int# (Word16# -> Word#
word16ToWord# Word16#
x#))

-- | @since base-2.01
instance Bounded Word16 where
    minBound :: Word16
minBound = Word16
0
    maxBound :: Word16
maxBound = Word16
0xFFFF

-- | @since base-2.01
instance Ix Word16 where
    range :: (Word16, Word16) -> [Word16]
range (Word16
m,Word16
n)         = [Word16
m..Word16
n]
    unsafeIndex :: (Word16, Word16) -> Word16 -> Int
unsafeIndex (Word16
m,Word16
_) Word16
i = Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16
i Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
- Word16
m)
    inRange :: (Word16, Word16) -> Word16 -> Bool
inRange (Word16
m,Word16
n) Word16
i     = Word16
m Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word16
i Bool -> Bool -> Bool
&& Word16
i Word16 -> Word16 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word16
n

-- | @since base-2.01
instance Bits Word16 where
    {-# INLINE shift #-}
    {-# INLINE bit #-}
    {-# INLINE testBit #-}
    {-# INLINE popCount #-}

    (W16# Word16#
x#) .&. :: Word16 -> Word16 -> Word16
.&.   (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Word# -> Word#
`and#` (Word16# -> Word#
word16ToWord# Word16#
y#)))
    (W16# Word16#
x#) .|. :: Word16 -> Word16 -> Word16
.|.   (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Word# -> Word#
`or#`  (Word16# -> Word#
word16ToWord# Word16#
y#)))
    (W16# Word16#
x#) xor :: Word16 -> Word16 -> Word16
`xor` (W16# Word16#
y#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Word# -> Word#
`xor#` (Word16# -> Word#
word16ToWord# Word16#
y#)))
    complement :: Word16 -> Word16
complement (W16# Word16#
x#)       = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (Word# -> Word#
not# (Word16# -> Word#
word16ToWord# Word16#
x#)))
    (W16# Word16#
x#) shift :: Word16 -> Int -> Word16
`shift` (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise            = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`shiftRL#` Int# -> Int#
negateInt# Int#
i#))
    (W16# Word16#
x#) shiftL :: Word16 -> Int -> Word16
`shiftL`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise            = Word16
forall a. a
overflowError
    (W16# Word16#
x#) unsafeShiftL :: Word16 -> Int -> Word16
`unsafeShiftL` (I# Int#
i#) =
        Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i#))
    (W16# Word16#
x#) shiftR :: Word16 -> Int -> Word16
`shiftR`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`shiftRL#` Int#
i#))
        | Bool
otherwise            = Word16
forall a. a
overflowError
    (W16# Word16#
x#) unsafeShiftR :: Word16 -> Int -> Word16
`unsafeShiftR` (I# Int#
i#) = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` Int#
i#))
    (W16# Word16#
x#) rotate :: Word16 -> Int -> Word16
`rotate`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i'# Int# -> Int# -> Int#
==# Int#
0#) = Word16# -> Word16
W16# Word16#
x#
        | Bool
otherwise  = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i'#) Word# -> Word# -> Word#
`or#`
                                            ((Word16# -> Word#
word16ToWord# Word16#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` (Int#
16# Int# -> Int# -> Int#
-# Int#
i'#))))
        where
        !i'# :: Int#
i'# = Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
i# Word# -> Word# -> Word#
`and#` Word#
15##)
    bitSizeMaybe :: Word16 -> Maybe Int
bitSizeMaybe Word16
i            = Int -> Maybe Int
forall a. a -> Maybe a
Just (Word16 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word16
i)
    bitSize :: Word16 -> Int
bitSize Word16
i                 = Word16 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word16
i
    isSigned :: Word16 -> Bool
isSigned Word16
_                = Bool
False
    popCount :: Word16 -> Int
popCount (W16# Word16#
x#)        = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
popCnt16# (Word16# -> Word#
word16ToWord# Word16#
x#)))
    bit :: Int -> Word16
bit Int
i                     = Int -> Word16
forall a. (Bits a, Num a) => Int -> a
bitDefault Int
i
    testBit :: Word16 -> Int -> Bool
testBit Word16
a Int
i               = Word16 -> Int -> Bool
forall a. (Bits a, Num a) => a -> Int -> Bool
testBitDefault Word16
a Int
i

-- | @since base-4.6.0.0
instance FiniteBits Word16 where
    {-# INLINE countLeadingZeros #-}
    {-# INLINE countTrailingZeros #-}
    finiteBitSize :: Word16 -> Int
finiteBitSize Word16
_ = Int
16
    countLeadingZeros :: Word16 -> Int
countLeadingZeros  (W16# Word16#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
clz16# (Word16# -> Word#
word16ToWord# Word16#
x#)))
    countTrailingZeros :: Word16 -> Int
countTrailingZeros (W16# Word16#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
ctz16# (Word16# -> Word#
word16ToWord# Word16#
x#)))

-- | Reverse order of bytes in 'Word16'.
--
-- @since base-4.7.0.0
byteSwap16 :: Word16 -> Word16
byteSwap16 :: Word16 -> Word16
byteSwap16 (W16# Word16#
w#) = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (Word# -> Word#
byteSwap16# (Word16# -> Word#
word16ToWord# Word16#
w#)))

{-# RULES
"properFraction/Float->(Word16,Float)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word16) n, y :: Float) }
"truncate/Float->Word16"
    truncate = (fromIntegral :: Int -> Word16) . (truncate :: Float -> Int)
"floor/Float->Word16"
    floor    = (fromIntegral :: Int -> Word16) . (floor :: Float -> Int)
"ceiling/Float->Word16"
    ceiling  = (fromIntegral :: Int -> Word16) . (ceiling :: Float -> Int)
"round/Float->Word16"
    round    = (fromIntegral :: Int -> Word16) . (round  :: Float -> Int)
  #-}

{-# RULES
"properFraction/Double->(Word16,Double)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word16) n, y :: Double) }
"truncate/Double->Word16"
    truncate = (fromIntegral :: Int -> Word16) . (truncate :: Double -> Int)
"floor/Double->Word16"
    floor    = (fromIntegral :: Int -> Word16) . (floor :: Double -> Int)
"ceiling/Double->Word16"
    ceiling  = (fromIntegral :: Int -> Word16) . (ceiling :: Double -> Int)
"round/Double->Word16"
    round    = (fromIntegral :: Int -> Word16) . (round  :: Double -> Int)
  #-}

------------------------------------------------------------------------
-- type Word32
------------------------------------------------------------------------

-- Word32 is represented in the same way as Word.
#if WORD_SIZE_IN_BITS > 32
-- Operations may assume and must ensure that it holds only values
-- from its logical range.

-- We can use rewrite rules for the RealFrac methods

{-# RULES
"properFraction/Float->(Word32,Float)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word32) n, y :: Float) }
"truncate/Float->Word32"
    truncate = (fromIntegral :: Int -> Word32) . (truncate :: Float -> Int)
"floor/Float->Word32"
    floor    = (fromIntegral :: Int -> Word32) . (floor :: Float -> Int)
"ceiling/Float->Word32"
    ceiling  = (fromIntegral :: Int -> Word32) . (ceiling :: Float -> Int)
"round/Float->Word32"
    round    = (fromIntegral :: Int -> Word32) . (round  :: Float -> Int)
  #-}

{-# RULES
"properFraction/Double->(Word32,Double)"
    properFraction = \x ->
                      case properFraction x of {
                        (n, y) -> ((fromIntegral :: Int -> Word32) n, y :: Double) }
"truncate/Double->Word32"
    truncate = (fromIntegral :: Int -> Word32) . (truncate :: Double -> Int)
"floor/Double->Word32"
    floor    = (fromIntegral :: Int -> Word32) . (floor :: Double -> Int)
"ceiling/Double->Word32"
    ceiling  = (fromIntegral :: Int -> Word32) . (ceiling :: Double -> Int)
"round/Double->Word32"
    round    = (fromIntegral :: Int -> Word32) . (round  :: Double -> Int)
  #-}

#endif

data {-# CTYPE "HsWord32" #-} Word32 = W32# Word32#
-- ^ 32-bit unsigned integer type

-- See GHC.Classes#matching_overloaded_methods_in_rules
-- | @since base-2.01
instance Eq Word32 where
    == :: Word32 -> Word32 -> Bool
(==) = Word32 -> Word32 -> Bool
eqWord32
    /= :: Word32 -> Word32 -> Bool
(/=) = Word32 -> Word32 -> Bool
neWord32

eqWord32, neWord32 :: Word32 -> Word32 -> Bool
eqWord32 :: Word32 -> Word32 -> Bool
eqWord32 (W32# Word32#
x) (W32# Word32#
y) = Int# -> Bool
isTrue# ((Word32# -> Word#
word32ToWord# Word32#
x) Word# -> Word# -> Int#
`eqWord#` (Word32# -> Word#
word32ToWord# Word32#
y))
neWord32 :: Word32 -> Word32 -> Bool
neWord32 (W32# Word32#
x) (W32# Word32#
y) = Int# -> Bool
isTrue# ((Word32# -> Word#
word32ToWord# Word32#
x) Word# -> Word# -> Int#
`neWord#` (Word32# -> Word#
word32ToWord# Word32#
y))
{-# INLINE [1] eqWord32 #-}
{-# INLINE [1] neWord32 #-}

-- | @since base-2.01
instance Ord Word32 where
    < :: Word32 -> Word32 -> Bool
(<)  = Word32 -> Word32 -> Bool
ltWord32
    <= :: Word32 -> Word32 -> Bool
(<=) = Word32 -> Word32 -> Bool
leWord32
    >= :: Word32 -> Word32 -> Bool
(>=) = Word32 -> Word32 -> Bool
geWord32
    > :: Word32 -> Word32 -> Bool
(>)  = Word32 -> Word32 -> Bool
gtWord32

{-# INLINE [1] gtWord32 #-}
{-# INLINE [1] geWord32 #-}
{-# INLINE [1] ltWord32 #-}
{-# INLINE [1] leWord32 #-}
gtWord32, geWord32, ltWord32, leWord32 :: Word32 -> Word32 -> Bool
(W32# Word32#
x) gtWord32 :: Word32 -> Word32 -> Bool
`gtWord32` (W32# Word32#
y) = Int# -> Bool
isTrue# (Word32#
x Word32# -> Word32# -> Int#
`gtWord32#` Word32#
y)
(W32# Word32#
x) geWord32 :: Word32 -> Word32 -> Bool
`geWord32` (W32# Word32#
y) = Int# -> Bool
isTrue# (Word32#
x Word32# -> Word32# -> Int#
`geWord32#` Word32#
y)
(W32# Word32#
x) ltWord32 :: Word32 -> Word32 -> Bool
`ltWord32` (W32# Word32#
y) = Int# -> Bool
isTrue# (Word32#
x Word32# -> Word32# -> Int#
`ltWord32#` Word32#
y)
(W32# Word32#
x) leWord32 :: Word32 -> Word32 -> Bool
`leWord32` (W32# Word32#
y) = Int# -> Bool
isTrue# (Word32#
x Word32# -> Word32# -> Int#
`leWord32#` Word32#
y)

-- | @since base-2.01
instance Num Word32 where
    (W32# Word32#
x#) + :: Word32 -> Word32 -> Word32
+ (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word32#
x# Word32# -> Word32# -> Word32#
`plusWord32#` Word32#
y#)
    (W32# Word32#
x#) - :: Word32 -> Word32 -> Word32
- (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word32#
x# Word32# -> Word32# -> Word32#
`subWord32#` Word32#
y#)
    (W32# Word32#
x#) * :: Word32 -> Word32 -> Word32
* (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word32#
x# Word32# -> Word32# -> Word32#
`timesWord32#` Word32#
y#)
    negate :: Word32 -> Word32
negate (W32# Word32#
x#)       = Word32# -> Word32
W32# (Int32# -> Word32#
int32ToWord32# (Int32# -> Int32#
negateInt32# (Word32# -> Int32#
word32ToInt32# Word32#
x#)))
    abs :: Word32 -> Word32
abs Word32
x                  = Word32
x
    signum :: Word32 -> Word32
signum Word32
0               = Word32
0
    signum Word32
_               = Word32
1
    fromInteger :: Integer -> Word32
fromInteger Integer
i          = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (Integer -> Word#
integerToWord# Integer
i))

-- | @since base-2.01
instance Enum Word32 where
    succ :: Word32 -> Word32
succ Word32
x
        | Word32
x Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
forall a. Bounded a => a
maxBound = Word32
x Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
1
        | Bool
otherwise     = String -> Word32
forall a. String -> a
succError String
"Word32"
    pred :: Word32 -> Word32
pred Word32
x
        | Word32
x Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
forall a. Bounded a => a
minBound = Word32
x Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1
        | Bool
otherwise     = String -> Word32
forall a. String -> a
predError String
"Word32"
    toEnum :: Int -> Word32
toEnum i :: Int
i@(I# Int#
i#)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0
#if WORD_SIZE_IN_BITS > 32
          Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
forall a. Bounded a => a
maxBound::Word32)
#endif
                        = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (Int# -> Word#
int2Word# Int#
i#))
        | Bool
otherwise     = String -> Int -> (Word32, Word32) -> Word32
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Word32" Int
i (Word32
forall a. Bounded a => a
minBound::Word32, Word32
forall a. Bounded a => a
maxBound::Word32)
#if WORD_SIZE_IN_BITS == 32
    fromEnum x@(W32# x#)
        | x <= fromIntegral (maxBound::Int)
                        = I# (word2Int# (word32ToWord# x#))
        | otherwise     = fromEnumError "Word32" x
    enumFrom            = integralEnumFrom
    enumFromThen        = integralEnumFromThen
    enumFromTo          = integralEnumFromTo
    enumFromThenTo      = integralEnumFromThenTo
#else
    fromEnum :: Word32 -> Int
fromEnum (W32# Word32#
x#)  = Int# -> Int
I# (Word# -> Int#
word2Int# (Word32# -> Word#
word32ToWord# Word32#
x#))
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFrom #-}
    enumFrom :: Word32 -> [Word32]
enumFrom            = Word32 -> [Word32]
forall a. (Enum a, Bounded a) => a -> [a]
boundedEnumFrom
    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromThen #-}
    enumFromThen :: Word32 -> Word32 -> [Word32]
enumFromThen        = Word32 -> Word32 -> [Word32]
forall a. (Enum a, Bounded a) => a -> a -> [a]
boundedEnumFromThen
#endif

-- | @since base-2.01
instance Integral Word32 where
    -- see Note [INLINE division wrappers] in GHC.Internal.Base
    {-# INLINE quot    #-}
    {-# INLINE rem     #-}
    {-# INLINE quotRem #-}
    {-# INLINE div     #-}
    {-# INLINE mod     #-}
    {-# INLINE divMod  #-}

    quot :: Word32 -> Word32 -> Word32
quot    (W32# Word32#
x#) y :: Word32
y@(W32# Word32#
y#)
        | Word32
y Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0                    = Word32# -> Word32
W32# (Word32#
x# Word32# -> Word32# -> Word32#
`quotWord32#` Word32#
y#)
        | Bool
otherwise                 = Word32
forall a. a
divZeroError
    rem :: Word32 -> Word32 -> Word32
rem     (W32# Word32#
x#) y :: Word32
y@(W32# Word32#
y#)
        | Word32
y Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0                    = Word32# -> Word32
W32# (Word32#
x# Word32# -> Word32# -> Word32#
`remWord32#` Word32#
y#)
        | Bool
otherwise                 = Word32
forall a. a
divZeroError
    quotRem :: Word32 -> Word32 -> (Word32, Word32)
quotRem (W32# Word32#
x#) y :: Word32
y@(W32# Word32#
y#)
        | Word32
y Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
0                    = case Word32#
x# Word32# -> Word32# -> (# Word32#, Word32# #)
`quotRemWord32#` Word32#
y# of
                                        (# Word32#
q, Word32#
r #) -> (Word32# -> Word32
W32# Word32#
q, Word32# -> Word32
W32# Word32#
r)
        | Bool
otherwise                 = (Word32, Word32)
forall a. a
divZeroError

    div :: Word32 -> Word32 -> Word32
div    Word32
x Word32
y = Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
quot Word32
x Word32
y
    mod :: Word32 -> Word32 -> Word32
mod    Word32
x Word32
y = Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
rem Word32
x Word32
y
    divMod :: Word32 -> Word32 -> (Word32, Word32)
divMod Word32
x Word32
y = Word32 -> Word32 -> (Word32, Word32)
forall a. Integral a => a -> a -> (a, a)
quotRem Word32
x Word32
y

    toInteger :: Word32 -> Integer
toInteger (W32# Word32#
x#) =
#if WORD_SIZE_IN_BITS > 32
      -- In this case the conversion to Int# cannot overflow.
      Int# -> Integer
IS (Word# -> Int#
word2Int# (Word32# -> Word#
word32ToWord# Word32#
x#))
#else
      integerFromWord# (word32ToWord# x#)
#endif

-- | @since base-2.01
instance Bits Word32 where
    {-# INLINE shift #-}
    {-# INLINE bit #-}
    {-# INLINE testBit #-}
    {-# INLINE popCount #-}

    (W32# Word32#
x#) .&. :: Word32 -> Word32 -> Word32
.&.   (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Word# -> Word#
`and#` (Word32# -> Word#
word32ToWord# Word32#
y#)))
    (W32# Word32#
x#) .|. :: Word32 -> Word32 -> Word32
.|.   (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Word# -> Word#
`or#`  (Word32# -> Word#
word32ToWord# Word32#
y#)))
    (W32# Word32#
x#) xor :: Word32 -> Word32 -> Word32
`xor` (W32# Word32#
y#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Word# -> Word#
`xor#` (Word32# -> Word#
word32ToWord# Word32#
y#)))
    complement :: Word32 -> Word32
complement (W32# Word32#
x#)       = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (Word# -> Word#
not# (Word32# -> Word#
word32ToWord# Word32#
x#)))
    (W32# Word32#
x#) shift :: Word32 -> Int -> Word32
`shift` (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise            = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`shiftRL#` Int# -> Int#
negateInt# Int#
i#))
    (W32# Word32#
x#) shiftL :: Word32 -> Int -> Word32
`shiftL`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`shiftL#` Int#
i#))
        | Bool
otherwise            = Word32
forall a. a
overflowError
    (W32# Word32#
x#) unsafeShiftL :: Word32 -> Int -> Word32
`unsafeShiftL` (I# Int#
i#) =
        Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i#))
    (W32# Word32#
x#) shiftR :: Word32 -> Int -> Word32
`shiftR`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`shiftRL#` Int#
i#))
        | Bool
otherwise            = Word32
forall a. a
overflowError
    (W32# Word32#
x#) unsafeShiftR :: Word32 -> Int -> Word32
`unsafeShiftR` (I# Int#
i#) = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` Int#
i#))
    (W32# Word32#
x#) rotate :: Word32 -> Int -> Word32
`rotate`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i'# Int# -> Int# -> Int#
==# Int#
0#) = Word32# -> Word32
W32# Word32#
x#
        | Bool
otherwise   = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`uncheckedShiftL#` Int#
i'#) Word# -> Word# -> Word#
`or#`
                                            ((Word32# -> Word#
word32ToWord# Word32#
x#) Word# -> Int# -> Word#
`uncheckedShiftRL#` (Int#
32# Int# -> Int# -> Int#
-# Int#
i'#))))
        where
        !i'# :: Int#
i'# = Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
i# Word# -> Word# -> Word#
`and#` Word#
31##)
    bitSizeMaybe :: Word32 -> Maybe Int
bitSizeMaybe Word32
i            = Int -> Maybe Int
forall a. a -> Maybe a
Just (Word32 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word32
i)
    bitSize :: Word32 -> Int
bitSize Word32
i                 = Word32 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word32
i
    isSigned :: Word32 -> Bool
isSigned Word32
_                = Bool
False
    popCount :: Word32 -> Int
popCount (W32# Word32#
x#)        = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
popCnt32# (Word32# -> Word#
word32ToWord# Word32#
x#)))
    bit :: Int -> Word32
bit Int
i                     = Int -> Word32
forall a. (Bits a, Num a) => Int -> a
bitDefault Int
i
    testBit :: Word32 -> Int -> Bool
testBit Word32
a Int
i               = Word32 -> Int -> Bool
forall a. (Bits a, Num a) => a -> Int -> Bool
testBitDefault Word32
a Int
i

-- | @since base-4.6.0.0
instance FiniteBits Word32 where
    {-# INLINE countLeadingZeros #-}
    {-# INLINE countTrailingZeros #-}
    finiteBitSize :: Word32 -> Int
finiteBitSize Word32
_ = Int
32
    countLeadingZeros :: Word32 -> Int
countLeadingZeros  (W32# Word32#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
clz32# (Word32# -> Word#
word32ToWord# Word32#
x#)))
    countTrailingZeros :: Word32 -> Int
countTrailingZeros (W32# Word32#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word# -> Word#
ctz32# (Word32# -> Word#
word32ToWord# Word32#
x#)))

-- | @since base-2.01
instance Show Word32 where
#if WORD_SIZE_IN_BITS < 33
    showsPrec p x = showsPrec p (toInteger x)
#else
    showsPrec :: Int -> Word32 -> ShowS
showsPrec Int
p Word32
x = Int -> Int -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x :: Int)
#endif


-- | @since base-2.01
instance Real Word32 where
    toRational :: Word32 -> Rational
toRational Word32
x = Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger Word32
x Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1

-- | @since base-2.01
instance Bounded Word32 where
    minBound :: Word32
minBound = Word32
0
    maxBound :: Word32
maxBound = Word32
0xFFFFFFFF

-- | @since base-2.01
instance Ix Word32 where
    range :: (Word32, Word32) -> [Word32]
range (Word32
m,Word32
n)         = [Word32
m..Word32
n]
    unsafeIndex :: (Word32, Word32) -> Word32 -> Int
unsafeIndex (Word32
m,Word32
_) Word32
i = Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32
i Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
m)
    inRange :: (Word32, Word32) -> Word32 -> Bool
inRange (Word32
m,Word32
n) Word32
i     = Word32
m Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
i Bool -> Bool -> Bool
&& Word32
i Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
n

-- | Reverse order of bytes in 'Word32'.
--
-- @since base-4.7.0.0
byteSwap32 :: Word32 -> Word32
byteSwap32 :: Word32 -> Word32
byteSwap32 (W32# Word32#
w#) = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (Word# -> Word#
byteSwap32# (Word32# -> Word#
word32ToWord# Word32#
w#)))

------------------------------------------------------------------------
-- type Word64
------------------------------------------------------------------------

data {-# CTYPE "HsWord64" #-} Word64 = W64# Word64#
-- ^ 64-bit unsigned integer type

-- See GHC.Classes#matching_overloaded_methods_in_rules
-- | @since base-2.01
instance Eq Word64 where
    == :: Word64 -> Word64 -> Bool
(==) = Word64 -> Word64 -> Bool
eqWord64
    /= :: Word64 -> Word64 -> Bool
(/=) = Word64 -> Word64 -> Bool
neWord64

eqWord64, neWord64 :: Word64 -> Word64 -> Bool
eqWord64 :: Word64 -> Word64 -> Bool
eqWord64 (W64# Word64#
x) (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`eqWord64#` Word64#
y)
neWord64 :: Word64 -> Word64 -> Bool
neWord64 (W64# Word64#
x) (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`neWord64#` Word64#
y)
{-# INLINE [1] eqWord64 #-}
{-# INLINE [1] neWord64 #-}

-- | @since base-2.01
instance Ord Word64 where
    < :: Word64 -> Word64 -> Bool
(<)  = Word64 -> Word64 -> Bool
ltWord64
    <= :: Word64 -> Word64 -> Bool
(<=) = Word64 -> Word64 -> Bool
leWord64
    >= :: Word64 -> Word64 -> Bool
(>=) = Word64 -> Word64 -> Bool
geWord64
    > :: Word64 -> Word64 -> Bool
(>)  = Word64 -> Word64 -> Bool
gtWord64

{-# INLINE [1] gtWord64 #-}
{-# INLINE [1] geWord64 #-}
{-# INLINE [1] ltWord64 #-}
{-# INLINE [1] leWord64 #-}
gtWord64, geWord64, ltWord64, leWord64 :: Word64 -> Word64 -> Bool
(W64# Word64#
x) gtWord64 :: Word64 -> Word64 -> Bool
`gtWord64` (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`gtWord64#` Word64#
y)
(W64# Word64#
x) geWord64 :: Word64 -> Word64 -> Bool
`geWord64` (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`geWord64#` Word64#
y)
(W64# Word64#
x) ltWord64 :: Word64 -> Word64 -> Bool
`ltWord64` (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`ltWord64#` Word64#
y)
(W64# Word64#
x) leWord64 :: Word64 -> Word64 -> Bool
`leWord64` (W64# Word64#
y) = Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`leWord64#` Word64#
y)

-- | @since base-2.01
instance Num Word64 where
    (W64# Word64#
x#) + :: Word64 -> Word64 -> Word64
+ (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`plusWord64#` Word64#
y#)
    (W64# Word64#
x#) - :: Word64 -> Word64 -> Word64
- (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`subWord64#` Word64#
y#)
    (W64# Word64#
x#) * :: Word64 -> Word64 -> Word64
* (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`timesWord64#` Word64#
y#)
    negate :: Word64 -> Word64
negate (W64# Word64#
x#)       = Word64# -> Word64
W64# (Int64# -> Word64#
int64ToWord64# (Int64# -> Int64#
negateInt64# (Word64# -> Int64#
word64ToInt64# Word64#
x#)))
    abs :: Word64 -> Word64
abs Word64
x                  = Word64
x
    signum :: Word64 -> Word64
signum Word64
0               = Word64
0
    signum Word64
_               = Word64
1
    fromInteger :: Integer -> Word64
fromInteger Integer
i          = Word64# -> Word64
W64# (Integer -> Word64#
integerToWord64# Integer
i)

-- | @since base-2.01
instance Enum Word64 where
    succ :: Word64 -> Word64
succ Word64
x
        | Word64
x Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
forall a. Bounded a => a
maxBound = Word64
x Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
1
        | Bool
otherwise     = String -> Word64
forall a. String -> a
succError String
"Word64"
    pred :: Word64 -> Word64
pred Word64
x
        | Word64
x Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
forall a. Bounded a => a
minBound = Word64
x Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1
        | Bool
otherwise     = String -> Word64
forall a. String -> a
predError String
"Word64"
    toEnum :: Int -> Word64
toEnum i :: Int
i@(I# Int#
i#)
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0        = Word64# -> Word64
W64# (Word# -> Word64#
wordToWord64# (Int# -> Word#
int2Word# Int#
i#))
        | Bool
otherwise     = String -> Int -> (Word64, Word64) -> Word64
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Word64" Int
i (Word64
forall a. Bounded a => a
minBound::Word64, Word64
forall a. Bounded a => a
maxBound::Word64)
    fromEnum :: Word64 -> Int
fromEnum x :: Word64
x@(W64# Word64#
x#)
        | Word64
x Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
forall a. Bounded a => a
maxBound::Int)
                        = Int# -> Int
I# (Word# -> Int#
word2Int# (Word64# -> Word#
word64ToWord# Word64#
x#))
        | Bool
otherwise     = String -> Word64 -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"Word64" Word64
x

    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFrom #-}
    enumFrom :: Word64 -> [Word64]
enumFrom (W64# Word64#
x#)      = Word64# -> Word64# -> [Word64]
eftWord64 Word64#
x# Word64#
maxWord#
        where !(W64# Word64#
maxWord#) = Word64
forall a. Bounded a => a
maxBound
        -- Blarg: technically I guess enumFrom isn't strict!

    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromTo #-}
    enumFromTo :: Word64 -> Word64 -> [Word64]
enumFromTo (W64# Word64#
x) (W64# Word64#
y) = Word64# -> Word64# -> [Word64]
eftWord64 Word64#
x Word64#
y

    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromThen #-}
    enumFromThen :: Word64 -> Word64 -> [Word64]
enumFromThen (W64# Word64#
x1) (W64# Word64#
x2) = Word64# -> Word64# -> [Word64]
efdWord64 Word64#
x1 Word64#
x2

    -- See Note [Stable Unfolding for list producers] in GHC.Internal.Enum
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]
enumFromThenTo (W64# Word64#
x1) (W64# Word64#
x2) (W64# Word64#
y) = Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64 Word64#
x1 Word64#
x2 Word64#
y


-----------------------------------------------------
-- eftWord64 and eftWord64FB deal with [a..b], which is the
-- most common form, so we take a lot of care
-- In particular, we have rules for deforestation

{-# RULES
"eftWord64"        [~1] forall x y. eftWord64 x y = build (\ c n -> eftWord64FB c n x y)
"eftWord64List"    [1] eftWord64FB  (:) [] = eftWord64
 #-}

-- The Enum rules for Word64 work much the same way that they do for Int.
-- See Note [How the Enum rules work].

{-# NOINLINE [1] eftWord64 #-}
eftWord64 :: Word64# -> Word64# -> [Word64]
-- [x1..x2]
eftWord64 :: Word64# -> Word64# -> [Word64]
eftWord64 Word64#
x0 Word64#
y | Int# -> Bool
isTrue# (Word64#
x0 Word64# -> Word64# -> Int#
`gtWord64#` Word64#
y) = []
               | Bool
otherwise                = Word64# -> [Word64]
go Word64#
x0
                  where
                    go :: Word64# -> [Word64]
go Word64#
x = Word64# -> Word64
W64# Word64#
x Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: if Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`eqWord64#` Word64#
y)
                                    then []
                                    else Word64# -> [Word64]
go (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` (Word# -> Word64#
wordToWord64# Word#
1##))

{-# INLINE [0] eftWord64FB #-} -- See Note [Inline FB functions] in GHC.Internal.List
eftWord64FB :: (Word64 -> r -> r) -> r -> Word64# -> Word64# -> r
eftWord64FB :: forall r. (Word64 -> r -> r) -> r -> Word64# -> Word64# -> r
eftWord64FB Word64 -> r -> r
c r
n Word64#
x0 Word64#
y | Int# -> Bool
isTrue# (Word64#
x0 Word64# -> Word64# -> Int#
`gtWord64#` Word64#
y) = r
n
                     | Bool
otherwise                = Word64# -> r
go Word64#
x0
                    where
                      go :: Word64# -> r
go Word64#
x = Word64# -> Word64
W64# Word64#
x Word64 -> r -> r
`c` if Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`eqWord64#` Word64#
y)
                                        then r
n
                                        else Word64# -> r
go (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` (Word# -> Word64#
wordToWord64# Word#
1##))
                            -- Watch out for y=maxBound; hence ==, not >
        -- Be very careful not to have more than one "c"
        -- so that when eftInfFB is inlined we can inline
        -- whatever is bound to "c"


-----------------------------------------------------
-- efdWord64 and efdtWord64 deal with [a,b..] and [a,b..c].
-- The code is more complicated because of worries about Word64 overflow.

-- See Note [How the Enum rules work]
{-# RULES
"efdtWord64"       [~1] forall x1 x2 y.
                     efdtWord64 x1 x2 y = build (\ c n -> efdtWord64FB c n x1 x2 y)
"efdtWord64UpList" [1]  efdtWord64FB (:) [] = efdtWord64
 #-}

efdWord64 :: Word64# -> Word64# -> [Word64]
-- [x1,x2..maxWord64]
efdWord64 :: Word64# -> Word64# -> [Word64]
efdWord64 Word64#
x1 Word64#
x2
 | Int# -> Bool
isTrue# (Word64#
x2 Word64# -> Word64# -> Int#
`geWord64#` Word64#
x1) = case Word64
forall a. Bounded a => a
maxBound of W64# Word64#
y -> Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Up Word64#
x1 Word64#
x2 Word64#
y
 | Bool
otherwise                   = case Word64
forall a. Bounded a => a
minBound of W64# Word64#
y -> Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Dn Word64#
x1 Word64#
x2 Word64#
y

{-# NOINLINE [1] efdtWord64 #-}
efdtWord64 :: Word64# -> Word64# -> Word64# -> [Word64]
-- [x1,x2..y]
efdtWord64 :: Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64 Word64#
x1 Word64#
x2 Word64#
y
 | Int# -> Bool
isTrue# (Word64#
x2 Word64# -> Word64# -> Int#
`geWord64#` Word64#
x1) = Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Up Word64#
x1 Word64#
x2 Word64#
y
 | Bool
otherwise                   = Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Dn Word64#
x1 Word64#
x2 Word64#
y

{-# INLINE [0] efdtWord64FB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWord64FB :: (Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64FB :: forall r.
(Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64FB Word64 -> r -> r
c r
n Word64#
x1 Word64#
x2 Word64#
y
 | Int# -> Bool
isTrue# (Word64#
x2 Word64# -> Word64# -> Int#
`geWord64#` Word64#
x1) = (Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
forall r.
(Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64UpFB Word64 -> r -> r
c r
n Word64#
x1 Word64#
x2 Word64#
y
 | Bool
otherwise                   = (Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
forall r.
(Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64DnFB Word64 -> r -> r
c r
n Word64#
x1 Word64#
x2 Word64#
y

-- Requires x2 >= x1
efdtWord64Up :: Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Up :: Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Up Word64#
x1 Word64#
x2 Word64#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`ltWord64#` Word64#
x2) = if Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`ltWord64#` Word64#
x1) then [] else [Word64# -> Word64
W64# Word64#
x1]
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Word64#
delta = Word64#
x2 Word64# -> Word64# -> Word64#
`subWord64#` Word64#
x1 -- >= 0
                   !y' :: Word64#
y' = Word64#
y Word64# -> Word64# -> Word64#
`subWord64#` Word64#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Word64# -> [Word64]
go_up Word64#
x | Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`gtWord64#` Word64#
y') = [Word64# -> Word64
W64# Word64#
x]
                           | Bool
otherwise                  = Word64# -> Word64
W64# Word64#
x Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: Word64# -> [Word64]
go_up (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` Word64#
delta)
               in Word64# -> Word64
W64# Word64#
x1 Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: Word64# -> [Word64]
go_up Word64#
x2

-- Requires x2 >= x1
{-# INLINE [0] efdtWord64UpFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWord64UpFB :: (Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64UpFB :: forall r.
(Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64UpFB Word64 -> r -> r
c r
n Word64#
x1 Word64#
x2 Word64#
y    -- Be careful about overflow!
 | Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`ltWord64#` Word64#
x2) = if Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`ltWord64#` Word64#
x1) then r
n else Word64# -> Word64
W64# Word64#
x1 Word64 -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 <= x2 <= y
               let !delta :: Word64#
delta = Word64#
x2 Word64# -> Word64# -> Word64#
`subWord64#` Word64#
x1 -- >= 0
                   !y' :: Word64#
y' = Word64#
y Word64# -> Word64# -> Word64#
`subWord64#` Word64#
delta  -- x1 <= y' <= y; hence y' is representable

                   -- Invariant: x <= y
                   -- Note that: z <= y' => z + delta won't overflow
                   -- so we are guaranteed not to overflow if/when we recurse
                   go_up :: Word64# -> r
go_up Word64#
x | Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`gtWord64#` Word64#
y') = Word64# -> Word64
W64# Word64#
x Word64 -> r -> r
`c` r
n
                           | Bool
otherwise                  = Word64# -> Word64
W64# Word64#
x Word64 -> r -> r
`c` Word64# -> r
go_up (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` Word64#
delta)
               in Word64# -> Word64
W64# Word64#
x1 Word64 -> r -> r
`c` Word64# -> r
go_up Word64#
x2

-- Requires x2 <= x1
efdtWord64Dn :: Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Dn :: Word64# -> Word64# -> Word64# -> [Word64]
efdtWord64Dn Word64#
x1 Word64#
x2 Word64#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`gtWord64#` Word64#
x2) = if Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`gtWord64#` Word64#
x1) then [] else [Word64# -> Word64
W64# Word64#
x1]
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Word64#
delta = Word64#
x2 Word64# -> Word64# -> Word64#
`subWord64#` Word64#
x1 -- <= 0
                   !y' :: Word64#
y' = Word64#
y Word64# -> Word64# -> Word64#
`subWord64#` Word64#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Word64# -> [Word64]
go_dn Word64#
x | Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`ltWord64#` Word64#
y') = [Word64# -> Word64
W64# Word64#
x]
                           | Bool
otherwise                  = Word64# -> Word64
W64# Word64#
x Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: Word64# -> [Word64]
go_dn (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` Word64#
delta)
   in Word64# -> Word64
W64# Word64#
x1 Word64 -> [Word64] -> [Word64]
forall a. a -> [a] -> [a]
: Word64# -> [Word64]
go_dn Word64#
x2

-- Requires x2 <= x1
{-# INLINE [0] efdtWord64DnFB #-} -- See Note [Inline FB functions] in GHC.Internal.List
efdtWord64DnFB :: (Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64DnFB :: forall r.
(Word64 -> r -> r) -> r -> Word64# -> Word64# -> Word64# -> r
efdtWord64DnFB Word64 -> r -> r
c r
n Word64#
x1 Word64#
x2 Word64#
y    -- Be careful about underflow!
 | Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`gtWord64#` Word64#
x2) = if Int# -> Bool
isTrue# (Word64#
y Word64# -> Word64# -> Int#
`gtWord64#` Word64#
x1) then r
n else Word64# -> Word64
W64# Word64#
x1 Word64 -> r -> r
`c` r
n
 | Bool
otherwise = -- Common case: x1 >= x2 >= y
               let !delta :: Word64#
delta = Word64#
x2 Word64# -> Word64# -> Word64#
`subWord64#` Word64#
x1 -- <= 0
                   !y' :: Word64#
y' = Word64#
y Word64# -> Word64# -> Word64#
`subWord64#` Word64#
delta  -- y <= y' <= x1; hence y' is representable

                   -- Invariant: x >= y
                   -- Note that: z >= y' => z + delta won't underflow
                   -- so we are guaranteed not to underflow if/when we recurse
                   go_dn :: Word64# -> r
go_dn Word64#
x | Int# -> Bool
isTrue# (Word64#
x Word64# -> Word64# -> Int#
`ltWord64#` Word64#
y') = Word64# -> Word64
W64# Word64#
x Word64 -> r -> r
`c` r
n
                           | Bool
otherwise                  = Word64# -> Word64
W64# Word64#
x Word64 -> r -> r
`c` Word64# -> r
go_dn (Word64#
x Word64# -> Word64# -> Word64#
`plusWord64#` Word64#
delta)
               in Word64# -> Word64
W64# Word64#
x1 Word64 -> r -> r
`c` Word64# -> r
go_dn Word64#
x2


-- | @since base-2.01
instance Integral Word64 where
    -- see Note [INLINE division wrappers] in GHC.Internal.Base
    {-# INLINE quot    #-}
    {-# INLINE rem     #-}
    {-# INLINE quotRem #-}
    {-# INLINE div     #-}
    {-# INLINE mod     #-}
    {-# INLINE divMod  #-}

    quot :: Word64 -> Word64 -> Word64
quot    (W64# Word64#
x#) y :: Word64
y@(W64# Word64#
y#)
        | Word64
y Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0                    = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`quotWord64#` Word64#
y#)
        | Bool
otherwise                 = Word64
forall a. a
divZeroError
    rem :: Word64 -> Word64 -> Word64
rem     (W64# Word64#
x#) y :: Word64
y@(W64# Word64#
y#)
        | Word64
y Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0                    = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`remWord64#` Word64#
y#)
        | Bool
otherwise                 = Word64
forall a. a
divZeroError
    quotRem :: Word64 -> Word64 -> (Word64, Word64)
quotRem (W64# Word64#
x#) y :: Word64
y@(W64# Word64#
y#)
#if WORD_SIZE_IN_BITS < 64
        | y /= 0                    = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
#else
        -- we don't have a `quotRemWord64#` primitive yet.
        | Word64
y Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0                    = case Word# -> Word# -> (# Word#, Word# #)
quotRemWord# (Word64# -> Word#
word64ToWord# Word64#
x#) (Word64# -> Word#
word64ToWord# Word64#
y#) of
                                        (# Word#
q, Word#
r #) -> (Word64# -> Word64
W64# (Word# -> Word64#
wordToWord64# Word#
q),  Word64# -> Word64
W64# (Word# -> Word64#
wordToWord64# Word#
r))
#endif
        | Bool
otherwise                 = (Word64, Word64)
forall a. a
divZeroError

    div :: Word64 -> Word64 -> Word64
div    Word64
x Word64
y = Word64 -> Word64 -> Word64
forall a. Integral a => a -> a -> a
quot Word64
x Word64
y
    mod :: Word64 -> Word64 -> Word64
mod    Word64
x Word64
y = Word64 -> Word64 -> Word64
forall a. Integral a => a -> a -> a
rem Word64
x Word64
y
    divMod :: Word64 -> Word64 -> (Word64, Word64)
divMod Word64
x Word64
y = Word64 -> Word64 -> (Word64, Word64)
forall a. Integral a => a -> a -> (a, a)
quotRem Word64
x Word64
y

    toInteger :: Word64 -> Integer
toInteger (W64# Word64#
x#)             = Word64# -> Integer
integerFromWord64# Word64#
x#

-- | @since base-2.01
instance Bits Word64 where
    {-# INLINE shift #-}
    {-# INLINE bit #-}
    {-# INLINE testBit #-}
    {-# INLINE popCount #-}

    (W64# Word64#
x#) .&. :: Word64 -> Word64 -> Word64
.&.   (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`and64#` Word64#
y#)
    (W64# Word64#
x#) .|. :: Word64 -> Word64 -> Word64
.|.   (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`or64#`  Word64#
y#)
    (W64# Word64#
x#) xor :: Word64 -> Word64 -> Word64
`xor` (W64# Word64#
y#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Word64# -> Word64#
`xor64#` Word64#
y#)
    complement :: Word64 -> Word64
complement (W64# Word64#
x#)       = Word64# -> Word64
W64# (Word64# -> Word64#
not64# Word64#
x#)
    (W64# Word64#
x#) shift :: Word64 -> Int -> Word64
`shift` (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`shiftLWord64#` Int#
i#)
        | Bool
otherwise            = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`shiftRLWord64#` Int# -> Int#
negateInt# Int#
i#)
    (W64# Word64#
x#) shiftL :: Word64 -> Int -> Word64
`shiftL`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`shiftLWord64#` Int#
i#)
        | Bool
otherwise            = Word64
forall a. a
overflowError
    (W64# Word64#
x#) unsafeShiftL :: Word64 -> Int -> Word64
`unsafeShiftL` (I# Int#
i#) = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`uncheckedShiftL64#` Int#
i#)
    (W64# Word64#
x#) shiftR :: Word64 -> Int -> Word64
`shiftR`       (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i# Int# -> Int# -> Int#
>=# Int#
0#)  = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`shiftRLWord64#` Int#
i#)
        | Bool
otherwise            = Word64
forall a. a
overflowError
    (W64# Word64#
x#) unsafeShiftR :: Word64 -> Int -> Word64
`unsafeShiftR` (I# Int#
i#) = Word64# -> Word64
W64# (Word64#
x# Word64# -> Int# -> Word64#
`uncheckedShiftRL64#` Int#
i#)
    (W64# Word64#
x#) rotate :: Word64 -> Int -> Word64
`rotate` (I# Int#
i#)
        | Int# -> Bool
isTrue# (Int#
i'# Int# -> Int# -> Int#
==# Int#
0#) = Word64# -> Word64
W64# Word64#
x#
        | Bool
otherwise            = Word64# -> Word64
W64# ((Word64#
x# Word64# -> Int# -> Word64#
`uncheckedShiftL64#` Int#
i'#) Word64# -> Word64# -> Word64#
`or64#`
                                       (Word64#
x# Word64# -> Int# -> Word64#
`uncheckedShiftRL64#` (Int#
64# Int# -> Int# -> Int#
-# Int#
i'#)))
        where
        !i'# :: Int#
i'# = Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
i# Word# -> Word# -> Word#
`and#` Word#
63##)
    bitSizeMaybe :: Word64 -> Maybe Int
bitSizeMaybe Word64
i            = Int -> Maybe Int
forall a. a -> Maybe a
Just (Word64 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word64
i)
    bitSize :: Word64 -> Int
bitSize Word64
i                 = Word64 -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize Word64
i
    isSigned :: Word64 -> Bool
isSigned Word64
_                = Bool
False
    popCount :: Word64 -> Int
popCount (W64# Word64#
x#)        = Int# -> Int
I# (Word# -> Int#
word2Int# (Word64# -> Word#
popCnt64# Word64#
x#))
    bit :: Int -> Word64
bit Int
i                     = Int -> Word64
forall a. (Bits a, Num a) => Int -> a
bitDefault Int
i
    testBit :: Word64 -> Int -> Bool
testBit Word64
a Int
i               = Word64 -> Int -> Bool
forall a. (Bits a, Num a) => a -> Int -> Bool
testBitDefault Word64
a Int
i

-- | @since base-4.6.0.0
instance FiniteBits Word64 where
    {-# INLINE countLeadingZeros #-}
    {-# INLINE countTrailingZeros #-}
    finiteBitSize :: Word64 -> Int
finiteBitSize Word64
_ = Int
64
    countLeadingZeros :: Word64 -> Int
countLeadingZeros  (W64# Word64#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word64# -> Word#
clz64# Word64#
x#))
    countTrailingZeros :: Word64 -> Int
countTrailingZeros (W64# Word64#
x#) = Int# -> Int
I# (Word# -> Int#
word2Int# (Word64# -> Word#
ctz64# Word64#
x#))

-- | @since base-2.01
instance Show Word64 where
    showsPrec :: Int -> Word64 -> ShowS
showsPrec Int
p Word64
x = Int -> Integer -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger Word64
x)

-- | @since base-2.01
instance Real Word64 where
    toRational :: Word64 -> Rational
toRational Word64
x = Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger Word64
x Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1

-- | @since base-2.01
instance Bounded Word64 where
    minBound :: Word64
minBound = Word64
0
    maxBound :: Word64
maxBound = Word64
0xFFFFFFFFFFFFFFFF

-- | @since base-2.01
instance Ix Word64 where
    range :: (Word64, Word64) -> [Word64]
range (Word64
m,Word64
n)         = [Word64
m..Word64
n]
    unsafeIndex :: (Word64, Word64) -> Word64 -> Int
unsafeIndex (Word64
m,Word64
_) Word64
i = Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64
i Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
m)
    inRange :: (Word64, Word64) -> Word64 -> Bool
inRange (Word64
m,Word64
n) Word64
i     = Word64
m Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word64
i Bool -> Bool -> Bool
&& Word64
i Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word64
n

-- | Reverse order of bytes in 'Word64'.
--
-- @since base-4.7.0.0
byteSwap64 :: Word64 -> Word64
byteSwap64 :: Word64 -> Word64
byteSwap64 (W64# Word64#
w#) = Word64# -> Word64
W64# (Word64# -> Word64#
byteSwap64# Word64#
w#)

-- | Reverse the order of the bits in a 'Word8'.
--
-- @since base-4.14.0.0
bitReverse8 :: Word8 -> Word8
bitReverse8 :: Word8 -> Word8
bitReverse8 (W8# Word8#
w#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (Word# -> Word#
bitReverse8# (Word8# -> Word#
word8ToWord# Word8#
w#)))

-- | Reverse the order of the bits in a 'Word16'.
--
-- @since base-4.14.0.0
bitReverse16 :: Word16 -> Word16
bitReverse16 :: Word16 -> Word16
bitReverse16 (W16# Word16#
w#) = Word16# -> Word16
W16# (Word# -> Word16#
wordToWord16# (Word# -> Word#
bitReverse16# (Word16# -> Word#
word16ToWord# Word16#
w#)))

-- | Reverse the order of the bits in a 'Word32'.
--
-- @since base-4.14.0.0
bitReverse32 :: Word32 -> Word32
bitReverse32 :: Word32 -> Word32
bitReverse32 (W32# Word32#
w#) = Word32# -> Word32
W32# (Word# -> Word32#
wordToWord32# (Word# -> Word#
bitReverse32# (Word32# -> Word#
word32ToWord# Word32#
w#)))

-- | Reverse the order of the bits in a 'Word64'.
--
-- @since base-4.14.0.0
bitReverse64 :: Word64 -> Word64
bitReverse64 :: Word64 -> Word64
bitReverse64 (W64# Word64#
w#) = Word64# -> Word64
W64# (Word64# -> Word64#
bitReverse64# Word64#
w#)

-------------------------------------------------------------------------------

-- unchecked shift primops may be lowered into C shift operations which have
-- unspecified behaviour if the amount of bits to shift is greater or equal to the word
-- size in bits.
-- The following safe shift operations wrap unchecked primops to take this into
-- account: 0 is consistently returned when the shift amount is too big.

shiftRLWord64# :: Word64# -> Int# -> Word64#
Word64#
a shiftRLWord64# :: Word64# -> Int# -> Word64#
`shiftRLWord64#` Int#
b = Word64# -> Int# -> Word64#
uncheckedShiftRL64# Word64#
a Int#
b
                    Word64# -> Word64# -> Word64#
`and64#` Int64# -> Word64#
int64ToWord64# (Int# -> Int64#
intToInt64# (Int# -> Int# -> Int#
shift_mask Int#
64# Int#
b))

shiftLWord64# :: Word64# -> Int# -> Word64#
Word64#
a shiftLWord64# :: Word64# -> Int# -> Word64#
`shiftLWord64#` Int#
b  = Word64# -> Int# -> Word64#
uncheckedShiftL64# Word64#
a Int#
b
                    Word64# -> Word64# -> Word64#
`and64#` Int64# -> Word64#
int64ToWord64# (Int# -> Int64#
intToInt64# (Int# -> Int# -> Int#
shift_mask Int#
64# Int#
b))