    {-# LANGUAGE CPP #-}
    {-# LANGUAGE NoImplicitPrelude #-}
    {-# LANGUAGE MagicHash #-}
    {-# LANGUAGE UnboxedTuples #-}
    {-# LANGUAGE BlockArguments #-}
    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE MultiWayIf #-}
    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE PolyKinds #-}
    {-# LANGUAGE KindSignatures #-}
    {-# OPTIONS_GHC -Wno-name-shadowing #-}

    module GHC.Num.WordArray where

    import GHC.Prim
    import GHC.Magic
    import GHC.Types
    import GHC.Num.Primitives

    #include "MachDeps.h"
    #include "WordSize.h"

    default ()

    -- | Unlifted array of Word
    type WordArray#        = ByteArray#
    type MutableWordArray# = MutableByteArray#

    data WordArray          = WordArray WordArray#
    data MutableWordArray s = MutableWordArray (MutableWordArray# s)

    -- | Convert limb count into byte count
    wordsToBytes# :: Int# -> Int#
    wordsToBytes# :: Int# -> Int#
    wordsToBytes# Int#
    i = Int#
    i Int# -> Int# -> Int#
    `uncheckedIShiftL#` WORD_SIZE_BYTES_SHIFT#

    -- | Convert byte count into limb count
    bytesToWords# :: Int# -> Int#
    bytesToWords# :: Int# -> Int#
    bytesToWords# Int#
    i = Int#
    i Int# -> Int# -> Int#
    `uncheckedIShiftRL#` WORD_SIZE_BYTES_SHIFT#

    -- | Create a new WordArray# of the given size (*in Word#*) and apply the
    -- action to it before returning it frozen
    withNewWordArray#
       :: Int#  -- ^ Size in Word
       -> (MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld)
       -> WordArray#
    withNewWordArray# :: Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> State# RealWorld)
    -> WordArray#
    withNewWordArray# Int#
    sz MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    act = case (State# RealWorld -> (# State# RealWorld, WordArray# #))
    -> (# State# RealWorld, WordArray# #)
    forall o. (State# RealWorld -> o) -> o
    runRW# State# RealWorld -> (# State# RealWorld, WordArray# #)
    io of (# State# RealWorld
    _, WordArray#
    a #) -> WordArray#
    a
       where
          io :: State# RealWorld -> (# State# RealWorld, WordArray# #)
    io State# RealWorld
    s =
             case Int#
    -> State# RealWorld
    -> (# State# RealWorld, MutableWordArray# RealWorld #)
    forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# Int#
    sz State# RealWorld
    s of { (# State# RealWorld
    s, MutableWordArray# RealWorld
    mwa #) ->
             case MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    act MutableWordArray# RealWorld
    mwa State# RealWorld
    s          of { State# RealWorld
    s ->
             MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, WordArray# #)
    forall d.
    MutableByteArray# d -> State# d -> (# State# d, WordArray# #)
    unsafeFreezeByteArray# MutableWordArray# RealWorld
    mwa State# RealWorld
    s
             }}

    -- | Create two new WordArray# of the given sizes (*in Word#*) and apply the
    -- action to them before returning them frozen
    withNewWordArray2#
       :: Int# -- ^ Size in Word
       -> Int# -- ^ Ditto
       -> (MutableWordArray# RealWorld
          -> MutableWordArray# RealWorld
          -> State# RealWorld
          -> State# RealWorld)
       -> (# WordArray#, WordArray# #)
    withNewWordArray2# :: Int#
    -> Int#
    -> (MutableWordArray# RealWorld
        -> MutableWordArray# RealWorld
        -> State# RealWorld
        -> State# RealWorld)
    -> (# WordArray#, WordArray# #)
    withNewWordArray2# Int#
    sz1 Int#
    sz2 MutableWordArray# RealWorld
    -> MutableWordArray# RealWorld
    -> State# RealWorld
    -> State# RealWorld
    act = case (State# RealWorld
     -> (# State# RealWorld, (# WordArray#, WordArray# #) #))
    -> (# State# RealWorld, (# WordArray#, WordArray# #) #)
    forall o. (State# RealWorld -> o) -> o
    runRW# State# RealWorld
    -> (# State# RealWorld, (# WordArray#, WordArray# #) #)
    io of (# State# RealWorld
    _, (# WordArray#, WordArray# #)
    a #) -> (# WordArray#, WordArray# #)
    a
       where
          io :: State# RealWorld
    -> (# State# RealWorld, (# WordArray#, WordArray# #) #)
    io State# RealWorld
    s =
             case Int#
    -> State# RealWorld
    -> (# State# RealWorld, MutableWordArray# RealWorld #)
    forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# Int#
    sz1 State# RealWorld
    s of { (# State# RealWorld
    s, MutableWordArray# RealWorld
    mwa1 #) ->
             case Int#
    -> State# RealWorld
    -> (# State# RealWorld, MutableWordArray# RealWorld #)
    forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# Int#
    sz2 State# RealWorld
    s of { (# State# RealWorld
    s, MutableWordArray# RealWorld
    mwa2 #) ->
             case MutableWordArray# RealWorld
    -> MutableWordArray# RealWorld
    -> State# RealWorld
    -> State# RealWorld
    act MutableWordArray# RealWorld
    mwa1 MutableWordArray# RealWorld
    mwa2 State# RealWorld
    s     of { State# RealWorld
    s ->
             case MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, WordArray# #)
    forall d.
    MutableByteArray# d -> State# d -> (# State# d, WordArray# #)
    unsafeFreezeByteArray# MutableWordArray# RealWorld
    mwa1 State# RealWorld
    s of { (# State# RealWorld
    s, WordArray#
    wa1 #) ->
             case MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, WordArray# #)
    forall d.
    MutableByteArray# d -> State# d -> (# State# d, WordArray# #)
    unsafeFreezeByteArray# MutableWordArray# RealWorld
    mwa2 State# RealWorld
    s of { (# State# RealWorld
    s, WordArray#
    wa2 #) ->
                (# State# RealWorld
    s, (# WordArray#
    wa1, WordArray#
    wa2 #) #)
             }}}}}

    -- | Create a new WordArray#
    newWordArray# :: Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# :: forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# Int#
    sz State# s
    s = Int# -> State# s -> (# State# s, MutableByteArray# s #)
    forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newByteArray# (Int# -> Int#
    wordsToBytes# Int#
    sz) State# s
    s

    -- | Create a new WordArray# of the given size (*in Word#*), apply the action to
    -- it, trim its most significant zeroes, then return it frozen
    withNewWordArrayTrimed#
       :: Int#  -- ^ Size in Word
       -> (MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld)
       -> WordArray#
    withNewWordArrayTrimed# :: Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> State# RealWorld)
    -> WordArray#
    withNewWordArrayTrimed# Int#
    sz MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    act = Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> State# RealWorld)
    -> WordArray#
    withNewWordArray# Int#
    sz \MutableWordArray# RealWorld
    mwa State# RealWorld
    s ->
       case MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    act MutableWordArray# RealWorld
    mwa State# RealWorld
    s of
          State# RealWorld
    s' -> MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableWordArray# RealWorld
    mwa State# RealWorld
    s'

    -- | Create two new WordArray# of the given sizes (*in Word#*), apply the action
    -- to them, trim their most significant zeroes, then return them frozen
    withNewWordArray2Trimed#
       :: Int#  -- ^ Size in Word
       -> Int#  -- ^ Ditto
       -> (MutableWordArray# RealWorld
          -> MutableWordArray# RealWorld
          -> State# RealWorld
          -> State# RealWorld)
       -> (# WordArray#, WordArray# #)
    withNewWordArray2Trimed# :: Int#
    -> Int#
    -> (MutableWordArray# RealWorld
        -> MutableWordArray# RealWorld
        -> State# RealWorld
        -> State# RealWorld)
    -> (# WordArray#, WordArray# #)
    withNewWordArray2Trimed# Int#
    sz1 Int#
    sz2 MutableWordArray# RealWorld
    -> MutableWordArray# RealWorld
    -> State# RealWorld
    -> State# RealWorld
    act = Int#
    -> Int#
    -> (MutableWordArray# RealWorld
        -> MutableWordArray# RealWorld
        -> State# RealWorld
        -> State# RealWorld)
    -> (# WordArray#, WordArray# #)
    withNewWordArray2# Int#
    sz1 Int#
    sz2 \MutableWordArray# RealWorld
    mwa1 MutableWordArray# RealWorld
    mwa2 State# RealWorld
    s ->
       case MutableWordArray# RealWorld
    -> MutableWordArray# RealWorld
    -> State# RealWorld
    -> State# RealWorld
    act MutableWordArray# RealWorld
    mwa1 MutableWordArray# RealWorld
    mwa2 State# RealWorld
    s of
          State# RealWorld
    s' -> case MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableWordArray# RealWorld
    mwa1 State# RealWorld
    s' of
             State# RealWorld
    s'' -> MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableWordArray# RealWorld
    mwa2 State# RealWorld
    s''

    -- | Create a new WordArray# of the given size (*in Word#*), apply the action to
    -- it. If the action returns true#, trim its most significant zeroes, then
    -- return it frozen. Otherwise, return ().
    withNewWordArrayTrimedMaybe#
       :: Int#  -- ^ Size in Word
       -> (MutableWordArray# RealWorld -> State# RealWorld -> (# State# RealWorld, Bool# #))
       -> (# (# #) | WordArray# #)
    withNewWordArrayTrimedMaybe# :: Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> (# State# RealWorld, Int# #))
    -> (# (# #) | WordArray# #)
    withNewWordArrayTrimedMaybe# Int#
    sz MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, Int# #)
    act = case (State# RealWorld
     -> (# State# RealWorld, (# (# #) | WordArray# #) #))
    -> (# State# RealWorld, (# (# #) | WordArray# #) #)
    forall o. (State# RealWorld -> o) -> o
    runRW# State# RealWorld
    -> (# State# RealWorld, (# (# #) | WordArray# #) #)
    io of (# State# RealWorld
    _, (# (# #) | WordArray# #)
    a #) -> (# (# #) | WordArray# #)
    a
       where
          io :: State# RealWorld
    -> (# State# RealWorld, (# (# #) | WordArray# #) #)
    io State# RealWorld
    s =
             case Int#
    -> State# RealWorld
    -> (# State# RealWorld, MutableWordArray# RealWorld #)
    forall s. Int# -> State# s -> (# State# s, MutableWordArray# s #)
    newWordArray# Int#
    sz State# RealWorld
    s of
                (# State# RealWorld
    s, MutableWordArray# RealWorld
    mwa #) -> case MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, Int# #)
    act MutableWordArray# RealWorld
    mwa State# RealWorld
    s of
                   (# State# RealWorld
    s, Int#
    0# #) -> (# State# RealWorld
    s, (# (# #) | #) #)
                   (# State# RealWorld
    s, Int#
    _  #) -> case MutableWordArray# RealWorld -> State# RealWorld -> State# RealWorld
    forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableWordArray# RealWorld
    mwa State# RealWorld
    s of
                      State# RealWorld
    s -> case MutableWordArray# RealWorld
    -> State# RealWorld -> (# State# RealWorld, WordArray# #)
    forall d.
    MutableByteArray# d -> State# d -> (# State# d, WordArray# #)
    unsafeFreezeByteArray# MutableWordArray# RealWorld
    mwa State# RealWorld
    s of
                         (# State# RealWorld
    s, WordArray#
    ba #) -> (# State# RealWorld
    s, (# | WordArray#
    ba #) #)

    -- | Create a WordArray# from two Word#
    --
    -- `wordArrayFromWord2# h l
    --    where h is the most significant word
    --          l is the least significant word
    wordArrayFromWord2# :: Word# -> Word# -> WordArray#
    wordArrayFromWord2# :: Word# -> Word# -> WordArray#
    wordArrayFromWord2# Word#
    h Word#
    l   =
       Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> State# RealWorld)
    -> WordArray#
    withNewWordArray# Int#
    2# \MutableWordArray# RealWorld
    mwa State# RealWorld
    s ->
          case MutableWordArray# RealWorld
    -> Int# -> Word# -> State# RealWorld -> State# RealWorld
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# RealWorld
    mwa Int#
    0# Word#
    l State# RealWorld
    s of
             State# RealWorld
    s -> MutableWordArray# RealWorld
    -> Int# -> Word# -> State# RealWorld -> State# RealWorld
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# RealWorld
    mwa Int#
    1# Word#
    h State# RealWorld
    s

    -- | Create a WordArray# from one Word#
    wordArrayFromWord# :: Word# -> WordArray#
    wordArrayFromWord# :: Word# -> WordArray#
    wordArrayFromWord# Word#
    w   =
       Int#
    -> (MutableWordArray# RealWorld
        -> State# RealWorld -> State# RealWorld)
    -> WordArray#
    withNewWordArray# Int#
    1# \MutableWordArray# RealWorld
    mwa State# RealWorld
    s ->
          MutableWordArray# RealWorld
    -> Int# -> Word# -> State# RealWorld -> State# RealWorld
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# RealWorld
    mwa Int#
    0# Word#
    w State# RealWorld
    s

    -- | Word array size
    wordArraySize# :: WordArray# -> Int#
    wordArraySize# :: WordArray# -> Int#
    wordArraySize# WordArray#
    ba = Int# -> Int#
    bytesToWords# (WordArray# -> Int#
    sizeofByteArray# WordArray#
    ba)

    -- | Equality test for WordArray#

    -- | Get size in Words
    mwaSize# :: MutableWordArray# s-> State# s -> (# State# s, Int# #)
    mwaSize# :: forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# s
    mba State# s
    s = case MutableWordArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    getSizeofMutableByteArray# MutableWordArray# s
    mba State# s
    s of
       (# State# s
    s2, Int#
    sz #) -> (# State# s
    s2, Int# -> Int#
    bytesToWords# Int#
    sz #)

    -- | Get the last Word (must be non empty!)
    wordArrayLast# :: WordArray# -> Word#
    wordArrayLast# :: WordArray# -> Word#
    wordArrayLast# WordArray#
    a = WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    a (WordArray# -> Int#
    wordArraySize# WordArray#
    a Int# -> Int# -> Int#
    -# Int#
    1#)

    -- | Copy Words from a WordArray
    --
    -- Don't do anything if the number of words to copy is <= 0
    mwaArrayCopy# :: MutableByteArray# s -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    mwaArrayCopy# :: forall s.
    MutableByteArray# s
    -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    mwaArrayCopy# MutableByteArray# s
    dst Int#
    dstIdx WordArray#
    src Int#
    srcIdx Int#
    n State# s
    s
       | Int# -> Bool
    isTrue# (Int#
    n Int# -> Int# -> Int#
    <=# Int#
    0#) = State# s
    s
       | Bool
    True = WordArray#
    -> Int#
    -> MutableByteArray# s
    -> Int#
    -> Int#
    -> State# s
    -> State# s
    forall d.
    WordArray#
    -> Int#
    -> MutableByteArray# d
    -> Int#
    -> Int#
    -> State# d
    -> State# d
    copyByteArray#
                   WordArray#
    src (Int# -> Int#
    wordsToBytes# Int#
    srcIdx)
                   MutableByteArray# s
    dst (Int# -> Int#
    wordsToBytes# Int#
    dstIdx)
                   (Int# -> Int#
    wordsToBytes# Int#
    n) State# s
    s

    -- | Shrink last words of a WordArray
    mwaShrink# :: MutableByteArray# s -> Int# -> State# s -> State# s
    mwaShrink# :: forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaShrink# MutableByteArray# s
    _mwa Int#
    0# State# s
    s = State# s
    s
    mwaShrink# MutableByteArray# s
    mwa  Int#
    i  State# s
    s =
       case MutableByteArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableByteArray# s
    mwa State# s
    s of
          (# State# s
    s, Int#
    n #) -> MutableByteArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    shrinkMutableByteArray# MutableByteArray# s
    mwa (Int# -> Int#
    wordsToBytes# (Int#
    n Int# -> Int# -> Int#
    -# Int#
    i)) State# s
    s

    -- | Set size
    mwaSetSize# :: MutableByteArray# s -> Int# -> State# s -> State# s
    mwaSetSize# :: forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaSetSize# MutableByteArray# s
    mwa Int#
    n State# s
    s = MutableByteArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    shrinkMutableByteArray# MutableByteArray# s
    mwa (Int# -> Int#
    wordsToBytes# Int#
    n) State# s
    s

    -- | Copy the WordArray into the MWA and shrink the size of MWA to the one of
    -- the WordArray
    mwaInitCopyShrink# :: MutableByteArray# s -> WordArray# -> State# s -> State# s
    mwaInitCopyShrink# :: forall s. MutableByteArray# s -> WordArray# -> State# s -> State# s
    mwaInitCopyShrink# MutableByteArray# s
    mwa WordArray#
    wa State# s
    s =
       case MutableByteArray# s
    -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    forall s.
    MutableByteArray# s
    -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    mwaArrayCopy# MutableByteArray# s
    mwa Int#
    0# WordArray#
    wa Int#
    0# (WordArray# -> Int#
    wordArraySize# WordArray#
    wa) State# s
    s of
          State# s
    s -> MutableByteArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaSetSize# MutableByteArray# s
    mwa (WordArray# -> Int#
    wordArraySize# WordArray#
    wa) State# s
    s

    -- | Trim ending zeroes
    mwaTrimZeroes# :: MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# :: forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableByteArray# s
    mwa State# s
    s1 =
       case MutableByteArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaClz MutableByteArray# s
    mwa State# s
    s1 of
          (# State# s
    s2, Int#
    0# #) -> State# s
    s2
          (# State# s
    s2, Int#
    c  #) -> MutableByteArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaShrink# MutableByteArray# s
    mwa Int#
    c State# s
    s2

    -- | Count leading zero Words
    mwaClz :: MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaClz :: forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaClz MutableWordArray# s
    mwa State# s
    s1 = case MutableWordArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# s
    mwa State# s
    s1 of
       (# State# s
    s2,Int#
    sz #)  -> MutableWordArray# s -> Int# -> State# s -> (# State# s, Int# #)
    forall s.
    MutableWordArray# s -> Int# -> State# s -> (# State# s, Int# #)
    mwaClzAt MutableWordArray# s
    mwa (Int#
    sz Int# -> Int# -> Int#
    -# Int#
    1#) State# s
    s2

    -- | Count leading zero Words starting at given position
    mwaClzAt :: MutableWordArray# s -> Int# -> State# s -> (# State# s, Int# #)
    mwaClzAt :: forall s.
    MutableWordArray# s -> Int# -> State# s -> (# State# s, Int# #)
    mwaClzAt MutableWordArray# s
    mwa = Int# -> Int# -> State# s -> (# State# s, Int# #)
    go Int#
    0#
       where
          go :: Int# -> Int# -> State# s -> (# State# s, Int# #)
    go Int#
    c Int#
    i State# s
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#) = (# State# s
    s, Int#
    c #)
             | Bool
    True = case MutableWordArray# s -> Int# -> State# s -> (# State# s, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# s
    mwa Int#
    i State# s
    s of
                (# State# s
    s', Word#
    0## #) -> Int# -> Int# -> State# s -> (# State# s, Int# #)
    go (Int#
    c Int# -> Int# -> Int#
    +# Int#
    1#) (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#) State# s
    s'
                (# State# s
    s', Word#
    _   #) -> (# State# s
    s', Int#
    c #)

    -- | Count leading zero Words starting at given position
    waClzAt :: WordArray# -> Int# -> Int#
    waClzAt :: WordArray# -> Int# -> Int#
    waClzAt WordArray#
    wa = Int# -> Int# -> Int#
    go Int#
    0#
       where
          go :: Int# -> Int# -> Int#
    go Int#
    c Int#
    i
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#)
             = Int#
    c

             | Word#
    0## <- WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wa Int#
    i
             = Int# -> Int# -> Int#
    go (Int#
    c Int# -> Int# -> Int#
    +# Int#
    1#) (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#)

             | Bool
    True
             = Int#
    c

    -- | Compare the most signiciant limbs of a and b. The comparison stops (i.e.
    -- returns EQ) when there isn't enough lims in a or b to perform another
    -- comparison.
    wordArrayCompareMSWords :: WordArray# -> WordArray# -> Ordering
    wordArrayCompareMSWords :: WordArray# -> WordArray# -> Ordering
    wordArrayCompareMSWords WordArray#
    wa WordArray#
    wb
       | Int#
    0# <- Int#
    szA
       , Int#
    0# <- Int#
    szB
       = Ordering
    EQ

       | Int#
    0# <- Int#
    szA
       = Ordering
    LT

       | Int#
    0# <- Int#
    szB
       = Ordering
    GT

       | Bool
    True
       = Int# -> Int# -> Ordering
    go (Int#
    szA Int# -> Int# -> Int#
    -# Int#
    1#) (Int#
    szB Int# -> Int# -> Int#
    -# Int#
    1#)
       where
          szA :: Int#
    szA  = WordArray# -> Int#
    wordArraySize# WordArray#
    wa
          szB :: Int#
    szB  = WordArray# -> Int#
    wordArraySize# WordArray#
    wb

          go :: Int# -> Int# -> Ordering
    go Int#
    i Int#
    j
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#) = Ordering
    EQ
             | Int# -> Bool
    isTrue# (Int#
    j Int# -> Int# -> Int#
    <# Int#
    0#) = Ordering
    EQ
             | Bool
    True =
                let
                   a :: Word#
    a = WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wa Int#
    i
                   b :: Word#
    b = WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wb Int#
    j
                in if | Int# -> Bool
    isTrue# (Word#
    a Word# -> Word# -> Int#
    `gtWord#` Word#
    b) -> Ordering
    GT
                      | Int# -> Bool
    isTrue# (Word#
    b Word# -> Word# -> Int#
    `gtWord#` Word#
    a) -> Ordering
    LT
                      | Bool
    True                    -> Int# -> Int# -> Ordering
    go (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#) (Int#
    j Int# -> Int# -> Int#
    -# Int#
    1#)

    -- | Compute MutableWordArray <- WordArray + Word
    --
    -- The MutableWordArray may not be initialized and will be erased anyway.
    --
    -- Input: Size(MutableWordArray) = Size(WordArray) + 1
    -- Output: Size(MutableWordArray) = Size(WordArray) [+ 1]
    mwaInitArrayPlusWord :: MutableWordArray# s -> WordArray# -> Word# -> State# s -> State#s
    mwaInitArrayPlusWord :: forall s.
    MutableWordArray# s -> WordArray# -> Word# -> State# s -> State# s
    mwaInitArrayPlusWord MutableWordArray# s
    mwa WordArray#
    wa = Int# -> Word# -> State# s -> State# s
    go Int#
    0#
       where
          sz :: Int#
    sz = WordArray# -> Int#
    wordArraySize# WordArray#
    wa
          go :: Int# -> Word# -> State# s -> State# s
    go Int#
    i Word#
    carry State# s
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    ># Int#
    sz)  = State# s
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    ==# Int#
    sz) = MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    mwaWriteOrShrink MutableWordArray# s
    mwa Word#
    carry Int#
    i State# s
    s
             | Word#
    0## <- Word#
    carry       = -- copy higher remaining words and shrink the mwa
                                    case MutableWordArray# s
    -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    forall s.
    MutableByteArray# s
    -> Int# -> WordArray# -> Int# -> Int# -> State# s -> State# s
    mwaArrayCopy# MutableWordArray# s
    mwa Int#
    i WordArray#
    wa Int#
    i (Int#
    sz Int# -> Int# -> Int#
    -# Int#
    i) State# s
    s of
                                        State# s
    s2 -> MutableWordArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaShrink# MutableWordArray# s
    mwa Int#
    1# State# s
    s2
             | Bool
    True               = let !(# Word#
    l,Int#
    c #) = Word# -> Word# -> (# Word#, Int# #)
    addWordC# (WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wa Int#
    i) Word#
    carry
                                    in case MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# s
    mwa Int#
    i Word#
    l State# s
    s of
                                        State# s
    s2 -> Int# -> Word# -> State# s -> State# s
    go (Int#
    i Int# -> Int# -> Int#
    +# Int#
    1#) (Int# -> Word#
    int2Word# Int#
    c) State# s
    s2

    -- | Write the most-significant Word:
    --    * if it is 0: shrink the array of 1 Word
    --    * otherwise: write it
    mwaWriteOrShrink :: MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    mwaWriteOrShrink :: forall s.
    MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    mwaWriteOrShrink MutableWordArray# s
    mwa Word#
    0## Int#
    _i State# s
    s = MutableWordArray# s -> Int# -> State# s -> State# s
    forall s. MutableByteArray# s -> Int# -> State# s -> State# s
    mwaShrink# MutableWordArray# s
    mwa Int#
    1# State# s
    s
    mwaWriteOrShrink MutableWordArray# s
    mwa  Word#
    w   Int#
    i State# s
    s = MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# s
    mwa Int#
    i Word#
    w State# s
    s

    -- | Compute the index of the most-significant Word and write it.
    mwaWriteMostSignificant :: MutableWordArray# s -> Word# -> State# s -> State# s
    mwaWriteMostSignificant :: forall s. MutableWordArray# s -> Word# -> State# s -> State# s
    mwaWriteMostSignificant MutableWordArray# s
    mwa Word#
    w State# s
    s =
       case MutableWordArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# s
    mwa State# s
    s of
          (# State# s
    s', Int#
    sz #) -> MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Word# -> Int# -> State# s -> State# s
    mwaWriteOrShrink MutableWordArray# s
    mwa Word#
    w (Int#
    sz Int# -> Int# -> Int#
    -# Int#
    1#) State# s
    s'

    -- | MutableWordArray <- zipWith op wa1 wa2
    --
    -- Required output: Size(MutableWordArray) = min Size(wa1) Size(wa2)
    mwaInitArrayBinOp :: MutableWordArray# s -> WordArray# -> WordArray# -> (Word# -> Word# -> Word#) -> State# s -> State#s
    mwaInitArrayBinOp :: forall s.
    MutableWordArray# s
    -> WordArray#
    -> WordArray#
    -> (Word# -> Word# -> Word#)
    -> State# s
    -> State# s
    mwaInitArrayBinOp MutableWordArray# s
    mwa WordArray#
    wa WordArray#
    wb Word# -> Word# -> Word#
    op State# s
    s = Int# -> State# s -> State# s
    go Int#
    0# State# s
    s
       where
          !sz :: Int#
    sz = Int# -> Int# -> Int#
    minI# (WordArray# -> Int#
    wordArraySize# WordArray#
    wa) (WordArray# -> Int#
    wordArraySize# WordArray#
    wb)
          go :: Int# -> State# s -> State# s
    go Int#
    i State# s
    s'
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    ==# Int#
    sz) = State# s
    s'
             | Bool
    True =
                case WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wa Int#
    i Word# -> Word# -> Word#
    `op` WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wb Int#
    i of
                   Word#
    v -> case MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# s
    mwa Int#
    i Word#
    v State# s
    s' of
                      State# s
    s'' -> Int# -> State# s -> State# s
    go (Int#
    i Int# -> Int# -> Int#
    +# Int#
    1#) State# s
    s''

    -- | Write an element of the MutableWordArray
    mwaWrite# :: MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# :: forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# = MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    writeWordArray#

    -- | Fill some part of a MutableWordArray with the given Word#
    mwaFill# :: MutableWordArray# s -> Word# -> Word# -> Word# -> State# s -> State# s
    mwaFill# :: forall s.
    MutableWordArray# s
    -> Word# -> Word# -> Word# -> State# s -> State# s
    mwaFill# MutableWordArray# s
    _   Word#
    _ Word#
    _   Word#
    0## State# s
    s = State# s
    s
    mwaFill# MutableWordArray# s
    mwa Word#
    v Word#
    off Word#
    n   State# s
    s = case MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# s
    mwa (Word# -> Int#
    word2Int# Word#
    off) Word#
    v State# s
    s of
       State# s
    s' -> MutableWordArray# s
    -> Word# -> Word# -> Word# -> State# s -> State# s
    forall s.
    MutableWordArray# s
    -> Word# -> Word# -> Word# -> State# s -> State# s
    mwaFill# MutableWordArray# s
    mwa Word#
    v (Word#
    off Word# -> Word# -> Word#
    `plusWord#` Word#
    1##) (Word#
    n Word# -> Word# -> Word#
    `minusWord#` Word#
    1##) State# s
    s'

    -- | Add Word# inplace (a the specified offset) in the mwa with carry propagation.
    mwaAddInplaceWord# :: MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    mwaAddInplaceWord# :: forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaAddInplaceWord#   MutableWordArray# d
    _ Int#
    _ Word#
    0## State# d
    s = State# d
    s
    mwaAddInplaceWord# MutableWordArray# d
    mwa Int#
    i Word#
    y   State# d
    s = case MutableWordArray# d -> Int# -> State# d -> (# State# d, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# d
    mwa Int#
    i State# d
    s of
       (# State# d
    s1, Word#
    x #) -> let !(# Word#
    h,Word#
    l #) = Word# -> Word# -> (# Word#, Word# #)
    plusWord2# Word#
    x Word#
    y
                      in case MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# d
    mwa Int#
    i Word#
    l State# d
    s1 of
                            State# d
    s2 -> MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaAddInplaceWord# MutableWordArray# d
    mwa (Int#
    i Int# -> Int# -> Int#
    +# Int#
    1#) Word#
    h State# d
    s2

    -- | Sub Word# inplace (at the specified offset) in the mwa with carry
    -- propagation.
    --
    -- Return False# on underflow
    mwaSubInplaceWord#
       :: MutableWordArray# d
       -> Int#
       -> Word#
       -> State# d
       -> (# State# d, Bool# #)
    mwaSubInplaceWord# :: forall d.
    MutableWordArray# d
    -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    mwaSubInplaceWord# MutableWordArray# d
    mwa Int#
    ii Word#
    iw State# d
    s1 = case MutableWordArray# d -> State# d -> (# State# d, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# d
    mwa State# d
    s1 of
       (# State# d
    is, Int#
    sz #) ->
          let
             go :: Int# -> Word# -> State# d -> (# State# d, Int# #)
    go Int#
    _ Word#
    0## State# d
    s = (# State# d
    s, Int#
    1# #) -- no underflow
             go Int#
    i Word#
    y   State# d
    s
                | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    >=# Int#
    sz) = (# State# d
    s, Int#
    0# #) -- underflow
                | Bool
    True = case MutableWordArray# d -> Int# -> State# d -> (# State# d, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# d
    mwa Int#
    i State# d
    s of
                   (# State# d
    s1, Word#
    x #) -> let !(# Word#
    l,Int#
    h #) = Word# -> Word# -> (# Word#, Int# #)
    subWordC# Word#
    x Word#
    y
                      in case MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaWrite# MutableWordArray# d
    mwa Int#
    i Word#
    l State# d
    s1 of
                         State# d
    s2 -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    go (Int#
    i Int# -> Int# -> Int#
    +# Int#
    1#) (Int# -> Word#
    int2Word# Int#
    h) State# d
    s2
          in Int# -> Word# -> State# d -> (# State# d, Int# #)
    go Int#
    ii Word#
    iw State# d
    is

    -- | Trim `a` of `k` less significant limbs and then compare the result with `b`
    --
    -- "mwa" doesn't need to be trimmed
    mwaTrimCompare :: Int# -> MutableWordArray# s -> WordArray# -> State# s -> (# State# s, Ordering #)
    mwaTrimCompare :: forall s.
    Int#
    -> MutableWordArray# s
    -> WordArray#
    -> State# s
    -> (# State# s, Ordering #)
    mwaTrimCompare Int#
    k MutableWordArray# s
    mwa WordArray#
    wb State# s
    s1
       | (# State# s
    s, Int#
    szA #) <- MutableWordArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# s
    mwa State# s
    s1
       , Int#
    szB <- WordArray# -> Int#
    wordArraySize# WordArray#
    wb
       =
         let
          go :: Int# -> State# s -> (# State# s, Ordering #)
    go Int#
    i State# s
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#) = (# State# s
    s, Ordering
    EQ #)
             | Bool
    True = case MutableWordArray# s -> Int# -> State# s -> (# State# s, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# s
    mwa (Int#
    i Int# -> Int# -> Int#
    +# Int#
    k) State# s
    s of
                (# State# s
    s2, Word#
    ai #) ->
                   let bi :: Word#
    bi = if Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    >=# Int#
    szB)
                               then Word#
    0##
                               else WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wb Int#
    i
                   in if | Int# -> Bool
    isTrue# (Word#
    ai Word# -> Word# -> Int#
    `gtWord#` Word#
    bi) -> (# State# s
    s2, Ordering
    GT #)
                         | Int# -> Bool
    isTrue# (Word#
    bi Word# -> Word# -> Int#
    `gtWord#` Word#
    ai) -> (# State# s
    s2, Ordering
    LT #)
                         | Bool
    True                      -> Int# -> State# s -> (# State# s, Ordering #)
    go (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#) State# s
    s2

          szTrimA :: Int#
    szTrimA = Int#
    szA Int# -> Int# -> Int#
    -# Int#
    k

         in if | Int# -> Bool
    isTrue# (Int#
    szTrimA Int# -> Int# -> Int#
    <# Int#
    szB) -> (# State# s
    s, Ordering
    LT #)
               | Bool
    True                     -> Int# -> State# s -> (# State# s, Ordering #)
    go (Int#
    szA Int# -> Int# -> Int#
    -# Int#
    k Int# -> Int# -> Int#
    -# Int#
    1#) State# s
    s

    -- | Sub array inplace (at the specified offset) in the mwa with carry propagation.
    --
    -- We don't trim the resulting array!
    --
    -- Return False# on underflow.
    mwaSubInplaceArray :: MutableWordArray# d -> Int# -> WordArray# -> State# d -> (# State# d, Bool# #)
    mwaSubInplaceArray :: forall d.
    MutableWordArray# d
    -> Int# -> WordArray# -> State# d -> (# State# d, Int# #)
    mwaSubInplaceArray MutableWordArray# d
    mwa Int#
    off WordArray#
    wb = Int# -> State# d -> (# State# d, Int# #)
    go (WordArray# -> Int#
    wordArraySize# WordArray#
    wb Int# -> Int# -> Int#
    -# Int#
    1#)
       where
          go :: Int# -> State# d -> (# State# d, Int# #)
    go Int#
    i State# d
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#) = (# State# d
    s, Int#
    1# #) -- no underflow
             | Bool
    True
             = case MutableWordArray# d
    -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    forall d.
    MutableWordArray# d
    -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    mwaSubInplaceWord# MutableWordArray# d
    mwa (Int#
    off Int# -> Int# -> Int#
    +# Int#
    i) (WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wb Int#
    i) State# d
    s of
                (# State# d
    s2, Int#
    1# #) -> Int# -> State# d -> (# State# d, Int# #)
    go (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#) State# d
    s2
                (# State# d
    s2, Int#
    _  #) -> (# State# d
    s2, Int#
    0# #) -- underflow

    -- | Add array inplace (a the specified offset) in the mwa with carry propagation.
    --
    -- Upper bound of the result mutable aray is not checked against overflow.
    mwaAddInplaceArray :: MutableWordArray# d -> Int# -> WordArray# -> State# d -> State# d
    mwaAddInplaceArray :: forall d.
    MutableWordArray# d -> Int# -> WordArray# -> State# d -> State# d
    mwaAddInplaceArray MutableWordArray# d
    mwa Int#
    off WordArray#
    wb = Int# -> Word# -> State# d -> State# d
    go Int#
    0# Word#
    0##
       where
          !maxi :: Int#
    maxi = WordArray# -> Int#
    wordArraySize# WordArray#
    wb
          go :: Int# -> Word# -> State# d -> State# d
    go Int#
    i Word#
    c State# d
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    ==# Int#
    maxi) = MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    mwaAddInplaceWord# MutableWordArray# d
    mwa (Int#
    i Int# -> Int# -> Int#
    +# Int#
    off) Word#
    c State# d
    s
             | Bool
    True
             = case MutableWordArray# d -> Int# -> State# d -> (# State# d, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# d
    mwa (Int#
    i Int# -> Int# -> Int#
    +# Int#
    off) State# d
    s of
                (# State# d
    s, Word#
    v #) -> case Word# -> Word# -> Word# -> (# Word#, Word# #)
    plusWord3# Word#
    v (WordArray# -> Int# -> Word#
    indexWordArray# WordArray#
    wb Int#
    i) Word#
    c of
                   (# Word#
    c', Word#
    v' #) -> case MutableWordArray# d -> Int# -> Word# -> State# d -> State# d
    forall s.
    MutableWordArray# s -> Int# -> Word# -> State# s -> State# s
    writeWordArray# MutableWordArray# d
    mwa (Int#
    i Int# -> Int# -> Int#
    +# Int#
    off) Word#
    v' State# d
    s of
                      State# d
    s -> Int# -> Word# -> State# d -> State# d
    go (Int#
    i Int# -> Int# -> Int#
    +# Int#
    1#) Word#
    c' State# d
    s

    -- | Sub array inplace (at the specified offset) in the mwa with carry propagation.
    --
    -- We don't trim the resulting array!
    --
    -- Return False# on underflow.
    mwaSubInplaceMutableArray :: MutableWordArray# d -> Int# -> MutableWordArray# d -> State# d -> (# State# d, Bool# #)
    mwaSubInplaceMutableArray :: forall d.
    MutableWordArray# d
    -> Int# -> MutableWordArray# d -> State# d -> (# State# d, Int# #)
    mwaSubInplaceMutableArray MutableWordArray# d
    mwa Int#
    off MutableWordArray# d
    mwb State# d
    s0 =
       case MutableWordArray# d -> State# d -> (# State# d, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# d
    mwb State# d
    s0 of
          (# State# d
    s1, Int#
    szB #) -> Int# -> State# d -> (# State# d, Int# #)
    go (Int#
    szB Int# -> Int# -> Int#
    -# Int#
    1#) State# d
    s1
       where
          go :: Int# -> State# d -> (# State# d, Int# #)
    go Int#
    i State# d
    s
             | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#) = (# State# d
    s, Int#
    1# #) -- no underflow
             | Bool
    True
             = case MutableWordArray# d -> Int# -> State# d -> (# State# d, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# d
    mwb Int#
    i State# d
    s of
                (# State# d
    s1, Word#
    bi #) -> case MutableWordArray# d
    -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    forall d.
    MutableWordArray# d
    -> Int# -> Word# -> State# d -> (# State# d, Int# #)
    mwaSubInplaceWord# MutableWordArray# d
    mwa (Int#
    off Int# -> Int# -> Int#
    +# Int#
    i) Word#
    bi State# d
    s1 of
                   (# State# d
    s2, Int#
    1# #) -> Int# -> State# d -> (# State# d, Int# #)
    go (Int#
    i Int# -> Int# -> Int#
    -# Int#
    1#) State# d
    s2
                   (# State# d
    s2, Int#
    _  #) -> (# State# d
    s2, Int#
    0# #) -- underflow

    -- | Sub an array inplace and then trim zeroes
    --
    -- Don't check overflow. The caller must ensure that a>=b
    mwaSubInplaceArrayTrim :: MutableWordArray# d -> Int# -> WordArray# -> State# d -> State# d
    mwaSubInplaceArrayTrim :: forall d.
    MutableWordArray# d -> Int# -> WordArray# -> State# d -> State# d
    mwaSubInplaceArrayTrim MutableWordArray# d
    mwa Int#
    off WordArray#
    wb State# d
    s =
       case MutableWordArray# d
    -> Int# -> WordArray# -> State# d -> (# State# d, Int# #)
    forall d.
    MutableWordArray# d
    -> Int# -> WordArray# -> State# d -> (# State# d, Int# #)
    mwaSubInplaceArray MutableWordArray# d
    mwa Int#
    off WordArray#
    wb State# d
    s of
          (# State# d
    s', Int#
    _ #) -> MutableWordArray# d -> State# d -> State# d
    forall s. MutableByteArray# s -> State# s -> State# s
    mwaTrimZeroes# MutableWordArray# d
    mwa State# d
    s'

    -- | Read an indexed Word in the MutableWordArray. If the index is out-of-bound,
    -- return zero.
    mwaReadOrZero :: MutableWordArray# s -> Int# -> State# s  -> (# State# s, Word# #)
    mwaReadOrZero :: forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    mwaReadOrZero MutableWordArray# s
    mwa Int#
    i State# s
    s = case MutableWordArray# s -> State# s -> (# State# s, Int# #)
    forall s. MutableWordArray# s -> State# s -> (# State# s, Int# #)
    mwaSize# MutableWordArray# s
    mwa State# s
    s of
       (# State# s
    s2, Int#
    sz #)
          | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    >=# Int#
    sz) -> (# State# s
    s2, Word#
    0## #)
          | Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <# Int#
    0#)  -> (# State# s
    s2, Word#
    0## #)
          | Bool
    True               -> MutableWordArray# s -> Int# -> State# s -> (# State# s, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray# MutableWordArray# s
    mwa Int#
    i State# s
    s2

    mwaRead# :: MutableWordArray# s -> Int# -> State# s -> (# State# s, Word# #)
    mwaRead# :: forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    mwaRead# = MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
    forall d.
    MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
    readWordArray#