h,x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None -!G:Encode (# Word# mantissa, Int# exponent #) into a Double#.(provided by GHC's RTS)H9Encode (# Int# mantissa, Int# exponent #) into a Double#.(provided by GHC's RTS)L Branchless absM Branchless signumNPopulation countOBranchless comparisonU0Return the absolute value of the Int# in a Word#ZSafe right shift for Word#[(h,l) <- a + (hb,lb)\Add 3 values together]2-by-1 large divisionRequires: b0 /= 0 a1 >= b0 (not required, but if not q1=0)^Compute base-2 log of This is internally implemented as count-leading-zeros machine instruction._Logarithm for an arbitrary basea5Indicate if the value is a power of two and which onebReverse bytes in a Word#cReverse bits in a Word#d5Reverse bits in the Word32 subwords composing a Word#eWrite a Word to addr in base-256 little-endian representation and return the number of bytes written.fWrite a Word to addr in base-256 big-endian representation and return the number of bytes written.gWrite a Word to addr in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.hRead a Word from addr* in base-256 little-endian representation.@n is the number of bytes to read.iRead a Word from addr' in base-256 big-endian representation.@n is the number of bytes to read.jRead a Word from addr in base-256 representation.@n is the number of bytes to read.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.k-Write a full word with little-endian encodingl-Write a full word with little-endian encodingmWrite a Word to MutableByteArray in base-256 little-endian representation and return the number of bytes written.The offset is in bytes.nWrite a Word to MutableByteArray in base-256 big-endian representation and return the number of bytes written.The offset is in bytes.oWrite a Word to MutableByteArray in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.The offset is in bytes.p-Write a full word with little-endian encodingq-Write a full word with little-endian encodingrRead a Word from  ByteArray* in base-256 little-endian representation.@n is the number of bytes to read.sRead a Word from  ByteArray' in base-256 big-endian representation.@n is the number of bytes to read.tRead a Word from  ByteArray in base-256 representation.@n is the number of bytes to read.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.:ILSXOTHxwuvRWQVK[\N]{|MZPY}yzGUjihtsra^_cdb`gfeonmlkqpJEDF:FIJKPQRMLOHNSTXWVYZ\[]U^_`aGcdbjhigefkltrsomnpqD|E{}yzvwuxI J None -0%E%Unlifted array of Word"Convert limb count into byte count"Convert byte count into limb countCreate a new WordArray# of the given size (*in Word#*) and apply the action to it before returning it frozenCreate two new WordArray# of the given sizes (*in Word#*) and apply the action to them before returning them frozenCreate a new WordArray#Create a new WordArray# of the given size (*in Word#*), apply the action to it, trim its most significant zeroes, then return it frozenCreate two new WordArray# of the given sizes (*in Word#*), apply the action to them, trim their most significant zeroes, then return them frozenCreate a new WordArray# of the given size (*in Word#*), apply the action to it. If the action returns true#, trim its most significant zeroes, then return it frozen. Otherwise, return ()."Create a WordArray# from two Word#`wordArrayFromWord2# h l where h is the most significant word l is the least significant word"Create a WordArray# from one Word#Word array sizeEquality test for WordArray#Get size in Words&Get the last Word (must be non empty!)Copy Words from a WordArray8Don't do anything if the number of words to copy is <= 0 Shrink last words of a WordArraySet sizeCopy the WordArray into the MWA and shrink the size of MWA to the one of the WordArrayTrim ending zeroesCount leading zero Words3Count leading zero Words starting at given position3Count leading zero Words starting at given positionCompare the most signiciant limbs of a and b. The comparison stops (i.e. returns EQ) when there isn't enough lims in a or b to perform another comparison.,Compute MutableWordArray <- WordArray + WordThe MutableWordArray may not be initialized and will be erased anyway.Input: Size(MutableWordArray) = Size(WordArray) + 1 Output: Size(MutableWordArray) = Size(WordArray) [+ 1]Write the most-significant Word: * if it is 0: shrink the array of 1 Word * otherwise: write it=bRead an indexed Word in the MutableWordArray. If the index is out-of-bound, return zero. Size in Word Size in WordDitto Size in Word Size in WordDitto Size in Word+~+~ None -8'  Count of 1s, must be positive (unless specified otherwise).Type representing a GMP Limbghc-bignum backend nameReturn 0 for invalid inputsResultResultResultQuotientQuotientNone' None(None -0PB<Equality test for BigNatA lifted BigNatRepresented 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.A BigNatRepresented 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.#Return count of trailing zero wordsReturn 0 for zero BigNat"Return count of trailing zero bitsReturn 0 for zero BigNatBit shift leftBit shift right/Divide a BigNat by a Word, return the remainderRequire: b /= 0#BigNat division returning remainderMultiply a BigNat by a Word#+Subtract two BigNat (don't check if a >= b)Number of words in the BigNatIndicate if a bigNat is zeroCheck that the BigNat is validCheck that the BigNat is validNumber of words in the BigNat BigNat Zero BigNat oneIndicate if a bigNat is zeroIndicate if a bigNat is oneIndicate if a bigNat is oneIndicate if a bigNat is twoIndicate if a bigNat is two5Indicate if the value is a power of two and which one#Return the Word# at the given index#Return the Word# at the given indexCreate a BigNat from a WordCreate a BigNat from a WordConvert a list of non-zero Words (most-significant first) into a BigNatConvert a list of non-zero Words (most-significant first) into a BigNat1Return the absolute value of the Int# in a BigNatConvert a list of non-zero Words (most-significant first) into a BigNat. Don't remove most-significant zero wordsConvert a BigNat into a list of non-zero Words (most-significant first)8Convert two Word# (most-significant first) into a BigNatConvert a BigNat into a Word#(Convert a BigNat into a Word# if it fitsConvert a BigNat into a WordConvert a BigNat into a Int#Convert a BigNat into a Int7Convert a Word64# into a BigNat on 64-bit architectures7Convert a BigNat into a Word64# on 64-bit architectures:Encode (# BigNat mantissa, Int# exponent #) into a Double#'Test if a BigNat is greater than a Word#Test if a BigNat is equal to a Word'Test if a BigNat is greater than a Word1Test if a BigNat is lower than or equal to a Word1Test if a BigNat is lower than or equal to a WordEquality test for BigNatInequality test for BigNatEquality test for BigNatCompare a BigNat and a Word#Compare a BigNat and a WordCompare two BigNatPredicate: a < bPredicate: a < bPredicate: a <= bPredicate: a <= bPredicate: a > bPredicate: a > bPredicate: a >= bPredicate: a >= bAdd a bigNat and a Word#Add a bigNat and a WordAdd two bigNatsMultiply a BigNAt by a WordSquare a BigNat$Multiplication (classical algorithm)Subtract a Word# from a BigNat)The BigNat must be bigger than the Word#.Subtract a Word# from a BigNat)The BigNat must be bigger than the Word#.Subtract a Word# from a BigNatSubtract two BigNat.Divide a BigNat by a Word, return the quotientRequire: b /= 0.Divide a BigNat by a Word, return the quotientRequire: b /= 0/Divide a BigNat by a Word, return the remainderRequire: b /= 0QuotRem a BigNat by a WordRequire: b /= 0.BigNat division returning (quotient,remainder)"BigNat division returning quotient)Greatest common divisor between two Word#(Greatest common divisor between two Word(Greatest common divisor between two Int#Warning<: result may become negative if (at least) one argument is minBound'Greatest common divisor between two IntWarning<: result may become negative if (at least) one argument is minBoundGreatest common divisorGreatest common divisorLeast common multiple"Least common multiple with a Word#'Least common multiple between two Word# Bitwise ORBitwise OR with Word# Bitwise ANDBitwise ANDNOTBitwise AND with Word#Bitwise ANDNOT with Word#Bitwise AND with Int# Bitwise XORBitwise XOR with Word#PopCount for BigNatPopCount for BigNat"Bit shift right (two's complement)Bit shift rightBit shift leftBigNat bit testBigNat bit testReturn a BigNat whose bit i is the only one set.;Specialized version of `bigNatShiftL (bigNatFromWord# 1##)`Return a BigNat whose bit i is the only one set.;Specialized version of `bigNatShiftL (bigNatFromWord# 1##)`BigNat clear bitBigNat set bitReverse the given bitBase 2 logarithmBase 2 logarithmLogarithm for an arbitrary baseLogarithm for an arbitrary baseLogarithm for an arbitrary baseLogarithm for an arbitrary base=Compute the number of digits of the BigNat in the given base.base must be > 1=Compute the number of digits of the BigNat in the given base.base must be > 1" b e m" computes base b raised to exponent e modulo m." b e m" computes base b raised to exponent e modulo m."Return count of trailing zero bitsReturn 0 for zero BigNat#Return count of trailing zero wordsReturn 0 for zero BigNatWrite a BigNat in base-256 little-endian representation and return the number of bytes written.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.Write a BigNat in base-256 big-endian representation and return the number of bytes written.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.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#5 or least significant byte first (little-endian) if 0#.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.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#5 or least significant byte first (little-endian) if 0#.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.Read a BigNat in base-256 little-endian representation from an Addr#.The size is given in bytes.2Higher limbs equal to 0 are automatically trimmed.Read a BigNat in base-256 big-endian representation from an Addr#.The size is given in bytes.,Null higher limbs are automatically trimmed.7Read 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#5 or least significant byte first (little-endian) if 0#.,Null higher limbs are automatically trimmed.Write a BigNat in base-256 little-endian representation and return the number of bytes written.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.Write a BigNat in base-256 big-endian representation and return the number of bytes written.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.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#5 or least significant byte first (little-endian) if 0#.Use " 256# i" to compute the exact number of bytes written in advance. In case of i == 09, the function will write and report zero bytes written.Read a BigNat in base-256 little-endian representation from a ByteArray#.The size is given in bytes.,Null higher limbs are automatically trimmed.Read a BigNat in base-256 big-endian representation from a ByteArray#.The size is given in bytes.,Null higher limbs are automatically trimmed.;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#5 or least significant byte first (little-endian) if 0#.,Null higher limbs are automatically trimmed..Create a BigNat# from a WordArray# containing n) limbs in least-significant-first order. If possible &, will be used directly (i.e. shared without cloning the  into a newly allocated one)-Create a BigNat from a WordArray# containing n) limbs in least-significant-first order. If possible &, will be used directly (i.e. shared without cloning the  into a newly allocated one)<<None-d7#0Convert the lower bits of a Natural into a Word#$PopCount for Natural%Right shift for Natural& Left shift'Add two naturals(Sub two naturals)Sub two naturals%Throw an Underflow exception if x < y*Sub two naturalsUnsafe: don't check that x >= y Undefined results if it happens+Multiplication,&Return division quotient and remainder%Division by zero is handled by BigNat-Return division quotient.Return division remainder5 Compute greatest common divisor.6Compute least common multiple.7Base 2 logarithm8Logarithm for an arbitrary base9Logarithm for an arbitrary base:": b e m" computes base b raised to exponent e modulo m.;>Compute the number of digits of the Natural in the given base.base must be > 1>Natural number1Invariant: numbers <= 0xffffffffffffffff use the B constructorEquality test for NaturalTest Zero Natural Zero Natural Convert a Natural into a BigNat#8Create a Natural from a BigNat# (respect the invariants)Create a Natural from a Word#Check Natural invariantsCheck Natural invariants One NaturalTest One Natural5Indicate if the value is a power of two and which one9Convert two Word# (most-significant first) into a NaturalCreate a Natural from a Word$Create a Natural from a list of Word/Convert the lower bits of a Natural into a Word?Convert a Natural into a Word# clamping to (maxBound :: Word#).>Convert a Natural into a Word# clamping to (maxBound :: Word).Try downcasting > to  value. Returns (##) if value doesn't fit in .;Encode (# Natural mantissa, Int# exponent #) into a Double#:Encode (# Natural mantissa, Int# exponent #) into a Float#&TODO: Not sure if it's worth to write  optimized versions hereEquality test for NaturalInequality test for NaturalInequality test for Natural!Greater or equal test for Natural!Greater or equal test for NaturalLower or equal test for NaturalLower or equal test for NaturalGreater test for NaturalGreater test for NaturalLower test for NaturalLower test for NaturalCompare two NaturalPopCount for NaturalRight shift for Natural Left shiftSquare a NaturalSignum for NaturalNegate for Natural&Return division quotient and remainder ghc-bignum ghc-bignum ghc-bignum ghc-bignum ghc-bignum ghc-bignumBase 2 logarithmLogarithm for an arbitrary baseLogarithm for an arbitrary baseWrite a > to addr in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.Write a > to addr in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.8Read a Natural 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed.8Read a Natural 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed.Write a Natural 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#5 or least significant byte first (little-endian) if 0#.CB>BC#$%&/01234'()*+,-.56789:;(c) Sylvain Henry 2019, (c) Herbert Valerio Riedel 2014BSD3sylvain@haskus.fr provisionalnon-portable (GHC Extensions)None -T!Convert a Natural into an Integer!Convert an Integer into a NaturalReturn 0 for negative Integers.!Convert an Integer into a Natural2Throw an Underflow exception if input is negative.!Convert an Integer into a NaturalReturn absolute valueTruncate an Integer into a Word Truncates = to least-significant !Convert an Integer into a Word64#!Convert an Integer into an Int64#Add two =s  Multiply two =s  Subtract one = from another. Negate =.One edge-case issue to take into account is that Int's range is not symmetric around 0. I.e. minBound+maxBound = -1IP is used iff n > maxBound::Int IN is used iff n < minBound::Int Compute absolute value of an = Count number of set bits. For negative arguments returns the negated population count of the absolute value. Simultaneous  and .Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault. Simultaneous  and .Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.:Encode (# Integer mantissa, Int# exponent #) into a Float#&TODO: Not sure if it's worth to write  optimized versions here;Encode (# Integer mantissa, Int# exponent #) into a Double# Compute greatest common divisor.Compute least common multiple.Bitwise AND operation7Fake 2's complement for negative values (might be slow)Bitwise OR operation7Fake 2's complement for negative values (might be slow)Bitwise XOR operation7Fake 2's complement for negative values (might be slow)Binary complement of the Positive = for which only n-th bit is setTest if n-th bit is set.7Fake 2's complement for negative values (might be slow)Shift-left operationShift-right operation7Fake 2's complement for negative values (might be slow) Convert a Word# into an Integer!!Convert a Word64# into an Integer"!Convert an Int64# into an Integer=Arbitrary precision integers. In contrast with fixed-size integral types such as , the =8 type represents the entire infinite range of integers.Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.*If the value is small (i.e., fits into an ), the ?! constructor is used. Otherwise  and @" constructors are used to store a  representing the positive or the negative value magnitude, respectively. Invariant:  and @( are used iff the value does not fit in ?.? iff value in  [minBound:: , maxBound::] range@ iff value in ]-inf, minBound::[ rangeA iff value in  ]maxBound::, +inf[ range'Create a positive Integer from a BigNat.Create an Integer from a sign-bit and a BigNat/Convert an Integer into a sign-bit and a BigNatNegative predicate One predicateZero predicateGreater predicate.Equal predicate.Equal predicate. Integer One Integer ZeroCheck Integer invariantsCheck Integer invariants'Create a negative Integer from a BigNat!Convert an Integer into a BigNat.Return 0 for negative Integers.Create an Integer from an Int#Create an Integer from an Int Truncates = to least-significant Convert a Word into an Integer7Create a negative Integer with the given Word magnitude2Create an Integer from a sign and a Word magnitudeTruncate an Integer into a Word&Convert a list of Word into an IntegerNegative predicateNot-equal predicate.Lower-or-equal predicate.Lower predicate.Greater-or-equal predicate.Not-equal predicate.Greater predicate.Lower-or-equal predicate.Lower predicate.Greater-or-equal predicate.Compare two IntegerReturn -1, 0, and 1 depending on whether argument is negative, zero, or positive, respectivelyReturn -1#, 0#, and 1# depending on whether argument is negative, zero, or positive, respectively= for which only n-th bit is setTest if n-th bit is set. For negative Integers it tests the n-th bit of the negated argument.7Fake 2's complement for negative values (might be slow)Shift-right operation7Fake 2's complement for negative values (might be slow)Shift-left operationRemember that bits are stored in sign-magnitude form, hence the behavior of negative Integers is different from negative Int's behavior. Simultaneous  and .Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault. Simultaneous  and .Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.Square a IntegerBase 2 logarithm (floor)For numbers <= 0, return 0Base 2 logarithm (floor)For numbers <= 0, return 0'Logarithm (floor) for an arbitrary baseFor numbers <= 0, return 0'Logarithm (floor) for an arbitrary baseFor numbers <= 0, return 0'Logarithm (floor) for an arbitrary baseFor numbers <= 0, return 0'Logarithm (floor) for an arbitrary baseFor numbers <= 0, return 05Indicate if the value is a power of two and which one;Decode a Double# into (# Integer mantissa, Int# exponent #)5Encode (Integer mantissa, Int exponent) into a DoubleCompute the number of digits of the Integer (without the sign) in the given base.base must be > 1 Write an = (without sign) to addr in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#. Write an = (without sign) to addr in base-256 representation and return the number of bytes written.The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1#5 or least significant byte first (little-endian) if 0#.Read an =9 (without sign) 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed.Read an =9 (without sign) 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed. Write an = (without sign) 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#5 or least significant byte first (little-endian) if 0#. Write an = (without sign) 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#5 or least significant byte first (little-endian) if 0#.Read an == (without sign) 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed.Read an == (without sign) 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#5 or least significant byte first (little-endian) if 0#.+Null higher limbs are automatically trimed.%Get the extended GCD of two integers.`integerGcde# a b` returns (# g,x,y #) where * ax + by = g = |gcd a b|%Get the extended GCD of two integers.`integerGcde a b` returns (g,x,y) where * ax + by = g = |gcd a b|Computes the modular inverse.integerRecipMod# x m behaves as follows:If m > 1 and gcd x m = 1, it returns an integer y with 0 < y < m such that x*y is congruent to 1 modulo m.#If m > 1 and gcd x m > 1, it fails.If m = 1, it returns 0 for all x. The computation effectively takes place in the zero ring, which has a single element 0 with 0+0 = 0*0 = 0: the element 0 is the multiplicative identity element and is its own multiplicative inverse.If m = 0, it fails.6NB. Successful evaluation returns a value of the form  (# n | #)%; failure is indicated by returning  (# | () #).$Computes the modular exponentiation.integerPowMod# b e m behaves as follows:If m > 1 and e >= 0, it returns an integer y with 0 <= y < m and y congruent to b^e modulo m.If m > 1 and e < 0, it uses  to try to find a modular multiplicative inverse b' (which only exists if gcd b m = 1) and then caculates (b')^(-e) modulo m (note that -e > 0); if the inverse does not exist then it fails.If m = 1, it returns 0 for all b and e.If m = 0, it fails.6NB. Successful evaluation returns a value of the form  (# n | #)%; failure is indicated by returning  (# | () #). " !    =@A?=A?@ "!   None 8ghc-bignum backend namePerform quotRem on normalized inputs: * highest bit of B is set * A is trimmed * A >= B * B > 1This operation doesn't really belongs here, but GMP's one is much faster than this simple implementation (basic Euclid algorithm).Ideally we should make an implementation as fast as GMP's one and put it into GHC.Num.Primitives. ResultResultResultResultResultResultResultResultQuotientQuotient##  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSQRTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                     QQQQQQN ghc-bignumGHC.Num.IntegerGHC.Num.NaturalGHC.Num.BigNatGHC.Num.PrimitivesGHC.Num.WordArrayGHC.Num.Backend.SelectedGHC.Num.Backend.Native32GHC.Num.Backend.GMPGHC.Num.BackendintegerFromNaturalintegerToNaturalClampintegerToNaturalThrowintegerToNaturalintegerToWord# integerToInt#integerToWord64#integerToInt64# integerAdd integerMul integerSub integerNegate integerAbsintegerPopCount# integerQuot integerRem integerDiv integerModintegerDivMod#integerQuotRem#integerEncodeFloat#integerEncodeDouble# integerGcd integerLcm integerAnd integerOr integerXorintegerComplement integerBit#integerTestBit#integerShiftL#integerShiftR#integerFromWord#integerFromWord64#integerFromInt64#naturalToWord#naturalPopCount#naturalShiftR#naturalShiftL# naturalAdd naturalSubnaturalSubThrownaturalSubUnsafe naturalMulnaturalQuotRem# naturalQuot naturalRem naturalAnd naturalAndNot naturalOr naturalXornaturalTestBit# naturalBit# naturalGcd naturalLcm naturalLog2#naturalLogBaseWord#naturalLogBase# naturalPowModnaturalSizeInBase# bigNatEq#IntegerNaturalISINIPNSNBghc-primGHC.Prim.ExceptionraiseUnderflow raiseDivZeroBool#wordEncodeDouble#intEncodeDouble#&&#||#notB#absI#sgnI#popCntI#cmpI# testBitI#minI#maxI#andNot#cmpW#wordFromAbsInt#minW#maxW#bitW# testBitW#shiftRW# plusWord12# plusWord3# quotRemWord3# wordLog2# wordLogBase#wordSizeInBase#wordIsPowerOf2#wordReverseBytes#wordReverseBits#wordReverseBits32# wordToAddrLE# wordToAddrBE# wordToAddr#wordFromAddrLE#wordFromAddrBE# wordFromAddr#wordWriteAddrLE#wordWriteAddrBE#wordToMutableByteArrayLE#wordToMutableByteArrayBE#wordToMutableByteArray#wordWriteMutableByteArrayLE#wordWriteMutableByteArrayBE#wordFromByteArrayLE#wordFromByteArrayBE#wordFromByteArray#ioVoidioWord#ioInt#ioBoolunexpectedValue_Int#unexpectedValue_Word#raiseDivZero_Word#raiseUnderflow_Word#unexpectedValueMutableWordArray WordArrayMutableWordArray# WordArray# wordsToBytes# bytesToWords#withNewWordArray#withNewWordArray2# newWordArray#withNewWordArrayTrimmed#withNewWordArray2Trimmed#withNewWordArrayTrimmedMaybe#wordArrayFromWord2#wordArrayFromWord#wordArraySize#mwaSize#wordArrayLast# mwaArrayCopy# mwaShrink# mwaSetSize#mwaInitCopyShrink#mwaTrimZeroes#mwaClzmwaClzAtwaClzAtwordArrayCompareMSWordsmwaInitArrayPlusWordmwaWriteOrShrinkmwaWriteMostSignificantmwaInitArrayBinOp mwaWrite#mwaFill#mwaAddInplaceWord#mwaSubInplaceWord#mwaTrimComparemwaSubInplaceArraymwaAddInplaceArraymwaSubInplaceMutableArraymwaSubInplaceArrayTrim mwaReadOrZeromwaRead#BigNatBN#unBigNatBigNat#bigNatCtzWord# bigNatCtz# bigNatShiftL# bigNatShiftR#bigNatRemWord# bigNatRembigNatMulWord#bigNatSubUnsafe bigNatSize# bigNatIsZero# naturalEq# naturalIsZero naturalZeronaturalToBigNat#naturalFromBigNat#naturalFromWord#integerFromBigNat#integerFromBigNatSign#integerToBigNatSign#integerIsNegative integerIsOne integerIsZero integerGt integerEq integerEq# integerOne integerZeroGmpSize#GmpSizeGmpLimb#GmpLimbinteger_gmp_powm1#integer_gmp_powm_wordinteger_gmp_powm# c_mpn_get_dc_mpn_popcount c_mpn_xor_n c_mpn_ior_n c_mpn_andn_n c_mpn_and_n c_mpn_lshiftc_mpn_rshift_2c c_mpn_rshift c_mpn_mod_1c_mpn_divrem_1 c_mpn_tdiv_r c_mpn_tdiv_q c_mpn_tdiv_qr c_mpn_cmp c_mpn_mul c_mpn_sub c_mpn_add c_mpn_mul_1 c_mpn_sub_1 c_mpn_add_1integer_gmp_invert#integer_gmp_gcdext# c_mpn_gcd# c_mpn_gcd_1#integer_gmp_gcd_word backendNamenarrowGmpSize# narrowCInt#bignat_compare bignat_addbignat_add_word bignat_subbignat_sub_word bignat_mulbignat_mul_wordbignat_popcount bignat_shiftl bignat_shiftr bignat_or bignat_xor bignat_andbignat_and_notbignat_quotrem bignat_quot bignat_rembignat_quotrem_wordbignat_quot_wordbignat_rem_word bignat_gcdbignat_gcd_wordbignat_gcd_word_wordbignat_encode_doublebignat_shiftr_negbignat_powmod_wordbignat_powmod_words bignat_powmodinteger_powmodsbignat_powmod integer_gcdeinteger_recip_modsbignat_recip_mod bigNatCheck# bigNatCheck bigNatSize bigNatZero bigNatOne bigNatZero# bigNatOne#raiseDivZero_BigNat bigNatIsZero bigNatIsOne bigNatIsOne# bigNatIsTwo bigNatIsTwo#bigNatIsPowerOf2# bigNatIndex# bigNatIndexbigNatFromWordbigNatFromWord#bigNatFromWordListbigNatFromWordList#bigNatFromAbsInt#bigNatFromWordListUnsafebigNatToWordListbigNatFromWord2# bigNatToWord#bigNatToWordMaybe# bigNatToWord bigNatToInt# bigNatToIntbigNatFromWord64#bigNatToWord64#bigNatEncodeDouble# bigNatGtWord# bigNatEqWord# bigNatGtWord bigNatLeWord# bigNatLeWordbigNatEq bigNatNe#bigNatNebigNatCompareWord#bigNatCompareWord bigNatCompare bigNatLt#bigNatLt bigNatLe#bigNatLe bigNatGt#bigNatGt bigNatGe#bigNatGebigNatAddWord# bigNatAddWord bigNatAdd bigNatMulWord bigNatSqr bigNatMulbigNatSubWordUnsafe#bigNatSubWordUnsafebigNatSubWord# bigNatSubbigNatQuotWord#bigNatQuotWord bigNatRemWordbigNatQuotRemWord#bigNatQuotRem# bigNatQuotgcdWord#gcdWordgcdInt#gcdInt bigNatGcdbigNatGcdWord# bigNatLcmbigNatLcmWord#bigNatLcmWordWord#bigNatOr bigNatOrWord# bigNatAnd bigNatAndNotbigNatAndWord#bigNatAndNotWord# bigNatAndInt# bigNatXorbigNatXorWord#bigNatPopCountbigNatPopCount#bigNatShiftRNeg# bigNatShiftR bigNatShiftLbigNatTestBit# bigNatTestBit bigNatBit# bigNatBitbigNatClearBit# bigNatSetBit#bigNatComplementBit# bigNatLog2# bigNatLog2bigNatLogBase# bigNatLogBasebigNatLogBaseWord#bigNatLogBaseWordbigNatSizeInBase#bigNatSizeInBase powModWord#bigNatPowModWord# bigNatPowMod bigNatCtz bigNatCtzWordbigNatToAddrLE#bigNatToAddrBE# bigNatToAddr# bigNatToAddrbigNatFromAddrLE#bigNatFromAddrBE#bigNatFromAddr#bigNatToMutableByteArrayLE#bigNatToMutableByteArrayBE#bigNatToMutableByteArray#bigNatFromByteArrayLE#bigNatFromByteArrayBE#bigNatFromByteArray#bigNatFromWordArray#bigNatFromWordArray $fOrdBigNat $fEqBigNat naturalCheck# naturalCheck naturalOne naturalIsOnenaturalIsPowerOf2#naturalFromWord2#naturalFromWordnaturalFromWordList naturalToWordnaturalToWordClamp#naturalToWordClampnaturalToWordMaybe#naturalEncodeDouble#naturalEncodeFloat# naturalEq naturalNe# naturalNe naturalGe# naturalGe naturalLe# naturalLe naturalGt# naturalGt naturalLt# naturalLtnaturalComparenaturalPopCount naturalShiftR naturalShiftL naturalSqr naturalSignum naturalNegatenaturalQuotRemnaturalTestBit naturalBitnaturalSetBit# naturalSetBitnaturalClearBit#naturalClearBitnaturalComplementBit#naturalComplementBit naturalLog2naturalLogBaseWordnaturalLogBasenaturalToAddr# naturalToAddrnaturalFromAddr#naturalFromAddrnaturalToMutableByteArray#naturalFromByteArray# $fOrdNatural $fEqNatural integerCheck# integerCheckintegerFromBigNatNeg#integerToBigNatClamp#integerFromInt#integerFromInt integerToIntintegerFromWordintegerFromWordNeg#integerFromWordSign# integerToWordintegerFromWordListintegerIsNegative# integerNe integerLe integerLt integerGe integerNe# integerGt# integerLe# integerLt# integerGe#integerCompare integerSignumintegerSignum# integerBitintegerTestBit integerShiftR integerShiftLintegerQuotRem integerDivMod integerSqr integerLog2# integerLog2integerLogBaseWord#integerLogBaseWordintegerLogBase#integerLogBaseintegerIsPowerOf2#integerDecodeDouble#integerEncodeDoubleintegerSizeInBase#integerToAddr# integerToAddrintegerFromAddr#integerFromAddrintegerToMutableByteArray#integerToMutableByteArrayintegerFromByteArray#integerFromByteArray integerGcde# integerGcdeintegerRecipMod#integerPowMod# $fOrdInteger $fEqIntegercount_words_bitscount_words_bits_intbignat_quotrem_normalizedGHC.PrimWord# GHC.TypesWordFloatInt#Int GHC.Classes