content: {-# LANGUAGE CPP #-}
  {-# LANGUAGE MagicHash #-}
  {-# LANGUAGE UnboxedTuples #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  
  {-# OPTIONS_HADDOCK not-home #-}
  
  #include "MachDeps.h"
  
  -- | Compatibility module for pre ghc-bignum code.
  module GHC.Internal.Integer (
      Integer,
  
      -- * Construct 'Integer's
      smallInteger, wordToInteger,
  #if WORD_SIZE_IN_BITS < 64
      word64ToInteger, int64ToInteger,
  #endif
      -- * Conversion to other integral types
      integerToWord, integerToInt,
  #if WORD_SIZE_IN_BITS < 64
      integerToWord64, integerToInt64,
  #endif
  
      -- * Helpers for 'RealFloat' type-class operations
      encodeFloatInteger, encodeDoubleInteger, decodeDoubleInteger,
  
      -- * Arithmetic operations
      plusInteger, minusInteger, timesInteger, negateInteger,
      absInteger, signumInteger,
  
      divModInteger, divInteger, modInteger,
      quotRemInteger, quotInteger, remInteger,
  
      -- * Comparison predicates
      eqInteger,  neqInteger,  leInteger,  gtInteger,  ltInteger,  geInteger,
      compareInteger,
  
      -- ** 'Int#'-boolean valued versions of comparison predicates
      --
      -- | These operations return @0#@ and @1#@ instead of 'False' and
      -- 'True' respectively.  See
      -- <https://gitlab.haskell.org/ghc/ghc/wikis/prim-bool PrimBool wiki-page>
      -- for more details
      eqInteger#, neqInteger#, leInteger#, gtInteger#, ltInteger#, geInteger#,
  
  
      -- * Bit-operations
      andInteger, orInteger, xorInteger,
  
      complementInteger,
      shiftLInteger, shiftRInteger, testBitInteger,
  
      popCountInteger, bitInteger,
  
      -- * Hashing
      hashInteger,
      ) where
  
  import GHC.Internal.Bignum.Integer (Integer)
  import qualified GHC.Internal.Bignum.Integer as I
  import GHC.Internal.Prim
  import GHC.Internal.Types
  
  smallInteger :: Int# -> Integer
  smallInteger = I.integerFromInt#
  
  integerToInt :: Integer -> Int#
  integerToInt = I.integerToInt#
  
  wordToInteger :: Word# -> Integer
  wordToInteger = I.integerFromWord#
  
  integerToWord :: Integer -> Word#
  integerToWord = I.integerToWord#
  
  #if WORD_SIZE_IN_BITS < 64
  
  word64ToInteger :: Word64# -> Integer
  word64ToInteger = I.integerFromWord64#
  
  integerToWord64 :: Integer -> Word64#
  integerToWord64 = I.integerToWord64#
  
  int64ToInteger :: Int64# -> Integer
  int64ToInteger = I.integerFromInt64#
  
  integerToInt64 :: Integer -> Int64#
  integerToInt64 = I.integerToInt64#
  
  #endif
  
  
  encodeFloatInteger :: Integer -> Int# -> Float#
  encodeFloatInteger = I.integerEncodeFloat#
  
  encodeDoubleInteger :: Integer -> Int# -> Double#
  encodeDoubleInteger = I.integerEncodeDouble#
  
  decodeDoubleInteger :: Double# -> (# Integer, Int# #)
  decodeDoubleInteger = I.integerDecodeDouble#
  
  -- | Used to implement `(+)` for the `Num` typeclass.
  --   This gives the sum of two integers.
  --
  -- ==== __Example__
  -- >>> plusInteger 3 2
  -- 5
  --
  -- >>> (+) 3 2
  -- 5
  plusInteger :: Integer -> Integer -> Integer
  plusInteger = I.integerAdd
  
  -- | Used to implement `(-)` for the `Num` typeclass.
  --   This gives the difference of two integers.
  --
  -- ==== __Example__
  -- >>> minusInteger 3 2
  -- 1
  --
  -- >>> (-) 3 2
  -- 1
  minusInteger :: Integer -> Integer -> Integer
  minusInteger = I.integerSub
  
  -- | Used to implement `(*)` for the `Num` typeclass.
  --   This gives the product of two integers.
  --
  -- ==== __Example__
  -- >>> timesInteger 3 2
  -- 6
  --
  -- >>> (*) 3 2
  -- 6
  timesInteger :: Integer -> Integer -> Integer
  timesInteger = I.integerMul
  
  -- | Used to implement `negate` for the `Num` typeclass.
  --   This changes the sign of whatever integer is passed into it.
  --
  -- ==== __Example__
  -- >>> negateInteger (-6)
  -- 6
  --
  -- >>> negate (-6)
  -- 6
  negateInteger :: Integer -> Integer
  negateInteger = I.integerNegate
  
  -- | Used to implement `abs` for the `Num` typeclass.
  --   This gives the absolute value of whatever integer is passed into it.
  --
  -- ==== __Example__
  -- >>> absInteger (-6)
  -- 6
  --
  -- >>> abs (-6)
  -- 6
  absInteger :: Integer -> Integer
  absInteger = I.integerAbs
  
  -- | Used to implement `signum` for the `Num` typeclass.
  --   This gives 1 for a positive integer, and -1 for a negative integer.
  --
  -- ==== __Example__
  -- >>> signumInteger 5
  -- 1
  --
  -- >>> signum 5
  -- 1
  signumInteger :: Integer -> Integer
  signumInteger = I.integerSignum
  
  -- | Used to implement `divMod` for the `Integral` typeclass.
  --   This gives a tuple equivalent to
  --
  -- >(div x y, mod x y)
  --
  -- ==== __Example__
  -- >>> divModInteger 10 2
  -- (5,0)
  --
  -- >>> divMod 10 2
  -- (5,0)
  divModInteger :: Integer -> Integer -> (# Integer, Integer #)
  divModInteger = I.integerDivMod#
  
  -- | Used to implement `div` for the `Integral` typeclass.
  --   This performs integer division on its two parameters, truncated towards negative infinity.
  --
  -- ==== __Example__
  -- >>> 10 `divInteger` 2
  -- 5
  --
  -- >>> 10 `div` 2
  divInteger :: Integer -> Integer -> Integer
  divInteger = I.integerDiv
  
  -- | Used to implement `mod` for the `Integral` typeclass.
  --   This performs the modulo operation, satisfying
  --
  -- > ((x `div` y) * y) + (x `mod` y) == x
  --
  -- ==== __Example__
  -- >>> 7 `modInteger` 3
  -- 1
  --
  -- >>> 7 `mod` 3
  -- 1
  modInteger :: Integer -> Integer -> Integer
  modInteger = I.integerMod
  
  -- | Used to implement `quotRem` for the `Integral` typeclass.
  --   This gives a tuple equivalent to
  --
  -- > (quot x y, mod x y)
  --
  -- ==== __Example__
  -- >>> quotRemInteger 10 2
  -- (5,0)
  --
  -- >>> quotRem 10 2
  -- (5,0)
  quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
  quotRemInteger = I.integerQuotRem#
  
  -- | Used to implement `quot` for the `Integral` typeclass.
  --   This performs integer division on its two parameters, truncated towards zero.
  --
  -- ==== __Example__
  -- >>> quotInteger 10 2
  -- 5
  --
  -- >>> quot 10 2
  -- 5
  quotInteger :: Integer -> Integer -> Integer
  quotInteger = I.integerQuot
  
  -- | Used to implement `rem` for the `Integral` typeclass.
  --   This gives the remainder after integer division of its two parameters, satisfying
  --
  -- > ((x `quot` y) * y) + (x `rem` y) == x
  --
  -- ==== __Example__
  -- >>> remInteger 3 2
  -- 1
  --
  -- >>> rem 3 2
  -- 1
  remInteger :: Integer -> Integer -> Integer
  remInteger = I.integerRem
  
  -- | Used to implement `(==)` for the `Eq` typeclass.
  --   Outputs `True` if two integers are equal to each other.
  --
  -- ==== __Example__
  -- >>> 6 `eqInteger` 6
  -- True
  --
  -- >>> 6 == 6
  -- True
  eqInteger :: Integer -> Integer -> Bool
  eqInteger = I.integerEq
  
  -- | Used to implement `(/=)` for the `Eq` typeclass.
  --   Outputs `True` if two integers are not equal to each other.
  --
  -- ==== __Example__
  -- >>> 6 `neqInteger` 7
  -- True
  --
  -- >>> 6 /= 7
  -- True
  neqInteger :: Integer -> Integer -> Bool
  neqInteger = I.integerNe
  
  -- | Used to implement `(<=)` for the `Ord` typeclass.
  --   Outputs `True` if the first argument is less than or equal to the second.
  --
  -- ==== __Example__
  -- >>> 3 `leInteger` 5
  -- True
  --
  -- >>> 3 <= 5
  -- True
  leInteger :: Integer -> Integer -> Bool
  leInteger = I.integerLe
  
  -- | Used to implement `(>)` for the `Ord` typeclass.
  --   Outputs `True` if the first argument is greater than the second.
  --
  -- ==== __Example__
  -- >>> 5 `gtInteger` 3
  -- True
  --
  -- >>> 5 > 3
  -- True
  gtInteger :: Integer -> Integer -> Bool
  gtInteger = I.integerGt
  
  -- | Used to implement `(<)` for the `Ord` typeclass.
  --   Outputs `True` if the first argument is less than the second.
  --
  -- ==== __Example__
  -- >>> 3 `ltInteger` 5
  -- True
  --
  -- >>> 3 < 5
  -- True
  ltInteger :: Integer -> Integer -> Bool
  ltInteger = I.integerLt
  
  -- | Used to implement `(>=)` for the `Ord` typeclass.
  --   Outputs `True` if the first argument is greater than or equal to the second.
  --
  -- ==== __Example__
  -- >>> 5 `geInteger` 3
  -- True
  --
  -- >>> 5 >= 3
  -- True
  geInteger :: Integer -> Integer -> Bool
  geInteger = I.integerGe
  
  -- | Used to implement `compare` for the `Integral` typeclass.
  --   This takes two integers, and outputs whether the first is less than, equal to, or greater than the second.
  --
  -- ==== __Example__
  -- >>> compareInteger 2 10
  -- LT
  --
  -- >>> compare 2 10
  -- LT
  compareInteger :: Integer -> Integer -> Ordering
  compareInteger = I.integerCompare
  
  
  
  eqInteger# :: Integer -> Integer -> Int#
  eqInteger# = I.integerEq#
  
  neqInteger# :: Integer -> Integer -> Int#
  neqInteger# = I.integerNe#
  
  leInteger# :: Integer -> Integer -> Int#
  leInteger# = I.integerLe#
  
  gtInteger# :: Integer -> Integer -> Int#
  gtInteger# = I.integerGt#
  
  ltInteger# :: Integer -> Integer -> Int#
  ltInteger# = I.integerLt#
  
  geInteger# :: Integer -> Integer -> Int#
  geInteger# = I.integerGe#
  
  
  andInteger :: Integer -> Integer -> Integer
  andInteger = I.integerAnd
  
  orInteger :: Integer -> Integer -> Integer
  orInteger = I.integerOr
  
  xorInteger :: Integer -> Integer -> Integer
  xorInteger = I.integerXor
  
  complementInteger :: Integer -> Integer
  complementInteger = I.integerComplement
  
  shiftLInteger :: Integer -> Int# -> Integer
  shiftLInteger n i = I.integerShiftL# n (int2Word# i)
  
  shiftRInteger :: Integer -> Int# -> Integer
  shiftRInteger n i = I.integerShiftR# n (int2Word# i)
  
  testBitInteger :: Integer -> Int# -> Bool
  testBitInteger n i = isTrue# (I.integerTestBit# n (int2Word# i))
  
  hashInteger :: Integer -> Int#
  hashInteger = I.integerToInt#
  
  bitInteger :: Int# -> Integer
  bitInteger i = I.integerBit# (int2Word# i)
  
  popCountInteger :: Integer -> Int#
  popCountInteger = I.integerPopCount#
  
  