Movatterモバイル変換

{-# LANGUAGE CPP #-}{-# LANGUAGE MagicHash #-}{-# LANGUAGE UnboxedTuples #-}{-# LANGUAGE BlockArguments #-}{-# LANGUAGE BangPatterns #-}{-# LANGUAGE MultiWayIf #-}{-# LANGUAGE LambdaCase #-}{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE PolyKinds #-}{-# LANGUAGE KindSignatures #-}{-# LANGUAGE BinaryLiterals #-}{-# OPTIONS_GHC -Wno-name-shadowing #-}-- | Multi-precision naturalmoduleGHC.Num.BigNatwhere#include "MachDeps.h"#include "WordSize.h"importGHC.PrimimportGHC.TypesimportGHC.ClassesimportGHC.MagicimportGHC.Num.PrimitivesimportGHC.Num.WordArrayimportGHC.Num.Backenddefault()-- | A BigNat---- Represented as an array of limbs (Word#) stored in little-endian order (Word#-- themselves use machine order).---- Invariant (canonical representation): higher Word# is non-zero.---- As a consequence, zero is represented with a WordArray# whose size is 0.typeBigNat#=WordArray#-- we use a type-alias instead of an unlifted newtype to make Integer/Natural-- types easier to wire in the compiler-- | A lifted BigNat---- Represented as an array of limbs (Word#) stored in little-endian order (Word#-- themselves use machine order).---- Invariant (canonical representation): higher Word# is non-zero.---- As a consequence, zero is represented with a WordArray# whose size is 0.dataBigNat=BN#{BigNat -> BigNat#unBigNat::BigNat#}-- Note [Why (# #)?]-- ~~~~~~~~~~~~~~~~~---- We can't have top-level BigNat# for now because they are unlifted ByteArray#-- (see #17521). So we use functions that take an empty argument (# #) that-- will be discarded at compile time.-- | Check that the BigNat is validbigNatCheck#::BigNat#->Bool#bigNatCheck# :: BigNat# -> Bool#bigNatCheck#BigNat#bn|Bool#0#<-BigNat# -> Bool#bigNatSize#BigNat#bn=Bool#1#-- check that size is a multiple of Word size|Bool#r<-Bool# -> Bool# -> Bool#remInt#(BigNat# -> Bool#sizeofByteArray#BigNat#bn)WORD_SIZE_IN_BYTES#,Bool# -> BoolisTrue#(Bool#rBool# -> Bool# -> Bool#/=#Bool#0#)=Bool#0#-- check that most-significant limb isn't zero|Word#0##<-BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bn(BigNat# -> Bool#bigNatSize#BigNat#bnBool# -> Bool# -> Bool#-#Bool#1#)=Bool#0#|BoolTrue=Bool#1#-- | Check that the BigNat is validbigNatCheck::BigNat#->BoolbigNatCheck :: BigNat# -> BoolbigNatCheckBigNat#bn=Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatCheck#BigNat#bn)-- | Number of words in the BigNatbigNatSize::BigNat#->WordbigNatSize :: BigNat# -> WordbigNatSizeBigNat#bn=Word# -> WordW#(Bool# -> Word#int2Word#(BigNat# -> Bool#bigNatSize#BigNat#bn))-- | Number of words in the BigNatbigNatSize#::BigNat#->Int#bigNatSize# :: BigNat# -> Bool#bigNatSize#BigNat#ba=BigNat# -> Bool#wordArraySize#BigNat#ba{-# NOINLINEbigNatZero#-}bigNatZero::BigNatbigNatZero :: BigNatbigNatZero=BigNat# -> BigNatBN#(Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#0#(\MutableWordArray# RealWorld_State# RealWorlds->State# RealWorlds)){-# NOINLINEbigNatOne#-}bigNatOne::BigNatbigNatOne :: BigNatbigNatOne=BigNat# -> BigNatBN#(Word# -> BigNat#bigNatFromWord#Word#1##)-- | BigNat ZerobigNatZero#::(##)->BigNat#-- cf Note [Why (# #)?]bigNatZero# :: (# #) -> BigNat#bigNatZero#(# #)_=caseBigNatbigNatZeroofBN#BigNat#w->BigNat#w-- | BigNat onebigNatOne#::(##)->BigNat#-- cf Note [Why (# #)?]bigNatOne# :: (# #) -> BigNat#bigNatOne#(# #)_=caseBigNatbigNatOneofBN#BigNat#w->BigNat#wraiseDivZero_BigNat::(##)->BigNat#raiseDivZero_BigNat :: (# #) -> BigNat#raiseDivZero_BigNat(# #)_=caseZonkAny 1forall a. araiseDivZeroof!ZonkAny 1_->(# #) -> BigNat#bigNatZero#(##)-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives-- | Indicate if a bigNat is zerobigNatIsZero::BigNat#->BoolbigNatIsZero :: BigNat# -> BoolbigNatIsZeroBigNat#bn=Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatIsZero#BigNat#bn)-- | Indicate if a bigNat is zerobigNatIsZero#::BigNat#->Bool#bigNatIsZero# :: BigNat# -> Bool#bigNatIsZero#BigNat#ba=BigNat# -> Bool#wordArraySize#BigNat#baBool# -> Bool# -> Bool#==#Bool#0#-- | Indicate if a bigNat is onebigNatIsOne::BigNat#->BoolbigNatIsOne :: BigNat# -> BoolbigNatIsOneBigNat#bn=Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatIsOne#BigNat#bn)-- | Indicate if a bigNat is onebigNatIsOne#::BigNat#->Bool#bigNatIsOne# :: BigNat# -> Bool#bigNatIsOne#BigNat#ba=BigNat# -> Bool#wordArraySize#BigNat#baBool# -> Bool# -> Bool#==#Bool#1#Bool# -> Bool# -> Bool#&&#BigNat# -> Bool# -> Word#indexWordArray#BigNat#baBool#0#Word# -> Word# -> Bool#`eqWord#`Word#1##-- | Indicate if a bigNat is twobigNatIsTwo::BigNat#->BoolbigNatIsTwo :: BigNat# -> BoolbigNatIsTwoBigNat#bn=Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatIsTwo#BigNat#bn)-- | Indicate if a bigNat is twobigNatIsTwo#::BigNat#->Bool#bigNatIsTwo# :: BigNat# -> Bool#bigNatIsTwo#BigNat#ba=BigNat# -> Bool#wordArraySize#BigNat#baBool# -> Bool# -> Bool#==#Bool#1#Bool# -> Bool# -> Bool#&&#BigNat# -> Bool# -> Word#indexWordArray#BigNat#baBool#0#Word# -> Word# -> Bool#`eqWord#`Word#2##-- | Indicate if the value is a power of two and which onebigNatIsPowerOf2#::BigNat#->(#(##)|Word##)bigNatIsPowerOf2# :: BigNat# -> (# (# #) | Word# #)bigNatIsPowerOf2#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=(#(##)|#)|BoolTrue=letmsw :: Word#msw=BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#imaxsz :: Bool#sz=BigNat# -> Bool#bigNatSize#BigNat#aimax :: Bool#imax=Bool#szBool# -> Bool# -> Bool#-#Bool#1#checkAllZeroes :: Bool# -> Bool#checkAllZeroesBool#i|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#<#Bool#0#)=Bool#1#|BoolTrue=caseBigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#iofWord#0##->Bool# -> Bool#checkAllZeroes(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)Word#_->Bool#0#incaseWord# -> (# (# #) | Word# #)wordIsPowerOf2#Word#mswof(#(##)|#)->(#(##)|#)(#|Word#c#)->caseBool# -> Bool#checkAllZeroes(Bool#imaxBool# -> Bool# -> Bool#-#Bool#1#)ofBool#0#->(#(##)|#)Bool#_->(#|Word#cWord# -> Word# -> Word#`plusWord#`(Bool# -> Word#int2Word#Bool#imaxWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BITS_SHIFT#)#)-- | Return the Word# at the given indexbigNatIndex#::BigNat#->Int#->Word#bigNatIndex# :: BigNat# -> Bool# -> Word#bigNatIndex#BigNat#xBool#i=BigNat# -> Bool# -> Word#indexWordArray#BigNat#xBool#i-- | Return the Word# at the given indexbigNatIndex::BigNat#->Int#->WordbigNatIndex :: BigNat# -> Bool# -> WordbigNatIndexBigNat#bnBool#i=Word# -> WordW#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bnBool#i)--------------------------------------------------- Conversion--------------------------------------------------- | Create a BigNat from a WordbigNatFromWord::Word->BigNat#bigNatFromWord :: Word -> BigNat#bigNatFromWord(W#Word#w)=Word# -> BigNat#bigNatFromWord#Word#w-- | Create a BigNat from a WordbigNatFromWord#::Word#->BigNat#bigNatFromWord# :: Word# -> BigNat#bigNatFromWord#Word#0##=(# #) -> BigNat#bigNatZero#(##)bigNatFromWord#Word#w=Word# -> BigNat#wordArrayFromWord#Word#w-- | Convert a list of non-zero Words (most-significant first) into a BigNatbigNatFromWordList::[Word]->BigNat#bigNatFromWordList :: [Word] -> BigNat#bigNatFromWordList(W#Word#0##:[Word]xs)=[Word] -> BigNat#bigNatFromWordList[Word]xsbigNatFromWordList[Word]xs=[Word] -> BigNat#bigNatFromWordListUnsafe[Word]xs-- | Convert a list of non-zero Words (most-significant first) into a BigNatbigNatFromWordList#::[Word]->WordArray#{-# NOINLINEbigNatFromWordList##-}bigNatFromWordList# :: [Word] -> BigNat#bigNatFromWordList#[Word]xs=[Word] -> BigNat#bigNatFromWordList[Word]xs-- | Return the absolute value of the Int# in a BigNatbigNatFromAbsInt#::Int#->BigNat#bigNatFromAbsInt# :: Bool# -> BigNat#bigNatFromAbsInt#Bool#i=Word# -> BigNat#bigNatFromWord#(Bool# -> Word#wordFromAbsInt#Bool#i)-- | Convert a list of non-zero Words (most-significant first) into a BigNat.-- Don't remove most-significant zero wordsbigNatFromWordListUnsafe::[Word]->BigNat#bigNatFromWordListUnsafe :: [Word] -> BigNat#bigNatFromWordListUnsafe[]=(# #) -> BigNat#bigNatZero#(##)bigNatFromWordListUnsafe[Word]xs=letlength :: Bool# -> [a] -> Bool#lengthBool#i[]=Bool#ilengthBool#i(a_:[a]ys)=Bool# -> [a] -> Bool#length(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)[a]ys!lxs :: Bool#lxs=Bool# -> [Word] -> Bool#forall {a}. Bool# -> [a] -> Bool#lengthBool#0#[Word]xswriteWordList :: MutableWordArray# s -> Bool# -> [Word] -> State# s -> State# swriteWordListMutableWordArray# s_mwaBool#_i[]State# ss=State# sswriteWordListMutableWordArray# smwaBool#i(W#Word#w:[Word]ws)State# ss=caseMutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwaBool#iWord#wState# ssofState# ss1->MutableWordArray# s -> Bool# -> [Word] -> State# s -> State# swriteWordListMutableWordArray# smwa(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)[Word]wsState# ss1inBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#lxs\MutableWordArray# RealWorldmwa->MutableWordArray# RealWorld-> Bool# -> [Word] -> State# RealWorld -> State# RealWorldforall {s}.MutableWordArray# s -> Bool# -> [Word] -> State# s -> State# swriteWordListMutableWordArray# RealWorldmwa(Bool#lxsBool# -> Bool# -> Bool#-#Bool#1#)[Word]xs-- | Convert a BigNat into a list of non-zero Words (most-significant first)bigNatToWordList::BigNat#->[Word]bigNatToWordList :: BigNat# -> [Word]bigNatToWordListBigNat#bn=Bool# -> [Word]go(BigNat# -> Bool#bigNatSize#BigNat#bn)wherego :: Bool# -> [Word]goBool#0#=[]goBool#n=BigNat# -> Bool# -> WordbigNatIndexBigNat#bn(Bool#nBool# -> Bool# -> Bool#-#Bool#1#)Word -> [Word] -> [Word]forall a. a -> [a] -> [a]:Bool# -> [Word]go(Bool#nBool# -> Bool# -> Bool#-#Bool#1#)-- | Convert two Word# (most-significant first) into a BigNatbigNatFromWord2#::Word#->Word#->BigNat#bigNatFromWord2# :: Word# -> Word# -> BigNat#bigNatFromWord2#Word#0##Word#0##=(# #) -> BigNat#bigNatZero#(##)bigNatFromWord2#Word#0##Word#l=Word# -> BigNat#bigNatFromWord#Word#lbigNatFromWord2#Word#hWord#l=Word# -> Word# -> BigNat#wordArrayFromWord2#Word#hWord#l-- | Convert a BigNat into a Word#bigNatToWord#::BigNat#->Word#bigNatToWord# :: BigNat# -> Word#bigNatToWord#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#-- | Convert a BigNat into a Word# if it fitsbigNatToWordMaybe#::BigNat#->(#(##)|Word##)bigNatToWordMaybe# :: BigNat# -> (# (# #) | Word# #)bigNatToWordMaybe#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=(#|Word#0###)|Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatSize#BigNat#aBool# -> Bool# -> Bool#>#Bool#1#)=(#(##)|#)|BoolTrue=(#|BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0##)-- | Convert a BigNat into a WordbigNatToWord::BigNat#->WordbigNatToWord :: BigNat# -> WordbigNatToWordBigNat#bn=Word# -> WordW#(BigNat# -> Word#bigNatToWord#BigNat#bn)-- | Convert a BigNat into a Int#bigNatToInt#::BigNat#->Int#bigNatToInt# :: BigNat# -> Bool#bigNatToInt#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Bool#0#|BoolTrue=BigNat# -> Bool# -> Bool#indexIntArray#BigNat#aBool#0#-- | Convert a BigNat into a IntbigNatToInt::BigNat#->IntbigNatToInt :: BigNat# -> IntbigNatToIntBigNat#bn=Bool# -> IntI#(BigNat# -> Bool#bigNatToInt#BigNat#bn)#if WORD_SIZE_IN_BITS == 32-- | Convert a Word64# into a BigNat on 32-bit architecturesbigNatFromWord64#::Word64#->BigNat#bigNatFromWord64#w64=bigNatFromWord2#wh#wl#wherewh#=word64ToWord#(uncheckedShiftRL64#w6432#)wl#=word64ToWord#w64-- | Convert a BigNat into a Word64# on 32-bit architecturesbigNatToWord64#::BigNat#->Word64#bigNatToWord64#b|bigNatIsZerob=wordToWord64#0##|wl<-wordToWord64#(bigNatToWord#b)=ifisTrue#(bigNatSize#b>#1#)thenletwh=wordToWord64#(bigNatIndex#b1#)inuncheckedShiftL64#wh32#`or64#`wlelsewl#else-- | Convert a Word64# into a BigNat on 64-bit architecturesbigNatFromWord64#::Word64#->BigNat#bigNatFromWord64# :: Word64# -> BigNat#bigNatFromWord64#Word64#w64=Word# -> BigNat#bigNatFromWord#(Word64# -> Word#word64ToWord#Word64#w64)-- | Convert a BigNat into a Word64# on 64-bit architecturesbigNatToWord64#::BigNat#->Word64#bigNatToWord64# :: BigNat# -> Word64#bigNatToWord64#BigNat#b=Word# -> Word64#wordToWord64#(BigNat# -> Word#bigNatToWord#BigNat#b)#endif-- | Encode (# BigNat mantissa, Int# exponent #) into a Double#bigNatEncodeDouble#::BigNat#->Int#->Double#bigNatEncodeDouble# :: BigNat# -> Bool# -> Double#bigNatEncodeDouble#BigNat#aBool#e|BigNat# -> BoolbigNatIsZeroBigNat#a=Word# -> Double#word2Double#Word#0##-- FIXME: isn't it NaN on 0# exponent?|BoolTrue=(BigNat# -> Bool# -> Double#) -> BigNat# -> Bool# -> Double#forall a. a -> ainlineBigNat# -> Bool# -> Double#bignat_encode_doubleBigNat#aBool#e--------------------------------------------------- Predicates--------------------------------------------------- | Test if a BigNat is greater than a WordbigNatGtWord#::BigNat#->Word#->Bool#bigNatGtWord# :: BigNat# -> Word# -> Bool#bigNatGtWord#BigNat#bnWord#w=Bool# -> Bool#notB#(BigNat# -> Bool#bigNatIsZero#BigNat#bn)Bool# -> Bool# -> Bool#&&#(BigNat# -> Bool#bigNatSize#BigNat#bnBool# -> Bool# -> Bool#>#Bool#1#Bool# -> Bool# -> Bool#||#BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bnBool#0#Word# -> Word# -> Bool#`gtWord#`Word#w)-- | Test if a BigNat is equal to a WordbigNatEqWord#::BigNat#->Word#->Bool#bigNatEqWord# :: BigNat# -> Word# -> Bool#bigNatEqWord#BigNat#bnWord#w|Word#0##<-Word#w=BigNat# -> Bool#bigNatIsZero#BigNat#bn|Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatSize#BigNat#bnBool# -> Bool# -> Bool#==#Bool#1#)=BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bnBool#0#Word# -> Word# -> Bool#`eqWord#`Word#w|BoolTrue=Bool#0#-- | Test if a BigNat is greater than a WordbigNatGtWord::BigNat#->Word->BoolbigNatGtWord :: BigNat# -> Word -> BoolbigNatGtWordBigNat#bn(W#Word#w)=Bool# -> BoolisTrue#(BigNat# -> Word# -> Bool#bigNatGtWord#BigNat#bnWord#w)-- | Test if a BigNat is lower than or equal to a WordbigNatLeWord#::BigNat#->Word#->Bool#bigNatLeWord# :: BigNat# -> Word# -> Bool#bigNatLeWord#BigNat#bnWord#w=Bool# -> Bool#notB#(BigNat# -> Word# -> Bool#bigNatGtWord#BigNat#bnWord#w)-- | Test if a BigNat is lower than or equal to a WordbigNatLeWord::BigNat#->Word->BoolbigNatLeWord :: BigNat# -> Word -> BoolbigNatLeWordBigNat#bn(W#Word#w)=Bool# -> BoolisTrue#(BigNat# -> Word# -> Bool#bigNatLeWord#BigNat#bnWord#w)-- | Equality test for BigNatbigNatEq#::BigNat#->BigNat#->Bool#{-# NOINLINEbigNatEq##-}bigNatEq# :: BigNat# -> BigNat# -> Bool#bigNatEq#BigNat#waBigNat#wb|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#waBool# -> Bool# -> Bool#/=#BigNat# -> Bool#wordArraySize#BigNat#wb)=Bool#0#|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#waBool# -> Bool# -> Bool#==#Bool#0#)=Bool#1#|BoolTrue=(BigNat# -> BigNat# -> Bool#) -> BigNat# -> BigNat# -> Bool#forall a. a -> ainlineBigNat# -> BigNat# -> Bool#bignat_compareBigNat#waBigNat#wbBool# -> Bool# -> Bool#==#Bool#0#-- | Equality test for BigNatbigNatEq::BigNat#->BigNat#->BoolbigNatEq :: BigNat# -> BigNat# -> BoolbigNatEqBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatEq#BigNat#aBigNat#b)-- | Inequality test for BigNatbigNatNe#::BigNat#->BigNat#->Bool#bigNatNe# :: BigNat# -> BigNat# -> Bool#bigNatNe#BigNat#aBigNat#b=Bool# -> Bool#notB#(BigNat# -> BigNat# -> Bool#bigNatEq#BigNat#aBigNat#b)-- | Equality test for BigNatbigNatNe::BigNat#->BigNat#->BoolbigNatNe :: BigNat# -> BigNat# -> BoolbigNatNeBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatNe#BigNat#aBigNat#b)-- | Compare a BigNat and a Word#bigNatCompareWord#::BigNat#->Word#->Ordering{-# NOINLINEbigNatCompareWord##-}bigNatCompareWord# :: BigNat# -> Word# -> OrderingbigNatCompareWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=Word# -> Word# -> OrderingcmpW#Word#0##Word#b|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#aBool# -> Bool# -> Bool#>#Bool#1#)=OrderingGT|BoolTrue=Word# -> Word# -> OrderingcmpW#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#)Word#b-- | Compare a BigNat and a WordbigNatCompareWord::BigNat#->Word->OrderingbigNatCompareWord :: BigNat# -> Word -> OrderingbigNatCompareWordBigNat#a(W#Word#b)=BigNat# -> Word# -> OrderingbigNatCompareWord#BigNat#aWord#b-- | Compare two BigNatbigNatCompare::BigNat#->BigNat#->Ordering{-# NOINLINEbigNatCompare#-}bigNatCompare :: BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#b=letszA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#aszB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#binif|Bool# -> BoolisTrue#(Bool#szABool# -> Bool# -> Bool#>#Bool#szB)->OrderingGT|Bool# -> BoolisTrue#(Bool#szABool# -> Bool# -> Bool#<#Bool#szB)->OrderingLT|Bool# -> BoolisTrue#(Bool#szABool# -> Bool# -> Bool#==#Bool#0#)->OrderingEQ|BoolTrue->Bool# -> Bool# -> OrderingcompareInt#((BigNat# -> BigNat# -> Bool#) -> BigNat# -> BigNat# -> Bool#forall a. a -> ainlineBigNat# -> BigNat# -> Bool#bignat_compareBigNat#aBigNat#b)Bool#0#-- | Predicate: a < bbigNatLt#::BigNat#->BigNat#->Bool#bigNatLt# :: BigNat# -> BigNat# -> Bool#bigNatLt#BigNat#aBigNat#b|OrderingLT<-BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#b=Bool#1#|BoolTrue=Bool#0#-- | Predicate: a < bbigNatLt::BigNat#->BigNat#->BoolbigNatLt :: BigNat# -> BigNat# -> BoolbigNatLtBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatLt#BigNat#aBigNat#b)-- | Predicate: a <= bbigNatLe#::BigNat#->BigNat#->Bool#bigNatLe# :: BigNat# -> BigNat# -> Bool#bigNatLe#BigNat#aBigNat#b|OrderingGT<-BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#b=Bool#0#|BoolTrue=Bool#1#-- | Predicate: a <= bbigNatLe::BigNat#->BigNat#->BoolbigNatLe :: BigNat# -> BigNat# -> BoolbigNatLeBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatLe#BigNat#aBigNat#b)-- | Predicate: a > bbigNatGt#::BigNat#->BigNat#->Bool#bigNatGt# :: BigNat# -> BigNat# -> Bool#bigNatGt#BigNat#aBigNat#b|OrderingGT<-BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#b=Bool#1#|BoolTrue=Bool#0#-- | Predicate: a > bbigNatGt::BigNat#->BigNat#->BoolbigNatGt :: BigNat# -> BigNat# -> BoolbigNatGtBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatGt#BigNat#aBigNat#b)-- | Predicate: a >= bbigNatGe#::BigNat#->BigNat#->Bool#bigNatGe# :: BigNat# -> BigNat# -> Bool#bigNatGe#BigNat#aBigNat#b|OrderingLT<-BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#b=Bool#0#|BoolTrue=Bool#1#-- | Predicate: a >= bbigNatGe::BigNat#->BigNat#->BoolbigNatGe :: BigNat# -> BigNat# -> BoolbigNatGeBigNat#aBigNat#b=Bool# -> BoolisTrue#(BigNat# -> BigNat# -> Bool#bigNatGe#BigNat#aBigNat#b)--------------------------------------------------- Addition--------------------------------------------------- | Add a bigNat and a Word#bigNatAddWord#::BigNat#->Word#->BigNat#bigNatAddWord# :: BigNat# -> Word# -> BigNat#bigNatAddWord#BigNat#aWord#b|Word#0##<-Word#b=BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word# -> BigNat#bigNatFromWord#Word#b|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#(BigNat# -> Bool#wordArraySize#BigNat#aBool# -> Bool# -> Bool#+#Bool#1#)\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_add_wordMutableWordArray# RealWorldmwaBigNat#aWord#bState# RealWorlds-- | Add a bigNat and a WordbigNatAddWord::BigNat#->Word->BigNat#bigNatAddWord :: BigNat# -> Word -> BigNat#bigNatAddWordBigNat#a(W#Word#b)=BigNat# -> Word# -> BigNat#bigNatAddWord#BigNat#aWord#b-- | Add two bigNatsbigNatAdd::BigNat#->BigNat#->BigNat#bigNatAdd :: BigNat# -> BigNat# -> BigNat#bigNatAddBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BoolTrue=let!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!szB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#b!szMax :: Bool#szMax=Bool# -> Bool# -> Bool#maxI#Bool#szABool#szB!sz :: Bool#sz=Bool#szMaxBool# -> Bool# -> Bool#+#Bool#1#-- for the potential carryinBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_addMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorlds--------------------------------------------------- Multiplication--------------------------------------------------- | Multiply a BigNat by a Word#bigNatMulWord#::BigNat#->Word#->BigNat#bigNatMulWord# :: BigNat# -> Word# -> BigNat#bigNatMulWord#BigNat#aWord#w|Word#0##<-Word#w=(# #) -> BigNat#bigNatZero#(##)|Word#1##<-Word#w=BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsOneBigNat#a=Word# -> BigNat#bigNatFromWord#Word#w|Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatSize#BigNat#aBool# -> Bool# -> Bool#==#Bool#1#)=caseWord# -> Word# -> (# Word#, Word# #)timesWord2#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#)Word#wof(#Word#h,Word#l#)->Word# -> Word# -> BigNat#bigNatFromWord2#Word#hWord#l|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#(BigNat# -> Bool#bigNatSize#BigNat#aBool# -> Bool# -> Bool#+#Bool#1#)\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_mul_wordMutableWordArray# RealWorldmwaBigNat#aWord#wState# RealWorlds-- | Multiply a BigNAt by a WordbigNatMulWord::BigNat#->Word->BigNat#bigNatMulWord :: BigNat# -> Word -> BigNat#bigNatMulWordBigNat#a(W#Word#w)=BigNat# -> Word# -> BigNat#bigNatMulWord#BigNat#aWord#w-- | Square a BigNatbigNatSqr::BigNat#->BigNat#bigNatSqr :: BigNat# -> BigNat#bigNatSqrBigNat#a=BigNat# -> BigNat# -> BigNat#bigNatMulBigNat#aBigNat#a-- This can be replaced by a backend primitive in the future (e.g. to use-- GMP's mpn_sqr)-- | Multiplication (classical algorithm)bigNatMul::BigNat#->BigNat#->BigNat#bigNatMul :: BigNat# -> BigNat# -> BigNat#bigNatMulBigNat#aBigNat#b|BigNat# -> WordbigNatSizeBigNat#bWord -> Word -> Boolforall a. Ord a => a -> a -> Bool>BigNat# -> WordbigNatSizeBigNat#a=BigNat# -> BigNat# -> BigNat#bigNatMulBigNat#bBigNat#a-- optimize loops|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#b|BigNat# -> BoolbigNatIsOneBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsOneBigNat#b=BigNat#a|BoolTrue=let!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!szB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#b!sz :: Bool#sz=Bool#szABool# -> Bool# -> Bool#+#Bool#szBinBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_mulMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorlds--------------------------------------------------- Subtraction--------------------------------------------------- | Subtract a Word# from a BigNat---- The BigNat must be bigger than the Word#.bigNatSubWordUnsafe#::BigNat#->Word#->BigNat#bigNatSubWordUnsafe# :: BigNat# -> Word# -> BigNat#bigNatSubWordUnsafe#BigNat#xWord#y|Word#0##<-Word#y=BigNat#x|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwa->MutableWordArray# RealWorld-> Word# -> Bool# -> State# RealWorld -> State# RealWorldforall {s}.MutableByteArray# s -> Word# -> Bool# -> State# s -> State# sgoMutableWordArray# RealWorldmwaWord#yBool#0#where!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#xgo :: MutableByteArray# s -> Word# -> Bool# -> State# s -> State# sgoMutableByteArray# smwaWord#carryBool#iState# ss|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#>=#Bool#sz)=State# ss|Word#0##<-Word#carry=MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# sforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableByteArray# smwaBool#iBigNat#xBool#i(Bool#szBool# -> Bool# -> Bool#-#Bool#i)State# ss|BoolTrue=caseWord# -> Word# -> (# Word#, Bool# #)subWordC#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#xBool#i)Word#carryof(#Word#l,Bool#c#)->caseMutableByteArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableByteArray# smwaBool#iWord#lState# ssofState# ss1->MutableByteArray# s -> Word# -> Bool# -> State# s -> State# sgoMutableByteArray# smwa(Bool# -> Word#int2Word#Bool#c)(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)State# ss1-- | Subtract a Word# from a BigNat---- The BigNat must be bigger than the Word#.bigNatSubWordUnsafe::BigNat#->Word->BigNat#bigNatSubWordUnsafe :: BigNat# -> Word -> BigNat#bigNatSubWordUnsafeBigNat#x(W#Word#y)=BigNat# -> Word# -> BigNat#bigNatSubWordUnsafe#BigNat#xWord#y-- | Subtract a Word# from a BigNatbigNatSubWord#::BigNat#->Word#->(#(##)|BigNat##)bigNatSubWord# :: BigNat# -> Word# -> (# (# #) | BigNat# #)bigNatSubWord#BigNat#aWord#b|Word#0##<-Word#b=(#|BigNat#a#)|BigNat# -> BoolbigNatIsZeroBigNat#a=(#(##)|#)|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> (# State# RealWorld, Bool# #))-> (# (# #) | BigNat# #)withNewWordArrayTrimmedMaybe#(BigNat# -> Bool#bigNatSize#BigNat#a)\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> (# State# RealWorld, Bool# #))-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> (# State# RealWorld, Bool# #)forall a. a -> ainlineMutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> (# State# RealWorld, Bool# #)bignat_sub_wordMutableWordArray# RealWorldmwaBigNat#aWord#bState# RealWorlds-- | Subtract two BigNat (don't check if a >= b)bigNatSubUnsafe::BigNat#->BigNat#->BigNat#bigNatSubUnsafe :: BigNat# -> BigNat# -> BigNat#bigNatSubUnsafeBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BoolTrue=letszA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#ainBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#szA\MutableWordArray# RealWorldmwaState# RealWorlds->case(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> (# State# RealWorld, Bool# #))-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> (# State# RealWorld, Bool# #)forall a. a -> ainlineMutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> (# State# RealWorld, Bool# #)bignat_subMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorldsof(#State# RealWorlds',Bool#1##)->State# RealWorlds'(#State# RealWorlds',Bool#_#)->caseZonkAny 0forall a. araiseUnderflowof!ZonkAny 0_->State# RealWorlds'-- see Note [ghc-bignum exceptions] in-- GHC.Num.Primitives-- | Subtract two BigNatbigNatSub::BigNat#->BigNat#->(#(##)|BigNat##)bigNatSub :: BigNat# -> BigNat# -> (# (# #) | BigNat# #)bigNatSubBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=(#|BigNat#a#)|Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatSize#BigNat#aBool# -> Bool# -> Bool#<#BigNat# -> Bool#bigNatSize#BigNat#b)=(#(##)|#)|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> (# State# RealWorld, Bool# #))-> (# (# #) | BigNat# #)withNewWordArrayTrimmedMaybe#(BigNat# -> Bool#bigNatSize#BigNat#a)\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> (# State# RealWorld, Bool# #))-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> (# State# RealWorld, Bool# #)forall a. a -> ainlineMutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> (# State# RealWorld, Bool# #)bignat_subMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorlds--------------------------------------------------- Division--------------------------------------------------- | Divide a BigNat by a Word, return the quotient---- Require:--    b /= 0bigNatQuotWord#::BigNat#->Word#->BigNat#bigNatQuotWord# :: BigNat# -> Word# -> BigNat#bigNatQuotWord#BigNat#aWord#b|Word#1##<-Word#b=BigNat#a|Word#0##<-Word#b=(# #) -> BigNat#raiseDivZero_BigNat(##)|BoolTrue=letsz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#ainBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwqState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_quot_wordMutableWordArray# RealWorldmwqBigNat#aWord#bState# RealWorlds-- | Divide a BigNat by a Word, return the quotient---- Require:--    b /= 0bigNatQuotWord::BigNat#->Word->BigNat#bigNatQuotWord :: BigNat# -> Word -> BigNat#bigNatQuotWordBigNat#a(W#Word#b)=BigNat# -> Word# -> BigNat#bigNatQuotWord#BigNat#aWord#b-- | Divide a BigNat by a Word, return the remainder---- Require:--    b /= 0bigNatRemWord#::BigNat#->Word#->Word#bigNatRemWord# :: BigNat# -> Word# -> Word#bigNatRemWord#BigNat#aWord#b|Word#0##<-Word#b=(# #) -> Word#raiseDivZero_Word#(##)|Word#1##<-Word#b=Word#0##|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=(BigNat# -> Word# -> Word#) -> BigNat# -> Word# -> Word#forall a. a -> ainlineBigNat# -> Word# -> Word#bignat_rem_wordBigNat#aWord#b-- | Divide a BigNat by a Word, return the remainder---- Require:--    b /= 0bigNatRemWord::BigNat#->Word->WordbigNatRemWord :: BigNat# -> Word -> WordbigNatRemWordBigNat#a(W#Word#b)=Word# -> WordW#(BigNat# -> Word# -> Word#bigNatRemWord#BigNat#aWord#b)-- | QuotRem a BigNat by a Word---- Require:--    b /= 0bigNatQuotRemWord#::BigNat#->Word#->(#BigNat#,Word##)bigNatQuotRemWord# :: BigNat# -> Word# -> (# BigNat#, Word# #)bigNatQuotRemWord#BigNat#aWord#b|Word#0##<-Word#b=caseZonkAny 2forall a. araiseDivZeroof!ZonkAny 2_->(#(# #) -> BigNat#bigNatZero#(##),Word#0###)-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives|Word#1##<-Word#b=(#BigNat#a,Word#0###)|Bool# -> BoolisTrue#(BigNat# -> Bool#bigNatSize#BigNat#aBool# -> Bool# -> Bool#==#Bool#1#),Word#a0<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#=caseWord# -> Word# -> OrderingcompareWord#Word#a0Word#bofOrderingLT->(#(# #) -> BigNat#bigNatZero#(##),Word#a0#)OrderingEQ->(#(# #) -> BigNat#bigNatOne#(##),Word#0###)OrderingGT->caseWord# -> Word# -> (# Word#, Word# #)quotRemWord#Word#a0Word#bof(#Word#q,Word#r#)->(#Word# -> BigNat#bigNatFromWord#Word#q,Word#r#)|BoolTrue=letsz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#aio :: State# RealWorld -> (# State# RealWorld, (# BigNat#, Word# #) #)ioState# RealWorlds=caseBool#-> State# RealWorld-> (# State# RealWorld, MutableWordArray# RealWorld #)forall s. Bool# -> State# s -> (# State# s, MutableWordArray# s #)newWordArray#Bool#szState# RealWorldsof{(#State# RealWorlds1,MutableWordArray# RealWorldmwq#)->case(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> (# State# RealWorld, Word# #))-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> (# State# RealWorld, Word# #)forall a. a -> ainlineMutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> (# State# RealWorld, Word# #)bignat_quotrem_wordMutableWordArray# RealWorldmwqBigNat#aWord#bState# RealWorlds1of{(#State# RealWorlds2,Word#r#)->caseMutableWordArray# RealWorld -> State# RealWorld -> State# RealWorldforall s. MutableByteArray# s -> State# s -> State# smwaTrimZeroes#MutableWordArray# RealWorldmwqState# RealWorlds2of{State# RealWorlds3->caseMutableWordArray# RealWorld-> State# RealWorld -> (# State# RealWorld, BigNat# #)forall d.MutableByteArray# d -> State# d -> (# State# d, BigNat# #)unsafeFreezeByteArray#MutableWordArray# RealWorldmwqState# RealWorlds3of{(#State# RealWorlds4,BigNat#wq#)->(#State# RealWorlds4,(#BigNat#wq,Word#r#)#)}}}}incase(State# RealWorld -> (# State# RealWorld, (# BigNat#, Word# #) #))-> (# State# RealWorld, (# BigNat#, Word# #) #)forall o. (State# RealWorld -> o) -> orunRW#State# RealWorld -> (# State# RealWorld, (# BigNat#, Word# #) #)ioof(#State# RealWorld_,(#BigNat#wq,Word#r#)#)->(#BigNat#wq,Word#r#)-- | BigNat division returning (quotient,remainder)bigNatQuotRem#::BigNat#->BigNat#->(#BigNat#,BigNat##)bigNatQuotRem# :: BigNat# -> BigNat# -> (# BigNat#, BigNat# #)bigNatQuotRem#BigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=caseZonkAny 3forall a. araiseDivZeroof!ZonkAny 3_->(#(# #) -> BigNat#bigNatZero#(##),(# #) -> BigNat#bigNatZero#(##)#)-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives|BigNat# -> BoolbigNatIsZeroBigNat#a=(#(# #) -> BigNat#bigNatZero#(##),(# #) -> BigNat#bigNatZero#(##)#)|BigNat# -> BoolbigNatIsOneBigNat#b=(#BigNat#a,(# #) -> BigNat#bigNatZero#(##)#)|OrderingLT<-Orderingcmp=(#(# #) -> BigNat#bigNatZero#(##),BigNat#a#)|OrderingEQ<-Orderingcmp=(#(# #) -> BigNat#bigNatOne#(##),(# #) -> BigNat#bigNatZero#(##)#)|Bool# -> BoolisTrue#(Bool#szBBool# -> Bool# -> Bool#==#Bool#1#)=caseBigNat# -> Word# -> (# BigNat#, Word# #)bigNatQuotRemWord#BigNat#a(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#)of(#BigNat#q,Word#r#)->(#BigNat#q,Word# -> BigNat#bigNatFromWord#Word#r#)|BoolTrue=Bool#-> Bool#-> (MutableWordArray# RealWorld    -> MutableWordArray# RealWorld    -> State# RealWorld    -> State# RealWorld)-> (# BigNat#, BigNat# #)withNewWordArray2Trimmed#Bool#szQBool#szR\MutableWordArray# RealWorldmwqMutableWordArray# RealWorldmwrState# RealWorlds->(MutableWordArray# RealWorld -> MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldbignat_quotremMutableWordArray# RealWorldmwqMutableWordArray# RealWorldmwrBigNat#aBigNat#bState# RealWorldswherecmp :: Orderingcmp=BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#bszA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#aszB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#bszQ :: Bool#szQ=Bool#1#Bool# -> Bool# -> Bool#+#Bool#szABool# -> Bool# -> Bool#-#Bool#szBszR :: Bool#szR=Bool#szB-- | BigNat division returning quotientbigNatQuot::BigNat#->BigNat#->BigNat#bigNatQuot :: BigNat# -> BigNat# -> BigNat#bigNatQuotBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=(# #) -> BigNat#raiseDivZero_BigNat(##)|BigNat# -> BoolbigNatIsZeroBigNat#a=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsOneBigNat#b=BigNat#a|OrderingLT<-Orderingcmp=(# #) -> BigNat#bigNatZero#(##)|OrderingEQ<-Orderingcmp=(# #) -> BigNat#bigNatOne#(##)|Bool# -> BoolisTrue#(Bool#szBBool# -> Bool# -> Bool#==#Bool#1#)=BigNat# -> Word# -> BigNat#bigNatQuotWord#BigNat#a(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#)|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#szQ\MutableWordArray# RealWorldmwqState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_quotMutableWordArray# RealWorldmwqBigNat#aBigNat#bState# RealWorldswherecmp :: Orderingcmp=BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#bszA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#aszB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#bszQ :: Bool#szQ=Bool#1#Bool# -> Bool# -> Bool#+#Bool#szABool# -> Bool# -> Bool#-#Bool#szB-- | BigNat division returning remainderbigNatRem::BigNat#->BigNat#->BigNat#bigNatRem :: BigNat# -> BigNat# -> BigNat#bigNatRemBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=(# #) -> BigNat#raiseDivZero_BigNat(##)|BigNat# -> BoolbigNatIsZeroBigNat#a=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsOneBigNat#b=(# #) -> BigNat#bigNatZero#(##)|OrderingLT<-Orderingcmp=BigNat#a|OrderingEQ<-Orderingcmp=(# #) -> BigNat#bigNatZero#(##)|Bool# -> BoolisTrue#(Bool#szBBool# -> Bool# -> Bool#==#Bool#1#)=caseBigNat# -> Word# -> Word#bigNatRemWord#BigNat#a(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#)ofWord#r->Word# -> BigNat#bigNatFromWord#Word#r|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#szR\MutableWordArray# RealWorldmwrState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_remMutableWordArray# RealWorldmwrBigNat#aBigNat#bState# RealWorldswherecmp :: Orderingcmp=BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#bszB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#bszR :: Bool#szR=Bool#szB--------------------------------------------------- GCD / LCM--------------------------------------------------- Word#/Int# GCDs shouldn't be here in BigNat. However GMP provides a very fast-- implementation so we keep this here at least until we get a native Haskell-- implementation as fast as GMP's one. Note that these functions are used in-- `base` (e.g. in GHC.Real)-- | Greatest common divisor between two Word#gcdWord#::Word#->Word#->Word#gcdWord# :: Word# -> Word# -> Word#gcdWord#=Word# -> Word# -> Word#bignat_gcd_word_word-- | Greatest common divisor between two WordgcdWord::Word->Word->WordgcdWord :: Word -> Word -> WordgcdWord(W#Word#x)(W#Word#y)=Word# -> WordW#(Word# -> Word# -> Word#gcdWord#Word#xWord#y)-- | Greatest common divisor between two Int#---- __Warning__: result may become negative if (at least) one argument-- is 'minBound'gcdInt#::Int#->Int#->Int#gcdInt# :: Bool# -> Bool# -> Bool#gcdInt#Bool#xBool#y=Word# -> Bool#word2Int#(Word# -> Word# -> Word#gcdWord#(Bool# -> Word#wordFromAbsInt#Bool#x)(Bool# -> Word#wordFromAbsInt#Bool#y))-- | Greatest common divisor between two Int---- __Warning__: result may become negative if (at least) one argument-- is 'minBound'gcdInt::Int->Int->IntgcdInt :: Int -> Int -> IntgcdInt(I#Bool#x)(I#Bool#y)=Bool# -> IntI#(Bool# -> Bool# -> Bool#gcdInt#Bool#xBool#y)-- | Greatest common divisorbigNatGcd::BigNat#->BigNat#->BigNat#bigNatGcd :: BigNat# -> BigNat# -> BigNat#bigNatGcdBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BigNat# -> BoolbigNatIsOneBigNat#a=BigNat#a|BigNat# -> BoolbigNatIsOneBigNat#b=BigNat#b|BoolTrue=case(#BigNat# -> Bool#bigNatSize#BigNat#a,BigNat# -> Bool#bigNatSize#BigNat#b#)of(#Bool#1#,Bool#1##)->Word# -> BigNat#bigNatFromWord#(Word# -> Word# -> Word#gcdWord#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#)(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#))(#Bool#1#,Bool#_#)->Word# -> BigNat#bigNatFromWord#(BigNat# -> Word# -> Word#bigNatGcdWord#BigNat#b(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#))(#Bool#_,Bool#1##)->Word# -> BigNat#bigNatFromWord#(BigNat# -> Word# -> Word#bigNatGcdWord#BigNat#a(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#))(# Bool#, Bool# #)_->letgo :: BigNat# -> BigNat# -> BigNat#goBigNat#wxBigNat#wy=-- wx > wyBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#(BigNat# -> Bool#wordArraySize#BigNat#wy)\MutableWordArray# RealWorldmwrState# RealWorlds->MutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_gcdMutableWordArray# RealWorldmwrBigNat#wxBigNat#wyState# RealWorldsincaseBigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#bofOrderingEQ->BigNat#aOrderingLT->BigNat# -> BigNat# -> BigNat#goBigNat#bBigNat#aOrderingGT->BigNat# -> BigNat# -> BigNat#goBigNat#aBigNat#b-- | Greatest common divisorbigNatGcdWord#::BigNat#->Word#->Word#bigNatGcdWord# :: BigNat# -> Word# -> Word#bigNatGcdWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|Word#0##<-Word#b=Word#0##|BigNat# -> BoolbigNatIsOneBigNat#a=Word#1##|Word#1##<-Word#b=Word#1##|BoolTrue=caseBigNat# -> Word# -> OrderingbigNatCompareWord#BigNat#aWord#bofOrderingEQ->Word#bOrdering_->BigNat# -> Word# -> Word#bignat_gcd_wordBigNat#aWord#b-- | Least common multiplebigNatLcm::BigNat#->BigNat#->BigNat#bigNatLcm :: BigNat# -> BigNat# -> BigNat#bigNatLcmBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsZeroBigNat#b=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsOneBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsOneBigNat#b=BigNat#a|BoolTrue=case(#BigNat# -> Bool#bigNatSize#BigNat#a,BigNat# -> Bool#bigNatSize#BigNat#b#)of(#Bool#1#,Bool#1##)->Word# -> Word# -> BigNat#bigNatLcmWordWord#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#)(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#)(#Bool#1#,Bool#_#)->BigNat# -> Word# -> BigNat#bigNatLcmWord#BigNat#b(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#)(#Bool#_,Bool#1##)->BigNat# -> Word# -> BigNat#bigNatLcmWord#BigNat#a(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#bBool#0#)(# Bool#, Bool# #)_->(BigNat#aBigNat# -> BigNat# -> BigNat#`bigNatQuot`(BigNat#aBigNat# -> BigNat# -> BigNat#`bigNatGcd`BigNat#b))BigNat# -> BigNat# -> BigNat#`bigNatMul`BigNat#b-- TODO: use extended GCD to get a's factor directly-- | Least common multiple with a Word#bigNatLcmWord#::BigNat#->Word#->BigNat#bigNatLcmWord# :: BigNat# -> Word# -> BigNat#bigNatLcmWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=(# #) -> BigNat#bigNatZero#(##)|Word#0##<-Word#b=(# #) -> BigNat#bigNatZero#(##)|BigNat# -> BoolbigNatIsOneBigNat#a=Word# -> BigNat#bigNatFromWord#Word#b|Word#1##<-Word#b=BigNat#a|Bool#1#<-BigNat# -> Bool#bigNatSize#BigNat#a=Word# -> Word# -> BigNat#bigNatLcmWordWord#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#0#)Word#b|BoolTrue=(BigNat#aBigNat# -> Word# -> BigNat#`bigNatQuotWord#`(BigNat#aBigNat# -> Word# -> Word#`bigNatGcdWord#`Word#b))BigNat# -> Word# -> BigNat#`bigNatMulWord#`Word#b-- TODO: use extended GCD to get a's factor directly-- | Least common multiple between two Word#bigNatLcmWordWord#::Word#->Word#->BigNat#bigNatLcmWordWord# :: Word# -> Word# -> BigNat#bigNatLcmWordWord#Word#aWord#b|Word#0##<-Word#a=(# #) -> BigNat#bigNatZero#(##)|Word#0##<-Word#b=(# #) -> BigNat#bigNatZero#(##)|Word#1##<-Word#a=Word# -> BigNat#bigNatFromWord#Word#b|Word#1##<-Word#b=Word# -> BigNat#bigNatFromWord#Word#a|BoolTrue=case(Word#aWord# -> Word# -> Word#`quotWord#`(Word#aWord# -> Word# -> Word#`gcdWord#`Word#b))Word# -> Word# -> (# Word#, Word# #)`timesWord2#`Word#bof-- TODO: use extended GCD to get a's factor directly(#Word#h,Word#l#)->Word# -> Word# -> BigNat#bigNatFromWord2#Word#hWord#l--------------------------------------------------- Bitwise operations--------------------------------------------------- | Bitwise ORbigNatOr::BigNat#->BigNat#->BigNat#bigNatOr :: BigNat# -> BigNat# -> BigNat#bigNatOrBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_orMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorldswhere!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!szB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#b!sz :: Bool#sz=Bool# -> Bool# -> Bool#maxI#Bool#szABool#szB-- | Bitwise OR with Word#bigNatOrWord#::BigNat#->Word#->BigNat#bigNatOrWord# :: BigNat# -> Word# -> BigNat#bigNatOrWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=Word# -> BigNat#bigNatFromWord#Word#b|Word#0##<-Word#b=BigNat#a|BoolTrue=letsz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#ainBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#1#BigNat#aBool#1#(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)State# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# RealWorldmwaBool#0#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#Word# -> Word# -> Word#`or#`Word#b)State# RealWorlds'-- | Bitwise ANDbigNatAnd::BigNat#->BigNat#->BigNat#bigNatAnd :: BigNat# -> BigNat# -> BigNat#bigNatAndBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#b|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_andMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorldswhere!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!szB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#b!sz :: Bool#sz=Bool# -> Bool# -> Bool#minI#Bool#szABool#szB-- | Bitwise ANDNOTbigNatAndNot::BigNat#->BigNat#->BigNat#bigNatAndNot :: BigNat# -> BigNat# -> BigNat#bigNatAndNotBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#szA\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_and_notMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorldswhere!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a-- | Bitwise AND with Word#bigNatAndWord#::BigNat#->Word#->BigNat#bigNatAndWord# :: BigNat# -> Word# -> BigNat#bigNatAndWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|BoolTrue=Word# -> BigNat#bigNatFromWord#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#Word# -> Word# -> Word#`and#`Word#b)-- | Bitwise ANDNOT with Word#bigNatAndNotWord#::BigNat#->Word#->BigNat#bigNatAndNotWord# :: BigNat# -> Word# -> BigNat#bigNatAndNotWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|Bool#szA<-BigNat# -> Bool#bigNatSize#BigNat#a=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#szA\MutableWordArray# RealWorldmwaState# RealWorlds->-- duplicate higher limbscaseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#1#BigNat#aBool#1#(Bool#szABool# -> Bool# -> Bool#-#Bool#1#)State# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#0#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#Word# -> Word# -> Word#`and#`Word# -> Word#not#Word#b)State# RealWorlds'-- | Bitwise AND with Int#bigNatAndInt#::BigNat#->Int#->BigNat#bigNatAndInt# :: BigNat# -> Bool# -> BigNat#bigNatAndInt#BigNat#aBool#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#a|Bool# -> BoolisTrue#(Bool#bBool# -> Bool# -> Bool#>=#Bool#0#)=BigNat# -> Word# -> BigNat#bigNatAndWord#BigNat#a(Bool# -> Word#int2Word#Bool#b)|Bool#szA<-BigNat# -> Bool#bigNatSize#BigNat#a=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#szA\MutableWordArray# RealWorldmwaState# RealWorlds->-- duplicate higher limbs (because of sign-extension of b)caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#1#BigNat#aBool#1#(Bool#szABool# -> Bool# -> Bool#-#Bool#1#)State# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#0#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#Word# -> Word# -> Word#`and#`Bool# -> Word#int2Word#Bool#b)State# RealWorlds'-- | Bitwise XORbigNatXor::BigNat#->BigNat#->BigNat#bigNatXor :: BigNat# -> BigNat# -> BigNat#bigNatXorBigNat#aBigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#a=BigNat#b|BigNat# -> BoolbigNatIsZeroBigNat#b=BigNat#a|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorldbignat_xorMutableWordArray# RealWorldmwaBigNat#aBigNat#bState# RealWorldswhere!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!szB :: Bool#szB=BigNat# -> Bool#wordArraySize#BigNat#b!sz :: Bool#sz=Bool# -> Bool# -> Bool#maxI#Bool#szABool#szB-- | Bitwise XOR with Word#bigNatXorWord#::BigNat#->Word#->BigNat#bigNatXorWord# :: BigNat# -> Word# -> BigNat#bigNatXorWord#BigNat#aWord#b|BigNat# -> BoolbigNatIsZeroBigNat#a=Word# -> BigNat#bigNatFromWord#Word#b|Word#0##<-Word#b=BigNat#a|BoolTrue=letsz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#ainBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#1#BigNat#aBool#1#(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)State# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# RealWorldmwaBool#0#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#0#Word# -> Word# -> Word#`xor#`Word#b)State# RealWorlds'-- | PopCount for BigNatbigNatPopCount::BigNat#->WordbigNatPopCount :: BigNat# -> WordbigNatPopCountBigNat#a=Word# -> WordW#(BigNat# -> Word#bigNatPopCount#BigNat#a)-- | PopCount for BigNatbigNatPopCount#::BigNat#->Word#bigNatPopCount# :: BigNat# -> Word#bigNatPopCount#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=(BigNat# -> Word#) -> BigNat# -> Word#forall a. a -> ainlineBigNat# -> Word#bignat_popcountBigNat#a-- | Bit shift rightbigNatShiftR#::BigNat#->Word#->BigNat#bigNatShiftR# :: BigNat# -> Word# -> BigNat#bigNatShiftR#BigNat#aWord#n|Word#0##<-Word#n=BigNat#a|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#aBool# -> Bool# -> Bool#==#Bool#0#)=BigNat#a|Bool#nw<-Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#),Bool# -> BoolisTrue#(Bool#nwBool# -> Bool# -> Bool#>=#BigNat# -> Bool#wordArraySize#BigNat#a)=(# #) -> BigNat#bigNatZero#(##)|BoolTrue=let!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!sz :: Bool#sz=Bool#szABool# -> Bool# -> Bool#-#Bool#nwinBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_shiftrMutableWordArray# RealWorldmwaBigNat#aWord#nState# RealWorlds-- | Bit shift right (two's complement)bigNatShiftRNeg#::BigNat#->Word#->BigNat#bigNatShiftRNeg# :: BigNat# -> Word# -> BigNat#bigNatShiftRNeg#BigNat#aWord#n|Word#0##<-Word#n=BigNat#a|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#aBool# -> Bool# -> Bool#==#Bool#0#)=BigNat#a|Bool#nw<-Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#),Bool# -> BoolisTrue#(Bool#nwBool# -> Bool# -> Bool#>=#BigNat# -> Bool#wordArraySize#BigNat#a)=(# #) -> BigNat#bigNatZero#(##)|BoolTrue=let!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=(Word# -> Bool#word2Int#Word#nBool# -> Bool# -> Bool#-#Bool#1#)Bool# -> Bool# -> Bool#`uncheckedIShiftRL#`WORD_SIZE_BITS_SHIFT#!sz :: Bool#sz=Bool#szABool# -> Bool# -> Bool#-#Bool#nwinBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_shiftr_negMutableWordArray# RealWorldmwaBigNat#aWord#nState# RealWorlds-- | Bit shift rightbigNatShiftR::BigNat#->Word->BigNat#bigNatShiftR :: BigNat# -> Word -> BigNat#bigNatShiftRBigNat#a(W#Word#n)=BigNat# -> Word# -> BigNat#bigNatShiftR#BigNat#aWord#n-- | Bit shift leftbigNatShiftL::BigNat#->Word->BigNat#bigNatShiftL :: BigNat# -> Word -> BigNat#bigNatShiftLBigNat#a(W#Word#n)=BigNat# -> Word# -> BigNat#bigNatShiftL#BigNat#aWord#n-- | Bit shift leftbigNatShiftL#::BigNat#->Word#->BigNat#bigNatShiftL# :: BigNat# -> Word# -> BigNat#bigNatShiftL#BigNat#aWord#n|Word#0##<-Word#n=BigNat#a|Bool# -> BoolisTrue#(BigNat# -> Bool#wordArraySize#BigNat#aBool# -> Bool# -> Bool#==#Bool#0#)=BigNat#a|BoolTrue=let!szA :: Bool#szA=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Bool#nb=Word# -> Bool#word2Int#(Word#nWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##)!sz :: Bool#sz=Bool#szABool# -> Bool# -> Bool#+#Bool#nwBool# -> Bool# -> Bool#+#(Bool#nbBool# -> Bool# -> Bool#/=#Bool#0#)inBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> Word# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> Word#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat# -> Word# -> State# RealWorld -> State# RealWorldbignat_shiftlMutableWordArray# RealWorldmwaBigNat#aWord#nState# RealWorlds-- | BigNat bit testbigNatTestBit#::BigNat#->Word#->Bool#bigNatTestBit# :: BigNat# -> Word# -> Bool#bigNatTestBit#BigNat#aWord#n=let!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Word#nb=Word#nWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##inif|Bool# -> BoolisTrue#(Bool#nwBool# -> Bool# -> Bool#>=#Bool#sz)->Bool#0#|BoolTrue->Word# -> Word# -> Bool#testBitW#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#nw)Word#nb-- | BigNat bit testbigNatTestBit::BigNat#->Word->BoolbigNatTestBit :: BigNat# -> Word -> BoolbigNatTestBitBigNat#a(W#Word#n)=Bool# -> BoolisTrue#(BigNat# -> Word# -> Bool#bigNatTestBit#BigNat#aWord#n)-- | Return a BigNat whose bit `i` is the only one set.---- Specialized version of `bigNatShiftL (bigNatFromWord# 1##)`--bigNatBit#::Word#->BigNat#bigNatBit# :: Word# -> BigNat#bigNatBit#Word#i|Word#0##<-Word#i=(# #) -> BigNat#bigNatOne#(##)|BoolTrue=let!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#iWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Bool#nb=Word# -> Bool#word2Int#(Word#iWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##)!sz :: Bool#sz=Bool#nwBool# -> Bool# -> Bool#+#Bool#1#!v :: Word#v=Word#1##Word# -> Bool# -> Word#`uncheckedShiftL#`Bool#nbinBool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->-- clear the arraycaseMutableWordArray# RealWorld-> Word# -> Word# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s-> Word# -> Word# -> Word# -> State# s -> State# smwaFill#MutableWordArray# RealWorldmwaWord#0##Word#0##(Bool# -> Word#int2Word#Bool#sz)State# RealWorldsof-- set the bit in the most-significant wordState# RealWorlds2->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# RealWorldmwa(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)Word#vState# RealWorlds2-- | Return a BigNat whose bit `i` is the only one set.---- Specialized version of `bigNatShiftL (bigNatFromWord# 1##)`--bigNatBit::Word->BigNat#bigNatBit :: Word -> BigNat#bigNatBit(W#Word#i)=Word# -> BigNat#bigNatBit#Word#i-- | BigNat clear bitbigNatClearBit#::BigNat#->Word#->BigNat#bigNatClearBit# :: BigNat# -> Word# -> BigNat#bigNatClearBit#BigNat#aWord#n-- check the range validity and the current bit value|Bool# -> BoolisTrue#(BigNat# -> Word# -> Bool#bigNatTestBit#BigNat#aWord#nBool# -> Bool# -> Bool#==#Bool#0#)=BigNat#a|BoolTrue=let!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Bool#nb=Word# -> Bool#word2Int#(Word#nWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##)!nv :: Word#nv=BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#nwWord# -> Word# -> Word#`xor#`Bool# -> Word#bitW#Bool#nbinif|Bool# -> BoolisTrue#(Bool#szBool# -> Bool# -> Bool#==#Bool#1#)->Word# -> BigNat#bigNatFromWord#Word#nv-- special case, operating on most-significant Word|Word#0##<-Word#nv,Bool# -> BoolisTrue#(Bool#nwBool# -> Bool# -> Bool#+#Bool#1#Bool# -> Bool# -> Bool#==#Bool#sz)->caseBool#szBool# -> Bool# -> Bool#-#(BigNat# -> Bool# -> Bool#waClzAtBigNat#a(Bool#szBool# -> Bool# -> Bool#-#Bool#2#)Bool# -> Bool# -> Bool#+#Bool#1#)ofBool#0#->(# #) -> BigNat#bigNatZero#(##)Bool#nsz->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#nsz\MutableWordArray# RealWorldmwaState# RealWorlds->MutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#nszState# RealWorlds|BoolTrue->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#szState# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#nwWord#nvState# RealWorlds'-- | BigNat set bitbigNatSetBit#::BigNat#->Word#->BigNat#{-# NOINLINEbigNatSetBit##-}bigNatSetBit# :: BigNat# -> Word# -> BigNat#bigNatSetBit#BigNat#aWord#n-- check the current bit value|Bool# -> BoolisTrue#(BigNat# -> Word# -> Bool#bigNatTestBit#BigNat#aWord#n)=BigNat#a|BoolTrue=let!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Bool#nb=Word# -> Bool#word2Int#(Word#nWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##)d :: Bool#d=Bool#nwBool# -> Bool# -> Bool#+#Bool#1#Bool# -> Bool# -> Bool#-#Bool#szinif-- result BigNat will have more limbs|Bool# -> BoolisTrue#(Bool#dBool# -> Bool# -> Bool#>#Bool#0#)->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#(Bool#nwBool# -> Bool# -> Bool#+#Bool#1#)\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#szState# RealWorldsofState# RealWorlds'->caseMutableWordArray# RealWorld-> Word# -> Word# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s-> Word# -> Word# -> Word# -> State# s -> State# smwaFill#MutableWordArray# RealWorldmwaWord#0##(Bool# -> Word#int2Word#Bool#sz)(Bool# -> Word#int2Word#(Bool#dBool# -> Bool# -> Bool#-#Bool#1#))State# RealWorlds'ofState# RealWorlds''->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#nw(Bool# -> Word#bitW#Bool#nb)State# RealWorlds''|Word#nv<-BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#nwWord# -> Word# -> Word#`or#`Bool# -> Word#bitW#Bool#nb->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#szState# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#nwWord#nvState# RealWorlds'-- | Reverse the given bitbigNatComplementBit#::BigNat#->Word#->BigNat#bigNatComplementBit# :: BigNat# -> Word# -> BigNat#bigNatComplementBit#BigNat#aWord#n=let!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#nWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BITS_SHIFT#)!nb :: Bool#nb=Word# -> Bool#word2Int#(Word#nWord# -> Word# -> Word#`and#`WORD_SIZE_BITS_MASK##)d :: Bool#d=Bool#nwBool# -> Bool# -> Bool#+#Bool#1#Bool# -> Bool# -> Bool#-#Bool#szinif-- result BigNat will have more limbs|Bool# -> BoolisTrue#(Bool#dBool# -> Bool# -> Bool#>#Bool#0#)->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#(Bool#nwBool# -> Bool# -> Bool#+#Bool#1#)\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#szState# RealWorldsofState# RealWorlds'->caseMutableWordArray# RealWorld-> Word# -> Word# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s-> Word# -> Word# -> Word# -> State# s -> State# smwaFill#MutableWordArray# RealWorldmwaWord#0##(Bool# -> Word#int2Word#Bool#sz)(Bool# -> Word#int2Word#(Bool#dBool# -> Bool# -> Bool#-#Bool#1#))State# RealWorlds'ofState# RealWorlds''->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#nw(Bool# -> Word#bitW#Bool#nb)State# RealWorlds''|Word#nv<-BigNat# -> Bool# -> Word#bigNatIndex#BigNat#aBool#nwWord# -> Word# -> Word#`xor#`Bool# -> Word#bitW#Bool#nb->Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#Bool#sz\MutableWordArray# RealWorldmwaState# RealWorlds->caseMutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#aBool#0#Bool#szState# RealWorldsofState# RealWorlds'->MutableWordArray# RealWorld-> Bool# -> Word# -> State# RealWorld -> State# RealWorldforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# swriteWordArray#MutableWordArray# RealWorldmwaBool#nwWord#nvState# RealWorlds'--------------------------------------------------- Log operations--------------------------------------------------- | Base 2 logarithmbigNatLog2#::BigNat#->Word#bigNatLog2# :: BigNat# -> Word#bigNatLog2#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=leti :: Word#i=Bool# -> Word#int2Word#(BigNat# -> Bool#bigNatSize#BigNat#a)Word# -> Word# -> Word#`minusWord#`Word#1##inWord# -> Word#wordLog2#(BigNat# -> Bool# -> Word#bigNatIndex#BigNat#a(Word# -> Bool#word2Int#Word#i))Word# -> Word# -> Word#`plusWord#`(Word#iWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BITS_SHIFT#)-- | Base 2 logarithmbigNatLog2::BigNat#->WordbigNatLog2 :: BigNat# -> WordbigNatLog2BigNat#a=Word# -> WordW#(BigNat# -> Word#bigNatLog2#BigNat#a)-- | Logarithm for an arbitrary basebigNatLogBase#::BigNat#->BigNat#->Word#bigNatLogBase# :: BigNat# -> BigNat# -> Word#bigNatLogBase#BigNat#baseBigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#baseBool -> Bool -> Bool||BigNat# -> BoolbigNatIsOneBigNat#base=(# #) -> Word#unexpectedValue_Word#(##)|Bool#1#<-BigNat# -> Bool#bigNatSize#BigNat#base,Word#2##<-BigNat# -> Bool# -> Word#bigNatIndex#BigNat#baseBool#0#=BigNat# -> Word#bigNatLog2#BigNat#a-- TODO: optimize log base power of 2 (256, etc.)|BoolTrue=caseBigNat# -> (# BigNat#, Word# #)goBigNat#baseof(#BigNat#_,Word#e'#)->Word#e'wherego :: BigNat# -> (# BigNat#, Word# #)goBigNat#pw=ifBigNat#aBigNat# -> BigNat# -> Bool`bigNatLt`BigNat#pwthen(#BigNat#a,Word#0###)elsecaseBigNat# -> (# BigNat#, Word# #)go(BigNat# -> BigNat#bigNatSqrBigNat#pw)of(#BigNat#q,Word#e#)->ifBigNat#qBigNat# -> BigNat# -> Bool`bigNatLt`BigNat#pwthen(#BigNat#q,Word#2##Word# -> Word# -> Word#`timesWord#`Word#e#)else(#BigNat#qBigNat# -> BigNat# -> BigNat#`bigNatQuot`BigNat#pw,(Word#2##Word# -> Word# -> Word#`timesWord#`Word#e)Word# -> Word# -> Word#`plusWord#`Word#1###)-- | Logarithm for an arbitrary basebigNatLogBase::BigNat#->BigNat#->WordbigNatLogBase :: BigNat# -> BigNat# -> WordbigNatLogBaseBigNat#baseBigNat#a=Word# -> WordW#(BigNat# -> BigNat# -> Word#bigNatLogBase#BigNat#baseBigNat#a)-- | Logarithm for an arbitrary basebigNatLogBaseWord#::Word#->BigNat#->Word#bigNatLogBaseWord# :: Word# -> BigNat# -> Word#bigNatLogBaseWord#Word#baseBigNat#a|Word#0##<-Word#base=(# #) -> Word#unexpectedValue_Word#(##)|Word#1##<-Word#base=(# #) -> Word#unexpectedValue_Word#(##)|Word#2##<-Word#base=BigNat# -> Word#bigNatLog2#BigNat#a-- TODO: optimize log base power of 2 (256, etc.)|BoolTrue=BigNat# -> BigNat# -> Word#bigNatLogBase#(Word# -> BigNat#bigNatFromWord#Word#base)BigNat#a-- | Logarithm for an arbitrary basebigNatLogBaseWord::Word->BigNat#->WordbigNatLogBaseWord :: Word -> BigNat# -> WordbigNatLogBaseWord(W#Word#base)BigNat#a=Word# -> WordW#(Word# -> BigNat# -> Word#bigNatLogBaseWord#Word#baseBigNat#a)--------------------------------------------------- Various--------------------------------------------------- | Compute the number of digits of the BigNat in the given base.---- `base` must be > 1bigNatSizeInBase#::Word#->BigNat#->Word#bigNatSizeInBase# :: Word# -> BigNat# -> Word#bigNatSizeInBase#Word#baseBigNat#a|Bool# -> BoolisTrue#(Word#baseWord# -> Word# -> Bool#`leWord#`Word#1##)=(# #) -> Word#unexpectedValue_Word#(##)|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=Word# -> BigNat# -> Word#bigNatLogBaseWord#Word#baseBigNat#aWord# -> Word# -> Word#`plusWord#`Word#1##-- | Compute the number of digits of the BigNat in the given base.---- `base` must be > 1bigNatSizeInBase::Word->BigNat#->WordbigNatSizeInBase :: Word -> BigNat# -> WordbigNatSizeInBase(W#Word#w)BigNat#a=Word# -> WordW#(Word# -> BigNat# -> Word#bigNatSizeInBase#Word#wBigNat#a)--------------------------------------------------- PowMod--------------------------------------------------- Word# powMod shouldn't be here in BigNat. However GMP provides a very fast-- implementation so we keep this here at least until we get a native Haskell-- implementation as fast as GMP's one.powModWord#::Word#->Word#->Word#->Word#powModWord# :: Word# -> Word# -> Word# -> Word#powModWord#=Word# -> Word# -> Word# -> Word#bignat_powmod_words-- | \"@'bigNatPowModWord#' /b/ /e/ /m/@\" computes base @/b/@ raised to-- exponent @/e/@ modulo @/m/@.bigNatPowModWord#::BigNat#->BigNat#->Word#->Word#bigNatPowModWord# :: BigNat# -> BigNat# -> Word# -> Word#bigNatPowModWord#!BigNat#_!BigNat#_Word#0##=(# #) -> Word#raiseDivZero_Word#(##)bigNatPowModWord#BigNat#_BigNat#_Word#1##=Word#0##bigNatPowModWord#BigNat#bBigNat#eWord#m|BigNat# -> BoolbigNatIsZeroBigNat#e=Word#1##|BigNat# -> BoolbigNatIsZeroBigNat#b=Word#0##|BigNat# -> BoolbigNatIsOneBigNat#b=Word#1##|BoolTrue=BigNat# -> BigNat# -> Word# -> Word#bignat_powmod_wordBigNat#bBigNat#eWord#m-- | \"@'bigNatPowMod' /b/ /e/ /m/@\" computes base @/b/@ raised to-- exponent @/e/@ modulo @/m/@.bigNatPowMod::BigNat#->BigNat#->BigNat#->BigNat#bigNatPowMod :: BigNat# -> BigNat# -> BigNat# -> BigNat#bigNatPowMod!BigNat#b!BigNat#e!BigNat#m|(#|Word#m'#)<-BigNat# -> (# (# #) | Word# #)bigNatToWordMaybe#BigNat#m=Word# -> BigNat#bigNatFromWord#(BigNat# -> BigNat# -> Word# -> Word#bigNatPowModWord#BigNat#bBigNat#eWord#m')|BigNat# -> BoolbigNatIsZeroBigNat#m=(# #) -> BigNat#raiseDivZero_BigNat(##)|BigNat# -> BoolbigNatIsOneBigNat#m=Word# -> BigNat#bigNatFromWord#Word#0##|BigNat# -> BoolbigNatIsZeroBigNat#e=Word# -> BigNat#bigNatFromWord#Word#1##|BigNat# -> BoolbigNatIsZeroBigNat#b=Word# -> BigNat#bigNatFromWord#Word#0##|BigNat# -> BoolbigNatIsOneBigNat#b=Word# -> BigNat#bigNatFromWord#Word#1##|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArrayTrimmed#(BigNat# -> Bool#bigNatSize#BigNat#m)\MutableWordArray# RealWorldmwaState# RealWorlds->(MutableWordArray# RealWorld -> BigNat# -> BigNat# -> BigNat# -> State# RealWorld -> State# RealWorld)-> MutableWordArray# RealWorld-> BigNat#-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldforall a. a -> ainlineMutableWordArray# RealWorld-> BigNat#-> BigNat#-> BigNat#-> State# RealWorld-> State# RealWorldbignat_powmodMutableWordArray# RealWorldmwaBigNat#bBigNat#eBigNat#mState# RealWorlds-- | Return count of trailing zero bits---- Return 0 for zero BigNatbigNatCtz#::BigNat#->Word#bigNatCtz# :: BigNat# -> Word#bigNatCtz#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=Bool# -> Word# -> Word#goBool#0#Word#0##wherego :: Bool# -> Word# -> Word#goBool#iWord#c=caseBigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#iofWord#0##->Bool# -> Word# -> Word#go(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)(Word#cWord# -> Word# -> Word#`plusWord#`WORD_SIZE_IN_BITS##)Word#w->Word# -> Word#ctz#Word#wWord# -> Word# -> Word#`plusWord#`Word#c-- | Return count of trailing zero bits---- Return 0 for zero BigNatbigNatCtz::BigNat#->WordbigNatCtz :: BigNat# -> WordbigNatCtzBigNat#a=Word# -> WordW#(BigNat# -> Word#bigNatCtz#BigNat#a)-- | Return count of trailing zero words---- Return 0 for zero BigNatbigNatCtzWord#::BigNat#->Word#bigNatCtzWord# :: BigNat# -> Word#bigNatCtzWord#BigNat#a|BigNat# -> BoolbigNatIsZeroBigNat#a=Word#0##|BoolTrue=Bool# -> Word# -> Word#goBool#0#Word#0##wherego :: Bool# -> Word# -> Word#goBool#iWord#c=caseBigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#iofWord#0##->Bool# -> Word# -> Word#go(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)(Word#cWord# -> Word# -> Word#`plusWord#`Word#1##)Word#_->Word#c-- | Return count of trailing zero words---- Return 0 for zero BigNatbigNatCtzWord::BigNat#->WordbigNatCtzWord :: BigNat# -> WordbigNatCtzWordBigNat#a=Word# -> WordW#(BigNat# -> Word#bigNatCtzWord#BigNat#a)--------------------------------------------------- Export to memory--------------------------------------------------- | Write a BigNat in base-256 little-endian representation and return the-- number of bytes written.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToAddrLE#::BigNat#->Addr#->State#s->(#State#s,Word##){-# NOINLINEbigNatToAddrLE##-}bigNatToAddrLE# :: forall s. BigNat# -> Addr# -> State# s -> (# State# s, Word# #)bigNatToAddrLE#BigNat#aAddr#addrState# ss0|Bool# -> BoolisTrue#(Bool#szBool# -> Bool# -> Bool#==#Bool#0#)=(#State# ss0,Word#0###)|BoolTrue=caseState# s -> (# State# s, Word# #)forall {s}. State# s -> (# State# s, Word# #)writeMSBState# ss0of(#State# ss1,Word#k#)->caseBool# -> State# s -> State# sforall {s}. Bool# -> State# s -> State# sgoBool#0#State# ss1ofState# ss2->(#State# ss2,Word#kWord# -> Word# -> Word#`plusWord#`(Bool# -> Word#int2Word#Bool#liWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)#)where!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!li :: Bool#li=Bool#szBool# -> Bool# -> Bool#-#Bool#1#writeMSB :: State# s -> (# State# s, Word# #)writeMSB=Word# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordToAddrLE#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#li)(Addr#addrAddr# -> Bool# -> Addr#`plusAddr#`(Bool#liBool# -> Bool# -> Bool#`uncheckedIShiftL#`WORD_SIZE_BYTES_SHIFT#))go :: Bool# -> State# s -> State# sgoBool#iState# ss|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#<#Bool#li),Bool#off<-Bool#iBool# -> Bool# -> Bool#`uncheckedIShiftL#`WORD_SIZE_BYTES_SHIFT#,Word#w<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#i=caseWord# -> Addr# -> State# s -> State# sforall s. Word# -> Addr# -> State# s -> State# swordWriteAddrLE#Word#w(Addr#addrAddr# -> Bool# -> Addr#`plusAddr#`Bool#off)State# ssofState# ss->Bool# -> State# s -> State# sgo(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)State# ss|BoolTrue=State# ss-- | Write a BigNat in base-256 big-endian representation and return the-- number of bytes written.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToAddrBE#::BigNat#->Addr#->State#s->(#State#s,Word##){-# NOINLINEbigNatToAddrBE##-}bigNatToAddrBE# :: forall s. BigNat# -> Addr# -> State# s -> (# State# s, Word# #)bigNatToAddrBE#BigNat#aAddr#addrState# ss0|Bool# -> BoolisTrue#(Bool#szBool# -> Bool# -> Bool#==#Bool#0#)=(#State# ss0,Word#0###)|Word#msw<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#a(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)=caseWord# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordToAddrBE#Word#mswAddr#addrState# ss0of(#State# ss1,Word#k#)->caseBool# -> Addr# -> State# s -> State# sforall {s}. Bool# -> Addr# -> State# s -> State# sgo(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)(Addr#addrAddr# -> Bool# -> Addr#`plusAddr#`Word# -> Bool#word2Int#Word#k)State# ss1ofState# ss2->(#State# ss2,Word#kWord# -> Word# -> Word#`plusWord#`(Bool# -> Word#int2Word#(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)Word# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)#)wheresz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#ago :: Bool# -> Addr# -> State# s -> State# sgoBool#iAddr#adrState# ss|Bool#0#<-Bool#i=State# ss|Word#w<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#a(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)=caseWord# -> Addr# -> State# s -> State# sforall s. Word# -> Addr# -> State# s -> State# swordWriteAddrBE#Word#wAddr#adrState# ssofState# ss'->Bool# -> Addr# -> State# s -> State# sgo(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)(Addr#adrAddr# -> Bool# -> Addr#`plusAddr#`WORD_SIZE_IN_BYTES#)s'-- | Write a BigNat in base-256 representation and return the-- number of bytes written.---- The endianness is selected with the Bool# parameter: most significant-- byte first (big-endian) if @1#@ or least significant byte first-- (little-endian) if @0#@.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToAddr#::BigNat#->Addr#->Bool#->State#s->(#State#s,Word##)bigNatToAddr# :: forall s.BigNat# -> Addr# -> Bool# -> State# s -> (# State# s, Word# #)bigNatToAddr#BigNat#aAddr#addrBool#0#State# ss=BigNat# -> Addr# -> State# s -> (# State# s, Word# #)forall s. BigNat# -> Addr# -> State# s -> (# State# s, Word# #)bigNatToAddrLE#BigNat#aAddr#addrState# ssbigNatToAddr#BigNat#aAddr#addrBool#_State# ss=BigNat# -> Addr# -> State# s -> (# State# s, Word# #)forall s. BigNat# -> Addr# -> State# s -> (# State# s, Word# #)bigNatToAddrBE#BigNat#aAddr#addrState# ss-- | Write a BigNat in base-256 representation and return the-- number of bytes written.---- The endianness is selected with the Bool# parameter: most significant-- byte first (big-endian) if @1#@ or least significant byte first-- (little-endian) if @0#@.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToAddr::BigNat#->Addr#->Bool#->IOWordbigNatToAddr :: BigNat# -> Addr# -> Bool# -> IO WordbigNatToAddrBigNat#aAddr#addrBool#e=(State# RealWorld -> (# State# RealWorld, Word #)) -> IO Wordforall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO aIO\State# RealWorlds->caseBigNat#-> Addr#-> Bool#-> State# RealWorld-> (# State# RealWorld, Word# #)forall s.BigNat# -> Addr# -> Bool# -> State# s -> (# State# s, Word# #)bigNatToAddr#BigNat#aAddr#addrBool#eState# RealWorldsof(#State# RealWorlds',Word#w#)->(#State# RealWorlds',Word# -> WordW#Word#w#)--------------------------------------------------- Import from memory--------------------------------------------------- | Read a BigNat in base-256 little-endian representation from an Addr#.---- The size is given in bytes.---- Higher limbs equal to 0 are automatically trimmed.bigNatFromAddrLE#::Word#->Addr#->State#s->(#State#s,BigNat##){-# NOINLINEbigNatFromAddrLE##-}bigNatFromAddrLE# :: forall s. Word# -> Addr# -> State# s -> (# State# s, BigNat# #)bigNatFromAddrLE#Word#0##Addr#_State# ss=(#State# ss,(# #) -> BigNat#bigNatZero#(##)#)bigNatFromAddrLE#Word#szAddr#addrState# ss=let!nw :: Word#nw=Word#szWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BYTES_SHIFT#!nb :: Word#nb=Word#szWord# -> Word# -> Word#`and#`WORD_SIZE_BYTES_MASK##readMSB :: MutableWordArray# s -> State# s -> State# sreadMSBMutableWordArray# smwaState# ss|Word#0##<-Word#nb=State# ss|Bool#off<-Word# -> Bool#word2Int#(Word#nwWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)=caseWord# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordFromAddrLE#Word#nb(Addr#addrAddr# -> Bool# -> Addr#`plusAddr#`Bool#off)State# ssof(#State# ss,Word#w#)->MutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwa(Word# -> Bool#word2Int#Word#nw)Word#wState# ssgo :: MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwaBool#iState# ss|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#==#Word# -> Bool#word2Int#Word#nw)=State# ss|Bool#off<-Bool#iBool# -> Bool# -> Bool#`uncheckedIShiftL#`WORD_SIZE_BYTES_SHIFT#=caseWord# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordFromAddrLE#WORD_SIZE_IN_BYTES##(addrState# s`plusAddr#`off)sof(#State# ss,Word#w#)->caseMutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwaBool#iWord#wState# ssofState# ss->MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwa(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)State# ssincaseBool# -> State# s -> (# State# s, MutableWordArray# s #)forall s. Bool# -> State# s -> (# State# s, MutableWordArray# s #)newWordArray#(Word# -> Bool#word2Int#Word#nwBool# -> Bool# -> Bool#+#(Word# -> Bool#word2Int#Word#nbBool# -> Bool# -> Bool#/=#Bool#0#))State# ssof(#State# ss,MutableWordArray# smwa#)->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# sreadMSBMutableWordArray# smwaState# ssofState# ss->caseMutableWordArray# s -> Bool# -> State# s -> State# sforall {s}. MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwaBool#0#State# ssofState# ss->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# smwaTrimZeroes#MutableWordArray# smwaState# ssofState# ss->MutableWordArray# s -> State# s -> (# State# s, BigNat# #)forall d.MutableByteArray# d -> State# d -> (# State# d, BigNat# #)unsafeFreezeByteArray#MutableWordArray# smwaState# ss-- | Read a BigNat in base-256 big-endian representation from an Addr#.---- The size is given in bytes.---- Null higher limbs are automatically trimmed.bigNatFromAddrBE#::Word#->Addr#->State#s->(#State#s,BigNat##){-# NOINLINEbigNatFromAddrBE##-}bigNatFromAddrBE# :: forall s. Word# -> Addr# -> State# s -> (# State# s, BigNat# #)bigNatFromAddrBE#Word#0##Addr#_State# ss=(#State# ss,(# #) -> BigNat#bigNatZero#(##)#)bigNatFromAddrBE#Word#szAddr#addrState# ss=let!nw :: Bool#nw=Word# -> Bool#word2Int#(Word#szWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BYTES_SHIFT#)!nb :: Word#nb=Word#szWord# -> Word# -> Word#`and#`WORD_SIZE_BYTES_MASK##goMSB :: MutableWordArray# s -> State# s -> State# sgoMSBMutableWordArray# smwaState# ss|Word#0##<-Word#nb=State# ss|BoolTrue=caseWord# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordFromAddrBE#Word#nbAddr#addrState# ssof(#State# ss,Word#w#)->MutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwaBool#nwWord#wState# ssgo :: MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwaBool#iState# ss|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#==#Bool#nw)=State# ss|Bool#k<-Bool#nwBool# -> Bool# -> Bool#-#Bool#1#Bool# -> Bool# -> Bool#-#Bool#i,Bool#off<-(Bool#kBool# -> Bool# -> Bool#`uncheckedIShiftL#`WORD_SIZE_BYTES_SHIFT#)+#word2Int#nb=caseWord# -> Addr# -> State# s -> (# State# s, Word# #)forall s. Word# -> Addr# -> State# s -> (# State# s, Word# #)wordFromAddrBE#WORD_SIZE_IN_BYTES##(addrState# s`plusAddr#`off)sof(#State# ss,Word#w#)->caseMutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwaBool#iWord#wState# ssofState# ss->MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwa(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)State# ssincaseBool# -> State# s -> (# State# s, MutableWordArray# s #)forall s. Bool# -> State# s -> (# State# s, MutableWordArray# s #)newWordArray#(Bool#nwBool# -> Bool# -> Bool#+#(Word# -> Bool#word2Int#Word#nbBool# -> Bool# -> Bool#/=#Bool#0#))State# ssof(#State# ss,MutableWordArray# smwa#)->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# sgoMSBMutableWordArray# smwaState# ssofState# ss->caseMutableWordArray# s -> Bool# -> State# s -> State# sforall {s}. MutableWordArray# s -> Bool# -> State# s -> State# sgoMutableWordArray# smwaBool#0#State# ssofState# ss->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# smwaTrimZeroes#MutableWordArray# smwaState# ssofState# ss->MutableWordArray# s -> State# s -> (# State# s, BigNat# #)forall d.MutableByteArray# d -> State# d -> (# State# d, BigNat# #)unsafeFreezeByteArray#MutableWordArray# smwaState# ss-- | Read a BigNat in base-256 representation from an Addr#.---- The size is given in bytes.---- The endianness is selected with the Bool# parameter: most significant-- byte first (big-endian) if @1#@ or least significant byte first-- (little-endian) if @0#@.---- Null higher limbs are automatically trimmed.bigNatFromAddr#::Word#->Addr#->Bool#->State#s->(#State#s,BigNat##)bigNatFromAddr# :: forall s.Word# -> Addr# -> Bool# -> State# s -> (# State# s, BigNat# #)bigNatFromAddr#Word#szAddr#addrBool#0#State# ss=Word# -> Addr# -> State# s -> (# State# s, BigNat# #)forall s. Word# -> Addr# -> State# s -> (# State# s, BigNat# #)bigNatFromAddrLE#Word#szAddr#addrState# ssbigNatFromAddr#Word#szAddr#addrBool#_State# ss=Word# -> Addr# -> State# s -> (# State# s, BigNat# #)forall s. Word# -> Addr# -> State# s -> (# State# s, BigNat# #)bigNatFromAddrBE#Word#szAddr#addrState# ss--------------------------------------------------- Export to ByteArray--------------------------------------------------- | Write a BigNat in base-256 little-endian representation and return the-- number of bytes written.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToMutableByteArrayLE#::BigNat#->MutableByteArray#s->Word#->State#s->(#State#s,Word##){-# NOINLINEbigNatToMutableByteArrayLE##-}bigNatToMutableByteArrayLE# :: forall s.BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)bigNatToMutableByteArrayLE#BigNat#aMutableByteArray# smbaWord#moffState# ss0|Bool# -> BoolisTrue#(Bool#szBool# -> Bool# -> Bool#==#Bool#0#)=(#State# ss0,Word#0###)|BoolTrue=caseState# s -> (# State# s, Word# #)writeMSBState# ss0of(#State# ss1,Word#k#)->caseBool# -> State# s -> State# sgoBool#0#State# ss1ofState# ss2->(#State# ss2,Word#kWord# -> Word# -> Word#`plusWord#`(Bool# -> Word#int2Word#Bool#liWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)#)where!sz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#a!li :: Bool#li=Bool#szBool# -> Bool# -> Bool#-#Bool#1#writeMSB :: State# s -> (# State# s, Word# #)writeMSB=Word#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)forall s.Word#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)wordToMutableByteArrayLE#(BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#li)MutableByteArray# smba(Word#moffWord# -> Word# -> Word#`plusWord#`Bool# -> Word#int2Word#(Bool#liBool# -> Bool# -> Bool#`uncheckedIShiftL#`WORD_SIZE_BYTES_SHIFT#))go :: Bool# -> State# s -> State# sgoBool#iState# ss|Bool# -> BoolisTrue#(Bool#iBool# -> Bool# -> Bool#<#Bool#li),Word#off<-Bool# -> Word#int2Word#Bool#iWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#,Word#w<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#aBool#i=caseWord# -> MutableByteArray# s -> Word# -> State# s -> State# sforall s.Word# -> MutableByteArray# s -> Word# -> State# s -> State# swordWriteMutableByteArrayLE#Word#wMutableByteArray# smba(Word#moffWord# -> Word# -> Word#`plusWord#`Word#off)State# ssofState# ss->Bool# -> State# s -> State# sgo(Bool#iBool# -> Bool# -> Bool#+#Bool#1#)State# ss|BoolTrue=State# ss-- | Write a BigNat in base-256 big-endian representation and return the-- number of bytes written.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToMutableByteArrayBE#::BigNat#->MutableByteArray#s->Word#->State#s->(#State#s,Word##){-# NOINLINEbigNatToMutableByteArrayBE##-}bigNatToMutableByteArrayBE# :: forall s.BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)bigNatToMutableByteArrayBE#BigNat#aMutableByteArray# smbaWord#moffState# ss0|Bool# -> BoolisTrue#(Bool#szBool# -> Bool# -> Bool#==#Bool#0#)=(#State# ss0,Word#0###)|Word#msw<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#a(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)=caseWord#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)forall s.Word#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)wordToMutableByteArrayBE#Word#mswMutableByteArray# smbaWord#moffState# ss0of(#State# ss1,Word#k#)->caseBool# -> Word# -> State# s -> State# sgo(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)Word#kState# ss1ofState# ss2->(#State# ss2,Word#kWord# -> Word# -> Word#`plusWord#`(Bool# -> Word#int2Word#(Bool#szBool# -> Bool# -> Bool#-#Bool#1#)Word# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)#)wheresz :: Bool#sz=BigNat# -> Bool#wordArraySize#BigNat#ago :: Bool# -> Word# -> State# s -> State# sgoBool#iWord#cState# ss|Bool#0#<-Bool#i=State# ss|Word#w<-BigNat# -> Bool# -> Word#indexWordArray#BigNat#a(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)=caseWord# -> MutableByteArray# s -> Word# -> State# s -> State# sforall s.Word# -> MutableByteArray# s -> Word# -> State# s -> State# swordWriteMutableByteArrayBE#Word#wMutableByteArray# smba(Word#moffWord# -> Word# -> Word#`plusWord#`Word#c)State# ssofState# ss'->Bool# -> Word# -> State# s -> State# sgo(Bool#iBool# -> Bool# -> Bool#-#Bool#1#)(Word#cWord# -> Word# -> Word#`plusWord#`WORD_SIZE_IN_BYTES##)s'-- | Write a BigNat in base-256 representation and return the-- number of bytes written.---- The endianness is selected with the Bool# parameter: most significant-- byte first (big-endian) if @1#@ or least significant byte first-- (little-endian) if @0#@.---- Use \"@'bigNatSizeInBase' 256# /i/@\" to compute the exact number of bytes-- written in advance. In case of @/i/ == 0@, the function will write and report-- zero bytes written.bigNatToMutableByteArray#::BigNat#->MutableByteArray#s->Word#->Bool#->State#s->(#State#s,Word##)bigNatToMutableByteArray# :: forall s.BigNat#-> MutableByteArray# s-> Word#-> Bool#-> State# s-> (# State# s, Word# #)bigNatToMutableByteArray#BigNat#aMutableByteArray# smbaWord#offBool#0#State# ss=BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)forall s.BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)bigNatToMutableByteArrayLE#BigNat#aMutableByteArray# smbaWord#offState# ssbigNatToMutableByteArray#BigNat#aMutableByteArray# smbaWord#offBool#_State# ss=BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)forall s.BigNat#-> MutableByteArray# s-> Word#-> State# s-> (# State# s, Word# #)bigNatToMutableByteArrayBE#BigNat#aMutableByteArray# smbaWord#offState# ss--------------------------------------------------- Import from ByteArray--------------------------------------------------- | Read a BigNat in base-256 little-endian representation from a ByteArray#.---- The size is given in bytes.---- Null higher limbs are automatically trimmed.bigNatFromByteArrayLE#::Word#->ByteArray#->Word#->State#s->(#State#s,BigNat##){-# NOINLINEbigNatFromByteArrayLE##-}bigNatFromByteArrayLE# :: forall s.Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)bigNatFromByteArrayLE#Word#0##BigNat#_Word#_State# ss=(#State# ss,(# #) -> BigNat#bigNatZero#(##)#)bigNatFromByteArrayLE#Word#szBigNat#baWord#moffState# ss=let!nw :: Word#nw=Word#szWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BYTES_SHIFT#!nb :: Word#nb=Word#szWord# -> Word# -> Word#`and#`WORD_SIZE_BYTES_MASK##readMSB :: MutableWordArray# s -> State# s -> State# sreadMSBMutableWordArray# smwaState# ss|Word#0##<-Word#nb=State# ss|Word#off<-Word#nwWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#=caseWord# -> BigNat# -> Word# -> Word#wordFromByteArrayLE#Word#nbBigNat#ba(Word#moffWord# -> Word# -> Word#`plusWord#`Word#off)ofWord#w->MutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwa(Word# -> Bool#word2Int#Word#nw)Word#wState# ssgo :: MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwaWord#iState# ss|Bool# -> BoolisTrue#(Word#iWord# -> Word# -> Bool#`eqWord#`Word#nw)=State# ss|Word#off<-Word#iWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#=caseWord# -> BigNat# -> Word# -> Word#wordFromByteArrayLE#WORD_SIZE_IN_BYTES##ba(moff`plusWord#`off)ofWord#w->caseMutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwa(Word# -> Bool#word2Int#Word#i)Word#wState# ssofState# ss->MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwa(Word#iWord# -> Word# -> Word#`plusWord#`Word#1##)State# ssincaseBool# -> State# s -> (# State# s, MutableWordArray# s #)forall s. Bool# -> State# s -> (# State# s, MutableWordArray# s #)newWordArray#(Word# -> Bool#word2Int#Word#nwBool# -> Bool# -> Bool#+#(Word# -> Bool#word2Int#Word#nbBool# -> Bool# -> Bool#/=#Bool#0#))State# ssof(#State# ss,MutableWordArray# smwa#)->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# sreadMSBMutableWordArray# smwaState# ssofState# ss->caseMutableWordArray# s -> Word# -> State# s -> State# sforall {s}. MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwaWord#0##State# ssofState# ss->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# smwaTrimZeroes#MutableWordArray# smwaState# ssofState# ss->MutableWordArray# s -> State# s -> (# State# s, BigNat# #)forall d.MutableByteArray# d -> State# d -> (# State# d, BigNat# #)unsafeFreezeByteArray#MutableWordArray# smwaState# ss-- | Read a BigNat in base-256 big-endian representation from a ByteArray#.---- The size is given in bytes.---- Null higher limbs are automatically trimmed.bigNatFromByteArrayBE#::Word#->ByteArray#->Word#->State#s->(#State#s,BigNat##){-# NOINLINEbigNatFromByteArrayBE##-}bigNatFromByteArrayBE# :: forall s.Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)bigNatFromByteArrayBE#Word#0##BigNat#_Word#_State# ss=(#State# ss,(# #) -> BigNat#bigNatZero#(##)#)bigNatFromByteArrayBE#Word#szBigNat#baWord#moffState# ss=let!nw :: Word#nw=Word#szWord# -> Bool# -> Word#`uncheckedShiftRL#`WORD_SIZE_BYTES_SHIFT#!nb :: Word#nb=Word#szWord# -> Word# -> Word#`and#`WORD_SIZE_BYTES_MASK##goMSB :: MutableWordArray# s -> State# s -> State# sgoMSBMutableWordArray# smwaState# ss|Word#0##<-Word#nb=State# ss|BoolTrue=caseWord# -> BigNat# -> Word# -> Word#wordFromByteArrayBE#Word#nbBigNat#baWord#moffofWord#w->MutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwa(Word# -> Bool#word2Int#Word#nw)Word#wState# ssgo :: MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwaWord#iState# ss|Bool# -> BoolisTrue#(Word#iWord# -> Word# -> Bool#`eqWord#`Word#nw)=State# ss|Word#k<-Word#nwWord# -> Word# -> Word#`minusWord#`Word#1##Word# -> Word# -> Word#`minusWord#`Word#i,Word#off<-(Word#kWord# -> Bool# -> Word#`uncheckedShiftL#`WORD_SIZE_BYTES_SHIFT#)`plusWord#`nb=caseWord# -> BigNat# -> Word# -> Word#wordFromByteArrayBE#WORD_SIZE_IN_BYTES##ba(moff`plusWord#`off)ofWord#w->caseMutableWordArray# s -> Bool# -> Word# -> State# s -> State# sforall s.MutableWordArray# s -> Bool# -> Word# -> State# s -> State# smwaWrite#MutableWordArray# smwa(Word# -> Bool#word2Int#Word#i)Word#wState# ssofState# ss->MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwa(Word#iWord# -> Word# -> Word#`plusWord#`Word#1##)State# ssincaseBool# -> State# s -> (# State# s, MutableWordArray# s #)forall s. Bool# -> State# s -> (# State# s, MutableWordArray# s #)newWordArray#(Word# -> Bool#word2Int#Word#nwBool# -> Bool# -> Bool#+#(Word# -> Bool#word2Int#Word#nbBool# -> Bool# -> Bool#/=#Bool#0#))State# ssof(#State# ss,MutableWordArray# smwa#)->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# sgoMSBMutableWordArray# smwaState# ssofState# ss->caseMutableWordArray# s -> Word# -> State# s -> State# sforall {s}. MutableWordArray# s -> Word# -> State# s -> State# sgoMutableWordArray# smwaWord#0##State# ssofState# ss->caseMutableWordArray# s -> State# s -> State# sforall s. MutableByteArray# s -> State# s -> State# smwaTrimZeroes#MutableWordArray# smwaState# ssofState# ss->MutableWordArray# s -> State# s -> (# State# s, BigNat# #)forall d.MutableByteArray# d -> State# d -> (# State# d, BigNat# #)unsafeFreezeByteArray#MutableWordArray# smwaState# ss-- | Read a BigNat in base-256 representation from a ByteArray#.---- The size is given in bytes.---- The endianness is selected with the Bool# parameter: most significant-- byte first (big-endian) if @1#@ or least significant byte first-- (little-endian) if @0#@.---- Null higher limbs are automatically trimmed.bigNatFromByteArray#::Word#->ByteArray#->Word#->Bool#->State#s->(#State#s,BigNat##)bigNatFromByteArray# :: forall s.Word#-> BigNat# -> Word# -> Bool# -> State# s -> (# State# s, BigNat# #)bigNatFromByteArray#Word#szBigNat#baWord#offBool#0#State# ss=Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)forall s.Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)bigNatFromByteArrayLE#Word#szBigNat#baWord#offState# ssbigNatFromByteArray#Word#szBigNat#baWord#offBool#_State# ss=Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)forall s.Word# -> BigNat# -> Word# -> State# s -> (# State# s, BigNat# #)bigNatFromByteArrayBE#Word#szBigNat#baWord#offState# ss-- | Create a BigNat# from a WordArray# containing /n/ limbs in-- least-significant-first order.---- If possible 'WordArray#', will be used directly (i.e. shared-- /without/ cloning the 'WordArray#' into a newly allocated one)bigNatFromWordArray#::WordArray#->Word#->BigNat#{-# NOINLINEbigNatFromWordArray##-}bigNatFromWordArray# :: BigNat# -> Word# -> BigNat#bigNatFromWordArray#BigNat#waWord#n0|Bool# -> BoolisTrue#(Word#nWord# -> Word# -> Bool#`eqWord#`Word#0##)=(# #) -> BigNat#bigNatZero#(##)|Bool# -> BoolisTrue#(Word#rWord# -> Word# -> Bool#`eqWord#`Word#0##)-- i.e. wa is multiple of limb-size,Bool# -> BoolisTrue#(Word#qWord# -> Word# -> Bool#`eqWord#`Word#n)=BigNat#wa|BoolTrue=Bool#-> (MutableWordArray# RealWorld    -> State# RealWorld -> State# RealWorld)-> BigNat#withNewWordArray#(Word# -> Bool#word2Int#Word#n)\MutableWordArray# RealWorldmwaState# RealWorlds->MutableWordArray# RealWorld-> Bool#-> BigNat#-> Bool#-> Bool#-> State# RealWorld-> State# RealWorldforall s.MutableByteArray# s-> Bool# -> BigNat# -> Bool# -> Bool# -> State# s -> State# smwaArrayCopy#MutableWordArray# RealWorldmwaBool#0#BigNat#waBool#0#(Word# -> Bool#word2Int#Word#n)State# RealWorldswhere!(#Word#q,Word#r#)=Word# -> Word# -> (# Word#, Word# #)quotRemWord#(Bool# -> Word#int2Word#(BigNat# -> Bool#sizeofByteArray#BigNat#wa))WORD_SIZE_IN_BYTES##-- find real size in Words by removing trailing null limbs!n :: Word#n=Word# -> Word#real_sizeWord#n0real_size :: Word# -> Word#real_sizeWord#0##=Word#0##real_sizeWord#i|Word#0##<-BigNat# -> Bool# -> Word#bigNatIndex#BigNat#wa(Word# -> Bool#word2Int#(Word#iWord# -> Word# -> Word#`minusWord#`Word#1##))=Word# -> Word#real_size(Word#iWord# -> Word# -> Word#`minusWord#`Word#1##)real_sizeWord#i=Word#i-- | Create a BigNat from a WordArray# containing /n/ limbs in-- least-significant-first order.---- If possible 'WordArray#', will be used directly (i.e. shared-- /without/ cloning the 'WordArray#' into a newly allocated one)bigNatFromWordArray::WordArray#->Word#->BigNatbigNatFromWordArray :: BigNat# -> Word# -> BigNatbigNatFromWordArrayBigNat#waWord#n=BigNat# -> BigNatBN#(BigNat# -> Word# -> BigNat#bigNatFromWordArray#BigNat#waWord#n)--------------------------------------------------- Instances-------------------------------------------------instanceEqBigNatwhereBN#BigNat#a== :: BigNat -> BigNat -> Bool==BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatEqBigNat#aBigNat#bBN#BigNat#a/= :: BigNat -> BigNat -> Bool/=BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatNeBigNat#aBigNat#binstanceOrdBigNatwhere(BN#BigNat#a)compare :: BigNat -> BigNat -> Ordering`compare`(BN#BigNat#b)=BigNat# -> BigNat# -> OrderingbigNatCompareBigNat#aBigNat#bBN#BigNat#a< :: BigNat -> BigNat -> Bool<BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatLtBigNat#aBigNat#bBN#BigNat#a<= :: BigNat -> BigNat -> Bool<=BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatLeBigNat#aBigNat#bBN#BigNat#a> :: BigNat -> BigNat -> Bool>BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatGtBigNat#aBigNat#bBN#BigNat#a>= :: BigNat -> BigNat -> Bool>=BN#BigNat#b=BigNat# -> BigNat# -> BoolbigNatGeBigNat#aBigNat#b{- Note [ghc-bignum and error symbols]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ghc-bignum only depends on ghc-prim, not base.Hence it may not introduce any symbol references to the error symbols inControl.Exception.Base such as `patError` or `impossibleError`, otherwisewe get linker errors.This implies that  * Every pattern match must be "obviously complete", otherwise GHC's desugaring    inserts `patError`s for the missing cases. "Obviously complete" in the sense    that the desugarer is able to infer completeness, so considering type info    but not long distance information (as the pattern-match checker would do).  * We compile with -fno-catch-nonexhaustive-cases so that we don't risk    introducing `impossibleError`  * ... probably other similar observations that will be added to this list in    the future ...-}