remove conflicting import for nhc98

[haskell-directory.git] / GHC / Word.hs

diff --git a/GHC/Word.hs b/GHC/Word.hs
index 1850161..694a9df 100644 (file)
--- a/GHC/Word.hs
+++ b/GHC/Word.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -fno-implicit-prelude #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  GHC.Word
@@ -16,13 +16,15 @@
 
 #include "MachDeps.h"
 
+-- #hide
 module GHC.Word (
     Word(..), Word8(..), Word16(..), Word32(..), Word64(..),
-    divZeroError, toEnumError, fromEnumError, succError, predError)
+    toEnumError, fromEnumError, succError, predError)
     where
 
 import Data.Bits
 
+import {-# SOURCE #-} GHC.Err
 import GHC.Base
 import GHC.Enum
 import GHC.Num
@@ -35,11 +37,6 @@ import GHC.Show
 -- Helper functions
 ------------------------------------------------------------------------
 
-{-# NOINLINE divZeroError #-}
-divZeroError :: (Show a) => String -> a -> b
-divZeroError meth x =
-    error $ "Integral." ++ meth ++ ": divide by 0 (" ++ show x ++ " / 0)"
-
 {-# NOINLINE toEnumError #-}
 toEnumError :: (Show a) => String -> Int -> (a,a) -> b
 toEnumError inst_ty i bnds =
@@ -70,13 +67,9 @@ predError inst_ty =
 -- type Word
 ------------------------------------------------------------------------
 
--- A Word is an unsigned integral type, with the same size as Int.
-
+-- |A 'Word' is an unsigned integral type, with the same size as 'Int'.
 data Word = W# Word# deriving (Eq, Ord)
 
-instance CCallable Word
-instance CReturnable Word
-
 instance Show Word where
     showsPrec p x = showsPrec p (toInteger x)
 
@@ -116,22 +109,22 @@ instance Enum Word where
 instance Integral Word where
     quot    x@(W# x#) y@(W# y#)
         | y /= 0                = W# (x# `quotWord#` y#)
-        | otherwise             = divZeroError "quot{Word}" x
+        | otherwise             = divZeroError
     rem     x@(W# x#) y@(W# y#)
         | y /= 0                = W# (x# `remWord#` y#)
-        | otherwise             = divZeroError "rem{Word}" x
+        | otherwise             = divZeroError
     div     x@(W# x#) y@(W# y#)
         | y /= 0                = W# (x# `quotWord#` y#)
-        | otherwise             = divZeroError "div{Word}" x
+        | otherwise             = divZeroError
     mod     x@(W# x#) y@(W# y#)
         | y /= 0                = W# (x# `remWord#` y#)
-        | otherwise             = divZeroError "mod{Word}" x
+        | otherwise             = divZeroError
     quotRem x@(W# x#) y@(W# y#)
         | y /= 0                = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
-        | otherwise             = divZeroError "quotRem{Word}" x
+        | otherwise             = divZeroError
     divMod  x@(W# x#) y@(W# y#)
         | y /= 0                = (W# (x# `quotWord#` y#), W# (x# `remWord#` y#))
-        | otherwise             = divZeroError "divMod{Word}" x
+        | otherwise             = divZeroError
     toInteger (W# x#)
         | i# >=# 0#             = S# i#
         | otherwise             = case word2Integer# x# of (# s, d #) -> J# s d
@@ -140,24 +133,28 @@ instance Integral Word where
 
 instance Bounded Word where
     minBound = 0
+
+    -- use unboxed literals for maxBound, because GHC doesn't optimise
+    -- (fromInteger 0xffffffff :: Word).
 #if WORD_SIZE_IN_BITS == 31
-    maxBound = 0x7FFFFFFF
+    maxBound = W# (int2Word# 0x7FFFFFFF#)
 #elif WORD_SIZE_IN_BITS == 32
-    maxBound = 0xFFFFFFFF
+    maxBound = W# (int2Word# 0xFFFFFFFF#)
 #else
-    maxBound = 0xFFFFFFFFFFFFFFFF
+    maxBound = W# (int2Word# 0xFFFFFFFFFFFFFFFF#)
 #endif
 
 instance Ix Word where
     range (m,n)              = [m..n]
     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
     inRange (m,n) i          = m <= i && i <= n
-    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 
 instance Read Word where
     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
 
 instance Bits Word where
+    {-# INLINE shift #-}
+
     (W# x#) .&.   (W# y#)    = W# (x# `and#` y#)
     (W# x#) .|.   (W# y#)    = W# (x# `or#`  y#)
     (W# x#) `xor` (W# y#)    = W# (x# `xor#` y#)
@@ -167,7 +164,7 @@ instance Bits Word where
         | otherwise          = W# (x# `shiftRL#` negateInt# i#)
     (W# x#) `rotate` (I# i#)
         | i'# ==# 0# = W# x#
-        | otherwise  = W# ((x# `shiftL#` i'#) `or#` (x# `shiftRL#` (wsib -# i'#)))
+        | otherwise  = W# ((x# `uncheckedShiftL#` i'#) `or#` (x# `uncheckedShiftRL#` (wsib -# i'#)))
         where
         i'# = word2Int# (int2Word# i# `and#` int2Word# (wsib -# 1#))
        wsib = WORD_SIZE_IN_BITS#  {- work around preprocessor problem (??) -}
@@ -188,9 +185,7 @@ instance Bits Word where
 -- and must ensure that it holds only values from its logical range.
 
 data Word8 = W8# Word# deriving (Eq, Ord)
-
-instance CCallable Word8
-instance CReturnable Word8
+-- ^ 8-bit unsigned integer type
 
 instance Show Word8 where
     showsPrec p x = showsPrec p (fromIntegral x :: Int)
@@ -227,22 +222,22 @@ instance Enum Word8 where
 instance Integral Word8 where
     quot    x@(W8# x#) y@(W8# y#)
         | y /= 0                  = W8# (x# `quotWord#` y#)
-        | otherwise               = divZeroError "quot{Word8}" x
+        | otherwise               = divZeroError
     rem     x@(W8# x#) y@(W8# y#)
         | y /= 0                  = W8# (x# `remWord#` y#)
-        | otherwise               = divZeroError "rem{Word8}" x
+        | otherwise               = divZeroError
     div     x@(W8# x#) y@(W8# y#)
         | y /= 0                  = W8# (x# `quotWord#` y#)
-        | otherwise               = divZeroError "div{Word8}" x
+        | otherwise               = divZeroError
     mod     x@(W8# x#) y@(W8# y#)
         | y /= 0                  = W8# (x# `remWord#` y#)
-        | otherwise               = divZeroError "mod{Word8}" x
+        | otherwise               = divZeroError
     quotRem x@(W8# x#) y@(W8# y#)
         | y /= 0                  = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
-        | otherwise               = divZeroError "quotRem{Word8}" x
+        | otherwise               = divZeroError
     divMod  x@(W8# x#) y@(W8# y#)
         | y /= 0                  = (W8# (x# `quotWord#` y#), W8# (x# `remWord#` y#))
-        | otherwise               = divZeroError "quotRem{Word8}" x
+        | otherwise               = divZeroError
     toInteger (W8# x#)            = S# (word2Int# x#)
 
 instance Bounded Word8 where
@@ -253,12 +248,13 @@ instance Ix Word8 where
     range (m,n)              = [m..n]
     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
     inRange (m,n) i          = m <= i && i <= n
-    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 
 instance Read Word8 where
     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 
 instance Bits Word8 where
+    {-# INLINE shift #-}
+
     (W8# x#) .&.   (W8# y#)   = W8# (x# `and#` y#)
     (W8# x#) .|.   (W8# y#)   = W8# (x# `or#`  y#)
     (W8# x#) `xor` (W8# y#)   = W8# (x# `xor#` y#)
@@ -268,8 +264,8 @@ instance Bits Word8 where
         | otherwise           = W8# (x# `shiftRL#` negateInt# i#)
     (W8# x#) `rotate` (I# i#)
         | i'# ==# 0# = W8# x#
-        | otherwise  = W8# (narrow8Word# ((x# `shiftL#` i'#) `or#`
-                                          (x# `shiftRL#` (8# -# i'#))))
+        | otherwise  = W8# (narrow8Word# ((x# `uncheckedShiftL#` i'#) `or#`
+                                          (x# `uncheckedShiftRL#` (8# -# i'#))))
         where
         i'# = word2Int# (int2Word# i# `and#` int2Word# 7#)
     bitSize  _                = 8
@@ -290,9 +286,7 @@ instance Bits Word8 where
 -- and must ensure that it holds only values from its logical range.
 
 data Word16 = W16# Word# deriving (Eq, Ord)
-
-instance CCallable Word16
-instance CReturnable Word16
+-- ^ 16-bit unsigned integer type
 
 instance Show Word16 where
     showsPrec p x = showsPrec p (fromIntegral x :: Int)
@@ -329,22 +323,22 @@ instance Enum Word16 where
 instance Integral Word16 where
     quot    x@(W16# x#) y@(W16# y#)
         | y /= 0                    = W16# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "quot{Word16}" x
+        | otherwise                 = divZeroError
     rem     x@(W16# x#) y@(W16# y#)
         | y /= 0                    = W16# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "rem{Word16}" x
+        | otherwise                 = divZeroError
     div     x@(W16# x#) y@(W16# y#)
         | y /= 0                    = W16# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "div{Word16}" x
+        | otherwise                 = divZeroError
     mod     x@(W16# x#) y@(W16# y#)
         | y /= 0                    = W16# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "mod{Word16}" x
+        | otherwise                 = divZeroError
     quotRem x@(W16# x#) y@(W16# y#)
         | y /= 0                    = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word16}" x
+        | otherwise                 = divZeroError
     divMod  x@(W16# x#) y@(W16# y#)
         | y /= 0                    = (W16# (x# `quotWord#` y#), W16# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word16}" x
+        | otherwise                 = divZeroError
     toInteger (W16# x#)             = S# (word2Int# x#)
 
 instance Bounded Word16 where
@@ -355,12 +349,13 @@ instance Ix Word16 where
     range (m,n)              = [m..n]
     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
     inRange (m,n) i          = m <= i && i <= n
-    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 
 instance Read Word16 where
     readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
 
 instance Bits Word16 where
+    {-# INLINE shift #-}
+
     (W16# x#) .&.   (W16# y#)  = W16# (x# `and#` y#)
     (W16# x#) .|.   (W16# y#)  = W16# (x# `or#`  y#)
     (W16# x#) `xor` (W16# y#)  = W16# (x# `xor#` y#)
@@ -370,8 +365,8 @@ instance Bits Word16 where
         | otherwise            = W16# (x# `shiftRL#` negateInt# i#)
     (W16# x#) `rotate` (I# i#)
         | i'# ==# 0# = W16# x#
-        | otherwise  = W16# (narrow16Word# ((x# `shiftL#` i'#) `or#`
-                                            (x# `shiftRL#` (16# -# i'#))))
+        | otherwise  = W16# (narrow16Word# ((x# `uncheckedShiftL#` i'#) `or#`
+                                            (x# `uncheckedShiftRL#` (16# -# i'#))))
         where
         i'# = word2Int# (int2Word# i# `and#` int2Word# 15#)
     bitSize  _                = 16
@@ -392,6 +387,7 @@ instance Bits Word16 where
 #if WORD_SIZE_IN_BITS < 32
 
 data Word32 = W32# Word32#
+-- ^ 32-bit unsigned integer type
 
 instance Eq Word32 where
     (W32# x#) == (W32# y#) = x# `eqWord32#` y#
@@ -436,27 +432,29 @@ instance Enum Word32 where
 instance Integral Word32 where
     quot    x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `quotWord32#` y#)
-        | otherwise                 = divZeroError "quot{Word32}" x
+        | otherwise                 = divZeroError
     rem     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `remWord32#` y#)
-        | otherwise                 = divZeroError "rem{Word32}" x
+        | otherwise                 = divZeroError
     div     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `quotWord32#` y#)
-        | otherwise                 = divZeroError "div{Word32}" x
+        | otherwise                 = divZeroError
     mod     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `remWord32#` y#)
-        | otherwise                 = divZeroError "mod{Word32}" x
+        | otherwise                 = divZeroError
     quotRem x@(W32# x#) y@(W32# y#)
         | y /= 0                    = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
-        | otherwise                 = divZeroError "quotRem{Word32}" x
+        | otherwise                 = divZeroError
     divMod  x@(W32# x#) y@(W32# y#)
         | y /= 0                    = (W32# (x# `quotWord32#` y#), W32# (x# `remWord32#` y#))
-        | otherwise                 = divZeroError "quotRem{Word32}" x
+        | otherwise                 = divZeroError
     toInteger x@(W32# x#)
         | x <= fromIntegral (maxBound::Int)  = S# (word2Int# (word32ToWord# x#))
         | otherwise                 = case word32ToInteger# x# of (# s, d #) -> J# s d
 
 instance Bits Word32 where
+    {-# INLINE shift #-}
+
     (W32# x#) .&.   (W32# y#)  = W32# (x# `and32#` y#)
     (W32# x#) .|.   (W32# y#)  = W32# (x# `or32#`  y#)
     (W32# x#) `xor` (W32# y#)  = W32# (x# `xor32#` y#)
@@ -514,6 +512,7 @@ foreign import unsafe "stg_shiftRL32"     shiftRL32#     :: Word32# -> Int# -> W
 #endif
 
 data Word32 = W32# Word# deriving (Eq, Ord)
+-- ^ 32-bit unsigned integer type
 
 instance Num Word32 where
     (W32# x#) + (W32# y#)  = W32# (narrow32Word# (x# `plusWord#` y#))
@@ -558,22 +557,22 @@ instance Enum Word32 where
 instance Integral Word32 where
     quot    x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "quot{Word32}" x
+        | otherwise                 = divZeroError
     rem     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "rem{Word32}" x
+        | otherwise                 = divZeroError
     div     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "div{Word32}" x
+        | otherwise                 = divZeroError
     mod     x@(W32# x#) y@(W32# y#)
         | y /= 0                    = W32# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "mod{Word32}" x
+        | otherwise                 = divZeroError
     quotRem x@(W32# x#) y@(W32# y#)
         | y /= 0                    = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word32}" x
+        | otherwise                 = divZeroError
     divMod  x@(W32# x#) y@(W32# y#)
         | y /= 0                    = (W32# (x# `quotWord#` y#), W32# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word32}" x
+        | otherwise                 = divZeroError
     toInteger (W32# x#)
 #if WORD_SIZE_IN_BITS == 32
         | i# >=# 0#                 = S# i#
@@ -585,6 +584,8 @@ instance Integral Word32 where
 #endif
 
 instance Bits Word32 where
+    {-# INLINE shift #-}
+
     (W32# x#) .&.   (W32# y#)  = W32# (x# `and#` y#)
     (W32# x#) .|.   (W32# y#)  = W32# (x# `or#`  y#)
     (W32# x#) `xor` (W32# y#)  = W32# (x# `xor#` y#)
@@ -594,8 +595,8 @@ instance Bits Word32 where
         | otherwise            = W32# (x# `shiftRL#` negateInt# i#)
     (W32# x#) `rotate` (I# i#)
         | i'# ==# 0# = W32# x#
-        | otherwise  = W32# (narrow32Word# ((x# `shiftL#` i'#) `or#`
-                                            (x# `shiftRL#` (32# -# i'#))))
+        | otherwise  = W32# (narrow32Word# ((x# `uncheckedShiftL#` i'#) `or#`
+                                            (x# `uncheckedShiftRL#` (32# -# i'#))))
         where
         i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
     bitSize  _                = 32
@@ -612,9 +613,6 @@ instance Bits Word32 where
 
 #endif
 
-instance CCallable Word32
-instance CReturnable Word32
-
 instance Show Word32 where
 #if WORD_SIZE_IN_BITS < 33
     showsPrec p x = showsPrec p (toInteger x)
@@ -634,7 +632,6 @@ instance Ix Word32 where
     range (m,n)              = [m..n]
     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
     inRange (m,n) i          = m <= i && i <= n
-    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 
 instance Read Word32 where  
 #if WORD_SIZE_IN_BITS < 33
@@ -650,6 +647,7 @@ instance Read Word32 where
 #if WORD_SIZE_IN_BITS < 64
 
 data Word64 = W64# Word64#
+-- ^ 64-bit unsigned integer type
 
 instance Eq Word64 where
     (W64# x#) == (W64# y#) = x# `eqWord64#` y#
@@ -694,27 +692,29 @@ instance Enum Word64 where
 instance Integral Word64 where
     quot    x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `quotWord64#` y#)
-        | otherwise                 = divZeroError "quot{Word64}" x
+        | otherwise                 = divZeroError
     rem     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `remWord64#` y#)
-        | otherwise                 = divZeroError "rem{Word64}" x
+        | otherwise                 = divZeroError
     div     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `quotWord64#` y#)
-        | otherwise                 = divZeroError "div{Word64}" x
+        | otherwise                 = divZeroError
     mod     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `remWord64#` y#)
-        | otherwise                 = divZeroError "mod{Word64}" x
+        | otherwise                 = divZeroError
     quotRem x@(W64# x#) y@(W64# y#)
         | y /= 0                    = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
-        | otherwise                 = divZeroError "quotRem{Word64}" x
+        | otherwise                 = divZeroError
     divMod  x@(W64# x#) y@(W64# y#)
         | y /= 0                    = (W64# (x# `quotWord64#` y#), W64# (x# `remWord64#` y#))
-        | otherwise                 = divZeroError "quotRem{Word64}" x
+        | otherwise                 = divZeroError
     toInteger x@(W64# x#)
         | x <= 0x7FFFFFFF           = S# (word2Int# (word64ToWord# x#))
         | otherwise                 = case word64ToInteger# x# of (# s, d #) -> J# s d
 
 instance Bits Word64 where
+    {-# INLINE shift #-}
+
     (W64# x#) .&.   (W64# y#)  = W64# (x# `and64#` y#)
     (W64# x#) .|.   (W64# y#)  = W64# (x# `or64#`  y#)
     (W64# x#) `xor` (W64# y#)  = W64# (x# `xor64#` y#)
@@ -787,6 +787,7 @@ foreign import ccall unsafe "stg_integerToWord64" integerToWord64# :: Int# -> By
 -- from its logical range.
 
 data Word64 = W64# Word# deriving (Eq, Ord)
+-- ^ 64-bit unsigned integer type
 
 instance Num Word64 where
     (W64# x#) + (W64# y#)  = W64# (x# `plusWord#` y#)
@@ -821,22 +822,22 @@ instance Enum Word64 where
 instance Integral Word64 where
     quot    x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "quot{Word64}" x
+        | otherwise                 = divZeroError
     rem     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "rem{Word64}" x
+        | otherwise                 = divZeroError
     div     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `quotWord#` y#)
-        | otherwise                 = divZeroError "div{Word64}" x
+        | otherwise                 = divZeroError
     mod     x@(W64# x#) y@(W64# y#)
         | y /= 0                    = W64# (x# `remWord#` y#)
-        | otherwise                 = divZeroError "mod{Word64}" x
+        | otherwise                 = divZeroError
     quotRem x@(W64# x#) y@(W64# y#)
         | y /= 0                    = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word64}" x
+        | otherwise                 = divZeroError
     divMod  x@(W64# x#) y@(W64# y#)
         | y /= 0                    = (W64# (x# `quotWord#` y#), W64# (x# `remWord#` y#))
-        | otherwise                 = divZeroError "quotRem{Word64}" x
+        | otherwise                 = divZeroError
     toInteger (W64# x#)
         | i# >=# 0#                 = S# i#
         | otherwise                 = case word2Integer# x# of (# s, d #) -> J# s d
@@ -844,6 +845,8 @@ instance Integral Word64 where
         i# = word2Int# x#
 
 instance Bits Word64 where
+    {-# INLINE shift #-}
+
     (W64# x#) .&.   (W64# y#)  = W64# (x# `and#` y#)
     (W64# x#) .|.   (W64# y#)  = W64# (x# `or#`  y#)
     (W64# x#) `xor` (W64# y#)  = W64# (x# `xor#` y#)
@@ -853,8 +856,8 @@ instance Bits Word64 where
         | otherwise            = W64# (x# `shiftRL#` negateInt# i#)
     (W64# x#) `rotate` (I# i#)
         | i'# ==# 0# = W64# x#
-        | otherwise  = W64# ((x# `shiftL#` i'#) `or#`
-                             (x# `shiftRL#` (64# -# i'#)))
+        | otherwise  = W64# ((x# `uncheckedShiftL#` i'#) `or#`
+                             (x# `uncheckedShiftRL#` (64# -# i'#)))
         where
         i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
     bitSize  _                = 64
@@ -867,9 +870,6 @@ instance Bits Word64 where
 
 #endif
 
-instance CCallable Word64
-instance CReturnable Word64
-
 instance Show Word64 where
     showsPrec p x = showsPrec p (toInteger x)
 
@@ -884,7 +884,6 @@ instance Ix Word64 where
     range (m,n)              = [m..n]
     unsafeIndex b@(m,_) i    = fromIntegral (i - m)
     inRange (m,n) i          = m <= i && i <= n
-    unsafeRangeSize b@(_l,h) = unsafeIndex b h + 1
 
 instance Read Word64 where
     readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]