diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,39 @@ +# Version 0.6.0 + +* COMPILER ASSISTED BREAKING CHANGE: `KindInteger.Integer` is now + is now only ever used as a kind. So, all term-level functions in + the `KindInteger` consume and produce `Prelude.Integer`s. + +* COMPILER ASSISTED BREAKING CHANGE: Removed `Eq`, `Ord`, `Show` and + `Read` instances for `KindInteger.Integer`. + +* COMPILER ASSISTED BREAKING CHANGE: `Z` is now used to represent + zero, instead of the previous `P 0`. + +* COMPILER ASSISTED BREAKING CHANGE: `P 0` and `N 0` are not + `KnownInteger`s anymore. + +* COMPILER ASSISTED BREAKING CHANGE: `KnownInteger` is now a type-synonym + that implies `Normalized i ~ i` and `KnownNat (Abs i)` as well. + +* Added `readPrecTypeLit`. + +* Added `Normalized`. + +* Added `singletons-base` support for `Integer`, including `PNum`, `SNum`, + `PEq`, `SEq`, `POrd`, `SOrd`, `PShow` and `SShow`. Most arithmetic + functions are now exported through `PNum` and `SNum`, rather than standalone. + +* Added `ShowLit`, `ShowsLit`, `ShowsPrecLit` and its singletons and + promoted versions. + +* Added `Fold` and `sFold`. + +* Added defunctionalization symbols. + +* Added ZigZag encoding and decoding tools. + + # Version 0.5 * COMPILER ASSISTED BREAKING CHANGE: `integerVal`, `someIntegerVal`, diff --git a/kind-integer.cabal b/kind-integer.cabal --- a/kind-integer.cabal +++ b/kind-integer.cabal @@ -1,6 +1,6 @@ cabal-version: 2.4 name: kind-integer -version: 0.5 +version: 0.6.0 license: BSD-3-Clause license-file: LICENSE extra-source-files: README.md CHANGELOG.md @@ -23,9 +23,14 @@ common basic default-language: GHC2021 ghc-options: -O2 -Wall -Werror=incomplete-patterns - build-depends: base ==4.* + build-depends: + base ==4.*, + singletons, + singletons-base, default-extensions: DataKinds + DerivingStrategies + LambdaCase MultiWayIf NoStarIsType RoleAnnotations @@ -36,9 +41,9 @@ library import: basic - build-depends: singletons hs-source-dirs: lib exposed-modules: KindInteger + other-modules: KindInteger.Round test-suite test import: basic diff --git a/lib/KindInteger.hs b/lib/KindInteger.hs --- a/lib/KindInteger.hs +++ b/lib/KindInteger.hs @@ -1,764 +1,1282 @@ -{-# LANGUAGE UndecidableInstances #-} - --- | This module provides a type-level representation for term-level --- 'P.Integer's. This type-level representation is also named 'P.Integer', --- So import this module qualified to avoid name conflicts. --- --- @ --- import "KindInteger" qualified as KI --- @ --- --- The implementation details are the same as the ones for type-level 'Natural's --- in "GHC.TypeNats" as of @base-4.18@, and it will continue to evolve together --- with @base@, trying to follow its API as much as possible until the day --- @base@ provides its own type-level integer, making this module redundant. -module KindInteger {--} - ( -- * Integer kind - Integer - , type P - , type N - , Normalize - - -- * Prelude support - , toPrelude - , fromPrelude - , showsPrecTypeLit - - -- * Types ⇔ Terms - , KnownInteger(integerSing), integerVal - , SomeInteger(..) - , someIntegerVal - , sameInteger - - -- * Singletons - , SInteger - , pattern SInteger - , fromSInteger - , withSomeSInteger - , withKnownInteger - - -- * Arithmethic - , type (+), type (*), type (^), type (-) - , Odd, Even, Abs, Sign, Negate, GCD, LCM, Log2 - - -- ** Division - , Div - , Rem - , DivRem - , Round(..) - -- *** Term-level - , div - , rem - , divRem - - -- * Comparisons - , CmpInteger - , cmpInteger - , eqIntegerRep - - -- * Extra - , type (==?), type (==), type (/=?), type (/=) - ) --} - where - -import Control.Exception qualified as Ex -import Data.Bits -import Data.Proxy -import Data.Singletons -import Data.Singletons.Decide -import Data.Type.Bool (If) -import Data.Type.Coercion -import Data.Type.Equality (TestEquality(..)) -import Data.Type.Ord -import GHC.Base (WithDict(..)) -import GHC.Exts (TYPE, Constraint) -import GHC.Real qualified as P -import GHC.Show (appPrec, appPrec1) -import GHC.TypeLits qualified as L -import Numeric.Natural (Natural) -import Prelude hiding (Integer, (==), (/=), div, rem) -import Prelude qualified as P -import Unsafe.Coerce(unsafeCoerce) - --------------------------------------------------------------------------------- - --- | Type-level version of 'P.Integer', mostly used as a /kind/ for 'P' and 'N'. --- --- * A positive number /+x/ is represented as @'P' x@. --- --- * A negative number /-x/ is represented as @'N' x@. --- --- * /Zero/ can be represented as @'P' 0@ or @'N' 0@. For consistency, all --- /zero/ outputs from type families in this "KindInteger" module use the --- @'P' 0@, but don't assume that this will be the case elsewhere. So, if you --- need to treat /zero/ specially in some situation, be sure to handle both the --- @'P' 0@ and @'N' 0@ cases. --- --- __NB__: 'Integer' is mostly used as a kind, with its types constructed --- using 'P' and 'N'. However, it might also be used as type, with its terms --- constructed using 'fromPrelude'. One reason why you may want a 'Integer' --- at the term-level is so that you embed it in larger data-types (for example, --- the "KindRational" module from the --- [@kind-rational@](https://hackage.haskell.org/package/kind-rational) --- library embeds this 'I.Integer' in its 'KindRational.Rational' type). --- Contrary to "Prelude"'s 'P.Integer', "KindInteger"'s 'Integer' preserves --- the internal distinction between @'P' 0@ and @'N' 0@, this is why functions --- such as 'fromSInteger' prefer to use "KindInteger"'s 'Integer' rather --- than "Prelude"'s 'P.Integer'. -data Integer - = P_ Natural - | N_ Natural - --- | Note that @'P' 0 '==' 'N' 0@. -instance Eq Integer where - a == b = toPrelude a P.== toPrelude b - -instance Ord Integer where - compare a b = compare (toPrelude a) (toPrelude b) - a <= b = toPrelude a <= toPrelude b - --- | Same as "Prelude" 'P.Integer'. -instance Show Integer where - showsPrec p = showsPrec p . toPrelude - --- | Same as "Prelude" 'P.Integer'. -instance Read Integer where - readsPrec p xs = do (a, ys) <- readsPrec p xs - [(fromPrelude a, ys)] - --- | Shows the 'Integer' as it appears literally at the type-level. --- --- This is different from normal 'show' for 'Integer', which shows --- the term-level value. --- --- @ --- 'shows' 0 ('fromPrelude' 8) \"z\" == \"8z\" --- 'showsPrecTypeLit' 0 ('fromPrelude' 8) \"z\" == \"P 8z\" --- @ -showsPrecTypeLit :: Int -> Integer -> ShowS -showsPrecTypeLit p i = showParen (p > appPrec) $ case i of - P_ x -> showString "P " . shows x - N_ x -> showString "N " . shows x - --- | * A positive number /+x/ is represented as @'P' x@. --- --- * /Zero/ can be represented as @'P' 0@ (see notes at 'Integer'). -type P (x :: Natural) = 'P_ x :: Integer - --- | * A negative number /-x/ is represented as @'N' x@. --- --- * /Zero/ can be represented as @'N' 0@ (but often isn't, see notes at 'Integer'). -type N (x :: Natural) = 'N_ x :: Integer - --- | Convert a term-level "KindInteger" 'Integer' into a term-level --- "Prelude" 'P.Integer'. --- --- @ --- 'fromPrelude' . 'toPrelude' == 'id' --- 'toPrelude' . 'fromPrelude' == 'id' --- @ -toPrelude :: Integer -> P.Integer -toPrelude (P_ n) = toInteger n -toPrelude (N_ n) = negate (toInteger n) - --- | Obtain a term-level "KindInteger" 'Integer' from a term-level --- "Prelude" 'P.Integer'. This can fail if the "Prelude" 'P.Integer' is --- infinite, or if it is so big that it would exhaust system resources. --- --- @ --- 'fromPrelude' . 'toPrelude' == 'id' --- 'toPrelude' . 'fromPrelude' == 'id' --- @ --- --- This function can be handy if you are passing "KindInteger"'s 'Integer' --- around for some reason. But, other than this, "KindInteger" doesn't offer --- any tool to deal with the internals of its 'Integer'. -fromPrelude :: P.Integer -> Integer -fromPrelude i = if i >= 0 then P_ (fromInteger i) - else N_ (fromInteger (negate i)) - --------------------------------------------------------------------------------- - --- | This class gives the integer associated with a type-level integer. --- There are instances of the class for every integer. -class KnownInteger (i :: Integer) where - integerSing :: SInteger i - --- | Positive numbers and zero. -instance L.KnownNat x => KnownInteger (P x) where - integerSing = UnsafeSInteger (P_ (fromInteger (L.natVal (Proxy @x)))) - --- | Negative numbers and zero. --- --- Implementation note: Notice that @'N' 0@ will not be 'Normalize'd to --- @'P' 0@. This is so that 'SDecide', 'TestEquality' and 'TestCoercion' --- behave as expected. If you want a 'Normalize'd 'SInteger', then use --- @'integerSing' \@('Normalize' i)@. -instance L.KnownNat x => KnownInteger (N x) where - integerSing = UnsafeSInteger (N_ (fromInteger (L.natVal (Proxy @x)))) - --- | Term-level "KindRational" 'Integer' representation of the type-level --- 'Integer' @i@. -integerVal :: forall i proxy. KnownInteger i => proxy i -> Integer -integerVal _ = case integerSing :: SInteger i of UnsafeSInteger x -> x - --- | This type represents unknown type-level 'Integer'. -data SomeInteger = forall n. KnownInteger n => SomeInteger (Proxy n) - --- | Convert a term-level "KindInteger" 'Integer' into an unknown --- type-level 'Integer'. -someIntegerVal :: Integer -> SomeInteger -someIntegerVal i = withSomeSInteger i $ \(si :: SInteger i) -> - withKnownInteger si (SomeInteger @i Proxy) - --- | Note that @'P' 0 '==' 'N' 0@. -instance Eq SomeInteger where - SomeInteger x == SomeInteger y = integerVal x P.== integerVal y - -instance Ord SomeInteger where - compare (SomeInteger x) (SomeInteger y) = - compare (integerVal x) (integerVal y) - -instance Show SomeInteger where - showsPrec p (SomeInteger x) = showsPrec p (integerVal x) - -instance Read SomeInteger where - readsPrec p xs = do (a, ys) <- readsPrec p xs - [(someIntegerVal a, ys)] - --------------------------------------------------------------------------------- --- Within this module, we use these “normalization” tools to make sure that --- /zero/ is always represented as @'P' 0@. We don't export any of these --- normalization tools to end-users because it seems like we can't make them --- reliable enough so as to offer a decent user experience. So, we just tell --- users to deal with the fact that both @'P' 0@ and @'N' 0@ mean /zero/. - --- | Make sure /zero/ is represented as @'P' 0@, not as @'N' 0@ --- --- Notice that all the tools in the "KindInteger" can readily handle --- non-'Normalize'd inputs. This 'Normalize' type-family is offered offered --- only as a convenience in case you want to simplify /your/ dealing with --- /zeros/. -type family Normalize (i :: Integer) :: Integer where - Normalize (N 0) = P 0 - Normalize i = i - --- | Construct a 'Normalize'd 'N'egative type-level 'Integer'. --- --- To be used for producing all negative outputs in this module. -type NN (a :: Natural) = Normalize (N a) :: Integer - --------------------------------------------------------------------------------- - -infixl 6 +, - -infixl 7 *, `Div`, `Rem` -infixr 8 ^ - --- | Whether a type-level 'Natural' is odd. /Zero/ is not considered odd. -type Odd (x :: Integer) = L.Mod (Abs x) 2 ==? 1 :: Bool - --- | Whether a type-level 'Natural' is even. /Zero/ is considered even. -type Even (x :: Integer) = L.Mod (Abs x) 2 ==? 0 :: Bool - --- | Negation of type-level 'Integer's. -type family Negate (x :: Integer) :: Integer where - Negate (P 0) = P 0 - Negate (P x) = N x - Negate (N x) = P x - --- | Sign of type-level 'Integer's. --- --- * @'P' 0@ if zero. --- --- * @'P' 1@ if positive. --- --- * @'N' 1@ if negative. -type family Sign (x :: Integer) :: Integer where - Sign (P 0) = P 0 - Sign (N 0) = P 0 - Sign (P _) = P 1 - Sign (N _) = N 1 - --- | Absolute value of a type-level 'Integer', as a type-level 'Natural'. -type family Abs (x :: Integer) :: Natural where - Abs (P x) = x - Abs (N x) = x - --- | Addition of type-level 'Integer's. -type (a :: Integer) + (b :: Integer) = Add_ (Normalize a) (Normalize b) :: Integer -type family Add_ (a :: Integer) (b :: Integer) :: Integer where - Add_ (P a) (P b) = P (a L.+ b) - Add_ (N a) (N b) = NN (a L.+ b) - Add_ (P a) (N b) = If (b <=? a) (P (a L.- b)) (NN (b L.- a)) - Add_ (N a) (P b) = Add_ (P b) (N a) - --- | Multiplication of type-level 'Integer's. -type (a :: Integer) * (b :: Integer) = Mul_ (Normalize a) (Normalize b) :: Integer -type family Mul_ (a :: Integer) (b :: Integer) :: Integer where - Mul_ (P a) (P b) = P (a L.* b) - Mul_ (N a) (N b) = Mul_ (P a) (P b) - Mul_ (P a) (N b) = NN (a L.* b) - Mul_ (N a) (P b) = Mul_ (P a) (N b) - --- | Exponentiation of type-level 'Integer's. --- --- * Exponentiation by negative 'Integer' doesn't type-check. -type (a :: Integer) ^ (b :: Integer) = Pow_ (Normalize a) (Normalize b) :: Integer -type family Pow_ (a :: Integer) (b :: Integer) :: Integer where - Pow_ (P a) (P b) = P (a L.^ b) - Pow_ (N a) (P b) = NN (a L.^ b) - Pow_ _ (N _) = L.TypeError ('L.Text "KindInteger.(^): Negative exponent") - --- | Subtraction of type-level 'Integer's. -type (a :: Integer) - (b :: Integer) = a + Negate b :: Integer - --- | Get both the quotient and the 'Rem'ainder of the 'Div'ision of --- type-level 'Integer's @a@ and @b@ using the specified 'Round'ing @r@. --- --- @ --- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). --- (b '/=' 0) => --- 'DivRem' r a b '==' '('Div' r a b, 'Rem' r a b) --- @ -type DivRem (r :: Round) (a :: Integer) (b :: Integer) = - '( Div r a b, Rem r a b ) :: (Integer, Integer) - --- | 'Rem'ainder of the division of type-level 'Integer' @a@ by @b@, --- using the specified 'Round'ing @r@. --- --- @ --- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). --- (b '/=' 0) => --- 'Rem' r a b '==' a '-' b '*' 'Div' r a b --- @ --- --- * Division by /zero/ doesn't type-check. -type Rem (r :: Round) (a :: Integer) (b :: Integer) = - a - b * Div r a b :: Integer - --- | Divide of type-level 'Integer' @a@ by @b@, --- using the specified 'Round'ing @r@. --- --- * Division by /zero/ doesn't type-check. -type Div (r :: Round) (a :: Integer) (b :: Integer) = - Div_ r (Normalize a) (Normalize b) :: Integer - -type family Div_ (r :: Round) (a :: Integer) (b :: Integer) :: Integer where - Div_ r (P a) (P b) = Div__ r (P a) b - Div_ r (N a) (N b) = Div__ r (P a) b - Div_ r (P a) (N b) = Div__ r (N a) b - Div_ r (N a) (P b) = Div__ r (N a) b - -type family Div__ (r :: Round) (a :: Integer) (b :: Natural) :: Integer where - Div__ _ _ 0 = L.TypeError ('L.Text "KindInteger.Div: Division by zero") - Div__ _ (P 0) _ = P 0 - Div__ _ (N 0) _ = P 0 - - Div__ 'RoundDown (P a) b = P (L.Div a b) - Div__ 'RoundDown (N a) b = NN (If (b L.* L.Div a b ==? a) - (L.Div a b) - (L.Div a b L.+ 1)) - - Div__ 'RoundUp a b = Negate (Div__ 'RoundDown (Negate a) b) - - Div__ 'RoundZero (P a) b = Div__ 'RoundDown (P a) b - Div__ 'RoundZero (N a) b = Negate (Div__ 'RoundDown (P a) b) - - Div__ 'RoundAway (P a) b = Div__ 'RoundUp (P a) b - Div__ 'RoundAway (N a) b = Div__ 'RoundDown (N a) b - - Div__ 'RoundHalfDown a b = If (HalfLT (R a b) (Div__ 'RoundUp a b)) - (Div__ 'RoundUp a b) - (Div__ 'RoundDown a b) - - Div__ 'RoundHalfUp a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (Div__ 'RoundUp a b) - - Div__ 'RoundHalfEven a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (If (HalfLT (R a b) (Div__ 'RoundUp a b)) - (Div__ 'RoundUp a b) - (If (Even (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (Div__ 'RoundUp a b))) - - Div__ 'RoundHalfOdd a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (If (HalfLT (R a b) (Div__ 'RoundUp a b)) - (Div__ 'RoundUp a b) - (If (Odd (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (Div__ 'RoundUp a b))) - - Div__ 'RoundHalfZero a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) - (Div__ 'RoundDown a b) - (If (HalfLT (R a b) (Div__ 'RoundUp a b)) - (Div__ 'RoundUp a b) - (Div__ 'RoundZero a b)) - - Div__ 'RoundHalfAway (P a) b = Div__ 'RoundHalfUp (P a) b - Div__ 'RoundHalfAway (N a) b = Div__ 'RoundHalfDown (N a) b - - --- | Log base 2 ('floor'ed) of type-level 'Integer's. --- --- * Logarithm of /zero/ doesn't type-check. --- --- * Logarithm of negative number doesn't type-check. -type Log2 (a :: Integer) = Log2_ (Normalize a) :: Integer -type family Log2_ (a :: Integer) :: Integer where - Log2_ (P 0) = L.TypeError ('L.Text "KindInteger.Log2: Logarithm of zero") - Log2_ (P a) = P (L.Log2 a) - Log2_ (N a) = L.TypeError ('L.Text "KindInteger.Log2: Logarithm of negative number") - --- | Greatest Common Divisor of type-level 'Integer' numbers @a@ and @b@. --- --- Returns a 'Natural', since the Greatest Common Divisor is always positive. -type GCD (a :: Integer) (b :: Integer) = NatGCD (Abs a) (Abs b) :: Natural - --- | Greatest Common Divisor of type-level 'Natural's @a@ and @b@. -type family NatGCD (a :: Natural) (b :: Natural) :: Natural where - NatGCD a 0 = a - NatGCD a b = NatGCD b (L.Mod a b) - --- | Least Common Multiple of type-level 'Integer' numbers @a@ and @b@. --- --- Returns a 'Natural', since the Least Common Multiple is always positive. -type LCM (a :: Integer) (b :: Integer) = NatLCM (Abs a) (Abs b) :: Natural - --- | Least Common Multiple of type-level 'Natural's @a@ and @b@. -type NatLCM (a :: Natural) (b :: Natural) = - L.Div a (NatGCD a b) L.* b :: Natural - --------------------------------------------------------------------------------- - --- | Comparison of type-level 'Integer's, as a function. -type CmpInteger (a :: Integer) (b :: Integer) = - CmpInteger_ (Normalize a) (Normalize b) :: Ordering -type family CmpInteger_ (a :: Integer) (b :: Integer) :: Ordering where - CmpInteger_ a a = 'EQ - CmpInteger_ (P a) (P b) = Compare a b - CmpInteger_ (N a) (N b) = Compare b a - CmpInteger_ (N _) (P _) = 'LT - CmpInteger_ (P _) (N _) = 'GT - --- | "Data.Type.Ord" support for type-level 'Integer's. -type instance Compare (a :: Integer) (b :: Integer) = - CmpInteger a b :: Ordering - --------------------------------------------------------------------------------- - --- | We either get evidence that this function was instantiated with the --- same type-level 'Integer's, or 'Nothing'. -sameInteger - :: forall a b proxy1 proxy2 - . (KnownInteger a, KnownInteger b) - => proxy1 a - -> proxy2 b - -> Maybe (a :~: b) -sameInteger _ _ = testEquality (integerSing @a) (integerSing @b) - --- | Like 'sameInteger', but if the type-level 'Integer's aren't equal, this --- additionally provides proof of 'LT' or 'GT'. -cmpInteger - :: forall a b proxy1 proxy2 - . (KnownInteger a, KnownInteger b) - => proxy1 a - -> proxy2 b - -> OrderingI a b -cmpInteger x y = case compare (integerVal x) (integerVal y) of - EQ -> case unsafeCoerce Refl :: CmpInteger a b :~: 'EQ of - Refl -> case unsafeCoerce Refl :: a :~: b of - Refl -> EQI - LT -> case unsafeCoerce Refl :: (CmpInteger a b :~: 'LT) of - Refl -> LTI - GT -> case unsafeCoerce Refl :: (CmpInteger a b :~: 'GT) of - Refl -> GTI - --------------------------------------------------------------------------------- - --- | Singleton type for a type-level 'Integer' @i@. -newtype SInteger (i :: Integer) = UnsafeSInteger Integer -type role SInteger representational - --- | A explicitly bidirectional pattern synonym relating an 'SInteger' to a --- 'KnownInteger' constraint. --- --- As an __expression__: Constructs an explicit @'SInteger' i@ value from an --- implicit @'KnownInteger' i@ constraint: --- --- @ --- 'SInteger' @i :: 'KnownInteger' i => 'SInteger' i --- @ --- --- As a __pattern__: Matches on an explicit @'SInteger' i@ value bringing --- an implicit @'KnownInteger' i@ constraint into scope: --- --- @ --- f :: 'SInteger' i -> .. --- f SInteger = {- SInteger i in scope -} --- @ -pattern SInteger :: forall i. () => KnownInteger i => SInteger i -pattern SInteger <- (knownIntegerInstance -> KnownIntegeregerInstance) - where SInteger = integerSing - --- | An internal data type that is only used for defining the 'SInteger' pattern --- synonym. -data KnownIntegeregerInstance (i :: Integer) where - KnownIntegeregerInstance :: KnownInteger i => KnownIntegeregerInstance i - --- | An internal function that is only used for defining the 'SInteger' pattern --- synonym. -knownIntegerInstance :: SInteger i -> KnownIntegeregerInstance i -knownIntegerInstance si = withKnownInteger si KnownIntegeregerInstance - -instance Show (SInteger i) where - showsPrec p (UnsafeSInteger i) = showParen (p > appPrec) $ - showString "SInteger @" . showsPrecTypeLit appPrec1 i - --- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@ --- are not equal types, even if they are treated equally elsewhere in --- "KindInteger". -instance TestEquality SInteger where - testEquality = decideEquality - {-# INLINE testEquality #-} - --- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@ --- are not equal types, even if they are treated equally elsewhere in --- "KindInteger". -instance TestCoercion SInteger where - testCoercion = decideCoercion - {-# INLINE testCoercion #-} - --- | Return the term-level "KindInteger" 'Integer' number corresponding to @i@ --- in a @'SInteger' i@ value. -fromSInteger :: SInteger i -> Integer -fromSInteger (UnsafeSInteger i) = i -{-# INLINE fromSInteger #-} - --- | Whether the internal representation of the 'Integer's are equal. --- --- Note that this is not the same as '(P.==)'. Use '(P.==)' unless you --- know what you are doing. -eqIntegerRep :: Integer -> Integer -> Bool -eqIntegerRep (N_ l) (N_ r) = l P.== r -eqIntegerRep (P_ l) (P_ r) = l P.== r -eqIntegerRep _ _ = False -{-# INLINE eqIntegerRep #-} - --- | Convert an explicit @'SInteger' i@ value into an implicit --- @'KnownInteger' i@ constraint. -withKnownInteger - :: forall i rep (r :: TYPE rep). SInteger i -> (KnownInteger i => r) -> r -withKnownInteger = withDict @(KnownInteger i) - --- | Convert a "KindIiteger" 'Integer' number into an @'SInteger' n@ value, --- where @n@ is a fresh type-level 'Integer'. -withSomeSInteger - :: forall rep (r :: TYPE rep). Integer -> (forall n. SInteger n -> r) -> r -withSomeSInteger n k = k (UnsafeSInteger n) --- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats" -{-# NOINLINE withSomeSInteger #-} - --------------------------------------------------------------------------------- - -type instance Sing = SInteger - -instance KnownInteger i => SingI (i :: Integer) where - sing = integerSing - {-# INLINE sing #-} - --- | 'Demote' refers to "KindInteger"'s 'Integer' rather than "Prelude"'s --- 'Integer' so that the 'SInteger''s internal representation is preserved. --- Use 'toPrelude' and 'fromPrelude' as necessary. -instance SingKind Integer where - type Demote Integer = Integer - fromSing = fromSInteger - {-# INLINE fromSing #-} - toSing i = withSomeSInteger i SomeSing - {-# INLINE toSing #-} - --- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@ --- are not equal types, even if they are treated equally elsewhere in --- "KindInteger". -instance SDecide Integer where - UnsafeSInteger l %~ UnsafeSInteger r = - case eqIntegerRep l r of - True -> Proved (unsafeCoerce Refl) - False -> Disproved (\Refl -> error "SDecide.Integer") - --------------------------------------------------------------------------------- - -data Round - = RoundUp - -- ^ Round __up__ towards positive infinity. - | RoundDown - -- ^ Round __down__ towards negative infinity. Also known as "Prelude"'s - -- 'P.floor'. This is the type of rounding used by "Prelude"'s 'P.div', - -- 'P.mod', 'P.divMod', 'L.Div', 'L.Mod'. - | RoundZero - -- ^ Round towards __zero__. Also known as "Prelude"'s 'P.truncate'. This is - -- the type of rounding used by "Prelude"'s 'P.quot', 'P.rem', 'P.quotRem'. - | RoundAway - -- ^ Round __away__ from zero. - | RoundHalfUp - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round __up__ towards positive infinity. - | RoundHalfDown - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round __down__ towards negative infinity. - | RoundHalfZero - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round towards __zero__. - | RoundHalfAway - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round __away__ from zero. - | RoundHalfEven - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round towards the closest __even__ integer. Also known as "Prelude"'s - -- 'P.round'. - | RoundHalfOdd - -- ^ Round towards the closest integer. If __half__way between two integers, - -- round towards the closest __odd__ integer. - deriving (Eq, Ord, Show, Read, Enum, Bounded) - - --- | Divide @a@ by @a@ using the specified 'Round'ing. --- Return the quotient @q@. See 'divRem'. -div :: Round - -> P.Integer -- ^ Dividend @a@. - -> P.Integer -- ^ Divisor @b@. - -> P.Integer -- ^ Quotient @q@. -div r a b = fst (divRem r a b) - --- | Divide @a@ by @a@ using the specified 'Round'ing. --- Return the remainder @m@. See 'divRem'. -rem :: Round - -> P.Integer -- ^ Dividend @a@. - -> P.Integer -- ^ Divisor @b@. - -> P.Integer -- ^ Remainder @m@. -rem r a b = snd (divRem r a b) - --- | Divide @a@ by @a@ using the specified 'Round'ing. --- Return the quotient @q@ and the remainder @m@. --- --- @ --- forall (r :: 'Round') (a :: 'P.Integer') (b :: 'P.Integer'). --- (b 'P./=' 0) => --- case 'divRem' r a b of --- (q, m) -> m 'P.==' a 'P.-' b 'P.*' q --- @ -divRem - :: Round - -> P.Integer -- ^ Dividend @a@. - -> P.Integer -- ^ Divisor @b@. - -> (P.Integer, P.Integer) -- ^ Quotient @q@ and remainder @m@. -{-# NOINLINE divRem #-} -divRem RoundZero = \a (errDiv0 -> b) -> P.quotRem a b -divRem RoundDown = \a (errDiv0 -> b) -> P.divMod a b -divRem RoundUp = \a (errDiv0 -> b) -> _divRemRoundUpNoCheck a b -divRem RoundAway = \a (errDiv0 -> b) -> - if xor (a < 0) (b < 0) - then P.divMod a b - else _divRemRoundUpNoCheck a b -divRem RoundHalfUp = _divRemHalf $ \_ _ up -> up -divRem RoundHalfDown = _divRemHalf $ \_ down _ -> down -divRem RoundHalfZero = _divRemHalf $ \neg down up -> - if neg then up else down -divRem RoundHalfAway = _divRemHalf $ \neg down up -> - if neg then down else up -divRem RoundHalfEven = _divRemHalf $ \_ down up -> - if even (fst down) then down else up -divRem RoundHalfOdd = _divRemHalf $ \_ down up -> - if odd (fst down) then down else up - -_divRemRoundUpNoCheck :: P.Integer -> P.Integer -> (P.Integer, P.Integer) -_divRemRoundUpNoCheck a b = - let q = negate (P.div (negate a) b) - in (q, a - b * q) -{-# INLINE _divRemRoundUpNoCheck #-} - -_divRemHalf - :: (Bool -> - (P.Integer, P.Integer) -> - (P.Integer, P.Integer) -> - (P.Integer, P.Integer)) - -- ^ Negative -> divRem RoundDown -> divRem RoundDown -> Result - -> P.Integer -- ^ Dividend - -> P.Integer -- ^ Divisor - -> (P.Integer, P.Integer) -_divRemHalf f = \a (errDiv0 -> b) -> - let neg = xor (a < 0) (b < 0) - down = P.divMod a b - up = _divRemRoundUpNoCheck a b - in case compare (a P.% b - toRational (fst down)) (1 P.:% 2) of - LT -> down - GT -> up - EQ -> f neg down up -{-# INLINE _divRemHalf #-} - --------------------------------------------------------------------------------- --- Extras - -infixr 4 /=, /=?, ==, ==? - --- | This should be exported by "Data.Type.Ord". -type (a :: k) ==? (b :: k) = OrdCond (Compare a b) 'False 'True 'False :: Bool - --- | This should be exported by "Data.Type.Ord". -type (a :: k) == (b :: k) = (a ==? b) ~ 'True :: Constraint - --- | This should be exported by "Data.Type.Ord". -type (a :: k) /=? (b :: k) = OrdCond (Compare a b) 'True 'False 'True :: Bool - --- | This should be exported by "Data.Type.Ord". -type (a :: k) /= (b :: k) = (a /=? b) ~ 'True :: Constraint - --------------------------------------------------------------------------------- --- Rational tools - -data Rat = Rat Integer Natural - -type family R (n :: Integer) (d :: Natural) :: Rat where - R (P n) d = RatNormalize ('Rat (P n) d) - R (N n) d = RatNormalize ('Rat (N n) d) - -type family RatNormalize (r :: Rat) :: Rat where - RatNormalize ('Rat _ 0) = - L.TypeError ('L.Text "KindInteger: Denominator is 0") - RatNormalize ('Rat (P 0) _) = 'Rat (P 0) 1 - RatNormalize ('Rat (N 0) _) = 'Rat (P 0) 1 - RatNormalize ('Rat (P n) d) = 'Rat (P (L.Div n (NatGCD n d))) - (L.Div d (NatGCD n d)) - RatNormalize ('Rat (N n) d) = 'Rat (N (L.Div n (NatGCD n d))) - (L.Div d (NatGCD n d)) - -type family RatAbs (a :: Rat) :: Rat where - RatAbs ('Rat n d) = RatNormalize ('Rat (P (Abs n)) d) - -type RatAdd (a :: Rat) (b :: Rat) = - RatNormalize (RatAdd_ (RatNormalize a) (RatNormalize b)) :: Rat -type family RatAdd_ (a :: Rat) (b :: Rat) :: Rat where - RatAdd_ ('Rat an ad) ('Rat bn bd) = 'Rat (an * P bd + bn * P ad) (ad L.* bd) - -type family RatNegate (a :: Rat) :: Rat where - RatNegate ('Rat n d) = RatNormalize ('Rat (Negate n) d) - -type RatMinus (a :: Rat) (b :: Rat) = RatAdd a (RatNegate b) - -type instance Compare (a :: Rat) (b :: Rat) = RatCmp a b -type RatCmp (a :: Rat) (b :: Rat) = - RatCmp_ (RatNormalize a) (RatNormalize b) :: Ordering -type family RatCmp_ (a :: Rat) (b :: Rat) :: Ordering where - RatCmp_ a a = 'EQ - RatCmp_ ('Rat an ad) ('Rat bn bd) = CmpInteger (an * P bd) (bn * P ad) - --- | ''True' if the distance between @a@ and @b@ is less than /0.5/. -type HalfLT (a :: Rat) (b :: Integer) = - (RatAbs (RatMinus a ('Rat b 1))) P.Integer -errDiv0 0 = Ex.throw Ex.DivideByZero -errDiv0 i = i +{-# LANGUAGE StrictData #-} +{-# LANGUAGE TypeFamilyDependencies #-} +{-# LANGUAGE UndecidableInstances #-} + +-- | This module provides a type-level representation for term-level +-- 'P.Integer's. This type-level representation is also named 'P.Integer', +-- So import this module qualified to avoid name conflicts. +-- +-- @ +-- import "KindInteger" qualified as KI +-- @ +-- +-- The implementation details are similar to the ones for type-level 'Natural's +-- as of @base-4.18@ and @singletons-base-3.1.1@, and they will continue to +-- evolve together with @base@ and @singletons-base@, trying to more or less +-- follow their API. +module KindInteger {--} + ( -- * Integer + Integer + , type Z, pattern SZ + , type N, pattern SN + , type P, pattern SP + , FromNatural, sFromNatural + , Fold, sFold + -- * SInteger + , KnownInteger + , Normalized + , integerSing + , integerVal + , withKnownInteger + , SomeInteger(..) + , someIntegerVal + , SInteger + , pattern SInteger + , fromSInteger + , withSomeSInteger + -- * Proofs + , sNegateRefl + , sZigZagRefl + , sZagZigRefl + + -- * Show + -- + -- | Besides the following /\*Lit/ tools, 'P.PShow' and 'P.SShow' can + -- be used to display as "Prelude".'P.Integer' does. + , ShowLit, showLit, sShowLit + , ShowsLit, showsLit, sShowsLit + , ShowsPrecLit, showsPrecLit, sShowsPrecLit + , readPrecLit + + -- * Operations + -- + -- | Additional arithmetic operations are provided through the 'P.PNum' + -- and 'P.SNum' instances. Notably 'P.Abs', 'P.sAbs', 'P.Negate', + -- 'P.sNegate', 'P.Signum', 'P.sSignum', 'P.+', 'P.-', 'P.*', 'P.%+', + -- 'P.%-', 'P.%*'. + , type (^), (%^) + , Odd, sOdd + , Even, sEven + , Abs, sAbs + , GCD, sGCD + , LCM, sLCM + , Log2, sLog2 + , Div, sDiv, div + , Rem, sRem, rem + , DivRem, sDivRem, divRem + -- ** Rounding + , Round(..) + , SRound(..) + + -- * Comparisons + -- + -- | Additional comparison tools are available at 'SDdecide', + -- 'TestEquality', 'TestCoercion', 'P.PEq', 'P.SEq', 'P.POrd', 'P.SOrd' + -- and 'Compare'. + , cmpInteger + , sameInteger + + -- * Misc + , ZigZag, sZigZag + , ZagZig, sZagZig + + -- * Defunctionalization + , ZSym0 + , NSym0, NSym1 + , PSym0, PSym1 + , FromNaturalSym0, FromNaturalSym1 + , KnownIntegerSym0, KnownIntegerSym1 + , NormalizedSym0, NormalizedSym1 + , FoldSym0, FoldSym1, FoldSym2, FoldSym3, FoldSym4 + , type (^@#@$), type (^@#@$$), type (^@#@$$$) + , OddSym0, OddSym1 + , EvenSym0, EvenSym1 + , GCDSym0, GCDSym1 + , LCMSym0, LCMSym1 + , Log2Sym0, Log2Sym1 + , DivSym0, DivSym1, DivSym2, DivSym3 + , RemSym0, RemSym1, RemSym2, RemSym3 + , DivRemSym0, DivRemSym1, DivRemSym2, DivRemSym3 + , ShowLitSym0, ShowLitSym1 + , ShowsLitSym0, ShowsLitSym1, ShowsLitSym2 + , ShowsPrecLitSym0, ShowsPrecLitSym1, ShowsPrecLitSym2, ShowsPrecLitSym3 + , RoundUpSym0 + , RoundDownSym0 + , RoundZeroSym0 + , RoundAwaySym0 + , RoundHalfUpSym0 + , RoundHalfDownSym0 + , RoundHalfZeroSym0 + , RoundHalfAwaySym0 + , RoundHalfEvenSym0 + , RoundHalfOddSym0 + ) --} + where + +import Control.Applicative +import Control.Exception qualified as Ex +import Control.Monad +import Data.Bits +import Data.Bool.Singletons (SBool(..)) +import Data.Char qualified as Char +import Data.Eq.Singletons qualified as EqS +import Data.Maybe +import Data.Ord.Singletons qualified as OrdS +import Data.Proxy +import Data.Singletons +import Data.Singletons.Decide +import Data.String +import Data.Type.Bool (If) +import Data.Type.Coercion +import Data.Type.Equality (TestEquality(..)) +import Data.Type.Ord +import GHC.Base (WithDict(..)) +import GHC.Exts (TYPE, Constraint, coerce) +import GHC.Num.Integer (integerLog2) +import GHC.Real qualified as P +import GHC.Show (appPrec1) +import GHC.TypeLits qualified as L +import GHC.TypeLits.Singletons qualified as L hiding (natVal) +import Numeric.Natural (Natural) +import Prelude hiding (Show, Integer, (==), (/=), div, rem) +import Prelude qualified as P +import Prelude.Singletons qualified as P +import Text.ParserCombinators.ReadP qualified as ReadP +import Text.ParserCombinators.ReadPrec qualified as ReadPrec +import Text.Read qualified as Read +import Text.Show.Singletons (AppPrec1) +import Unsafe.Coerce (unsafeCoerce) + +import KindInteger.Round + +-------------------------------------------------------------------------------- + +-- | Type-level version of 'P.Integer', only used as a /kind/. +-- +-- * Zero is represented as t'Z'. +-- +-- * A positive number /+x/ is represented as @t'P' x@. +-- +-- * A negative number /-x/ is represented as @t'N' x@. + +-- __Note__: This representation is depressing. We hate it. It's not “total”, +-- because things such as @'N' 0@ and @'P' 0@ are not “valid”, and it's not +-- efficient, because we have to pay attention to three different constructors +-- rather than just one. The reason why we use this horrible representation +-- anyway is that type errors are easier to understand, since literals like +-- @'N' 2@ or 'Z' will show up in them. @'N' 0@ and @'P' 0@ will type-check +-- just fine on their own. However, tools in this module will reject them. For +-- example, there is no 'KnownInteger' instance for them, and 'Normalized' +-- will fail to type-check. Moreover, it is not possible to construct a +-- 'SInteger' for @'N' 0@ or @'P' 0@. If we could customize the way this +-- 'Integer' gets rendered in type-errors, we'd switch to a better internal +-- representation such as ZigZag. Also note that rather than exporting the +-- constructors directly, we export type-synonyms with the same name. This is +-- mostly so that users don't need to type the annoying preceeding tick. +data Integer + = Z -- ^ 0. + | N Natural -- ^ Guaranteed to be greater than 0 only after going through + -- 'KnownInteger', 'Normalized' or 'SInteger'. + | P Natural -- ^ Guaranteed to be greater than 0 only after going through + -- 'KnownInteger', 'Normalized' or 'SInteger'. + +-------------------------------------------------------------------------------- + +-- | Zero is represented as t'Z'. +type Z = 'Z :: Integer + +type ZSym0 :: Integer + +type ZSym0 = Z + +-- | A negative number /-x/ is represented as @t'N' x@. +-- +-- While a standalone @t'N' 0@ type-checks, it is not considered valid, +-- so tools like 'KnownInteger' or 'Normalized' will reject it. +-- @t'N' 0@ itself is not rejected so that it can be used to pattern-match +-- against 'Integer's at the type-level if necessary. +type N (x :: Natural) = 'N x :: Integer + +data NSym0 :: Natural ~> Integer +type NSym1 :: Natural -> Integer + +type instance Apply NSym0 x = NSym1 x +type NSym1 x = N x + +-- | A positive number /+x/ is represented as @t'P' x@. +-- +-- While a standalone @t'P' 0@ type-checks, it is not considered valid, +-- so tools like 'KnownInteger' or 'Normalized' will reject it. +-- @t'P' 0@ itself is not rejected so that it can be used to pattern-match +-- against 'Integer's at the type-level if necessary. +type P (x :: Natural) = 'P x :: Integer + +data PSym0 :: Natural ~> Integer +type PSym1 :: Natural -> Integer + +type instance Apply PSym0 x = PSym1 x +type PSym1 x = P x + +-------------------------------------------------------------------------------- + +-- | @'SZ' == 'sing' \@Z@ +pattern SZ :: SInteger Z +pattern SZ <- UnsafeSInteger _ + where SZ = UnsafeSInteger 0 +{-# COMPLETE SZ #-} + +-- | @'SP' ('sing' \@1) == 'sing' \@(P 1)@ +pattern SP :: (0 < x) + => (KnownInteger (P x), L.KnownNat x) + => Sing (x :: Natural) + -> SInteger (P x) +pattern SP x <- (patternSP -> PatternSI x) + where SP = UnsafeSInteger . toInteger . fromSing +{-# COMPLETE SP #-} + +-- | @'SN' ('sing' \@1) == 'sing' \@(N 1)@ +pattern SN :: (0 < x) + => (KnownInteger (N x), L.KnownNat x) + => Sing (x :: Natural) + -> SInteger (N x) +pattern SN x <- (patternSN -> PatternSI x) + where SN = UnsafeSInteger . negate . toInteger . fromSing +{-# COMPLETE SN #-} + +-- | Internal. Used to implement 'SP' and 'SN'. +data PatternSI i n = (KnownInteger i, L.KnownNat n) => PatternSI (Sing n) + +patternSI :: SInteger i -> PatternSI i (Abs i) +patternSI si@SInteger | sa <- sAbs si = L.withKnownNat sa (PatternSI sa) + +patternSN :: SInteger (N x) -> PatternSI (N x) x +patternSN = unsafeCoerce . patternSI + +patternSP :: SInteger (P x) -> PatternSI (P x) x +patternSP = unsafeCoerce . patternSI + +-------------------------------------------------------------------------------- + +-- | @'Fold' z n p i@ evaluates to @z@ if @i@ is zero, otherwise applies @n@ to +-- the absolute value of @i@ if negative, or @p@ to the absolute value of @i@ if +-- positive. @t'N' 0@ and @t'P' 0@ fail to type-check. +type family Fold + (z :: k) + (n :: Natural ~> k) + (p :: Natural ~> k) + (i :: Integer) + :: k where + Fold _ _ _ (N 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘N 0’.") + Fold _ _ _ (P 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘P 0’.") + Fold z _ _ Z = z + Fold _ n _ (N x) = n @@ x + Fold _ _ p (P x) = p @@ x + +data FoldSym0 :: k ~> (Natural ~> k) ~> (Natural ~> k) ~> Integer ~> k +data FoldSym1 :: k -> (Natural ~> k) ~> (Natural ~> k) ~> Integer ~> k +data FoldSym2 :: k -> (Natural ~> k) -> (Natural ~> k) ~> Integer ~> k +data FoldSym3 :: k -> (Natural ~> k) -> (Natural ~> k) -> Integer ~> k +type FoldSym4 :: k -> (Natural ~> k) -> (Natural ~> k) -> Integer -> k + +type instance Apply FoldSym0 z = FoldSym1 z +type instance Apply (FoldSym1 z) n = FoldSym2 z n +type instance Apply (FoldSym2 z n) p = FoldSym3 z n p +type instance Apply (FoldSym3 z n p) i = FoldSym4 z n p i +type FoldSym4 z n p i = Fold z n p i + +-- | Singleton version of 'Fold'. +sFold + :: SingKind k + => Sing (z :: k) + -> Sing (n :: Natural ~> k) + -> Sing (p :: Natural ~> k) + -> SInteger i + -> Sing (Fold z n p i) +sFold sz sn sp si = + case compare (fromSing si) 0 of + EQ -> unsafeCoerce sz + LT -> unsafeCoerce (sn @@ sAbs si) + GT -> unsafeCoerce (sp @@ sAbs si) + +-------------------------------------------------------------------------------- + +-- | Displays @i@ as it would show literally as a term. +-- +-- @ +-- 'P.Show_' ( t'N' 1) ~ \"-1\" +-- 'P.Show_' t'Z' ~ \"0\" +-- 'P.Show_' ( t'P' 1) ~ \"1\" +-- @ +-- +-- @t'N' 0@ and @t'P' 0@ fail to type-check. +instance P.PShow Integer where + type ShowsPrec p i s = ShowsPrec_ p (Normalized i) s + +type ShowsPrec_ :: Natural -> Integer -> L.Symbol -> L.Symbol +type family ShowsPrec_ p i s where + ShowsPrec_ _ Z s = P.Shows 0 s + ShowsPrec_ p (N x) s = + P.ShowParen (p P.>= AppPrec1) (P.ShowCharSym1 '-' P..@#@$$$ P.ShowsSym1 x) s + ShowsPrec_ _ (P x) s = P.Shows x s + +-- | Displays @i@ as it would show literally as a term. +-- +-- @ +-- 'fromSing' \@('P.sShow_' ('SN' ('sing' \@1))) == \"-1\" +-- 'fromSing' \@('P.sShow_' 'SZ') == \"0\" +-- 'fromSing' \@('P.sShow_' ('SP' ('sing' \@1))) == \"1\" +-- @ +instance P.SShow Integer where + sShowsPrec _ si ss = + withSomeSing (fromString (show (fromSing si)) <> fromSing ss) unsafeCoerce + +-------------------------------------------------------------------------------- + +-- | Displays @i@ as it would show literally as a type. +-- +-- @ +-- 'P.ShowLit' ( t'N' 1) ~ \"P 1\" +-- 'P.ShowLit' t'Z' ~ \"Z\" +-- 'P.ShowLit' ( t'P' 1) ~ \"P 1\" +-- @ +-- +-- @t'N' 0@ and @t'P' 0@ fail to type-check. +type ShowLit (i :: Integer) = ShowsLit i "" :: L.Symbol + +data ShowLitSym0 :: Integer ~> L.Symbol +type ShowLitSym1 :: Integer -> L.Symbol + +type instance Apply ShowLitSym0 i = ShowLitSym1 i +type ShowLitSym1 i = ShowLit i + +-- | Displays @i@ as it would show literally as a type. See 'ShowLit. +-- Behaves like 'P.Shows'. +type ShowsLit (i :: Integer) (s :: L.Symbol) = ShowsPrecLit 0 i s :: L.Symbol + +data ShowsLitSym0 :: Integer ~> L.Symbol ~> L.Symbol +data ShowsLitSym1 :: Integer -> L.Symbol ~> L.Symbol +type ShowsLitSym2 :: Integer -> L.Symbol -> L.Symbol + +type instance Apply ShowsLitSym0 i = ShowsLitSym1 i +type instance Apply (ShowsLitSym1 i) s = ShowsLitSym2 i s +type ShowsLitSym2 i s = ShowsLit i s + +-- | Displays @i@ as it would show literally as a type. See 'ShowLit. +-- Behaves like 'P.ShowsPrec'. +type ShowsPrecLit :: Natural -> Integer -> L.Symbol -> L.Symbol +type ShowsPrecLit p i s = ShowsPrecLit_ p (Normalized i) s + +type ShowsPrecLit_ :: Natural -> Integer -> L.Symbol -> L.Symbol +type family ShowsPrecLit_ p i s where + ShowsPrecLit_ _ Z s = P.ShowString "Z" s + ShowsPrecLit_ p (N n) s = + P.ShowParen (p P.>= 11) (P.ShowStringSym1 "N " P..@#@$$$ P.ShowsSym1 n) s + ShowsPrecLit_ p (P n) s = + P.ShowParen (p P.>= 11) (P.ShowStringSym1 "P " P..@#@$$$ P.ShowsSym1 n) s + +data ShowsPrecLitSym0 :: Natural ~> Integer ~> L.Symbol ~> L.Symbol +data ShowsPrecLitSym1 :: Natural -> Integer ~> L.Symbol ~> L.Symbol +data ShowsPrecLitSym2 :: Natural -> Integer -> L.Symbol ~> L.Symbol +type ShowsPrecLitSym3 :: Natural -> Integer -> L.Symbol -> L.Symbol + +type instance Apply ShowsPrecLitSym0 p = ShowsPrecLitSym1 p +type instance Apply (ShowsPrecLitSym1 p) i = ShowsPrecLitSym2 p i +type instance Apply (ShowsPrecLitSym2 p i) s = ShowsPrecLitSym3 p i s +type ShowsPrecLitSym3 p i s = ShowsPrecLit p i s + +-- | Singleton version of 'ShowLit'. +-- +-- @ +-- 'fromSing' \@('sShowLit' ('SN' ('sing' \@1))) == \"N 1\" +-- 'fromSing' \@('sShowLit' 'SZ') == \"Z" +-- 'fromSing' \@('sShowLit' ('SP' ('sing' \@1))) == \"P 1\" +-- @ +sShowLit :: SInteger i -> Sing (ShowLit i) +sShowLit si = sShowsLit si (sing @"") + +-- | Demoted version of 'ShowLit'. +showLit :: P.Integer -> String +showLit i = showsLit i "" + +-- | Singleton version of 'ShowsLit'. +sShowsLit :: SInteger i -> Sing (s :: P.Symbol) -> Sing (ShowsLit i s) +sShowsLit = sShowsPrecLit (sing @0) + +-- | Demoted version of 'ShowsLit'. +showsLit :: P.Integer -> ShowS +showsLit = showsPrecLit 0 + +-- | Singleton version of 'ShowsPrecLit'. +sShowsPrecLit + :: Sing (p :: Natural) -> SInteger i -> Sing (s :: P.Symbol) + -> Sing (ShowsPrecLit p i s) +sShowsPrecLit sp si ss = + let p = fromMaybe (error "sShowsPrecLit: invalid precedence") + (toIntegralSized (fromSing sp)) + t = fromString (showsPrecLit p (fromSing si) "") + in withSomeSing (t <> fromSing ss) unsafeCoerce + +-- | Demoted version of 'ShowsPrecLit'. +showsPrecLit :: Int -> P.Integer -> ShowS +showsPrecLit p | p < 0 = error "showsPrecLit: negative precedence" +showsPrecLit p = \case + 0 -> showChar 'Z' + i | i > 0 -> showParen (p >= appPrec1) (showString "P " . shows i) + i -> showParen (p >= appPrec1) (showString "N " . shows (abs i)) + +-- | Inverse of 'showsPrecLit'. +readPrecLit :: ReadPrec.ReadPrec P.Integer +readPrecLit = Read.parens $ asum + [ 0 <$ ReadPrec.lift (ReadP.char 'Z') + , do ReadPrec.lift $ ReadP.char 'N' >> pSkipSpaces1 + n <- Read.parens (ReadPrec.lift pNatural) + guard (n P./= 0) + pure $ negate $ fromIntegral n + , do ReadPrec.lift $ ReadP.char 'P' >> pSkipSpaces1 + n <- Read.parens (ReadPrec.lift pNatural) + guard (n P./= 0) + pure $ fromIntegral n + ] + where + pNatural :: ReadP.ReadP Natural + pNatural = read <$> ReadP.munch1 (\c -> c >= '0' && c <= '9') + +-------------------------------------------------------------------------------- + +-- | This class gives the 'SInteger' associated with a type-level 'Integer'. +class KnownInteger_ (i :: Integer) where + integerSing_ :: SInteger i + +-- | Type-level 'Integer's satisfying 'KnownInteger' can be converted to +-- 'SInteger's using 'integerSing'. Every 'Integer' other than @'N' 0@ and +-- @'P' 0@ are 'KnownInteger's. + +-- Note: Ideally, the constraints mentioned here would be superclasses to +-- 'KnownInteger_'. However, 'withDict' doesn't allow having a superclass +-- there, so we treat 'KnownInteger_' as internal an export 'KnownInteger' only. +-- The 'KnownNat (Abs i)' constraint is listed here as a convenience, seeing +-- as it is necessary to implement 'KnownInteger_' anyway. +type KnownInteger (i :: Integer) = + (KnownInteger_ i, Normalized i ~ i, L.KnownNat (Abs i)) + +data KnownIntegerSym0 :: Integer ~> Constraint +type KnownIntegerSym1 :: Integer -> Constraint + +type instance Apply KnownIntegerSym0 i = KnownIntegerSym1 i +type KnownIntegerSym1 i = KnownInteger i + +-- | Convert an implicit 'KnownInteger' to an explicit 'SInteger'. +integerSing :: KnownInteger i => SInteger i +integerSing = integerSing_ -- The difference is in the constraint. +{-# INLINE integerSing #-} + +instance KnownInteger_ Z where + integerSing_ = UnsafeSInteger 0 + {-# INLINE integerSing_ #-} + +instance (KnownInteger (N n), n ~ Abs (N n)) => KnownInteger_ (N n) where + integerSing_ = UnsafeSInteger $! P.negate (L.natVal (Proxy @n)) + {-# INLINE integerSing_ #-} + +instance (KnownInteger (P n), n ~ Abs (P n)) => KnownInteger_ (P n) where + integerSing_ = UnsafeSInteger $! L.natVal (Proxy @n) + {-# INLINE integerSing_ #-} + +-- | @'Normalized' i@ is an identity function that fails to type-check +-- if @i@ is not in normalized form. That is, /zero/ is represented with t'Z', +-- not with @t'P' 0@ or @ t'N' 0@. +type family Normalized (i :: Integer) :: Integer where + Normalized (N 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘N 0’.") + Normalized (P 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘P 0’.") + Normalized i = i + +data NormalizedSym0 :: Integer ~> Integer +type NormalizedSym1 :: Integer -> Integer + +type instance Apply NormalizedSym0 i = Normalized i +type NormalizedSym1 i = Normalized i + +-- | 'SInteger' contains only 'Normalized' integers. +sNormalizedRefl :: SInteger i -> (i :~: Normalized i) +sNormalizedRefl !_ = unsafeCoerce Refl + +-- | Term-level "Prelude".'P.Integer' representation of the type-level +-- 'Integer'. +integerVal :: forall i proxy. KnownInteger i => proxy i -> P.Integer +integerVal _ = case integerSing_ :: SInteger i of UnsafeSInteger x -> x +{-# INLINE integerVal #-} + +-- | Term-level representation of an existentialized 'KnownInteger'. +data SomeInteger = forall i. KnownInteger i => SomeInteger (Proxy i) + +-- | Convert a term-level "Prelude".'P.Integer' into an +-- extistentialized 'KnownInteger' wrapped in 'SomeInteger'. +someIntegerVal :: P.Integer -> SomeInteger +someIntegerVal = \i -> + withSomeSInteger i $ \(si :: SInteger i) -> + withKnownInteger si $ SomeInteger (Proxy @i) + +instance Eq SomeInteger where + SomeInteger x == SomeInteger y = + integerVal x P.== integerVal y + {-# INLINE (==) #-} + +instance Ord SomeInteger where + compare (SomeInteger x) (SomeInteger y) = + compare (integerVal x) (integerVal y) + {-# INLINE compare #-} + +-- | As for "Prelude".'P.Integer'. +instance P.Show SomeInteger where + showsPrec p (SomeInteger i) = + showsPrec p (integerVal i) + +-- | As for "Prelude".'P.Integer'. +instance Read SomeInteger where + readPrec = fmap someIntegerVal Read.readPrec + +-------------------------------------------------------------------------------- + +-- | Construct a type-level 'Integer' from a type-level 'Natural'. +type family FromNatural (x :: Natural) :: Integer where + FromNatural 0 = Z + FromNatural x = P x + +data FromNaturalSym0 :: Natural ~> Integer +type FromNaturalSym1 :: Natural -> Integer + +type instance Apply FromNaturalSym0 i = FromNatural i +type FromNaturalSym1 i = FromNatural i + +-- | Singleton version of 'FromNatural'. +sFromNatural :: Sing (x :: Natural) -> SInteger (FromNatural x) +sFromNatural = UnsafeSInteger . toInteger . fromSing +{-# INLINE sFromNatural #-} + +-------------------------------------------------------------------------------- + +-- | Demoted version of 'ZigZag'. +zigZag :: P.Integer -> Natural +zigZag 0 = 0 +zigZag i = fromInteger (if i < 0 then abs i * 2 - 1 else i * 2) + +-- | Singleton version of 'ZigZag'. +sZigZag :: SInteger i -> Sing (ZigZag i :: Natural) +sZigZag si = withSomeSing @Natural (zigZag (fromSing si)) unsafeCoerce + +-- | Identity. +sZigZagRefl :: SInteger i -> (i :~: ZagZig (ZigZag i)) +sZigZagRefl !_ = unsafeCoerce Refl + +-- | Demoted version of 'ZagZig'. +zagZig :: Natural -> P.Integer +zagZig 0 = 0 +zagZig n = if odd n then P.negate (P.toInteger (P.div (n + 1) 2)) + else P.toInteger (P.div n 2) + +-- | Singleton version of 'ZagZig'. +sZagZig :: Sing (n :: Natural) -> SInteger (ZagZig n) +sZagZig = UnsafeSInteger . zagZig . fromSing + +-- | Identity. +sZagZigRefl :: Sing (n :: Natural) -> (n :~: ZigZag (ZagZig n)) +sZagZigRefl !_ = unsafeCoerce Refl + +-- | ZigZag encoding of an 'Integer'. +-- +-- * /0/ is /0/ +-- +-- * /-x/ is /abs(x) * 2 - 1/ +-- +-- * /+x/ is /x * 2/ +type ZigZag :: Integer -> Natural +type ZigZag (i :: Integer) = ZigZag_ (Normalized i) :: Natural +type family ZigZag_ (i :: Integer) :: Natural where + ZigZag_ Z = 0 + ZigZag_ (P x) = x P.* 2 + ZigZag_ (N x) = x P.* 2 P.- 1 + +data ZigZagSym0 :: Integer ~> Natural +type ZigZagSym1 :: Integer -> Natural + +type instance Apply ZigZagSym0 i = ZigZagSym1 i +type ZigZagSym1 i = ZigZag i + +-- | Inverse of 'ZigZag'. +type ZagZig :: Natural -> Integer +type ZagZig n = If (L.Mod n 2 P.== 1) + (P.Negate (FromNatural (L.Div (n L.+ 1) 2))) + (FromNatural (L.Div n 2)) + +data ZagZigSym0 :: Natural ~> Integer +type ZagZigSym1 :: Natural -> Integer + +type instance Apply ZagZigSym0 n = ZagZigSym1 n +type ZagZigSym1 n = ZagZig n + +-------------------------------------------------------------------------------- + + +-- | Whether a type-level 'Integer' is odd. /Zero/ is not considered odd. +type Odd (i :: Integer) = L.Mod (Abs i) 2 P.== 1 :: Bool + +data OddSym0 :: Integer ~> Bool +type OddSym1 :: Integer -> Bool + +type instance Apply OddSym0 i = Odd i +type OddSym1 i = Odd i + +-- | Singleton version of 'Odd'. +sOdd :: SInteger i -> Sing (Odd i :: Bool) +sOdd si | odd (fromSing si) = unsafeCoerce STrue + | otherwise = unsafeCoerce SFalse + +-- | Whether a type-level 'Integer' is even. /Zero/ is considered even. +type Even (i :: Integer) = L.Mod (Abs i) 2 P.== 0 :: Bool + +data EvenSym0 :: Integer ~> Bool +type EvenSym1 :: Integer -> Bool + +type instance Apply EvenSym0 i = Even i +type EvenSym1 i = Even i + +-- | Singleton version of 'Even'. +sEven :: SInteger i -> Sing (Even i :: Bool) +sEven si | even (fromSing si) = unsafeCoerce STrue + | otherwise = unsafeCoerce SFalse + +-------------------------------------------------------------------------------- + +-- | Double negation is identity. +sNegateRefl :: SInteger i -> (i :~: P.Negate (P.Negate i)) +sNegateRefl !_ = unsafeCoerce Refl + +-------------------------------------------------------------------------------- + +-- | Absolute value of a type-level 'Integer', as a type-level 'Natural'. +type Abs (i :: Integer) = Fold 0 P.IdSym0 P.IdSym0 i :: Natural + +data AbsSym0 :: Integer ~> Natural +type AbsSym1 :: Integer -> Natural + +type instance Apply AbsSym0 x = AbsSym1 x +type AbsSym1 x = Abs x + +-- | Singleton version of 'Abs'. +sAbs :: SInteger i -> Sing (Abs i :: Natural) +sAbs si = withSomeSing @Natural (fromInteger (abs (fromSing si))) unsafeCoerce + +-------------------------------------------------------------------------------- + +infixr 8 %^, ^, ^@#@$$$ + +-- | Singleton version of '^'. +(%^) :: Sing (b :: Integer) -> Sing (p :: Natural) -> Sing (b ^ p :: Integer) +sb %^ sp = UnsafeSInteger (fromSing sb ^ fromSing sp) +{-# INLINE (%^) #-} + +-- | Exponentiation of type-level 'Integer's. +type (b :: Integer) ^ (p :: Natural) = Pow (Normalized b) p :: Integer + +data (^@#@$) :: Integer ~> Natural ~> Integer +data (^@#@$$) :: Integer -> Natural ~> Integer +type (^@#@$$$) :: Integer -> Natural -> Integer + +type instance Apply ((^@#@$$) b) p = (^@#@$$$) b p +type instance Apply (^@#@$) b = (^@#@$$) b +type (^@#@$$$) b p = b ^ p + +type family Pow (b :: Integer) (p :: Natural) :: Integer where + Pow _ 0 = P 1 + Pow Z _ = Z + Pow (P b) p = FromNatural (b L.^ p) + Pow (N b) p = FromNatural (b L.^ p) P.* If (Even (P p)) (P 1) (N 1) + +-------------------------------------------------------------------------------- + +infixl 7 `Div`, `Rem`, `DivRem` + +-- | Get both the quotient and the 'Rem'ainder of the 'Div'ision of +-- type-level 'Integer's @a@ and @b@ using the specified 'Round'ing @r@. +-- +-- @ +-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). +-- (b '/=' 0) => +-- 'DivRem' r a b '==' '('Div' r a b, 'Rem' r a b) +-- @ +type DivRem (r :: Round) (a :: Integer) (b :: Integer) = + '( Div r a b, Rem r a b ) :: (Integer, Integer) + +data DivRemSym0 :: Round ~> Integer ~> Integer ~> (Integer, Integer) +data DivRemSym1 :: Round -> Integer ~> Integer ~> (Integer, Integer) +data DivRemSym2 :: Round -> Integer -> Integer ~> (Integer, Integer) +type DivRemSym3 :: Round -> Integer -> Integer -> (Integer, Integer) + +type instance Apply DivRemSym0 r = DivRemSym1 r +type instance Apply (DivRemSym1 r) a = DivRemSym2 r a +type instance Apply (DivRemSym2 r a) b = DivRemSym3 r a b +type DivRemSym3 r a b = DivRem r a b + +-------------------------------------------------------------------------------- + +-- | 'Rem'ainder of the division of type-level 'Integer' @a@ by @b@, +-- using the specified 'Round'ing @r@. +-- +-- @ +-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). +-- (b '/=' 0) => +-- 'Rem' r a b '==' a '-' b '*' 'Div' r a b +-- @ +-- +-- * Division by /zero/ doesn't type-check. +type Rem (r :: Round) (a :: Integer) (b :: Integer) = + Rem_ r (Normalized a) (Normalized b) :: Integer +type Rem_ (r :: Round) (a :: Integer) (b :: Integer) = + a P.- b P.* Div r a b :: Integer + +data RemSym0 :: Round ~> Integer ~> Integer ~> Integer +data RemSym1 :: Round -> Integer ~> Integer ~> Integer +data RemSym2 :: Round -> Integer -> Integer ~> Integer +type RemSym3 :: Round -> Integer -> Integer -> Integer + +type instance Apply RemSym0 r = RemSym1 r +type instance Apply (RemSym1 r) a = RemSym2 r a +type instance Apply (RemSym2 r a) b = RemSym3 r a b +type RemSym3 r a b = Rem r a b + +-- | Demoted version of 'Rem'. +-- +-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check. +rem :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> P.Integer -- ^ Remainder @m@. +rem r a b = snd (divRem r a b) + +-- | Singleton version of 'Rem'. +sRem :: SRound r + -> SInteger a -- ^ Dividend. + -> SInteger b -- ^ Divisor. + -> SInteger (Rem r a b) +sRem sr sa sb = snd (sDivRem sr sa sb) + +-------------------------------------------------------------------------------- + +-- | Divide the type-level 'Integer' @a@ by @b@, +-- using the specified 'Round'ing @r@. +-- +-- * Division by /zero/ doesn't type-check. +type Div (r :: Round) (a :: Integer) (b :: Integer) = + Div_ r (Normalized a) (Normalized b) :: Integer +type family Div_ (r :: Round) (a :: Integer) (b :: Integer) :: Integer where + Div_ r Z Z = Div__ r Z 0 + Div_ r Z (P b) = Div__ r Z b + Div_ r Z (N b) = Div__ r Z b + Div_ r (P a) (P b) = Div__ r (P a) b + Div_ r (N a) (N b) = Div__ r (P a) b + Div_ r (P a) (N b) = Div__ r (N a) b + Div_ r (N a) (P b) = Div__ r (N a) b + +data DivSym0 :: Round ~> Integer ~> Integer ~> Integer +data DivSym1 :: Round -> Integer ~> Integer ~> Integer +data DivSym2 :: Round -> Integer -> Integer ~> Integer +type DivSym3 :: Round -> Integer -> Integer -> Integer + +type instance Apply DivSym0 r = DivSym1 r +type instance Apply (DivSym1 r) a = DivSym2 r a +type instance Apply (DivSym2 r a) b = DivSym3 r a b +type DivSym3 r a b = Div r a b + +type family Div__ (r :: Round) (a :: Integer) (b :: Natural) :: Integer where + Div__ _ _ 0 = L.TypeError ('L.Text "Division by zero") + Div__ _ Z _ = Z + + Div__ 'RoundDown (P a) b = FromNatural (L.Div a b) + Div__ 'RoundDown (N a) b = P.Negate (FromNatural (If (b L.* L.Div a b P.== a) + (L.Div a b) + (L.Div a b L.+ 1))) + + Div__ 'RoundUp a b = P.Negate (Div__ 'RoundDown (P.Negate a) b) + + Div__ 'RoundZero (P a) b = Div__ 'RoundDown (P a) b + Div__ 'RoundZero (N a) b = P.Negate (Div__ 'RoundDown (P a) b) + + Div__ 'RoundAway (P a) b = Div__ 'RoundUp (P a) b + Div__ 'RoundAway (N a) b = Div__ 'RoundDown (N a) b + + Div__ 'RoundHalfDown a b = If (HalfLT (R a b) (Div__ 'RoundUp a b)) + (Div__ 'RoundUp a b) + (Div__ 'RoundDown a b) + + Div__ 'RoundHalfUp a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (Div__ 'RoundUp a b) + + Div__ 'RoundHalfEven a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (If (HalfLT (R a b) (Div__ 'RoundUp a b)) + (Div__ 'RoundUp a b) + (If (Even (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (Div__ 'RoundUp a b))) + + Div__ 'RoundHalfOdd a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (If (HalfLT (R a b) (Div__ 'RoundUp a b)) + (Div__ 'RoundUp a b) + (If (Odd (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (Div__ 'RoundUp a b))) + + Div__ 'RoundHalfZero a b = If (HalfLT (R a b) (Div__ 'RoundDown a b)) + (Div__ 'RoundDown a b) + (If (HalfLT (R a b) (Div__ 'RoundUp a b)) + (Div__ 'RoundUp a b) + (Div__ 'RoundZero a b)) + + Div__ 'RoundHalfAway (P a) b = Div__ 'RoundHalfUp (P a) b + Div__ 'RoundHalfAway (N a) b = Div__ 'RoundHalfDown (N a) b + +-- | Demoted version of 'Div'. +-- +-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check. +div :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> P.Integer -- ^ Quotient @q@. +div r a b = fst (divRem r a b) + +-- | Singleton version of 'Div'. +sDiv :: SRound r + -> SInteger a -- ^ Dividend. + -> SInteger b -- ^ Divisor. + -> SInteger (Div r a b) +sDiv sr sa sb = fst (sDivRem sr sa sb) + +-------------------------------------------------------------------------------- + +-- | Singleton version of 'Log2'. +sLog2 :: SInteger i -> Sing (Log2 i :: Natural) +sLog2 si = withSomeSing + (fromIntegral (integerLog2 (fromSing si)) :: Natural) + unsafeCoerce + + +-- | Log base 2 ('floor'ed) of type-level 'Integer's. +-- +-- * Logarithm of /zero/ doesn't type-check. +-- +-- * Logarithm of negative number doesn't type-check. +type Log2 (a :: Integer) = + Fold (L.TypeError ('L.Text "Logarithm of zero.")) + (P.ConstSym1 (L.TypeError ('L.Text "Logarithm of negative number."))) + (L.Log2Sym0) + a + :: Natural + +data Log2Sym0 :: Integer ~> Natural +type Log2Sym1 :: Integer -> Natural + +type instance Apply Log2Sym0 a = Log2Sym1 a +type Log2Sym1 a = Log2 a + +-------------------------------------------------------------------------------- + +-- | Singleton version of 'GCD'. +sGCD :: SInteger a -> SInteger b -> Sing (GCD a b :: Natural) +sGCD sa sb = withSomeSing @Natural + (fromInteger (gcd (fromSing sa) (fromSing sb))) + unsafeCoerce + +-- | Greatest Common Divisor of type-level 'Integer' numbers @a@ and @b@. +-- +-- Returns a 'Natural', since the Greatest Common Divisor is always positive. +type GCD (a :: Integer) (b :: Integer) = NatGCD (Abs a) (Abs b) :: Natural + +data GCDSym0 :: Integer ~> Integer ~> Natural +data GCDSym1 :: Integer -> Integer ~> Natural +type GCDSym2 :: Integer -> Integer -> Natural + +type instance Apply GCDSym0 a = GCDSym1 a +type instance Apply (GCDSym1 a) b = GCDSym2 a b +type GCDSym2 a b = GCD a b + +-- | Greatest Common Divisor of type-level 'Natural's @a@ and @b@. +type family NatGCD (a :: Natural) (b :: Natural) :: Natural where + NatGCD a 0 = a + NatGCD a b = NatGCD b (L.Mod a b) + +-------------------------------------------------------------------------------- + +-- | Singleton version of 'LCM'. +sLCM :: SInteger a -> SInteger b -> Sing (LCM a b :: Natural) +sLCM sa sb = withSomeSing @Natural + (fromInteger (lcm (fromSing sa) (fromSing sb))) + unsafeCoerce + +-- | Least Common Multiple of type-level 'Integer' numbers @a@ and @b@. +-- +-- Returns a 'Natural', since the Least Common Multiple is always positive. +type LCM (a :: Integer) (b :: Integer) = NatLCM (Abs a) (Abs b) :: Natural + +data LCMSym0 :: Integer ~> Integer ~> Natural +data LCMSym1 :: Integer -> Integer ~> Natural +type LCMSym2 :: Integer -> Integer -> Natural + +type instance Apply LCMSym0 a = LCMSym1 a +type instance Apply (LCMSym1 a) b = LCMSym2 a b +type LCMSym2 a b = LCM a b + +-- | Least Common Multiple of type-level 'Natural's @a@ and @b@. +type NatLCM (a :: Natural) (b :: Natural) = + L.Div a (NatGCD a b) L.* b :: Natural + +-------------------------------------------------------------------------------- + +type Add_ :: Ordering -> Ordering -> Natural -> Natural -> Integer +type family Add_ lc rc la ra where + Add_ 'EQ 'EQ _ _ = Z + Add_ 'EQ 'LT _ r = N r + Add_ 'EQ 'GT _ r = P r + Add_ 'LT 'EQ l _ = N l + Add_ 'GT 'EQ l _ = P l + Add_ 'LT 'LT l r = N (l L.+ r) + Add_ 'LT 'GT l r = OrdCond (Compare l r) (P (r P.- l)) Z (N (l P.- r)) + Add_ 'GT 'GT l r = P (l L.+ r) + Add_ 'GT 'LT l r = OrdCond (Compare l r) (N (r P.- l)) Z (P (l P.- r)) + +-------------------------------------------------------------------------------- + +type Mul_ :: Ordering -> Ordering -> Natural -> Natural -> Integer +type family Mul_ lc rc la ra where + Mul_ _ 'EQ _ _ = Z + Mul_ 'EQ _ _ _ = Z + Mul_ x x l r = P (l L.* r) + Mul_ _ _ l r = N (l L.* r) + +-------------------------------------------------------------------------------- + +instance P.PNum Integer where + type l + r = Add_ (Compare l Z) (Compare r Z) (Abs l) (Abs r) + type l - r = l P.+ P.Negate r + type l * r = Mul_ (Compare l Z) (Compare r Z) (Abs l) (Abs r) + type Negate i = Fold Z PSym0 NSym0 i + type Abs i = FromNatural (Abs i) + type Signum i = Fold Z (P.ConstSym1 (N 1)) (P.ConstSym1 (P 1)) i + type FromInteger i = FromNatural i + +instance P.SNum Integer where + l %+ r = UnsafeSInteger (fromSing l + fromSing r) + l %- r = UnsafeSInteger (fromSing l - fromSing r) + l %* r = UnsafeSInteger (fromSing l * fromSing r) + sNegate = UnsafeSInteger . negate . fromSing + sAbs = sFromNatural . sAbs + sSignum = UnsafeSInteger . signum . fromSing + sFromInteger = sFromNatural + +-------------------------------------------------------------------------------- + +type instance Compare (l :: Integer) (r :: Integer) = + CmpInteger_ (Fold 'EQ (P.ConstSym1 'LT) (P.ConstSym1 'GT) l) + (Fold 'EQ (P.ConstSym1 'LT) (P.ConstSym1 'GT) r) + (Abs l) + (Abs r) + +type CmpInteger_ :: Ordering -> Ordering -> Natural -> Natural -> Ordering +type family CmpInteger_ lc rc la ra where + CmpInteger_ 'LT 'LT l r = Compare r l + CmpInteger_ 'LT 'EQ _ _ = 'LT + CmpInteger_ 'LT 'GT _ _ = 'LT + CmpInteger_ 'EQ 'LT _ _ = 'GT + CmpInteger_ 'EQ 'EQ _ _ = 'EQ + CmpInteger_ 'EQ 'GT _ _ = 'LT + CmpInteger_ 'GT 'LT _ _ = 'GT + CmpInteger_ 'GT 'EQ _ _ = 'GT + CmpInteger_ 'GT 'GT l r = Compare l r + +instance OrdS.POrd Integer where + type Compare l r = Data.Type.Ord.Compare l r + +instance OrdS.SOrd Integer where + sCompare sa sb = + case compare (fromSing sa) (fromSing sb) of + LT -> unsafeCoerce OrdS.SLT + EQ -> unsafeCoerce OrdS.SEQ + GT -> unsafeCoerce OrdS.SGT + +-------------------------------------------------------------------------------- + +instance EqS.PEq Integer where + type a == b = OrdCond (Compare a b) 'False 'True 'False + +instance EqS.SEq Integer where + sa %== sb = case fromSing sa P.== fromSing sb of + True -> unsafeCoerce STrue + False -> unsafeCoerce SFalse + +-------------------------------------------------------------------------------- + +-- | We either get evidence that this function was instantiated with the +-- same type-level 'Integer's, or 'Nothing'. +sameInteger + :: forall a b proxy1 proxy2 + . (KnownInteger a, KnownInteger b) + => proxy1 a + -> proxy2 b + -> Maybe (a :~: b) +sameInteger _ _ = testEquality (sing @a) (sing @b) + +-- | Like 'sameInteger', but if the type-level 'Integer's aren't equal, this +-- additionally provides proof of 'LT' or 'GT'. +cmpInteger + :: forall a b proxy1 proxy2 + . (KnownInteger a, KnownInteger b) + => proxy1 a + -> proxy2 b + -> OrderingI a b +cmpInteger _ _ = case compare (demote @a) (demote @b) of + EQ | Refl <- (unsafeCoerce Refl :: a :~: b) + , Refl <- (unsafeCoerce Refl :: Compare a b :~: 'EQ) -> EQI + LT | Refl <- (unsafeCoerce Refl :: Compare a b :~: 'LT) -> LTI + GT | Refl <- (unsafeCoerce Refl :: Compare a b :~: 'GT) -> GTI + +-------------------------------------------------------------------------------- + +-- | Singleton type for a type-level 'Integer' @i@. +newtype SInteger (i :: Integer) = UnsafeSInteger P.Integer +type role SInteger representational + +-- | A explicitly bidirectional pattern synonym relating an 'SInteger' to a +-- 'KnownInteger' constraint. +-- +-- As an __expression__: Constructs an explicit @'SInteger' i@ value from an +-- implicit @'KnownInteger' i@ constraint: +-- +-- @ +-- 'SInteger' @i :: 'KnownInteger' i => 'SInteger' i +-- @ +-- +-- As a __pattern__: Matches on an explicit @'SInteger' i@ value bringing +-- an implicit @'KnownInteger' i@ constraint into scope: +-- +-- @ +-- f :: 'SInteger' i -> .. +-- f si\@'SInteger' = /... both (si :: 'SInteger' i) and ('KnownInteger' i) in scope .../ +-- @ +pattern SInteger :: forall i. () => KnownInteger i => SInteger i +pattern SInteger <- (patternSInteger -> PatternSInteger) + where SInteger = integerSing +{-# COMPLETE SInteger #-} + +-- | Only used for defining the 'SInteger' pattern synonym. +data PatternSInteger (i :: Integer) where + PatternSInteger :: KnownInteger i => PatternSInteger i + +-- | Only used for defining the 'SInteger' pattern synonym. +patternSInteger :: SInteger i -> PatternSInteger i +patternSInteger si = withKnownInteger si PatternSInteger + +instance Eq (SInteger i) where + _ == _ = True + +instance Ord (SInteger i) where + compare _ _ = P.EQ + +instance P.Show (SInteger i) where + showsPrec p i = + showParen (p >= appPrec1) $ + showString "SInteger @" . + showsPrecLit appPrec1 (fromSing i) + +instance forall i. KnownInteger i => Read (SInteger i) where + readPrec = ReadPrec.lift $ do + let si = integerSing @i + _ <- ReadP.string "SInteger" >> pSkipSpaces1 + _ <- ReadP.char '@' + _ <- ReadP.string (showsPrecLit appPrec1 (fromSing si) "") + pure si + +instance TestEquality SInteger where + testEquality = decideEquality + {-# INLINE testEquality #-} + +instance TestCoercion SInteger where + testCoercion = decideCoercion + {-# INLINE testCoercion #-} + +-- | Return the term-level "Prelude".'P.Integer' number corresponding to @i@. +fromSInteger :: SInteger i -> P.Integer +fromSInteger = coerce +{-# INLINE fromSInteger #-} + +withKnownInteger_ + :: forall i rep (x :: TYPE rep) + . SInteger i + -> (KnownInteger_ i => x) + -> x +withKnownInteger_ = withDict @(KnownInteger_ i) + +-- | Convert an explicit @'SInteger' i@ value into an implicit +-- @'KnownInteger' i@ constraint. +withKnownInteger + :: forall i rep (x :: TYPE rep) + . SInteger i + -> (KnownInteger i => x) + -> x +withKnownInteger si x + | sa :: Sing a <- sAbs si + , Refl <- sNormalizedRefl si + = L.withKnownNat sa (withKnownInteger_ si x) + +-- | Convert a "Prelude".'P.Integer' number into an @'SInteger' n@ value, +-- where @n@ is a fresh type-level 'Integer'. +withSomeSInteger + :: forall rep (x :: TYPE rep) + . P.Integer + -> (forall (i :: Integer). Sing i -> x) + -> x +withSomeSInteger i k = k (UnsafeSInteger i) +-- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats" +{-# NOINLINE withSomeSInteger #-} + +-------------------------------------------------------------------------------- + +type instance Sing = SInteger + +instance (KnownInteger i) => SingI (i :: Integer) where + sing = integerSing + {-# INLINE sing #-} + +instance SingKind Integer where + type Demote Integer = P.Integer + fromSing = fromSInteger + {-# INLINE fromSing #-} + toSing i = withSomeSInteger i SomeSing + {-# INLINE toSing #-} + +instance SDecide Integer where + l %~ r = case fromSing l P.== fromSing r of + True -> Proved (unsafeCoerce Refl) + False -> Disproved (\Refl -> error "KindInteger.Integer: SDecide") + +-------------------------------------------------------------------------------- + +-- | Demoted version of 'DivRem'. +-- +-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check. +divRem + :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> (P.Integer, P.Integer) -- ^ Quotient @q@ and remainder @m@. +{-# NOINLINE divRem #-} +divRem RoundZero = \a (errDiv0 -> b) -> P.quotRem a b +divRem RoundDown = \a (errDiv0 -> b) -> P.divMod a b +divRem RoundUp = \a (errDiv0 -> b) -> _divRemRoundUpNoCheck a b +divRem RoundAway = \a (errDiv0 -> b) -> + if xor (a < 0) (b < 0) + then P.divMod a b + else _divRemRoundUpNoCheck a b +divRem RoundHalfUp = _divRemHalf $ \_ _ up -> up +divRem RoundHalfDown = _divRemHalf $ \_ down _ -> down +divRem RoundHalfZero = _divRemHalf $ \neg down up -> + if neg then up else down +divRem RoundHalfAway = _divRemHalf $ \neg down up -> + if neg then down else up +divRem RoundHalfEven = _divRemHalf $ \_ down up -> + if even (fst down) then down else up +divRem RoundHalfOdd = _divRemHalf $ \_ down up -> + if odd (fst down) then down else up + +_divRemRoundUpNoCheck :: P.Integer -> P.Integer -> (P.Integer, P.Integer) +_divRemRoundUpNoCheck a b = + let q = negate (P.div (negate a) b) + in (q, a - b * q) +{-# INLINE _divRemRoundUpNoCheck #-} + +_divRemHalf + :: (Bool -> + (P.Integer, P.Integer) -> + (P.Integer, P.Integer) -> + (P.Integer, P.Integer)) + -- ^ Negative -> divRem RoundDown -> divRem RoundUp -> Result + -> P.Integer -- ^ Dividend + -> P.Integer -- ^ Divisor + -> (P.Integer, P.Integer) +_divRemHalf f = \a (errDiv0 -> b) -> + let neg = xor (a < 0) (b < 0) + down = P.divMod a b + up = _divRemRoundUpNoCheck a b + in case compare (a P.% b - toRational (fst down)) (1 P.:% 2) of + LT -> down + GT -> up + EQ -> f neg down up +{-# INLINE _divRemHalf #-} + +-- | Singleton version of 'DivRem'. +sDivRem :: SRound r + -> SInteger a -- ^ Dividend. + -> SInteger b -- ^ Divisor. + -> (SInteger (Div r a b), SInteger (Rem r a b)) +sDivRem sr sa sb = + let (q, m) = divRem (fromSing sr) (fromSing sa) (fromSing sb) + in withSomeSing q $ \sq -> + withSomeSInteger m $ \sm -> + (unsafeCoerce sq, unsafeCoerce sm) + +-------------------------------------------------------------------------------- +-- Rational tools necessary to support 'HalfLT' + +data Rat = MkRat Integer Natural + -- ^ Invariant: 'Natural' is never 0. This is enforced by the 'R' type-family. + +type R :: Integer -> Natural -> Rat +type family R n d where + R _ 0 = L.TypeError ('L.Text "Denominator is 0.") + R n d = Fold ('MkRat Z 1) (RAuxSym2 NSym0 d) (RAuxSym2 PSym0 d) n + +data RAuxSym2 :: (Natural ~> Integer) -> Natural -> Natural ~> Rat +type instance Apply (RAuxSym2 fn d) n = 'MkRat (fn @@ n) d + +type RatReduce :: Rat -> Rat +type family RatReduce r where + RatReduce ('MkRat n d) = 'MkRat + (P.Signum n P.* FromNatural (L.Div (Abs n) (NatGCD (Abs n) d))) + (L.Div d (NatGCD (Abs n) d)) + +type RatAbs :: Rat -> Rat +type family RatAbs r where + RatAbs ('MkRat n d) = R (P.Abs n) d + +type RatAdd :: Rat -> Rat -> Rat +type family RatAdd l r where + RatAdd ('MkRat ln ld) ('MkRat rn rd) = + RatReduce (R (ln P.* P rd P.+ rn P.* P ld) (ld P.* rd)) + +type RatNegate :: Rat -> Rat +type family RatNegate r where + RatNegate ('MkRat n d) = R (P.Negate n) d + +type RatMinus :: Rat -> Rat -> Rat +type RatMinus l r = RatAdd l (RatNegate r) + +type RatCmp :: Rat -> Rat -> Ordering +type RatCmp l r = RatCmp_ (RatReduce l) (RatReduce r) +type family RatCmp_ (a :: Rat) (b :: Rat) :: Ordering where + RatCmp_ a a = 'EQ + RatCmp_ ('MkRat an ad) ('MkRat bn bd) = Compare (an P.* P bd) (bn P.* P ad) + +-- | ''True' if the distance between @a@ and @b@ is less than /0.5/. +type HalfLT :: Rat -> Integer -> Bool +type HalfLT a b = + 'LT P.== RatCmp (RatAbs (RatMinus a ('MkRat b 1))) ('MkRat (P 1) 2) + +-------------------------------------------------------------------------------- + +errDiv0 :: P.Integer -> P.Integer +errDiv0 0 = Ex.throw Ex.DivideByZero +errDiv0 i = i + +pSkipSpaces1 :: ReadP.ReadP () +pSkipSpaces1 = void $ ReadP.munch1 Char.isSpace diff --git a/lib/KindInteger/Round.hs b/lib/KindInteger/Round.hs new file mode 100644 --- /dev/null +++ b/lib/KindInteger/Round.hs @@ -0,0 +1,73 @@ +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE UndecidableInstances #-} + +-- | We define 'Round' here keep the TemplateHaskell stuff contained. +module KindInteger.Round {--} + ( Round(..) + , RoundUpSym0 + , RoundDownSym0 + , RoundZeroSym0 + , RoundAwaySym0 + , RoundHalfUpSym0 + , RoundHalfDownSym0 + , RoundHalfZeroSym0 + , RoundHalfAwaySym0 + , RoundHalfEvenSym0 + , RoundHalfOddSym0 + , SRound(..) + ) --} + where + +import Data.Bool.Singletons +import Data.Eq.Singletons +import Data.Ord.Singletons +import Data.Singletons.TH +import Prelude.Singletons + +-------------------------------------------------------------------------------- + +-- | Rounding strategy. +data Round + = RoundUp + -- ^ Round __up__ towards positive infinity. + | RoundDown + -- ^ Round __down__ towards negative infinity. Also known as "Prelude"'s + -- 'P.floor'. This is the type of rounding used by "Prelude"'s 'P.div', + -- 'P.mod', 'P.divMod', 'L.Div', 'L.Mod'. + | RoundZero + -- ^ Round towards __zero__. Also known as "Prelude"'s 'P.truncate'. This is + -- the type of rounding used by "Prelude"'s 'P.quot', 'P.rem', 'P.quotRem'. + | RoundAway + -- ^ Round __away__ from zero. + | RoundHalfUp + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round __up__ towards positive infinity. + | RoundHalfDown + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round __down__ towards negative infinity. + | RoundHalfZero + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round towards __zero__. + | RoundHalfAway + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round __away__ from zero. + | RoundHalfEven + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round towards the closest __even__ integer. Also known as "Prelude"'s + -- 'P.round'. + | RoundHalfOdd + -- ^ Round towards the closest integer. If __half__way between two integers, + -- round towards the closest __odd__ integer. + deriving stock (Read) + +$(fmap concat $ sequence + [ genSingletons [''Round] + , singletons [d| + deriving stock instance Bounded Round + deriving stock instance Enum Round + deriving stock instance Eq Round + deriving stock instance Ord Round + deriving stock instance Show Round + |] + ]) + diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -11,3364 +11,3647 @@ import Data.Ratio as P import Data.Type.Equality (TestEquality(..)) import Data.Type.Ord (type (<=)) -import GHC.Exts (Constraint) -import Prelude hiding (Integer) -import Prelude qualified as P -import System.Exit -import Text.Read - -import KindInteger (P, N) -import KindInteger qualified as K - --------------------------------------------------------------------------------- - -data Dict (c :: Constraint) where - Dict :: c => Dict c - --------------------------------------------------------------------------------- - -_testEq = Dict -_testEq :: Dict - ( P 0 K.== P 0, 'True ~ (P 0 K.==? P 0) - , N 0 K.== N 0, 'True ~ (N 0 K.==? N 0) - , P 0 K.== N 0, 'True ~ (P 0 K.==? N 0) - , N 0 K.== P 0, 'True ~ (N 0 K.==? P 0) - - , P 0 K./= P 1, 'True ~ (P 0 K./=? P 1) - , P 0 K./= N 1, 'True ~ (P 0 K./=? N 1) - - , N 0 K./= N 1, 'True ~ (N 0 K./=? N 1) - , N 0 K./= N 1, 'True ~ (N 0 K./=? N 1) - - , P 1 K./= P 0, 'True ~ (P 1 K./=? P 0) - , P 1 K./= N 0, 'True ~ (P 1 K./=? N 0) - - , N 1 K./= N 0, 'True ~ (N 1 K./=? N 0) - , N 1 K./= N 0, 'True ~ (N 1 K./=? N 0) - ) - -_testCmp = Dict -_testCmp :: Dict - ( P 0 <= P 0 - , P 0 <= N 0 - , N 0 <= P 0 - , N 0 <= N 0 - - , N 2 <= N 1 - , N 1 <= N 0 - , N 0 <= P 1 - - , P 0 <= P 1 - , P 1 <= P 2 - ) - -_testAdd = Dict -_testAdd :: Dict - ( P 0 ~ P 0 K.+ P 0 - , P 0 ~ N 0 K.+ N 0 - , P 0 ~ P 0 K.+ N 0 - , P 0 ~ N 0 K.+ P 0 - - , P 1 ~ P 1 K.+ P 0 - , N 1 ~ N 1 K.+ N 0 - , P 1 ~ P 1 K.+ N 0 - , N 1 ~ N 1 K.+ P 0 - - , P 1 ~ P 0 K.+ P 1 - , N 1 ~ N 0 K.+ N 1 - , N 1 ~ P 0 K.+ N 1 - , P 1 ~ N 0 K.+ P 1 - - , P 2 ~ P 1 K.+ P 1 - , N 2 ~ N 1 K.+ N 1 - , P 0 ~ P 1 K.+ N 1 - , P 0 ~ N 1 K.+ P 1 - ) - -_testMul = Dict -_testMul :: Dict - ( P 0 ~ P 0 K.* P 0 - , P 0 ~ N 0 K.* N 0 - , P 0 ~ P 0 K.* N 0 - , P 0 ~ N 0 K.* P 0 - - , P 0 ~ P 1 K.* P 0 - , P 0 ~ N 1 K.* N 0 - , P 0 ~ P 1 K.* N 0 - , P 0 ~ N 1 K.* P 0 - - , P 0 ~ P 0 K.* P 1 - , P 0 ~ N 0 K.* N 1 - , P 0 ~ P 0 K.* N 1 - , P 0 ~ N 0 K.* P 1 - - , P 1 ~ P 1 K.* P 1 - , P 1 ~ N 1 K.* N 1 - , N 1 ~ P 1 K.* N 1 - , N 1 ~ N 1 K.* P 1 - - , P 2 ~ P 2 K.* P 1 - , P 2 ~ N 2 K.* N 1 - , N 2 ~ P 2 K.* N 1 - , N 2 ~ N 2 K.* P 1 - - , P 6 ~ P 2 K.* P 3 - , P 6 ~ N 2 K.* N 3 - , N 6 ~ P 2 K.* N 3 - , N 6 ~ N 2 K.* P 3 - ) - -_testLog2 = Dict -_testLog2 :: Dict - ( P 0 ~ K.Log2 (P 1) - , P 1 ~ K.Log2 (P 2) - , P 1 ~ K.Log2 (P 3) - , P 2 ~ K.Log2 (P 4) - , P 2 ~ K.Log2 (P 5) - , P 2 ~ K.Log2 (P 6) - , P 2 ~ K.Log2 (P 7) - , P 3 ~ K.Log2 (P 8) - , P 3 ~ K.Log2 (P 9) - , P 3 ~ K.Log2 (P 10) - , P 3 ~ K.Log2 (P 11) - , P 3 ~ K.Log2 (P 12) - , P 3 ~ K.Log2 (P 13) - , P 3 ~ K.Log2 (P 14) - , P 3 ~ K.Log2 (P 15) - , P 4 ~ K.Log2 (P 16) - , P 4 ~ K.Log2 (P 17) - , P 4 ~ K.Log2 (P 18) - , P 4 ~ K.Log2 (P 19) - , P 4 ~ K.Log2 (P 20) - , P 4 ~ K.Log2 (P 21) - , P 4 ~ K.Log2 (P 22) - , P 4 ~ K.Log2 (P 23) - , P 4 ~ K.Log2 (P 24) - , P 4 ~ K.Log2 (P 25) - , P 4 ~ K.Log2 (P 26) - , P 4 ~ K.Log2 (P 27) - , P 4 ~ K.Log2 (P 28) - , P 4 ~ K.Log2 (P 29) - , P 4 ~ K.Log2 (P 30) - , P 4 ~ K.Log2 (P 31) - , P 5 ~ K.Log2 (P 32) - ) - -_testNegate = Dict -_testNegate :: Dict - ( P 0 ~ K.Negate (P 0) - , P 0 ~ K.Negate (N 0) - , N 1 ~ K.Negate (P 1) - , P 1 ~ K.Negate (N 1) - , N 2 ~ K.Negate (P 2) - , P 2 ~ K.Negate (N 2) - ) - -_testSign = Dict -_testSign :: Dict - ( P 0 ~ K.Sign (P 0) - , P 0 ~ K.Sign (N 0) - , P 1 ~ K.Sign (P 1) - , N 1 ~ K.Sign (N 1) - , P 1 ~ K.Sign (P 2) - , N 1 ~ K.Sign (N 2) - ) - -_testAbs = Dict -_testAbs :: Dict - ( 0 ~ K.Abs (P 0) - , 0 ~ K.Abs (N 0) - , 1 ~ K.Abs (P 1) - , 1 ~ K.Abs (N 1) - , 2 ~ K.Abs (P 2) - , 2 ~ K.Abs (N 2) - ) - -_testEven = Dict -_testEven :: Dict - ( 'True ~ K.Even (P 0) - , 'True ~ K.Even (N 0) - , 'False ~ K.Even (P 1) - , 'False ~ K.Even (N 1) - , 'True ~ K.Even (P 2) - , 'True ~ K.Even (N 2) - ) - -_testOdd = Dict -_testOdd :: Dict - ( 'False ~ K.Odd (P 0) - , 'False ~ K.Odd (N 0) - , 'True ~ K.Odd (P 1) - , 'True ~ K.Odd (N 1) - , 'False ~ K.Odd (P 2) - , 'False ~ K.Odd (N 2) - ) - -_testGCD = Dict -_testGCD :: Dict - ( 0 ~ K.GCD (P 0) (P 0) - , 0 ~ K.GCD (P 0) (N 0) - , 0 ~ K.GCD (N 0) (P 0) - , 0 ~ K.GCD (N 0) (N 0) - - , 1 ~ K.GCD (P 1) (P 0) - , 1 ~ K.GCD (P 1) (N 0) - , 1 ~ K.GCD (N 1) (P 0) - , 1 ~ K.GCD (N 1) (N 0) - - , 1 ~ K.GCD (P 0) (P 1) - , 1 ~ K.GCD (P 0) (N 1) - , 1 ~ K.GCD (N 0) (P 1) - , 1 ~ K.GCD (N 0) (N 1) - - , 1 ~ K.GCD (P 1) (P 2) - , 1 ~ K.GCD (P 1) (N 2) - , 1 ~ K.GCD (N 1) (P 2) - , 1 ~ K.GCD (N 1) (N 2) - - , 1 ~ K.GCD (P 2) (P 1) - , 1 ~ K.GCD (P 2) (N 1) - , 1 ~ K.GCD (N 2) (P 1) - , 1 ~ K.GCD (N 2) (N 1) - - , 3 ~ K.GCD (P 6) (P 9) - , 3 ~ K.GCD (P 6) (N 9) - , 3 ~ K.GCD (N 6) (P 9) - , 3 ~ K.GCD (N 6) (N 9) - - , 3 ~ K.GCD (P 9) (P 6) - , 3 ~ K.GCD (P 9) (N 6) - , 3 ~ K.GCD (N 9) (P 6) - , 3 ~ K.GCD (N 9) (N 6) - ) - -_testLCM = Dict -_testLCM :: Dict - ( 0 ~ K.LCM (P 0) (P 0) - , 0 ~ K.LCM (P 0) (N 0) - , 0 ~ K.LCM (N 0) (P 0) - , 0 ~ K.LCM (N 0) (N 0) - - , 0 ~ K.LCM (P 1) (P 0) - , 0 ~ K.LCM (P 1) (N 0) - , 0 ~ K.LCM (N 1) (P 0) - , 0 ~ K.LCM (N 1) (N 0) - - , 0 ~ K.LCM (P 0) (P 1) - , 0 ~ K.LCM (P 0) (N 1) - , 0 ~ K.LCM (N 0) (P 1) - , 0 ~ K.LCM (N 0) (N 1) - - , 2 ~ K.LCM (P 1) (P 2) - , 2 ~ K.LCM (P 1) (N 2) - , 2 ~ K.LCM (N 1) (P 2) - , 2 ~ K.LCM (N 1) (N 2) - - , 2 ~ K.LCM (P 2) (P 1) - , 2 ~ K.LCM (P 2) (N 1) - , 2 ~ K.LCM (N 2) (P 1) - , 2 ~ K.LCM (N 2) (N 1) - - , 18 ~ K.LCM (P 6) (P 9) - , 18 ~ K.LCM (P 6) (N 9) - , 18 ~ K.LCM (N 6) (P 9) - , 18 ~ K.LCM (N 6) (N 9) - - , 18 ~ K.LCM (P 9) (P 6) - , 18 ~ K.LCM (P 9) (N 6) - , 18 ~ K.LCM (N 9) (P 6) - , 18 ~ K.LCM (N 9) (N 6) - ) - --------------------------------------------------------------------------------- - -assert - :: String -- ^ Test name - -> Bool -- ^ Successful is true - -> IO Bool -- ^ Return the same 'Bool' given as input. -assert n x = do - putStrLn ((if x then "[OK] " else "[FAIL] ") <> n) - pure x - -testsMain :: [IO Bool] -> IO a -testsMain xs = do - res <- sequence xs - let (oks, bads) = List.partition id res - putStrLn ("[TOTAL] OK: " <> show (length oks) <> - ". FAIL: " <> show (length bads) <> ".") - case bads of - [] -> exitSuccess - _ -> exitFailure - -main :: IO () -main = testsMain $ - [ assert "Prelude % throws RatioZeroDenominator" =<< do - ea <- Ex.try (Ex.evaluate (1 P.% 0 :: P.Rational)) - pure (ea == Left Ex.RatioZeroDenominator) - - , assert "integerVal . someIntegerVal == id" $ - flip all [-5 .. 5] $ \a -> - let a' = K.fromPrelude a - in case K.someIntegerVal a' of - K.SomeInteger pa -> - a' == K.integerVal pa - - , assert "sameIntegerVal a a" $ - flip all [-5 .. 5] $ \a -> - let a' = K.fromPrelude a - in case K.someIntegerVal a' of - K.SomeInteger pa -> - isJust (K.sameInteger pa pa) - - , assert "sameIntegerVal a a'" $ - flip all [-5 .. 5] $ \a -> - let a' = K.fromPrelude a - in case (K.someIntegerVal a', K.someIntegerVal a') of - (K.SomeInteger pa1, K.SomeInteger pa2) -> - isJust (K.sameInteger pa1 pa2) - - , assert "sameIntegerVal a b" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - let a' = K.fromPrelude a - b' = K.fromPrelude b - in case (K.someIntegerVal a', K.someIntegerVal b') of - (K.SomeInteger pa, K.SomeInteger pb) - | a == b -> isJust (K.sameInteger pa pb) - | otherwise -> isNothing (K.sameInteger pa pb) - - , assert "Eq fromPrelude" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - (a == b) == (K.fromPrelude a == K.fromPrelude b) - - , assert "Ord fromPrelude" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - (a `compare` b) == (K.fromPrelude a `compare` K.fromPrelude b) - - , assert "Show fromPrelude" $ - flip all [-5 .. 5] $ \i -> - show i == show (K.fromPrelude i) - - , assert "Read fromPrelude" $ - flip all [-5 .. 5] $ \i -> - let str = show (i :: P.Integer) - in readMaybe @P.Integer str - == fmap K.toPrelude (readMaybe @K.Integer str) - - , assert "Eq SomeInteger" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - let a' = K.fromPrelude a - b' = K.fromPrelude b - in (a == b) == (K.someIntegerVal a' == K.someIntegerVal b') - - , assert "Ord SomeInteger" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - compare a b == - compare (K.someIntegerVal (K.fromPrelude a)) - (K.someIntegerVal (K.fromPrelude b)) - - , assert "Show SomeInteger" $ - flip all [-5 .. 5] $ \a -> - let a' = K.fromPrelude a - in show a == show (K.someIntegerVal a') - - , assert "Read SomeInteger" $ - flip all [-5 .. 5] $ \i -> - let str = show (i :: P.Integer) - in readMaybe @P.Integer str - == fmap (\(K.SomeInteger p) -> K.toPrelude (K.integerVal p)) - (readMaybe @K.SomeInteger str) - - , assert "TestEquality +0 +0" $ - isJust (testEquality (K.SInteger @(P 0)) (K.SInteger @(P 0))) - , assert "TestEquality -0 -0" $ - isJust (testEquality (K.SInteger @(N 0)) (K.SInteger @(N 0))) - , assert "TestEquality +0 -0" $ - isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(N 0))) - , assert "TestEquality -0 +0" $ - isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(P 0))) - , assert "TestEquality +0 +1" $ - isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(P 1))) - , assert "TestEquality +0 -1" $ - isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(N 1))) - , assert "TestEquality -0 +1" $ - isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(P 1))) - , assert "TestEquality -0 -1" $ - isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(N 1))) - , assert "TestEquality +1 +0" $ - isNothing (testEquality (K.SInteger @(P 1)) (K.SInteger @(P 0))) - , assert "TestEquality +1 -0" $ - isNothing (testEquality (K.SInteger @(P 1)) (K.SInteger @(N 0))) - , assert "TestEquality -1 +0" $ - isNothing (testEquality (K.SInteger @(N 1)) (K.SInteger @(P 0))) - , assert "TestEquality -1 -0" $ - isNothing (testEquality (K.SInteger @(N 1)) (K.SInteger @(N 0))) - - , assert "Show Integer +0" $ - "0" == show (K.fromSInteger (K.SInteger @(P 0))) - , assert "Show Integer -0" $ - "0" == show (K.fromSInteger (K.SInteger @(N 0))) - , assert "Show Integer +1" $ - "1" == show (K.fromSInteger (K.SInteger @(P 1))) - , assert "Show Integer -1" $ - "-1" == show (K.fromSInteger (K.SInteger @(N 1))) - - , assert "Show SInteger +0" $ - "SInteger @(P 0)" == show (K.SInteger @(P 0)) - , assert "Show SInteger -0" $ - "SInteger @(N 0)" == show (K.SInteger @(N 0)) - , assert "Show SInteger +1" $ - "SInteger @(P 1)" == show (K.SInteger @(P 1)) - , assert "Show SInteger -1" $ - "SInteger @(N 1)" == show (K.SInteger @(N 1)) - - ] <> testsDivRem - -testsDivRem :: [IO Bool] -testsDivRem = do - b :: P.Integer <- [-5 .. 5] - guard (b P./= 0) - a :: P.Integer <- [-5 .. 5] - r :: K.Round <- [minBound .. maxBound] - let tname :: String -> ShowS - tname t = showString t . showChar ' ' . shows r . showChar ' ' - . shows a . showChar ' ' . shows b - [ assert (tname "divRem" "") $ case K.divRem r a b of - (q, m) -> m == a - b * q - , assert (tname "div" "") $ fst (K.divRem r a b) == K.div r a b - , assert (tname "rem" "") $ snd (K.divRem r a b) == K.rem r a b - ] - - --------------------------------------------------------------------------------- - -_divRemTestCode :: String -_divRemTestCode = unlines $ List.sort $ do - b <- [-4 .. 4] - guard (b P./= 0) - a <- [-4 .. 4] - r <- [minBound..maxBound] - let (q, m) = K.divRem r a b - sname :: String -> ShowS - sname t = showString "_test_" - . showString t - . showChar '_' - . showsPrec 0 r - . showChar '_' - . showChar (if a < 0 then 'N' else 'P') - . shows (abs a) - . showChar '_' - . showChar (if b < 0 then 'N' else 'P') - . shows (abs b) - sDiv :: ShowS - sDiv = sname "Div" - . showString " :: Dict (K.Div 'K." - . shows r - . showChar ' ' - . K.showsPrecTypeLit 11 (K.fromPrelude a) - . showChar ' ' - . K.showsPrecTypeLit 11 (K.fromPrelude b) - . showString " ~ " - . K.showsPrecTypeLit 0 (K.fromPrelude q) - . showString ")\n" - . sname "Div" - . showString " = Dict" - sRem :: ShowS - sRem = sname "Rem" - . showString " :: Dict (K.Rem 'K." - . shows r - . showChar ' ' - . K.showsPrecTypeLit 11 (K.fromPrelude a) - . showChar ' ' - . K.showsPrecTypeLit 11 (K.fromPrelude b) - . showString " ~ " - . K.showsPrecTypeLit 0 (K.fromPrelude m) - . showString ")\n" - . sname "Rem" - . showString " = Dict" - ss :: ShowS - ss = sDiv . showChar '\n' . sRem - pure (ss "") - - --- The following tests are generated by `_divRemTestCode` in this remule. --- Copy and paste by hand. -_test_Div_RoundAway_N1_N1 :: Dict (K.Div 'K.RoundAway (N 1) (N 1) ~ P 1) -_test_Div_RoundAway_N1_N1 = Dict -_test_Rem_RoundAway_N1_N1 :: Dict (K.Rem 'K.RoundAway (N 1) (N 1) ~ P 0) -_test_Rem_RoundAway_N1_N1 = Dict -_test_Div_RoundAway_N1_N2 :: Dict (K.Div 'K.RoundAway (N 1) (N 2) ~ P 1) -_test_Div_RoundAway_N1_N2 = Dict -_test_Rem_RoundAway_N1_N2 :: Dict (K.Rem 'K.RoundAway (N 1) (N 2) ~ P 1) -_test_Rem_RoundAway_N1_N2 = Dict -_test_Div_RoundAway_N1_N3 :: Dict (K.Div 'K.RoundAway (N 1) (N 3) ~ P 1) -_test_Div_RoundAway_N1_N3 = Dict -_test_Rem_RoundAway_N1_N3 :: Dict (K.Rem 'K.RoundAway (N 1) (N 3) ~ P 2) -_test_Rem_RoundAway_N1_N3 = Dict -_test_Div_RoundAway_N1_N4 :: Dict (K.Div 'K.RoundAway (N 1) (N 4) ~ P 1) -_test_Div_RoundAway_N1_N4 = Dict -_test_Rem_RoundAway_N1_N4 :: Dict (K.Rem 'K.RoundAway (N 1) (N 4) ~ P 3) -_test_Rem_RoundAway_N1_N4 = Dict -_test_Div_RoundAway_N1_P1 :: Dict (K.Div 'K.RoundAway (N 1) (P 1) ~ N 1) -_test_Div_RoundAway_N1_P1 = Dict -_test_Rem_RoundAway_N1_P1 :: Dict (K.Rem 'K.RoundAway (N 1) (P 1) ~ P 0) -_test_Rem_RoundAway_N1_P1 = Dict -_test_Div_RoundAway_N1_P2 :: Dict (K.Div 'K.RoundAway (N 1) (P 2) ~ N 1) -_test_Div_RoundAway_N1_P2 = Dict -_test_Rem_RoundAway_N1_P2 :: Dict (K.Rem 'K.RoundAway (N 1) (P 2) ~ P 1) -_test_Rem_RoundAway_N1_P2 = Dict -_test_Div_RoundAway_N1_P3 :: Dict (K.Div 'K.RoundAway (N 1) (P 3) ~ N 1) -_test_Div_RoundAway_N1_P3 = Dict -_test_Rem_RoundAway_N1_P3 :: Dict (K.Rem 'K.RoundAway (N 1) (P 3) ~ P 2) -_test_Rem_RoundAway_N1_P3 = Dict -_test_Div_RoundAway_N1_P4 :: Dict (K.Div 'K.RoundAway (N 1) (P 4) ~ N 1) -_test_Div_RoundAway_N1_P4 = Dict -_test_Rem_RoundAway_N1_P4 :: Dict (K.Rem 'K.RoundAway (N 1) (P 4) ~ P 3) -_test_Rem_RoundAway_N1_P4 = Dict -_test_Div_RoundAway_N2_N1 :: Dict (K.Div 'K.RoundAway (N 2) (N 1) ~ P 2) -_test_Div_RoundAway_N2_N1 = Dict -_test_Rem_RoundAway_N2_N1 :: Dict (K.Rem 'K.RoundAway (N 2) (N 1) ~ P 0) -_test_Rem_RoundAway_N2_N1 = Dict -_test_Div_RoundAway_N2_N2 :: Dict (K.Div 'K.RoundAway (N 2) (N 2) ~ P 1) -_test_Div_RoundAway_N2_N2 = Dict -_test_Rem_RoundAway_N2_N2 :: Dict (K.Rem 'K.RoundAway (N 2) (N 2) ~ P 0) -_test_Rem_RoundAway_N2_N2 = Dict -_test_Div_RoundAway_N2_N3 :: Dict (K.Div 'K.RoundAway (N 2) (N 3) ~ P 1) -_test_Div_RoundAway_N2_N3 = Dict -_test_Rem_RoundAway_N2_N3 :: Dict (K.Rem 'K.RoundAway (N 2) (N 3) ~ P 1) -_test_Rem_RoundAway_N2_N3 = Dict -_test_Div_RoundAway_N2_N4 :: Dict (K.Div 'K.RoundAway (N 2) (N 4) ~ P 1) -_test_Div_RoundAway_N2_N4 = Dict -_test_Rem_RoundAway_N2_N4 :: Dict (K.Rem 'K.RoundAway (N 2) (N 4) ~ P 2) -_test_Rem_RoundAway_N2_N4 = Dict -_test_Div_RoundAway_N2_P1 :: Dict (K.Div 'K.RoundAway (N 2) (P 1) ~ N 2) -_test_Div_RoundAway_N2_P1 = Dict -_test_Rem_RoundAway_N2_P1 :: Dict (K.Rem 'K.RoundAway (N 2) (P 1) ~ P 0) -_test_Rem_RoundAway_N2_P1 = Dict -_test_Div_RoundAway_N2_P2 :: Dict (K.Div 'K.RoundAway (N 2) (P 2) ~ N 1) -_test_Div_RoundAway_N2_P2 = Dict -_test_Rem_RoundAway_N2_P2 :: Dict (K.Rem 'K.RoundAway (N 2) (P 2) ~ P 0) -_test_Rem_RoundAway_N2_P2 = Dict -_test_Div_RoundAway_N2_P3 :: Dict (K.Div 'K.RoundAway (N 2) (P 3) ~ N 1) -_test_Div_RoundAway_N2_P3 = Dict -_test_Rem_RoundAway_N2_P3 :: Dict (K.Rem 'K.RoundAway (N 2) (P 3) ~ P 1) -_test_Rem_RoundAway_N2_P3 = Dict -_test_Div_RoundAway_N2_P4 :: Dict (K.Div 'K.RoundAway (N 2) (P 4) ~ N 1) -_test_Div_RoundAway_N2_P4 = Dict -_test_Rem_RoundAway_N2_P4 :: Dict (K.Rem 'K.RoundAway (N 2) (P 4) ~ P 2) -_test_Rem_RoundAway_N2_P4 = Dict -_test_Div_RoundAway_N3_N1 :: Dict (K.Div 'K.RoundAway (N 3) (N 1) ~ P 3) -_test_Div_RoundAway_N3_N1 = Dict -_test_Rem_RoundAway_N3_N1 :: Dict (K.Rem 'K.RoundAway (N 3) (N 1) ~ P 0) -_test_Rem_RoundAway_N3_N1 = Dict -_test_Div_RoundAway_N3_N2 :: Dict (K.Div 'K.RoundAway (N 3) (N 2) ~ P 2) -_test_Div_RoundAway_N3_N2 = Dict -_test_Rem_RoundAway_N3_N2 :: Dict (K.Rem 'K.RoundAway (N 3) (N 2) ~ P 1) -_test_Rem_RoundAway_N3_N2 = Dict -_test_Div_RoundAway_N3_N3 :: Dict (K.Div 'K.RoundAway (N 3) (N 3) ~ P 1) -_test_Div_RoundAway_N3_N3 = Dict -_test_Rem_RoundAway_N3_N3 :: Dict (K.Rem 'K.RoundAway (N 3) (N 3) ~ P 0) -_test_Rem_RoundAway_N3_N3 = Dict -_test_Div_RoundAway_N3_N4 :: Dict (K.Div 'K.RoundAway (N 3) (N 4) ~ P 1) -_test_Div_RoundAway_N3_N4 = Dict -_test_Rem_RoundAway_N3_N4 :: Dict (K.Rem 'K.RoundAway (N 3) (N 4) ~ P 1) -_test_Rem_RoundAway_N3_N4 = Dict -_test_Div_RoundAway_N3_P1 :: Dict (K.Div 'K.RoundAway (N 3) (P 1) ~ N 3) -_test_Div_RoundAway_N3_P1 = Dict -_test_Rem_RoundAway_N3_P1 :: Dict (K.Rem 'K.RoundAway (N 3) (P 1) ~ P 0) -_test_Rem_RoundAway_N3_P1 = Dict -_test_Div_RoundAway_N3_P2 :: Dict (K.Div 'K.RoundAway (N 3) (P 2) ~ N 2) -_test_Div_RoundAway_N3_P2 = Dict -_test_Rem_RoundAway_N3_P2 :: Dict (K.Rem 'K.RoundAway (N 3) (P 2) ~ P 1) -_test_Rem_RoundAway_N3_P2 = Dict -_test_Div_RoundAway_N3_P3 :: Dict (K.Div 'K.RoundAway (N 3) (P 3) ~ N 1) -_test_Div_RoundAway_N3_P3 = Dict -_test_Rem_RoundAway_N3_P3 :: Dict (K.Rem 'K.RoundAway (N 3) (P 3) ~ P 0) -_test_Rem_RoundAway_N3_P3 = Dict -_test_Div_RoundAway_N3_P4 :: Dict (K.Div 'K.RoundAway (N 3) (P 4) ~ N 1) -_test_Div_RoundAway_N3_P4 = Dict -_test_Rem_RoundAway_N3_P4 :: Dict (K.Rem 'K.RoundAway (N 3) (P 4) ~ P 1) -_test_Rem_RoundAway_N3_P4 = Dict -_test_Div_RoundAway_N4_N1 :: Dict (K.Div 'K.RoundAway (N 4) (N 1) ~ P 4) -_test_Div_RoundAway_N4_N1 = Dict -_test_Rem_RoundAway_N4_N1 :: Dict (K.Rem 'K.RoundAway (N 4) (N 1) ~ P 0) -_test_Rem_RoundAway_N4_N1 = Dict -_test_Div_RoundAway_N4_N2 :: Dict (K.Div 'K.RoundAway (N 4) (N 2) ~ P 2) -_test_Div_RoundAway_N4_N2 = Dict -_test_Rem_RoundAway_N4_N2 :: Dict (K.Rem 'K.RoundAway (N 4) (N 2) ~ P 0) -_test_Rem_RoundAway_N4_N2 = Dict -_test_Div_RoundAway_N4_N3 :: Dict (K.Div 'K.RoundAway (N 4) (N 3) ~ P 2) -_test_Div_RoundAway_N4_N3 = Dict -_test_Rem_RoundAway_N4_N3 :: Dict (K.Rem 'K.RoundAway (N 4) (N 3) ~ P 2) -_test_Rem_RoundAway_N4_N3 = Dict -_test_Div_RoundAway_N4_N4 :: Dict (K.Div 'K.RoundAway (N 4) (N 4) ~ P 1) -_test_Div_RoundAway_N4_N4 = Dict -_test_Rem_RoundAway_N4_N4 :: Dict (K.Rem 'K.RoundAway (N 4) (N 4) ~ P 0) -_test_Rem_RoundAway_N4_N4 = Dict -_test_Div_RoundAway_N4_P1 :: Dict (K.Div 'K.RoundAway (N 4) (P 1) ~ N 4) -_test_Div_RoundAway_N4_P1 = Dict -_test_Rem_RoundAway_N4_P1 :: Dict (K.Rem 'K.RoundAway (N 4) (P 1) ~ P 0) -_test_Rem_RoundAway_N4_P1 = Dict -_test_Div_RoundAway_N4_P2 :: Dict (K.Div 'K.RoundAway (N 4) (P 2) ~ N 2) -_test_Div_RoundAway_N4_P2 = Dict -_test_Rem_RoundAway_N4_P2 :: Dict (K.Rem 'K.RoundAway (N 4) (P 2) ~ P 0) -_test_Rem_RoundAway_N4_P2 = Dict -_test_Div_RoundAway_N4_P3 :: Dict (K.Div 'K.RoundAway (N 4) (P 3) ~ N 2) -_test_Div_RoundAway_N4_P3 = Dict -_test_Rem_RoundAway_N4_P3 :: Dict (K.Rem 'K.RoundAway (N 4) (P 3) ~ P 2) -_test_Rem_RoundAway_N4_P3 = Dict -_test_Div_RoundAway_N4_P4 :: Dict (K.Div 'K.RoundAway (N 4) (P 4) ~ N 1) -_test_Div_RoundAway_N4_P4 = Dict -_test_Rem_RoundAway_N4_P4 :: Dict (K.Rem 'K.RoundAway (N 4) (P 4) ~ P 0) -_test_Rem_RoundAway_N4_P4 = Dict -_test_Div_RoundAway_P0_N1 :: Dict (K.Div 'K.RoundAway (P 0) (N 1) ~ P 0) -_test_Div_RoundAway_P0_N1 = Dict -_test_Rem_RoundAway_P0_N1 :: Dict (K.Rem 'K.RoundAway (P 0) (N 1) ~ P 0) -_test_Rem_RoundAway_P0_N1 = Dict -_test_Div_RoundAway_P0_N2 :: Dict (K.Div 'K.RoundAway (P 0) (N 2) ~ P 0) -_test_Div_RoundAway_P0_N2 = Dict -_test_Rem_RoundAway_P0_N2 :: Dict (K.Rem 'K.RoundAway (P 0) (N 2) ~ P 0) -_test_Rem_RoundAway_P0_N2 = Dict -_test_Div_RoundAway_P0_N3 :: Dict (K.Div 'K.RoundAway (P 0) (N 3) ~ P 0) -_test_Div_RoundAway_P0_N3 = Dict -_test_Rem_RoundAway_P0_N3 :: Dict (K.Rem 'K.RoundAway (P 0) (N 3) ~ P 0) -_test_Rem_RoundAway_P0_N3 = Dict -_test_Div_RoundAway_P0_N4 :: Dict (K.Div 'K.RoundAway (P 0) (N 4) ~ P 0) -_test_Div_RoundAway_P0_N4 = Dict -_test_Rem_RoundAway_P0_N4 :: Dict (K.Rem 'K.RoundAway (P 0) (N 4) ~ P 0) -_test_Rem_RoundAway_P0_N4 = Dict -_test_Div_RoundAway_P0_P1 :: Dict (K.Div 'K.RoundAway (P 0) (P 1) ~ P 0) -_test_Div_RoundAway_P0_P1 = Dict -_test_Rem_RoundAway_P0_P1 :: Dict (K.Rem 'K.RoundAway (P 0) (P 1) ~ P 0) -_test_Rem_RoundAway_P0_P1 = Dict -_test_Div_RoundAway_P0_P2 :: Dict (K.Div 'K.RoundAway (P 0) (P 2) ~ P 0) -_test_Div_RoundAway_P0_P2 = Dict -_test_Rem_RoundAway_P0_P2 :: Dict (K.Rem 'K.RoundAway (P 0) (P 2) ~ P 0) -_test_Rem_RoundAway_P0_P2 = Dict -_test_Div_RoundAway_P0_P3 :: Dict (K.Div 'K.RoundAway (P 0) (P 3) ~ P 0) -_test_Div_RoundAway_P0_P3 = Dict -_test_Rem_RoundAway_P0_P3 :: Dict (K.Rem 'K.RoundAway (P 0) (P 3) ~ P 0) -_test_Rem_RoundAway_P0_P3 = Dict -_test_Div_RoundAway_P0_P4 :: Dict (K.Div 'K.RoundAway (P 0) (P 4) ~ P 0) -_test_Div_RoundAway_P0_P4 = Dict -_test_Rem_RoundAway_P0_P4 :: Dict (K.Rem 'K.RoundAway (P 0) (P 4) ~ P 0) -_test_Rem_RoundAway_P0_P4 = Dict -_test_Div_RoundAway_P1_N1 :: Dict (K.Div 'K.RoundAway (P 1) (N 1) ~ N 1) -_test_Div_RoundAway_P1_N1 = Dict -_test_Rem_RoundAway_P1_N1 :: Dict (K.Rem 'K.RoundAway (P 1) (N 1) ~ P 0) -_test_Rem_RoundAway_P1_N1 = Dict -_test_Div_RoundAway_P1_N2 :: Dict (K.Div 'K.RoundAway (P 1) (N 2) ~ N 1) -_test_Div_RoundAway_P1_N2 = Dict -_test_Rem_RoundAway_P1_N2 :: Dict (K.Rem 'K.RoundAway (P 1) (N 2) ~ N 1) -_test_Rem_RoundAway_P1_N2 = Dict -_test_Div_RoundAway_P1_N3 :: Dict (K.Div 'K.RoundAway (P 1) (N 3) ~ N 1) -_test_Div_RoundAway_P1_N3 = Dict -_test_Rem_RoundAway_P1_N3 :: Dict (K.Rem 'K.RoundAway (P 1) (N 3) ~ N 2) -_test_Rem_RoundAway_P1_N3 = Dict -_test_Div_RoundAway_P1_N4 :: Dict (K.Div 'K.RoundAway (P 1) (N 4) ~ N 1) -_test_Div_RoundAway_P1_N4 = Dict -_test_Rem_RoundAway_P1_N4 :: Dict (K.Rem 'K.RoundAway (P 1) (N 4) ~ N 3) -_test_Rem_RoundAway_P1_N4 = Dict -_test_Div_RoundAway_P1_P1 :: Dict (K.Div 'K.RoundAway (P 1) (P 1) ~ P 1) -_test_Div_RoundAway_P1_P1 = Dict -_test_Rem_RoundAway_P1_P1 :: Dict (K.Rem 'K.RoundAway (P 1) (P 1) ~ P 0) -_test_Rem_RoundAway_P1_P1 = Dict -_test_Div_RoundAway_P1_P2 :: Dict (K.Div 'K.RoundAway (P 1) (P 2) ~ P 1) -_test_Div_RoundAway_P1_P2 = Dict -_test_Rem_RoundAway_P1_P2 :: Dict (K.Rem 'K.RoundAway (P 1) (P 2) ~ N 1) -_test_Rem_RoundAway_P1_P2 = Dict -_test_Div_RoundAway_P1_P3 :: Dict (K.Div 'K.RoundAway (P 1) (P 3) ~ P 1) -_test_Div_RoundAway_P1_P3 = Dict -_test_Rem_RoundAway_P1_P3 :: Dict (K.Rem 'K.RoundAway (P 1) (P 3) ~ N 2) -_test_Rem_RoundAway_P1_P3 = Dict -_test_Div_RoundAway_P1_P4 :: Dict (K.Div 'K.RoundAway (P 1) (P 4) ~ P 1) -_test_Div_RoundAway_P1_P4 = Dict -_test_Rem_RoundAway_P1_P4 :: Dict (K.Rem 'K.RoundAway (P 1) (P 4) ~ N 3) -_test_Rem_RoundAway_P1_P4 = Dict -_test_Div_RoundAway_P2_N1 :: Dict (K.Div 'K.RoundAway (P 2) (N 1) ~ N 2) -_test_Div_RoundAway_P2_N1 = Dict -_test_Rem_RoundAway_P2_N1 :: Dict (K.Rem 'K.RoundAway (P 2) (N 1) ~ P 0) -_test_Rem_RoundAway_P2_N1 = Dict -_test_Div_RoundAway_P2_N2 :: Dict (K.Div 'K.RoundAway (P 2) (N 2) ~ N 1) -_test_Div_RoundAway_P2_N2 = Dict -_test_Rem_RoundAway_P2_N2 :: Dict (K.Rem 'K.RoundAway (P 2) (N 2) ~ P 0) -_test_Rem_RoundAway_P2_N2 = Dict -_test_Div_RoundAway_P2_N3 :: Dict (K.Div 'K.RoundAway (P 2) (N 3) ~ N 1) -_test_Div_RoundAway_P2_N3 = Dict -_test_Rem_RoundAway_P2_N3 :: Dict (K.Rem 'K.RoundAway (P 2) (N 3) ~ N 1) -_test_Rem_RoundAway_P2_N3 = Dict -_test_Div_RoundAway_P2_N4 :: Dict (K.Div 'K.RoundAway (P 2) (N 4) ~ N 1) -_test_Div_RoundAway_P2_N4 = Dict -_test_Rem_RoundAway_P2_N4 :: Dict (K.Rem 'K.RoundAway (P 2) (N 4) ~ N 2) -_test_Rem_RoundAway_P2_N4 = Dict -_test_Div_RoundAway_P2_P1 :: Dict (K.Div 'K.RoundAway (P 2) (P 1) ~ P 2) -_test_Div_RoundAway_P2_P1 = Dict -_test_Rem_RoundAway_P2_P1 :: Dict (K.Rem 'K.RoundAway (P 2) (P 1) ~ P 0) -_test_Rem_RoundAway_P2_P1 = Dict -_test_Div_RoundAway_P2_P2 :: Dict (K.Div 'K.RoundAway (P 2) (P 2) ~ P 1) -_test_Div_RoundAway_P2_P2 = Dict -_test_Rem_RoundAway_P2_P2 :: Dict (K.Rem 'K.RoundAway (P 2) (P 2) ~ P 0) -_test_Rem_RoundAway_P2_P2 = Dict -_test_Div_RoundAway_P2_P3 :: Dict (K.Div 'K.RoundAway (P 2) (P 3) ~ P 1) -_test_Div_RoundAway_P2_P3 = Dict -_test_Rem_RoundAway_P2_P3 :: Dict (K.Rem 'K.RoundAway (P 2) (P 3) ~ N 1) -_test_Rem_RoundAway_P2_P3 = Dict -_test_Div_RoundAway_P2_P4 :: Dict (K.Div 'K.RoundAway (P 2) (P 4) ~ P 1) -_test_Div_RoundAway_P2_P4 = Dict -_test_Rem_RoundAway_P2_P4 :: Dict (K.Rem 'K.RoundAway (P 2) (P 4) ~ N 2) -_test_Rem_RoundAway_P2_P4 = Dict -_test_Div_RoundAway_P3_N1 :: Dict (K.Div 'K.RoundAway (P 3) (N 1) ~ N 3) -_test_Div_RoundAway_P3_N1 = Dict -_test_Rem_RoundAway_P3_N1 :: Dict (K.Rem 'K.RoundAway (P 3) (N 1) ~ P 0) -_test_Rem_RoundAway_P3_N1 = Dict -_test_Div_RoundAway_P3_N2 :: Dict (K.Div 'K.RoundAway (P 3) (N 2) ~ N 2) -_test_Div_RoundAway_P3_N2 = Dict -_test_Rem_RoundAway_P3_N2 :: Dict (K.Rem 'K.RoundAway (P 3) (N 2) ~ N 1) -_test_Rem_RoundAway_P3_N2 = Dict -_test_Div_RoundAway_P3_N3 :: Dict (K.Div 'K.RoundAway (P 3) (N 3) ~ N 1) -_test_Div_RoundAway_P3_N3 = Dict -_test_Rem_RoundAway_P3_N3 :: Dict (K.Rem 'K.RoundAway (P 3) (N 3) ~ P 0) -_test_Rem_RoundAway_P3_N3 = Dict -_test_Div_RoundAway_P3_N4 :: Dict (K.Div 'K.RoundAway (P 3) (N 4) ~ N 1) -_test_Div_RoundAway_P3_N4 = Dict -_test_Rem_RoundAway_P3_N4 :: Dict (K.Rem 'K.RoundAway (P 3) (N 4) ~ N 1) -_test_Rem_RoundAway_P3_N4 = Dict -_test_Div_RoundAway_P3_P1 :: Dict (K.Div 'K.RoundAway (P 3) (P 1) ~ P 3) -_test_Div_RoundAway_P3_P1 = Dict -_test_Rem_RoundAway_P3_P1 :: Dict (K.Rem 'K.RoundAway (P 3) (P 1) ~ P 0) -_test_Rem_RoundAway_P3_P1 = Dict -_test_Div_RoundAway_P3_P2 :: Dict (K.Div 'K.RoundAway (P 3) (P 2) ~ P 2) -_test_Div_RoundAway_P3_P2 = Dict -_test_Rem_RoundAway_P3_P2 :: Dict (K.Rem 'K.RoundAway (P 3) (P 2) ~ N 1) -_test_Rem_RoundAway_P3_P2 = Dict -_test_Div_RoundAway_P3_P3 :: Dict (K.Div 'K.RoundAway (P 3) (P 3) ~ P 1) -_test_Div_RoundAway_P3_P3 = Dict -_test_Rem_RoundAway_P3_P3 :: Dict (K.Rem 'K.RoundAway (P 3) (P 3) ~ P 0) -_test_Rem_RoundAway_P3_P3 = Dict -_test_Div_RoundAway_P3_P4 :: Dict (K.Div 'K.RoundAway (P 3) (P 4) ~ P 1) -_test_Div_RoundAway_P3_P4 = Dict -_test_Rem_RoundAway_P3_P4 :: Dict (K.Rem 'K.RoundAway (P 3) (P 4) ~ N 1) -_test_Rem_RoundAway_P3_P4 = Dict -_test_Div_RoundAway_P4_N1 :: Dict (K.Div 'K.RoundAway (P 4) (N 1) ~ N 4) -_test_Div_RoundAway_P4_N1 = Dict -_test_Rem_RoundAway_P4_N1 :: Dict (K.Rem 'K.RoundAway (P 4) (N 1) ~ P 0) -_test_Rem_RoundAway_P4_N1 = Dict -_test_Div_RoundAway_P4_N2 :: Dict (K.Div 'K.RoundAway (P 4) (N 2) ~ N 2) -_test_Div_RoundAway_P4_N2 = Dict -_test_Rem_RoundAway_P4_N2 :: Dict (K.Rem 'K.RoundAway (P 4) (N 2) ~ P 0) -_test_Rem_RoundAway_P4_N2 = Dict -_test_Div_RoundAway_P4_N3 :: Dict (K.Div 'K.RoundAway (P 4) (N 3) ~ N 2) -_test_Div_RoundAway_P4_N3 = Dict -_test_Rem_RoundAway_P4_N3 :: Dict (K.Rem 'K.RoundAway (P 4) (N 3) ~ N 2) -_test_Rem_RoundAway_P4_N3 = Dict -_test_Div_RoundAway_P4_N4 :: Dict (K.Div 'K.RoundAway (P 4) (N 4) ~ N 1) -_test_Div_RoundAway_P4_N4 = Dict -_test_Rem_RoundAway_P4_N4 :: Dict (K.Rem 'K.RoundAway (P 4) (N 4) ~ P 0) -_test_Rem_RoundAway_P4_N4 = Dict -_test_Div_RoundAway_P4_P1 :: Dict (K.Div 'K.RoundAway (P 4) (P 1) ~ P 4) -_test_Div_RoundAway_P4_P1 = Dict -_test_Rem_RoundAway_P4_P1 :: Dict (K.Rem 'K.RoundAway (P 4) (P 1) ~ P 0) -_test_Rem_RoundAway_P4_P1 = Dict -_test_Div_RoundAway_P4_P2 :: Dict (K.Div 'K.RoundAway (P 4) (P 2) ~ P 2) -_test_Div_RoundAway_P4_P2 = Dict -_test_Rem_RoundAway_P4_P2 :: Dict (K.Rem 'K.RoundAway (P 4) (P 2) ~ P 0) -_test_Rem_RoundAway_P4_P2 = Dict -_test_Div_RoundAway_P4_P3 :: Dict (K.Div 'K.RoundAway (P 4) (P 3) ~ P 2) -_test_Div_RoundAway_P4_P3 = Dict -_test_Rem_RoundAway_P4_P3 :: Dict (K.Rem 'K.RoundAway (P 4) (P 3) ~ N 2) -_test_Rem_RoundAway_P4_P3 = Dict -_test_Div_RoundAway_P4_P4 :: Dict (K.Div 'K.RoundAway (P 4) (P 4) ~ P 1) -_test_Div_RoundAway_P4_P4 = Dict -_test_Rem_RoundAway_P4_P4 :: Dict (K.Rem 'K.RoundAway (P 4) (P 4) ~ P 0) -_test_Rem_RoundAway_P4_P4 = Dict -_test_Div_RoundDown_N1_N1 :: Dict (K.Div 'K.RoundDown (N 1) (N 1) ~ P 1) -_test_Div_RoundDown_N1_N1 = Dict -_test_Rem_RoundDown_N1_N1 :: Dict (K.Rem 'K.RoundDown (N 1) (N 1) ~ P 0) -_test_Rem_RoundDown_N1_N1 = Dict -_test_Div_RoundDown_N1_N2 :: Dict (K.Div 'K.RoundDown (N 1) (N 2) ~ P 0) -_test_Div_RoundDown_N1_N2 = Dict -_test_Rem_RoundDown_N1_N2 :: Dict (K.Rem 'K.RoundDown (N 1) (N 2) ~ N 1) -_test_Rem_RoundDown_N1_N2 = Dict -_test_Div_RoundDown_N1_N3 :: Dict (K.Div 'K.RoundDown (N 1) (N 3) ~ P 0) -_test_Div_RoundDown_N1_N3 = Dict -_test_Rem_RoundDown_N1_N3 :: Dict (K.Rem 'K.RoundDown (N 1) (N 3) ~ N 1) -_test_Rem_RoundDown_N1_N3 = Dict -_test_Div_RoundDown_N1_N4 :: Dict (K.Div 'K.RoundDown (N 1) (N 4) ~ P 0) -_test_Div_RoundDown_N1_N4 = Dict -_test_Rem_RoundDown_N1_N4 :: Dict (K.Rem 'K.RoundDown (N 1) (N 4) ~ N 1) -_test_Rem_RoundDown_N1_N4 = Dict -_test_Div_RoundDown_N1_P1 :: Dict (K.Div 'K.RoundDown (N 1) (P 1) ~ N 1) -_test_Div_RoundDown_N1_P1 = Dict -_test_Rem_RoundDown_N1_P1 :: Dict (K.Rem 'K.RoundDown (N 1) (P 1) ~ P 0) -_test_Rem_RoundDown_N1_P1 = Dict -_test_Div_RoundDown_N1_P2 :: Dict (K.Div 'K.RoundDown (N 1) (P 2) ~ N 1) -_test_Div_RoundDown_N1_P2 = Dict -_test_Rem_RoundDown_N1_P2 :: Dict (K.Rem 'K.RoundDown (N 1) (P 2) ~ P 1) -_test_Rem_RoundDown_N1_P2 = Dict -_test_Div_RoundDown_N1_P3 :: Dict (K.Div 'K.RoundDown (N 1) (P 3) ~ N 1) -_test_Div_RoundDown_N1_P3 = Dict -_test_Rem_RoundDown_N1_P3 :: Dict (K.Rem 'K.RoundDown (N 1) (P 3) ~ P 2) -_test_Rem_RoundDown_N1_P3 = Dict -_test_Div_RoundDown_N1_P4 :: Dict (K.Div 'K.RoundDown (N 1) (P 4) ~ N 1) -_test_Div_RoundDown_N1_P4 = Dict -_test_Rem_RoundDown_N1_P4 :: Dict (K.Rem 'K.RoundDown (N 1) (P 4) ~ P 3) -_test_Rem_RoundDown_N1_P4 = Dict -_test_Div_RoundDown_N2_N1 :: Dict (K.Div 'K.RoundDown (N 2) (N 1) ~ P 2) -_test_Div_RoundDown_N2_N1 = Dict -_test_Rem_RoundDown_N2_N1 :: Dict (K.Rem 'K.RoundDown (N 2) (N 1) ~ P 0) -_test_Rem_RoundDown_N2_N1 = Dict -_test_Div_RoundDown_N2_N2 :: Dict (K.Div 'K.RoundDown (N 2) (N 2) ~ P 1) -_test_Div_RoundDown_N2_N2 = Dict -_test_Rem_RoundDown_N2_N2 :: Dict (K.Rem 'K.RoundDown (N 2) (N 2) ~ P 0) -_test_Rem_RoundDown_N2_N2 = Dict -_test_Div_RoundDown_N2_N3 :: Dict (K.Div 'K.RoundDown (N 2) (N 3) ~ P 0) -_test_Div_RoundDown_N2_N3 = Dict -_test_Rem_RoundDown_N2_N3 :: Dict (K.Rem 'K.RoundDown (N 2) (N 3) ~ N 2) -_test_Rem_RoundDown_N2_N3 = Dict -_test_Div_RoundDown_N2_N4 :: Dict (K.Div 'K.RoundDown (N 2) (N 4) ~ P 0) -_test_Div_RoundDown_N2_N4 = Dict -_test_Rem_RoundDown_N2_N4 :: Dict (K.Rem 'K.RoundDown (N 2) (N 4) ~ N 2) -_test_Rem_RoundDown_N2_N4 = Dict -_test_Div_RoundDown_N2_P1 :: Dict (K.Div 'K.RoundDown (N 2) (P 1) ~ N 2) -_test_Div_RoundDown_N2_P1 = Dict -_test_Rem_RoundDown_N2_P1 :: Dict (K.Rem 'K.RoundDown (N 2) (P 1) ~ P 0) -_test_Rem_RoundDown_N2_P1 = Dict -_test_Div_RoundDown_N2_P2 :: Dict (K.Div 'K.RoundDown (N 2) (P 2) ~ N 1) -_test_Div_RoundDown_N2_P2 = Dict -_test_Rem_RoundDown_N2_P2 :: Dict (K.Rem 'K.RoundDown (N 2) (P 2) ~ P 0) -_test_Rem_RoundDown_N2_P2 = Dict -_test_Div_RoundDown_N2_P3 :: Dict (K.Div 'K.RoundDown (N 2) (P 3) ~ N 1) -_test_Div_RoundDown_N2_P3 = Dict -_test_Rem_RoundDown_N2_P3 :: Dict (K.Rem 'K.RoundDown (N 2) (P 3) ~ P 1) -_test_Rem_RoundDown_N2_P3 = Dict -_test_Div_RoundDown_N2_P4 :: Dict (K.Div 'K.RoundDown (N 2) (P 4) ~ N 1) -_test_Div_RoundDown_N2_P4 = Dict -_test_Rem_RoundDown_N2_P4 :: Dict (K.Rem 'K.RoundDown (N 2) (P 4) ~ P 2) -_test_Rem_RoundDown_N2_P4 = Dict -_test_Div_RoundDown_N3_N1 :: Dict (K.Div 'K.RoundDown (N 3) (N 1) ~ P 3) -_test_Div_RoundDown_N3_N1 = Dict -_test_Rem_RoundDown_N3_N1 :: Dict (K.Rem 'K.RoundDown (N 3) (N 1) ~ P 0) -_test_Rem_RoundDown_N3_N1 = Dict -_test_Div_RoundDown_N3_N2 :: Dict (K.Div 'K.RoundDown (N 3) (N 2) ~ P 1) -_test_Div_RoundDown_N3_N2 = Dict -_test_Rem_RoundDown_N3_N2 :: Dict (K.Rem 'K.RoundDown (N 3) (N 2) ~ N 1) -_test_Rem_RoundDown_N3_N2 = Dict -_test_Div_RoundDown_N3_N3 :: Dict (K.Div 'K.RoundDown (N 3) (N 3) ~ P 1) -_test_Div_RoundDown_N3_N3 = Dict -_test_Rem_RoundDown_N3_N3 :: Dict (K.Rem 'K.RoundDown (N 3) (N 3) ~ P 0) -_test_Rem_RoundDown_N3_N3 = Dict -_test_Div_RoundDown_N3_N4 :: Dict (K.Div 'K.RoundDown (N 3) (N 4) ~ P 0) -_test_Div_RoundDown_N3_N4 = Dict -_test_Rem_RoundDown_N3_N4 :: Dict (K.Rem 'K.RoundDown (N 3) (N 4) ~ N 3) -_test_Rem_RoundDown_N3_N4 = Dict -_test_Div_RoundDown_N3_P1 :: Dict (K.Div 'K.RoundDown (N 3) (P 1) ~ N 3) -_test_Div_RoundDown_N3_P1 = Dict -_test_Rem_RoundDown_N3_P1 :: Dict (K.Rem 'K.RoundDown (N 3) (P 1) ~ P 0) -_test_Rem_RoundDown_N3_P1 = Dict -_test_Div_RoundDown_N3_P2 :: Dict (K.Div 'K.RoundDown (N 3) (P 2) ~ N 2) -_test_Div_RoundDown_N3_P2 = Dict -_test_Rem_RoundDown_N3_P2 :: Dict (K.Rem 'K.RoundDown (N 3) (P 2) ~ P 1) -_test_Rem_RoundDown_N3_P2 = Dict -_test_Div_RoundDown_N3_P3 :: Dict (K.Div 'K.RoundDown (N 3) (P 3) ~ N 1) -_test_Div_RoundDown_N3_P3 = Dict -_test_Rem_RoundDown_N3_P3 :: Dict (K.Rem 'K.RoundDown (N 3) (P 3) ~ P 0) -_test_Rem_RoundDown_N3_P3 = Dict -_test_Div_RoundDown_N3_P4 :: Dict (K.Div 'K.RoundDown (N 3) (P 4) ~ N 1) -_test_Div_RoundDown_N3_P4 = Dict -_test_Rem_RoundDown_N3_P4 :: Dict (K.Rem 'K.RoundDown (N 3) (P 4) ~ P 1) -_test_Rem_RoundDown_N3_P4 = Dict -_test_Div_RoundDown_N4_N1 :: Dict (K.Div 'K.RoundDown (N 4) (N 1) ~ P 4) -_test_Div_RoundDown_N4_N1 = Dict -_test_Rem_RoundDown_N4_N1 :: Dict (K.Rem 'K.RoundDown (N 4) (N 1) ~ P 0) -_test_Rem_RoundDown_N4_N1 = Dict -_test_Div_RoundDown_N4_N2 :: Dict (K.Div 'K.RoundDown (N 4) (N 2) ~ P 2) -_test_Div_RoundDown_N4_N2 = Dict -_test_Rem_RoundDown_N4_N2 :: Dict (K.Rem 'K.RoundDown (N 4) (N 2) ~ P 0) -_test_Rem_RoundDown_N4_N2 = Dict -_test_Div_RoundDown_N4_N3 :: Dict (K.Div 'K.RoundDown (N 4) (N 3) ~ P 1) -_test_Div_RoundDown_N4_N3 = Dict -_test_Rem_RoundDown_N4_N3 :: Dict (K.Rem 'K.RoundDown (N 4) (N 3) ~ N 1) -_test_Rem_RoundDown_N4_N3 = Dict -_test_Div_RoundDown_N4_N4 :: Dict (K.Div 'K.RoundDown (N 4) (N 4) ~ P 1) -_test_Div_RoundDown_N4_N4 = Dict -_test_Rem_RoundDown_N4_N4 :: Dict (K.Rem 'K.RoundDown (N 4) (N 4) ~ P 0) -_test_Rem_RoundDown_N4_N4 = Dict -_test_Div_RoundDown_N4_P1 :: Dict (K.Div 'K.RoundDown (N 4) (P 1) ~ N 4) -_test_Div_RoundDown_N4_P1 = Dict -_test_Rem_RoundDown_N4_P1 :: Dict (K.Rem 'K.RoundDown (N 4) (P 1) ~ P 0) -_test_Rem_RoundDown_N4_P1 = Dict -_test_Div_RoundDown_N4_P2 :: Dict (K.Div 'K.RoundDown (N 4) (P 2) ~ N 2) -_test_Div_RoundDown_N4_P2 = Dict -_test_Rem_RoundDown_N4_P2 :: Dict (K.Rem 'K.RoundDown (N 4) (P 2) ~ P 0) -_test_Rem_RoundDown_N4_P2 = Dict -_test_Div_RoundDown_N4_P3 :: Dict (K.Div 'K.RoundDown (N 4) (P 3) ~ N 2) -_test_Div_RoundDown_N4_P3 = Dict -_test_Rem_RoundDown_N4_P3 :: Dict (K.Rem 'K.RoundDown (N 4) (P 3) ~ P 2) -_test_Rem_RoundDown_N4_P3 = Dict -_test_Div_RoundDown_N4_P4 :: Dict (K.Div 'K.RoundDown (N 4) (P 4) ~ N 1) -_test_Div_RoundDown_N4_P4 = Dict -_test_Rem_RoundDown_N4_P4 :: Dict (K.Rem 'K.RoundDown (N 4) (P 4) ~ P 0) -_test_Rem_RoundDown_N4_P4 = Dict -_test_Div_RoundDown_P0_N1 :: Dict (K.Div 'K.RoundDown (P 0) (N 1) ~ P 0) -_test_Div_RoundDown_P0_N1 = Dict -_test_Rem_RoundDown_P0_N1 :: Dict (K.Rem 'K.RoundDown (P 0) (N 1) ~ P 0) -_test_Rem_RoundDown_P0_N1 = Dict -_test_Div_RoundDown_P0_N2 :: Dict (K.Div 'K.RoundDown (P 0) (N 2) ~ P 0) -_test_Div_RoundDown_P0_N2 = Dict -_test_Rem_RoundDown_P0_N2 :: Dict (K.Rem 'K.RoundDown (P 0) (N 2) ~ P 0) -_test_Rem_RoundDown_P0_N2 = Dict -_test_Div_RoundDown_P0_N3 :: Dict (K.Div 'K.RoundDown (P 0) (N 3) ~ P 0) -_test_Div_RoundDown_P0_N3 = Dict -_test_Rem_RoundDown_P0_N3 :: Dict (K.Rem 'K.RoundDown (P 0) (N 3) ~ P 0) -_test_Rem_RoundDown_P0_N3 = Dict -_test_Div_RoundDown_P0_N4 :: Dict (K.Div 'K.RoundDown (P 0) (N 4) ~ P 0) -_test_Div_RoundDown_P0_N4 = Dict -_test_Rem_RoundDown_P0_N4 :: Dict (K.Rem 'K.RoundDown (P 0) (N 4) ~ P 0) -_test_Rem_RoundDown_P0_N4 = Dict -_test_Div_RoundDown_P0_P1 :: Dict (K.Div 'K.RoundDown (P 0) (P 1) ~ P 0) -_test_Div_RoundDown_P0_P1 = Dict -_test_Rem_RoundDown_P0_P1 :: Dict (K.Rem 'K.RoundDown (P 0) (P 1) ~ P 0) -_test_Rem_RoundDown_P0_P1 = Dict -_test_Div_RoundDown_P0_P2 :: Dict (K.Div 'K.RoundDown (P 0) (P 2) ~ P 0) -_test_Div_RoundDown_P0_P2 = Dict -_test_Rem_RoundDown_P0_P2 :: Dict (K.Rem 'K.RoundDown (P 0) (P 2) ~ P 0) -_test_Rem_RoundDown_P0_P2 = Dict -_test_Div_RoundDown_P0_P3 :: Dict (K.Div 'K.RoundDown (P 0) (P 3) ~ P 0) -_test_Div_RoundDown_P0_P3 = Dict -_test_Rem_RoundDown_P0_P3 :: Dict (K.Rem 'K.RoundDown (P 0) (P 3) ~ P 0) -_test_Rem_RoundDown_P0_P3 = Dict -_test_Div_RoundDown_P0_P4 :: Dict (K.Div 'K.RoundDown (P 0) (P 4) ~ P 0) -_test_Div_RoundDown_P0_P4 = Dict -_test_Rem_RoundDown_P0_P4 :: Dict (K.Rem 'K.RoundDown (P 0) (P 4) ~ P 0) -_test_Rem_RoundDown_P0_P4 = Dict -_test_Div_RoundDown_P1_N1 :: Dict (K.Div 'K.RoundDown (P 1) (N 1) ~ N 1) -_test_Div_RoundDown_P1_N1 = Dict -_test_Rem_RoundDown_P1_N1 :: Dict (K.Rem 'K.RoundDown (P 1) (N 1) ~ P 0) -_test_Rem_RoundDown_P1_N1 = Dict -_test_Div_RoundDown_P1_N2 :: Dict (K.Div 'K.RoundDown (P 1) (N 2) ~ N 1) -_test_Div_RoundDown_P1_N2 = Dict -_test_Rem_RoundDown_P1_N2 :: Dict (K.Rem 'K.RoundDown (P 1) (N 2) ~ N 1) -_test_Rem_RoundDown_P1_N2 = Dict -_test_Div_RoundDown_P1_N3 :: Dict (K.Div 'K.RoundDown (P 1) (N 3) ~ N 1) -_test_Div_RoundDown_P1_N3 = Dict -_test_Rem_RoundDown_P1_N3 :: Dict (K.Rem 'K.RoundDown (P 1) (N 3) ~ N 2) -_test_Rem_RoundDown_P1_N3 = Dict -_test_Div_RoundDown_P1_N4 :: Dict (K.Div 'K.RoundDown (P 1) (N 4) ~ N 1) -_test_Div_RoundDown_P1_N4 = Dict -_test_Rem_RoundDown_P1_N4 :: Dict (K.Rem 'K.RoundDown (P 1) (N 4) ~ N 3) -_test_Rem_RoundDown_P1_N4 = Dict -_test_Div_RoundDown_P1_P1 :: Dict (K.Div 'K.RoundDown (P 1) (P 1) ~ P 1) -_test_Div_RoundDown_P1_P1 = Dict -_test_Rem_RoundDown_P1_P1 :: Dict (K.Rem 'K.RoundDown (P 1) (P 1) ~ P 0) -_test_Rem_RoundDown_P1_P1 = Dict -_test_Div_RoundDown_P1_P2 :: Dict (K.Div 'K.RoundDown (P 1) (P 2) ~ P 0) -_test_Div_RoundDown_P1_P2 = Dict -_test_Rem_RoundDown_P1_P2 :: Dict (K.Rem 'K.RoundDown (P 1) (P 2) ~ P 1) -_test_Rem_RoundDown_P1_P2 = Dict -_test_Div_RoundDown_P1_P3 :: Dict (K.Div 'K.RoundDown (P 1) (P 3) ~ P 0) -_test_Div_RoundDown_P1_P3 = Dict -_test_Rem_RoundDown_P1_P3 :: Dict (K.Rem 'K.RoundDown (P 1) (P 3) ~ P 1) -_test_Rem_RoundDown_P1_P3 = Dict -_test_Div_RoundDown_P1_P4 :: Dict (K.Div 'K.RoundDown (P 1) (P 4) ~ P 0) -_test_Div_RoundDown_P1_P4 = Dict -_test_Rem_RoundDown_P1_P4 :: Dict (K.Rem 'K.RoundDown (P 1) (P 4) ~ P 1) -_test_Rem_RoundDown_P1_P4 = Dict -_test_Div_RoundDown_P2_N1 :: Dict (K.Div 'K.RoundDown (P 2) (N 1) ~ N 2) -_test_Div_RoundDown_P2_N1 = Dict -_test_Rem_RoundDown_P2_N1 :: Dict (K.Rem 'K.RoundDown (P 2) (N 1) ~ P 0) -_test_Rem_RoundDown_P2_N1 = Dict -_test_Div_RoundDown_P2_N2 :: Dict (K.Div 'K.RoundDown (P 2) (N 2) ~ N 1) -_test_Div_RoundDown_P2_N2 = Dict -_test_Rem_RoundDown_P2_N2 :: Dict (K.Rem 'K.RoundDown (P 2) (N 2) ~ P 0) -_test_Rem_RoundDown_P2_N2 = Dict -_test_Div_RoundDown_P2_N3 :: Dict (K.Div 'K.RoundDown (P 2) (N 3) ~ N 1) -_test_Div_RoundDown_P2_N3 = Dict -_test_Rem_RoundDown_P2_N3 :: Dict (K.Rem 'K.RoundDown (P 2) (N 3) ~ N 1) -_test_Rem_RoundDown_P2_N3 = Dict -_test_Div_RoundDown_P2_N4 :: Dict (K.Div 'K.RoundDown (P 2) (N 4) ~ N 1) -_test_Div_RoundDown_P2_N4 = Dict -_test_Rem_RoundDown_P2_N4 :: Dict (K.Rem 'K.RoundDown (P 2) (N 4) ~ N 2) -_test_Rem_RoundDown_P2_N4 = Dict -_test_Div_RoundDown_P2_P1 :: Dict (K.Div 'K.RoundDown (P 2) (P 1) ~ P 2) -_test_Div_RoundDown_P2_P1 = Dict -_test_Rem_RoundDown_P2_P1 :: Dict (K.Rem 'K.RoundDown (P 2) (P 1) ~ P 0) -_test_Rem_RoundDown_P2_P1 = Dict -_test_Div_RoundDown_P2_P2 :: Dict (K.Div 'K.RoundDown (P 2) (P 2) ~ P 1) -_test_Div_RoundDown_P2_P2 = Dict -_test_Rem_RoundDown_P2_P2 :: Dict (K.Rem 'K.RoundDown (P 2) (P 2) ~ P 0) -_test_Rem_RoundDown_P2_P2 = Dict -_test_Div_RoundDown_P2_P3 :: Dict (K.Div 'K.RoundDown (P 2) (P 3) ~ P 0) -_test_Div_RoundDown_P2_P3 = Dict -_test_Rem_RoundDown_P2_P3 :: Dict (K.Rem 'K.RoundDown (P 2) (P 3) ~ P 2) -_test_Rem_RoundDown_P2_P3 = Dict -_test_Div_RoundDown_P2_P4 :: Dict (K.Div 'K.RoundDown (P 2) (P 4) ~ P 0) -_test_Div_RoundDown_P2_P4 = Dict -_test_Rem_RoundDown_P2_P4 :: Dict (K.Rem 'K.RoundDown (P 2) (P 4) ~ P 2) -_test_Rem_RoundDown_P2_P4 = Dict -_test_Div_RoundDown_P3_N1 :: Dict (K.Div 'K.RoundDown (P 3) (N 1) ~ N 3) -_test_Div_RoundDown_P3_N1 = Dict -_test_Rem_RoundDown_P3_N1 :: Dict (K.Rem 'K.RoundDown (P 3) (N 1) ~ P 0) -_test_Rem_RoundDown_P3_N1 = Dict -_test_Div_RoundDown_P3_N2 :: Dict (K.Div 'K.RoundDown (P 3) (N 2) ~ N 2) -_test_Div_RoundDown_P3_N2 = Dict -_test_Rem_RoundDown_P3_N2 :: Dict (K.Rem 'K.RoundDown (P 3) (N 2) ~ N 1) -_test_Rem_RoundDown_P3_N2 = Dict -_test_Div_RoundDown_P3_N3 :: Dict (K.Div 'K.RoundDown (P 3) (N 3) ~ N 1) -_test_Div_RoundDown_P3_N3 = Dict -_test_Rem_RoundDown_P3_N3 :: Dict (K.Rem 'K.RoundDown (P 3) (N 3) ~ P 0) -_test_Rem_RoundDown_P3_N3 = Dict -_test_Div_RoundDown_P3_N4 :: Dict (K.Div 'K.RoundDown (P 3) (N 4) ~ N 1) -_test_Div_RoundDown_P3_N4 = Dict -_test_Rem_RoundDown_P3_N4 :: Dict (K.Rem 'K.RoundDown (P 3) (N 4) ~ N 1) -_test_Rem_RoundDown_P3_N4 = Dict -_test_Div_RoundDown_P3_P1 :: Dict (K.Div 'K.RoundDown (P 3) (P 1) ~ P 3) -_test_Div_RoundDown_P3_P1 = Dict -_test_Rem_RoundDown_P3_P1 :: Dict (K.Rem 'K.RoundDown (P 3) (P 1) ~ P 0) -_test_Rem_RoundDown_P3_P1 = Dict -_test_Div_RoundDown_P3_P2 :: Dict (K.Div 'K.RoundDown (P 3) (P 2) ~ P 1) -_test_Div_RoundDown_P3_P2 = Dict -_test_Rem_RoundDown_P3_P2 :: Dict (K.Rem 'K.RoundDown (P 3) (P 2) ~ P 1) -_test_Rem_RoundDown_P3_P2 = Dict -_test_Div_RoundDown_P3_P3 :: Dict (K.Div 'K.RoundDown (P 3) (P 3) ~ P 1) -_test_Div_RoundDown_P3_P3 = Dict -_test_Rem_RoundDown_P3_P3 :: Dict (K.Rem 'K.RoundDown (P 3) (P 3) ~ P 0) -_test_Rem_RoundDown_P3_P3 = Dict -_test_Div_RoundDown_P3_P4 :: Dict (K.Div 'K.RoundDown (P 3) (P 4) ~ P 0) -_test_Div_RoundDown_P3_P4 = Dict -_test_Rem_RoundDown_P3_P4 :: Dict (K.Rem 'K.RoundDown (P 3) (P 4) ~ P 3) -_test_Rem_RoundDown_P3_P4 = Dict -_test_Div_RoundDown_P4_N1 :: Dict (K.Div 'K.RoundDown (P 4) (N 1) ~ N 4) -_test_Div_RoundDown_P4_N1 = Dict -_test_Rem_RoundDown_P4_N1 :: Dict (K.Rem 'K.RoundDown (P 4) (N 1) ~ P 0) -_test_Rem_RoundDown_P4_N1 = Dict -_test_Div_RoundDown_P4_N2 :: Dict (K.Div 'K.RoundDown (P 4) (N 2) ~ N 2) -_test_Div_RoundDown_P4_N2 = Dict -_test_Rem_RoundDown_P4_N2 :: Dict (K.Rem 'K.RoundDown (P 4) (N 2) ~ P 0) -_test_Rem_RoundDown_P4_N2 = Dict -_test_Div_RoundDown_P4_N3 :: Dict (K.Div 'K.RoundDown (P 4) (N 3) ~ N 2) -_test_Div_RoundDown_P4_N3 = Dict -_test_Rem_RoundDown_P4_N3 :: Dict (K.Rem 'K.RoundDown (P 4) (N 3) ~ N 2) -_test_Rem_RoundDown_P4_N3 = Dict -_test_Div_RoundDown_P4_N4 :: Dict (K.Div 'K.RoundDown (P 4) (N 4) ~ N 1) -_test_Div_RoundDown_P4_N4 = Dict -_test_Rem_RoundDown_P4_N4 :: Dict (K.Rem 'K.RoundDown (P 4) (N 4) ~ P 0) -_test_Rem_RoundDown_P4_N4 = Dict -_test_Div_RoundDown_P4_P1 :: Dict (K.Div 'K.RoundDown (P 4) (P 1) ~ P 4) -_test_Div_RoundDown_P4_P1 = Dict -_test_Rem_RoundDown_P4_P1 :: Dict (K.Rem 'K.RoundDown (P 4) (P 1) ~ P 0) -_test_Rem_RoundDown_P4_P1 = Dict -_test_Div_RoundDown_P4_P2 :: Dict (K.Div 'K.RoundDown (P 4) (P 2) ~ P 2) -_test_Div_RoundDown_P4_P2 = Dict -_test_Rem_RoundDown_P4_P2 :: Dict (K.Rem 'K.RoundDown (P 4) (P 2) ~ P 0) -_test_Rem_RoundDown_P4_P2 = Dict -_test_Div_RoundDown_P4_P3 :: Dict (K.Div 'K.RoundDown (P 4) (P 3) ~ P 1) -_test_Div_RoundDown_P4_P3 = Dict -_test_Rem_RoundDown_P4_P3 :: Dict (K.Rem 'K.RoundDown (P 4) (P 3) ~ P 1) -_test_Rem_RoundDown_P4_P3 = Dict -_test_Div_RoundDown_P4_P4 :: Dict (K.Div 'K.RoundDown (P 4) (P 4) ~ P 1) -_test_Div_RoundDown_P4_P4 = Dict -_test_Rem_RoundDown_P4_P4 :: Dict (K.Rem 'K.RoundDown (P 4) (P 4) ~ P 0) -_test_Rem_RoundDown_P4_P4 = Dict -_test_Div_RoundHalfAway_N1_N1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfAway_N1_N1 = Dict -_test_Rem_RoundHalfAway_N1_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_N1_N1 = Dict -_test_Div_RoundHalfAway_N1_N2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 2) ~ P 1) -_test_Div_RoundHalfAway_N1_N2 = Dict -_test_Rem_RoundHalfAway_N1_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 2) ~ P 1) -_test_Rem_RoundHalfAway_N1_N2 = Dict -_test_Div_RoundHalfAway_N1_N3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfAway_N1_N3 = Dict -_test_Rem_RoundHalfAway_N1_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfAway_N1_N3 = Dict -_test_Div_RoundHalfAway_N1_N4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfAway_N1_N4 = Dict -_test_Rem_RoundHalfAway_N1_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfAway_N1_N4 = Dict -_test_Div_RoundHalfAway_N1_P1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfAway_N1_P1 = Dict -_test_Rem_RoundHalfAway_N1_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_N1_P1 = Dict -_test_Div_RoundHalfAway_N1_P2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 2) ~ N 1) -_test_Div_RoundHalfAway_N1_P2 = Dict -_test_Rem_RoundHalfAway_N1_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 2) ~ P 1) -_test_Rem_RoundHalfAway_N1_P2 = Dict -_test_Div_RoundHalfAway_N1_P3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfAway_N1_P3 = Dict -_test_Rem_RoundHalfAway_N1_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfAway_N1_P3 = Dict -_test_Div_RoundHalfAway_N1_P4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfAway_N1_P4 = Dict -_test_Rem_RoundHalfAway_N1_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfAway_N1_P4 = Dict -_test_Div_RoundHalfAway_N2_N1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfAway_N2_N1 = Dict -_test_Rem_RoundHalfAway_N2_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_N2_N1 = Dict -_test_Div_RoundHalfAway_N2_N2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfAway_N2_N2 = Dict -_test_Rem_RoundHalfAway_N2_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfAway_N2_N2 = Dict -_test_Div_RoundHalfAway_N2_N3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfAway_N2_N3 = Dict -_test_Rem_RoundHalfAway_N2_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfAway_N2_N3 = Dict -_test_Div_RoundHalfAway_N2_N4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 4) ~ P 1) -_test_Div_RoundHalfAway_N2_N4 = Dict -_test_Rem_RoundHalfAway_N2_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 4) ~ P 2) -_test_Rem_RoundHalfAway_N2_N4 = Dict -_test_Div_RoundHalfAway_N2_P1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfAway_N2_P1 = Dict -_test_Rem_RoundHalfAway_N2_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_N2_P1 = Dict -_test_Div_RoundHalfAway_N2_P2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfAway_N2_P2 = Dict -_test_Rem_RoundHalfAway_N2_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfAway_N2_P2 = Dict -_test_Div_RoundHalfAway_N2_P3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfAway_N2_P3 = Dict -_test_Rem_RoundHalfAway_N2_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfAway_N2_P3 = Dict -_test_Div_RoundHalfAway_N2_P4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 4) ~ N 1) -_test_Div_RoundHalfAway_N2_P4 = Dict -_test_Rem_RoundHalfAway_N2_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 4) ~ P 2) -_test_Rem_RoundHalfAway_N2_P4 = Dict -_test_Div_RoundHalfAway_N3_N1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfAway_N3_N1 = Dict -_test_Rem_RoundHalfAway_N3_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_N3_N1 = Dict -_test_Div_RoundHalfAway_N3_N2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 2) ~ P 2) -_test_Div_RoundHalfAway_N3_N2 = Dict -_test_Rem_RoundHalfAway_N3_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 2) ~ P 1) -_test_Rem_RoundHalfAway_N3_N2 = Dict -_test_Div_RoundHalfAway_N3_N3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfAway_N3_N3 = Dict -_test_Rem_RoundHalfAway_N3_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfAway_N3_N3 = Dict -_test_Div_RoundHalfAway_N3_N4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfAway_N3_N4 = Dict -_test_Rem_RoundHalfAway_N3_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfAway_N3_N4 = Dict -_test_Div_RoundHalfAway_N3_P1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfAway_N3_P1 = Dict -_test_Rem_RoundHalfAway_N3_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_N3_P1 = Dict -_test_Div_RoundHalfAway_N3_P2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 2) ~ N 2) -_test_Div_RoundHalfAway_N3_P2 = Dict -_test_Rem_RoundHalfAway_N3_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 2) ~ P 1) -_test_Rem_RoundHalfAway_N3_P2 = Dict -_test_Div_RoundHalfAway_N3_P3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfAway_N3_P3 = Dict -_test_Rem_RoundHalfAway_N3_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfAway_N3_P3 = Dict -_test_Div_RoundHalfAway_N3_P4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfAway_N3_P4 = Dict -_test_Rem_RoundHalfAway_N3_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfAway_N3_P4 = Dict -_test_Div_RoundHalfAway_N4_N1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfAway_N4_N1 = Dict -_test_Rem_RoundHalfAway_N4_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_N4_N1 = Dict -_test_Div_RoundHalfAway_N4_N2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfAway_N4_N2 = Dict -_test_Rem_RoundHalfAway_N4_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfAway_N4_N2 = Dict -_test_Div_RoundHalfAway_N4_N3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfAway_N4_N3 = Dict -_test_Rem_RoundHalfAway_N4_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfAway_N4_N3 = Dict -_test_Div_RoundHalfAway_N4_N4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfAway_N4_N4 = Dict -_test_Rem_RoundHalfAway_N4_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfAway_N4_N4 = Dict -_test_Div_RoundHalfAway_N4_P1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfAway_N4_P1 = Dict -_test_Rem_RoundHalfAway_N4_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_N4_P1 = Dict -_test_Div_RoundHalfAway_N4_P2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfAway_N4_P2 = Dict -_test_Rem_RoundHalfAway_N4_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfAway_N4_P2 = Dict -_test_Div_RoundHalfAway_N4_P3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfAway_N4_P3 = Dict -_test_Rem_RoundHalfAway_N4_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfAway_N4_P3 = Dict -_test_Div_RoundHalfAway_N4_P4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfAway_N4_P4 = Dict -_test_Rem_RoundHalfAway_N4_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfAway_N4_P4 = Dict -_test_Div_RoundHalfAway_P0_N1 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfAway_P0_N1 = Dict -_test_Rem_RoundHalfAway_P0_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_P0_N1 = Dict -_test_Div_RoundHalfAway_P0_N2 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfAway_P0_N2 = Dict -_test_Rem_RoundHalfAway_P0_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfAway_P0_N2 = Dict -_test_Div_RoundHalfAway_P0_N3 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfAway_P0_N3 = Dict -_test_Rem_RoundHalfAway_P0_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfAway_P0_N3 = Dict -_test_Div_RoundHalfAway_P0_N4 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfAway_P0_N4 = Dict -_test_Rem_RoundHalfAway_P0_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfAway_P0_N4 = Dict -_test_Div_RoundHalfAway_P0_P1 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfAway_P0_P1 = Dict -_test_Rem_RoundHalfAway_P0_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_P0_P1 = Dict -_test_Div_RoundHalfAway_P0_P2 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfAway_P0_P2 = Dict -_test_Rem_RoundHalfAway_P0_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfAway_P0_P2 = Dict -_test_Div_RoundHalfAway_P0_P3 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfAway_P0_P3 = Dict -_test_Rem_RoundHalfAway_P0_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfAway_P0_P3 = Dict -_test_Div_RoundHalfAway_P0_P4 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfAway_P0_P4 = Dict -_test_Rem_RoundHalfAway_P0_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfAway_P0_P4 = Dict -_test_Div_RoundHalfAway_P1_N1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfAway_P1_N1 = Dict -_test_Rem_RoundHalfAway_P1_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_P1_N1 = Dict -_test_Div_RoundHalfAway_P1_N2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 2) ~ N 1) -_test_Div_RoundHalfAway_P1_N2 = Dict -_test_Rem_RoundHalfAway_P1_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 2) ~ N 1) -_test_Rem_RoundHalfAway_P1_N2 = Dict -_test_Div_RoundHalfAway_P1_N3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfAway_P1_N3 = Dict -_test_Rem_RoundHalfAway_P1_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfAway_P1_N3 = Dict -_test_Div_RoundHalfAway_P1_N4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfAway_P1_N4 = Dict -_test_Rem_RoundHalfAway_P1_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfAway_P1_N4 = Dict -_test_Div_RoundHalfAway_P1_P1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfAway_P1_P1 = Dict -_test_Rem_RoundHalfAway_P1_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_P1_P1 = Dict -_test_Div_RoundHalfAway_P1_P2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 2) ~ P 1) -_test_Div_RoundHalfAway_P1_P2 = Dict -_test_Rem_RoundHalfAway_P1_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 2) ~ N 1) -_test_Rem_RoundHalfAway_P1_P2 = Dict -_test_Div_RoundHalfAway_P1_P3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfAway_P1_P3 = Dict -_test_Rem_RoundHalfAway_P1_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfAway_P1_P3 = Dict -_test_Div_RoundHalfAway_P1_P4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfAway_P1_P4 = Dict -_test_Rem_RoundHalfAway_P1_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfAway_P1_P4 = Dict -_test_Div_RoundHalfAway_P2_N1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfAway_P2_N1 = Dict -_test_Rem_RoundHalfAway_P2_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_P2_N1 = Dict -_test_Div_RoundHalfAway_P2_N2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfAway_P2_N2 = Dict -_test_Rem_RoundHalfAway_P2_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfAway_P2_N2 = Dict -_test_Div_RoundHalfAway_P2_N3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfAway_P2_N3 = Dict -_test_Rem_RoundHalfAway_P2_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfAway_P2_N3 = Dict -_test_Div_RoundHalfAway_P2_N4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 4) ~ N 1) -_test_Div_RoundHalfAway_P2_N4 = Dict -_test_Rem_RoundHalfAway_P2_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 4) ~ N 2) -_test_Rem_RoundHalfAway_P2_N4 = Dict -_test_Div_RoundHalfAway_P2_P1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfAway_P2_P1 = Dict -_test_Rem_RoundHalfAway_P2_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_P2_P1 = Dict -_test_Div_RoundHalfAway_P2_P2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfAway_P2_P2 = Dict -_test_Rem_RoundHalfAway_P2_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfAway_P2_P2 = Dict -_test_Div_RoundHalfAway_P2_P3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfAway_P2_P3 = Dict -_test_Rem_RoundHalfAway_P2_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfAway_P2_P3 = Dict -_test_Div_RoundHalfAway_P2_P4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 4) ~ P 1) -_test_Div_RoundHalfAway_P2_P4 = Dict -_test_Rem_RoundHalfAway_P2_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 4) ~ N 2) -_test_Rem_RoundHalfAway_P2_P4 = Dict -_test_Div_RoundHalfAway_P3_N1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfAway_P3_N1 = Dict -_test_Rem_RoundHalfAway_P3_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_P3_N1 = Dict -_test_Div_RoundHalfAway_P3_N2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 2) ~ N 2) -_test_Div_RoundHalfAway_P3_N2 = Dict -_test_Rem_RoundHalfAway_P3_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 2) ~ N 1) -_test_Rem_RoundHalfAway_P3_N2 = Dict -_test_Div_RoundHalfAway_P3_N3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfAway_P3_N3 = Dict -_test_Rem_RoundHalfAway_P3_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfAway_P3_N3 = Dict -_test_Div_RoundHalfAway_P3_N4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfAway_P3_N4 = Dict -_test_Rem_RoundHalfAway_P3_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfAway_P3_N4 = Dict -_test_Div_RoundHalfAway_P3_P1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfAway_P3_P1 = Dict -_test_Rem_RoundHalfAway_P3_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_P3_P1 = Dict -_test_Div_RoundHalfAway_P3_P2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 2) ~ P 2) -_test_Div_RoundHalfAway_P3_P2 = Dict -_test_Rem_RoundHalfAway_P3_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 2) ~ N 1) -_test_Rem_RoundHalfAway_P3_P2 = Dict -_test_Div_RoundHalfAway_P3_P3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfAway_P3_P3 = Dict -_test_Rem_RoundHalfAway_P3_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfAway_P3_P3 = Dict -_test_Div_RoundHalfAway_P3_P4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfAway_P3_P4 = Dict -_test_Rem_RoundHalfAway_P3_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfAway_P3_P4 = Dict -_test_Div_RoundHalfAway_P4_N1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfAway_P4_N1 = Dict -_test_Rem_RoundHalfAway_P4_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfAway_P4_N1 = Dict -_test_Div_RoundHalfAway_P4_N2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfAway_P4_N2 = Dict -_test_Rem_RoundHalfAway_P4_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfAway_P4_N2 = Dict -_test_Div_RoundHalfAway_P4_N3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfAway_P4_N3 = Dict -_test_Rem_RoundHalfAway_P4_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfAway_P4_N3 = Dict -_test_Div_RoundHalfAway_P4_N4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfAway_P4_N4 = Dict -_test_Rem_RoundHalfAway_P4_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfAway_P4_N4 = Dict -_test_Div_RoundHalfAway_P4_P1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfAway_P4_P1 = Dict -_test_Rem_RoundHalfAway_P4_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfAway_P4_P1 = Dict -_test_Div_RoundHalfAway_P4_P2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfAway_P4_P2 = Dict -_test_Rem_RoundHalfAway_P4_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfAway_P4_P2 = Dict -_test_Div_RoundHalfAway_P4_P3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfAway_P4_P3 = Dict -_test_Rem_RoundHalfAway_P4_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfAway_P4_P3 = Dict -_test_Div_RoundHalfAway_P4_P4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfAway_P4_P4 = Dict -_test_Rem_RoundHalfAway_P4_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfAway_P4_P4 = Dict -_test_Div_RoundHalfDown_N1_N1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfDown_N1_N1 = Dict -_test_Rem_RoundHalfDown_N1_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_N1_N1 = Dict -_test_Div_RoundHalfDown_N1_N2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 2) ~ P 0) -_test_Div_RoundHalfDown_N1_N2 = Dict -_test_Rem_RoundHalfDown_N1_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 2) ~ N 1) -_test_Rem_RoundHalfDown_N1_N2 = Dict -_test_Div_RoundHalfDown_N1_N3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfDown_N1_N3 = Dict -_test_Rem_RoundHalfDown_N1_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfDown_N1_N3 = Dict -_test_Div_RoundHalfDown_N1_N4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfDown_N1_N4 = Dict -_test_Rem_RoundHalfDown_N1_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfDown_N1_N4 = Dict -_test_Div_RoundHalfDown_N1_P1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfDown_N1_P1 = Dict -_test_Rem_RoundHalfDown_N1_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_N1_P1 = Dict -_test_Div_RoundHalfDown_N1_P2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 2) ~ N 1) -_test_Div_RoundHalfDown_N1_P2 = Dict -_test_Rem_RoundHalfDown_N1_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 2) ~ P 1) -_test_Rem_RoundHalfDown_N1_P2 = Dict -_test_Div_RoundHalfDown_N1_P3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfDown_N1_P3 = Dict -_test_Rem_RoundHalfDown_N1_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfDown_N1_P3 = Dict -_test_Div_RoundHalfDown_N1_P4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfDown_N1_P4 = Dict -_test_Rem_RoundHalfDown_N1_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfDown_N1_P4 = Dict -_test_Div_RoundHalfDown_N2_N1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfDown_N2_N1 = Dict -_test_Rem_RoundHalfDown_N2_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_N2_N1 = Dict -_test_Div_RoundHalfDown_N2_N2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfDown_N2_N2 = Dict -_test_Rem_RoundHalfDown_N2_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfDown_N2_N2 = Dict -_test_Div_RoundHalfDown_N2_N3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfDown_N2_N3 = Dict -_test_Rem_RoundHalfDown_N2_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfDown_N2_N3 = Dict -_test_Div_RoundHalfDown_N2_N4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 4) ~ P 0) -_test_Div_RoundHalfDown_N2_N4 = Dict -_test_Rem_RoundHalfDown_N2_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 4) ~ N 2) -_test_Rem_RoundHalfDown_N2_N4 = Dict -_test_Div_RoundHalfDown_N2_P1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfDown_N2_P1 = Dict -_test_Rem_RoundHalfDown_N2_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_N2_P1 = Dict -_test_Div_RoundHalfDown_N2_P2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfDown_N2_P2 = Dict -_test_Rem_RoundHalfDown_N2_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfDown_N2_P2 = Dict -_test_Div_RoundHalfDown_N2_P3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfDown_N2_P3 = Dict -_test_Rem_RoundHalfDown_N2_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfDown_N2_P3 = Dict -_test_Div_RoundHalfDown_N2_P4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 4) ~ N 1) -_test_Div_RoundHalfDown_N2_P4 = Dict -_test_Rem_RoundHalfDown_N2_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 4) ~ P 2) -_test_Rem_RoundHalfDown_N2_P4 = Dict -_test_Div_RoundHalfDown_N3_N1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfDown_N3_N1 = Dict -_test_Rem_RoundHalfDown_N3_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_N3_N1 = Dict -_test_Div_RoundHalfDown_N3_N2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 2) ~ P 1) -_test_Div_RoundHalfDown_N3_N2 = Dict -_test_Rem_RoundHalfDown_N3_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 2) ~ N 1) -_test_Rem_RoundHalfDown_N3_N2 = Dict -_test_Div_RoundHalfDown_N3_N3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfDown_N3_N3 = Dict -_test_Rem_RoundHalfDown_N3_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfDown_N3_N3 = Dict -_test_Div_RoundHalfDown_N3_N4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfDown_N3_N4 = Dict -_test_Rem_RoundHalfDown_N3_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfDown_N3_N4 = Dict -_test_Div_RoundHalfDown_N3_P1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfDown_N3_P1 = Dict -_test_Rem_RoundHalfDown_N3_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_N3_P1 = Dict -_test_Div_RoundHalfDown_N3_P2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 2) ~ N 2) -_test_Div_RoundHalfDown_N3_P2 = Dict -_test_Rem_RoundHalfDown_N3_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 2) ~ P 1) -_test_Rem_RoundHalfDown_N3_P2 = Dict -_test_Div_RoundHalfDown_N3_P3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfDown_N3_P3 = Dict -_test_Rem_RoundHalfDown_N3_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfDown_N3_P3 = Dict -_test_Div_RoundHalfDown_N3_P4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfDown_N3_P4 = Dict -_test_Rem_RoundHalfDown_N3_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfDown_N3_P4 = Dict -_test_Div_RoundHalfDown_N4_N1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfDown_N4_N1 = Dict -_test_Rem_RoundHalfDown_N4_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_N4_N1 = Dict -_test_Div_RoundHalfDown_N4_N2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfDown_N4_N2 = Dict -_test_Rem_RoundHalfDown_N4_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfDown_N4_N2 = Dict -_test_Div_RoundHalfDown_N4_N3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfDown_N4_N3 = Dict -_test_Rem_RoundHalfDown_N4_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfDown_N4_N3 = Dict -_test_Div_RoundHalfDown_N4_N4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfDown_N4_N4 = Dict -_test_Rem_RoundHalfDown_N4_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfDown_N4_N4 = Dict -_test_Div_RoundHalfDown_N4_P1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfDown_N4_P1 = Dict -_test_Rem_RoundHalfDown_N4_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_N4_P1 = Dict -_test_Div_RoundHalfDown_N4_P2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfDown_N4_P2 = Dict -_test_Rem_RoundHalfDown_N4_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfDown_N4_P2 = Dict -_test_Div_RoundHalfDown_N4_P3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfDown_N4_P3 = Dict -_test_Rem_RoundHalfDown_N4_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfDown_N4_P3 = Dict -_test_Div_RoundHalfDown_N4_P4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfDown_N4_P4 = Dict -_test_Rem_RoundHalfDown_N4_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfDown_N4_P4 = Dict -_test_Div_RoundHalfDown_P0_N1 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfDown_P0_N1 = Dict -_test_Rem_RoundHalfDown_P0_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_P0_N1 = Dict -_test_Div_RoundHalfDown_P0_N2 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfDown_P0_N2 = Dict -_test_Rem_RoundHalfDown_P0_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfDown_P0_N2 = Dict -_test_Div_RoundHalfDown_P0_N3 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfDown_P0_N3 = Dict -_test_Rem_RoundHalfDown_P0_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfDown_P0_N3 = Dict -_test_Div_RoundHalfDown_P0_N4 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfDown_P0_N4 = Dict -_test_Rem_RoundHalfDown_P0_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfDown_P0_N4 = Dict -_test_Div_RoundHalfDown_P0_P1 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfDown_P0_P1 = Dict -_test_Rem_RoundHalfDown_P0_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_P0_P1 = Dict -_test_Div_RoundHalfDown_P0_P2 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfDown_P0_P2 = Dict -_test_Rem_RoundHalfDown_P0_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfDown_P0_P2 = Dict -_test_Div_RoundHalfDown_P0_P3 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfDown_P0_P3 = Dict -_test_Rem_RoundHalfDown_P0_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfDown_P0_P3 = Dict -_test_Div_RoundHalfDown_P0_P4 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfDown_P0_P4 = Dict -_test_Rem_RoundHalfDown_P0_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfDown_P0_P4 = Dict -_test_Div_RoundHalfDown_P1_N1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfDown_P1_N1 = Dict -_test_Rem_RoundHalfDown_P1_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_P1_N1 = Dict -_test_Div_RoundHalfDown_P1_N2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 2) ~ N 1) -_test_Div_RoundHalfDown_P1_N2 = Dict -_test_Rem_RoundHalfDown_P1_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 2) ~ N 1) -_test_Rem_RoundHalfDown_P1_N2 = Dict -_test_Div_RoundHalfDown_P1_N3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfDown_P1_N3 = Dict -_test_Rem_RoundHalfDown_P1_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfDown_P1_N3 = Dict -_test_Div_RoundHalfDown_P1_N4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfDown_P1_N4 = Dict -_test_Rem_RoundHalfDown_P1_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfDown_P1_N4 = Dict -_test_Div_RoundHalfDown_P1_P1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfDown_P1_P1 = Dict -_test_Rem_RoundHalfDown_P1_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_P1_P1 = Dict -_test_Div_RoundHalfDown_P1_P2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 2) ~ P 0) -_test_Div_RoundHalfDown_P1_P2 = Dict -_test_Rem_RoundHalfDown_P1_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 2) ~ P 1) -_test_Rem_RoundHalfDown_P1_P2 = Dict -_test_Div_RoundHalfDown_P1_P3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfDown_P1_P3 = Dict -_test_Rem_RoundHalfDown_P1_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfDown_P1_P3 = Dict -_test_Div_RoundHalfDown_P1_P4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfDown_P1_P4 = Dict -_test_Rem_RoundHalfDown_P1_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfDown_P1_P4 = Dict -_test_Div_RoundHalfDown_P2_N1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfDown_P2_N1 = Dict -_test_Rem_RoundHalfDown_P2_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_P2_N1 = Dict -_test_Div_RoundHalfDown_P2_N2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfDown_P2_N2 = Dict -_test_Rem_RoundHalfDown_P2_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfDown_P2_N2 = Dict -_test_Div_RoundHalfDown_P2_N3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfDown_P2_N3 = Dict -_test_Rem_RoundHalfDown_P2_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfDown_P2_N3 = Dict -_test_Div_RoundHalfDown_P2_N4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 4) ~ N 1) -_test_Div_RoundHalfDown_P2_N4 = Dict -_test_Rem_RoundHalfDown_P2_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 4) ~ N 2) -_test_Rem_RoundHalfDown_P2_N4 = Dict -_test_Div_RoundHalfDown_P2_P1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfDown_P2_P1 = Dict -_test_Rem_RoundHalfDown_P2_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_P2_P1 = Dict -_test_Div_RoundHalfDown_P2_P2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfDown_P2_P2 = Dict -_test_Rem_RoundHalfDown_P2_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfDown_P2_P2 = Dict -_test_Div_RoundHalfDown_P2_P3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfDown_P2_P3 = Dict -_test_Rem_RoundHalfDown_P2_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfDown_P2_P3 = Dict -_test_Div_RoundHalfDown_P2_P4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 4) ~ P 0) -_test_Div_RoundHalfDown_P2_P4 = Dict -_test_Rem_RoundHalfDown_P2_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 4) ~ P 2) -_test_Rem_RoundHalfDown_P2_P4 = Dict -_test_Div_RoundHalfDown_P3_N1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfDown_P3_N1 = Dict -_test_Rem_RoundHalfDown_P3_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_P3_N1 = Dict -_test_Div_RoundHalfDown_P3_N2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 2) ~ N 2) -_test_Div_RoundHalfDown_P3_N2 = Dict -_test_Rem_RoundHalfDown_P3_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 2) ~ N 1) -_test_Rem_RoundHalfDown_P3_N2 = Dict -_test_Div_RoundHalfDown_P3_N3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfDown_P3_N3 = Dict -_test_Rem_RoundHalfDown_P3_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfDown_P3_N3 = Dict -_test_Div_RoundHalfDown_P3_N4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfDown_P3_N4 = Dict -_test_Rem_RoundHalfDown_P3_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfDown_P3_N4 = Dict -_test_Div_RoundHalfDown_P3_P1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfDown_P3_P1 = Dict -_test_Rem_RoundHalfDown_P3_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_P3_P1 = Dict -_test_Div_RoundHalfDown_P3_P2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 2) ~ P 1) -_test_Div_RoundHalfDown_P3_P2 = Dict -_test_Rem_RoundHalfDown_P3_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 2) ~ P 1) -_test_Rem_RoundHalfDown_P3_P2 = Dict -_test_Div_RoundHalfDown_P3_P3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfDown_P3_P3 = Dict -_test_Rem_RoundHalfDown_P3_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfDown_P3_P3 = Dict -_test_Div_RoundHalfDown_P3_P4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfDown_P3_P4 = Dict -_test_Rem_RoundHalfDown_P3_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfDown_P3_P4 = Dict -_test_Div_RoundHalfDown_P4_N1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfDown_P4_N1 = Dict -_test_Rem_RoundHalfDown_P4_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfDown_P4_N1 = Dict -_test_Div_RoundHalfDown_P4_N2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfDown_P4_N2 = Dict -_test_Rem_RoundHalfDown_P4_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfDown_P4_N2 = Dict -_test_Div_RoundHalfDown_P4_N3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfDown_P4_N3 = Dict -_test_Rem_RoundHalfDown_P4_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfDown_P4_N3 = Dict -_test_Div_RoundHalfDown_P4_N4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfDown_P4_N4 = Dict -_test_Rem_RoundHalfDown_P4_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfDown_P4_N4 = Dict -_test_Div_RoundHalfDown_P4_P1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfDown_P4_P1 = Dict -_test_Rem_RoundHalfDown_P4_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfDown_P4_P1 = Dict -_test_Div_RoundHalfDown_P4_P2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfDown_P4_P2 = Dict -_test_Rem_RoundHalfDown_P4_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfDown_P4_P2 = Dict -_test_Div_RoundHalfDown_P4_P3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfDown_P4_P3 = Dict -_test_Rem_RoundHalfDown_P4_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfDown_P4_P3 = Dict -_test_Div_RoundHalfDown_P4_P4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfDown_P4_P4 = Dict -_test_Rem_RoundHalfDown_P4_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfDown_P4_P4 = Dict -_test_Div_RoundHalfEven_N1_N1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfEven_N1_N1 = Dict -_test_Rem_RoundHalfEven_N1_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_N1_N1 = Dict -_test_Div_RoundHalfEven_N1_N2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 2) ~ P 0) -_test_Div_RoundHalfEven_N1_N2 = Dict -_test_Rem_RoundHalfEven_N1_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 2) ~ N 1) -_test_Rem_RoundHalfEven_N1_N2 = Dict -_test_Div_RoundHalfEven_N1_N3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfEven_N1_N3 = Dict -_test_Rem_RoundHalfEven_N1_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfEven_N1_N3 = Dict -_test_Div_RoundHalfEven_N1_N4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfEven_N1_N4 = Dict -_test_Rem_RoundHalfEven_N1_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfEven_N1_N4 = Dict -_test_Div_RoundHalfEven_N1_P1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfEven_N1_P1 = Dict -_test_Rem_RoundHalfEven_N1_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_N1_P1 = Dict -_test_Div_RoundHalfEven_N1_P2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 2) ~ P 0) -_test_Div_RoundHalfEven_N1_P2 = Dict -_test_Rem_RoundHalfEven_N1_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 2) ~ N 1) -_test_Rem_RoundHalfEven_N1_P2 = Dict -_test_Div_RoundHalfEven_N1_P3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfEven_N1_P3 = Dict -_test_Rem_RoundHalfEven_N1_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfEven_N1_P3 = Dict -_test_Div_RoundHalfEven_N1_P4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfEven_N1_P4 = Dict -_test_Rem_RoundHalfEven_N1_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfEven_N1_P4 = Dict -_test_Div_RoundHalfEven_N2_N1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfEven_N2_N1 = Dict -_test_Rem_RoundHalfEven_N2_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_N2_N1 = Dict -_test_Div_RoundHalfEven_N2_N2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfEven_N2_N2 = Dict -_test_Rem_RoundHalfEven_N2_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfEven_N2_N2 = Dict -_test_Div_RoundHalfEven_N2_N3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfEven_N2_N3 = Dict -_test_Rem_RoundHalfEven_N2_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfEven_N2_N3 = Dict -_test_Div_RoundHalfEven_N2_N4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 4) ~ P 0) -_test_Div_RoundHalfEven_N2_N4 = Dict -_test_Rem_RoundHalfEven_N2_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 4) ~ N 2) -_test_Rem_RoundHalfEven_N2_N4 = Dict -_test_Div_RoundHalfEven_N2_P1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfEven_N2_P1 = Dict -_test_Rem_RoundHalfEven_N2_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_N2_P1 = Dict -_test_Div_RoundHalfEven_N2_P2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfEven_N2_P2 = Dict -_test_Rem_RoundHalfEven_N2_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfEven_N2_P2 = Dict -_test_Div_RoundHalfEven_N2_P3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfEven_N2_P3 = Dict -_test_Rem_RoundHalfEven_N2_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfEven_N2_P3 = Dict -_test_Div_RoundHalfEven_N2_P4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 4) ~ P 0) -_test_Div_RoundHalfEven_N2_P4 = Dict -_test_Rem_RoundHalfEven_N2_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 4) ~ N 2) -_test_Rem_RoundHalfEven_N2_P4 = Dict -_test_Div_RoundHalfEven_N3_N1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfEven_N3_N1 = Dict -_test_Rem_RoundHalfEven_N3_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_N3_N1 = Dict -_test_Div_RoundHalfEven_N3_N2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 2) ~ P 2) -_test_Div_RoundHalfEven_N3_N2 = Dict -_test_Rem_RoundHalfEven_N3_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 2) ~ P 1) -_test_Rem_RoundHalfEven_N3_N2 = Dict -_test_Div_RoundHalfEven_N3_N3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfEven_N3_N3 = Dict -_test_Rem_RoundHalfEven_N3_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfEven_N3_N3 = Dict -_test_Div_RoundHalfEven_N3_N4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfEven_N3_N4 = Dict -_test_Rem_RoundHalfEven_N3_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfEven_N3_N4 = Dict -_test_Div_RoundHalfEven_N3_P1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfEven_N3_P1 = Dict -_test_Rem_RoundHalfEven_N3_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_N3_P1 = Dict -_test_Div_RoundHalfEven_N3_P2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 2) ~ N 2) -_test_Div_RoundHalfEven_N3_P2 = Dict -_test_Rem_RoundHalfEven_N3_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 2) ~ P 1) -_test_Rem_RoundHalfEven_N3_P2 = Dict -_test_Div_RoundHalfEven_N3_P3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfEven_N3_P3 = Dict -_test_Rem_RoundHalfEven_N3_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfEven_N3_P3 = Dict -_test_Div_RoundHalfEven_N3_P4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfEven_N3_P4 = Dict -_test_Rem_RoundHalfEven_N3_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfEven_N3_P4 = Dict -_test_Div_RoundHalfEven_N4_N1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfEven_N4_N1 = Dict -_test_Rem_RoundHalfEven_N4_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_N4_N1 = Dict -_test_Div_RoundHalfEven_N4_N2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfEven_N4_N2 = Dict -_test_Rem_RoundHalfEven_N4_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfEven_N4_N2 = Dict -_test_Div_RoundHalfEven_N4_N3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfEven_N4_N3 = Dict -_test_Rem_RoundHalfEven_N4_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfEven_N4_N3 = Dict -_test_Div_RoundHalfEven_N4_N4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfEven_N4_N4 = Dict -_test_Rem_RoundHalfEven_N4_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfEven_N4_N4 = Dict -_test_Div_RoundHalfEven_N4_P1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfEven_N4_P1 = Dict -_test_Rem_RoundHalfEven_N4_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_N4_P1 = Dict -_test_Div_RoundHalfEven_N4_P2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfEven_N4_P2 = Dict -_test_Rem_RoundHalfEven_N4_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfEven_N4_P2 = Dict -_test_Div_RoundHalfEven_N4_P3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfEven_N4_P3 = Dict -_test_Rem_RoundHalfEven_N4_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfEven_N4_P3 = Dict -_test_Div_RoundHalfEven_N4_P4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfEven_N4_P4 = Dict -_test_Rem_RoundHalfEven_N4_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfEven_N4_P4 = Dict -_test_Div_RoundHalfEven_P0_N1 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfEven_P0_N1 = Dict -_test_Rem_RoundHalfEven_P0_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_P0_N1 = Dict -_test_Div_RoundHalfEven_P0_N2 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfEven_P0_N2 = Dict -_test_Rem_RoundHalfEven_P0_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfEven_P0_N2 = Dict -_test_Div_RoundHalfEven_P0_N3 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfEven_P0_N3 = Dict -_test_Rem_RoundHalfEven_P0_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfEven_P0_N3 = Dict -_test_Div_RoundHalfEven_P0_N4 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfEven_P0_N4 = Dict -_test_Rem_RoundHalfEven_P0_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfEven_P0_N4 = Dict -_test_Div_RoundHalfEven_P0_P1 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfEven_P0_P1 = Dict -_test_Rem_RoundHalfEven_P0_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_P0_P1 = Dict -_test_Div_RoundHalfEven_P0_P2 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfEven_P0_P2 = Dict -_test_Rem_RoundHalfEven_P0_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfEven_P0_P2 = Dict -_test_Div_RoundHalfEven_P0_P3 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfEven_P0_P3 = Dict -_test_Rem_RoundHalfEven_P0_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfEven_P0_P3 = Dict -_test_Div_RoundHalfEven_P0_P4 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfEven_P0_P4 = Dict -_test_Rem_RoundHalfEven_P0_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfEven_P0_P4 = Dict -_test_Div_RoundHalfEven_P1_N1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfEven_P1_N1 = Dict -_test_Rem_RoundHalfEven_P1_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_P1_N1 = Dict -_test_Div_RoundHalfEven_P1_N2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 2) ~ P 0) -_test_Div_RoundHalfEven_P1_N2 = Dict -_test_Rem_RoundHalfEven_P1_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 2) ~ P 1) -_test_Rem_RoundHalfEven_P1_N2 = Dict -_test_Div_RoundHalfEven_P1_N3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfEven_P1_N3 = Dict -_test_Rem_RoundHalfEven_P1_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfEven_P1_N3 = Dict -_test_Div_RoundHalfEven_P1_N4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfEven_P1_N4 = Dict -_test_Rem_RoundHalfEven_P1_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfEven_P1_N4 = Dict -_test_Div_RoundHalfEven_P1_P1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfEven_P1_P1 = Dict -_test_Rem_RoundHalfEven_P1_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_P1_P1 = Dict -_test_Div_RoundHalfEven_P1_P2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 2) ~ P 0) -_test_Div_RoundHalfEven_P1_P2 = Dict -_test_Rem_RoundHalfEven_P1_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 2) ~ P 1) -_test_Rem_RoundHalfEven_P1_P2 = Dict -_test_Div_RoundHalfEven_P1_P3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfEven_P1_P3 = Dict -_test_Rem_RoundHalfEven_P1_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfEven_P1_P3 = Dict -_test_Div_RoundHalfEven_P1_P4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfEven_P1_P4 = Dict -_test_Rem_RoundHalfEven_P1_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfEven_P1_P4 = Dict -_test_Div_RoundHalfEven_P2_N1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfEven_P2_N1 = Dict -_test_Rem_RoundHalfEven_P2_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_P2_N1 = Dict -_test_Div_RoundHalfEven_P2_N2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfEven_P2_N2 = Dict -_test_Rem_RoundHalfEven_P2_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfEven_P2_N2 = Dict -_test_Div_RoundHalfEven_P2_N3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfEven_P2_N3 = Dict -_test_Rem_RoundHalfEven_P2_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfEven_P2_N3 = Dict -_test_Div_RoundHalfEven_P2_N4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 4) ~ P 0) -_test_Div_RoundHalfEven_P2_N4 = Dict -_test_Rem_RoundHalfEven_P2_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 4) ~ P 2) -_test_Rem_RoundHalfEven_P2_N4 = Dict -_test_Div_RoundHalfEven_P2_P1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfEven_P2_P1 = Dict -_test_Rem_RoundHalfEven_P2_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_P2_P1 = Dict -_test_Div_RoundHalfEven_P2_P2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfEven_P2_P2 = Dict -_test_Rem_RoundHalfEven_P2_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfEven_P2_P2 = Dict -_test_Div_RoundHalfEven_P2_P3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfEven_P2_P3 = Dict -_test_Rem_RoundHalfEven_P2_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfEven_P2_P3 = Dict -_test_Div_RoundHalfEven_P2_P4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 4) ~ P 0) -_test_Div_RoundHalfEven_P2_P4 = Dict -_test_Rem_RoundHalfEven_P2_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 4) ~ P 2) -_test_Rem_RoundHalfEven_P2_P4 = Dict -_test_Div_RoundHalfEven_P3_N1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfEven_P3_N1 = Dict -_test_Rem_RoundHalfEven_P3_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_P3_N1 = Dict -_test_Div_RoundHalfEven_P3_N2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 2) ~ N 2) -_test_Div_RoundHalfEven_P3_N2 = Dict -_test_Rem_RoundHalfEven_P3_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 2) ~ N 1) -_test_Rem_RoundHalfEven_P3_N2 = Dict -_test_Div_RoundHalfEven_P3_N3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfEven_P3_N3 = Dict -_test_Rem_RoundHalfEven_P3_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfEven_P3_N3 = Dict -_test_Div_RoundHalfEven_P3_N4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfEven_P3_N4 = Dict -_test_Rem_RoundHalfEven_P3_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfEven_P3_N4 = Dict -_test_Div_RoundHalfEven_P3_P1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfEven_P3_P1 = Dict -_test_Rem_RoundHalfEven_P3_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_P3_P1 = Dict -_test_Div_RoundHalfEven_P3_P2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 2) ~ P 2) -_test_Div_RoundHalfEven_P3_P2 = Dict -_test_Rem_RoundHalfEven_P3_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 2) ~ N 1) -_test_Rem_RoundHalfEven_P3_P2 = Dict -_test_Div_RoundHalfEven_P3_P3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfEven_P3_P3 = Dict -_test_Rem_RoundHalfEven_P3_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfEven_P3_P3 = Dict -_test_Div_RoundHalfEven_P3_P4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfEven_P3_P4 = Dict -_test_Rem_RoundHalfEven_P3_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfEven_P3_P4 = Dict -_test_Div_RoundHalfEven_P4_N1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfEven_P4_N1 = Dict -_test_Rem_RoundHalfEven_P4_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfEven_P4_N1 = Dict -_test_Div_RoundHalfEven_P4_N2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfEven_P4_N2 = Dict -_test_Rem_RoundHalfEven_P4_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfEven_P4_N2 = Dict -_test_Div_RoundHalfEven_P4_N3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfEven_P4_N3 = Dict -_test_Rem_RoundHalfEven_P4_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfEven_P4_N3 = Dict -_test_Div_RoundHalfEven_P4_N4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfEven_P4_N4 = Dict -_test_Rem_RoundHalfEven_P4_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfEven_P4_N4 = Dict -_test_Div_RoundHalfEven_P4_P1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfEven_P4_P1 = Dict -_test_Rem_RoundHalfEven_P4_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfEven_P4_P1 = Dict -_test_Div_RoundHalfEven_P4_P2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfEven_P4_P2 = Dict -_test_Rem_RoundHalfEven_P4_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfEven_P4_P2 = Dict -_test_Div_RoundHalfEven_P4_P3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfEven_P4_P3 = Dict -_test_Rem_RoundHalfEven_P4_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfEven_P4_P3 = Dict -_test_Div_RoundHalfEven_P4_P4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfEven_P4_P4 = Dict -_test_Rem_RoundHalfEven_P4_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfEven_P4_P4 = Dict -_test_Div_RoundHalfOdd_N1_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfOdd_N1_N1 = Dict -_test_Rem_RoundHalfOdd_N1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_N1_N1 = Dict -_test_Div_RoundHalfOdd_N1_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 2) ~ P 1) -_test_Div_RoundHalfOdd_N1_N2 = Dict -_test_Rem_RoundHalfOdd_N1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 2) ~ P 1) -_test_Rem_RoundHalfOdd_N1_N2 = Dict -_test_Div_RoundHalfOdd_N1_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfOdd_N1_N3 = Dict -_test_Rem_RoundHalfOdd_N1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfOdd_N1_N3 = Dict -_test_Div_RoundHalfOdd_N1_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfOdd_N1_N4 = Dict -_test_Rem_RoundHalfOdd_N1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfOdd_N1_N4 = Dict -_test_Div_RoundHalfOdd_N1_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfOdd_N1_P1 = Dict -_test_Rem_RoundHalfOdd_N1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_N1_P1 = Dict -_test_Div_RoundHalfOdd_N1_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 2) ~ N 1) -_test_Div_RoundHalfOdd_N1_P2 = Dict -_test_Rem_RoundHalfOdd_N1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 2) ~ P 1) -_test_Rem_RoundHalfOdd_N1_P2 = Dict -_test_Div_RoundHalfOdd_N1_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfOdd_N1_P3 = Dict -_test_Rem_RoundHalfOdd_N1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfOdd_N1_P3 = Dict -_test_Div_RoundHalfOdd_N1_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfOdd_N1_P4 = Dict -_test_Rem_RoundHalfOdd_N1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfOdd_N1_P4 = Dict -_test_Div_RoundHalfOdd_N2_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfOdd_N2_N1 = Dict -_test_Rem_RoundHalfOdd_N2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_N2_N1 = Dict -_test_Div_RoundHalfOdd_N2_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfOdd_N2_N2 = Dict -_test_Rem_RoundHalfOdd_N2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfOdd_N2_N2 = Dict -_test_Div_RoundHalfOdd_N2_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfOdd_N2_N3 = Dict -_test_Rem_RoundHalfOdd_N2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfOdd_N2_N3 = Dict -_test_Div_RoundHalfOdd_N2_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 4) ~ P 1) -_test_Div_RoundHalfOdd_N2_N4 = Dict -_test_Rem_RoundHalfOdd_N2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 4) ~ P 2) -_test_Rem_RoundHalfOdd_N2_N4 = Dict -_test_Div_RoundHalfOdd_N2_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfOdd_N2_P1 = Dict -_test_Rem_RoundHalfOdd_N2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_N2_P1 = Dict -_test_Div_RoundHalfOdd_N2_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfOdd_N2_P2 = Dict -_test_Rem_RoundHalfOdd_N2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfOdd_N2_P2 = Dict -_test_Div_RoundHalfOdd_N2_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfOdd_N2_P3 = Dict -_test_Rem_RoundHalfOdd_N2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfOdd_N2_P3 = Dict -_test_Div_RoundHalfOdd_N2_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 4) ~ N 1) -_test_Div_RoundHalfOdd_N2_P4 = Dict -_test_Rem_RoundHalfOdd_N2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 4) ~ P 2) -_test_Rem_RoundHalfOdd_N2_P4 = Dict -_test_Div_RoundHalfOdd_N3_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfOdd_N3_N1 = Dict -_test_Rem_RoundHalfOdd_N3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_N3_N1 = Dict -_test_Div_RoundHalfOdd_N3_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 2) ~ P 1) -_test_Div_RoundHalfOdd_N3_N2 = Dict -_test_Rem_RoundHalfOdd_N3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 2) ~ N 1) -_test_Rem_RoundHalfOdd_N3_N2 = Dict -_test_Div_RoundHalfOdd_N3_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfOdd_N3_N3 = Dict -_test_Rem_RoundHalfOdd_N3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfOdd_N3_N3 = Dict -_test_Div_RoundHalfOdd_N3_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfOdd_N3_N4 = Dict -_test_Rem_RoundHalfOdd_N3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfOdd_N3_N4 = Dict -_test_Div_RoundHalfOdd_N3_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfOdd_N3_P1 = Dict -_test_Rem_RoundHalfOdd_N3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_N3_P1 = Dict -_test_Div_RoundHalfOdd_N3_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 2) ~ N 1) -_test_Div_RoundHalfOdd_N3_P2 = Dict -_test_Rem_RoundHalfOdd_N3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 2) ~ N 1) -_test_Rem_RoundHalfOdd_N3_P2 = Dict -_test_Div_RoundHalfOdd_N3_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfOdd_N3_P3 = Dict -_test_Rem_RoundHalfOdd_N3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfOdd_N3_P3 = Dict -_test_Div_RoundHalfOdd_N3_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfOdd_N3_P4 = Dict -_test_Rem_RoundHalfOdd_N3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfOdd_N3_P4 = Dict -_test_Div_RoundHalfOdd_N4_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfOdd_N4_N1 = Dict -_test_Rem_RoundHalfOdd_N4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_N4_N1 = Dict -_test_Div_RoundHalfOdd_N4_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfOdd_N4_N2 = Dict -_test_Rem_RoundHalfOdd_N4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfOdd_N4_N2 = Dict -_test_Div_RoundHalfOdd_N4_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfOdd_N4_N3 = Dict -_test_Rem_RoundHalfOdd_N4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfOdd_N4_N3 = Dict -_test_Div_RoundHalfOdd_N4_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfOdd_N4_N4 = Dict -_test_Rem_RoundHalfOdd_N4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfOdd_N4_N4 = Dict -_test_Div_RoundHalfOdd_N4_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfOdd_N4_P1 = Dict -_test_Rem_RoundHalfOdd_N4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_N4_P1 = Dict -_test_Div_RoundHalfOdd_N4_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfOdd_N4_P2 = Dict -_test_Rem_RoundHalfOdd_N4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfOdd_N4_P2 = Dict -_test_Div_RoundHalfOdd_N4_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfOdd_N4_P3 = Dict -_test_Rem_RoundHalfOdd_N4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfOdd_N4_P3 = Dict -_test_Div_RoundHalfOdd_N4_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfOdd_N4_P4 = Dict -_test_Rem_RoundHalfOdd_N4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfOdd_N4_P4 = Dict -_test_Div_RoundHalfOdd_P0_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfOdd_P0_N1 = Dict -_test_Rem_RoundHalfOdd_P0_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_P0_N1 = Dict -_test_Div_RoundHalfOdd_P0_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfOdd_P0_N2 = Dict -_test_Rem_RoundHalfOdd_P0_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfOdd_P0_N2 = Dict -_test_Div_RoundHalfOdd_P0_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfOdd_P0_N3 = Dict -_test_Rem_RoundHalfOdd_P0_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfOdd_P0_N3 = Dict -_test_Div_RoundHalfOdd_P0_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfOdd_P0_N4 = Dict -_test_Rem_RoundHalfOdd_P0_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfOdd_P0_N4 = Dict -_test_Div_RoundHalfOdd_P0_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfOdd_P0_P1 = Dict -_test_Rem_RoundHalfOdd_P0_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_P0_P1 = Dict -_test_Div_RoundHalfOdd_P0_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfOdd_P0_P2 = Dict -_test_Rem_RoundHalfOdd_P0_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfOdd_P0_P2 = Dict -_test_Div_RoundHalfOdd_P0_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfOdd_P0_P3 = Dict -_test_Rem_RoundHalfOdd_P0_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfOdd_P0_P3 = Dict -_test_Div_RoundHalfOdd_P0_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfOdd_P0_P4 = Dict -_test_Rem_RoundHalfOdd_P0_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfOdd_P0_P4 = Dict -_test_Div_RoundHalfOdd_P1_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfOdd_P1_N1 = Dict -_test_Rem_RoundHalfOdd_P1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_P1_N1 = Dict -_test_Div_RoundHalfOdd_P1_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 2) ~ N 1) -_test_Div_RoundHalfOdd_P1_N2 = Dict -_test_Rem_RoundHalfOdd_P1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 2) ~ N 1) -_test_Rem_RoundHalfOdd_P1_N2 = Dict -_test_Div_RoundHalfOdd_P1_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfOdd_P1_N3 = Dict -_test_Rem_RoundHalfOdd_P1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfOdd_P1_N3 = Dict -_test_Div_RoundHalfOdd_P1_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfOdd_P1_N4 = Dict -_test_Rem_RoundHalfOdd_P1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfOdd_P1_N4 = Dict -_test_Div_RoundHalfOdd_P1_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfOdd_P1_P1 = Dict -_test_Rem_RoundHalfOdd_P1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_P1_P1 = Dict -_test_Div_RoundHalfOdd_P1_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 2) ~ P 1) -_test_Div_RoundHalfOdd_P1_P2 = Dict -_test_Rem_RoundHalfOdd_P1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 2) ~ N 1) -_test_Rem_RoundHalfOdd_P1_P2 = Dict -_test_Div_RoundHalfOdd_P1_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfOdd_P1_P3 = Dict -_test_Rem_RoundHalfOdd_P1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfOdd_P1_P3 = Dict -_test_Div_RoundHalfOdd_P1_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfOdd_P1_P4 = Dict -_test_Rem_RoundHalfOdd_P1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfOdd_P1_P4 = Dict -_test_Div_RoundHalfOdd_P2_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfOdd_P2_N1 = Dict -_test_Rem_RoundHalfOdd_P2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_P2_N1 = Dict -_test_Div_RoundHalfOdd_P2_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfOdd_P2_N2 = Dict -_test_Rem_RoundHalfOdd_P2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfOdd_P2_N2 = Dict -_test_Div_RoundHalfOdd_P2_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfOdd_P2_N3 = Dict -_test_Rem_RoundHalfOdd_P2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfOdd_P2_N3 = Dict -_test_Div_RoundHalfOdd_P2_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 4) ~ N 1) -_test_Div_RoundHalfOdd_P2_N4 = Dict -_test_Rem_RoundHalfOdd_P2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 4) ~ N 2) -_test_Rem_RoundHalfOdd_P2_N4 = Dict -_test_Div_RoundHalfOdd_P2_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfOdd_P2_P1 = Dict -_test_Rem_RoundHalfOdd_P2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_P2_P1 = Dict -_test_Div_RoundHalfOdd_P2_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfOdd_P2_P2 = Dict -_test_Rem_RoundHalfOdd_P2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfOdd_P2_P2 = Dict -_test_Div_RoundHalfOdd_P2_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfOdd_P2_P3 = Dict -_test_Rem_RoundHalfOdd_P2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfOdd_P2_P3 = Dict -_test_Div_RoundHalfOdd_P2_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 4) ~ P 1) -_test_Div_RoundHalfOdd_P2_P4 = Dict -_test_Rem_RoundHalfOdd_P2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 4) ~ N 2) -_test_Rem_RoundHalfOdd_P2_P4 = Dict -_test_Div_RoundHalfOdd_P3_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfOdd_P3_N1 = Dict -_test_Rem_RoundHalfOdd_P3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_P3_N1 = Dict -_test_Div_RoundHalfOdd_P3_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 2) ~ N 1) -_test_Div_RoundHalfOdd_P3_N2 = Dict -_test_Rem_RoundHalfOdd_P3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 2) ~ P 1) -_test_Rem_RoundHalfOdd_P3_N2 = Dict -_test_Div_RoundHalfOdd_P3_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfOdd_P3_N3 = Dict -_test_Rem_RoundHalfOdd_P3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfOdd_P3_N3 = Dict -_test_Div_RoundHalfOdd_P3_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfOdd_P3_N4 = Dict -_test_Rem_RoundHalfOdd_P3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfOdd_P3_N4 = Dict -_test_Div_RoundHalfOdd_P3_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfOdd_P3_P1 = Dict -_test_Rem_RoundHalfOdd_P3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_P3_P1 = Dict -_test_Div_RoundHalfOdd_P3_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 2) ~ P 1) -_test_Div_RoundHalfOdd_P3_P2 = Dict -_test_Rem_RoundHalfOdd_P3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 2) ~ P 1) -_test_Rem_RoundHalfOdd_P3_P2 = Dict -_test_Div_RoundHalfOdd_P3_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfOdd_P3_P3 = Dict -_test_Rem_RoundHalfOdd_P3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfOdd_P3_P3 = Dict -_test_Div_RoundHalfOdd_P3_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfOdd_P3_P4 = Dict -_test_Rem_RoundHalfOdd_P3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfOdd_P3_P4 = Dict -_test_Div_RoundHalfOdd_P4_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfOdd_P4_N1 = Dict -_test_Rem_RoundHalfOdd_P4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfOdd_P4_N1 = Dict -_test_Div_RoundHalfOdd_P4_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfOdd_P4_N2 = Dict -_test_Rem_RoundHalfOdd_P4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfOdd_P4_N2 = Dict -_test_Div_RoundHalfOdd_P4_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfOdd_P4_N3 = Dict -_test_Rem_RoundHalfOdd_P4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfOdd_P4_N3 = Dict -_test_Div_RoundHalfOdd_P4_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfOdd_P4_N4 = Dict -_test_Rem_RoundHalfOdd_P4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfOdd_P4_N4 = Dict -_test_Div_RoundHalfOdd_P4_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfOdd_P4_P1 = Dict -_test_Rem_RoundHalfOdd_P4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfOdd_P4_P1 = Dict -_test_Div_RoundHalfOdd_P4_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfOdd_P4_P2 = Dict -_test_Rem_RoundHalfOdd_P4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfOdd_P4_P2 = Dict -_test_Div_RoundHalfOdd_P4_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfOdd_P4_P3 = Dict -_test_Rem_RoundHalfOdd_P4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfOdd_P4_P3 = Dict -_test_Div_RoundHalfOdd_P4_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfOdd_P4_P4 = Dict -_test_Rem_RoundHalfOdd_P4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfOdd_P4_P4 = Dict -_test_Div_RoundHalfUp_N1_N1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfUp_N1_N1 = Dict -_test_Rem_RoundHalfUp_N1_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_N1_N1 = Dict -_test_Div_RoundHalfUp_N1_N2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 2) ~ P 1) -_test_Div_RoundHalfUp_N1_N2 = Dict -_test_Rem_RoundHalfUp_N1_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 2) ~ P 1) -_test_Rem_RoundHalfUp_N1_N2 = Dict -_test_Div_RoundHalfUp_N1_N3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfUp_N1_N3 = Dict -_test_Rem_RoundHalfUp_N1_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfUp_N1_N3 = Dict -_test_Div_RoundHalfUp_N1_N4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfUp_N1_N4 = Dict -_test_Rem_RoundHalfUp_N1_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfUp_N1_N4 = Dict -_test_Div_RoundHalfUp_N1_P1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfUp_N1_P1 = Dict -_test_Rem_RoundHalfUp_N1_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_N1_P1 = Dict -_test_Div_RoundHalfUp_N1_P2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 2) ~ P 0) -_test_Div_RoundHalfUp_N1_P2 = Dict -_test_Rem_RoundHalfUp_N1_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 2) ~ N 1) -_test_Rem_RoundHalfUp_N1_P2 = Dict -_test_Div_RoundHalfUp_N1_P3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfUp_N1_P3 = Dict -_test_Rem_RoundHalfUp_N1_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfUp_N1_P3 = Dict -_test_Div_RoundHalfUp_N1_P4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfUp_N1_P4 = Dict -_test_Rem_RoundHalfUp_N1_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfUp_N1_P4 = Dict -_test_Div_RoundHalfUp_N2_N1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfUp_N2_N1 = Dict -_test_Rem_RoundHalfUp_N2_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_N2_N1 = Dict -_test_Div_RoundHalfUp_N2_N2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfUp_N2_N2 = Dict -_test_Rem_RoundHalfUp_N2_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfUp_N2_N2 = Dict -_test_Div_RoundHalfUp_N2_N3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfUp_N2_N3 = Dict -_test_Rem_RoundHalfUp_N2_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfUp_N2_N3 = Dict -_test_Div_RoundHalfUp_N2_N4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 4) ~ P 1) -_test_Div_RoundHalfUp_N2_N4 = Dict -_test_Rem_RoundHalfUp_N2_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 4) ~ P 2) -_test_Rem_RoundHalfUp_N2_N4 = Dict -_test_Div_RoundHalfUp_N2_P1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfUp_N2_P1 = Dict -_test_Rem_RoundHalfUp_N2_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_N2_P1 = Dict -_test_Div_RoundHalfUp_N2_P2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfUp_N2_P2 = Dict -_test_Rem_RoundHalfUp_N2_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfUp_N2_P2 = Dict -_test_Div_RoundHalfUp_N2_P3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfUp_N2_P3 = Dict -_test_Rem_RoundHalfUp_N2_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfUp_N2_P3 = Dict -_test_Div_RoundHalfUp_N2_P4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 4) ~ P 0) -_test_Div_RoundHalfUp_N2_P4 = Dict -_test_Rem_RoundHalfUp_N2_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 4) ~ N 2) -_test_Rem_RoundHalfUp_N2_P4 = Dict -_test_Div_RoundHalfUp_N3_N1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfUp_N3_N1 = Dict -_test_Rem_RoundHalfUp_N3_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_N3_N1 = Dict -_test_Div_RoundHalfUp_N3_N2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 2) ~ P 2) -_test_Div_RoundHalfUp_N3_N2 = Dict -_test_Rem_RoundHalfUp_N3_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 2) ~ P 1) -_test_Rem_RoundHalfUp_N3_N2 = Dict -_test_Div_RoundHalfUp_N3_N3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfUp_N3_N3 = Dict -_test_Rem_RoundHalfUp_N3_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfUp_N3_N3 = Dict -_test_Div_RoundHalfUp_N3_N4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfUp_N3_N4 = Dict -_test_Rem_RoundHalfUp_N3_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfUp_N3_N4 = Dict -_test_Div_RoundHalfUp_N3_P1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfUp_N3_P1 = Dict -_test_Rem_RoundHalfUp_N3_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_N3_P1 = Dict -_test_Div_RoundHalfUp_N3_P2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 2) ~ N 1) -_test_Div_RoundHalfUp_N3_P2 = Dict -_test_Rem_RoundHalfUp_N3_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 2) ~ N 1) -_test_Rem_RoundHalfUp_N3_P2 = Dict -_test_Div_RoundHalfUp_N3_P3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfUp_N3_P3 = Dict -_test_Rem_RoundHalfUp_N3_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfUp_N3_P3 = Dict -_test_Div_RoundHalfUp_N3_P4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfUp_N3_P4 = Dict -_test_Rem_RoundHalfUp_N3_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfUp_N3_P4 = Dict -_test_Div_RoundHalfUp_N4_N1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfUp_N4_N1 = Dict -_test_Rem_RoundHalfUp_N4_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_N4_N1 = Dict -_test_Div_RoundHalfUp_N4_N2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfUp_N4_N2 = Dict -_test_Rem_RoundHalfUp_N4_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfUp_N4_N2 = Dict -_test_Div_RoundHalfUp_N4_N3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfUp_N4_N3 = Dict -_test_Rem_RoundHalfUp_N4_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfUp_N4_N3 = Dict -_test_Div_RoundHalfUp_N4_N4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfUp_N4_N4 = Dict -_test_Rem_RoundHalfUp_N4_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfUp_N4_N4 = Dict -_test_Div_RoundHalfUp_N4_P1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfUp_N4_P1 = Dict -_test_Rem_RoundHalfUp_N4_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_N4_P1 = Dict -_test_Div_RoundHalfUp_N4_P2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfUp_N4_P2 = Dict -_test_Rem_RoundHalfUp_N4_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfUp_N4_P2 = Dict -_test_Div_RoundHalfUp_N4_P3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfUp_N4_P3 = Dict -_test_Rem_RoundHalfUp_N4_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfUp_N4_P3 = Dict -_test_Div_RoundHalfUp_N4_P4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfUp_N4_P4 = Dict -_test_Rem_RoundHalfUp_N4_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfUp_N4_P4 = Dict -_test_Div_RoundHalfUp_P0_N1 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfUp_P0_N1 = Dict -_test_Rem_RoundHalfUp_P0_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_P0_N1 = Dict -_test_Div_RoundHalfUp_P0_N2 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfUp_P0_N2 = Dict -_test_Rem_RoundHalfUp_P0_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfUp_P0_N2 = Dict -_test_Div_RoundHalfUp_P0_N3 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfUp_P0_N3 = Dict -_test_Rem_RoundHalfUp_P0_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfUp_P0_N3 = Dict -_test_Div_RoundHalfUp_P0_N4 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfUp_P0_N4 = Dict -_test_Rem_RoundHalfUp_P0_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfUp_P0_N4 = Dict -_test_Div_RoundHalfUp_P0_P1 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfUp_P0_P1 = Dict -_test_Rem_RoundHalfUp_P0_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_P0_P1 = Dict -_test_Div_RoundHalfUp_P0_P2 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfUp_P0_P2 = Dict -_test_Rem_RoundHalfUp_P0_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfUp_P0_P2 = Dict -_test_Div_RoundHalfUp_P0_P3 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfUp_P0_P3 = Dict -_test_Rem_RoundHalfUp_P0_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfUp_P0_P3 = Dict -_test_Div_RoundHalfUp_P0_P4 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfUp_P0_P4 = Dict -_test_Rem_RoundHalfUp_P0_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfUp_P0_P4 = Dict -_test_Div_RoundHalfUp_P1_N1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfUp_P1_N1 = Dict -_test_Rem_RoundHalfUp_P1_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_P1_N1 = Dict -_test_Div_RoundHalfUp_P1_N2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 2) ~ P 0) -_test_Div_RoundHalfUp_P1_N2 = Dict -_test_Rem_RoundHalfUp_P1_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 2) ~ P 1) -_test_Rem_RoundHalfUp_P1_N2 = Dict -_test_Div_RoundHalfUp_P1_N3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfUp_P1_N3 = Dict -_test_Rem_RoundHalfUp_P1_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfUp_P1_N3 = Dict -_test_Div_RoundHalfUp_P1_N4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfUp_P1_N4 = Dict -_test_Rem_RoundHalfUp_P1_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfUp_P1_N4 = Dict -_test_Div_RoundHalfUp_P1_P1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfUp_P1_P1 = Dict -_test_Rem_RoundHalfUp_P1_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_P1_P1 = Dict -_test_Div_RoundHalfUp_P1_P2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 2) ~ P 1) -_test_Div_RoundHalfUp_P1_P2 = Dict -_test_Rem_RoundHalfUp_P1_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 2) ~ N 1) -_test_Rem_RoundHalfUp_P1_P2 = Dict -_test_Div_RoundHalfUp_P1_P3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfUp_P1_P3 = Dict -_test_Rem_RoundHalfUp_P1_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfUp_P1_P3 = Dict -_test_Div_RoundHalfUp_P1_P4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfUp_P1_P4 = Dict -_test_Rem_RoundHalfUp_P1_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfUp_P1_P4 = Dict -_test_Div_RoundHalfUp_P2_N1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfUp_P2_N1 = Dict -_test_Rem_RoundHalfUp_P2_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_P2_N1 = Dict -_test_Div_RoundHalfUp_P2_N2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfUp_P2_N2 = Dict -_test_Rem_RoundHalfUp_P2_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfUp_P2_N2 = Dict -_test_Div_RoundHalfUp_P2_N3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfUp_P2_N3 = Dict -_test_Rem_RoundHalfUp_P2_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfUp_P2_N3 = Dict -_test_Div_RoundHalfUp_P2_N4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 4) ~ P 0) -_test_Div_RoundHalfUp_P2_N4 = Dict -_test_Rem_RoundHalfUp_P2_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 4) ~ P 2) -_test_Rem_RoundHalfUp_P2_N4 = Dict -_test_Div_RoundHalfUp_P2_P1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfUp_P2_P1 = Dict -_test_Rem_RoundHalfUp_P2_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_P2_P1 = Dict -_test_Div_RoundHalfUp_P2_P2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfUp_P2_P2 = Dict -_test_Rem_RoundHalfUp_P2_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfUp_P2_P2 = Dict -_test_Div_RoundHalfUp_P2_P3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfUp_P2_P3 = Dict -_test_Rem_RoundHalfUp_P2_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfUp_P2_P3 = Dict -_test_Div_RoundHalfUp_P2_P4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 4) ~ P 1) -_test_Div_RoundHalfUp_P2_P4 = Dict -_test_Rem_RoundHalfUp_P2_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 4) ~ N 2) -_test_Rem_RoundHalfUp_P2_P4 = Dict -_test_Div_RoundHalfUp_P3_N1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfUp_P3_N1 = Dict -_test_Rem_RoundHalfUp_P3_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_P3_N1 = Dict -_test_Div_RoundHalfUp_P3_N2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 2) ~ N 1) -_test_Div_RoundHalfUp_P3_N2 = Dict -_test_Rem_RoundHalfUp_P3_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 2) ~ P 1) -_test_Rem_RoundHalfUp_P3_N2 = Dict -_test_Div_RoundHalfUp_P3_N3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfUp_P3_N3 = Dict -_test_Rem_RoundHalfUp_P3_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfUp_P3_N3 = Dict -_test_Div_RoundHalfUp_P3_N4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfUp_P3_N4 = Dict -_test_Rem_RoundHalfUp_P3_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfUp_P3_N4 = Dict -_test_Div_RoundHalfUp_P3_P1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfUp_P3_P1 = Dict -_test_Rem_RoundHalfUp_P3_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_P3_P1 = Dict -_test_Div_RoundHalfUp_P3_P2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 2) ~ P 2) -_test_Div_RoundHalfUp_P3_P2 = Dict -_test_Rem_RoundHalfUp_P3_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 2) ~ N 1) -_test_Rem_RoundHalfUp_P3_P2 = Dict -_test_Div_RoundHalfUp_P3_P3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfUp_P3_P3 = Dict -_test_Rem_RoundHalfUp_P3_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfUp_P3_P3 = Dict -_test_Div_RoundHalfUp_P3_P4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfUp_P3_P4 = Dict -_test_Rem_RoundHalfUp_P3_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfUp_P3_P4 = Dict -_test_Div_RoundHalfUp_P4_N1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfUp_P4_N1 = Dict -_test_Rem_RoundHalfUp_P4_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfUp_P4_N1 = Dict -_test_Div_RoundHalfUp_P4_N2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfUp_P4_N2 = Dict -_test_Rem_RoundHalfUp_P4_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfUp_P4_N2 = Dict -_test_Div_RoundHalfUp_P4_N3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfUp_P4_N3 = Dict -_test_Rem_RoundHalfUp_P4_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfUp_P4_N3 = Dict -_test_Div_RoundHalfUp_P4_N4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfUp_P4_N4 = Dict -_test_Rem_RoundHalfUp_P4_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfUp_P4_N4 = Dict -_test_Div_RoundHalfUp_P4_P1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfUp_P4_P1 = Dict -_test_Rem_RoundHalfUp_P4_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfUp_P4_P1 = Dict -_test_Div_RoundHalfUp_P4_P2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfUp_P4_P2 = Dict -_test_Rem_RoundHalfUp_P4_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfUp_P4_P2 = Dict -_test_Div_RoundHalfUp_P4_P3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfUp_P4_P3 = Dict -_test_Rem_RoundHalfUp_P4_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfUp_P4_P3 = Dict -_test_Div_RoundHalfUp_P4_P4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfUp_P4_P4 = Dict -_test_Rem_RoundHalfUp_P4_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfUp_P4_P4 = Dict -_test_Div_RoundHalfZero_N1_N1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 1) ~ P 1) -_test_Div_RoundHalfZero_N1_N1 = Dict -_test_Rem_RoundHalfZero_N1_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_N1_N1 = Dict -_test_Div_RoundHalfZero_N1_N2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 2) ~ P 0) -_test_Div_RoundHalfZero_N1_N2 = Dict -_test_Rem_RoundHalfZero_N1_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 2) ~ N 1) -_test_Rem_RoundHalfZero_N1_N2 = Dict -_test_Div_RoundHalfZero_N1_N3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 3) ~ P 0) -_test_Div_RoundHalfZero_N1_N3 = Dict -_test_Rem_RoundHalfZero_N1_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 3) ~ N 1) -_test_Rem_RoundHalfZero_N1_N3 = Dict -_test_Div_RoundHalfZero_N1_N4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 4) ~ P 0) -_test_Div_RoundHalfZero_N1_N4 = Dict -_test_Rem_RoundHalfZero_N1_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 4) ~ N 1) -_test_Rem_RoundHalfZero_N1_N4 = Dict -_test_Div_RoundHalfZero_N1_P1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 1) ~ N 1) -_test_Div_RoundHalfZero_N1_P1 = Dict -_test_Rem_RoundHalfZero_N1_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_N1_P1 = Dict -_test_Div_RoundHalfZero_N1_P2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 2) ~ P 0) -_test_Div_RoundHalfZero_N1_P2 = Dict -_test_Rem_RoundHalfZero_N1_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 2) ~ N 1) -_test_Rem_RoundHalfZero_N1_P2 = Dict -_test_Div_RoundHalfZero_N1_P3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 3) ~ P 0) -_test_Div_RoundHalfZero_N1_P3 = Dict -_test_Rem_RoundHalfZero_N1_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 3) ~ N 1) -_test_Rem_RoundHalfZero_N1_P3 = Dict -_test_Div_RoundHalfZero_N1_P4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 4) ~ P 0) -_test_Div_RoundHalfZero_N1_P4 = Dict -_test_Rem_RoundHalfZero_N1_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 4) ~ N 1) -_test_Rem_RoundHalfZero_N1_P4 = Dict -_test_Div_RoundHalfZero_N2_N1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 1) ~ P 2) -_test_Div_RoundHalfZero_N2_N1 = Dict -_test_Rem_RoundHalfZero_N2_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_N2_N1 = Dict -_test_Div_RoundHalfZero_N2_N2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 2) ~ P 1) -_test_Div_RoundHalfZero_N2_N2 = Dict -_test_Rem_RoundHalfZero_N2_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 2) ~ P 0) -_test_Rem_RoundHalfZero_N2_N2 = Dict -_test_Div_RoundHalfZero_N2_N3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 3) ~ P 1) -_test_Div_RoundHalfZero_N2_N3 = Dict -_test_Rem_RoundHalfZero_N2_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 3) ~ P 1) -_test_Rem_RoundHalfZero_N2_N3 = Dict -_test_Div_RoundHalfZero_N2_N4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 4) ~ P 0) -_test_Div_RoundHalfZero_N2_N4 = Dict -_test_Rem_RoundHalfZero_N2_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 4) ~ N 2) -_test_Rem_RoundHalfZero_N2_N4 = Dict -_test_Div_RoundHalfZero_N2_P1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 1) ~ N 2) -_test_Div_RoundHalfZero_N2_P1 = Dict -_test_Rem_RoundHalfZero_N2_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_N2_P1 = Dict -_test_Div_RoundHalfZero_N2_P2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 2) ~ N 1) -_test_Div_RoundHalfZero_N2_P2 = Dict -_test_Rem_RoundHalfZero_N2_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 2) ~ P 0) -_test_Rem_RoundHalfZero_N2_P2 = Dict -_test_Div_RoundHalfZero_N2_P3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 3) ~ N 1) -_test_Div_RoundHalfZero_N2_P3 = Dict -_test_Rem_RoundHalfZero_N2_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 3) ~ P 1) -_test_Rem_RoundHalfZero_N2_P3 = Dict -_test_Div_RoundHalfZero_N2_P4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 4) ~ P 0) -_test_Div_RoundHalfZero_N2_P4 = Dict -_test_Rem_RoundHalfZero_N2_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 4) ~ N 2) -_test_Rem_RoundHalfZero_N2_P4 = Dict -_test_Div_RoundHalfZero_N3_N1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 1) ~ P 3) -_test_Div_RoundHalfZero_N3_N1 = Dict -_test_Rem_RoundHalfZero_N3_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_N3_N1 = Dict -_test_Div_RoundHalfZero_N3_N2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 2) ~ P 1) -_test_Div_RoundHalfZero_N3_N2 = Dict -_test_Rem_RoundHalfZero_N3_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 2) ~ N 1) -_test_Rem_RoundHalfZero_N3_N2 = Dict -_test_Div_RoundHalfZero_N3_N3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 3) ~ P 1) -_test_Div_RoundHalfZero_N3_N3 = Dict -_test_Rem_RoundHalfZero_N3_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 3) ~ P 0) -_test_Rem_RoundHalfZero_N3_N3 = Dict -_test_Div_RoundHalfZero_N3_N4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 4) ~ P 1) -_test_Div_RoundHalfZero_N3_N4 = Dict -_test_Rem_RoundHalfZero_N3_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 4) ~ P 1) -_test_Rem_RoundHalfZero_N3_N4 = Dict -_test_Div_RoundHalfZero_N3_P1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 1) ~ N 3) -_test_Div_RoundHalfZero_N3_P1 = Dict -_test_Rem_RoundHalfZero_N3_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_N3_P1 = Dict -_test_Div_RoundHalfZero_N3_P2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 2) ~ N 1) -_test_Div_RoundHalfZero_N3_P2 = Dict -_test_Rem_RoundHalfZero_N3_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 2) ~ N 1) -_test_Rem_RoundHalfZero_N3_P2 = Dict -_test_Div_RoundHalfZero_N3_P3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 3) ~ N 1) -_test_Div_RoundHalfZero_N3_P3 = Dict -_test_Rem_RoundHalfZero_N3_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 3) ~ P 0) -_test_Rem_RoundHalfZero_N3_P3 = Dict -_test_Div_RoundHalfZero_N3_P4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 4) ~ N 1) -_test_Div_RoundHalfZero_N3_P4 = Dict -_test_Rem_RoundHalfZero_N3_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 4) ~ P 1) -_test_Rem_RoundHalfZero_N3_P4 = Dict -_test_Div_RoundHalfZero_N4_N1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 1) ~ P 4) -_test_Div_RoundHalfZero_N4_N1 = Dict -_test_Rem_RoundHalfZero_N4_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_N4_N1 = Dict -_test_Div_RoundHalfZero_N4_N2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 2) ~ P 2) -_test_Div_RoundHalfZero_N4_N2 = Dict -_test_Rem_RoundHalfZero_N4_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 2) ~ P 0) -_test_Rem_RoundHalfZero_N4_N2 = Dict -_test_Div_RoundHalfZero_N4_N3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 3) ~ P 1) -_test_Div_RoundHalfZero_N4_N3 = Dict -_test_Rem_RoundHalfZero_N4_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 3) ~ N 1) -_test_Rem_RoundHalfZero_N4_N3 = Dict -_test_Div_RoundHalfZero_N4_N4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 4) ~ P 1) -_test_Div_RoundHalfZero_N4_N4 = Dict -_test_Rem_RoundHalfZero_N4_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 4) ~ P 0) -_test_Rem_RoundHalfZero_N4_N4 = Dict -_test_Div_RoundHalfZero_N4_P1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 1) ~ N 4) -_test_Div_RoundHalfZero_N4_P1 = Dict -_test_Rem_RoundHalfZero_N4_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_N4_P1 = Dict -_test_Div_RoundHalfZero_N4_P2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 2) ~ N 2) -_test_Div_RoundHalfZero_N4_P2 = Dict -_test_Rem_RoundHalfZero_N4_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 2) ~ P 0) -_test_Rem_RoundHalfZero_N4_P2 = Dict -_test_Div_RoundHalfZero_N4_P3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 3) ~ N 1) -_test_Div_RoundHalfZero_N4_P3 = Dict -_test_Rem_RoundHalfZero_N4_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 3) ~ N 1) -_test_Rem_RoundHalfZero_N4_P3 = Dict -_test_Div_RoundHalfZero_N4_P4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 4) ~ N 1) -_test_Div_RoundHalfZero_N4_P4 = Dict -_test_Rem_RoundHalfZero_N4_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 4) ~ P 0) -_test_Rem_RoundHalfZero_N4_P4 = Dict -_test_Div_RoundHalfZero_P0_N1 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 1) ~ P 0) -_test_Div_RoundHalfZero_P0_N1 = Dict -_test_Rem_RoundHalfZero_P0_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_P0_N1 = Dict -_test_Div_RoundHalfZero_P0_N2 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 2) ~ P 0) -_test_Div_RoundHalfZero_P0_N2 = Dict -_test_Rem_RoundHalfZero_P0_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 2) ~ P 0) -_test_Rem_RoundHalfZero_P0_N2 = Dict -_test_Div_RoundHalfZero_P0_N3 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 3) ~ P 0) -_test_Div_RoundHalfZero_P0_N3 = Dict -_test_Rem_RoundHalfZero_P0_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 3) ~ P 0) -_test_Rem_RoundHalfZero_P0_N3 = Dict -_test_Div_RoundHalfZero_P0_N4 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 4) ~ P 0) -_test_Div_RoundHalfZero_P0_N4 = Dict -_test_Rem_RoundHalfZero_P0_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 4) ~ P 0) -_test_Rem_RoundHalfZero_P0_N4 = Dict -_test_Div_RoundHalfZero_P0_P1 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 1) ~ P 0) -_test_Div_RoundHalfZero_P0_P1 = Dict -_test_Rem_RoundHalfZero_P0_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_P0_P1 = Dict -_test_Div_RoundHalfZero_P0_P2 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 2) ~ P 0) -_test_Div_RoundHalfZero_P0_P2 = Dict -_test_Rem_RoundHalfZero_P0_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 2) ~ P 0) -_test_Rem_RoundHalfZero_P0_P2 = Dict -_test_Div_RoundHalfZero_P0_P3 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 3) ~ P 0) -_test_Div_RoundHalfZero_P0_P3 = Dict -_test_Rem_RoundHalfZero_P0_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 3) ~ P 0) -_test_Rem_RoundHalfZero_P0_P3 = Dict -_test_Div_RoundHalfZero_P0_P4 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 4) ~ P 0) -_test_Div_RoundHalfZero_P0_P4 = Dict -_test_Rem_RoundHalfZero_P0_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 4) ~ P 0) -_test_Rem_RoundHalfZero_P0_P4 = Dict -_test_Div_RoundHalfZero_P1_N1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 1) ~ N 1) -_test_Div_RoundHalfZero_P1_N1 = Dict -_test_Rem_RoundHalfZero_P1_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_P1_N1 = Dict -_test_Div_RoundHalfZero_P1_N2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 2) ~ P 0) -_test_Div_RoundHalfZero_P1_N2 = Dict -_test_Rem_RoundHalfZero_P1_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 2) ~ P 1) -_test_Rem_RoundHalfZero_P1_N2 = Dict -_test_Div_RoundHalfZero_P1_N3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 3) ~ P 0) -_test_Div_RoundHalfZero_P1_N3 = Dict -_test_Rem_RoundHalfZero_P1_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 3) ~ P 1) -_test_Rem_RoundHalfZero_P1_N3 = Dict -_test_Div_RoundHalfZero_P1_N4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 4) ~ P 0) -_test_Div_RoundHalfZero_P1_N4 = Dict -_test_Rem_RoundHalfZero_P1_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 4) ~ P 1) -_test_Rem_RoundHalfZero_P1_N4 = Dict -_test_Div_RoundHalfZero_P1_P1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 1) ~ P 1) -_test_Div_RoundHalfZero_P1_P1 = Dict -_test_Rem_RoundHalfZero_P1_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_P1_P1 = Dict -_test_Div_RoundHalfZero_P1_P2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 2) ~ P 0) -_test_Div_RoundHalfZero_P1_P2 = Dict -_test_Rem_RoundHalfZero_P1_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 2) ~ P 1) -_test_Rem_RoundHalfZero_P1_P2 = Dict -_test_Div_RoundHalfZero_P1_P3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 3) ~ P 0) -_test_Div_RoundHalfZero_P1_P3 = Dict -_test_Rem_RoundHalfZero_P1_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 3) ~ P 1) -_test_Rem_RoundHalfZero_P1_P3 = Dict -_test_Div_RoundHalfZero_P1_P4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 4) ~ P 0) -_test_Div_RoundHalfZero_P1_P4 = Dict -_test_Rem_RoundHalfZero_P1_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 4) ~ P 1) -_test_Rem_RoundHalfZero_P1_P4 = Dict -_test_Div_RoundHalfZero_P2_N1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 1) ~ N 2) -_test_Div_RoundHalfZero_P2_N1 = Dict -_test_Rem_RoundHalfZero_P2_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_P2_N1 = Dict -_test_Div_RoundHalfZero_P2_N2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 2) ~ N 1) -_test_Div_RoundHalfZero_P2_N2 = Dict -_test_Rem_RoundHalfZero_P2_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 2) ~ P 0) -_test_Rem_RoundHalfZero_P2_N2 = Dict -_test_Div_RoundHalfZero_P2_N3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 3) ~ N 1) -_test_Div_RoundHalfZero_P2_N3 = Dict -_test_Rem_RoundHalfZero_P2_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 3) ~ N 1) -_test_Rem_RoundHalfZero_P2_N3 = Dict -_test_Div_RoundHalfZero_P2_N4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 4) ~ P 0) -_test_Div_RoundHalfZero_P2_N4 = Dict -_test_Rem_RoundHalfZero_P2_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 4) ~ P 2) -_test_Rem_RoundHalfZero_P2_N4 = Dict -_test_Div_RoundHalfZero_P2_P1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 1) ~ P 2) -_test_Div_RoundHalfZero_P2_P1 = Dict -_test_Rem_RoundHalfZero_P2_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_P2_P1 = Dict -_test_Div_RoundHalfZero_P2_P2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 2) ~ P 1) -_test_Div_RoundHalfZero_P2_P2 = Dict -_test_Rem_RoundHalfZero_P2_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 2) ~ P 0) -_test_Rem_RoundHalfZero_P2_P2 = Dict -_test_Div_RoundHalfZero_P2_P3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 3) ~ P 1) -_test_Div_RoundHalfZero_P2_P3 = Dict -_test_Rem_RoundHalfZero_P2_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 3) ~ N 1) -_test_Rem_RoundHalfZero_P2_P3 = Dict -_test_Div_RoundHalfZero_P2_P4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 4) ~ P 0) -_test_Div_RoundHalfZero_P2_P4 = Dict -_test_Rem_RoundHalfZero_P2_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 4) ~ P 2) -_test_Rem_RoundHalfZero_P2_P4 = Dict -_test_Div_RoundHalfZero_P3_N1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 1) ~ N 3) -_test_Div_RoundHalfZero_P3_N1 = Dict -_test_Rem_RoundHalfZero_P3_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_P3_N1 = Dict -_test_Div_RoundHalfZero_P3_N2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 2) ~ N 1) -_test_Div_RoundHalfZero_P3_N2 = Dict -_test_Rem_RoundHalfZero_P3_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 2) ~ P 1) -_test_Rem_RoundHalfZero_P3_N2 = Dict -_test_Div_RoundHalfZero_P3_N3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 3) ~ N 1) -_test_Div_RoundHalfZero_P3_N3 = Dict -_test_Rem_RoundHalfZero_P3_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 3) ~ P 0) -_test_Rem_RoundHalfZero_P3_N3 = Dict -_test_Div_RoundHalfZero_P3_N4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 4) ~ N 1) -_test_Div_RoundHalfZero_P3_N4 = Dict -_test_Rem_RoundHalfZero_P3_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 4) ~ N 1) -_test_Rem_RoundHalfZero_P3_N4 = Dict -_test_Div_RoundHalfZero_P3_P1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 1) ~ P 3) -_test_Div_RoundHalfZero_P3_P1 = Dict -_test_Rem_RoundHalfZero_P3_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_P3_P1 = Dict -_test_Div_RoundHalfZero_P3_P2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 2) ~ P 1) -_test_Div_RoundHalfZero_P3_P2 = Dict -_test_Rem_RoundHalfZero_P3_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 2) ~ P 1) -_test_Rem_RoundHalfZero_P3_P2 = Dict -_test_Div_RoundHalfZero_P3_P3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 3) ~ P 1) -_test_Div_RoundHalfZero_P3_P3 = Dict -_test_Rem_RoundHalfZero_P3_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 3) ~ P 0) -_test_Rem_RoundHalfZero_P3_P3 = Dict -_test_Div_RoundHalfZero_P3_P4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 4) ~ P 1) -_test_Div_RoundHalfZero_P3_P4 = Dict -_test_Rem_RoundHalfZero_P3_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 4) ~ N 1) -_test_Rem_RoundHalfZero_P3_P4 = Dict -_test_Div_RoundHalfZero_P4_N1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 1) ~ N 4) -_test_Div_RoundHalfZero_P4_N1 = Dict -_test_Rem_RoundHalfZero_P4_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 1) ~ P 0) -_test_Rem_RoundHalfZero_P4_N1 = Dict -_test_Div_RoundHalfZero_P4_N2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 2) ~ N 2) -_test_Div_RoundHalfZero_P4_N2 = Dict -_test_Rem_RoundHalfZero_P4_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 2) ~ P 0) -_test_Rem_RoundHalfZero_P4_N2 = Dict -_test_Div_RoundHalfZero_P4_N3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 3) ~ N 1) -_test_Div_RoundHalfZero_P4_N3 = Dict -_test_Rem_RoundHalfZero_P4_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 3) ~ P 1) -_test_Rem_RoundHalfZero_P4_N3 = Dict -_test_Div_RoundHalfZero_P4_N4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 4) ~ N 1) -_test_Div_RoundHalfZero_P4_N4 = Dict -_test_Rem_RoundHalfZero_P4_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 4) ~ P 0) -_test_Rem_RoundHalfZero_P4_N4 = Dict -_test_Div_RoundHalfZero_P4_P1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 1) ~ P 4) -_test_Div_RoundHalfZero_P4_P1 = Dict -_test_Rem_RoundHalfZero_P4_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 1) ~ P 0) -_test_Rem_RoundHalfZero_P4_P1 = Dict -_test_Div_RoundHalfZero_P4_P2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 2) ~ P 2) -_test_Div_RoundHalfZero_P4_P2 = Dict -_test_Rem_RoundHalfZero_P4_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 2) ~ P 0) -_test_Rem_RoundHalfZero_P4_P2 = Dict -_test_Div_RoundHalfZero_P4_P3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 3) ~ P 1) -_test_Div_RoundHalfZero_P4_P3 = Dict -_test_Rem_RoundHalfZero_P4_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 3) ~ P 1) -_test_Rem_RoundHalfZero_P4_P3 = Dict -_test_Div_RoundHalfZero_P4_P4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 4) ~ P 1) -_test_Div_RoundHalfZero_P4_P4 = Dict -_test_Rem_RoundHalfZero_P4_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 4) ~ P 0) -_test_Rem_RoundHalfZero_P4_P4 = Dict -_test_Div_RoundUp_N1_N1 :: Dict (K.Div 'K.RoundUp (N 1) (N 1) ~ P 1) -_test_Div_RoundUp_N1_N1 = Dict -_test_Rem_RoundUp_N1_N1 :: Dict (K.Rem 'K.RoundUp (N 1) (N 1) ~ P 0) -_test_Rem_RoundUp_N1_N1 = Dict -_test_Div_RoundUp_N1_N2 :: Dict (K.Div 'K.RoundUp (N 1) (N 2) ~ P 1) -_test_Div_RoundUp_N1_N2 = Dict -_test_Rem_RoundUp_N1_N2 :: Dict (K.Rem 'K.RoundUp (N 1) (N 2) ~ P 1) -_test_Rem_RoundUp_N1_N2 = Dict -_test_Div_RoundUp_N1_N3 :: Dict (K.Div 'K.RoundUp (N 1) (N 3) ~ P 1) -_test_Div_RoundUp_N1_N3 = Dict -_test_Rem_RoundUp_N1_N3 :: Dict (K.Rem 'K.RoundUp (N 1) (N 3) ~ P 2) -_test_Rem_RoundUp_N1_N3 = Dict -_test_Div_RoundUp_N1_N4 :: Dict (K.Div 'K.RoundUp (N 1) (N 4) ~ P 1) -_test_Div_RoundUp_N1_N4 = Dict -_test_Rem_RoundUp_N1_N4 :: Dict (K.Rem 'K.RoundUp (N 1) (N 4) ~ P 3) -_test_Rem_RoundUp_N1_N4 = Dict -_test_Div_RoundUp_N1_P1 :: Dict (K.Div 'K.RoundUp (N 1) (P 1) ~ N 1) -_test_Div_RoundUp_N1_P1 = Dict -_test_Rem_RoundUp_N1_P1 :: Dict (K.Rem 'K.RoundUp (N 1) (P 1) ~ P 0) -_test_Rem_RoundUp_N1_P1 = Dict -_test_Div_RoundUp_N1_P2 :: Dict (K.Div 'K.RoundUp (N 1) (P 2) ~ P 0) -_test_Div_RoundUp_N1_P2 = Dict -_test_Rem_RoundUp_N1_P2 :: Dict (K.Rem 'K.RoundUp (N 1) (P 2) ~ N 1) -_test_Rem_RoundUp_N1_P2 = Dict -_test_Div_RoundUp_N1_P3 :: Dict (K.Div 'K.RoundUp (N 1) (P 3) ~ P 0) -_test_Div_RoundUp_N1_P3 = Dict -_test_Rem_RoundUp_N1_P3 :: Dict (K.Rem 'K.RoundUp (N 1) (P 3) ~ N 1) -_test_Rem_RoundUp_N1_P3 = Dict -_test_Div_RoundUp_N1_P4 :: Dict (K.Div 'K.RoundUp (N 1) (P 4) ~ P 0) -_test_Div_RoundUp_N1_P4 = Dict -_test_Rem_RoundUp_N1_P4 :: Dict (K.Rem 'K.RoundUp (N 1) (P 4) ~ N 1) -_test_Rem_RoundUp_N1_P4 = Dict -_test_Div_RoundUp_N2_N1 :: Dict (K.Div 'K.RoundUp (N 2) (N 1) ~ P 2) -_test_Div_RoundUp_N2_N1 = Dict -_test_Rem_RoundUp_N2_N1 :: Dict (K.Rem 'K.RoundUp (N 2) (N 1) ~ P 0) -_test_Rem_RoundUp_N2_N1 = Dict -_test_Div_RoundUp_N2_N2 :: Dict (K.Div 'K.RoundUp (N 2) (N 2) ~ P 1) -_test_Div_RoundUp_N2_N2 = Dict -_test_Rem_RoundUp_N2_N2 :: Dict (K.Rem 'K.RoundUp (N 2) (N 2) ~ P 0) -_test_Rem_RoundUp_N2_N2 = Dict -_test_Div_RoundUp_N2_N3 :: Dict (K.Div 'K.RoundUp (N 2) (N 3) ~ P 1) -_test_Div_RoundUp_N2_N3 = Dict -_test_Rem_RoundUp_N2_N3 :: Dict (K.Rem 'K.RoundUp (N 2) (N 3) ~ P 1) -_test_Rem_RoundUp_N2_N3 = Dict -_test_Div_RoundUp_N2_N4 :: Dict (K.Div 'K.RoundUp (N 2) (N 4) ~ P 1) -_test_Div_RoundUp_N2_N4 = Dict -_test_Rem_RoundUp_N2_N4 :: Dict (K.Rem 'K.RoundUp (N 2) (N 4) ~ P 2) -_test_Rem_RoundUp_N2_N4 = Dict -_test_Div_RoundUp_N2_P1 :: Dict (K.Div 'K.RoundUp (N 2) (P 1) ~ N 2) -_test_Div_RoundUp_N2_P1 = Dict -_test_Rem_RoundUp_N2_P1 :: Dict (K.Rem 'K.RoundUp (N 2) (P 1) ~ P 0) -_test_Rem_RoundUp_N2_P1 = Dict -_test_Div_RoundUp_N2_P2 :: Dict (K.Div 'K.RoundUp (N 2) (P 2) ~ N 1) -_test_Div_RoundUp_N2_P2 = Dict -_test_Rem_RoundUp_N2_P2 :: Dict (K.Rem 'K.RoundUp (N 2) (P 2) ~ P 0) -_test_Rem_RoundUp_N2_P2 = Dict -_test_Div_RoundUp_N2_P3 :: Dict (K.Div 'K.RoundUp (N 2) (P 3) ~ P 0) -_test_Div_RoundUp_N2_P3 = Dict -_test_Rem_RoundUp_N2_P3 :: Dict (K.Rem 'K.RoundUp (N 2) (P 3) ~ N 2) -_test_Rem_RoundUp_N2_P3 = Dict -_test_Div_RoundUp_N2_P4 :: Dict (K.Div 'K.RoundUp (N 2) (P 4) ~ P 0) -_test_Div_RoundUp_N2_P4 = Dict -_test_Rem_RoundUp_N2_P4 :: Dict (K.Rem 'K.RoundUp (N 2) (P 4) ~ N 2) -_test_Rem_RoundUp_N2_P4 = Dict -_test_Div_RoundUp_N3_N1 :: Dict (K.Div 'K.RoundUp (N 3) (N 1) ~ P 3) -_test_Div_RoundUp_N3_N1 = Dict -_test_Rem_RoundUp_N3_N1 :: Dict (K.Rem 'K.RoundUp (N 3) (N 1) ~ P 0) -_test_Rem_RoundUp_N3_N1 = Dict -_test_Div_RoundUp_N3_N2 :: Dict (K.Div 'K.RoundUp (N 3) (N 2) ~ P 2) -_test_Div_RoundUp_N3_N2 = Dict -_test_Rem_RoundUp_N3_N2 :: Dict (K.Rem 'K.RoundUp (N 3) (N 2) ~ P 1) -_test_Rem_RoundUp_N3_N2 = Dict -_test_Div_RoundUp_N3_N3 :: Dict (K.Div 'K.RoundUp (N 3) (N 3) ~ P 1) -_test_Div_RoundUp_N3_N3 = Dict -_test_Rem_RoundUp_N3_N3 :: Dict (K.Rem 'K.RoundUp (N 3) (N 3) ~ P 0) -_test_Rem_RoundUp_N3_N3 = Dict -_test_Div_RoundUp_N3_N4 :: Dict (K.Div 'K.RoundUp (N 3) (N 4) ~ P 1) -_test_Div_RoundUp_N3_N4 = Dict -_test_Rem_RoundUp_N3_N4 :: Dict (K.Rem 'K.RoundUp (N 3) (N 4) ~ P 1) -_test_Rem_RoundUp_N3_N4 = Dict -_test_Div_RoundUp_N3_P1 :: Dict (K.Div 'K.RoundUp (N 3) (P 1) ~ N 3) -_test_Div_RoundUp_N3_P1 = Dict -_test_Rem_RoundUp_N3_P1 :: Dict (K.Rem 'K.RoundUp (N 3) (P 1) ~ P 0) -_test_Rem_RoundUp_N3_P1 = Dict -_test_Div_RoundUp_N3_P2 :: Dict (K.Div 'K.RoundUp (N 3) (P 2) ~ N 1) -_test_Div_RoundUp_N3_P2 = Dict -_test_Rem_RoundUp_N3_P2 :: Dict (K.Rem 'K.RoundUp (N 3) (P 2) ~ N 1) -_test_Rem_RoundUp_N3_P2 = Dict -_test_Div_RoundUp_N3_P3 :: Dict (K.Div 'K.RoundUp (N 3) (P 3) ~ N 1) -_test_Div_RoundUp_N3_P3 = Dict -_test_Rem_RoundUp_N3_P3 :: Dict (K.Rem 'K.RoundUp (N 3) (P 3) ~ P 0) -_test_Rem_RoundUp_N3_P3 = Dict -_test_Div_RoundUp_N3_P4 :: Dict (K.Div 'K.RoundUp (N 3) (P 4) ~ P 0) -_test_Div_RoundUp_N3_P4 = Dict -_test_Rem_RoundUp_N3_P4 :: Dict (K.Rem 'K.RoundUp (N 3) (P 4) ~ N 3) -_test_Rem_RoundUp_N3_P4 = Dict -_test_Div_RoundUp_N4_N1 :: Dict (K.Div 'K.RoundUp (N 4) (N 1) ~ P 4) -_test_Div_RoundUp_N4_N1 = Dict -_test_Rem_RoundUp_N4_N1 :: Dict (K.Rem 'K.RoundUp (N 4) (N 1) ~ P 0) -_test_Rem_RoundUp_N4_N1 = Dict -_test_Div_RoundUp_N4_N2 :: Dict (K.Div 'K.RoundUp (N 4) (N 2) ~ P 2) -_test_Div_RoundUp_N4_N2 = Dict -_test_Rem_RoundUp_N4_N2 :: Dict (K.Rem 'K.RoundUp (N 4) (N 2) ~ P 0) -_test_Rem_RoundUp_N4_N2 = Dict -_test_Div_RoundUp_N4_N3 :: Dict (K.Div 'K.RoundUp (N 4) (N 3) ~ P 2) -_test_Div_RoundUp_N4_N3 = Dict -_test_Rem_RoundUp_N4_N3 :: Dict (K.Rem 'K.RoundUp (N 4) (N 3) ~ P 2) -_test_Rem_RoundUp_N4_N3 = Dict -_test_Div_RoundUp_N4_N4 :: Dict (K.Div 'K.RoundUp (N 4) (N 4) ~ P 1) -_test_Div_RoundUp_N4_N4 = Dict -_test_Rem_RoundUp_N4_N4 :: Dict (K.Rem 'K.RoundUp (N 4) (N 4) ~ P 0) -_test_Rem_RoundUp_N4_N4 = Dict -_test_Div_RoundUp_N4_P1 :: Dict (K.Div 'K.RoundUp (N 4) (P 1) ~ N 4) -_test_Div_RoundUp_N4_P1 = Dict -_test_Rem_RoundUp_N4_P1 :: Dict (K.Rem 'K.RoundUp (N 4) (P 1) ~ P 0) -_test_Rem_RoundUp_N4_P1 = Dict -_test_Div_RoundUp_N4_P2 :: Dict (K.Div 'K.RoundUp (N 4) (P 2) ~ N 2) -_test_Div_RoundUp_N4_P2 = Dict -_test_Rem_RoundUp_N4_P2 :: Dict (K.Rem 'K.RoundUp (N 4) (P 2) ~ P 0) -_test_Rem_RoundUp_N4_P2 = Dict -_test_Div_RoundUp_N4_P3 :: Dict (K.Div 'K.RoundUp (N 4) (P 3) ~ N 1) -_test_Div_RoundUp_N4_P3 = Dict -_test_Rem_RoundUp_N4_P3 :: Dict (K.Rem 'K.RoundUp (N 4) (P 3) ~ N 1) -_test_Rem_RoundUp_N4_P3 = Dict -_test_Div_RoundUp_N4_P4 :: Dict (K.Div 'K.RoundUp (N 4) (P 4) ~ N 1) -_test_Div_RoundUp_N4_P4 = Dict -_test_Rem_RoundUp_N4_P4 :: Dict (K.Rem 'K.RoundUp (N 4) (P 4) ~ P 0) -_test_Rem_RoundUp_N4_P4 = Dict -_test_Div_RoundUp_P0_N1 :: Dict (K.Div 'K.RoundUp (P 0) (N 1) ~ P 0) -_test_Div_RoundUp_P0_N1 = Dict -_test_Rem_RoundUp_P0_N1 :: Dict (K.Rem 'K.RoundUp (P 0) (N 1) ~ P 0) -_test_Rem_RoundUp_P0_N1 = Dict -_test_Div_RoundUp_P0_N2 :: Dict (K.Div 'K.RoundUp (P 0) (N 2) ~ P 0) -_test_Div_RoundUp_P0_N2 = Dict -_test_Rem_RoundUp_P0_N2 :: Dict (K.Rem 'K.RoundUp (P 0) (N 2) ~ P 0) -_test_Rem_RoundUp_P0_N2 = Dict -_test_Div_RoundUp_P0_N3 :: Dict (K.Div 'K.RoundUp (P 0) (N 3) ~ P 0) -_test_Div_RoundUp_P0_N3 = Dict -_test_Rem_RoundUp_P0_N3 :: Dict (K.Rem 'K.RoundUp (P 0) (N 3) ~ P 0) -_test_Rem_RoundUp_P0_N3 = Dict -_test_Div_RoundUp_P0_N4 :: Dict (K.Div 'K.RoundUp (P 0) (N 4) ~ P 0) -_test_Div_RoundUp_P0_N4 = Dict -_test_Rem_RoundUp_P0_N4 :: Dict (K.Rem 'K.RoundUp (P 0) (N 4) ~ P 0) -_test_Rem_RoundUp_P0_N4 = Dict -_test_Div_RoundUp_P0_P1 :: Dict (K.Div 'K.RoundUp (P 0) (P 1) ~ P 0) -_test_Div_RoundUp_P0_P1 = Dict -_test_Rem_RoundUp_P0_P1 :: Dict (K.Rem 'K.RoundUp (P 0) (P 1) ~ P 0) -_test_Rem_RoundUp_P0_P1 = Dict -_test_Div_RoundUp_P0_P2 :: Dict (K.Div 'K.RoundUp (P 0) (P 2) ~ P 0) -_test_Div_RoundUp_P0_P2 = Dict -_test_Rem_RoundUp_P0_P2 :: Dict (K.Rem 'K.RoundUp (P 0) (P 2) ~ P 0) -_test_Rem_RoundUp_P0_P2 = Dict -_test_Div_RoundUp_P0_P3 :: Dict (K.Div 'K.RoundUp (P 0) (P 3) ~ P 0) -_test_Div_RoundUp_P0_P3 = Dict -_test_Rem_RoundUp_P0_P3 :: Dict (K.Rem 'K.RoundUp (P 0) (P 3) ~ P 0) -_test_Rem_RoundUp_P0_P3 = Dict -_test_Div_RoundUp_P0_P4 :: Dict (K.Div 'K.RoundUp (P 0) (P 4) ~ P 0) -_test_Div_RoundUp_P0_P4 = Dict -_test_Rem_RoundUp_P0_P4 :: Dict (K.Rem 'K.RoundUp (P 0) (P 4) ~ P 0) -_test_Rem_RoundUp_P0_P4 = Dict -_test_Div_RoundUp_P1_N1 :: Dict (K.Div 'K.RoundUp (P 1) (N 1) ~ N 1) -_test_Div_RoundUp_P1_N1 = Dict -_test_Rem_RoundUp_P1_N1 :: Dict (K.Rem 'K.RoundUp (P 1) (N 1) ~ P 0) -_test_Rem_RoundUp_P1_N1 = Dict -_test_Div_RoundUp_P1_N2 :: Dict (K.Div 'K.RoundUp (P 1) (N 2) ~ P 0) -_test_Div_RoundUp_P1_N2 = Dict -_test_Rem_RoundUp_P1_N2 :: Dict (K.Rem 'K.RoundUp (P 1) (N 2) ~ P 1) -_test_Rem_RoundUp_P1_N2 = Dict -_test_Div_RoundUp_P1_N3 :: Dict (K.Div 'K.RoundUp (P 1) (N 3) ~ P 0) -_test_Div_RoundUp_P1_N3 = Dict -_test_Rem_RoundUp_P1_N3 :: Dict (K.Rem 'K.RoundUp (P 1) (N 3) ~ P 1) -_test_Rem_RoundUp_P1_N3 = Dict -_test_Div_RoundUp_P1_N4 :: Dict (K.Div 'K.RoundUp (P 1) (N 4) ~ P 0) -_test_Div_RoundUp_P1_N4 = Dict -_test_Rem_RoundUp_P1_N4 :: Dict (K.Rem 'K.RoundUp (P 1) (N 4) ~ P 1) -_test_Rem_RoundUp_P1_N4 = Dict -_test_Div_RoundUp_P1_P1 :: Dict (K.Div 'K.RoundUp (P 1) (P 1) ~ P 1) -_test_Div_RoundUp_P1_P1 = Dict -_test_Rem_RoundUp_P1_P1 :: Dict (K.Rem 'K.RoundUp (P 1) (P 1) ~ P 0) -_test_Rem_RoundUp_P1_P1 = Dict -_test_Div_RoundUp_P1_P2 :: Dict (K.Div 'K.RoundUp (P 1) (P 2) ~ P 1) -_test_Div_RoundUp_P1_P2 = Dict -_test_Rem_RoundUp_P1_P2 :: Dict (K.Rem 'K.RoundUp (P 1) (P 2) ~ N 1) -_test_Rem_RoundUp_P1_P2 = Dict -_test_Div_RoundUp_P1_P3 :: Dict (K.Div 'K.RoundUp (P 1) (P 3) ~ P 1) -_test_Div_RoundUp_P1_P3 = Dict -_test_Rem_RoundUp_P1_P3 :: Dict (K.Rem 'K.RoundUp (P 1) (P 3) ~ N 2) -_test_Rem_RoundUp_P1_P3 = Dict -_test_Div_RoundUp_P1_P4 :: Dict (K.Div 'K.RoundUp (P 1) (P 4) ~ P 1) -_test_Div_RoundUp_P1_P4 = Dict -_test_Rem_RoundUp_P1_P4 :: Dict (K.Rem 'K.RoundUp (P 1) (P 4) ~ N 3) -_test_Rem_RoundUp_P1_P4 = Dict -_test_Div_RoundUp_P2_N1 :: Dict (K.Div 'K.RoundUp (P 2) (N 1) ~ N 2) -_test_Div_RoundUp_P2_N1 = Dict -_test_Rem_RoundUp_P2_N1 :: Dict (K.Rem 'K.RoundUp (P 2) (N 1) ~ P 0) -_test_Rem_RoundUp_P2_N1 = Dict -_test_Div_RoundUp_P2_N2 :: Dict (K.Div 'K.RoundUp (P 2) (N 2) ~ N 1) -_test_Div_RoundUp_P2_N2 = Dict -_test_Rem_RoundUp_P2_N2 :: Dict (K.Rem 'K.RoundUp (P 2) (N 2) ~ P 0) -_test_Rem_RoundUp_P2_N2 = Dict -_test_Div_RoundUp_P2_N3 :: Dict (K.Div 'K.RoundUp (P 2) (N 3) ~ P 0) -_test_Div_RoundUp_P2_N3 = Dict -_test_Rem_RoundUp_P2_N3 :: Dict (K.Rem 'K.RoundUp (P 2) (N 3) ~ P 2) -_test_Rem_RoundUp_P2_N3 = Dict -_test_Div_RoundUp_P2_N4 :: Dict (K.Div 'K.RoundUp (P 2) (N 4) ~ P 0) -_test_Div_RoundUp_P2_N4 = Dict -_test_Rem_RoundUp_P2_N4 :: Dict (K.Rem 'K.RoundUp (P 2) (N 4) ~ P 2) -_test_Rem_RoundUp_P2_N4 = Dict -_test_Div_RoundUp_P2_P1 :: Dict (K.Div 'K.RoundUp (P 2) (P 1) ~ P 2) -_test_Div_RoundUp_P2_P1 = Dict -_test_Rem_RoundUp_P2_P1 :: Dict (K.Rem 'K.RoundUp (P 2) (P 1) ~ P 0) -_test_Rem_RoundUp_P2_P1 = Dict -_test_Div_RoundUp_P2_P2 :: Dict (K.Div 'K.RoundUp (P 2) (P 2) ~ P 1) -_test_Div_RoundUp_P2_P2 = Dict -_test_Rem_RoundUp_P2_P2 :: Dict (K.Rem 'K.RoundUp (P 2) (P 2) ~ P 0) -_test_Rem_RoundUp_P2_P2 = Dict -_test_Div_RoundUp_P2_P3 :: Dict (K.Div 'K.RoundUp (P 2) (P 3) ~ P 1) -_test_Div_RoundUp_P2_P3 = Dict -_test_Rem_RoundUp_P2_P3 :: Dict (K.Rem 'K.RoundUp (P 2) (P 3) ~ N 1) -_test_Rem_RoundUp_P2_P3 = Dict -_test_Div_RoundUp_P2_P4 :: Dict (K.Div 'K.RoundUp (P 2) (P 4) ~ P 1) -_test_Div_RoundUp_P2_P4 = Dict -_test_Rem_RoundUp_P2_P4 :: Dict (K.Rem 'K.RoundUp (P 2) (P 4) ~ N 2) -_test_Rem_RoundUp_P2_P4 = Dict -_test_Div_RoundUp_P3_N1 :: Dict (K.Div 'K.RoundUp (P 3) (N 1) ~ N 3) -_test_Div_RoundUp_P3_N1 = Dict -_test_Rem_RoundUp_P3_N1 :: Dict (K.Rem 'K.RoundUp (P 3) (N 1) ~ P 0) -_test_Rem_RoundUp_P3_N1 = Dict -_test_Div_RoundUp_P3_N2 :: Dict (K.Div 'K.RoundUp (P 3) (N 2) ~ N 1) -_test_Div_RoundUp_P3_N2 = Dict -_test_Rem_RoundUp_P3_N2 :: Dict (K.Rem 'K.RoundUp (P 3) (N 2) ~ P 1) -_test_Rem_RoundUp_P3_N2 = Dict -_test_Div_RoundUp_P3_N3 :: Dict (K.Div 'K.RoundUp (P 3) (N 3) ~ N 1) -_test_Div_RoundUp_P3_N3 = Dict -_test_Rem_RoundUp_P3_N3 :: Dict (K.Rem 'K.RoundUp (P 3) (N 3) ~ P 0) -_test_Rem_RoundUp_P3_N3 = Dict -_test_Div_RoundUp_P3_N4 :: Dict (K.Div 'K.RoundUp (P 3) (N 4) ~ P 0) -_test_Div_RoundUp_P3_N4 = Dict -_test_Rem_RoundUp_P3_N4 :: Dict (K.Rem 'K.RoundUp (P 3) (N 4) ~ P 3) -_test_Rem_RoundUp_P3_N4 = Dict -_test_Div_RoundUp_P3_P1 :: Dict (K.Div 'K.RoundUp (P 3) (P 1) ~ P 3) -_test_Div_RoundUp_P3_P1 = Dict -_test_Rem_RoundUp_P3_P1 :: Dict (K.Rem 'K.RoundUp (P 3) (P 1) ~ P 0) -_test_Rem_RoundUp_P3_P1 = Dict -_test_Div_RoundUp_P3_P2 :: Dict (K.Div 'K.RoundUp (P 3) (P 2) ~ P 2) -_test_Div_RoundUp_P3_P2 = Dict -_test_Rem_RoundUp_P3_P2 :: Dict (K.Rem 'K.RoundUp (P 3) (P 2) ~ N 1) -_test_Rem_RoundUp_P3_P2 = Dict -_test_Div_RoundUp_P3_P3 :: Dict (K.Div 'K.RoundUp (P 3) (P 3) ~ P 1) -_test_Div_RoundUp_P3_P3 = Dict -_test_Rem_RoundUp_P3_P3 :: Dict (K.Rem 'K.RoundUp (P 3) (P 3) ~ P 0) -_test_Rem_RoundUp_P3_P3 = Dict -_test_Div_RoundUp_P3_P4 :: Dict (K.Div 'K.RoundUp (P 3) (P 4) ~ P 1) -_test_Div_RoundUp_P3_P4 = Dict -_test_Rem_RoundUp_P3_P4 :: Dict (K.Rem 'K.RoundUp (P 3) (P 4) ~ N 1) -_test_Rem_RoundUp_P3_P4 = Dict -_test_Div_RoundUp_P4_N1 :: Dict (K.Div 'K.RoundUp (P 4) (N 1) ~ N 4) -_test_Div_RoundUp_P4_N1 = Dict -_test_Rem_RoundUp_P4_N1 :: Dict (K.Rem 'K.RoundUp (P 4) (N 1) ~ P 0) -_test_Rem_RoundUp_P4_N1 = Dict -_test_Div_RoundUp_P4_N2 :: Dict (K.Div 'K.RoundUp (P 4) (N 2) ~ N 2) -_test_Div_RoundUp_P4_N2 = Dict -_test_Rem_RoundUp_P4_N2 :: Dict (K.Rem 'K.RoundUp (P 4) (N 2) ~ P 0) -_test_Rem_RoundUp_P4_N2 = Dict -_test_Div_RoundUp_P4_N3 :: Dict (K.Div 'K.RoundUp (P 4) (N 3) ~ N 1) -_test_Div_RoundUp_P4_N3 = Dict -_test_Rem_RoundUp_P4_N3 :: Dict (K.Rem 'K.RoundUp (P 4) (N 3) ~ P 1) -_test_Rem_RoundUp_P4_N3 = Dict -_test_Div_RoundUp_P4_N4 :: Dict (K.Div 'K.RoundUp (P 4) (N 4) ~ N 1) -_test_Div_RoundUp_P4_N4 = Dict -_test_Rem_RoundUp_P4_N4 :: Dict (K.Rem 'K.RoundUp (P 4) (N 4) ~ P 0) -_test_Rem_RoundUp_P4_N4 = Dict -_test_Div_RoundUp_P4_P1 :: Dict (K.Div 'K.RoundUp (P 4) (P 1) ~ P 4) -_test_Div_RoundUp_P4_P1 = Dict -_test_Rem_RoundUp_P4_P1 :: Dict (K.Rem 'K.RoundUp (P 4) (P 1) ~ P 0) -_test_Rem_RoundUp_P4_P1 = Dict -_test_Div_RoundUp_P4_P2 :: Dict (K.Div 'K.RoundUp (P 4) (P 2) ~ P 2) -_test_Div_RoundUp_P4_P2 = Dict -_test_Rem_RoundUp_P4_P2 :: Dict (K.Rem 'K.RoundUp (P 4) (P 2) ~ P 0) -_test_Rem_RoundUp_P4_P2 = Dict -_test_Div_RoundUp_P4_P3 :: Dict (K.Div 'K.RoundUp (P 4) (P 3) ~ P 2) -_test_Div_RoundUp_P4_P3 = Dict -_test_Rem_RoundUp_P4_P3 :: Dict (K.Rem 'K.RoundUp (P 4) (P 3) ~ N 2) -_test_Rem_RoundUp_P4_P3 = Dict -_test_Div_RoundUp_P4_P4 :: Dict (K.Div 'K.RoundUp (P 4) (P 4) ~ P 1) -_test_Div_RoundUp_P4_P4 = Dict -_test_Rem_RoundUp_P4_P4 :: Dict (K.Rem 'K.RoundUp (P 4) (P 4) ~ P 0) -_test_Rem_RoundUp_P4_P4 = Dict -_test_Div_RoundZero_N1_N1 :: Dict (K.Div 'K.RoundZero (N 1) (N 1) ~ P 1) -_test_Div_RoundZero_N1_N1 = Dict -_test_Rem_RoundZero_N1_N1 :: Dict (K.Rem 'K.RoundZero (N 1) (N 1) ~ P 0) -_test_Rem_RoundZero_N1_N1 = Dict -_test_Div_RoundZero_N1_N2 :: Dict (K.Div 'K.RoundZero (N 1) (N 2) ~ P 0) -_test_Div_RoundZero_N1_N2 = Dict -_test_Rem_RoundZero_N1_N2 :: Dict (K.Rem 'K.RoundZero (N 1) (N 2) ~ N 1) -_test_Rem_RoundZero_N1_N2 = Dict -_test_Div_RoundZero_N1_N3 :: Dict (K.Div 'K.RoundZero (N 1) (N 3) ~ P 0) -_test_Div_RoundZero_N1_N3 = Dict -_test_Rem_RoundZero_N1_N3 :: Dict (K.Rem 'K.RoundZero (N 1) (N 3) ~ N 1) -_test_Rem_RoundZero_N1_N3 = Dict -_test_Div_RoundZero_N1_N4 :: Dict (K.Div 'K.RoundZero (N 1) (N 4) ~ P 0) -_test_Div_RoundZero_N1_N4 = Dict -_test_Rem_RoundZero_N1_N4 :: Dict (K.Rem 'K.RoundZero (N 1) (N 4) ~ N 1) -_test_Rem_RoundZero_N1_N4 = Dict -_test_Div_RoundZero_N1_P1 :: Dict (K.Div 'K.RoundZero (N 1) (P 1) ~ N 1) -_test_Div_RoundZero_N1_P1 = Dict -_test_Rem_RoundZero_N1_P1 :: Dict (K.Rem 'K.RoundZero (N 1) (P 1) ~ P 0) -_test_Rem_RoundZero_N1_P1 = Dict -_test_Div_RoundZero_N1_P2 :: Dict (K.Div 'K.RoundZero (N 1) (P 2) ~ P 0) -_test_Div_RoundZero_N1_P2 = Dict -_test_Rem_RoundZero_N1_P2 :: Dict (K.Rem 'K.RoundZero (N 1) (P 2) ~ N 1) -_test_Rem_RoundZero_N1_P2 = Dict -_test_Div_RoundZero_N1_P3 :: Dict (K.Div 'K.RoundZero (N 1) (P 3) ~ P 0) -_test_Div_RoundZero_N1_P3 = Dict -_test_Rem_RoundZero_N1_P3 :: Dict (K.Rem 'K.RoundZero (N 1) (P 3) ~ N 1) -_test_Rem_RoundZero_N1_P3 = Dict -_test_Div_RoundZero_N1_P4 :: Dict (K.Div 'K.RoundZero (N 1) (P 4) ~ P 0) -_test_Div_RoundZero_N1_P4 = Dict -_test_Rem_RoundZero_N1_P4 :: Dict (K.Rem 'K.RoundZero (N 1) (P 4) ~ N 1) -_test_Rem_RoundZero_N1_P4 = Dict -_test_Div_RoundZero_N2_N1 :: Dict (K.Div 'K.RoundZero (N 2) (N 1) ~ P 2) -_test_Div_RoundZero_N2_N1 = Dict -_test_Rem_RoundZero_N2_N1 :: Dict (K.Rem 'K.RoundZero (N 2) (N 1) ~ P 0) -_test_Rem_RoundZero_N2_N1 = Dict -_test_Div_RoundZero_N2_N2 :: Dict (K.Div 'K.RoundZero (N 2) (N 2) ~ P 1) -_test_Div_RoundZero_N2_N2 = Dict -_test_Rem_RoundZero_N2_N2 :: Dict (K.Rem 'K.RoundZero (N 2) (N 2) ~ P 0) -_test_Rem_RoundZero_N2_N2 = Dict -_test_Div_RoundZero_N2_N3 :: Dict (K.Div 'K.RoundZero (N 2) (N 3) ~ P 0) -_test_Div_RoundZero_N2_N3 = Dict -_test_Rem_RoundZero_N2_N3 :: Dict (K.Rem 'K.RoundZero (N 2) (N 3) ~ N 2) -_test_Rem_RoundZero_N2_N3 = Dict -_test_Div_RoundZero_N2_N4 :: Dict (K.Div 'K.RoundZero (N 2) (N 4) ~ P 0) -_test_Div_RoundZero_N2_N4 = Dict -_test_Rem_RoundZero_N2_N4 :: Dict (K.Rem 'K.RoundZero (N 2) (N 4) ~ N 2) -_test_Rem_RoundZero_N2_N4 = Dict -_test_Div_RoundZero_N2_P1 :: Dict (K.Div 'K.RoundZero (N 2) (P 1) ~ N 2) -_test_Div_RoundZero_N2_P1 = Dict -_test_Rem_RoundZero_N2_P1 :: Dict (K.Rem 'K.RoundZero (N 2) (P 1) ~ P 0) -_test_Rem_RoundZero_N2_P1 = Dict -_test_Div_RoundZero_N2_P2 :: Dict (K.Div 'K.RoundZero (N 2) (P 2) ~ N 1) -_test_Div_RoundZero_N2_P2 = Dict -_test_Rem_RoundZero_N2_P2 :: Dict (K.Rem 'K.RoundZero (N 2) (P 2) ~ P 0) -_test_Rem_RoundZero_N2_P2 = Dict -_test_Div_RoundZero_N2_P3 :: Dict (K.Div 'K.RoundZero (N 2) (P 3) ~ P 0) -_test_Div_RoundZero_N2_P3 = Dict -_test_Rem_RoundZero_N2_P3 :: Dict (K.Rem 'K.RoundZero (N 2) (P 3) ~ N 2) -_test_Rem_RoundZero_N2_P3 = Dict -_test_Div_RoundZero_N2_P4 :: Dict (K.Div 'K.RoundZero (N 2) (P 4) ~ P 0) -_test_Div_RoundZero_N2_P4 = Dict -_test_Rem_RoundZero_N2_P4 :: Dict (K.Rem 'K.RoundZero (N 2) (P 4) ~ N 2) -_test_Rem_RoundZero_N2_P4 = Dict -_test_Div_RoundZero_N3_N1 :: Dict (K.Div 'K.RoundZero (N 3) (N 1) ~ P 3) -_test_Div_RoundZero_N3_N1 = Dict -_test_Rem_RoundZero_N3_N1 :: Dict (K.Rem 'K.RoundZero (N 3) (N 1) ~ P 0) -_test_Rem_RoundZero_N3_N1 = Dict -_test_Div_RoundZero_N3_N2 :: Dict (K.Div 'K.RoundZero (N 3) (N 2) ~ P 1) -_test_Div_RoundZero_N3_N2 = Dict -_test_Rem_RoundZero_N3_N2 :: Dict (K.Rem 'K.RoundZero (N 3) (N 2) ~ N 1) -_test_Rem_RoundZero_N3_N2 = Dict -_test_Div_RoundZero_N3_N3 :: Dict (K.Div 'K.RoundZero (N 3) (N 3) ~ P 1) -_test_Div_RoundZero_N3_N3 = Dict -_test_Rem_RoundZero_N3_N3 :: Dict (K.Rem 'K.RoundZero (N 3) (N 3) ~ P 0) -_test_Rem_RoundZero_N3_N3 = Dict -_test_Div_RoundZero_N3_N4 :: Dict (K.Div 'K.RoundZero (N 3) (N 4) ~ P 0) -_test_Div_RoundZero_N3_N4 = Dict -_test_Rem_RoundZero_N3_N4 :: Dict (K.Rem 'K.RoundZero (N 3) (N 4) ~ N 3) -_test_Rem_RoundZero_N3_N4 = Dict -_test_Div_RoundZero_N3_P1 :: Dict (K.Div 'K.RoundZero (N 3) (P 1) ~ N 3) -_test_Div_RoundZero_N3_P1 = Dict -_test_Rem_RoundZero_N3_P1 :: Dict (K.Rem 'K.RoundZero (N 3) (P 1) ~ P 0) -_test_Rem_RoundZero_N3_P1 = Dict -_test_Div_RoundZero_N3_P2 :: Dict (K.Div 'K.RoundZero (N 3) (P 2) ~ N 1) -_test_Div_RoundZero_N3_P2 = Dict -_test_Rem_RoundZero_N3_P2 :: Dict (K.Rem 'K.RoundZero (N 3) (P 2) ~ N 1) -_test_Rem_RoundZero_N3_P2 = Dict -_test_Div_RoundZero_N3_P3 :: Dict (K.Div 'K.RoundZero (N 3) (P 3) ~ N 1) -_test_Div_RoundZero_N3_P3 = Dict -_test_Rem_RoundZero_N3_P3 :: Dict (K.Rem 'K.RoundZero (N 3) (P 3) ~ P 0) -_test_Rem_RoundZero_N3_P3 = Dict -_test_Div_RoundZero_N3_P4 :: Dict (K.Div 'K.RoundZero (N 3) (P 4) ~ P 0) -_test_Div_RoundZero_N3_P4 = Dict -_test_Rem_RoundZero_N3_P4 :: Dict (K.Rem 'K.RoundZero (N 3) (P 4) ~ N 3) -_test_Rem_RoundZero_N3_P4 = Dict -_test_Div_RoundZero_N4_N1 :: Dict (K.Div 'K.RoundZero (N 4) (N 1) ~ P 4) -_test_Div_RoundZero_N4_N1 = Dict -_test_Rem_RoundZero_N4_N1 :: Dict (K.Rem 'K.RoundZero (N 4) (N 1) ~ P 0) -_test_Rem_RoundZero_N4_N1 = Dict -_test_Div_RoundZero_N4_N2 :: Dict (K.Div 'K.RoundZero (N 4) (N 2) ~ P 2) -_test_Div_RoundZero_N4_N2 = Dict -_test_Rem_RoundZero_N4_N2 :: Dict (K.Rem 'K.RoundZero (N 4) (N 2) ~ P 0) -_test_Rem_RoundZero_N4_N2 = Dict -_test_Div_RoundZero_N4_N3 :: Dict (K.Div 'K.RoundZero (N 4) (N 3) ~ P 1) -_test_Div_RoundZero_N4_N3 = Dict -_test_Rem_RoundZero_N4_N3 :: Dict (K.Rem 'K.RoundZero (N 4) (N 3) ~ N 1) -_test_Rem_RoundZero_N4_N3 = Dict -_test_Div_RoundZero_N4_N4 :: Dict (K.Div 'K.RoundZero (N 4) (N 4) ~ P 1) -_test_Div_RoundZero_N4_N4 = Dict -_test_Rem_RoundZero_N4_N4 :: Dict (K.Rem 'K.RoundZero (N 4) (N 4) ~ P 0) -_test_Rem_RoundZero_N4_N4 = Dict -_test_Div_RoundZero_N4_P1 :: Dict (K.Div 'K.RoundZero (N 4) (P 1) ~ N 4) -_test_Div_RoundZero_N4_P1 = Dict -_test_Rem_RoundZero_N4_P1 :: Dict (K.Rem 'K.RoundZero (N 4) (P 1) ~ P 0) -_test_Rem_RoundZero_N4_P1 = Dict -_test_Div_RoundZero_N4_P2 :: Dict (K.Div 'K.RoundZero (N 4) (P 2) ~ N 2) -_test_Div_RoundZero_N4_P2 = Dict -_test_Rem_RoundZero_N4_P2 :: Dict (K.Rem 'K.RoundZero (N 4) (P 2) ~ P 0) -_test_Rem_RoundZero_N4_P2 = Dict -_test_Div_RoundZero_N4_P3 :: Dict (K.Div 'K.RoundZero (N 4) (P 3) ~ N 1) -_test_Div_RoundZero_N4_P3 = Dict -_test_Rem_RoundZero_N4_P3 :: Dict (K.Rem 'K.RoundZero (N 4) (P 3) ~ N 1) -_test_Rem_RoundZero_N4_P3 = Dict -_test_Div_RoundZero_N4_P4 :: Dict (K.Div 'K.RoundZero (N 4) (P 4) ~ N 1) -_test_Div_RoundZero_N4_P4 = Dict -_test_Rem_RoundZero_N4_P4 :: Dict (K.Rem 'K.RoundZero (N 4) (P 4) ~ P 0) -_test_Rem_RoundZero_N4_P4 = Dict -_test_Div_RoundZero_P0_N1 :: Dict (K.Div 'K.RoundZero (P 0) (N 1) ~ P 0) -_test_Div_RoundZero_P0_N1 = Dict -_test_Rem_RoundZero_P0_N1 :: Dict (K.Rem 'K.RoundZero (P 0) (N 1) ~ P 0) -_test_Rem_RoundZero_P0_N1 = Dict -_test_Div_RoundZero_P0_N2 :: Dict (K.Div 'K.RoundZero (P 0) (N 2) ~ P 0) -_test_Div_RoundZero_P0_N2 = Dict -_test_Rem_RoundZero_P0_N2 :: Dict (K.Rem 'K.RoundZero (P 0) (N 2) ~ P 0) -_test_Rem_RoundZero_P0_N2 = Dict -_test_Div_RoundZero_P0_N3 :: Dict (K.Div 'K.RoundZero (P 0) (N 3) ~ P 0) -_test_Div_RoundZero_P0_N3 = Dict -_test_Rem_RoundZero_P0_N3 :: Dict (K.Rem 'K.RoundZero (P 0) (N 3) ~ P 0) -_test_Rem_RoundZero_P0_N3 = Dict -_test_Div_RoundZero_P0_N4 :: Dict (K.Div 'K.RoundZero (P 0) (N 4) ~ P 0) -_test_Div_RoundZero_P0_N4 = Dict -_test_Rem_RoundZero_P0_N4 :: Dict (K.Rem 'K.RoundZero (P 0) (N 4) ~ P 0) -_test_Rem_RoundZero_P0_N4 = Dict -_test_Div_RoundZero_P0_P1 :: Dict (K.Div 'K.RoundZero (P 0) (P 1) ~ P 0) -_test_Div_RoundZero_P0_P1 = Dict -_test_Rem_RoundZero_P0_P1 :: Dict (K.Rem 'K.RoundZero (P 0) (P 1) ~ P 0) -_test_Rem_RoundZero_P0_P1 = Dict -_test_Div_RoundZero_P0_P2 :: Dict (K.Div 'K.RoundZero (P 0) (P 2) ~ P 0) -_test_Div_RoundZero_P0_P2 = Dict -_test_Rem_RoundZero_P0_P2 :: Dict (K.Rem 'K.RoundZero (P 0) (P 2) ~ P 0) -_test_Rem_RoundZero_P0_P2 = Dict -_test_Div_RoundZero_P0_P3 :: Dict (K.Div 'K.RoundZero (P 0) (P 3) ~ P 0) -_test_Div_RoundZero_P0_P3 = Dict -_test_Rem_RoundZero_P0_P3 :: Dict (K.Rem 'K.RoundZero (P 0) (P 3) ~ P 0) -_test_Rem_RoundZero_P0_P3 = Dict -_test_Div_RoundZero_P0_P4 :: Dict (K.Div 'K.RoundZero (P 0) (P 4) ~ P 0) -_test_Div_RoundZero_P0_P4 = Dict -_test_Rem_RoundZero_P0_P4 :: Dict (K.Rem 'K.RoundZero (P 0) (P 4) ~ P 0) -_test_Rem_RoundZero_P0_P4 = Dict -_test_Div_RoundZero_P1_N1 :: Dict (K.Div 'K.RoundZero (P 1) (N 1) ~ N 1) -_test_Div_RoundZero_P1_N1 = Dict -_test_Rem_RoundZero_P1_N1 :: Dict (K.Rem 'K.RoundZero (P 1) (N 1) ~ P 0) -_test_Rem_RoundZero_P1_N1 = Dict -_test_Div_RoundZero_P1_N2 :: Dict (K.Div 'K.RoundZero (P 1) (N 2) ~ P 0) -_test_Div_RoundZero_P1_N2 = Dict -_test_Rem_RoundZero_P1_N2 :: Dict (K.Rem 'K.RoundZero (P 1) (N 2) ~ P 1) -_test_Rem_RoundZero_P1_N2 = Dict -_test_Div_RoundZero_P1_N3 :: Dict (K.Div 'K.RoundZero (P 1) (N 3) ~ P 0) -_test_Div_RoundZero_P1_N3 = Dict -_test_Rem_RoundZero_P1_N3 :: Dict (K.Rem 'K.RoundZero (P 1) (N 3) ~ P 1) -_test_Rem_RoundZero_P1_N3 = Dict -_test_Div_RoundZero_P1_N4 :: Dict (K.Div 'K.RoundZero (P 1) (N 4) ~ P 0) -_test_Div_RoundZero_P1_N4 = Dict -_test_Rem_RoundZero_P1_N4 :: Dict (K.Rem 'K.RoundZero (P 1) (N 4) ~ P 1) -_test_Rem_RoundZero_P1_N4 = Dict -_test_Div_RoundZero_P1_P1 :: Dict (K.Div 'K.RoundZero (P 1) (P 1) ~ P 1) -_test_Div_RoundZero_P1_P1 = Dict -_test_Rem_RoundZero_P1_P1 :: Dict (K.Rem 'K.RoundZero (P 1) (P 1) ~ P 0) -_test_Rem_RoundZero_P1_P1 = Dict -_test_Div_RoundZero_P1_P2 :: Dict (K.Div 'K.RoundZero (P 1) (P 2) ~ P 0) -_test_Div_RoundZero_P1_P2 = Dict -_test_Rem_RoundZero_P1_P2 :: Dict (K.Rem 'K.RoundZero (P 1) (P 2) ~ P 1) -_test_Rem_RoundZero_P1_P2 = Dict -_test_Div_RoundZero_P1_P3 :: Dict (K.Div 'K.RoundZero (P 1) (P 3) ~ P 0) -_test_Div_RoundZero_P1_P3 = Dict -_test_Rem_RoundZero_P1_P3 :: Dict (K.Rem 'K.RoundZero (P 1) (P 3) ~ P 1) -_test_Rem_RoundZero_P1_P3 = Dict -_test_Div_RoundZero_P1_P4 :: Dict (K.Div 'K.RoundZero (P 1) (P 4) ~ P 0) -_test_Div_RoundZero_P1_P4 = Dict -_test_Rem_RoundZero_P1_P4 :: Dict (K.Rem 'K.RoundZero (P 1) (P 4) ~ P 1) -_test_Rem_RoundZero_P1_P4 = Dict -_test_Div_RoundZero_P2_N1 :: Dict (K.Div 'K.RoundZero (P 2) (N 1) ~ N 2) -_test_Div_RoundZero_P2_N1 = Dict -_test_Rem_RoundZero_P2_N1 :: Dict (K.Rem 'K.RoundZero (P 2) (N 1) ~ P 0) -_test_Rem_RoundZero_P2_N1 = Dict -_test_Div_RoundZero_P2_N2 :: Dict (K.Div 'K.RoundZero (P 2) (N 2) ~ N 1) -_test_Div_RoundZero_P2_N2 = Dict -_test_Rem_RoundZero_P2_N2 :: Dict (K.Rem 'K.RoundZero (P 2) (N 2) ~ P 0) -_test_Rem_RoundZero_P2_N2 = Dict -_test_Div_RoundZero_P2_N3 :: Dict (K.Div 'K.RoundZero (P 2) (N 3) ~ P 0) -_test_Div_RoundZero_P2_N3 = Dict -_test_Rem_RoundZero_P2_N3 :: Dict (K.Rem 'K.RoundZero (P 2) (N 3) ~ P 2) -_test_Rem_RoundZero_P2_N3 = Dict -_test_Div_RoundZero_P2_N4 :: Dict (K.Div 'K.RoundZero (P 2) (N 4) ~ P 0) -_test_Div_RoundZero_P2_N4 = Dict -_test_Rem_RoundZero_P2_N4 :: Dict (K.Rem 'K.RoundZero (P 2) (N 4) ~ P 2) -_test_Rem_RoundZero_P2_N4 = Dict -_test_Div_RoundZero_P2_P1 :: Dict (K.Div 'K.RoundZero (P 2) (P 1) ~ P 2) -_test_Div_RoundZero_P2_P1 = Dict -_test_Rem_RoundZero_P2_P1 :: Dict (K.Rem 'K.RoundZero (P 2) (P 1) ~ P 0) -_test_Rem_RoundZero_P2_P1 = Dict -_test_Div_RoundZero_P2_P2 :: Dict (K.Div 'K.RoundZero (P 2) (P 2) ~ P 1) -_test_Div_RoundZero_P2_P2 = Dict -_test_Rem_RoundZero_P2_P2 :: Dict (K.Rem 'K.RoundZero (P 2) (P 2) ~ P 0) -_test_Rem_RoundZero_P2_P2 = Dict -_test_Div_RoundZero_P2_P3 :: Dict (K.Div 'K.RoundZero (P 2) (P 3) ~ P 0) -_test_Div_RoundZero_P2_P3 = Dict -_test_Rem_RoundZero_P2_P3 :: Dict (K.Rem 'K.RoundZero (P 2) (P 3) ~ P 2) -_test_Rem_RoundZero_P2_P3 = Dict -_test_Div_RoundZero_P2_P4 :: Dict (K.Div 'K.RoundZero (P 2) (P 4) ~ P 0) -_test_Div_RoundZero_P2_P4 = Dict -_test_Rem_RoundZero_P2_P4 :: Dict (K.Rem 'K.RoundZero (P 2) (P 4) ~ P 2) -_test_Rem_RoundZero_P2_P4 = Dict -_test_Div_RoundZero_P3_N1 :: Dict (K.Div 'K.RoundZero (P 3) (N 1) ~ N 3) -_test_Div_RoundZero_P3_N1 = Dict -_test_Rem_RoundZero_P3_N1 :: Dict (K.Rem 'K.RoundZero (P 3) (N 1) ~ P 0) -_test_Rem_RoundZero_P3_N1 = Dict -_test_Div_RoundZero_P3_N2 :: Dict (K.Div 'K.RoundZero (P 3) (N 2) ~ N 1) -_test_Div_RoundZero_P3_N2 = Dict -_test_Rem_RoundZero_P3_N2 :: Dict (K.Rem 'K.RoundZero (P 3) (N 2) ~ P 1) -_test_Rem_RoundZero_P3_N2 = Dict -_test_Div_RoundZero_P3_N3 :: Dict (K.Div 'K.RoundZero (P 3) (N 3) ~ N 1) -_test_Div_RoundZero_P3_N3 = Dict -_test_Rem_RoundZero_P3_N3 :: Dict (K.Rem 'K.RoundZero (P 3) (N 3) ~ P 0) -_test_Rem_RoundZero_P3_N3 = Dict -_test_Div_RoundZero_P3_N4 :: Dict (K.Div 'K.RoundZero (P 3) (N 4) ~ P 0) -_test_Div_RoundZero_P3_N4 = Dict -_test_Rem_RoundZero_P3_N4 :: Dict (K.Rem 'K.RoundZero (P 3) (N 4) ~ P 3) -_test_Rem_RoundZero_P3_N4 = Dict -_test_Div_RoundZero_P3_P1 :: Dict (K.Div 'K.RoundZero (P 3) (P 1) ~ P 3) -_test_Div_RoundZero_P3_P1 = Dict -_test_Rem_RoundZero_P3_P1 :: Dict (K.Rem 'K.RoundZero (P 3) (P 1) ~ P 0) -_test_Rem_RoundZero_P3_P1 = Dict -_test_Div_RoundZero_P3_P2 :: Dict (K.Div 'K.RoundZero (P 3) (P 2) ~ P 1) -_test_Div_RoundZero_P3_P2 = Dict -_test_Rem_RoundZero_P3_P2 :: Dict (K.Rem 'K.RoundZero (P 3) (P 2) ~ P 1) -_test_Rem_RoundZero_P3_P2 = Dict -_test_Div_RoundZero_P3_P3 :: Dict (K.Div 'K.RoundZero (P 3) (P 3) ~ P 1) -_test_Div_RoundZero_P3_P3 = Dict -_test_Rem_RoundZero_P3_P3 :: Dict (K.Rem 'K.RoundZero (P 3) (P 3) ~ P 0) -_test_Rem_RoundZero_P3_P3 = Dict -_test_Div_RoundZero_P3_P4 :: Dict (K.Div 'K.RoundZero (P 3) (P 4) ~ P 0) -_test_Div_RoundZero_P3_P4 = Dict -_test_Rem_RoundZero_P3_P4 :: Dict (K.Rem 'K.RoundZero (P 3) (P 4) ~ P 3) -_test_Rem_RoundZero_P3_P4 = Dict -_test_Div_RoundZero_P4_N1 :: Dict (K.Div 'K.RoundZero (P 4) (N 1) ~ N 4) -_test_Div_RoundZero_P4_N1 = Dict -_test_Rem_RoundZero_P4_N1 :: Dict (K.Rem 'K.RoundZero (P 4) (N 1) ~ P 0) -_test_Rem_RoundZero_P4_N1 = Dict -_test_Div_RoundZero_P4_N2 :: Dict (K.Div 'K.RoundZero (P 4) (N 2) ~ N 2) -_test_Div_RoundZero_P4_N2 = Dict -_test_Rem_RoundZero_P4_N2 :: Dict (K.Rem 'K.RoundZero (P 4) (N 2) ~ P 0) -_test_Rem_RoundZero_P4_N2 = Dict -_test_Div_RoundZero_P4_N3 :: Dict (K.Div 'K.RoundZero (P 4) (N 3) ~ N 1) -_test_Div_RoundZero_P4_N3 = Dict -_test_Rem_RoundZero_P4_N3 :: Dict (K.Rem 'K.RoundZero (P 4) (N 3) ~ P 1) -_test_Rem_RoundZero_P4_N3 = Dict -_test_Div_RoundZero_P4_N4 :: Dict (K.Div 'K.RoundZero (P 4) (N 4) ~ N 1) -_test_Div_RoundZero_P4_N4 = Dict -_test_Rem_RoundZero_P4_N4 :: Dict (K.Rem 'K.RoundZero (P 4) (N 4) ~ P 0) -_test_Rem_RoundZero_P4_N4 = Dict -_test_Div_RoundZero_P4_P1 :: Dict (K.Div 'K.RoundZero (P 4) (P 1) ~ P 4) -_test_Div_RoundZero_P4_P1 = Dict -_test_Rem_RoundZero_P4_P1 :: Dict (K.Rem 'K.RoundZero (P 4) (P 1) ~ P 0) -_test_Rem_RoundZero_P4_P1 = Dict -_test_Div_RoundZero_P4_P2 :: Dict (K.Div 'K.RoundZero (P 4) (P 2) ~ P 2) -_test_Div_RoundZero_P4_P2 = Dict -_test_Rem_RoundZero_P4_P2 :: Dict (K.Rem 'K.RoundZero (P 4) (P 2) ~ P 0) -_test_Rem_RoundZero_P4_P2 = Dict -_test_Div_RoundZero_P4_P3 :: Dict (K.Div 'K.RoundZero (P 4) (P 3) ~ P 1) -_test_Div_RoundZero_P4_P3 = Dict -_test_Rem_RoundZero_P4_P3 :: Dict (K.Rem 'K.RoundZero (P 4) (P 3) ~ P 1) -_test_Rem_RoundZero_P4_P3 = Dict -_test_Div_RoundZero_P4_P4 :: Dict (K.Div 'K.RoundZero (P 4) (P 4) ~ P 1) -_test_Div_RoundZero_P4_P4 = Dict -_test_Rem_RoundZero_P4_P4 :: Dict (K.Rem 'K.RoundZero (P 4) (P 4) ~ P 0) -_test_Rem_RoundZero_P4_P4 = Dict +import Data.Singletons +import Data.String +import GHC.Exts (Constraint) +import GHC.TypeLits qualified as L +import Prelude hiding (Integer) +import Prelude qualified as P +import Prelude.Singletons qualified as P +import System.Exit +import Text.Read +import Text.ParserCombinators.ReadP qualified as ReadP +import Text.ParserCombinators.ReadPrec qualified as ReadPrec +import Text.Show.Singletons + +import KindInteger (P, N, Z, pattern SP, pattern SN, pattern SZ, + SInteger, pattern SInteger) +import KindInteger qualified as K + +-------------------------------------------------------------------------------- + +data Dict (c :: Constraint) where + Dict :: c => Dict c + +readPrecMaybe :: ReadPrec a -> String -> Maybe a +readPrecMaybe p s = + case readPrec_to_S (p <* ReadPrec.lift ReadP.skipSpaces) 0 s of + [(x, "")] -> Just x + _ -> Nothing + +-------------------------------------------------------------------------------- + +_testShow = Dict +_testShow :: Dict + ( P.Show_ Z ~ "0" + , P.Show_ (P 1) ~ "1" + , P.Show_ (N 2) ~ "-2" + , P.ShowsPrec AppPrec (N 2) "x" ~ "-2x" + , P.ShowsPrec AppPrec1 (N 2) "x" ~ "(-2)x" + , P.ShowsPrec AppPrec1 (P 2) "x" ~ "2x" + ) + +_testShowLit = Dict +_testShowLit :: Dict + ( K.ShowLit Z ~ "Z" + , K.ShowLit (P 1) ~ "P 1" + , K.ShowLit (N 2) ~ "N 2" + , K.ShowsPrecLit AppPrec (N 2) "x" ~ "N 2x" + , K.ShowsPrecLit AppPrec1 (N 2) "x" ~ "(N 2)x" + , K.ShowsPrecLit AppPrec1 (P 2) "x" ~ "(P 2)x" + ) + +_testEq = Dict +_testEq :: Dict + ( 'True ~ (Z P.== Z) + , 'True ~ (Z P.== Z) + , 'True ~ (Z P.== Z) + , 'True ~ (Z P.== Z) + + , 'True ~ (Z P./= P 1) + , 'True ~ (Z P./= N 1) + + , 'True ~ (Z P./= N 1) + , 'True ~ (Z P./= N 1) + + , 'True ~ (P 1 P./= Z) + , 'True ~ (P 1 P./= Z) + + , 'True ~ (N 1 P./= Z) + , 'True ~ (N 1 P./= Z) + ) + +_testCmp = Dict +_testCmp :: Dict + ( Z <= Z + , Z <= Z + , Z <= Z + , Z <= Z + + , N 2 <= N 1 + , N 1 <= Z + , Z <= P 1 + + , Z <= P 1 + , P 1 <= P 2 + ) + +_testAdd = Dict +_testAdd :: Dict + ( Z ~ Z P.+ Z + , Z ~ Z P.+ Z + , Z ~ Z P.+ Z + , Z ~ Z P.+ Z + + , P 1 ~ P 1 P.+ Z + , N 1 ~ N 1 P.+ Z + , P 1 ~ P 1 P.+ Z + , N 1 ~ N 1 P.+ Z + + , P 1 ~ Z P.+ P 1 + , N 1 ~ Z P.+ N 1 + , N 1 ~ Z P.+ N 1 + , P 1 ~ Z P.+ P 1 + + , P 2 ~ P 1 P.+ P 1 + , N 2 ~ N 1 P.+ N 1 + , Z ~ P 1 P.+ N 1 + , Z ~ N 1 P.+ P 1 + ) + +_testMul = Dict +_testMul :: Dict + ( Z ~ Z P.* Z + , Z ~ Z P.* Z + , Z ~ Z P.* Z + , Z ~ Z P.* Z + + , Z ~ P 1 P.* Z + , Z ~ N 1 P.* Z + , Z ~ P 1 P.* Z + , Z ~ N 1 P.* Z + + , Z ~ Z P.* P 1 + , Z ~ Z P.* N 1 + , Z ~ Z P.* N 1 + , Z ~ Z P.* P 1 + + , P 1 ~ P 1 P.* P 1 + , P 1 ~ N 1 P.* N 1 + , N 1 ~ P 1 P.* N 1 + , N 1 ~ N 1 P.* P 1 + + , P 2 ~ P 2 P.* P 1 + , P 2 ~ N 2 P.* N 1 + , N 2 ~ P 2 P.* N 1 + , N 2 ~ N 2 P.* P 1 + + , P 6 ~ P 2 P.* P 3 + , P 6 ~ N 2 P.* N 3 + , N 6 ~ P 2 P.* N 3 + , N 6 ~ N 2 P.* P 3 + ) + +_testLog2 = Dict +_testLog2 :: Dict + ( 0 ~ K.Log2 (P 1) + , 1 ~ K.Log2 (P 2) + , 1 ~ K.Log2 (P 3) + , 2 ~ K.Log2 (P 4) + , 2 ~ K.Log2 (P 5) + , 2 ~ K.Log2 (P 6) + , 2 ~ K.Log2 (P 7) + , 3 ~ K.Log2 (P 8) + , 3 ~ K.Log2 (P 9) + , 3 ~ K.Log2 (P 10) + , 3 ~ K.Log2 (P 11) + , 3 ~ K.Log2 (P 12) + , 3 ~ K.Log2 (P 13) + , 3 ~ K.Log2 (P 14) + , 3 ~ K.Log2 (P 15) + , 4 ~ K.Log2 (P 16) + , 4 ~ K.Log2 (P 17) + , 4 ~ K.Log2 (P 18) + , 4 ~ K.Log2 (P 19) + , 4 ~ K.Log2 (P 20) + , 4 ~ K.Log2 (P 21) + , 4 ~ K.Log2 (P 22) + , 4 ~ K.Log2 (P 23) + , 4 ~ K.Log2 (P 24) + , 4 ~ K.Log2 (P 25) + , 4 ~ K.Log2 (P 26) + , 4 ~ K.Log2 (P 27) + , 4 ~ K.Log2 (P 28) + , 4 ~ K.Log2 (P 29) + , 4 ~ K.Log2 (P 30) + , 4 ~ K.Log2 (P 31) + , 5 ~ K.Log2 (P 32) + ) + +_testNegate = Dict +_testNegate :: Dict + ( Z ~ P.Negate Z + , Z ~ P.Negate Z + , N 1 ~ P.Negate (P 1) + , P 1 ~ P.Negate (N 1) + , N 2 ~ P.Negate (P 2) + , P 2 ~ P.Negate (N 2) + ) + +_testSign = Dict +_testSign :: Dict + ( Z ~ P.Signum Z + , Z ~ P.Signum Z + , P 1 ~ P.Signum (P 1) + , N 1 ~ P.Signum (N 1) + , P 1 ~ P.Signum (P 2) + , N 1 ~ P.Signum (N 2) + ) + +_testAbs = Dict +_testAbs :: Dict + ( 0 ~ K.Abs Z + , 0 ~ K.Abs Z + , 1 ~ K.Abs (P 1) + , 1 ~ K.Abs (N 1) + , 2 ~ K.Abs (P 2) + , 2 ~ K.Abs (N 2) + ) + +_testEven = Dict +_testEven :: Dict + ( 'True ~ K.Even Z + , 'True ~ K.Even Z + , 'False ~ K.Even (P 1) + , 'False ~ K.Even (N 1) + , 'True ~ K.Even (P 2) + , 'True ~ K.Even (N 2) + ) + +_testOdd = Dict +_testOdd :: Dict + ( 'False ~ K.Odd Z + , 'False ~ K.Odd Z + , 'True ~ K.Odd (P 1) + , 'True ~ K.Odd (N 1) + , 'False ~ K.Odd (P 2) + , 'False ~ K.Odd (N 2) + ) + +_testGCD = Dict +_testGCD :: Dict + ( 0 ~ K.GCD Z Z + , 0 ~ K.GCD Z Z + , 0 ~ K.GCD Z Z + , 0 ~ K.GCD Z Z + + , 1 ~ K.GCD (P 1) Z + , 1 ~ K.GCD (P 1) Z + , 1 ~ K.GCD (N 1) Z + , 1 ~ K.GCD (N 1) Z + + , 1 ~ K.GCD Z (P 1) + , 1 ~ K.GCD Z (N 1) + , 1 ~ K.GCD Z (P 1) + , 1 ~ K.GCD Z (N 1) + + , 1 ~ K.GCD (P 1) (P 2) + , 1 ~ K.GCD (P 1) (N 2) + , 1 ~ K.GCD (N 1) (P 2) + , 1 ~ K.GCD (N 1) (N 2) + + , 1 ~ K.GCD (P 2) (P 1) + , 1 ~ K.GCD (P 2) (N 1) + , 1 ~ K.GCD (N 2) (P 1) + , 1 ~ K.GCD (N 2) (N 1) + + , 3 ~ K.GCD (P 6) (P 9) + , 3 ~ K.GCD (P 6) (N 9) + , 3 ~ K.GCD (N 6) (P 9) + , 3 ~ K.GCD (N 6) (N 9) + + , 3 ~ K.GCD (P 9) (P 6) + , 3 ~ K.GCD (P 9) (N 6) + , 3 ~ K.GCD (N 9) (P 6) + , 3 ~ K.GCD (N 9) (N 6) + ) + +_testLCM = Dict +_testLCM :: Dict + ( 0 ~ K.LCM Z Z + , 0 ~ K.LCM Z Z + , 0 ~ K.LCM Z Z + , 0 ~ K.LCM Z Z + + , 0 ~ K.LCM (P 1) Z + , 0 ~ K.LCM (P 1) Z + , 0 ~ K.LCM (N 1) Z + , 0 ~ K.LCM (N 1) Z + + , 0 ~ K.LCM Z (P 1) + , 0 ~ K.LCM Z (N 1) + , 0 ~ K.LCM Z (P 1) + , 0 ~ K.LCM Z (N 1) + + , 2 ~ K.LCM (P 1) (P 2) + , 2 ~ K.LCM (P 1) (N 2) + , 2 ~ K.LCM (N 1) (P 2) + , 2 ~ K.LCM (N 1) (N 2) + + , 2 ~ K.LCM (P 2) (P 1) + , 2 ~ K.LCM (P 2) (N 1) + , 2 ~ K.LCM (N 2) (P 1) + , 2 ~ K.LCM (N 2) (N 1) + + , 18 ~ K.LCM (P 6) (P 9) + , 18 ~ K.LCM (P 6) (N 9) + , 18 ~ K.LCM (N 6) (P 9) + , 18 ~ K.LCM (N 6) (N 9) + + , 18 ~ K.LCM (P 9) (P 6) + , 18 ~ K.LCM (P 9) (N 6) + , 18 ~ K.LCM (N 9) (P 6) + , 18 ~ K.LCM (N 9) (N 6) + ) + +-------------------------------------------------------------------------------- + +assert + :: String -- ^ Test name + -> Bool -- ^ Successful is true + -> IO Bool -- ^ Return the same 'Bool' given as input. +assert n x = do + putStrLn ((if x then "[OK] " else "[FAIL] ") <> n) + pure x + +testsMain :: [IO Bool] -> IO a +testsMain xs = do + res <- sequence xs + let (oks, bads) = List.partition id res + putStrLn ("[TOTAL] OK: " <> show (length oks) <> + ". FAIL: " <> show (length bads) <> ".") + case bads of + [] -> exitSuccess + _ -> exitFailure + +sn1, sz, sp1 :: K.SomeInteger +sn1 = K.SomeInteger (Proxy @(N 1)) +sz = K.SomeInteger (Proxy @Z) +sp1 = K.SomeInteger (Proxy @(P 1)) + + +main :: IO () +main = testsMain $ + [ assert "Prelude % throws RatioZeroDenominator" =<< do + ea <- Ex.try (Ex.evaluate (1 P.% 0 :: P.Rational)) + pure (ea == Left Ex.RatioZeroDenominator) + + , assert "integerVal . someIntegerVal == id" $ + flip all [-5 .. 5] $ \a -> + case K.someIntegerVal a of + K.SomeInteger pa -> + a == K.integerVal pa + + , assert "sameIntegerVal a a" $ + flip all [-5 .. 5] $ \a -> + case K.someIntegerVal a of + K.SomeInteger pa -> + isJust (K.sameInteger pa pa) + + , assert "sameIntegerVal a a'" $ + flip all [-5 .. 5] $ \a -> + case (K.someIntegerVal a, K.someIntegerVal a) of + (K.SomeInteger pa1, K.SomeInteger pa2) -> + isJust (K.sameInteger pa1 pa2) + + , assert "sameIntegerVal a b" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + case (K.someIntegerVal a, K.someIntegerVal b) of + (K.SomeInteger pa, K.SomeInteger pb) + | a == b -> isJust (K.sameInteger pa pb) + | otherwise -> isNothing (K.sameInteger pa pb) + + , assert "demote @Z" $ demote @Z == (0 :: P.Integer) + , assert "demote @(P 1)" $ demote @(P 1) == (1 :: P.Integer) + , assert "demote @(N 1)" $ demote @(N 1) == ((-1) :: P.Integer) + + , assert "Eq SomeInteger" $ + flip all (liftA2 (,) [(-2)..2] [(-2)..2]) $ \(a, b) -> + (==) (K.someIntegerVal a) (K.someIntegerVal b) + == (==) a b + + , assert "Ord SomeInteger" $ + flip all (liftA2 (,) [(-2)..2] [(-2)..2]) $ \(a, b) -> + compare (K.someIntegerVal a) (K.someIntegerVal b) + == compare a b + + , assert "Show SomeInteger" $ + and [ show sn1 == "-1" + , show sz == "0" + , show sp1 == "1" ] + + , assert "Read SomeInteger" $ + and [ readMaybe "-1" == Just sn1 + , readMaybe "0" == Just sz + , readMaybe "1" == Just sp1 ] + + , assert "TestEquality 0 0" $ + isJust (testEquality (SInteger @Z) (SInteger @Z)) + , assert "TestEquality 0 +1" $ + isNothing (testEquality (SInteger @Z) (SInteger @(P 1))) + , assert "TestEquality 0 -1" $ + isNothing (testEquality (SInteger @Z) (SInteger @(N 1))) + , assert "TestEquality +1 0" $ + isNothing (testEquality (SInteger @(P 1)) (SInteger @Z)) + , assert "TestEquality -1 0" $ + isNothing (testEquality (SInteger @(N 1)) (SInteger @Z)) + + , assert "show SInteger 0" $ + "SInteger @Z" == show (SInteger @Z) + , assert "show SInteger +1" $ + "SInteger @(P 1)" == show (SInteger @(P 1)) + , assert "show SInteger -1" $ + "SInteger @(N 1)" == show (SInteger @(N 1)) + + , assert "sShow SInteger 0" $ + fromString "0" == fromSing (P.sShow_ (SInteger @Z)) + , assert "sShow SInteger +1" $ + fromString "1" == fromSing (P.sShow_ (SInteger @(P 1))) + , assert "sShow SInteger -1" $ + fromString "-1" == fromSing (P.sShow_ (SInteger @(N 1))) + + , assert "sShowsPrec appPrec SInteger 0" $ + fromString "0y" == fromSing (P.sShowsPrec sAppPrec (SInteger @Z) (sing @"y")) + , assert "sShowsPrec appPrec SInteger +1" $ + fromString "1y" == fromSing (P.sShowsPrec sAppPrec (SInteger @(P 1)) (sing @"y")) + , assert "sShowPrec appPrec SInteger -1" $ + fromString "-1y" == fromSing (P.sShowsPrec sAppPrec (SInteger @(N 1)) (sing @"y")) + + , assert "sShowsPrec appPrec1 SInteger 0" $ + fromString "0y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @Z) (sing @"y")) + , assert "sShowsPrec appPrec1 SInteger +1" $ + fromString "1y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @(P 1)) (sing @"y")) + , assert "sShowPrec appPrec1 SInteger -1" $ + fromString "-1y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @(N 1)) (sing @"y")) + + , assert "sShowLit SInteger 0" $ + fromString "Z" == fromSing (K.sShowLit (SInteger @Z)) + , assert "sShowLit SInteger +1" $ + fromString "P 1" == fromSing (K.sShowLit (SInteger @(P 1))) + , assert "sShowLit SInteger -1" $ + fromString "N 1" == fromSing (K.sShowLit (SInteger @(N 1))) + + , assert "sShowsPrecLit appPrec SInteger 0" $ + fromString "Zy" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @Z) (sing @"y")) + , assert "sShowsPrecLit appPrec SInteger +1" $ + fromString "P 1y" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @(P 1)) (sing @"y")) + , assert "sShowPrec appPrec SInteger -1" $ + fromString "N 1y" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @(N 1)) (sing @"y")) + + , assert "sShowsPrecLit appPrec1 SInteger 0" $ + fromString "Zy" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @Z) (sing @"y")) + , assert "sShowsPrecLit appPrec1 SInteger +1" $ + fromString "(P 1)y" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @(P 1)) (sing @"y")) + , assert "sShowPrec appPrec1 SInteger -1" $ + fromString "(N 1)y" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @(N 1)) (sing @"y")) + + , assert "readPrecLit Z" $ + readPrecMaybe K.readPrecLit "Z" == Just 0 + , assert "readPrecLit P" $ + readPrecMaybe K.readPrecLit "P 0" == Nothing && + readPrecMaybe K.readPrecLit "P 1" == Just 1 + , assert "readPrecLit N" $ + readPrecMaybe K.readPrecLit "N 0" == Nothing && + readPrecMaybe K.readPrecLit "N 1" == Just (-1) + + , assert "Read SInteger 0" $ + readMaybe @(SInteger Z) "SInteger @Z" == Just (SInteger @Z) + , assert "Read SInteger +1" $ + readMaybe @(SInteger (P 1)) "SInteger @(P 1)" == Just (SInteger @(P 1)) + , assert "Read SInteger -1" $ + readMaybe @(SInteger (N 1)) "SInteger @(N 1)" == Just (SInteger @(N 1)) + + , assert "SZ == SInteger @Z" $ + case SInteger @Z of + SZ -> SZ == SInteger @Z + + , assert "SN (sing @1) == SInteger @(N 1)" $ + case SInteger @(N 1) of + SN s1 -> (fromSing @L.Natural s1 == 1) && + (SN s1 == SInteger @(N 1)) + + , assert "SP (sing @1) == SInteger @(P 1)" $ + case SInteger @(P 1) of + SP s1 -> (fromSing @L.Natural s1 == 1) && + (SP s1 == SInteger @(P 1)) + + , assert "KnownInteger i ==> KnownNat (Abs i)" $ + let fabs :: forall i. SInteger i -> P.Integer + fabs si = K.withKnownInteger si (L.natVal (Proxy @(K.Abs i))) + in and [ 1 == fabs (sing @(N 1)) + , 0 == fabs (sing @Z) + , 1 == fabs (sing @(P 1)) ] + + , assert "sNegate" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + negate a == withSomeSing a (fromSing . P.sNegate) + + , assert "%+" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + a + b == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: P.Integer) $ \sb -> + fromSing $ sa P.%+ sb) + + , assert "%-" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + a - b == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: P.Integer) $ \sb -> + fromSing $ sa P.%- sb) + + , assert "%*" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + a * b == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: P.Integer) $ \sb -> + fromSing $ sa P.%* sb) + + , assert "%^" $ + flip all (liftA2 (,) [-5 .. 5] [0 .. 5])$ \(a, b) -> + a ^ b == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: L.Natural) $ \sb -> + fromSing $ sa K.%^ sb) + + , assert "sOdd" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + odd a == withSomeSing a (fromSing . K.sOdd) + + , assert "sEven" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + even a == withSomeSing a (fromSing . K.sEven) + + , assert "sAbs" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + fromInteger @L.Natural (abs a) + == withSomeSing a (fromSing . K.sAbs) + + , assert "sSignum" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + signum a == withSomeSing a (fromSing . P.sSignum) + + , assert "sGCD" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + fromInteger @L.Natural (gcd a b) + == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: P.Integer) $ \sb -> + fromSing $ K.sGCD sa sb) + + , assert "sLCM" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + fromInteger @L.Natural (lcm a b) + == (withSomeSing (a :: P.Integer) $ \sa -> + withSomeSing (b :: P.Integer) $ \sb -> + fromSing $ K.sLCM sa sb) + + , assert "sSign" $ + flip all [-5 .. 5] $ \(a :: P.Integer) -> + signum a == withSomeSing a (fromSing . P.sSignum) + + , fmap and $ sequence $ do + r :: K.Round <- [minBound .. maxBound] + a :: P.Integer <- [-5 .. 5] + b :: P.Integer <- filter (/= 0) [-5 .. 5] + pure $ assert (mconcat ["sDivRem ", show r, " ", show a, " ", show b]) $ + K.divRem r a b == (withSomeSing r $ \sr -> + withSomeSing a $ \sa -> + withSomeSing b $ \sb -> + let (q, m) = K.sDivRem sr sa sb + in (fromSing q, fromSing m)) + + , fmap and $ sequence $ do + r :: K.Round <- [minBound .. maxBound] + a :: P.Integer <- [-5 .. 5] + b :: P.Integer <- filter (/= 0) [-5 .. 5] + pure $ assert (mconcat ["sDiv ", show r, " ", show a, " ", show b]) $ + K.div r a b == (withSomeSing r $ \sr -> + withSomeSing a $ \sa -> + withSomeSing b $ \sb -> + fromSing (K.sDiv sr sa sb)) + + , fmap and $ sequence $ do + r :: K.Round <- [minBound .. maxBound] + a :: P.Integer <- [-5 .. 5] + b :: P.Integer <- filter (/= 0) [-5 .. 5] + pure $ assert (mconcat ["sRem ", show r, " ", show a, " ", show b]) $ + K.rem r a b == (withSomeSing r $ \sr -> + withSomeSing a $ \sa -> + withSomeSing b $ \sb -> + fromSing (K.sRem sr sa sb)) + + , fmap and $ sequence $ do + n :: L.Natural <- [0..5] + pure $ assert (mconcat ["sFromNatural ", show n]) $ + toInteger n == withSomeSing n (fromSing . K.sFromNatural) + + ] <> testsDivRem + + + +testsDivRem :: [IO Bool] +testsDivRem = do + b :: P.Integer <- [-5 .. 5] + guard (b P./= 0) + a :: P.Integer <- [-5 .. 5] + r :: K.Round <- [minBound .. maxBound] + let tname :: String -> ShowS + tname t = showString t . showChar ' ' . shows r . showChar ' ' + . shows a . showChar ' ' . shows b + [ assert (tname "divRem" "") $ case K.divRem r a b of + (q, m) -> m == a - b * q + , assert (tname "div" "") $ fst (K.divRem r a b) == K.div r a b + , assert (tname "rem" "") $ snd (K.divRem r a b) == K.rem r a b + ] + + +-------------------------------------------------------------------------------- + +-- _divRemTestCode :: String +-- _divRemTestCode = unlines $ List.sort $ do +-- b <- [-4 .. 4] +-- guard (b P./= 0) +-- a <- [-4 .. 4] +-- r <- [minBound..maxBound] +-- let (q, m) = K.divRem r a b +-- sname :: String -> ShowS +-- sname t = showString "_test_" +-- . showString t +-- . showChar '_' +-- . showsPrec 0 r +-- . showChar '_' +-- . showChar (if a < 0 then 'N' else 'P') +-- . shows (abs a) +-- . showChar '_' +-- . showChar (if b < 0 then 'N' else 'P') +-- . shows (abs b) +-- sDiv :: ShowS +-- sDiv = sname "Div" +-- . showString " :: Dict (K.Div 'K." +-- . shows r +-- . showChar ' ' +-- . showsPrec appPrec1 (K.fromPrelude a) +-- . showChar ' ' +-- . showsPrec appPrec1 (K.fromPrelude b) +-- . showString " ~ " +-- . showsPrec appPrec (K.fromPrelude q) +-- . showString ")\n" +-- . sname "Div" +-- . showString " = Dict" +-- sRem :: ShowS +-- sRem = sname "Rem" +-- . showString " :: Dict (K.Rem 'K." +-- . shows r +-- . showChar ' ' +-- . showsPrec appPrec1 (K.fromPrelude a) +-- . showChar ' ' +-- . showsPrec appPrec1 (K.fromPrelude b) +-- . showString " ~ " +-- . showsPrec appPrec (K.fromPrelude m) +-- . showString ")\n" +-- . sname "Rem" +-- . showString " = Dict" +-- ss :: ShowS +-- ss = sDiv . showChar '\n' . sRem +-- pure (ss "") + + +-- The following tests are generated by `_divRemTestCode` in this remule. +-- Copy and paste by hand. +_test_Div_RoundAway_N1_N1 :: Dict (K.Div 'K.RoundAway (N 1) (N 1) ~ P 1) +_test_Div_RoundAway_N1_N1 = Dict +_test_Rem_RoundAway_N1_N1 :: Dict (K.Rem 'K.RoundAway (N 1) (N 1) ~ Z) +_test_Rem_RoundAway_N1_N1 = Dict +_test_Div_RoundAway_N1_N2 :: Dict (K.Div 'K.RoundAway (N 1) (N 2) ~ P 1) +_test_Div_RoundAway_N1_N2 = Dict +_test_Rem_RoundAway_N1_N2 :: Dict (K.Rem 'K.RoundAway (N 1) (N 2) ~ P 1) +_test_Rem_RoundAway_N1_N2 = Dict +_test_Div_RoundAway_N1_N3 :: Dict (K.Div 'K.RoundAway (N 1) (N 3) ~ P 1) +_test_Div_RoundAway_N1_N3 = Dict +_test_Rem_RoundAway_N1_N3 :: Dict (K.Rem 'K.RoundAway (N 1) (N 3) ~ P 2) +_test_Rem_RoundAway_N1_N3 = Dict +_test_Div_RoundAway_N1_N4 :: Dict (K.Div 'K.RoundAway (N 1) (N 4) ~ P 1) +_test_Div_RoundAway_N1_N4 = Dict +_test_Rem_RoundAway_N1_N4 :: Dict (K.Rem 'K.RoundAway (N 1) (N 4) ~ P 3) +_test_Rem_RoundAway_N1_N4 = Dict +_test_Div_RoundAway_N1_P1 :: Dict (K.Div 'K.RoundAway (N 1) (P 1) ~ N 1) +_test_Div_RoundAway_N1_P1 = Dict +_test_Rem_RoundAway_N1_P1 :: Dict (K.Rem 'K.RoundAway (N 1) (P 1) ~ Z) +_test_Rem_RoundAway_N1_P1 = Dict +_test_Div_RoundAway_N1_P2 :: Dict (K.Div 'K.RoundAway (N 1) (P 2) ~ N 1) +_test_Div_RoundAway_N1_P2 = Dict +_test_Rem_RoundAway_N1_P2 :: Dict (K.Rem 'K.RoundAway (N 1) (P 2) ~ P 1) +_test_Rem_RoundAway_N1_P2 = Dict +_test_Div_RoundAway_N1_P3 :: Dict (K.Div 'K.RoundAway (N 1) (P 3) ~ N 1) +_test_Div_RoundAway_N1_P3 = Dict +_test_Rem_RoundAway_N1_P3 :: Dict (K.Rem 'K.RoundAway (N 1) (P 3) ~ P 2) +_test_Rem_RoundAway_N1_P3 = Dict +_test_Div_RoundAway_N1_P4 :: Dict (K.Div 'K.RoundAway (N 1) (P 4) ~ N 1) +_test_Div_RoundAway_N1_P4 = Dict +_test_Rem_RoundAway_N1_P4 :: Dict (K.Rem 'K.RoundAway (N 1) (P 4) ~ P 3) +_test_Rem_RoundAway_N1_P4 = Dict +_test_Div_RoundAway_N2_N1 :: Dict (K.Div 'K.RoundAway (N 2) (N 1) ~ P 2) +_test_Div_RoundAway_N2_N1 = Dict +_test_Rem_RoundAway_N2_N1 :: Dict (K.Rem 'K.RoundAway (N 2) (N 1) ~ Z) +_test_Rem_RoundAway_N2_N1 = Dict +_test_Div_RoundAway_N2_N2 :: Dict (K.Div 'K.RoundAway (N 2) (N 2) ~ P 1) +_test_Div_RoundAway_N2_N2 = Dict +_test_Rem_RoundAway_N2_N2 :: Dict (K.Rem 'K.RoundAway (N 2) (N 2) ~ Z) +_test_Rem_RoundAway_N2_N2 = Dict +_test_Div_RoundAway_N2_N3 :: Dict (K.Div 'K.RoundAway (N 2) (N 3) ~ P 1) +_test_Div_RoundAway_N2_N3 = Dict +_test_Rem_RoundAway_N2_N3 :: Dict (K.Rem 'K.RoundAway (N 2) (N 3) ~ P 1) +_test_Rem_RoundAway_N2_N3 = Dict +_test_Div_RoundAway_N2_N4 :: Dict (K.Div 'K.RoundAway (N 2) (N 4) ~ P 1) +_test_Div_RoundAway_N2_N4 = Dict +_test_Rem_RoundAway_N2_N4 :: Dict (K.Rem 'K.RoundAway (N 2) (N 4) ~ P 2) +_test_Rem_RoundAway_N2_N4 = Dict +_test_Div_RoundAway_N2_P1 :: Dict (K.Div 'K.RoundAway (N 2) (P 1) ~ N 2) +_test_Div_RoundAway_N2_P1 = Dict +_test_Rem_RoundAway_N2_P1 :: Dict (K.Rem 'K.RoundAway (N 2) (P 1) ~ Z) +_test_Rem_RoundAway_N2_P1 = Dict +_test_Div_RoundAway_N2_P2 :: Dict (K.Div 'K.RoundAway (N 2) (P 2) ~ N 1) +_test_Div_RoundAway_N2_P2 = Dict +_test_Rem_RoundAway_N2_P2 :: Dict (K.Rem 'K.RoundAway (N 2) (P 2) ~ Z) +_test_Rem_RoundAway_N2_P2 = Dict +_test_Div_RoundAway_N2_P3 :: Dict (K.Div 'K.RoundAway (N 2) (P 3) ~ N 1) +_test_Div_RoundAway_N2_P3 = Dict +_test_Rem_RoundAway_N2_P3 :: Dict (K.Rem 'K.RoundAway (N 2) (P 3) ~ P 1) +_test_Rem_RoundAway_N2_P3 = Dict +_test_Div_RoundAway_N2_P4 :: Dict (K.Div 'K.RoundAway (N 2) (P 4) ~ N 1) +_test_Div_RoundAway_N2_P4 = Dict +_test_Rem_RoundAway_N2_P4 :: Dict (K.Rem 'K.RoundAway (N 2) (P 4) ~ P 2) +_test_Rem_RoundAway_N2_P4 = Dict +_test_Div_RoundAway_N3_N1 :: Dict (K.Div 'K.RoundAway (N 3) (N 1) ~ P 3) +_test_Div_RoundAway_N3_N1 = Dict +_test_Rem_RoundAway_N3_N1 :: Dict (K.Rem 'K.RoundAway (N 3) (N 1) ~ Z) +_test_Rem_RoundAway_N3_N1 = Dict +_test_Div_RoundAway_N3_N2 :: Dict (K.Div 'K.RoundAway (N 3) (N 2) ~ P 2) +_test_Div_RoundAway_N3_N2 = Dict +_test_Rem_RoundAway_N3_N2 :: Dict (K.Rem 'K.RoundAway (N 3) (N 2) ~ P 1) +_test_Rem_RoundAway_N3_N2 = Dict +_test_Div_RoundAway_N3_N3 :: Dict (K.Div 'K.RoundAway (N 3) (N 3) ~ P 1) +_test_Div_RoundAway_N3_N3 = Dict +_test_Rem_RoundAway_N3_N3 :: Dict (K.Rem 'K.RoundAway (N 3) (N 3) ~ Z) +_test_Rem_RoundAway_N3_N3 = Dict +_test_Div_RoundAway_N3_N4 :: Dict (K.Div 'K.RoundAway (N 3) (N 4) ~ P 1) +_test_Div_RoundAway_N3_N4 = Dict +_test_Rem_RoundAway_N3_N4 :: Dict (K.Rem 'K.RoundAway (N 3) (N 4) ~ P 1) +_test_Rem_RoundAway_N3_N4 = Dict +_test_Div_RoundAway_N3_P1 :: Dict (K.Div 'K.RoundAway (N 3) (P 1) ~ N 3) +_test_Div_RoundAway_N3_P1 = Dict +_test_Rem_RoundAway_N3_P1 :: Dict (K.Rem 'K.RoundAway (N 3) (P 1) ~ Z) +_test_Rem_RoundAway_N3_P1 = Dict +_test_Div_RoundAway_N3_P2 :: Dict (K.Div 'K.RoundAway (N 3) (P 2) ~ N 2) +_test_Div_RoundAway_N3_P2 = Dict +_test_Rem_RoundAway_N3_P2 :: Dict (K.Rem 'K.RoundAway (N 3) (P 2) ~ P 1) +_test_Rem_RoundAway_N3_P2 = Dict +_test_Div_RoundAway_N3_P3 :: Dict (K.Div 'K.RoundAway (N 3) (P 3) ~ N 1) +_test_Div_RoundAway_N3_P3 = Dict +_test_Rem_RoundAway_N3_P3 :: Dict (K.Rem 'K.RoundAway (N 3) (P 3) ~ Z) +_test_Rem_RoundAway_N3_P3 = Dict +_test_Div_RoundAway_N3_P4 :: Dict (K.Div 'K.RoundAway (N 3) (P 4) ~ N 1) +_test_Div_RoundAway_N3_P4 = Dict +_test_Rem_RoundAway_N3_P4 :: Dict (K.Rem 'K.RoundAway (N 3) (P 4) ~ P 1) +_test_Rem_RoundAway_N3_P4 = Dict +_test_Div_RoundAway_N4_N1 :: Dict (K.Div 'K.RoundAway (N 4) (N 1) ~ P 4) +_test_Div_RoundAway_N4_N1 = Dict +_test_Rem_RoundAway_N4_N1 :: Dict (K.Rem 'K.RoundAway (N 4) (N 1) ~ Z) +_test_Rem_RoundAway_N4_N1 = Dict +_test_Div_RoundAway_N4_N2 :: Dict (K.Div 'K.RoundAway (N 4) (N 2) ~ P 2) +_test_Div_RoundAway_N4_N2 = Dict +_test_Rem_RoundAway_N4_N2 :: Dict (K.Rem 'K.RoundAway (N 4) (N 2) ~ Z) +_test_Rem_RoundAway_N4_N2 = Dict +_test_Div_RoundAway_N4_N3 :: Dict (K.Div 'K.RoundAway (N 4) (N 3) ~ P 2) +_test_Div_RoundAway_N4_N3 = Dict +_test_Rem_RoundAway_N4_N3 :: Dict (K.Rem 'K.RoundAway (N 4) (N 3) ~ P 2) +_test_Rem_RoundAway_N4_N3 = Dict +_test_Div_RoundAway_N4_N4 :: Dict (K.Div 'K.RoundAway (N 4) (N 4) ~ P 1) +_test_Div_RoundAway_N4_N4 = Dict +_test_Rem_RoundAway_N4_N4 :: Dict (K.Rem 'K.RoundAway (N 4) (N 4) ~ Z) +_test_Rem_RoundAway_N4_N4 = Dict +_test_Div_RoundAway_N4_P1 :: Dict (K.Div 'K.RoundAway (N 4) (P 1) ~ N 4) +_test_Div_RoundAway_N4_P1 = Dict +_test_Rem_RoundAway_N4_P1 :: Dict (K.Rem 'K.RoundAway (N 4) (P 1) ~ Z) +_test_Rem_RoundAway_N4_P1 = Dict +_test_Div_RoundAway_N4_P2 :: Dict (K.Div 'K.RoundAway (N 4) (P 2) ~ N 2) +_test_Div_RoundAway_N4_P2 = Dict +_test_Rem_RoundAway_N4_P2 :: Dict (K.Rem 'K.RoundAway (N 4) (P 2) ~ Z) +_test_Rem_RoundAway_N4_P2 = Dict +_test_Div_RoundAway_N4_P3 :: Dict (K.Div 'K.RoundAway (N 4) (P 3) ~ N 2) +_test_Div_RoundAway_N4_P3 = Dict +_test_Rem_RoundAway_N4_P3 :: Dict (K.Rem 'K.RoundAway (N 4) (P 3) ~ P 2) +_test_Rem_RoundAway_N4_P3 = Dict +_test_Div_RoundAway_N4_P4 :: Dict (K.Div 'K.RoundAway (N 4) (P 4) ~ N 1) +_test_Div_RoundAway_N4_P4 = Dict +_test_Rem_RoundAway_N4_P4 :: Dict (K.Rem 'K.RoundAway (N 4) (P 4) ~ Z) +_test_Rem_RoundAway_N4_P4 = Dict +_test_Rem_RoundAway_Z_N1 :: Dict (K.Rem 'K.RoundAway Z (N 1) ~ Z) +_test_Rem_RoundAway_Z_N1 = Dict +_test_Rem_RoundAway_Z_N2 :: Dict (K.Rem 'K.RoundAway Z (N 2) ~ Z) +_test_Rem_RoundAway_Z_N2 = Dict +_test_Rem_RoundAway_Z_N3 :: Dict (K.Rem 'K.RoundAway Z (N 3) ~ Z) +_test_Rem_RoundAway_Z_N3 = Dict +_test_Rem_RoundAway_Z_N4 :: Dict (K.Rem 'K.RoundAway Z (N 4) ~ Z) +_test_Rem_RoundAway_Z_N4 = Dict +_test_Rem_RoundAway_Z_P1 :: Dict (K.Rem 'K.RoundAway Z (P 1) ~ Z) +_test_Rem_RoundAway_Z_P1 = Dict +_test_Rem_RoundAway_Z_P2 :: Dict (K.Rem 'K.RoundAway Z (P 2) ~ Z) +_test_Rem_RoundAway_Z_P2 = Dict +_test_Rem_RoundAway_Z_P3 :: Dict (K.Rem 'K.RoundAway Z (P 3) ~ Z) +_test_Rem_RoundAway_Z_P3 = Dict +_test_Rem_RoundAway_Z_P4 :: Dict (K.Rem 'K.RoundAway Z (P 4) ~ Z) +_test_Rem_RoundAway_Z_P4 = Dict +_test_Div_RoundAway_P1_N1 :: Dict (K.Div 'K.RoundAway (P 1) (N 1) ~ N 1) +_test_Div_RoundAway_P1_N1 = Dict +_test_Rem_RoundAway_P1_N1 :: Dict (K.Rem 'K.RoundAway (P 1) (N 1) ~ Z) +_test_Rem_RoundAway_P1_N1 = Dict +_test_Div_RoundAway_P1_N2 :: Dict (K.Div 'K.RoundAway (P 1) (N 2) ~ N 1) +_test_Div_RoundAway_P1_N2 = Dict +_test_Rem_RoundAway_P1_N2 :: Dict (K.Rem 'K.RoundAway (P 1) (N 2) ~ N 1) +_test_Rem_RoundAway_P1_N2 = Dict +_test_Div_RoundAway_P1_N3 :: Dict (K.Div 'K.RoundAway (P 1) (N 3) ~ N 1) +_test_Div_RoundAway_P1_N3 = Dict +_test_Rem_RoundAway_P1_N3 :: Dict (K.Rem 'K.RoundAway (P 1) (N 3) ~ N 2) +_test_Rem_RoundAway_P1_N3 = Dict +_test_Div_RoundAway_P1_N4 :: Dict (K.Div 'K.RoundAway (P 1) (N 4) ~ N 1) +_test_Div_RoundAway_P1_N4 = Dict +_test_Rem_RoundAway_P1_N4 :: Dict (K.Rem 'K.RoundAway (P 1) (N 4) ~ N 3) +_test_Rem_RoundAway_P1_N4 = Dict +_test_Div_RoundAway_P1_P1 :: Dict (K.Div 'K.RoundAway (P 1) (P 1) ~ P 1) +_test_Div_RoundAway_P1_P1 = Dict +_test_Rem_RoundAway_P1_P1 :: Dict (K.Rem 'K.RoundAway (P 1) (P 1) ~ Z) +_test_Rem_RoundAway_P1_P1 = Dict +_test_Div_RoundAway_P1_P2 :: Dict (K.Div 'K.RoundAway (P 1) (P 2) ~ P 1) +_test_Div_RoundAway_P1_P2 = Dict +_test_Rem_RoundAway_P1_P2 :: Dict (K.Rem 'K.RoundAway (P 1) (P 2) ~ N 1) +_test_Rem_RoundAway_P1_P2 = Dict +_test_Div_RoundAway_P1_P3 :: Dict (K.Div 'K.RoundAway (P 1) (P 3) ~ P 1) +_test_Div_RoundAway_P1_P3 = Dict +_test_Rem_RoundAway_P1_P3 :: Dict (K.Rem 'K.RoundAway (P 1) (P 3) ~ N 2) +_test_Rem_RoundAway_P1_P3 = Dict +_test_Div_RoundAway_P1_P4 :: Dict (K.Div 'K.RoundAway (P 1) (P 4) ~ P 1) +_test_Div_RoundAway_P1_P4 = Dict +_test_Rem_RoundAway_P1_P4 :: Dict (K.Rem 'K.RoundAway (P 1) (P 4) ~ N 3) +_test_Rem_RoundAway_P1_P4 = Dict +_test_Div_RoundAway_P2_N1 :: Dict (K.Div 'K.RoundAway (P 2) (N 1) ~ N 2) +_test_Div_RoundAway_P2_N1 = Dict +_test_Rem_RoundAway_P2_N1 :: Dict (K.Rem 'K.RoundAway (P 2) (N 1) ~ Z) +_test_Rem_RoundAway_P2_N1 = Dict +_test_Div_RoundAway_P2_N2 :: Dict (K.Div 'K.RoundAway (P 2) (N 2) ~ N 1) +_test_Div_RoundAway_P2_N2 = Dict +_test_Rem_RoundAway_P2_N2 :: Dict (K.Rem 'K.RoundAway (P 2) (N 2) ~ Z) +_test_Rem_RoundAway_P2_N2 = Dict +_test_Div_RoundAway_P2_N3 :: Dict (K.Div 'K.RoundAway (P 2) (N 3) ~ N 1) +_test_Div_RoundAway_P2_N3 = Dict +_test_Rem_RoundAway_P2_N3 :: Dict (K.Rem 'K.RoundAway (P 2) (N 3) ~ N 1) +_test_Rem_RoundAway_P2_N3 = Dict +_test_Div_RoundAway_P2_N4 :: Dict (K.Div 'K.RoundAway (P 2) (N 4) ~ N 1) +_test_Div_RoundAway_P2_N4 = Dict +_test_Rem_RoundAway_P2_N4 :: Dict (K.Rem 'K.RoundAway (P 2) (N 4) ~ N 2) +_test_Rem_RoundAway_P2_N4 = Dict +_test_Div_RoundAway_P2_P1 :: Dict (K.Div 'K.RoundAway (P 2) (P 1) ~ P 2) +_test_Div_RoundAway_P2_P1 = Dict +_test_Rem_RoundAway_P2_P1 :: Dict (K.Rem 'K.RoundAway (P 2) (P 1) ~ Z) +_test_Rem_RoundAway_P2_P1 = Dict +_test_Div_RoundAway_P2_P2 :: Dict (K.Div 'K.RoundAway (P 2) (P 2) ~ P 1) +_test_Div_RoundAway_P2_P2 = Dict +_test_Rem_RoundAway_P2_P2 :: Dict (K.Rem 'K.RoundAway (P 2) (P 2) ~ Z) +_test_Rem_RoundAway_P2_P2 = Dict +_test_Div_RoundAway_P2_P3 :: Dict (K.Div 'K.RoundAway (P 2) (P 3) ~ P 1) +_test_Div_RoundAway_P2_P3 = Dict +_test_Rem_RoundAway_P2_P3 :: Dict (K.Rem 'K.RoundAway (P 2) (P 3) ~ N 1) +_test_Rem_RoundAway_P2_P3 = Dict +_test_Div_RoundAway_P2_P4 :: Dict (K.Div 'K.RoundAway (P 2) (P 4) ~ P 1) +_test_Div_RoundAway_P2_P4 = Dict +_test_Rem_RoundAway_P2_P4 :: Dict (K.Rem 'K.RoundAway (P 2) (P 4) ~ N 2) +_test_Rem_RoundAway_P2_P4 = Dict +_test_Div_RoundAway_P3_N1 :: Dict (K.Div 'K.RoundAway (P 3) (N 1) ~ N 3) +_test_Div_RoundAway_P3_N1 = Dict +_test_Rem_RoundAway_P3_N1 :: Dict (K.Rem 'K.RoundAway (P 3) (N 1) ~ Z) +_test_Rem_RoundAway_P3_N1 = Dict +_test_Div_RoundAway_P3_N2 :: Dict (K.Div 'K.RoundAway (P 3) (N 2) ~ N 2) +_test_Div_RoundAway_P3_N2 = Dict +_test_Rem_RoundAway_P3_N2 :: Dict (K.Rem 'K.RoundAway (P 3) (N 2) ~ N 1) +_test_Rem_RoundAway_P3_N2 = Dict +_test_Div_RoundAway_P3_N3 :: Dict (K.Div 'K.RoundAway (P 3) (N 3) ~ N 1) +_test_Div_RoundAway_P3_N3 = Dict +_test_Rem_RoundAway_P3_N3 :: Dict (K.Rem 'K.RoundAway (P 3) (N 3) ~ Z) +_test_Rem_RoundAway_P3_N3 = Dict +_test_Div_RoundAway_P3_N4 :: Dict (K.Div 'K.RoundAway (P 3) (N 4) ~ N 1) +_test_Div_RoundAway_P3_N4 = Dict +_test_Rem_RoundAway_P3_N4 :: Dict (K.Rem 'K.RoundAway (P 3) (N 4) ~ N 1) +_test_Rem_RoundAway_P3_N4 = Dict +_test_Div_RoundAway_P3_P1 :: Dict (K.Div 'K.RoundAway (P 3) (P 1) ~ P 3) +_test_Div_RoundAway_P3_P1 = Dict +_test_Rem_RoundAway_P3_P1 :: Dict (K.Rem 'K.RoundAway (P 3) (P 1) ~ Z) +_test_Rem_RoundAway_P3_P1 = Dict +_test_Div_RoundAway_P3_P2 :: Dict (K.Div 'K.RoundAway (P 3) (P 2) ~ P 2) +_test_Div_RoundAway_P3_P2 = Dict +_test_Rem_RoundAway_P3_P2 :: Dict (K.Rem 'K.RoundAway (P 3) (P 2) ~ N 1) +_test_Rem_RoundAway_P3_P2 = Dict +_test_Div_RoundAway_P3_P3 :: Dict (K.Div 'K.RoundAway (P 3) (P 3) ~ P 1) +_test_Div_RoundAway_P3_P3 = Dict +_test_Rem_RoundAway_P3_P3 :: Dict (K.Rem 'K.RoundAway (P 3) (P 3) ~ Z) +_test_Rem_RoundAway_P3_P3 = Dict +_test_Div_RoundAway_P3_P4 :: Dict (K.Div 'K.RoundAway (P 3) (P 4) ~ P 1) +_test_Div_RoundAway_P3_P4 = Dict +_test_Rem_RoundAway_P3_P4 :: Dict (K.Rem 'K.RoundAway (P 3) (P 4) ~ N 1) +_test_Rem_RoundAway_P3_P4 = Dict +_test_Div_RoundAway_P4_N1 :: Dict (K.Div 'K.RoundAway (P 4) (N 1) ~ N 4) +_test_Div_RoundAway_P4_N1 = Dict +_test_Rem_RoundAway_P4_N1 :: Dict (K.Rem 'K.RoundAway (P 4) (N 1) ~ Z) +_test_Rem_RoundAway_P4_N1 = Dict +_test_Div_RoundAway_P4_N2 :: Dict (K.Div 'K.RoundAway (P 4) (N 2) ~ N 2) +_test_Div_RoundAway_P4_N2 = Dict +_test_Rem_RoundAway_P4_N2 :: Dict (K.Rem 'K.RoundAway (P 4) (N 2) ~ Z) +_test_Rem_RoundAway_P4_N2 = Dict +_test_Div_RoundAway_P4_N3 :: Dict (K.Div 'K.RoundAway (P 4) (N 3) ~ N 2) +_test_Div_RoundAway_P4_N3 = Dict +_test_Rem_RoundAway_P4_N3 :: Dict (K.Rem 'K.RoundAway (P 4) (N 3) ~ N 2) +_test_Rem_RoundAway_P4_N3 = Dict +_test_Div_RoundAway_P4_N4 :: Dict (K.Div 'K.RoundAway (P 4) (N 4) ~ N 1) +_test_Div_RoundAway_P4_N4 = Dict +_test_Rem_RoundAway_P4_N4 :: Dict (K.Rem 'K.RoundAway (P 4) (N 4) ~ Z) +_test_Rem_RoundAway_P4_N4 = Dict +_test_Div_RoundAway_P4_P1 :: Dict (K.Div 'K.RoundAway (P 4) (P 1) ~ P 4) +_test_Div_RoundAway_P4_P1 = Dict +_test_Rem_RoundAway_P4_P1 :: Dict (K.Rem 'K.RoundAway (P 4) (P 1) ~ Z) +_test_Rem_RoundAway_P4_P1 = Dict +_test_Div_RoundAway_P4_P2 :: Dict (K.Div 'K.RoundAway (P 4) (P 2) ~ P 2) +_test_Div_RoundAway_P4_P2 = Dict +_test_Rem_RoundAway_P4_P2 :: Dict (K.Rem 'K.RoundAway (P 4) (P 2) ~ Z) +_test_Rem_RoundAway_P4_P2 = Dict +_test_Div_RoundAway_P4_P3 :: Dict (K.Div 'K.RoundAway (P 4) (P 3) ~ P 2) +_test_Div_RoundAway_P4_P3 = Dict +_test_Rem_RoundAway_P4_P3 :: Dict (K.Rem 'K.RoundAway (P 4) (P 3) ~ N 2) +_test_Rem_RoundAway_P4_P3 = Dict +_test_Div_RoundAway_P4_P4 :: Dict (K.Div 'K.RoundAway (P 4) (P 4) ~ P 1) +_test_Div_RoundAway_P4_P4 = Dict +_test_Rem_RoundAway_P4_P4 :: Dict (K.Rem 'K.RoundAway (P 4) (P 4) ~ Z) +_test_Rem_RoundAway_P4_P4 = Dict +_test_Div_RoundDown_N1_N1 :: Dict (K.Div 'K.RoundDown (N 1) (N 1) ~ P 1) +_test_Div_RoundDown_N1_N1 = Dict +_test_Rem_RoundDown_N1_N1 :: Dict (K.Rem 'K.RoundDown (N 1) (N 1) ~ Z) +_test_Rem_RoundDown_N1_N1 = Dict +_test_Div_RoundDown_N1_N2 :: Dict (K.Div 'K.RoundDown (N 1) (N 2) ~ Z) +_test_Div_RoundDown_N1_N2 = Dict +_test_Rem_RoundDown_N1_N2 :: Dict (K.Rem 'K.RoundDown (N 1) (N 2) ~ N 1) +_test_Rem_RoundDown_N1_N2 = Dict +_test_Div_RoundDown_N1_N3 :: Dict (K.Div 'K.RoundDown (N 1) (N 3) ~ Z) +_test_Div_RoundDown_N1_N3 = Dict +_test_Rem_RoundDown_N1_N3 :: Dict (K.Rem 'K.RoundDown (N 1) (N 3) ~ N 1) +_test_Rem_RoundDown_N1_N3 = Dict +_test_Div_RoundDown_N1_N4 :: Dict (K.Div 'K.RoundDown (N 1) (N 4) ~ Z) +_test_Div_RoundDown_N1_N4 = Dict +_test_Rem_RoundDown_N1_N4 :: Dict (K.Rem 'K.RoundDown (N 1) (N 4) ~ N 1) +_test_Rem_RoundDown_N1_N4 = Dict +_test_Div_RoundDown_N1_P1 :: Dict (K.Div 'K.RoundDown (N 1) (P 1) ~ N 1) +_test_Div_RoundDown_N1_P1 = Dict +_test_Rem_RoundDown_N1_P1 :: Dict (K.Rem 'K.RoundDown (N 1) (P 1) ~ Z) +_test_Rem_RoundDown_N1_P1 = Dict +_test_Div_RoundDown_N1_P2 :: Dict (K.Div 'K.RoundDown (N 1) (P 2) ~ N 1) +_test_Div_RoundDown_N1_P2 = Dict +_test_Rem_RoundDown_N1_P2 :: Dict (K.Rem 'K.RoundDown (N 1) (P 2) ~ P 1) +_test_Rem_RoundDown_N1_P2 = Dict +_test_Div_RoundDown_N1_P3 :: Dict (K.Div 'K.RoundDown (N 1) (P 3) ~ N 1) +_test_Div_RoundDown_N1_P3 = Dict +_test_Rem_RoundDown_N1_P3 :: Dict (K.Rem 'K.RoundDown (N 1) (P 3) ~ P 2) +_test_Rem_RoundDown_N1_P3 = Dict +_test_Div_RoundDown_N1_P4 :: Dict (K.Div 'K.RoundDown (N 1) (P 4) ~ N 1) +_test_Div_RoundDown_N1_P4 = Dict +_test_Rem_RoundDown_N1_P4 :: Dict (K.Rem 'K.RoundDown (N 1) (P 4) ~ P 3) +_test_Rem_RoundDown_N1_P4 = Dict +_test_Div_RoundDown_N2_N1 :: Dict (K.Div 'K.RoundDown (N 2) (N 1) ~ P 2) +_test_Div_RoundDown_N2_N1 = Dict +_test_Rem_RoundDown_N2_N1 :: Dict (K.Rem 'K.RoundDown (N 2) (N 1) ~ Z) +_test_Rem_RoundDown_N2_N1 = Dict +_test_Div_RoundDown_N2_N2 :: Dict (K.Div 'K.RoundDown (N 2) (N 2) ~ P 1) +_test_Div_RoundDown_N2_N2 = Dict +_test_Rem_RoundDown_N2_N2 :: Dict (K.Rem 'K.RoundDown (N 2) (N 2) ~ Z) +_test_Rem_RoundDown_N2_N2 = Dict +_test_Div_RoundDown_N2_N3 :: Dict (K.Div 'K.RoundDown (N 2) (N 3) ~ Z) +_test_Div_RoundDown_N2_N3 = Dict +_test_Rem_RoundDown_N2_N3 :: Dict (K.Rem 'K.RoundDown (N 2) (N 3) ~ N 2) +_test_Rem_RoundDown_N2_N3 = Dict +_test_Div_RoundDown_N2_N4 :: Dict (K.Div 'K.RoundDown (N 2) (N 4) ~ Z) +_test_Div_RoundDown_N2_N4 = Dict +_test_Rem_RoundDown_N2_N4 :: Dict (K.Rem 'K.RoundDown (N 2) (N 4) ~ N 2) +_test_Rem_RoundDown_N2_N4 = Dict +_test_Div_RoundDown_N2_P1 :: Dict (K.Div 'K.RoundDown (N 2) (P 1) ~ N 2) +_test_Div_RoundDown_N2_P1 = Dict +_test_Rem_RoundDown_N2_P1 :: Dict (K.Rem 'K.RoundDown (N 2) (P 1) ~ Z) +_test_Rem_RoundDown_N2_P1 = Dict +_test_Div_RoundDown_N2_P2 :: Dict (K.Div 'K.RoundDown (N 2) (P 2) ~ N 1) +_test_Div_RoundDown_N2_P2 = Dict +_test_Rem_RoundDown_N2_P2 :: Dict (K.Rem 'K.RoundDown (N 2) (P 2) ~ Z) +_test_Rem_RoundDown_N2_P2 = Dict +_test_Div_RoundDown_N2_P3 :: Dict (K.Div 'K.RoundDown (N 2) (P 3) ~ N 1) +_test_Div_RoundDown_N2_P3 = Dict +_test_Rem_RoundDown_N2_P3 :: Dict (K.Rem 'K.RoundDown (N 2) (P 3) ~ P 1) +_test_Rem_RoundDown_N2_P3 = Dict +_test_Div_RoundDown_N2_P4 :: Dict (K.Div 'K.RoundDown (N 2) (P 4) ~ N 1) +_test_Div_RoundDown_N2_P4 = Dict +_test_Rem_RoundDown_N2_P4 :: Dict (K.Rem 'K.RoundDown (N 2) (P 4) ~ P 2) +_test_Rem_RoundDown_N2_P4 = Dict +_test_Div_RoundDown_N3_N1 :: Dict (K.Div 'K.RoundDown (N 3) (N 1) ~ P 3) +_test_Div_RoundDown_N3_N1 = Dict +_test_Rem_RoundDown_N3_N1 :: Dict (K.Rem 'K.RoundDown (N 3) (N 1) ~ Z) +_test_Rem_RoundDown_N3_N1 = Dict +_test_Div_RoundDown_N3_N2 :: Dict (K.Div 'K.RoundDown (N 3) (N 2) ~ P 1) +_test_Div_RoundDown_N3_N2 = Dict +_test_Rem_RoundDown_N3_N2 :: Dict (K.Rem 'K.RoundDown (N 3) (N 2) ~ N 1) +_test_Rem_RoundDown_N3_N2 = Dict +_test_Div_RoundDown_N3_N3 :: Dict (K.Div 'K.RoundDown (N 3) (N 3) ~ P 1) +_test_Div_RoundDown_N3_N3 = Dict +_test_Rem_RoundDown_N3_N3 :: Dict (K.Rem 'K.RoundDown (N 3) (N 3) ~ Z) +_test_Rem_RoundDown_N3_N3 = Dict +_test_Div_RoundDown_N3_N4 :: Dict (K.Div 'K.RoundDown (N 3) (N 4) ~ Z) +_test_Div_RoundDown_N3_N4 = Dict +_test_Rem_RoundDown_N3_N4 :: Dict (K.Rem 'K.RoundDown (N 3) (N 4) ~ N 3) +_test_Rem_RoundDown_N3_N4 = Dict +_test_Div_RoundDown_N3_P1 :: Dict (K.Div 'K.RoundDown (N 3) (P 1) ~ N 3) +_test_Div_RoundDown_N3_P1 = Dict +_test_Rem_RoundDown_N3_P1 :: Dict (K.Rem 'K.RoundDown (N 3) (P 1) ~ Z) +_test_Rem_RoundDown_N3_P1 = Dict +_test_Div_RoundDown_N3_P2 :: Dict (K.Div 'K.RoundDown (N 3) (P 2) ~ N 2) +_test_Div_RoundDown_N3_P2 = Dict +_test_Rem_RoundDown_N3_P2 :: Dict (K.Rem 'K.RoundDown (N 3) (P 2) ~ P 1) +_test_Rem_RoundDown_N3_P2 = Dict +_test_Div_RoundDown_N3_P3 :: Dict (K.Div 'K.RoundDown (N 3) (P 3) ~ N 1) +_test_Div_RoundDown_N3_P3 = Dict +_test_Rem_RoundDown_N3_P3 :: Dict (K.Rem 'K.RoundDown (N 3) (P 3) ~ Z) +_test_Rem_RoundDown_N3_P3 = Dict +_test_Div_RoundDown_N3_P4 :: Dict (K.Div 'K.RoundDown (N 3) (P 4) ~ N 1) +_test_Div_RoundDown_N3_P4 = Dict +_test_Rem_RoundDown_N3_P4 :: Dict (K.Rem 'K.RoundDown (N 3) (P 4) ~ P 1) +_test_Rem_RoundDown_N3_P4 = Dict +_test_Div_RoundDown_N4_N1 :: Dict (K.Div 'K.RoundDown (N 4) (N 1) ~ P 4) +_test_Div_RoundDown_N4_N1 = Dict +_test_Rem_RoundDown_N4_N1 :: Dict (K.Rem 'K.RoundDown (N 4) (N 1) ~ Z) +_test_Rem_RoundDown_N4_N1 = Dict +_test_Div_RoundDown_N4_N2 :: Dict (K.Div 'K.RoundDown (N 4) (N 2) ~ P 2) +_test_Div_RoundDown_N4_N2 = Dict +_test_Rem_RoundDown_N4_N2 :: Dict (K.Rem 'K.RoundDown (N 4) (N 2) ~ Z) +_test_Rem_RoundDown_N4_N2 = Dict +_test_Div_RoundDown_N4_N3 :: Dict (K.Div 'K.RoundDown (N 4) (N 3) ~ P 1) +_test_Div_RoundDown_N4_N3 = Dict +_test_Rem_RoundDown_N4_N3 :: Dict (K.Rem 'K.RoundDown (N 4) (N 3) ~ N 1) +_test_Rem_RoundDown_N4_N3 = Dict +_test_Div_RoundDown_N4_N4 :: Dict (K.Div 'K.RoundDown (N 4) (N 4) ~ P 1) +_test_Div_RoundDown_N4_N4 = Dict +_test_Rem_RoundDown_N4_N4 :: Dict (K.Rem 'K.RoundDown (N 4) (N 4) ~ Z) +_test_Rem_RoundDown_N4_N4 = Dict +_test_Div_RoundDown_N4_P1 :: Dict (K.Div 'K.RoundDown (N 4) (P 1) ~ N 4) +_test_Div_RoundDown_N4_P1 = Dict +_test_Rem_RoundDown_N4_P1 :: Dict (K.Rem 'K.RoundDown (N 4) (P 1) ~ Z) +_test_Rem_RoundDown_N4_P1 = Dict +_test_Div_RoundDown_N4_P2 :: Dict (K.Div 'K.RoundDown (N 4) (P 2) ~ N 2) +_test_Div_RoundDown_N4_P2 = Dict +_test_Rem_RoundDown_N4_P2 :: Dict (K.Rem 'K.RoundDown (N 4) (P 2) ~ Z) +_test_Rem_RoundDown_N4_P2 = Dict +_test_Div_RoundDown_N4_P3 :: Dict (K.Div 'K.RoundDown (N 4) (P 3) ~ N 2) +_test_Div_RoundDown_N4_P3 = Dict +_test_Rem_RoundDown_N4_P3 :: Dict (K.Rem 'K.RoundDown (N 4) (P 3) ~ P 2) +_test_Rem_RoundDown_N4_P3 = Dict +_test_Div_RoundDown_N4_P4 :: Dict (K.Div 'K.RoundDown (N 4) (P 4) ~ N 1) +_test_Div_RoundDown_N4_P4 = Dict +_test_Rem_RoundDown_N4_P4 :: Dict (K.Rem 'K.RoundDown (N 4) (P 4) ~ Z) +_test_Rem_RoundDown_N4_P4 = Dict +_test_Rem_RoundDown_Z_N1 :: Dict (K.Rem 'K.RoundDown Z (N 1) ~ Z) +_test_Rem_RoundDown_Z_N1 = Dict +_test_Rem_RoundDown_Z_N2 :: Dict (K.Rem 'K.RoundDown Z (N 2) ~ Z) +_test_Rem_RoundDown_Z_N2 = Dict +_test_Rem_RoundDown_Z_N3 :: Dict (K.Rem 'K.RoundDown Z (N 3) ~ Z) +_test_Rem_RoundDown_Z_N3 = Dict +_test_Rem_RoundDown_Z_N4 :: Dict (K.Rem 'K.RoundDown Z (N 4) ~ Z) +_test_Rem_RoundDown_Z_N4 = Dict +_test_Rem_RoundDown_Z_P1 :: Dict (K.Rem 'K.RoundDown Z (P 1) ~ Z) +_test_Rem_RoundDown_Z_P1 = Dict +_test_Rem_RoundDown_Z_P2 :: Dict (K.Rem 'K.RoundDown Z (P 2) ~ Z) +_test_Rem_RoundDown_Z_P2 = Dict +_test_Rem_RoundDown_Z_P3 :: Dict (K.Rem 'K.RoundDown Z (P 3) ~ Z) +_test_Rem_RoundDown_Z_P3 = Dict +_test_Rem_RoundDown_Z_P4 :: Dict (K.Rem 'K.RoundDown Z (P 4) ~ Z) +_test_Rem_RoundDown_Z_P4 = Dict +_test_Rem_RoundDown_P1_N1 :: Dict (K.Rem 'K.RoundDown (P 1) (N 1) ~ Z) +_test_Rem_RoundDown_P1_N1 = Dict +_test_Rem_RoundDown_P1_N2 :: Dict (K.Rem 'K.RoundDown (P 1) (N 2) ~ N 1) +_test_Rem_RoundDown_P1_N2 = Dict +_test_Rem_RoundDown_P1_N3 :: Dict (K.Rem 'K.RoundDown (P 1) (N 3) ~ N 2) +_test_Rem_RoundDown_P1_N3 = Dict +_test_Rem_RoundDown_P1_N4 :: Dict (K.Rem 'K.RoundDown (P 1) (N 4) ~ N 3) +_test_Rem_RoundDown_P1_N4 = Dict +_test_Div_RoundDown_P1_P1 :: Dict (K.Div 'K.RoundDown (P 1) (P 1) ~ P 1) +_test_Div_RoundDown_P1_P1 = Dict +_test_Rem_RoundDown_P1_P1 :: Dict (K.Rem 'K.RoundDown (P 1) (P 1) ~ Z) +_test_Rem_RoundDown_P1_P1 = Dict +_test_Div_RoundDown_P1_P2 :: Dict (K.Div 'K.RoundDown (P 1) (P 2) ~ Z) +_test_Div_RoundDown_P1_P2 = Dict +_test_Rem_RoundDown_P1_P2 :: Dict (K.Rem 'K.RoundDown (P 1) (P 2) ~ P 1) +_test_Rem_RoundDown_P1_P2 = Dict +_test_Div_RoundDown_P1_P3 :: Dict (K.Div 'K.RoundDown (P 1) (P 3) ~ Z) +_test_Div_RoundDown_P1_P3 = Dict +_test_Rem_RoundDown_P1_P3 :: Dict (K.Rem 'K.RoundDown (P 1) (P 3) ~ P 1) +_test_Rem_RoundDown_P1_P3 = Dict +_test_Div_RoundDown_P1_P4 :: Dict (K.Div 'K.RoundDown (P 1) (P 4) ~ Z) +_test_Div_RoundDown_P1_P4 = Dict +_test_Rem_RoundDown_P1_P4 :: Dict (K.Rem 'K.RoundDown (P 1) (P 4) ~ P 1) +_test_Rem_RoundDown_P1_P4 = Dict +_test_Div_RoundDown_P2_N1 :: Dict (K.Div 'K.RoundDown (P 2) (N 1) ~ N 2) +_test_Div_RoundDown_P2_N1 = Dict +_test_Rem_RoundDown_P2_N1 :: Dict (K.Rem 'K.RoundDown (P 2) (N 1) ~ Z) +_test_Rem_RoundDown_P2_N1 = Dict +_test_Div_RoundDown_P2_N2 :: Dict (K.Div 'K.RoundDown (P 2) (N 2) ~ N 1) +_test_Div_RoundDown_P2_N2 = Dict +_test_Rem_RoundDown_P2_N2 :: Dict (K.Rem 'K.RoundDown (P 2) (N 2) ~ Z) +_test_Rem_RoundDown_P2_N2 = Dict +_test_Div_RoundDown_P2_N3 :: Dict (K.Div 'K.RoundDown (P 2) (N 3) ~ N 1) +_test_Div_RoundDown_P2_N3 = Dict +_test_Rem_RoundDown_P2_N3 :: Dict (K.Rem 'K.RoundDown (P 2) (N 3) ~ N 1) +_test_Rem_RoundDown_P2_N3 = Dict +_test_Div_RoundDown_P2_N4 :: Dict (K.Div 'K.RoundDown (P 2) (N 4) ~ N 1) +_test_Div_RoundDown_P2_N4 = Dict +_test_Rem_RoundDown_P2_N4 :: Dict (K.Rem 'K.RoundDown (P 2) (N 4) ~ N 2) +_test_Rem_RoundDown_P2_N4 = Dict +_test_Div_RoundDown_P2_P1 :: Dict (K.Div 'K.RoundDown (P 2) (P 1) ~ P 2) +_test_Div_RoundDown_P2_P1 = Dict +_test_Rem_RoundDown_P2_P1 :: Dict (K.Rem 'K.RoundDown (P 2) (P 1) ~ Z) +_test_Rem_RoundDown_P2_P1 = Dict +_test_Div_RoundDown_P2_P2 :: Dict (K.Div 'K.RoundDown (P 2) (P 2) ~ P 1) +_test_Div_RoundDown_P2_P2 = Dict +_test_Rem_RoundDown_P2_P2 :: Dict (K.Rem 'K.RoundDown (P 2) (P 2) ~ Z) +_test_Rem_RoundDown_P2_P2 = Dict +_test_Div_RoundDown_P2_P3 :: Dict (K.Div 'K.RoundDown (P 2) (P 3) ~ Z) +_test_Div_RoundDown_P2_P3 = Dict +_test_Rem_RoundDown_P2_P3 :: Dict (K.Rem 'K.RoundDown (P 2) (P 3) ~ P 2) +_test_Rem_RoundDown_P2_P3 = Dict +_test_Div_RoundDown_P2_P4 :: Dict (K.Div 'K.RoundDown (P 2) (P 4) ~ Z) +_test_Div_RoundDown_P2_P4 = Dict +_test_Rem_RoundDown_P2_P4 :: Dict (K.Rem 'K.RoundDown (P 2) (P 4) ~ P 2) +_test_Rem_RoundDown_P2_P4 = Dict +_test_Div_RoundDown_P3_N1 :: Dict (K.Div 'K.RoundDown (P 3) (N 1) ~ N 3) +_test_Div_RoundDown_P3_N1 = Dict +_test_Rem_RoundDown_P3_N1 :: Dict (K.Rem 'K.RoundDown (P 3) (N 1) ~ Z) +_test_Rem_RoundDown_P3_N1 = Dict +_test_Div_RoundDown_P3_N2 :: Dict (K.Div 'K.RoundDown (P 3) (N 2) ~ N 2) +_test_Div_RoundDown_P3_N2 = Dict +_test_Rem_RoundDown_P3_N2 :: Dict (K.Rem 'K.RoundDown (P 3) (N 2) ~ N 1) +_test_Rem_RoundDown_P3_N2 = Dict +_test_Div_RoundDown_P3_N3 :: Dict (K.Div 'K.RoundDown (P 3) (N 3) ~ N 1) +_test_Div_RoundDown_P3_N3 = Dict +_test_Rem_RoundDown_P3_N3 :: Dict (K.Rem 'K.RoundDown (P 3) (N 3) ~ Z) +_test_Rem_RoundDown_P3_N3 = Dict +_test_Div_RoundDown_P3_N4 :: Dict (K.Div 'K.RoundDown (P 3) (N 4) ~ N 1) +_test_Div_RoundDown_P3_N4 = Dict +_test_Rem_RoundDown_P3_N4 :: Dict (K.Rem 'K.RoundDown (P 3) (N 4) ~ N 1) +_test_Rem_RoundDown_P3_N4 = Dict +_test_Div_RoundDown_P3_P1 :: Dict (K.Div 'K.RoundDown (P 3) (P 1) ~ P 3) +_test_Div_RoundDown_P3_P1 = Dict +_test_Rem_RoundDown_P3_P1 :: Dict (K.Rem 'K.RoundDown (P 3) (P 1) ~ Z) +_test_Rem_RoundDown_P3_P1 = Dict +_test_Div_RoundDown_P3_P2 :: Dict (K.Div 'K.RoundDown (P 3) (P 2) ~ P 1) +_test_Div_RoundDown_P3_P2 = Dict +_test_Rem_RoundDown_P3_P2 :: Dict (K.Rem 'K.RoundDown (P 3) (P 2) ~ P 1) +_test_Rem_RoundDown_P3_P2 = Dict +_test_Div_RoundDown_P3_P3 :: Dict (K.Div 'K.RoundDown (P 3) (P 3) ~ P 1) +_test_Div_RoundDown_P3_P3 = Dict +_test_Rem_RoundDown_P3_P3 :: Dict (K.Rem 'K.RoundDown (P 3) (P 3) ~ Z) +_test_Rem_RoundDown_P3_P3 = Dict +_test_Div_RoundDown_P3_P4 :: Dict (K.Div 'K.RoundDown (P 3) (P 4) ~ Z) +_test_Div_RoundDown_P3_P4 = Dict +_test_Rem_RoundDown_P3_P4 :: Dict (K.Rem 'K.RoundDown (P 3) (P 4) ~ P 3) +_test_Rem_RoundDown_P3_P4 = Dict +_test_Div_RoundDown_P4_N1 :: Dict (K.Div 'K.RoundDown (P 4) (N 1) ~ N 4) +_test_Div_RoundDown_P4_N1 = Dict +_test_Rem_RoundDown_P4_N1 :: Dict (K.Rem 'K.RoundDown (P 4) (N 1) ~ Z) +_test_Rem_RoundDown_P4_N1 = Dict +_test_Div_RoundDown_P4_N2 :: Dict (K.Div 'K.RoundDown (P 4) (N 2) ~ N 2) +_test_Div_RoundDown_P4_N2 = Dict +_test_Rem_RoundDown_P4_N2 :: Dict (K.Rem 'K.RoundDown (P 4) (N 2) ~ Z) +_test_Rem_RoundDown_P4_N2 = Dict +_test_Div_RoundDown_P4_N3 :: Dict (K.Div 'K.RoundDown (P 4) (N 3) ~ N 2) +_test_Div_RoundDown_P4_N3 = Dict +_test_Rem_RoundDown_P4_N3 :: Dict (K.Rem 'K.RoundDown (P 4) (N 3) ~ N 2) +_test_Rem_RoundDown_P4_N3 = Dict +_test_Div_RoundDown_P4_N4 :: Dict (K.Div 'K.RoundDown (P 4) (N 4) ~ N 1) +_test_Div_RoundDown_P4_N4 = Dict +_test_Rem_RoundDown_P4_N4 :: Dict (K.Rem 'K.RoundDown (P 4) (N 4) ~ Z) +_test_Rem_RoundDown_P4_N4 = Dict +_test_Div_RoundDown_P4_P1 :: Dict (K.Div 'K.RoundDown (P 4) (P 1) ~ P 4) +_test_Div_RoundDown_P4_P1 = Dict +_test_Rem_RoundDown_P4_P1 :: Dict (K.Rem 'K.RoundDown (P 4) (P 1) ~ Z) +_test_Rem_RoundDown_P4_P1 = Dict +_test_Div_RoundDown_P4_P2 :: Dict (K.Div 'K.RoundDown (P 4) (P 2) ~ P 2) +_test_Div_RoundDown_P4_P2 = Dict +_test_Rem_RoundDown_P4_P2 :: Dict (K.Rem 'K.RoundDown (P 4) (P 2) ~ Z) +_test_Rem_RoundDown_P4_P2 = Dict +_test_Div_RoundDown_P4_P3 :: Dict (K.Div 'K.RoundDown (P 4) (P 3) ~ P 1) +_test_Div_RoundDown_P4_P3 = Dict +_test_Rem_RoundDown_P4_P3 :: Dict (K.Rem 'K.RoundDown (P 4) (P 3) ~ P 1) +_test_Rem_RoundDown_P4_P3 = Dict +_test_Div_RoundDown_P4_P4 :: Dict (K.Div 'K.RoundDown (P 4) (P 4) ~ P 1) +_test_Div_RoundDown_P4_P4 = Dict +_test_Rem_RoundDown_P4_P4 :: Dict (K.Rem 'K.RoundDown (P 4) (P 4) ~ Z) +_test_Rem_RoundDown_P4_P4 = Dict +_test_Div_RoundHalfAway_N1_N1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfAway_N1_N1 = Dict +_test_Rem_RoundHalfAway_N1_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfAway_N1_N1 = Dict +_test_Div_RoundHalfAway_N1_N2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 2) ~ P 1) +_test_Div_RoundHalfAway_N1_N2 = Dict +_test_Rem_RoundHalfAway_N1_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 2) ~ P 1) +_test_Rem_RoundHalfAway_N1_N2 = Dict +_test_Div_RoundHalfAway_N1_N3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 3) ~ Z) +_test_Div_RoundHalfAway_N1_N3 = Dict +_test_Rem_RoundHalfAway_N1_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfAway_N1_N3 = Dict +_test_Div_RoundHalfAway_N1_N4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 4) ~ Z) +_test_Div_RoundHalfAway_N1_N4 = Dict +_test_Rem_RoundHalfAway_N1_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfAway_N1_N4 = Dict +_test_Div_RoundHalfAway_N1_P1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfAway_N1_P1 = Dict +_test_Rem_RoundHalfAway_N1_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfAway_N1_P1 = Dict +_test_Div_RoundHalfAway_N1_P2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 2) ~ N 1) +_test_Div_RoundHalfAway_N1_P2 = Dict +_test_Rem_RoundHalfAway_N1_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 2) ~ P 1) +_test_Rem_RoundHalfAway_N1_P2 = Dict +_test_Div_RoundHalfAway_N1_P3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 3) ~ Z) +_test_Div_RoundHalfAway_N1_P3 = Dict +_test_Rem_RoundHalfAway_N1_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfAway_N1_P3 = Dict +_test_Div_RoundHalfAway_N1_P4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 4) ~ Z) +_test_Div_RoundHalfAway_N1_P4 = Dict +_test_Rem_RoundHalfAway_N1_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfAway_N1_P4 = Dict +_test_Div_RoundHalfAway_N2_N1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfAway_N2_N1 = Dict +_test_Rem_RoundHalfAway_N2_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfAway_N2_N1 = Dict +_test_Div_RoundHalfAway_N2_N2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfAway_N2_N2 = Dict +_test_Rem_RoundHalfAway_N2_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfAway_N2_N2 = Dict +_test_Div_RoundHalfAway_N2_N3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfAway_N2_N3 = Dict +_test_Rem_RoundHalfAway_N2_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfAway_N2_N3 = Dict +_test_Div_RoundHalfAway_N2_N4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 4) ~ P 1) +_test_Div_RoundHalfAway_N2_N4 = Dict +_test_Rem_RoundHalfAway_N2_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 4) ~ P 2) +_test_Rem_RoundHalfAway_N2_N4 = Dict +_test_Div_RoundHalfAway_N2_P1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfAway_N2_P1 = Dict +_test_Rem_RoundHalfAway_N2_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfAway_N2_P1 = Dict +_test_Div_RoundHalfAway_N2_P2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfAway_N2_P2 = Dict +_test_Rem_RoundHalfAway_N2_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfAway_N2_P2 = Dict +_test_Div_RoundHalfAway_N2_P3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfAway_N2_P3 = Dict +_test_Rem_RoundHalfAway_N2_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfAway_N2_P3 = Dict +_test_Div_RoundHalfAway_N2_P4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 4) ~ N 1) +_test_Div_RoundHalfAway_N2_P4 = Dict +_test_Rem_RoundHalfAway_N2_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 4) ~ P 2) +_test_Rem_RoundHalfAway_N2_P4 = Dict +_test_Div_RoundHalfAway_N3_N1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfAway_N3_N1 = Dict +_test_Rem_RoundHalfAway_N3_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfAway_N3_N1 = Dict +_test_Div_RoundHalfAway_N3_N2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 2) ~ P 2) +_test_Div_RoundHalfAway_N3_N2 = Dict +_test_Rem_RoundHalfAway_N3_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 2) ~ P 1) +_test_Rem_RoundHalfAway_N3_N2 = Dict +_test_Div_RoundHalfAway_N3_N3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfAway_N3_N3 = Dict +_test_Rem_RoundHalfAway_N3_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfAway_N3_N3 = Dict +_test_Div_RoundHalfAway_N3_N4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfAway_N3_N4 = Dict +_test_Rem_RoundHalfAway_N3_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfAway_N3_N4 = Dict +_test_Div_RoundHalfAway_N3_P1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfAway_N3_P1 = Dict +_test_Rem_RoundHalfAway_N3_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfAway_N3_P1 = Dict +_test_Div_RoundHalfAway_N3_P2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 2) ~ N 2) +_test_Div_RoundHalfAway_N3_P2 = Dict +_test_Rem_RoundHalfAway_N3_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 2) ~ P 1) +_test_Rem_RoundHalfAway_N3_P2 = Dict +_test_Div_RoundHalfAway_N3_P3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfAway_N3_P3 = Dict +_test_Rem_RoundHalfAway_N3_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfAway_N3_P3 = Dict +_test_Div_RoundHalfAway_N3_P4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfAway_N3_P4 = Dict +_test_Rem_RoundHalfAway_N3_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfAway_N3_P4 = Dict +_test_Div_RoundHalfAway_N4_N1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfAway_N4_N1 = Dict +_test_Rem_RoundHalfAway_N4_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfAway_N4_N1 = Dict +_test_Div_RoundHalfAway_N4_N2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfAway_N4_N2 = Dict +_test_Rem_RoundHalfAway_N4_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfAway_N4_N2 = Dict +_test_Div_RoundHalfAway_N4_N3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfAway_N4_N3 = Dict +_test_Rem_RoundHalfAway_N4_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfAway_N4_N3 = Dict +_test_Div_RoundHalfAway_N4_N4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfAway_N4_N4 = Dict +_test_Rem_RoundHalfAway_N4_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfAway_N4_N4 = Dict +_test_Div_RoundHalfAway_N4_P1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfAway_N4_P1 = Dict +_test_Rem_RoundHalfAway_N4_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfAway_N4_P1 = Dict +_test_Div_RoundHalfAway_N4_P2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfAway_N4_P2 = Dict +_test_Rem_RoundHalfAway_N4_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfAway_N4_P2 = Dict +_test_Div_RoundHalfAway_N4_P3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfAway_N4_P3 = Dict +_test_Rem_RoundHalfAway_N4_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfAway_N4_P3 = Dict +_test_Div_RoundHalfAway_N4_P4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfAway_N4_P4 = Dict +_test_Rem_RoundHalfAway_N4_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfAway_N4_P4 = Dict +_test_Rem_RoundHalfAway_Z_N1 :: Dict (K.Rem 'K.RoundHalfAway Z (N 1) ~ Z) +_test_Rem_RoundHalfAway_Z_N1 = Dict +_test_Rem_RoundHalfAway_Z_N2 :: Dict (K.Rem 'K.RoundHalfAway Z (N 2) ~ Z) +_test_Rem_RoundHalfAway_Z_N2 = Dict +_test_Rem_RoundHalfAway_Z_N3 :: Dict (K.Rem 'K.RoundHalfAway Z (N 3) ~ Z) +_test_Rem_RoundHalfAway_Z_N3 = Dict +_test_Rem_RoundHalfAway_Z_N4 :: Dict (K.Rem 'K.RoundHalfAway Z (N 4) ~ Z) +_test_Rem_RoundHalfAway_Z_N4 = Dict +_test_Rem_RoundHalfAway_Z_P1 :: Dict (K.Rem 'K.RoundHalfAway Z (P 1) ~ Z) +_test_Rem_RoundHalfAway_Z_P1 = Dict +_test_Rem_RoundHalfAway_Z_P2 :: Dict (K.Rem 'K.RoundHalfAway Z (P 2) ~ Z) +_test_Rem_RoundHalfAway_Z_P2 = Dict +_test_Rem_RoundHalfAway_Z_P3 :: Dict (K.Rem 'K.RoundHalfAway Z (P 3) ~ Z) +_test_Rem_RoundHalfAway_Z_P3 = Dict +_test_Rem_RoundHalfAway_Z_P4 :: Dict (K.Rem 'K.RoundHalfAway Z (P 4) ~ Z) +_test_Rem_RoundHalfAway_Z_P4 = Dict +_test_Div_RoundHalfAway_P1_N1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfAway_P1_N1 = Dict +_test_Rem_RoundHalfAway_P1_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfAway_P1_N1 = Dict +_test_Div_RoundHalfAway_P1_N2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 2) ~ N 1) +_test_Div_RoundHalfAway_P1_N2 = Dict +_test_Rem_RoundHalfAway_P1_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 2) ~ N 1) +_test_Rem_RoundHalfAway_P1_N2 = Dict +_test_Div_RoundHalfAway_P1_N3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 3) ~ Z) +_test_Div_RoundHalfAway_P1_N3 = Dict +_test_Rem_RoundHalfAway_P1_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfAway_P1_N3 = Dict +_test_Div_RoundHalfAway_P1_N4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 4) ~ Z) +_test_Div_RoundHalfAway_P1_N4 = Dict +_test_Rem_RoundHalfAway_P1_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfAway_P1_N4 = Dict +_test_Div_RoundHalfAway_P1_P1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfAway_P1_P1 = Dict +_test_Rem_RoundHalfAway_P1_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfAway_P1_P1 = Dict +_test_Div_RoundHalfAway_P1_P2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 2) ~ P 1) +_test_Div_RoundHalfAway_P1_P2 = Dict +_test_Rem_RoundHalfAway_P1_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 2) ~ N 1) +_test_Rem_RoundHalfAway_P1_P2 = Dict +_test_Div_RoundHalfAway_P1_P3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 3) ~ Z) +_test_Div_RoundHalfAway_P1_P3 = Dict +_test_Rem_RoundHalfAway_P1_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfAway_P1_P3 = Dict +_test_Div_RoundHalfAway_P1_P4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 4) ~ Z) +_test_Div_RoundHalfAway_P1_P4 = Dict +_test_Rem_RoundHalfAway_P1_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfAway_P1_P4 = Dict +_test_Div_RoundHalfAway_P2_N1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfAway_P2_N1 = Dict +_test_Rem_RoundHalfAway_P2_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfAway_P2_N1 = Dict +_test_Div_RoundHalfAway_P2_N2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfAway_P2_N2 = Dict +_test_Rem_RoundHalfAway_P2_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfAway_P2_N2 = Dict +_test_Div_RoundHalfAway_P2_N3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfAway_P2_N3 = Dict +_test_Rem_RoundHalfAway_P2_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfAway_P2_N3 = Dict +_test_Div_RoundHalfAway_P2_N4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 4) ~ N 1) +_test_Div_RoundHalfAway_P2_N4 = Dict +_test_Rem_RoundHalfAway_P2_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 4) ~ N 2) +_test_Rem_RoundHalfAway_P2_N4 = Dict +_test_Div_RoundHalfAway_P2_P1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfAway_P2_P1 = Dict +_test_Rem_RoundHalfAway_P2_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfAway_P2_P1 = Dict +_test_Div_RoundHalfAway_P2_P2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfAway_P2_P2 = Dict +_test_Rem_RoundHalfAway_P2_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfAway_P2_P2 = Dict +_test_Div_RoundHalfAway_P2_P3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfAway_P2_P3 = Dict +_test_Rem_RoundHalfAway_P2_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfAway_P2_P3 = Dict +_test_Div_RoundHalfAway_P2_P4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 4) ~ P 1) +_test_Div_RoundHalfAway_P2_P4 = Dict +_test_Rem_RoundHalfAway_P2_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 4) ~ N 2) +_test_Rem_RoundHalfAway_P2_P4 = Dict +_test_Div_RoundHalfAway_P3_N1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfAway_P3_N1 = Dict +_test_Rem_RoundHalfAway_P3_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfAway_P3_N1 = Dict +_test_Div_RoundHalfAway_P3_N2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 2) ~ N 2) +_test_Div_RoundHalfAway_P3_N2 = Dict +_test_Rem_RoundHalfAway_P3_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 2) ~ N 1) +_test_Rem_RoundHalfAway_P3_N2 = Dict +_test_Div_RoundHalfAway_P3_N3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfAway_P3_N3 = Dict +_test_Rem_RoundHalfAway_P3_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfAway_P3_N3 = Dict +_test_Div_RoundHalfAway_P3_N4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfAway_P3_N4 = Dict +_test_Rem_RoundHalfAway_P3_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfAway_P3_N4 = Dict +_test_Div_RoundHalfAway_P3_P1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfAway_P3_P1 = Dict +_test_Rem_RoundHalfAway_P3_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfAway_P3_P1 = Dict +_test_Div_RoundHalfAway_P3_P2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 2) ~ P 2) +_test_Div_RoundHalfAway_P3_P2 = Dict +_test_Rem_RoundHalfAway_P3_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 2) ~ N 1) +_test_Rem_RoundHalfAway_P3_P2 = Dict +_test_Div_RoundHalfAway_P3_P3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfAway_P3_P3 = Dict +_test_Rem_RoundHalfAway_P3_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfAway_P3_P3 = Dict +_test_Div_RoundHalfAway_P3_P4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfAway_P3_P4 = Dict +_test_Rem_RoundHalfAway_P3_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfAway_P3_P4 = Dict +_test_Div_RoundHalfAway_P4_N1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfAway_P4_N1 = Dict +_test_Rem_RoundHalfAway_P4_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfAway_P4_N1 = Dict +_test_Div_RoundHalfAway_P4_N2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfAway_P4_N2 = Dict +_test_Rem_RoundHalfAway_P4_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfAway_P4_N2 = Dict +_test_Div_RoundHalfAway_P4_N3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfAway_P4_N3 = Dict +_test_Rem_RoundHalfAway_P4_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfAway_P4_N3 = Dict +_test_Div_RoundHalfAway_P4_N4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfAway_P4_N4 = Dict +_test_Rem_RoundHalfAway_P4_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfAway_P4_N4 = Dict +_test_Div_RoundHalfAway_P4_P1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfAway_P4_P1 = Dict +_test_Rem_RoundHalfAway_P4_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfAway_P4_P1 = Dict +_test_Div_RoundHalfAway_P4_P2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfAway_P4_P2 = Dict +_test_Rem_RoundHalfAway_P4_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfAway_P4_P2 = Dict +_test_Div_RoundHalfAway_P4_P3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfAway_P4_P3 = Dict +_test_Rem_RoundHalfAway_P4_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfAway_P4_P3 = Dict +_test_Div_RoundHalfAway_P4_P4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfAway_P4_P4 = Dict +_test_Rem_RoundHalfAway_P4_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfAway_P4_P4 = Dict +_test_Div_RoundHalfDown_N1_N1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfDown_N1_N1 = Dict +_test_Rem_RoundHalfDown_N1_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfDown_N1_N1 = Dict +_test_Div_RoundHalfDown_N1_N2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 2) ~ Z) +_test_Div_RoundHalfDown_N1_N2 = Dict +_test_Rem_RoundHalfDown_N1_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 2) ~ N 1) +_test_Rem_RoundHalfDown_N1_N2 = Dict +_test_Div_RoundHalfDown_N1_N3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 3) ~ Z) +_test_Div_RoundHalfDown_N1_N3 = Dict +_test_Rem_RoundHalfDown_N1_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfDown_N1_N3 = Dict +_test_Div_RoundHalfDown_N1_N4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 4) ~ Z) +_test_Div_RoundHalfDown_N1_N4 = Dict +_test_Rem_RoundHalfDown_N1_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfDown_N1_N4 = Dict +_test_Div_RoundHalfDown_N1_P1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfDown_N1_P1 = Dict +_test_Rem_RoundHalfDown_N1_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfDown_N1_P1 = Dict +_test_Div_RoundHalfDown_N1_P2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 2) ~ N 1) +_test_Div_RoundHalfDown_N1_P2 = Dict +_test_Rem_RoundHalfDown_N1_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 2) ~ P 1) +_test_Rem_RoundHalfDown_N1_P2 = Dict +_test_Div_RoundHalfDown_N1_P3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 3) ~ Z) +_test_Div_RoundHalfDown_N1_P3 = Dict +_test_Rem_RoundHalfDown_N1_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfDown_N1_P3 = Dict +_test_Div_RoundHalfDown_N1_P4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 4) ~ Z) +_test_Div_RoundHalfDown_N1_P4 = Dict +_test_Rem_RoundHalfDown_N1_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfDown_N1_P4 = Dict +_test_Div_RoundHalfDown_N2_N1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfDown_N2_N1 = Dict +_test_Rem_RoundHalfDown_N2_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfDown_N2_N1 = Dict +_test_Div_RoundHalfDown_N2_N2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfDown_N2_N2 = Dict +_test_Rem_RoundHalfDown_N2_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfDown_N2_N2 = Dict +_test_Div_RoundHalfDown_N2_N3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfDown_N2_N3 = Dict +_test_Rem_RoundHalfDown_N2_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfDown_N2_N3 = Dict +_test_Div_RoundHalfDown_N2_N4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 4) ~ Z) +_test_Div_RoundHalfDown_N2_N4 = Dict +_test_Rem_RoundHalfDown_N2_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 4) ~ N 2) +_test_Rem_RoundHalfDown_N2_N4 = Dict +_test_Div_RoundHalfDown_N2_P1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfDown_N2_P1 = Dict +_test_Rem_RoundHalfDown_N2_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfDown_N2_P1 = Dict +_test_Div_RoundHalfDown_N2_P2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfDown_N2_P2 = Dict +_test_Rem_RoundHalfDown_N2_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfDown_N2_P2 = Dict +_test_Div_RoundHalfDown_N2_P3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfDown_N2_P3 = Dict +_test_Rem_RoundHalfDown_N2_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfDown_N2_P3 = Dict +_test_Div_RoundHalfDown_N2_P4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 4) ~ N 1) +_test_Div_RoundHalfDown_N2_P4 = Dict +_test_Rem_RoundHalfDown_N2_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 4) ~ P 2) +_test_Rem_RoundHalfDown_N2_P4 = Dict +_test_Div_RoundHalfDown_N3_N1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfDown_N3_N1 = Dict +_test_Rem_RoundHalfDown_N3_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfDown_N3_N1 = Dict +_test_Div_RoundHalfDown_N3_N2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 2) ~ P 1) +_test_Div_RoundHalfDown_N3_N2 = Dict +_test_Rem_RoundHalfDown_N3_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 2) ~ N 1) +_test_Rem_RoundHalfDown_N3_N2 = Dict +_test_Div_RoundHalfDown_N3_N3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfDown_N3_N3 = Dict +_test_Rem_RoundHalfDown_N3_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfDown_N3_N3 = Dict +_test_Div_RoundHalfDown_N3_N4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfDown_N3_N4 = Dict +_test_Rem_RoundHalfDown_N3_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfDown_N3_N4 = Dict +_test_Div_RoundHalfDown_N3_P1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfDown_N3_P1 = Dict +_test_Rem_RoundHalfDown_N3_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfDown_N3_P1 = Dict +_test_Div_RoundHalfDown_N3_P2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 2) ~ N 2) +_test_Div_RoundHalfDown_N3_P2 = Dict +_test_Rem_RoundHalfDown_N3_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 2) ~ P 1) +_test_Rem_RoundHalfDown_N3_P2 = Dict +_test_Div_RoundHalfDown_N3_P3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfDown_N3_P3 = Dict +_test_Rem_RoundHalfDown_N3_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfDown_N3_P3 = Dict +_test_Div_RoundHalfDown_N3_P4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfDown_N3_P4 = Dict +_test_Rem_RoundHalfDown_N3_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfDown_N3_P4 = Dict +_test_Div_RoundHalfDown_N4_N1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfDown_N4_N1 = Dict +_test_Rem_RoundHalfDown_N4_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfDown_N4_N1 = Dict +_test_Div_RoundHalfDown_N4_N2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfDown_N4_N2 = Dict +_test_Rem_RoundHalfDown_N4_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfDown_N4_N2 = Dict +_test_Div_RoundHalfDown_N4_N3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfDown_N4_N3 = Dict +_test_Rem_RoundHalfDown_N4_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfDown_N4_N3 = Dict +_test_Div_RoundHalfDown_N4_N4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfDown_N4_N4 = Dict +_test_Rem_RoundHalfDown_N4_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfDown_N4_N4 = Dict +_test_Div_RoundHalfDown_N4_P1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfDown_N4_P1 = Dict +_test_Rem_RoundHalfDown_N4_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfDown_N4_P1 = Dict +_test_Div_RoundHalfDown_N4_P2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfDown_N4_P2 = Dict +_test_Rem_RoundHalfDown_N4_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfDown_N4_P2 = Dict +_test_Div_RoundHalfDown_N4_P3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfDown_N4_P3 = Dict +_test_Rem_RoundHalfDown_N4_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfDown_N4_P3 = Dict +_test_Div_RoundHalfDown_N4_P4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfDown_N4_P4 = Dict +_test_Rem_RoundHalfDown_N4_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfDown_N4_P4 = Dict +_test_Rem_RoundHalfDown_Z_N1 :: Dict (K.Rem 'K.RoundHalfDown Z (N 1) ~ Z) +_test_Rem_RoundHalfDown_Z_N1 = Dict +_test_Rem_RoundHalfDown_Z_N2 :: Dict (K.Rem 'K.RoundHalfDown Z (N 2) ~ Z) +_test_Rem_RoundHalfDown_Z_N2 = Dict +_test_Rem_RoundHalfDown_Z_N3 :: Dict (K.Rem 'K.RoundHalfDown Z (N 3) ~ Z) +_test_Rem_RoundHalfDown_Z_N3 = Dict +_test_Rem_RoundHalfDown_Z_N4 :: Dict (K.Rem 'K.RoundHalfDown Z (N 4) ~ Z) +_test_Rem_RoundHalfDown_Z_N4 = Dict +_test_Rem_RoundHalfDown_Z_P1 :: Dict (K.Rem 'K.RoundHalfDown Z (P 1) ~ Z) +_test_Rem_RoundHalfDown_Z_P1 = Dict +_test_Rem_RoundHalfDown_Z_P2 :: Dict (K.Rem 'K.RoundHalfDown Z (P 2) ~ Z) +_test_Rem_RoundHalfDown_Z_P2 = Dict +_test_Rem_RoundHalfDown_Z_P3 :: Dict (K.Rem 'K.RoundHalfDown Z (P 3) ~ Z) +_test_Rem_RoundHalfDown_Z_P3 = Dict +_test_Rem_RoundHalfDown_Z_P4 :: Dict (K.Rem 'K.RoundHalfDown Z (P 4) ~ Z) +_test_Rem_RoundHalfDown_Z_P4 = Dict +_test_Div_RoundHalfDown_P1_N1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfDown_P1_N1 = Dict +_test_Rem_RoundHalfDown_P1_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfDown_P1_N1 = Dict +_test_Div_RoundHalfDown_P1_N2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 2) ~ N 1) +_test_Div_RoundHalfDown_P1_N2 = Dict +_test_Rem_RoundHalfDown_P1_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 2) ~ N 1) +_test_Rem_RoundHalfDown_P1_N2 = Dict +_test_Div_RoundHalfDown_P1_N3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 3) ~ Z) +_test_Div_RoundHalfDown_P1_N3 = Dict +_test_Rem_RoundHalfDown_P1_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfDown_P1_N3 = Dict +_test_Div_RoundHalfDown_P1_N4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 4) ~ Z) +_test_Div_RoundHalfDown_P1_N4 = Dict +_test_Rem_RoundHalfDown_P1_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfDown_P1_N4 = Dict +_test_Div_RoundHalfDown_P1_P1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfDown_P1_P1 = Dict +_test_Rem_RoundHalfDown_P1_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfDown_P1_P1 = Dict +_test_Div_RoundHalfDown_P1_P2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 2) ~ Z) +_test_Div_RoundHalfDown_P1_P2 = Dict +_test_Rem_RoundHalfDown_P1_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 2) ~ P 1) +_test_Rem_RoundHalfDown_P1_P2 = Dict +_test_Div_RoundHalfDown_P1_P3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 3) ~ Z) +_test_Div_RoundHalfDown_P1_P3 = Dict +_test_Rem_RoundHalfDown_P1_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfDown_P1_P3 = Dict +_test_Div_RoundHalfDown_P1_P4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 4) ~ Z) +_test_Div_RoundHalfDown_P1_P4 = Dict +_test_Rem_RoundHalfDown_P1_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfDown_P1_P4 = Dict +_test_Div_RoundHalfDown_P2_N1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfDown_P2_N1 = Dict +_test_Rem_RoundHalfDown_P2_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfDown_P2_N1 = Dict +_test_Div_RoundHalfDown_P2_N2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfDown_P2_N2 = Dict +_test_Rem_RoundHalfDown_P2_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfDown_P2_N2 = Dict +_test_Div_RoundHalfDown_P2_N3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfDown_P2_N3 = Dict +_test_Rem_RoundHalfDown_P2_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfDown_P2_N3 = Dict +_test_Div_RoundHalfDown_P2_N4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 4) ~ N 1) +_test_Div_RoundHalfDown_P2_N4 = Dict +_test_Rem_RoundHalfDown_P2_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 4) ~ N 2) +_test_Rem_RoundHalfDown_P2_N4 = Dict +_test_Div_RoundHalfDown_P2_P1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfDown_P2_P1 = Dict +_test_Rem_RoundHalfDown_P2_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfDown_P2_P1 = Dict +_test_Div_RoundHalfDown_P2_P2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfDown_P2_P2 = Dict +_test_Rem_RoundHalfDown_P2_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfDown_P2_P2 = Dict +_test_Div_RoundHalfDown_P2_P3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfDown_P2_P3 = Dict +_test_Rem_RoundHalfDown_P2_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfDown_P2_P3 = Dict +_test_Div_RoundHalfDown_P2_P4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 4) ~ Z) +_test_Div_RoundHalfDown_P2_P4 = Dict +_test_Rem_RoundHalfDown_P2_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 4) ~ P 2) +_test_Rem_RoundHalfDown_P2_P4 = Dict +_test_Div_RoundHalfDown_P3_N1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfDown_P3_N1 = Dict +_test_Rem_RoundHalfDown_P3_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfDown_P3_N1 = Dict +_test_Div_RoundHalfDown_P3_N2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 2) ~ N 2) +_test_Div_RoundHalfDown_P3_N2 = Dict +_test_Rem_RoundHalfDown_P3_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 2) ~ N 1) +_test_Rem_RoundHalfDown_P3_N2 = Dict +_test_Div_RoundHalfDown_P3_N3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfDown_P3_N3 = Dict +_test_Rem_RoundHalfDown_P3_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfDown_P3_N3 = Dict +_test_Div_RoundHalfDown_P3_N4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfDown_P3_N4 = Dict +_test_Rem_RoundHalfDown_P3_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfDown_P3_N4 = Dict +_test_Div_RoundHalfDown_P3_P1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfDown_P3_P1 = Dict +_test_Rem_RoundHalfDown_P3_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfDown_P3_P1 = Dict +_test_Div_RoundHalfDown_P3_P2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 2) ~ P 1) +_test_Div_RoundHalfDown_P3_P2 = Dict +_test_Rem_RoundHalfDown_P3_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 2) ~ P 1) +_test_Rem_RoundHalfDown_P3_P2 = Dict +_test_Div_RoundHalfDown_P3_P3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfDown_P3_P3 = Dict +_test_Rem_RoundHalfDown_P3_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfDown_P3_P3 = Dict +_test_Div_RoundHalfDown_P3_P4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfDown_P3_P4 = Dict +_test_Rem_RoundHalfDown_P3_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfDown_P3_P4 = Dict +_test_Div_RoundHalfDown_P4_N1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfDown_P4_N1 = Dict +_test_Rem_RoundHalfDown_P4_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfDown_P4_N1 = Dict +_test_Div_RoundHalfDown_P4_N2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfDown_P4_N2 = Dict +_test_Rem_RoundHalfDown_P4_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfDown_P4_N2 = Dict +_test_Div_RoundHalfDown_P4_N3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfDown_P4_N3 = Dict +_test_Rem_RoundHalfDown_P4_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfDown_P4_N3 = Dict +_test_Div_RoundHalfDown_P4_N4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfDown_P4_N4 = Dict +_test_Rem_RoundHalfDown_P4_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfDown_P4_N4 = Dict +_test_Div_RoundHalfDown_P4_P1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfDown_P4_P1 = Dict +_test_Rem_RoundHalfDown_P4_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfDown_P4_P1 = Dict +_test_Div_RoundHalfDown_P4_P2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfDown_P4_P2 = Dict +_test_Rem_RoundHalfDown_P4_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfDown_P4_P2 = Dict +_test_Div_RoundHalfDown_P4_P3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfDown_P4_P3 = Dict +_test_Rem_RoundHalfDown_P4_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfDown_P4_P3 = Dict +_test_Div_RoundHalfDown_P4_P4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfDown_P4_P4 = Dict +_test_Rem_RoundHalfDown_P4_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfDown_P4_P4 = Dict +_test_Div_RoundHalfEven_N1_N1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfEven_N1_N1 = Dict +_test_Rem_RoundHalfEven_N1_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfEven_N1_N1 = Dict +_test_Div_RoundHalfEven_N1_N2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 2) ~ Z) +_test_Div_RoundHalfEven_N1_N2 = Dict +_test_Rem_RoundHalfEven_N1_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 2) ~ N 1) +_test_Rem_RoundHalfEven_N1_N2 = Dict +_test_Div_RoundHalfEven_N1_N3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 3) ~ Z) +_test_Div_RoundHalfEven_N1_N3 = Dict +_test_Rem_RoundHalfEven_N1_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfEven_N1_N3 = Dict +_test_Div_RoundHalfEven_N1_N4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 4) ~ Z) +_test_Div_RoundHalfEven_N1_N4 = Dict +_test_Rem_RoundHalfEven_N1_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfEven_N1_N4 = Dict +_test_Div_RoundHalfEven_N1_P1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfEven_N1_P1 = Dict +_test_Rem_RoundHalfEven_N1_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfEven_N1_P1 = Dict +_test_Div_RoundHalfEven_N1_P2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 2) ~ Z) +_test_Div_RoundHalfEven_N1_P2 = Dict +_test_Rem_RoundHalfEven_N1_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 2) ~ N 1) +_test_Rem_RoundHalfEven_N1_P2 = Dict +_test_Div_RoundHalfEven_N1_P3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 3) ~ Z) +_test_Div_RoundHalfEven_N1_P3 = Dict +_test_Rem_RoundHalfEven_N1_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfEven_N1_P3 = Dict +_test_Div_RoundHalfEven_N1_P4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 4) ~ Z) +_test_Div_RoundHalfEven_N1_P4 = Dict +_test_Rem_RoundHalfEven_N1_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfEven_N1_P4 = Dict +_test_Div_RoundHalfEven_N2_N1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfEven_N2_N1 = Dict +_test_Rem_RoundHalfEven_N2_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfEven_N2_N1 = Dict +_test_Div_RoundHalfEven_N2_N2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfEven_N2_N2 = Dict +_test_Rem_RoundHalfEven_N2_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfEven_N2_N2 = Dict +_test_Div_RoundHalfEven_N2_N3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfEven_N2_N3 = Dict +_test_Rem_RoundHalfEven_N2_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfEven_N2_N3 = Dict +_test_Div_RoundHalfEven_N2_N4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 4) ~ Z) +_test_Div_RoundHalfEven_N2_N4 = Dict +_test_Rem_RoundHalfEven_N2_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 4) ~ N 2) +_test_Rem_RoundHalfEven_N2_N4 = Dict +_test_Div_RoundHalfEven_N2_P1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfEven_N2_P1 = Dict +_test_Rem_RoundHalfEven_N2_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfEven_N2_P1 = Dict +_test_Div_RoundHalfEven_N2_P2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfEven_N2_P2 = Dict +_test_Rem_RoundHalfEven_N2_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfEven_N2_P2 = Dict +_test_Div_RoundHalfEven_N2_P3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfEven_N2_P3 = Dict +_test_Rem_RoundHalfEven_N2_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfEven_N2_P3 = Dict +_test_Div_RoundHalfEven_N2_P4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 4) ~ Z) +_test_Div_RoundHalfEven_N2_P4 = Dict +_test_Rem_RoundHalfEven_N2_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 4) ~ N 2) +_test_Rem_RoundHalfEven_N2_P4 = Dict +_test_Div_RoundHalfEven_N3_N1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfEven_N3_N1 = Dict +_test_Rem_RoundHalfEven_N3_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfEven_N3_N1 = Dict +_test_Div_RoundHalfEven_N3_N2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 2) ~ P 2) +_test_Div_RoundHalfEven_N3_N2 = Dict +_test_Rem_RoundHalfEven_N3_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 2) ~ P 1) +_test_Rem_RoundHalfEven_N3_N2 = Dict +_test_Div_RoundHalfEven_N3_N3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfEven_N3_N3 = Dict +_test_Rem_RoundHalfEven_N3_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfEven_N3_N3 = Dict +_test_Div_RoundHalfEven_N3_N4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfEven_N3_N4 = Dict +_test_Rem_RoundHalfEven_N3_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfEven_N3_N4 = Dict +_test_Div_RoundHalfEven_N3_P1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfEven_N3_P1 = Dict +_test_Rem_RoundHalfEven_N3_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfEven_N3_P1 = Dict +_test_Div_RoundHalfEven_N3_P2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 2) ~ N 2) +_test_Div_RoundHalfEven_N3_P2 = Dict +_test_Rem_RoundHalfEven_N3_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 2) ~ P 1) +_test_Rem_RoundHalfEven_N3_P2 = Dict +_test_Div_RoundHalfEven_N3_P3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfEven_N3_P3 = Dict +_test_Rem_RoundHalfEven_N3_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfEven_N3_P3 = Dict +_test_Div_RoundHalfEven_N3_P4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfEven_N3_P4 = Dict +_test_Rem_RoundHalfEven_N3_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfEven_N3_P4 = Dict +_test_Div_RoundHalfEven_N4_N1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfEven_N4_N1 = Dict +_test_Rem_RoundHalfEven_N4_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfEven_N4_N1 = Dict +_test_Div_RoundHalfEven_N4_N2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfEven_N4_N2 = Dict +_test_Rem_RoundHalfEven_N4_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfEven_N4_N2 = Dict +_test_Div_RoundHalfEven_N4_N3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfEven_N4_N3 = Dict +_test_Rem_RoundHalfEven_N4_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfEven_N4_N3 = Dict +_test_Div_RoundHalfEven_N4_N4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfEven_N4_N4 = Dict +_test_Rem_RoundHalfEven_N4_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfEven_N4_N4 = Dict +_test_Div_RoundHalfEven_N4_P1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfEven_N4_P1 = Dict +_test_Rem_RoundHalfEven_N4_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfEven_N4_P1 = Dict +_test_Div_RoundHalfEven_N4_P2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfEven_N4_P2 = Dict +_test_Rem_RoundHalfEven_N4_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfEven_N4_P2 = Dict +_test_Div_RoundHalfEven_N4_P3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfEven_N4_P3 = Dict +_test_Rem_RoundHalfEven_N4_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfEven_N4_P3 = Dict +_test_Div_RoundHalfEven_N4_P4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfEven_N4_P4 = Dict +_test_Rem_RoundHalfEven_N4_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfEven_N4_P4 = Dict +_test_Rem_RoundHalfEven_Z_N1 :: Dict (K.Rem 'K.RoundHalfEven Z (N 1) ~ Z) +_test_Rem_RoundHalfEven_Z_N1 = Dict +_test_Rem_RoundHalfEven_Z_N2 :: Dict (K.Rem 'K.RoundHalfEven Z (N 2) ~ Z) +_test_Rem_RoundHalfEven_Z_N2 = Dict +_test_Rem_RoundHalfEven_Z_N3 :: Dict (K.Rem 'K.RoundHalfEven Z (N 3) ~ Z) +_test_Rem_RoundHalfEven_Z_N3 = Dict +_test_Rem_RoundHalfEven_Z_N4 :: Dict (K.Rem 'K.RoundHalfEven Z (N 4) ~ Z) +_test_Rem_RoundHalfEven_Z_N4 = Dict +_test_Rem_RoundHalfEven_Z_P1 :: Dict (K.Rem 'K.RoundHalfEven Z (P 1) ~ Z) +_test_Rem_RoundHalfEven_Z_P1 = Dict +_test_Rem_RoundHalfEven_Z_P2 :: Dict (K.Rem 'K.RoundHalfEven Z (P 2) ~ Z) +_test_Rem_RoundHalfEven_Z_P2 = Dict +_test_Rem_RoundHalfEven_Z_P3 :: Dict (K.Rem 'K.RoundHalfEven Z (P 3) ~ Z) +_test_Rem_RoundHalfEven_Z_P3 = Dict +_test_Rem_RoundHalfEven_Z_P4 :: Dict (K.Rem 'K.RoundHalfEven Z (P 4) ~ Z) +_test_Rem_RoundHalfEven_Z_P4 = Dict +_test_Div_RoundHalfEven_P1_N1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfEven_P1_N1 = Dict +_test_Rem_RoundHalfEven_P1_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfEven_P1_N1 = Dict +_test_Div_RoundHalfEven_P1_N2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 2) ~ Z) +_test_Div_RoundHalfEven_P1_N2 = Dict +_test_Rem_RoundHalfEven_P1_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 2) ~ P 1) +_test_Rem_RoundHalfEven_P1_N2 = Dict +_test_Div_RoundHalfEven_P1_N3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 3) ~ Z) +_test_Div_RoundHalfEven_P1_N3 = Dict +_test_Rem_RoundHalfEven_P1_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfEven_P1_N3 = Dict +_test_Div_RoundHalfEven_P1_N4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 4) ~ Z) +_test_Div_RoundHalfEven_P1_N4 = Dict +_test_Rem_RoundHalfEven_P1_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfEven_P1_N4 = Dict +_test_Div_RoundHalfEven_P1_P1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfEven_P1_P1 = Dict +_test_Rem_RoundHalfEven_P1_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfEven_P1_P1 = Dict +_test_Div_RoundHalfEven_P1_P2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 2) ~ Z) +_test_Div_RoundHalfEven_P1_P2 = Dict +_test_Rem_RoundHalfEven_P1_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 2) ~ P 1) +_test_Rem_RoundHalfEven_P1_P2 = Dict +_test_Div_RoundHalfEven_P1_P3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 3) ~ Z) +_test_Div_RoundHalfEven_P1_P3 = Dict +_test_Rem_RoundHalfEven_P1_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfEven_P1_P3 = Dict +_test_Div_RoundHalfEven_P1_P4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 4) ~ Z) +_test_Div_RoundHalfEven_P1_P4 = Dict +_test_Rem_RoundHalfEven_P1_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfEven_P1_P4 = Dict +_test_Div_RoundHalfEven_P2_N1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfEven_P2_N1 = Dict +_test_Rem_RoundHalfEven_P2_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfEven_P2_N1 = Dict +_test_Div_RoundHalfEven_P2_N2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfEven_P2_N2 = Dict +_test_Rem_RoundHalfEven_P2_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfEven_P2_N2 = Dict +_test_Div_RoundHalfEven_P2_N3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfEven_P2_N3 = Dict +_test_Rem_RoundHalfEven_P2_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfEven_P2_N3 = Dict +_test_Div_RoundHalfEven_P2_N4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 4) ~ Z) +_test_Div_RoundHalfEven_P2_N4 = Dict +_test_Rem_RoundHalfEven_P2_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 4) ~ P 2) +_test_Rem_RoundHalfEven_P2_N4 = Dict +_test_Div_RoundHalfEven_P2_P1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfEven_P2_P1 = Dict +_test_Rem_RoundHalfEven_P2_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfEven_P2_P1 = Dict +_test_Div_RoundHalfEven_P2_P2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfEven_P2_P2 = Dict +_test_Rem_RoundHalfEven_P2_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfEven_P2_P2 = Dict +_test_Div_RoundHalfEven_P2_P3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfEven_P2_P3 = Dict +_test_Rem_RoundHalfEven_P2_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfEven_P2_P3 = Dict +_test_Div_RoundHalfEven_P2_P4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 4) ~ Z) +_test_Div_RoundHalfEven_P2_P4 = Dict +_test_Rem_RoundHalfEven_P2_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 4) ~ P 2) +_test_Rem_RoundHalfEven_P2_P4 = Dict +_test_Div_RoundHalfEven_P3_N1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfEven_P3_N1 = Dict +_test_Rem_RoundHalfEven_P3_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfEven_P3_N1 = Dict +_test_Div_RoundHalfEven_P3_N2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 2) ~ N 2) +_test_Div_RoundHalfEven_P3_N2 = Dict +_test_Rem_RoundHalfEven_P3_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 2) ~ N 1) +_test_Rem_RoundHalfEven_P3_N2 = Dict +_test_Div_RoundHalfEven_P3_N3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfEven_P3_N3 = Dict +_test_Rem_RoundHalfEven_P3_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfEven_P3_N3 = Dict +_test_Div_RoundHalfEven_P3_N4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfEven_P3_N4 = Dict +_test_Rem_RoundHalfEven_P3_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfEven_P3_N4 = Dict +_test_Div_RoundHalfEven_P3_P1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfEven_P3_P1 = Dict +_test_Rem_RoundHalfEven_P3_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfEven_P3_P1 = Dict +_test_Div_RoundHalfEven_P3_P2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 2) ~ P 2) +_test_Div_RoundHalfEven_P3_P2 = Dict +_test_Rem_RoundHalfEven_P3_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 2) ~ N 1) +_test_Rem_RoundHalfEven_P3_P2 = Dict +_test_Div_RoundHalfEven_P3_P3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfEven_P3_P3 = Dict +_test_Rem_RoundHalfEven_P3_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfEven_P3_P3 = Dict +_test_Div_RoundHalfEven_P3_P4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfEven_P3_P4 = Dict +_test_Rem_RoundHalfEven_P3_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfEven_P3_P4 = Dict +_test_Div_RoundHalfEven_P4_N1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfEven_P4_N1 = Dict +_test_Rem_RoundHalfEven_P4_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfEven_P4_N1 = Dict +_test_Div_RoundHalfEven_P4_N2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfEven_P4_N2 = Dict +_test_Rem_RoundHalfEven_P4_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfEven_P4_N2 = Dict +_test_Div_RoundHalfEven_P4_N3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfEven_P4_N3 = Dict +_test_Rem_RoundHalfEven_P4_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfEven_P4_N3 = Dict +_test_Div_RoundHalfEven_P4_N4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfEven_P4_N4 = Dict +_test_Rem_RoundHalfEven_P4_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfEven_P4_N4 = Dict +_test_Div_RoundHalfEven_P4_P1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfEven_P4_P1 = Dict +_test_Rem_RoundHalfEven_P4_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfEven_P4_P1 = Dict +_test_Div_RoundHalfEven_P4_P2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfEven_P4_P2 = Dict +_test_Rem_RoundHalfEven_P4_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfEven_P4_P2 = Dict +_test_Div_RoundHalfEven_P4_P3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfEven_P4_P3 = Dict +_test_Rem_RoundHalfEven_P4_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfEven_P4_P3 = Dict +_test_Div_RoundHalfEven_P4_P4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfEven_P4_P4 = Dict +_test_Rem_RoundHalfEven_P4_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfEven_P4_P4 = Dict +_test_Div_RoundHalfOdd_N1_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfOdd_N1_N1 = Dict +_test_Rem_RoundHalfOdd_N1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_N1_N1 = Dict +_test_Div_RoundHalfOdd_N1_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 2) ~ P 1) +_test_Div_RoundHalfOdd_N1_N2 = Dict +_test_Rem_RoundHalfOdd_N1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 2) ~ P 1) +_test_Rem_RoundHalfOdd_N1_N2 = Dict +_test_Div_RoundHalfOdd_N1_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 3) ~ Z) +_test_Div_RoundHalfOdd_N1_N3 = Dict +_test_Rem_RoundHalfOdd_N1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfOdd_N1_N3 = Dict +_test_Div_RoundHalfOdd_N1_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 4) ~ Z) +_test_Div_RoundHalfOdd_N1_N4 = Dict +_test_Rem_RoundHalfOdd_N1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfOdd_N1_N4 = Dict +_test_Div_RoundHalfOdd_N1_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfOdd_N1_P1 = Dict +_test_Rem_RoundHalfOdd_N1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_N1_P1 = Dict +_test_Div_RoundHalfOdd_N1_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 2) ~ N 1) +_test_Div_RoundHalfOdd_N1_P2 = Dict +_test_Rem_RoundHalfOdd_N1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 2) ~ P 1) +_test_Rem_RoundHalfOdd_N1_P2 = Dict +_test_Div_RoundHalfOdd_N1_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 3) ~ Z) +_test_Div_RoundHalfOdd_N1_P3 = Dict +_test_Rem_RoundHalfOdd_N1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfOdd_N1_P3 = Dict +_test_Div_RoundHalfOdd_N1_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 4) ~ Z) +_test_Div_RoundHalfOdd_N1_P4 = Dict +_test_Rem_RoundHalfOdd_N1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfOdd_N1_P4 = Dict +_test_Div_RoundHalfOdd_N2_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfOdd_N2_N1 = Dict +_test_Rem_RoundHalfOdd_N2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_N2_N1 = Dict +_test_Div_RoundHalfOdd_N2_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfOdd_N2_N2 = Dict +_test_Rem_RoundHalfOdd_N2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfOdd_N2_N2 = Dict +_test_Div_RoundHalfOdd_N2_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfOdd_N2_N3 = Dict +_test_Rem_RoundHalfOdd_N2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfOdd_N2_N3 = Dict +_test_Div_RoundHalfOdd_N2_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 4) ~ P 1) +_test_Div_RoundHalfOdd_N2_N4 = Dict +_test_Rem_RoundHalfOdd_N2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 4) ~ P 2) +_test_Rem_RoundHalfOdd_N2_N4 = Dict +_test_Div_RoundHalfOdd_N2_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfOdd_N2_P1 = Dict +_test_Rem_RoundHalfOdd_N2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_N2_P1 = Dict +_test_Div_RoundHalfOdd_N2_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfOdd_N2_P2 = Dict +_test_Rem_RoundHalfOdd_N2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfOdd_N2_P2 = Dict +_test_Div_RoundHalfOdd_N2_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfOdd_N2_P3 = Dict +_test_Rem_RoundHalfOdd_N2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfOdd_N2_P3 = Dict +_test_Div_RoundHalfOdd_N2_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 4) ~ N 1) +_test_Div_RoundHalfOdd_N2_P4 = Dict +_test_Rem_RoundHalfOdd_N2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 4) ~ P 2) +_test_Rem_RoundHalfOdd_N2_P4 = Dict +_test_Div_RoundHalfOdd_N3_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfOdd_N3_N1 = Dict +_test_Rem_RoundHalfOdd_N3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_N3_N1 = Dict +_test_Div_RoundHalfOdd_N3_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 2) ~ P 1) +_test_Div_RoundHalfOdd_N3_N2 = Dict +_test_Rem_RoundHalfOdd_N3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 2) ~ N 1) +_test_Rem_RoundHalfOdd_N3_N2 = Dict +_test_Div_RoundHalfOdd_N3_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfOdd_N3_N3 = Dict +_test_Rem_RoundHalfOdd_N3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfOdd_N3_N3 = Dict +_test_Div_RoundHalfOdd_N3_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfOdd_N3_N4 = Dict +_test_Rem_RoundHalfOdd_N3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfOdd_N3_N4 = Dict +_test_Div_RoundHalfOdd_N3_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfOdd_N3_P1 = Dict +_test_Rem_RoundHalfOdd_N3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_N3_P1 = Dict +_test_Div_RoundHalfOdd_N3_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 2) ~ N 1) +_test_Div_RoundHalfOdd_N3_P2 = Dict +_test_Rem_RoundHalfOdd_N3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 2) ~ N 1) +_test_Rem_RoundHalfOdd_N3_P2 = Dict +_test_Div_RoundHalfOdd_N3_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfOdd_N3_P3 = Dict +_test_Rem_RoundHalfOdd_N3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfOdd_N3_P3 = Dict +_test_Div_RoundHalfOdd_N3_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfOdd_N3_P4 = Dict +_test_Rem_RoundHalfOdd_N3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfOdd_N3_P4 = Dict +_test_Div_RoundHalfOdd_N4_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfOdd_N4_N1 = Dict +_test_Rem_RoundHalfOdd_N4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_N4_N1 = Dict +_test_Div_RoundHalfOdd_N4_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfOdd_N4_N2 = Dict +_test_Rem_RoundHalfOdd_N4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfOdd_N4_N2 = Dict +_test_Div_RoundHalfOdd_N4_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfOdd_N4_N3 = Dict +_test_Rem_RoundHalfOdd_N4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfOdd_N4_N3 = Dict +_test_Div_RoundHalfOdd_N4_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfOdd_N4_N4 = Dict +_test_Rem_RoundHalfOdd_N4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfOdd_N4_N4 = Dict +_test_Div_RoundHalfOdd_N4_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfOdd_N4_P1 = Dict +_test_Rem_RoundHalfOdd_N4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_N4_P1 = Dict +_test_Div_RoundHalfOdd_N4_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfOdd_N4_P2 = Dict +_test_Rem_RoundHalfOdd_N4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfOdd_N4_P2 = Dict +_test_Div_RoundHalfOdd_N4_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfOdd_N4_P3 = Dict +_test_Rem_RoundHalfOdd_N4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfOdd_N4_P3 = Dict +_test_Div_RoundHalfOdd_N4_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfOdd_N4_P4 = Dict +_test_Rem_RoundHalfOdd_N4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfOdd_N4_P4 = Dict +_test_Rem_RoundHalfOdd_Z_N1 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 1) ~ Z) +_test_Rem_RoundHalfOdd_Z_N1 = Dict +_test_Rem_RoundHalfOdd_Z_N2 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 2) ~ Z) +_test_Rem_RoundHalfOdd_Z_N2 = Dict +_test_Rem_RoundHalfOdd_Z_N3 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 3) ~ Z) +_test_Rem_RoundHalfOdd_Z_N3 = Dict +_test_Rem_RoundHalfOdd_Z_N4 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 4) ~ Z) +_test_Rem_RoundHalfOdd_Z_N4 = Dict +_test_Rem_RoundHalfOdd_Z_P1 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 1) ~ Z) +_test_Rem_RoundHalfOdd_Z_P1 = Dict +_test_Rem_RoundHalfOdd_Z_P2 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 2) ~ Z) +_test_Rem_RoundHalfOdd_Z_P2 = Dict +_test_Rem_RoundHalfOdd_Z_P3 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 3) ~ Z) +_test_Rem_RoundHalfOdd_Z_P3 = Dict +_test_Rem_RoundHalfOdd_Z_P4 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 4) ~ Z) +_test_Rem_RoundHalfOdd_Z_P4 = Dict +_test_Div_RoundHalfOdd_P1_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfOdd_P1_N1 = Dict +_test_Rem_RoundHalfOdd_P1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_P1_N1 = Dict +_test_Div_RoundHalfOdd_P1_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 2) ~ N 1) +_test_Div_RoundHalfOdd_P1_N2 = Dict +_test_Rem_RoundHalfOdd_P1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 2) ~ N 1) +_test_Rem_RoundHalfOdd_P1_N2 = Dict +_test_Div_RoundHalfOdd_P1_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 3) ~ Z) +_test_Div_RoundHalfOdd_P1_N3 = Dict +_test_Rem_RoundHalfOdd_P1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfOdd_P1_N3 = Dict +_test_Div_RoundHalfOdd_P1_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 4) ~ Z) +_test_Div_RoundHalfOdd_P1_N4 = Dict +_test_Rem_RoundHalfOdd_P1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfOdd_P1_N4 = Dict +_test_Div_RoundHalfOdd_P1_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfOdd_P1_P1 = Dict +_test_Rem_RoundHalfOdd_P1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_P1_P1 = Dict +_test_Div_RoundHalfOdd_P1_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 2) ~ P 1) +_test_Div_RoundHalfOdd_P1_P2 = Dict +_test_Rem_RoundHalfOdd_P1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 2) ~ N 1) +_test_Rem_RoundHalfOdd_P1_P2 = Dict +_test_Div_RoundHalfOdd_P1_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 3) ~ Z) +_test_Div_RoundHalfOdd_P1_P3 = Dict +_test_Rem_RoundHalfOdd_P1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfOdd_P1_P3 = Dict +_test_Div_RoundHalfOdd_P1_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 4) ~ Z) +_test_Div_RoundHalfOdd_P1_P4 = Dict +_test_Rem_RoundHalfOdd_P1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfOdd_P1_P4 = Dict +_test_Div_RoundHalfOdd_P2_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfOdd_P2_N1 = Dict +_test_Rem_RoundHalfOdd_P2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_P2_N1 = Dict +_test_Div_RoundHalfOdd_P2_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfOdd_P2_N2 = Dict +_test_Rem_RoundHalfOdd_P2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfOdd_P2_N2 = Dict +_test_Div_RoundHalfOdd_P2_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfOdd_P2_N3 = Dict +_test_Rem_RoundHalfOdd_P2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfOdd_P2_N3 = Dict +_test_Div_RoundHalfOdd_P2_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 4) ~ N 1) +_test_Div_RoundHalfOdd_P2_N4 = Dict +_test_Rem_RoundHalfOdd_P2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 4) ~ N 2) +_test_Rem_RoundHalfOdd_P2_N4 = Dict +_test_Div_RoundHalfOdd_P2_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfOdd_P2_P1 = Dict +_test_Rem_RoundHalfOdd_P2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_P2_P1 = Dict +_test_Div_RoundHalfOdd_P2_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfOdd_P2_P2 = Dict +_test_Rem_RoundHalfOdd_P2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfOdd_P2_P2 = Dict +_test_Div_RoundHalfOdd_P2_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfOdd_P2_P3 = Dict +_test_Rem_RoundHalfOdd_P2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfOdd_P2_P3 = Dict +_test_Div_RoundHalfOdd_P2_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 4) ~ P 1) +_test_Div_RoundHalfOdd_P2_P4 = Dict +_test_Rem_RoundHalfOdd_P2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 4) ~ N 2) +_test_Rem_RoundHalfOdd_P2_P4 = Dict +_test_Div_RoundHalfOdd_P3_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfOdd_P3_N1 = Dict +_test_Rem_RoundHalfOdd_P3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_P3_N1 = Dict +_test_Div_RoundHalfOdd_P3_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 2) ~ N 1) +_test_Div_RoundHalfOdd_P3_N2 = Dict +_test_Rem_RoundHalfOdd_P3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 2) ~ P 1) +_test_Rem_RoundHalfOdd_P3_N2 = Dict +_test_Div_RoundHalfOdd_P3_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfOdd_P3_N3 = Dict +_test_Rem_RoundHalfOdd_P3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfOdd_P3_N3 = Dict +_test_Div_RoundHalfOdd_P3_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfOdd_P3_N4 = Dict +_test_Rem_RoundHalfOdd_P3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfOdd_P3_N4 = Dict +_test_Div_RoundHalfOdd_P3_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfOdd_P3_P1 = Dict +_test_Rem_RoundHalfOdd_P3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_P3_P1 = Dict +_test_Div_RoundHalfOdd_P3_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 2) ~ P 1) +_test_Div_RoundHalfOdd_P3_P2 = Dict +_test_Rem_RoundHalfOdd_P3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 2) ~ P 1) +_test_Rem_RoundHalfOdd_P3_P2 = Dict +_test_Div_RoundHalfOdd_P3_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfOdd_P3_P3 = Dict +_test_Rem_RoundHalfOdd_P3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfOdd_P3_P3 = Dict +_test_Div_RoundHalfOdd_P3_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfOdd_P3_P4 = Dict +_test_Rem_RoundHalfOdd_P3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfOdd_P3_P4 = Dict +_test_Div_RoundHalfOdd_P4_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfOdd_P4_N1 = Dict +_test_Rem_RoundHalfOdd_P4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfOdd_P4_N1 = Dict +_test_Div_RoundHalfOdd_P4_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfOdd_P4_N2 = Dict +_test_Rem_RoundHalfOdd_P4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfOdd_P4_N2 = Dict +_test_Div_RoundHalfOdd_P4_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfOdd_P4_N3 = Dict +_test_Rem_RoundHalfOdd_P4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfOdd_P4_N3 = Dict +_test_Div_RoundHalfOdd_P4_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfOdd_P4_N4 = Dict +_test_Rem_RoundHalfOdd_P4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfOdd_P4_N4 = Dict +_test_Div_RoundHalfOdd_P4_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfOdd_P4_P1 = Dict +_test_Rem_RoundHalfOdd_P4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfOdd_P4_P1 = Dict +_test_Div_RoundHalfOdd_P4_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfOdd_P4_P2 = Dict +_test_Rem_RoundHalfOdd_P4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfOdd_P4_P2 = Dict +_test_Div_RoundHalfOdd_P4_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfOdd_P4_P3 = Dict +_test_Rem_RoundHalfOdd_P4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfOdd_P4_P3 = Dict +_test_Div_RoundHalfOdd_P4_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfOdd_P4_P4 = Dict +_test_Rem_RoundHalfOdd_P4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfOdd_P4_P4 = Dict +_test_Div_RoundHalfUp_N1_N1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfUp_N1_N1 = Dict +_test_Rem_RoundHalfUp_N1_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfUp_N1_N1 = Dict +_test_Div_RoundHalfUp_N1_N2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 2) ~ P 1) +_test_Div_RoundHalfUp_N1_N2 = Dict +_test_Rem_RoundHalfUp_N1_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 2) ~ P 1) +_test_Rem_RoundHalfUp_N1_N2 = Dict +_test_Div_RoundHalfUp_N1_N3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 3) ~ Z) +_test_Div_RoundHalfUp_N1_N3 = Dict +_test_Rem_RoundHalfUp_N1_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfUp_N1_N3 = Dict +_test_Div_RoundHalfUp_N1_N4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 4) ~ Z) +_test_Div_RoundHalfUp_N1_N4 = Dict +_test_Rem_RoundHalfUp_N1_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfUp_N1_N4 = Dict +_test_Div_RoundHalfUp_N1_P1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfUp_N1_P1 = Dict +_test_Rem_RoundHalfUp_N1_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfUp_N1_P1 = Dict +_test_Div_RoundHalfUp_N1_P2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 2) ~ Z) +_test_Div_RoundHalfUp_N1_P2 = Dict +_test_Rem_RoundHalfUp_N1_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 2) ~ N 1) +_test_Rem_RoundHalfUp_N1_P2 = Dict +_test_Div_RoundHalfUp_N1_P3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 3) ~ Z) +_test_Div_RoundHalfUp_N1_P3 = Dict +_test_Rem_RoundHalfUp_N1_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfUp_N1_P3 = Dict +_test_Div_RoundHalfUp_N1_P4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 4) ~ Z) +_test_Div_RoundHalfUp_N1_P4 = Dict +_test_Rem_RoundHalfUp_N1_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfUp_N1_P4 = Dict +_test_Div_RoundHalfUp_N2_N1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfUp_N2_N1 = Dict +_test_Rem_RoundHalfUp_N2_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfUp_N2_N1 = Dict +_test_Div_RoundHalfUp_N2_N2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfUp_N2_N2 = Dict +_test_Rem_RoundHalfUp_N2_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfUp_N2_N2 = Dict +_test_Div_RoundHalfUp_N2_N3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfUp_N2_N3 = Dict +_test_Rem_RoundHalfUp_N2_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfUp_N2_N3 = Dict +_test_Div_RoundHalfUp_N2_N4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 4) ~ P 1) +_test_Div_RoundHalfUp_N2_N4 = Dict +_test_Rem_RoundHalfUp_N2_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 4) ~ P 2) +_test_Rem_RoundHalfUp_N2_N4 = Dict +_test_Div_RoundHalfUp_N2_P1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfUp_N2_P1 = Dict +_test_Rem_RoundHalfUp_N2_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfUp_N2_P1 = Dict +_test_Div_RoundHalfUp_N2_P2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfUp_N2_P2 = Dict +_test_Rem_RoundHalfUp_N2_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfUp_N2_P2 = Dict +_test_Div_RoundHalfUp_N2_P3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfUp_N2_P3 = Dict +_test_Rem_RoundHalfUp_N2_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfUp_N2_P3 = Dict +_test_Div_RoundHalfUp_N2_P4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 4) ~ Z) +_test_Div_RoundHalfUp_N2_P4 = Dict +_test_Rem_RoundHalfUp_N2_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 4) ~ N 2) +_test_Rem_RoundHalfUp_N2_P4 = Dict +_test_Div_RoundHalfUp_N3_N1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfUp_N3_N1 = Dict +_test_Rem_RoundHalfUp_N3_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfUp_N3_N1 = Dict +_test_Div_RoundHalfUp_N3_N2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 2) ~ P 2) +_test_Div_RoundHalfUp_N3_N2 = Dict +_test_Rem_RoundHalfUp_N3_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 2) ~ P 1) +_test_Rem_RoundHalfUp_N3_N2 = Dict +_test_Div_RoundHalfUp_N3_N3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfUp_N3_N3 = Dict +_test_Rem_RoundHalfUp_N3_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfUp_N3_N3 = Dict +_test_Div_RoundHalfUp_N3_N4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfUp_N3_N4 = Dict +_test_Rem_RoundHalfUp_N3_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfUp_N3_N4 = Dict +_test_Div_RoundHalfUp_N3_P1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfUp_N3_P1 = Dict +_test_Rem_RoundHalfUp_N3_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfUp_N3_P1 = Dict +_test_Div_RoundHalfUp_N3_P2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 2) ~ N 1) +_test_Div_RoundHalfUp_N3_P2 = Dict +_test_Rem_RoundHalfUp_N3_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 2) ~ N 1) +_test_Rem_RoundHalfUp_N3_P2 = Dict +_test_Div_RoundHalfUp_N3_P3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfUp_N3_P3 = Dict +_test_Rem_RoundHalfUp_N3_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfUp_N3_P3 = Dict +_test_Div_RoundHalfUp_N3_P4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfUp_N3_P4 = Dict +_test_Rem_RoundHalfUp_N3_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfUp_N3_P4 = Dict +_test_Div_RoundHalfUp_N4_N1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfUp_N4_N1 = Dict +_test_Rem_RoundHalfUp_N4_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfUp_N4_N1 = Dict +_test_Div_RoundHalfUp_N4_N2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfUp_N4_N2 = Dict +_test_Rem_RoundHalfUp_N4_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfUp_N4_N2 = Dict +_test_Div_RoundHalfUp_N4_N3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfUp_N4_N3 = Dict +_test_Rem_RoundHalfUp_N4_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfUp_N4_N3 = Dict +_test_Div_RoundHalfUp_N4_N4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfUp_N4_N4 = Dict +_test_Rem_RoundHalfUp_N4_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfUp_N4_N4 = Dict +_test_Div_RoundHalfUp_N4_P1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfUp_N4_P1 = Dict +_test_Rem_RoundHalfUp_N4_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfUp_N4_P1 = Dict +_test_Div_RoundHalfUp_N4_P2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfUp_N4_P2 = Dict +_test_Rem_RoundHalfUp_N4_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfUp_N4_P2 = Dict +_test_Div_RoundHalfUp_N4_P3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfUp_N4_P3 = Dict +_test_Rem_RoundHalfUp_N4_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfUp_N4_P3 = Dict +_test_Div_RoundHalfUp_N4_P4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfUp_N4_P4 = Dict +_test_Rem_RoundHalfUp_N4_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfUp_N4_P4 = Dict +_test_Rem_RoundHalfUp_Z_N1 :: Dict (K.Rem 'K.RoundHalfUp Z (N 1) ~ Z) +_test_Rem_RoundHalfUp_Z_N1 = Dict +_test_Rem_RoundHalfUp_Z_N2 :: Dict (K.Rem 'K.RoundHalfUp Z (N 2) ~ Z) +_test_Rem_RoundHalfUp_Z_N2 = Dict +_test_Rem_RoundHalfUp_Z_N3 :: Dict (K.Rem 'K.RoundHalfUp Z (N 3) ~ Z) +_test_Rem_RoundHalfUp_Z_N3 = Dict +_test_Rem_RoundHalfUp_Z_N4 :: Dict (K.Rem 'K.RoundHalfUp Z (N 4) ~ Z) +_test_Rem_RoundHalfUp_Z_N4 = Dict +_test_Rem_RoundHalfUp_Z_P1 :: Dict (K.Rem 'K.RoundHalfUp Z (P 1) ~ Z) +_test_Rem_RoundHalfUp_Z_P1 = Dict +_test_Rem_RoundHalfUp_Z_P2 :: Dict (K.Rem 'K.RoundHalfUp Z (P 2) ~ Z) +_test_Rem_RoundHalfUp_Z_P2 = Dict +_test_Rem_RoundHalfUp_Z_P3 :: Dict (K.Rem 'K.RoundHalfUp Z (P 3) ~ Z) +_test_Rem_RoundHalfUp_Z_P3 = Dict +_test_Rem_RoundHalfUp_Z_P4 :: Dict (K.Rem 'K.RoundHalfUp Z (P 4) ~ Z) +_test_Rem_RoundHalfUp_Z_P4 = Dict +_test_Div_RoundHalfUp_P1_N1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfUp_P1_N1 = Dict +_test_Rem_RoundHalfUp_P1_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfUp_P1_N1 = Dict +_test_Div_RoundHalfUp_P1_N2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 2) ~ Z) +_test_Div_RoundHalfUp_P1_N2 = Dict +_test_Rem_RoundHalfUp_P1_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 2) ~ P 1) +_test_Rem_RoundHalfUp_P1_N2 = Dict +_test_Div_RoundHalfUp_P1_N3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 3) ~ Z) +_test_Div_RoundHalfUp_P1_N3 = Dict +_test_Rem_RoundHalfUp_P1_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfUp_P1_N3 = Dict +_test_Div_RoundHalfUp_P1_N4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 4) ~ Z) +_test_Div_RoundHalfUp_P1_N4 = Dict +_test_Rem_RoundHalfUp_P1_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfUp_P1_N4 = Dict +_test_Div_RoundHalfUp_P1_P1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfUp_P1_P1 = Dict +_test_Rem_RoundHalfUp_P1_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfUp_P1_P1 = Dict +_test_Div_RoundHalfUp_P1_P2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 2) ~ P 1) +_test_Div_RoundHalfUp_P1_P2 = Dict +_test_Rem_RoundHalfUp_P1_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 2) ~ N 1) +_test_Rem_RoundHalfUp_P1_P2 = Dict +_test_Div_RoundHalfUp_P1_P3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 3) ~ Z) +_test_Div_RoundHalfUp_P1_P3 = Dict +_test_Rem_RoundHalfUp_P1_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfUp_P1_P3 = Dict +_test_Div_RoundHalfUp_P1_P4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 4) ~ Z) +_test_Div_RoundHalfUp_P1_P4 = Dict +_test_Rem_RoundHalfUp_P1_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfUp_P1_P4 = Dict +_test_Div_RoundHalfUp_P2_N1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfUp_P2_N1 = Dict +_test_Rem_RoundHalfUp_P2_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfUp_P2_N1 = Dict +_test_Div_RoundHalfUp_P2_N2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfUp_P2_N2 = Dict +_test_Rem_RoundHalfUp_P2_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfUp_P2_N2 = Dict +_test_Div_RoundHalfUp_P2_N3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfUp_P2_N3 = Dict +_test_Rem_RoundHalfUp_P2_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfUp_P2_N3 = Dict +_test_Div_RoundHalfUp_P2_N4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 4) ~ Z) +_test_Div_RoundHalfUp_P2_N4 = Dict +_test_Rem_RoundHalfUp_P2_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 4) ~ P 2) +_test_Rem_RoundHalfUp_P2_N4 = Dict +_test_Div_RoundHalfUp_P2_P1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfUp_P2_P1 = Dict +_test_Rem_RoundHalfUp_P2_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfUp_P2_P1 = Dict +_test_Div_RoundHalfUp_P2_P2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfUp_P2_P2 = Dict +_test_Rem_RoundHalfUp_P2_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfUp_P2_P2 = Dict +_test_Div_RoundHalfUp_P2_P3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfUp_P2_P3 = Dict +_test_Rem_RoundHalfUp_P2_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfUp_P2_P3 = Dict +_test_Div_RoundHalfUp_P2_P4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 4) ~ P 1) +_test_Div_RoundHalfUp_P2_P4 = Dict +_test_Rem_RoundHalfUp_P2_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 4) ~ N 2) +_test_Rem_RoundHalfUp_P2_P4 = Dict +_test_Div_RoundHalfUp_P3_N1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfUp_P3_N1 = Dict +_test_Rem_RoundHalfUp_P3_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfUp_P3_N1 = Dict +_test_Div_RoundHalfUp_P3_N2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 2) ~ N 1) +_test_Div_RoundHalfUp_P3_N2 = Dict +_test_Rem_RoundHalfUp_P3_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 2) ~ P 1) +_test_Rem_RoundHalfUp_P3_N2 = Dict +_test_Div_RoundHalfUp_P3_N3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfUp_P3_N3 = Dict +_test_Rem_RoundHalfUp_P3_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfUp_P3_N3 = Dict +_test_Div_RoundHalfUp_P3_N4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfUp_P3_N4 = Dict +_test_Rem_RoundHalfUp_P3_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfUp_P3_N4 = Dict +_test_Div_RoundHalfUp_P3_P1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfUp_P3_P1 = Dict +_test_Rem_RoundHalfUp_P3_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfUp_P3_P1 = Dict +_test_Div_RoundHalfUp_P3_P2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 2) ~ P 2) +_test_Div_RoundHalfUp_P3_P2 = Dict +_test_Rem_RoundHalfUp_P3_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 2) ~ N 1) +_test_Rem_RoundHalfUp_P3_P2 = Dict +_test_Div_RoundHalfUp_P3_P3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfUp_P3_P3 = Dict +_test_Rem_RoundHalfUp_P3_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfUp_P3_P3 = Dict +_test_Div_RoundHalfUp_P3_P4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfUp_P3_P4 = Dict +_test_Rem_RoundHalfUp_P3_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfUp_P3_P4 = Dict +_test_Div_RoundHalfUp_P4_N1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfUp_P4_N1 = Dict +_test_Rem_RoundHalfUp_P4_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfUp_P4_N1 = Dict +_test_Div_RoundHalfUp_P4_N2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfUp_P4_N2 = Dict +_test_Rem_RoundHalfUp_P4_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfUp_P4_N2 = Dict +_test_Div_RoundHalfUp_P4_N3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfUp_P4_N3 = Dict +_test_Rem_RoundHalfUp_P4_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfUp_P4_N3 = Dict +_test_Div_RoundHalfUp_P4_N4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfUp_P4_N4 = Dict +_test_Rem_RoundHalfUp_P4_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfUp_P4_N4 = Dict +_test_Div_RoundHalfUp_P4_P1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfUp_P4_P1 = Dict +_test_Rem_RoundHalfUp_P4_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfUp_P4_P1 = Dict +_test_Div_RoundHalfUp_P4_P2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfUp_P4_P2 = Dict +_test_Rem_RoundHalfUp_P4_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfUp_P4_P2 = Dict +_test_Div_RoundHalfUp_P4_P3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfUp_P4_P3 = Dict +_test_Rem_RoundHalfUp_P4_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfUp_P4_P3 = Dict +_test_Div_RoundHalfUp_P4_P4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfUp_P4_P4 = Dict +_test_Rem_RoundHalfUp_P4_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfUp_P4_P4 = Dict +_test_Div_RoundHalfZero_N1_N1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 1) ~ P 1) +_test_Div_RoundHalfZero_N1_N1 = Dict +_test_Rem_RoundHalfZero_N1_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 1) ~ Z) +_test_Rem_RoundHalfZero_N1_N1 = Dict +_test_Div_RoundHalfZero_N1_N2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 2) ~ Z) +_test_Div_RoundHalfZero_N1_N2 = Dict +_test_Rem_RoundHalfZero_N1_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 2) ~ N 1) +_test_Rem_RoundHalfZero_N1_N2 = Dict +_test_Div_RoundHalfZero_N1_N3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 3) ~ Z) +_test_Div_RoundHalfZero_N1_N3 = Dict +_test_Rem_RoundHalfZero_N1_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 3) ~ N 1) +_test_Rem_RoundHalfZero_N1_N3 = Dict +_test_Div_RoundHalfZero_N1_N4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 4) ~ Z) +_test_Div_RoundHalfZero_N1_N4 = Dict +_test_Rem_RoundHalfZero_N1_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 4) ~ N 1) +_test_Rem_RoundHalfZero_N1_N4 = Dict +_test_Div_RoundHalfZero_N1_P1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 1) ~ N 1) +_test_Div_RoundHalfZero_N1_P1 = Dict +_test_Rem_RoundHalfZero_N1_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 1) ~ Z) +_test_Rem_RoundHalfZero_N1_P1 = Dict +_test_Div_RoundHalfZero_N1_P2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 2) ~ Z) +_test_Div_RoundHalfZero_N1_P2 = Dict +_test_Rem_RoundHalfZero_N1_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 2) ~ N 1) +_test_Rem_RoundHalfZero_N1_P2 = Dict +_test_Div_RoundHalfZero_N1_P3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 3) ~ Z) +_test_Div_RoundHalfZero_N1_P3 = Dict +_test_Rem_RoundHalfZero_N1_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 3) ~ N 1) +_test_Rem_RoundHalfZero_N1_P3 = Dict +_test_Div_RoundHalfZero_N1_P4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 4) ~ Z) +_test_Div_RoundHalfZero_N1_P4 = Dict +_test_Rem_RoundHalfZero_N1_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 4) ~ N 1) +_test_Rem_RoundHalfZero_N1_P4 = Dict +_test_Div_RoundHalfZero_N2_N1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 1) ~ P 2) +_test_Div_RoundHalfZero_N2_N1 = Dict +_test_Rem_RoundHalfZero_N2_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 1) ~ Z) +_test_Rem_RoundHalfZero_N2_N1 = Dict +_test_Div_RoundHalfZero_N2_N2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 2) ~ P 1) +_test_Div_RoundHalfZero_N2_N2 = Dict +_test_Rem_RoundHalfZero_N2_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 2) ~ Z) +_test_Rem_RoundHalfZero_N2_N2 = Dict +_test_Div_RoundHalfZero_N2_N3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 3) ~ P 1) +_test_Div_RoundHalfZero_N2_N3 = Dict +_test_Rem_RoundHalfZero_N2_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 3) ~ P 1) +_test_Rem_RoundHalfZero_N2_N3 = Dict +_test_Div_RoundHalfZero_N2_N4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 4) ~ Z) +_test_Div_RoundHalfZero_N2_N4 = Dict +_test_Rem_RoundHalfZero_N2_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 4) ~ N 2) +_test_Rem_RoundHalfZero_N2_N4 = Dict +_test_Div_RoundHalfZero_N2_P1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 1) ~ N 2) +_test_Div_RoundHalfZero_N2_P1 = Dict +_test_Rem_RoundHalfZero_N2_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 1) ~ Z) +_test_Rem_RoundHalfZero_N2_P1 = Dict +_test_Div_RoundHalfZero_N2_P2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 2) ~ N 1) +_test_Div_RoundHalfZero_N2_P2 = Dict +_test_Rem_RoundHalfZero_N2_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 2) ~ Z) +_test_Rem_RoundHalfZero_N2_P2 = Dict +_test_Div_RoundHalfZero_N2_P3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 3) ~ N 1) +_test_Div_RoundHalfZero_N2_P3 = Dict +_test_Rem_RoundHalfZero_N2_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 3) ~ P 1) +_test_Rem_RoundHalfZero_N2_P3 = Dict +_test_Div_RoundHalfZero_N2_P4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 4) ~ Z) +_test_Div_RoundHalfZero_N2_P4 = Dict +_test_Rem_RoundHalfZero_N2_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 4) ~ N 2) +_test_Rem_RoundHalfZero_N2_P4 = Dict +_test_Div_RoundHalfZero_N3_N1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 1) ~ P 3) +_test_Div_RoundHalfZero_N3_N1 = Dict +_test_Rem_RoundHalfZero_N3_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 1) ~ Z) +_test_Rem_RoundHalfZero_N3_N1 = Dict +_test_Div_RoundHalfZero_N3_N2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 2) ~ P 1) +_test_Div_RoundHalfZero_N3_N2 = Dict +_test_Rem_RoundHalfZero_N3_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 2) ~ N 1) +_test_Rem_RoundHalfZero_N3_N2 = Dict +_test_Div_RoundHalfZero_N3_N3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 3) ~ P 1) +_test_Div_RoundHalfZero_N3_N3 = Dict +_test_Rem_RoundHalfZero_N3_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 3) ~ Z) +_test_Rem_RoundHalfZero_N3_N3 = Dict +_test_Div_RoundHalfZero_N3_N4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 4) ~ P 1) +_test_Div_RoundHalfZero_N3_N4 = Dict +_test_Rem_RoundHalfZero_N3_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 4) ~ P 1) +_test_Rem_RoundHalfZero_N3_N4 = Dict +_test_Div_RoundHalfZero_N3_P1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 1) ~ N 3) +_test_Div_RoundHalfZero_N3_P1 = Dict +_test_Rem_RoundHalfZero_N3_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 1) ~ Z) +_test_Rem_RoundHalfZero_N3_P1 = Dict +_test_Div_RoundHalfZero_N3_P2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 2) ~ N 1) +_test_Div_RoundHalfZero_N3_P2 = Dict +_test_Rem_RoundHalfZero_N3_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 2) ~ N 1) +_test_Rem_RoundHalfZero_N3_P2 = Dict +_test_Div_RoundHalfZero_N3_P3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 3) ~ N 1) +_test_Div_RoundHalfZero_N3_P3 = Dict +_test_Rem_RoundHalfZero_N3_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 3) ~ Z) +_test_Rem_RoundHalfZero_N3_P3 = Dict +_test_Div_RoundHalfZero_N3_P4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 4) ~ N 1) +_test_Div_RoundHalfZero_N3_P4 = Dict +_test_Rem_RoundHalfZero_N3_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 4) ~ P 1) +_test_Rem_RoundHalfZero_N3_P4 = Dict +_test_Div_RoundHalfZero_N4_N1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 1) ~ P 4) +_test_Div_RoundHalfZero_N4_N1 = Dict +_test_Rem_RoundHalfZero_N4_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 1) ~ Z) +_test_Rem_RoundHalfZero_N4_N1 = Dict +_test_Div_RoundHalfZero_N4_N2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 2) ~ P 2) +_test_Div_RoundHalfZero_N4_N2 = Dict +_test_Rem_RoundHalfZero_N4_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 2) ~ Z) +_test_Rem_RoundHalfZero_N4_N2 = Dict +_test_Div_RoundHalfZero_N4_N3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 3) ~ P 1) +_test_Div_RoundHalfZero_N4_N3 = Dict +_test_Rem_RoundHalfZero_N4_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 3) ~ N 1) +_test_Rem_RoundHalfZero_N4_N3 = Dict +_test_Div_RoundHalfZero_N4_N4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 4) ~ P 1) +_test_Div_RoundHalfZero_N4_N4 = Dict +_test_Rem_RoundHalfZero_N4_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 4) ~ Z) +_test_Rem_RoundHalfZero_N4_N4 = Dict +_test_Div_RoundHalfZero_N4_P1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 1) ~ N 4) +_test_Div_RoundHalfZero_N4_P1 = Dict +_test_Rem_RoundHalfZero_N4_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 1) ~ Z) +_test_Rem_RoundHalfZero_N4_P1 = Dict +_test_Div_RoundHalfZero_N4_P2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 2) ~ N 2) +_test_Div_RoundHalfZero_N4_P2 = Dict +_test_Rem_RoundHalfZero_N4_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 2) ~ Z) +_test_Rem_RoundHalfZero_N4_P2 = Dict +_test_Div_RoundHalfZero_N4_P3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 3) ~ N 1) +_test_Div_RoundHalfZero_N4_P3 = Dict +_test_Rem_RoundHalfZero_N4_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 3) ~ N 1) +_test_Rem_RoundHalfZero_N4_P3 = Dict +_test_Div_RoundHalfZero_N4_P4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 4) ~ N 1) +_test_Div_RoundHalfZero_N4_P4 = Dict +_test_Rem_RoundHalfZero_N4_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 4) ~ Z) +_test_Rem_RoundHalfZero_N4_P4 = Dict +_test_Rem_RoundHalfZero_Z_N1 :: Dict (K.Rem 'K.RoundHalfZero Z (N 1) ~ Z) +_test_Rem_RoundHalfZero_Z_N1 = Dict +_test_Rem_RoundHalfZero_Z_N2 :: Dict (K.Rem 'K.RoundHalfZero Z (N 2) ~ Z) +_test_Rem_RoundHalfZero_Z_N2 = Dict +_test_Rem_RoundHalfZero_Z_N3 :: Dict (K.Rem 'K.RoundHalfZero Z (N 3) ~ Z) +_test_Rem_RoundHalfZero_Z_N3 = Dict +_test_Div_RoundHalfZero_Z_N4 :: Dict (K.Div 'K.RoundHalfZero Z (N 4) ~ Z) +_test_Div_RoundHalfZero_Z_N4 = Dict +_test_Rem_RoundHalfZero_Z_P1 :: Dict (K.Rem 'K.RoundHalfZero Z (P 1) ~ Z) +_test_Rem_RoundHalfZero_Z_P1 = Dict +_test_Div_RoundHalfZero_Z_P2 :: Dict (K.Div 'K.RoundHalfZero Z (P 2) ~ Z) +_test_Div_RoundHalfZero_Z_P2 = Dict +_test_Rem_RoundHalfZero_Z_P3 :: Dict (K.Rem 'K.RoundHalfZero Z (P 3) ~ Z) +_test_Rem_RoundHalfZero_Z_P3 = Dict +_test_Div_RoundHalfZero_Z_P4 :: Dict (K.Div 'K.RoundHalfZero Z (P 4) ~ Z) +_test_Div_RoundHalfZero_Z_P4 = Dict +_test_Div_RoundHalfZero_P1_N1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 1) ~ N 1) +_test_Div_RoundHalfZero_P1_N1 = Dict +_test_Rem_RoundHalfZero_P1_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 1) ~ Z) +_test_Rem_RoundHalfZero_P1_N1 = Dict +_test_Div_RoundHalfZero_P1_N2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 2) ~ Z) +_test_Div_RoundHalfZero_P1_N2 = Dict +_test_Rem_RoundHalfZero_P1_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 2) ~ P 1) +_test_Rem_RoundHalfZero_P1_N2 = Dict +_test_Div_RoundHalfZero_P1_N3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 3) ~ Z) +_test_Div_RoundHalfZero_P1_N3 = Dict +_test_Rem_RoundHalfZero_P1_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 3) ~ P 1) +_test_Rem_RoundHalfZero_P1_N3 = Dict +_test_Div_RoundHalfZero_P1_N4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 4) ~ Z) +_test_Div_RoundHalfZero_P1_N4 = Dict +_test_Rem_RoundHalfZero_P1_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 4) ~ P 1) +_test_Rem_RoundHalfZero_P1_N4 = Dict +_test_Div_RoundHalfZero_P1_P1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 1) ~ P 1) +_test_Div_RoundHalfZero_P1_P1 = Dict +_test_Rem_RoundHalfZero_P1_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 1) ~ Z) +_test_Rem_RoundHalfZero_P1_P1 = Dict +_test_Div_RoundHalfZero_P1_P2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 2) ~ Z) +_test_Div_RoundHalfZero_P1_P2 = Dict +_test_Rem_RoundHalfZero_P1_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 2) ~ P 1) +_test_Rem_RoundHalfZero_P1_P2 = Dict +_test_Div_RoundHalfZero_P1_P3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 3) ~ Z) +_test_Div_RoundHalfZero_P1_P3 = Dict +_test_Rem_RoundHalfZero_P1_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 3) ~ P 1) +_test_Rem_RoundHalfZero_P1_P3 = Dict +_test_Div_RoundHalfZero_P1_P4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 4) ~ Z) +_test_Div_RoundHalfZero_P1_P4 = Dict +_test_Rem_RoundHalfZero_P1_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 4) ~ P 1) +_test_Rem_RoundHalfZero_P1_P4 = Dict +_test_Div_RoundHalfZero_P2_N1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 1) ~ N 2) +_test_Div_RoundHalfZero_P2_N1 = Dict +_test_Rem_RoundHalfZero_P2_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 1) ~ Z) +_test_Rem_RoundHalfZero_P2_N1 = Dict +_test_Div_RoundHalfZero_P2_N2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 2) ~ N 1) +_test_Div_RoundHalfZero_P2_N2 = Dict +_test_Rem_RoundHalfZero_P2_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 2) ~ Z) +_test_Rem_RoundHalfZero_P2_N2 = Dict +_test_Div_RoundHalfZero_P2_N3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 3) ~ N 1) +_test_Div_RoundHalfZero_P2_N3 = Dict +_test_Rem_RoundHalfZero_P2_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 3) ~ N 1) +_test_Rem_RoundHalfZero_P2_N3 = Dict +_test_Div_RoundHalfZero_P2_N4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 4) ~ Z) +_test_Div_RoundHalfZero_P2_N4 = Dict +_test_Rem_RoundHalfZero_P2_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 4) ~ P 2) +_test_Rem_RoundHalfZero_P2_N4 = Dict +_test_Div_RoundHalfZero_P2_P1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 1) ~ P 2) +_test_Div_RoundHalfZero_P2_P1 = Dict +_test_Rem_RoundHalfZero_P2_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 1) ~ Z) +_test_Rem_RoundHalfZero_P2_P1 = Dict +_test_Div_RoundHalfZero_P2_P2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 2) ~ P 1) +_test_Div_RoundHalfZero_P2_P2 = Dict +_test_Rem_RoundHalfZero_P2_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 2) ~ Z) +_test_Rem_RoundHalfZero_P2_P2 = Dict +_test_Div_RoundHalfZero_P2_P3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 3) ~ P 1) +_test_Div_RoundHalfZero_P2_P3 = Dict +_test_Rem_RoundHalfZero_P2_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 3) ~ N 1) +_test_Rem_RoundHalfZero_P2_P3 = Dict +_test_Div_RoundHalfZero_P2_P4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 4) ~ Z) +_test_Div_RoundHalfZero_P2_P4 = Dict +_test_Rem_RoundHalfZero_P2_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 4) ~ P 2) +_test_Rem_RoundHalfZero_P2_P4 = Dict +_test_Div_RoundHalfZero_P3_N1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 1) ~ N 3) +_test_Div_RoundHalfZero_P3_N1 = Dict +_test_Rem_RoundHalfZero_P3_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 1) ~ Z) +_test_Rem_RoundHalfZero_P3_N1 = Dict +_test_Div_RoundHalfZero_P3_N2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 2) ~ N 1) +_test_Div_RoundHalfZero_P3_N2 = Dict +_test_Rem_RoundHalfZero_P3_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 2) ~ P 1) +_test_Rem_RoundHalfZero_P3_N2 = Dict +_test_Div_RoundHalfZero_P3_N3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 3) ~ N 1) +_test_Div_RoundHalfZero_P3_N3 = Dict +_test_Rem_RoundHalfZero_P3_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 3) ~ Z) +_test_Rem_RoundHalfZero_P3_N3 = Dict +_test_Div_RoundHalfZero_P3_N4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 4) ~ N 1) +_test_Div_RoundHalfZero_P3_N4 = Dict +_test_Rem_RoundHalfZero_P3_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 4) ~ N 1) +_test_Rem_RoundHalfZero_P3_N4 = Dict +_test_Div_RoundHalfZero_P3_P1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 1) ~ P 3) +_test_Div_RoundHalfZero_P3_P1 = Dict +_test_Rem_RoundHalfZero_P3_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 1) ~ Z) +_test_Rem_RoundHalfZero_P3_P1 = Dict +_test_Div_RoundHalfZero_P3_P2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 2) ~ P 1) +_test_Div_RoundHalfZero_P3_P2 = Dict +_test_Rem_RoundHalfZero_P3_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 2) ~ P 1) +_test_Rem_RoundHalfZero_P3_P2 = Dict +_test_Div_RoundHalfZero_P3_P3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 3) ~ P 1) +_test_Div_RoundHalfZero_P3_P3 = Dict +_test_Rem_RoundHalfZero_P3_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 3) ~ Z) +_test_Rem_RoundHalfZero_P3_P3 = Dict +_test_Div_RoundHalfZero_P3_P4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 4) ~ P 1) +_test_Div_RoundHalfZero_P3_P4 = Dict +_test_Rem_RoundHalfZero_P3_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 4) ~ N 1) +_test_Rem_RoundHalfZero_P3_P4 = Dict +_test_Div_RoundHalfZero_P4_N1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 1) ~ N 4) +_test_Div_RoundHalfZero_P4_N1 = Dict +_test_Rem_RoundHalfZero_P4_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 1) ~ Z) +_test_Rem_RoundHalfZero_P4_N1 = Dict +_test_Div_RoundHalfZero_P4_N2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 2) ~ N 2) +_test_Div_RoundHalfZero_P4_N2 = Dict +_test_Rem_RoundHalfZero_P4_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 2) ~ Z) +_test_Rem_RoundHalfZero_P4_N2 = Dict +_test_Div_RoundHalfZero_P4_N3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 3) ~ N 1) +_test_Div_RoundHalfZero_P4_N3 = Dict +_test_Rem_RoundHalfZero_P4_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 3) ~ P 1) +_test_Rem_RoundHalfZero_P4_N3 = Dict +_test_Div_RoundHalfZero_P4_N4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 4) ~ N 1) +_test_Div_RoundHalfZero_P4_N4 = Dict +_test_Rem_RoundHalfZero_P4_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 4) ~ Z) +_test_Rem_RoundHalfZero_P4_N4 = Dict +_test_Div_RoundHalfZero_P4_P1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 1) ~ P 4) +_test_Div_RoundHalfZero_P4_P1 = Dict +_test_Rem_RoundHalfZero_P4_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 1) ~ Z) +_test_Rem_RoundHalfZero_P4_P1 = Dict +_test_Div_RoundHalfZero_P4_P2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 2) ~ P 2) +_test_Div_RoundHalfZero_P4_P2 = Dict +_test_Rem_RoundHalfZero_P4_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 2) ~ Z) +_test_Rem_RoundHalfZero_P4_P2 = Dict +_test_Div_RoundHalfZero_P4_P3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 3) ~ P 1) +_test_Div_RoundHalfZero_P4_P3 = Dict +_test_Rem_RoundHalfZero_P4_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 3) ~ P 1) +_test_Rem_RoundHalfZero_P4_P3 = Dict +_test_Div_RoundHalfZero_P4_P4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 4) ~ P 1) +_test_Div_RoundHalfZero_P4_P4 = Dict +_test_Rem_RoundHalfZero_P4_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 4) ~ Z) +_test_Rem_RoundHalfZero_P4_P4 = Dict +_test_Div_RoundUp_N1_N1 :: Dict (K.Div 'K.RoundUp (N 1) (N 1) ~ P 1) +_test_Div_RoundUp_N1_N1 = Dict +_test_Rem_RoundUp_N1_N1 :: Dict (K.Rem 'K.RoundUp (N 1) (N 1) ~ Z) +_test_Rem_RoundUp_N1_N1 = Dict +_test_Div_RoundUp_N1_N2 :: Dict (K.Div 'K.RoundUp (N 1) (N 2) ~ P 1) +_test_Div_RoundUp_N1_N2 = Dict +_test_Rem_RoundUp_N1_N2 :: Dict (K.Rem 'K.RoundUp (N 1) (N 2) ~ P 1) +_test_Rem_RoundUp_N1_N2 = Dict +_test_Div_RoundUp_N1_N3 :: Dict (K.Div 'K.RoundUp (N 1) (N 3) ~ P 1) +_test_Div_RoundUp_N1_N3 = Dict +_test_Rem_RoundUp_N1_N3 :: Dict (K.Rem 'K.RoundUp (N 1) (N 3) ~ P 2) +_test_Rem_RoundUp_N1_N3 = Dict +_test_Div_RoundUp_N1_N4 :: Dict (K.Div 'K.RoundUp (N 1) (N 4) ~ P 1) +_test_Div_RoundUp_N1_N4 = Dict +_test_Rem_RoundUp_N1_N4 :: Dict (K.Rem 'K.RoundUp (N 1) (N 4) ~ P 3) +_test_Rem_RoundUp_N1_N4 = Dict +_test_Div_RoundUp_N1_P1 :: Dict (K.Div 'K.RoundUp (N 1) (P 1) ~ N 1) +_test_Div_RoundUp_N1_P1 = Dict +_test_Rem_RoundUp_N1_P1 :: Dict (K.Rem 'K.RoundUp (N 1) (P 1) ~ Z) +_test_Rem_RoundUp_N1_P1 = Dict +_test_Div_RoundUp_N1_P2 :: Dict (K.Div 'K.RoundUp (N 1) (P 2) ~ Z) +_test_Div_RoundUp_N1_P2 = Dict +_test_Rem_RoundUp_N1_P2 :: Dict (K.Rem 'K.RoundUp (N 1) (P 2) ~ N 1) +_test_Rem_RoundUp_N1_P2 = Dict +_test_Div_RoundUp_N1_P3 :: Dict (K.Div 'K.RoundUp (N 1) (P 3) ~ Z) +_test_Div_RoundUp_N1_P3 = Dict +_test_Rem_RoundUp_N1_P3 :: Dict (K.Rem 'K.RoundUp (N 1) (P 3) ~ N 1) +_test_Rem_RoundUp_N1_P3 = Dict +_test_Div_RoundUp_N1_P4 :: Dict (K.Div 'K.RoundUp (N 1) (P 4) ~ Z) +_test_Div_RoundUp_N1_P4 = Dict +_test_Rem_RoundUp_N1_P4 :: Dict (K.Rem 'K.RoundUp (N 1) (P 4) ~ N 1) +_test_Rem_RoundUp_N1_P4 = Dict +_test_Div_RoundUp_N2_N1 :: Dict (K.Div 'K.RoundUp (N 2) (N 1) ~ P 2) +_test_Div_RoundUp_N2_N1 = Dict +_test_Rem_RoundUp_N2_N1 :: Dict (K.Rem 'K.RoundUp (N 2) (N 1) ~ Z) +_test_Rem_RoundUp_N2_N1 = Dict +_test_Div_RoundUp_N2_N2 :: Dict (K.Div 'K.RoundUp (N 2) (N 2) ~ P 1) +_test_Div_RoundUp_N2_N2 = Dict +_test_Rem_RoundUp_N2_N2 :: Dict (K.Rem 'K.RoundUp (N 2) (N 2) ~ Z) +_test_Rem_RoundUp_N2_N2 = Dict +_test_Div_RoundUp_N2_N3 :: Dict (K.Div 'K.RoundUp (N 2) (N 3) ~ P 1) +_test_Div_RoundUp_N2_N3 = Dict +_test_Rem_RoundUp_N2_N3 :: Dict (K.Rem 'K.RoundUp (N 2) (N 3) ~ P 1) +_test_Rem_RoundUp_N2_N3 = Dict +_test_Div_RoundUp_N2_N4 :: Dict (K.Div 'K.RoundUp (N 2) (N 4) ~ P 1) +_test_Div_RoundUp_N2_N4 = Dict +_test_Rem_RoundUp_N2_N4 :: Dict (K.Rem 'K.RoundUp (N 2) (N 4) ~ P 2) +_test_Rem_RoundUp_N2_N4 = Dict +_test_Div_RoundUp_N2_P1 :: Dict (K.Div 'K.RoundUp (N 2) (P 1) ~ N 2) +_test_Div_RoundUp_N2_P1 = Dict +_test_Rem_RoundUp_N2_P1 :: Dict (K.Rem 'K.RoundUp (N 2) (P 1) ~ Z) +_test_Rem_RoundUp_N2_P1 = Dict +_test_Div_RoundUp_N2_P2 :: Dict (K.Div 'K.RoundUp (N 2) (P 2) ~ N 1) +_test_Div_RoundUp_N2_P2 = Dict +_test_Rem_RoundUp_N2_P2 :: Dict (K.Rem 'K.RoundUp (N 2) (P 2) ~ Z) +_test_Rem_RoundUp_N2_P2 = Dict +_test_Div_RoundUp_N2_P3 :: Dict (K.Div 'K.RoundUp (N 2) (P 3) ~ Z) +_test_Div_RoundUp_N2_P3 = Dict +_test_Rem_RoundUp_N2_P3 :: Dict (K.Rem 'K.RoundUp (N 2) (P 3) ~ N 2) +_test_Rem_RoundUp_N2_P3 = Dict +_test_Div_RoundUp_N2_P4 :: Dict (K.Div 'K.RoundUp (N 2) (P 4) ~ Z) +_test_Div_RoundUp_N2_P4 = Dict +_test_Rem_RoundUp_N2_P4 :: Dict (K.Rem 'K.RoundUp (N 2) (P 4) ~ N 2) +_test_Rem_RoundUp_N2_P4 = Dict +_test_Div_RoundUp_N3_N1 :: Dict (K.Div 'K.RoundUp (N 3) (N 1) ~ P 3) +_test_Div_RoundUp_N3_N1 = Dict +_test_Rem_RoundUp_N3_N1 :: Dict (K.Rem 'K.RoundUp (N 3) (N 1) ~ Z) +_test_Rem_RoundUp_N3_N1 = Dict +_test_Div_RoundUp_N3_N2 :: Dict (K.Div 'K.RoundUp (N 3) (N 2) ~ P 2) +_test_Div_RoundUp_N3_N2 = Dict +_test_Rem_RoundUp_N3_N2 :: Dict (K.Rem 'K.RoundUp (N 3) (N 2) ~ P 1) +_test_Rem_RoundUp_N3_N2 = Dict +_test_Div_RoundUp_N3_N3 :: Dict (K.Div 'K.RoundUp (N 3) (N 3) ~ P 1) +_test_Div_RoundUp_N3_N3 = Dict +_test_Rem_RoundUp_N3_N3 :: Dict (K.Rem 'K.RoundUp (N 3) (N 3) ~ Z) +_test_Rem_RoundUp_N3_N3 = Dict +_test_Div_RoundUp_N3_N4 :: Dict (K.Div 'K.RoundUp (N 3) (N 4) ~ P 1) +_test_Div_RoundUp_N3_N4 = Dict +_test_Rem_RoundUp_N3_N4 :: Dict (K.Rem 'K.RoundUp (N 3) (N 4) ~ P 1) +_test_Rem_RoundUp_N3_N4 = Dict +_test_Div_RoundUp_N3_P1 :: Dict (K.Div 'K.RoundUp (N 3) (P 1) ~ N 3) +_test_Div_RoundUp_N3_P1 = Dict +_test_Rem_RoundUp_N3_P1 :: Dict (K.Rem 'K.RoundUp (N 3) (P 1) ~ Z) +_test_Rem_RoundUp_N3_P1 = Dict +_test_Div_RoundUp_N3_P2 :: Dict (K.Div 'K.RoundUp (N 3) (P 2) ~ N 1) +_test_Div_RoundUp_N3_P2 = Dict +_test_Rem_RoundUp_N3_P2 :: Dict (K.Rem 'K.RoundUp (N 3) (P 2) ~ N 1) +_test_Rem_RoundUp_N3_P2 = Dict +_test_Div_RoundUp_N3_P3 :: Dict (K.Div 'K.RoundUp (N 3) (P 3) ~ N 1) +_test_Div_RoundUp_N3_P3 = Dict +_test_Rem_RoundUp_N3_P3 :: Dict (K.Rem 'K.RoundUp (N 3) (P 3) ~ Z) +_test_Rem_RoundUp_N3_P3 = Dict +_test_Div_RoundUp_N3_P4 :: Dict (K.Div 'K.RoundUp (N 3) (P 4) ~ Z) +_test_Div_RoundUp_N3_P4 = Dict +_test_Rem_RoundUp_N3_P4 :: Dict (K.Rem 'K.RoundUp (N 3) (P 4) ~ N 3) +_test_Rem_RoundUp_N3_P4 = Dict +_test_Div_RoundUp_N4_N1 :: Dict (K.Div 'K.RoundUp (N 4) (N 1) ~ P 4) +_test_Div_RoundUp_N4_N1 = Dict +_test_Rem_RoundUp_N4_N1 :: Dict (K.Rem 'K.RoundUp (N 4) (N 1) ~ Z) +_test_Rem_RoundUp_N4_N1 = Dict +_test_Div_RoundUp_N4_N2 :: Dict (K.Div 'K.RoundUp (N 4) (N 2) ~ P 2) +_test_Div_RoundUp_N4_N2 = Dict +_test_Rem_RoundUp_N4_N2 :: Dict (K.Rem 'K.RoundUp (N 4) (N 2) ~ Z) +_test_Rem_RoundUp_N4_N2 = Dict +_test_Div_RoundUp_N4_N3 :: Dict (K.Div 'K.RoundUp (N 4) (N 3) ~ P 2) +_test_Div_RoundUp_N4_N3 = Dict +_test_Rem_RoundUp_N4_N3 :: Dict (K.Rem 'K.RoundUp (N 4) (N 3) ~ P 2) +_test_Rem_RoundUp_N4_N3 = Dict +_test_Div_RoundUp_N4_N4 :: Dict (K.Div 'K.RoundUp (N 4) (N 4) ~ P 1) +_test_Div_RoundUp_N4_N4 = Dict +_test_Rem_RoundUp_N4_N4 :: Dict (K.Rem 'K.RoundUp (N 4) (N 4) ~ Z) +_test_Rem_RoundUp_N4_N4 = Dict +_test_Div_RoundUp_N4_P1 :: Dict (K.Div 'K.RoundUp (N 4) (P 1) ~ N 4) +_test_Div_RoundUp_N4_P1 = Dict +_test_Rem_RoundUp_N4_P1 :: Dict (K.Rem 'K.RoundUp (N 4) (P 1) ~ Z) +_test_Rem_RoundUp_N4_P1 = Dict +_test_Div_RoundUp_N4_P2 :: Dict (K.Div 'K.RoundUp (N 4) (P 2) ~ N 2) +_test_Div_RoundUp_N4_P2 = Dict +_test_Rem_RoundUp_N4_P2 :: Dict (K.Rem 'K.RoundUp (N 4) (P 2) ~ Z) +_test_Rem_RoundUp_N4_P2 = Dict +_test_Div_RoundUp_N4_P3 :: Dict (K.Div 'K.RoundUp (N 4) (P 3) ~ N 1) +_test_Div_RoundUp_N4_P3 = Dict +_test_Rem_RoundUp_N4_P3 :: Dict (K.Rem 'K.RoundUp (N 4) (P 3) ~ N 1) +_test_Rem_RoundUp_N4_P3 = Dict +_test_Div_RoundUp_N4_P4 :: Dict (K.Div 'K.RoundUp (N 4) (P 4) ~ N 1) +_test_Div_RoundUp_N4_P4 = Dict +_test_Rem_RoundUp_N4_P4 :: Dict (K.Rem 'K.RoundUp (N 4) (P 4) ~ Z) +_test_Rem_RoundUp_N4_P4 = Dict +_test_Div_RoundUp_Z_N1 :: Dict (K.Div 'K.RoundUp Z (N 1) ~ Z) +_test_Div_RoundUp_Z_N1 = Dict +_test_Rem_RoundUp_Z_N2 :: Dict (K.Rem 'K.RoundUp Z (N 2) ~ Z) +_test_Rem_RoundUp_Z_N2 = Dict +_test_Div_RoundUp_Z_N3 :: Dict (K.Div 'K.RoundUp Z (N 3) ~ Z) +_test_Div_RoundUp_Z_N3 = Dict +_test_Rem_RoundUp_Z_N4 :: Dict (K.Rem 'K.RoundUp Z (N 4) ~ Z) +_test_Rem_RoundUp_Z_N4 = Dict +_test_Div_RoundUp_Z_P1 :: Dict (K.Div 'K.RoundUp Z (P 1) ~ Z) +_test_Div_RoundUp_Z_P1 = Dict +_test_Rem_RoundUp_Z_P2 :: Dict (K.Rem 'K.RoundUp Z (P 2) ~ Z) +_test_Rem_RoundUp_Z_P2 = Dict +_test_Div_RoundUp_Z_P3 :: Dict (K.Div 'K.RoundUp Z (P 3) ~ Z) +_test_Div_RoundUp_Z_P3 = Dict +_test_Rem_RoundUp_Z_P4 :: Dict (K.Rem 'K.RoundUp Z (P 4) ~ Z) +_test_Rem_RoundUp_Z_P4 = Dict +_test_Div_RoundUp_P1_N1 :: Dict (K.Div 'K.RoundUp (P 1) (N 1) ~ N 1) +_test_Div_RoundUp_P1_N1 = Dict +_test_Rem_RoundUp_P1_N1 :: Dict (K.Rem 'K.RoundUp (P 1) (N 1) ~ Z) +_test_Rem_RoundUp_P1_N1 = Dict +_test_Div_RoundUp_P1_N2 :: Dict (K.Div 'K.RoundUp (P 1) (N 2) ~ Z) +_test_Div_RoundUp_P1_N2 = Dict +_test_Rem_RoundUp_P1_N2 :: Dict (K.Rem 'K.RoundUp (P 1) (N 2) ~ P 1) +_test_Rem_RoundUp_P1_N2 = Dict +_test_Div_RoundUp_P1_N3 :: Dict (K.Div 'K.RoundUp (P 1) (N 3) ~ Z) +_test_Div_RoundUp_P1_N3 = Dict +_test_Rem_RoundUp_P1_N3 :: Dict (K.Rem 'K.RoundUp (P 1) (N 3) ~ P 1) +_test_Rem_RoundUp_P1_N3 = Dict +_test_Div_RoundUp_P1_N4 :: Dict (K.Div 'K.RoundUp (P 1) (N 4) ~ Z) +_test_Div_RoundUp_P1_N4 = Dict +_test_Rem_RoundUp_P1_N4 :: Dict (K.Rem 'K.RoundUp (P 1) (N 4) ~ P 1) +_test_Rem_RoundUp_P1_N4 = Dict +_test_Div_RoundUp_P1_P1 :: Dict (K.Div 'K.RoundUp (P 1) (P 1) ~ P 1) +_test_Div_RoundUp_P1_P1 = Dict +_test_Rem_RoundUp_P1_P1 :: Dict (K.Rem 'K.RoundUp (P 1) (P 1) ~ Z) +_test_Rem_RoundUp_P1_P1 = Dict +_test_Div_RoundUp_P1_P2 :: Dict (K.Div 'K.RoundUp (P 1) (P 2) ~ P 1) +_test_Div_RoundUp_P1_P2 = Dict +_test_Rem_RoundUp_P1_P2 :: Dict (K.Rem 'K.RoundUp (P 1) (P 2) ~ N 1) +_test_Rem_RoundUp_P1_P2 = Dict +_test_Div_RoundUp_P1_P3 :: Dict (K.Div 'K.RoundUp (P 1) (P 3) ~ P 1) +_test_Div_RoundUp_P1_P3 = Dict +_test_Rem_RoundUp_P1_P3 :: Dict (K.Rem 'K.RoundUp (P 1) (P 3) ~ N 2) +_test_Rem_RoundUp_P1_P3 = Dict +_test_Div_RoundUp_P1_P4 :: Dict (K.Div 'K.RoundUp (P 1) (P 4) ~ P 1) +_test_Div_RoundUp_P1_P4 = Dict +_test_Rem_RoundUp_P1_P4 :: Dict (K.Rem 'K.RoundUp (P 1) (P 4) ~ N 3) +_test_Rem_RoundUp_P1_P4 = Dict +_test_Div_RoundUp_P2_N1 :: Dict (K.Div 'K.RoundUp (P 2) (N 1) ~ N 2) +_test_Div_RoundUp_P2_N1 = Dict +_test_Rem_RoundUp_P2_N1 :: Dict (K.Rem 'K.RoundUp (P 2) (N 1) ~ Z) +_test_Rem_RoundUp_P2_N1 = Dict +_test_Div_RoundUp_P2_N2 :: Dict (K.Div 'K.RoundUp (P 2) (N 2) ~ N 1) +_test_Div_RoundUp_P2_N2 = Dict +_test_Rem_RoundUp_P2_N2 :: Dict (K.Rem 'K.RoundUp (P 2) (N 2) ~ Z) +_test_Rem_RoundUp_P2_N2 = Dict +_test_Div_RoundUp_P2_N3 :: Dict (K.Div 'K.RoundUp (P 2) (N 3) ~ Z) +_test_Div_RoundUp_P2_N3 = Dict +_test_Rem_RoundUp_P2_N3 :: Dict (K.Rem 'K.RoundUp (P 2) (N 3) ~ P 2) +_test_Rem_RoundUp_P2_N3 = Dict +_test_Div_RoundUp_P2_N4 :: Dict (K.Div 'K.RoundUp (P 2) (N 4) ~ Z) +_test_Div_RoundUp_P2_N4 = Dict +_test_Rem_RoundUp_P2_N4 :: Dict (K.Rem 'K.RoundUp (P 2) (N 4) ~ P 2) +_test_Rem_RoundUp_P2_N4 = Dict +_test_Div_RoundUp_P2_P1 :: Dict (K.Div 'K.RoundUp (P 2) (P 1) ~ P 2) +_test_Div_RoundUp_P2_P1 = Dict +_test_Rem_RoundUp_P2_P1 :: Dict (K.Rem 'K.RoundUp (P 2) (P 1) ~ Z) +_test_Rem_RoundUp_P2_P1 = Dict +_test_Div_RoundUp_P2_P2 :: Dict (K.Div 'K.RoundUp (P 2) (P 2) ~ P 1) +_test_Div_RoundUp_P2_P2 = Dict +_test_Rem_RoundUp_P2_P2 :: Dict (K.Rem 'K.RoundUp (P 2) (P 2) ~ Z) +_test_Rem_RoundUp_P2_P2 = Dict +_test_Div_RoundUp_P2_P3 :: Dict (K.Div 'K.RoundUp (P 2) (P 3) ~ P 1) +_test_Div_RoundUp_P2_P3 = Dict +_test_Rem_RoundUp_P2_P3 :: Dict (K.Rem 'K.RoundUp (P 2) (P 3) ~ N 1) +_test_Rem_RoundUp_P2_P3 = Dict +_test_Div_RoundUp_P2_P4 :: Dict (K.Div 'K.RoundUp (P 2) (P 4) ~ P 1) +_test_Div_RoundUp_P2_P4 = Dict +_test_Rem_RoundUp_P2_P4 :: Dict (K.Rem 'K.RoundUp (P 2) (P 4) ~ N 2) +_test_Rem_RoundUp_P2_P4 = Dict +_test_Div_RoundUp_P3_N1 :: Dict (K.Div 'K.RoundUp (P 3) (N 1) ~ N 3) +_test_Div_RoundUp_P3_N1 = Dict +_test_Rem_RoundUp_P3_N1 :: Dict (K.Rem 'K.RoundUp (P 3) (N 1) ~ Z) +_test_Rem_RoundUp_P3_N1 = Dict +_test_Div_RoundUp_P3_N2 :: Dict (K.Div 'K.RoundUp (P 3) (N 2) ~ N 1) +_test_Div_RoundUp_P3_N2 = Dict +_test_Rem_RoundUp_P3_N2 :: Dict (K.Rem 'K.RoundUp (P 3) (N 2) ~ P 1) +_test_Rem_RoundUp_P3_N2 = Dict +_test_Div_RoundUp_P3_N3 :: Dict (K.Div 'K.RoundUp (P 3) (N 3) ~ N 1) +_test_Div_RoundUp_P3_N3 = Dict +_test_Rem_RoundUp_P3_N3 :: Dict (K.Rem 'K.RoundUp (P 3) (N 3) ~ Z) +_test_Rem_RoundUp_P3_N3 = Dict +_test_Div_RoundUp_P3_N4 :: Dict (K.Div 'K.RoundUp (P 3) (N 4) ~ Z) +_test_Div_RoundUp_P3_N4 = Dict +_test_Rem_RoundUp_P3_N4 :: Dict (K.Rem 'K.RoundUp (P 3) (N 4) ~ P 3) +_test_Rem_RoundUp_P3_N4 = Dict +_test_Div_RoundUp_P3_P1 :: Dict (K.Div 'K.RoundUp (P 3) (P 1) ~ P 3) +_test_Div_RoundUp_P3_P1 = Dict +_test_Rem_RoundUp_P3_P1 :: Dict (K.Rem 'K.RoundUp (P 3) (P 1) ~ Z) +_test_Rem_RoundUp_P3_P1 = Dict +_test_Div_RoundUp_P3_P2 :: Dict (K.Div 'K.RoundUp (P 3) (P 2) ~ P 2) +_test_Div_RoundUp_P3_P2 = Dict +_test_Rem_RoundUp_P3_P2 :: Dict (K.Rem 'K.RoundUp (P 3) (P 2) ~ N 1) +_test_Rem_RoundUp_P3_P2 = Dict +_test_Div_RoundUp_P3_P3 :: Dict (K.Div 'K.RoundUp (P 3) (P 3) ~ P 1) +_test_Div_RoundUp_P3_P3 = Dict +_test_Rem_RoundUp_P3_P3 :: Dict (K.Rem 'K.RoundUp (P 3) (P 3) ~ Z) +_test_Rem_RoundUp_P3_P3 = Dict +_test_Div_RoundUp_P3_P4 :: Dict (K.Div 'K.RoundUp (P 3) (P 4) ~ P 1) +_test_Div_RoundUp_P3_P4 = Dict +_test_Rem_RoundUp_P3_P4 :: Dict (K.Rem 'K.RoundUp (P 3) (P 4) ~ N 1) +_test_Rem_RoundUp_P3_P4 = Dict +_test_Div_RoundUp_P4_N1 :: Dict (K.Div 'K.RoundUp (P 4) (N 1) ~ N 4) +_test_Div_RoundUp_P4_N1 = Dict +_test_Rem_RoundUp_P4_N1 :: Dict (K.Rem 'K.RoundUp (P 4) (N 1) ~ Z) +_test_Rem_RoundUp_P4_N1 = Dict +_test_Div_RoundUp_P4_N2 :: Dict (K.Div 'K.RoundUp (P 4) (N 2) ~ N 2) +_test_Div_RoundUp_P4_N2 = Dict +_test_Rem_RoundUp_P4_N2 :: Dict (K.Rem 'K.RoundUp (P 4) (N 2) ~ Z) +_test_Rem_RoundUp_P4_N2 = Dict +_test_Div_RoundUp_P4_N3 :: Dict (K.Div 'K.RoundUp (P 4) (N 3) ~ N 1) +_test_Div_RoundUp_P4_N3 = Dict +_test_Rem_RoundUp_P4_N3 :: Dict (K.Rem 'K.RoundUp (P 4) (N 3) ~ P 1) +_test_Rem_RoundUp_P4_N3 = Dict +_test_Div_RoundUp_P4_N4 :: Dict (K.Div 'K.RoundUp (P 4) (N 4) ~ N 1) +_test_Div_RoundUp_P4_N4 = Dict +_test_Rem_RoundUp_P4_N4 :: Dict (K.Rem 'K.RoundUp (P 4) (N 4) ~ Z) +_test_Rem_RoundUp_P4_N4 = Dict +_test_Div_RoundUp_P4_P1 :: Dict (K.Div 'K.RoundUp (P 4) (P 1) ~ P 4) +_test_Div_RoundUp_P4_P1 = Dict +_test_Rem_RoundUp_P4_P1 :: Dict (K.Rem 'K.RoundUp (P 4) (P 1) ~ Z) +_test_Rem_RoundUp_P4_P1 = Dict +_test_Div_RoundUp_P4_P2 :: Dict (K.Div 'K.RoundUp (P 4) (P 2) ~ P 2) +_test_Div_RoundUp_P4_P2 = Dict +_test_Rem_RoundUp_P4_P2 :: Dict (K.Rem 'K.RoundUp (P 4) (P 2) ~ Z) +_test_Rem_RoundUp_P4_P2 = Dict +_test_Div_RoundUp_P4_P3 :: Dict (K.Div 'K.RoundUp (P 4) (P 3) ~ P 2) +_test_Div_RoundUp_P4_P3 = Dict +_test_Rem_RoundUp_P4_P3 :: Dict (K.Rem 'K.RoundUp (P 4) (P 3) ~ N 2) +_test_Rem_RoundUp_P4_P3 = Dict +_test_Div_RoundUp_P4_P4 :: Dict (K.Div 'K.RoundUp (P 4) (P 4) ~ P 1) +_test_Div_RoundUp_P4_P4 = Dict +_test_Rem_RoundUp_P4_P4 :: Dict (K.Rem 'K.RoundUp (P 4) (P 4) ~ Z) +_test_Rem_RoundUp_P4_P4 = Dict +_test_Div_RoundZero_N1_N1 :: Dict (K.Div 'K.RoundZero (N 1) (N 1) ~ P 1) +_test_Div_RoundZero_N1_N1 = Dict +_test_Rem_RoundZero_N1_N1 :: Dict (K.Rem 'K.RoundZero (N 1) (N 1) ~ Z) +_test_Rem_RoundZero_N1_N1 = Dict +_test_Div_RoundZero_N1_N2 :: Dict (K.Div 'K.RoundZero (N 1) (N 2) ~ Z) +_test_Div_RoundZero_N1_N2 = Dict +_test_Rem_RoundZero_N1_N2 :: Dict (K.Rem 'K.RoundZero (N 1) (N 2) ~ N 1) +_test_Rem_RoundZero_N1_N2 = Dict +_test_Div_RoundZero_N1_N3 :: Dict (K.Div 'K.RoundZero (N 1) (N 3) ~ Z) +_test_Div_RoundZero_N1_N3 = Dict +_test_Rem_RoundZero_N1_N3 :: Dict (K.Rem 'K.RoundZero (N 1) (N 3) ~ N 1) +_test_Rem_RoundZero_N1_N3 = Dict +_test_Div_RoundZero_N1_N4 :: Dict (K.Div 'K.RoundZero (N 1) (N 4) ~ Z) +_test_Div_RoundZero_N1_N4 = Dict +_test_Rem_RoundZero_N1_N4 :: Dict (K.Rem 'K.RoundZero (N 1) (N 4) ~ N 1) +_test_Rem_RoundZero_N1_N4 = Dict +_test_Div_RoundZero_N1_P1 :: Dict (K.Div 'K.RoundZero (N 1) (P 1) ~ N 1) +_test_Div_RoundZero_N1_P1 = Dict +_test_Rem_RoundZero_N1_P1 :: Dict (K.Rem 'K.RoundZero (N 1) (P 1) ~ Z) +_test_Rem_RoundZero_N1_P1 = Dict +_test_Div_RoundZero_N1_P2 :: Dict (K.Div 'K.RoundZero (N 1) (P 2) ~ Z) +_test_Div_RoundZero_N1_P2 = Dict +_test_Rem_RoundZero_N1_P2 :: Dict (K.Rem 'K.RoundZero (N 1) (P 2) ~ N 1) +_test_Rem_RoundZero_N1_P2 = Dict +_test_Div_RoundZero_N1_P3 :: Dict (K.Div 'K.RoundZero (N 1) (P 3) ~ Z) +_test_Div_RoundZero_N1_P3 = Dict +_test_Rem_RoundZero_N1_P3 :: Dict (K.Rem 'K.RoundZero (N 1) (P 3) ~ N 1) +_test_Rem_RoundZero_N1_P3 = Dict +_test_Div_RoundZero_N1_P4 :: Dict (K.Div 'K.RoundZero (N 1) (P 4) ~ Z) +_test_Div_RoundZero_N1_P4 = Dict +_test_Rem_RoundZero_N1_P4 :: Dict (K.Rem 'K.RoundZero (N 1) (P 4) ~ N 1) +_test_Rem_RoundZero_N1_P4 = Dict +_test_Div_RoundZero_N2_N1 :: Dict (K.Div 'K.RoundZero (N 2) (N 1) ~ P 2) +_test_Div_RoundZero_N2_N1 = Dict +_test_Rem_RoundZero_N2_N1 :: Dict (K.Rem 'K.RoundZero (N 2) (N 1) ~ Z) +_test_Rem_RoundZero_N2_N1 = Dict +_test_Div_RoundZero_N2_N2 :: Dict (K.Div 'K.RoundZero (N 2) (N 2) ~ P 1) +_test_Div_RoundZero_N2_N2 = Dict +_test_Rem_RoundZero_N2_N2 :: Dict (K.Rem 'K.RoundZero (N 2) (N 2) ~ Z) +_test_Rem_RoundZero_N2_N2 = Dict +_test_Div_RoundZero_N2_N3 :: Dict (K.Div 'K.RoundZero (N 2) (N 3) ~ Z) +_test_Div_RoundZero_N2_N3 = Dict +_test_Rem_RoundZero_N2_N3 :: Dict (K.Rem 'K.RoundZero (N 2) (N 3) ~ N 2) +_test_Rem_RoundZero_N2_N3 = Dict +_test_Div_RoundZero_N2_N4 :: Dict (K.Div 'K.RoundZero (N 2) (N 4) ~ Z) +_test_Div_RoundZero_N2_N4 = Dict +_test_Rem_RoundZero_N2_N4 :: Dict (K.Rem 'K.RoundZero (N 2) (N 4) ~ N 2) +_test_Rem_RoundZero_N2_N4 = Dict +_test_Div_RoundZero_N2_P1 :: Dict (K.Div 'K.RoundZero (N 2) (P 1) ~ N 2) +_test_Div_RoundZero_N2_P1 = Dict +_test_Rem_RoundZero_N2_P1 :: Dict (K.Rem 'K.RoundZero (N 2) (P 1) ~ Z) +_test_Rem_RoundZero_N2_P1 = Dict +_test_Div_RoundZero_N2_P2 :: Dict (K.Div 'K.RoundZero (N 2) (P 2) ~ N 1) +_test_Div_RoundZero_N2_P2 = Dict +_test_Rem_RoundZero_N2_P2 :: Dict (K.Rem 'K.RoundZero (N 2) (P 2) ~ Z) +_test_Rem_RoundZero_N2_P2 = Dict +_test_Div_RoundZero_N2_P3 :: Dict (K.Div 'K.RoundZero (N 2) (P 3) ~ Z) +_test_Div_RoundZero_N2_P3 = Dict +_test_Rem_RoundZero_N2_P3 :: Dict (K.Rem 'K.RoundZero (N 2) (P 3) ~ N 2) +_test_Rem_RoundZero_N2_P3 = Dict +_test_Div_RoundZero_N2_P4 :: Dict (K.Div 'K.RoundZero (N 2) (P 4) ~ Z) +_test_Div_RoundZero_N2_P4 = Dict +_test_Rem_RoundZero_N2_P4 :: Dict (K.Rem 'K.RoundZero (N 2) (P 4) ~ N 2) +_test_Rem_RoundZero_N2_P4 = Dict +_test_Div_RoundZero_N3_N1 :: Dict (K.Div 'K.RoundZero (N 3) (N 1) ~ P 3) +_test_Div_RoundZero_N3_N1 = Dict +_test_Rem_RoundZero_N3_N1 :: Dict (K.Rem 'K.RoundZero (N 3) (N 1) ~ Z) +_test_Rem_RoundZero_N3_N1 = Dict +_test_Div_RoundZero_N3_N2 :: Dict (K.Div 'K.RoundZero (N 3) (N 2) ~ P 1) +_test_Div_RoundZero_N3_N2 = Dict +_test_Rem_RoundZero_N3_N2 :: Dict (K.Rem 'K.RoundZero (N 3) (N 2) ~ N 1) +_test_Rem_RoundZero_N3_N2 = Dict +_test_Div_RoundZero_N3_N3 :: Dict (K.Div 'K.RoundZero (N 3) (N 3) ~ P 1) +_test_Div_RoundZero_N3_N3 = Dict +_test_Rem_RoundZero_N3_N3 :: Dict (K.Rem 'K.RoundZero (N 3) (N 3) ~ Z) +_test_Rem_RoundZero_N3_N3 = Dict +_test_Div_RoundZero_N3_N4 :: Dict (K.Div 'K.RoundZero (N 3) (N 4) ~ Z) +_test_Div_RoundZero_N3_N4 = Dict +_test_Rem_RoundZero_N3_N4 :: Dict (K.Rem 'K.RoundZero (N 3) (N 4) ~ N 3) +_test_Rem_RoundZero_N3_N4 = Dict +_test_Div_RoundZero_N3_P1 :: Dict (K.Div 'K.RoundZero (N 3) (P 1) ~ N 3) +_test_Div_RoundZero_N3_P1 = Dict +_test_Rem_RoundZero_N3_P1 :: Dict (K.Rem 'K.RoundZero (N 3) (P 1) ~ Z) +_test_Rem_RoundZero_N3_P1 = Dict +_test_Div_RoundZero_N3_P2 :: Dict (K.Div 'K.RoundZero (N 3) (P 2) ~ N 1) +_test_Div_RoundZero_N3_P2 = Dict +_test_Rem_RoundZero_N3_P2 :: Dict (K.Rem 'K.RoundZero (N 3) (P 2) ~ N 1) +_test_Rem_RoundZero_N3_P2 = Dict +_test_Div_RoundZero_N3_P3 :: Dict (K.Div 'K.RoundZero (N 3) (P 3) ~ N 1) +_test_Div_RoundZero_N3_P3 = Dict +_test_Rem_RoundZero_N3_P3 :: Dict (K.Rem 'K.RoundZero (N 3) (P 3) ~ Z) +_test_Rem_RoundZero_N3_P3 = Dict +_test_Div_RoundZero_N3_P4 :: Dict (K.Div 'K.RoundZero (N 3) (P 4) ~ Z) +_test_Div_RoundZero_N3_P4 = Dict +_test_Rem_RoundZero_N3_P4 :: Dict (K.Rem 'K.RoundZero (N 3) (P 4) ~ N 3) +_test_Rem_RoundZero_N3_P4 = Dict +_test_Div_RoundZero_N4_N1 :: Dict (K.Div 'K.RoundZero (N 4) (N 1) ~ P 4) +_test_Div_RoundZero_N4_N1 = Dict +_test_Rem_RoundZero_N4_N1 :: Dict (K.Rem 'K.RoundZero (N 4) (N 1) ~ Z) +_test_Rem_RoundZero_N4_N1 = Dict +_test_Div_RoundZero_N4_N2 :: Dict (K.Div 'K.RoundZero (N 4) (N 2) ~ P 2) +_test_Div_RoundZero_N4_N2 = Dict +_test_Rem_RoundZero_N4_N2 :: Dict (K.Rem 'K.RoundZero (N 4) (N 2) ~ Z) +_test_Rem_RoundZero_N4_N2 = Dict +_test_Div_RoundZero_N4_N3 :: Dict (K.Div 'K.RoundZero (N 4) (N 3) ~ P 1) +_test_Div_RoundZero_N4_N3 = Dict +_test_Rem_RoundZero_N4_N3 :: Dict (K.Rem 'K.RoundZero (N 4) (N 3) ~ N 1) +_test_Rem_RoundZero_N4_N3 = Dict +_test_Div_RoundZero_N4_N4 :: Dict (K.Div 'K.RoundZero (N 4) (N 4) ~ P 1) +_test_Div_RoundZero_N4_N4 = Dict +_test_Rem_RoundZero_N4_N4 :: Dict (K.Rem 'K.RoundZero (N 4) (N 4) ~ Z) +_test_Rem_RoundZero_N4_N4 = Dict +_test_Div_RoundZero_N4_P1 :: Dict (K.Div 'K.RoundZero (N 4) (P 1) ~ N 4) +_test_Div_RoundZero_N4_P1 = Dict +_test_Rem_RoundZero_N4_P1 :: Dict (K.Rem 'K.RoundZero (N 4) (P 1) ~ Z) +_test_Rem_RoundZero_N4_P1 = Dict +_test_Div_RoundZero_N4_P2 :: Dict (K.Div 'K.RoundZero (N 4) (P 2) ~ N 2) +_test_Div_RoundZero_N4_P2 = Dict +_test_Rem_RoundZero_N4_P2 :: Dict (K.Rem 'K.RoundZero (N 4) (P 2) ~ Z) +_test_Rem_RoundZero_N4_P2 = Dict +_test_Div_RoundZero_N4_P3 :: Dict (K.Div 'K.RoundZero (N 4) (P 3) ~ N 1) +_test_Div_RoundZero_N4_P3 = Dict +_test_Rem_RoundZero_N4_P3 :: Dict (K.Rem 'K.RoundZero (N 4) (P 3) ~ N 1) +_test_Rem_RoundZero_N4_P3 = Dict +_test_Div_RoundZero_N4_P4 :: Dict (K.Div 'K.RoundZero (N 4) (P 4) ~ N 1) +_test_Div_RoundZero_N4_P4 = Dict +_test_Rem_RoundZero_N4_P4 :: Dict (K.Rem 'K.RoundZero (N 4) (P 4) ~ Z) +_test_Rem_RoundZero_N4_P4 = Dict +_test_Div_RoundZero_Z_N1 :: Dict (K.Div 'K.RoundZero Z (N 1) ~ Z) +_test_Div_RoundZero_Z_N1 = Dict +_test_Div_RoundZero_Z_N2 :: Dict (K.Div 'K.RoundZero Z (N 2) ~ Z) +_test_Div_RoundZero_Z_N2 = Dict +_test_Div_RoundZero_Z_N3 :: Dict (K.Div 'K.RoundZero Z (N 3) ~ Z) +_test_Div_RoundZero_Z_N3 = Dict +_test_Div_RoundZero_Z_N4 :: Dict (K.Div 'K.RoundZero Z (N 4) ~ Z) +_test_Div_RoundZero_Z_N4 = Dict +_test_Div_RoundZero_Z_P1 :: Dict (K.Div 'K.RoundZero Z (P 1) ~ Z) +_test_Div_RoundZero_Z_P1 = Dict +_test_Div_RoundZero_Z_P2 :: Dict (K.Div 'K.RoundZero Z (P 2) ~ Z) +_test_Div_RoundZero_Z_P2 = Dict +_test_Div_RoundZero_Z_P3 :: Dict (K.Div 'K.RoundZero Z (P 3) ~ Z) +_test_Div_RoundZero_Z_P3 = Dict +_test_Div_RoundZero_Z_P4 :: Dict (K.Div 'K.RoundZero Z (P 4) ~ Z) +_test_Div_RoundZero_Z_P4 = Dict +_test_Div_RoundZero_P1_N1 :: Dict (K.Div 'K.RoundZero (P 1) (N 1) ~ N 1) +_test_Div_RoundZero_P1_N1 = Dict +_test_Rem_RoundZero_P1_N1 :: Dict (K.Rem 'K.RoundZero (P 1) (N 1) ~ Z) +_test_Rem_RoundZero_P1_N1 = Dict +_test_Div_RoundZero_P1_N2 :: Dict (K.Div 'K.RoundZero (P 1) (N 2) ~ Z) +_test_Div_RoundZero_P1_N2 = Dict +_test_Rem_RoundZero_P1_N2 :: Dict (K.Rem 'K.RoundZero (P 1) (N 2) ~ P 1) +_test_Rem_RoundZero_P1_N2 = Dict +_test_Div_RoundZero_P1_N3 :: Dict (K.Div 'K.RoundZero (P 1) (N 3) ~ Z) +_test_Div_RoundZero_P1_N3 = Dict +_test_Rem_RoundZero_P1_N3 :: Dict (K.Rem 'K.RoundZero (P 1) (N 3) ~ P 1) +_test_Rem_RoundZero_P1_N3 = Dict +_test_Div_RoundZero_P1_N4 :: Dict (K.Div 'K.RoundZero (P 1) (N 4) ~ Z) +_test_Div_RoundZero_P1_N4 = Dict +_test_Rem_RoundZero_P1_N4 :: Dict (K.Rem 'K.RoundZero (P 1) (N 4) ~ P 1) +_test_Rem_RoundZero_P1_N4 = Dict +_test_Div_RoundZero_P1_P1 :: Dict (K.Div 'K.RoundZero (P 1) (P 1) ~ P 1) +_test_Div_RoundZero_P1_P1 = Dict +_test_Rem_RoundZero_P1_P1 :: Dict (K.Rem 'K.RoundZero (P 1) (P 1) ~ Z) +_test_Rem_RoundZero_P1_P1 = Dict +_test_Div_RoundZero_P1_P2 :: Dict (K.Div 'K.RoundZero (P 1) (P 2) ~ Z) +_test_Div_RoundZero_P1_P2 = Dict +_test_Rem_RoundZero_P1_P2 :: Dict (K.Rem 'K.RoundZero (P 1) (P 2) ~ P 1) +_test_Rem_RoundZero_P1_P2 = Dict +_test_Div_RoundZero_P1_P3 :: Dict (K.Div 'K.RoundZero (P 1) (P 3) ~ Z) +_test_Div_RoundZero_P1_P3 = Dict +_test_Rem_RoundZero_P1_P3 :: Dict (K.Rem 'K.RoundZero (P 1) (P 3) ~ P 1) +_test_Rem_RoundZero_P1_P3 = Dict +_test_Div_RoundZero_P1_P4 :: Dict (K.Div 'K.RoundZero (P 1) (P 4) ~ Z) +_test_Div_RoundZero_P1_P4 = Dict +_test_Rem_RoundZero_P1_P4 :: Dict (K.Rem 'K.RoundZero (P 1) (P 4) ~ P 1) +_test_Rem_RoundZero_P1_P4 = Dict +_test_Div_RoundZero_P2_N1 :: Dict (K.Div 'K.RoundZero (P 2) (N 1) ~ N 2) +_test_Div_RoundZero_P2_N1 = Dict +_test_Rem_RoundZero_P2_N1 :: Dict (K.Rem 'K.RoundZero (P 2) (N 1) ~ Z) +_test_Rem_RoundZero_P2_N1 = Dict +_test_Div_RoundZero_P2_N2 :: Dict (K.Div 'K.RoundZero (P 2) (N 2) ~ N 1) +_test_Div_RoundZero_P2_N2 = Dict +_test_Rem_RoundZero_P2_N2 :: Dict (K.Rem 'K.RoundZero (P 2) (N 2) ~ Z) +_test_Rem_RoundZero_P2_N2 = Dict +_test_Div_RoundZero_P2_N3 :: Dict (K.Div 'K.RoundZero (P 2) (N 3) ~ Z) +_test_Div_RoundZero_P2_N3 = Dict +_test_Rem_RoundZero_P2_N3 :: Dict (K.Rem 'K.RoundZero (P 2) (N 3) ~ P 2) +_test_Rem_RoundZero_P2_N3 = Dict +_test_Div_RoundZero_P2_N4 :: Dict (K.Div 'K.RoundZero (P 2) (N 4) ~ Z) +_test_Div_RoundZero_P2_N4 = Dict +_test_Rem_RoundZero_P2_N4 :: Dict (K.Rem 'K.RoundZero (P 2) (N 4) ~ P 2) +_test_Rem_RoundZero_P2_N4 = Dict +_test_Div_RoundZero_P2_P1 :: Dict (K.Div 'K.RoundZero (P 2) (P 1) ~ P 2) +_test_Div_RoundZero_P2_P1 = Dict +_test_Rem_RoundZero_P2_P1 :: Dict (K.Rem 'K.RoundZero (P 2) (P 1) ~ Z) +_test_Rem_RoundZero_P2_P1 = Dict +_test_Div_RoundZero_P2_P2 :: Dict (K.Div 'K.RoundZero (P 2) (P 2) ~ P 1) +_test_Div_RoundZero_P2_P2 = Dict +_test_Rem_RoundZero_P2_P2 :: Dict (K.Rem 'K.RoundZero (P 2) (P 2) ~ Z) +_test_Rem_RoundZero_P2_P2 = Dict +_test_Div_RoundZero_P2_P3 :: Dict (K.Div 'K.RoundZero (P 2) (P 3) ~ Z) +_test_Div_RoundZero_P2_P3 = Dict +_test_Rem_RoundZero_P2_P3 :: Dict (K.Rem 'K.RoundZero (P 2) (P 3) ~ P 2) +_test_Rem_RoundZero_P2_P3 = Dict +_test_Div_RoundZero_P2_P4 :: Dict (K.Div 'K.RoundZero (P 2) (P 4) ~ Z) +_test_Div_RoundZero_P2_P4 = Dict +_test_Rem_RoundZero_P2_P4 :: Dict (K.Rem 'K.RoundZero (P 2) (P 4) ~ P 2) +_test_Rem_RoundZero_P2_P4 = Dict +_test_Div_RoundZero_P3_N1 :: Dict (K.Div 'K.RoundZero (P 3) (N 1) ~ N 3) +_test_Div_RoundZero_P3_N1 = Dict +_test_Rem_RoundZero_P3_N1 :: Dict (K.Rem 'K.RoundZero (P 3) (N 1) ~ Z) +_test_Rem_RoundZero_P3_N1 = Dict +_test_Div_RoundZero_P3_N2 :: Dict (K.Div 'K.RoundZero (P 3) (N 2) ~ N 1) +_test_Div_RoundZero_P3_N2 = Dict +_test_Rem_RoundZero_P3_N2 :: Dict (K.Rem 'K.RoundZero (P 3) (N 2) ~ P 1) +_test_Rem_RoundZero_P3_N2 = Dict +_test_Div_RoundZero_P3_N3 :: Dict (K.Div 'K.RoundZero (P 3) (N 3) ~ N 1) +_test_Div_RoundZero_P3_N3 = Dict +_test_Rem_RoundZero_P3_N3 :: Dict (K.Rem 'K.RoundZero (P 3) (N 3) ~ Z) +_test_Rem_RoundZero_P3_N3 = Dict +_test_Div_RoundZero_P3_N4 :: Dict (K.Div 'K.RoundZero (P 3) (N 4) ~ Z) +_test_Div_RoundZero_P3_N4 = Dict +_test_Rem_RoundZero_P3_N4 :: Dict (K.Rem 'K.RoundZero (P 3) (N 4) ~ P 3) +_test_Rem_RoundZero_P3_N4 = Dict +_test_Div_RoundZero_P3_P1 :: Dict (K.Div 'K.RoundZero (P 3) (P 1) ~ P 3) +_test_Div_RoundZero_P3_P1 = Dict +_test_Rem_RoundZero_P3_P1 :: Dict (K.Rem 'K.RoundZero (P 3) (P 1) ~ Z) +_test_Rem_RoundZero_P3_P1 = Dict +_test_Div_RoundZero_P3_P2 :: Dict (K.Div 'K.RoundZero (P 3) (P 2) ~ P 1) +_test_Div_RoundZero_P3_P2 = Dict +_test_Rem_RoundZero_P3_P2 :: Dict (K.Rem 'K.RoundZero (P 3) (P 2) ~ P 1) +_test_Rem_RoundZero_P3_P2 = Dict +_test_Div_RoundZero_P3_P3 :: Dict (K.Div 'K.RoundZero (P 3) (P 3) ~ P 1) +_test_Div_RoundZero_P3_P3 = Dict +_test_Rem_RoundZero_P3_P3 :: Dict (K.Rem 'K.RoundZero (P 3) (P 3) ~ Z) +_test_Rem_RoundZero_P3_P3 = Dict +_test_Div_RoundZero_P3_P4 :: Dict (K.Div 'K.RoundZero (P 3) (P 4) ~ Z) +_test_Div_RoundZero_P3_P4 = Dict +_test_Rem_RoundZero_P3_P4 :: Dict (K.Rem 'K.RoundZero (P 3) (P 4) ~ P 3) +_test_Rem_RoundZero_P3_P4 = Dict +_test_Div_RoundZero_P4_N1 :: Dict (K.Div 'K.RoundZero (P 4) (N 1) ~ N 4) +_test_Div_RoundZero_P4_N1 = Dict +_test_Rem_RoundZero_P4_N1 :: Dict (K.Rem 'K.RoundZero (P 4) (N 1) ~ Z) +_test_Rem_RoundZero_P4_N1 = Dict +_test_Div_RoundZero_P4_N2 :: Dict (K.Div 'K.RoundZero (P 4) (N 2) ~ N 2) +_test_Div_RoundZero_P4_N2 = Dict +_test_Rem_RoundZero_P4_N2 :: Dict (K.Rem 'K.RoundZero (P 4) (N 2) ~ Z) +_test_Rem_RoundZero_P4_N2 = Dict +_test_Div_RoundZero_P4_N3 :: Dict (K.Div 'K.RoundZero (P 4) (N 3) ~ N 1) +_test_Div_RoundZero_P4_N3 = Dict +_test_Rem_RoundZero_P4_N3 :: Dict (K.Rem 'K.RoundZero (P 4) (N 3) ~ P 1) +_test_Rem_RoundZero_P4_N3 = Dict +_test_Div_RoundZero_P4_N4 :: Dict (K.Div 'K.RoundZero (P 4) (N 4) ~ N 1) +_test_Div_RoundZero_P4_N4 = Dict +_test_Rem_RoundZero_P4_N4 :: Dict (K.Rem 'K.RoundZero (P 4) (N 4) ~ Z) +_test_Rem_RoundZero_P4_N4 = Dict +_test_Div_RoundZero_P4_P1 :: Dict (K.Div 'K.RoundZero (P 4) (P 1) ~ P 4) +_test_Div_RoundZero_P4_P1 = Dict +_test_Rem_RoundZero_P4_P1 :: Dict (K.Rem 'K.RoundZero (P 4) (P 1) ~ Z) +_test_Rem_RoundZero_P4_P1 = Dict +_test_Div_RoundZero_P4_P2 :: Dict (K.Div 'K.RoundZero (P 4) (P 2) ~ P 2) +_test_Div_RoundZero_P4_P2 = Dict +_test_Rem_RoundZero_P4_P2 :: Dict (K.Rem 'K.RoundZero (P 4) (P 2) ~ Z) +_test_Rem_RoundZero_P4_P2 = Dict +_test_Div_RoundZero_P4_P3 :: Dict (K.Div 'K.RoundZero (P 4) (P 3) ~ P 1) +_test_Div_RoundZero_P4_P3 = Dict +_test_Rem_RoundZero_P4_P3 :: Dict (K.Rem 'K.RoundZero (P 4) (P 3) ~ P 1) +_test_Rem_RoundZero_P4_P3 = Dict +_test_Div_RoundZero_P4_P4 :: Dict (K.Div 'K.RoundZero (P 4) (P 4) ~ P 1) +_test_Div_RoundZero_P4_P4 = Dict +_test_Rem_RoundZero_P4_P4 :: Dict (K.Rem 'K.RoundZero (P 4) (P 4) ~ Z) +_test_Rem_RoundZero_P4_P4 = Dict + +_test_ShowsPrec_AppPrec_Z :: Dict (P.ShowsPrec AppPrec Z "y" ~ "0y") +_test_ShowsPrec_AppPrec_Z = Dict +_test_ShowsPrec_AppPrec_P1 :: Dict (P.ShowsPrec AppPrec (P 1) "y" ~ "1y") +_test_ShowsPrec_AppPrec_P1 = Dict +_test_ShowsPrec_AppPrec_N1 :: Dict (P.ShowsPrec AppPrec (N 1) "y" ~ "-1y") +_test_ShowsPrec_AppPrec_N1 = Dict + +_test_ShowsPrec_AppPrec1_Z :: Dict (P.ShowsPrec AppPrec1 Z "y" ~ "0y") +_test_ShowsPrec_AppPrec1_Z = Dict +_test_ShowsPrec_AppPrec1_P1 :: Dict (P.ShowsPrec AppPrec1 (P 1) "y" ~ "1y") +_test_ShowsPrec_AppPrec1_P1 = Dict +_test_ShowsPrec_AppPrec1_N1 :: Dict (P.ShowsPrec AppPrec1 (N 1) "y" ~ "(-1)y") +_test_ShowsPrec_AppPrec1_N1 = Dict + +_test_ShowsPrecLit_AppPrec_Z :: Dict (K.ShowsPrecLit AppPrec Z "y" ~ "Zy") +_test_ShowsPrecLit_AppPrec_Z = Dict +_test_ShowsPrecLit_AppPrec_P1 :: Dict (K.ShowsPrecLit AppPrec (P 1) "y" ~ "P 1y") +_test_ShowsPrecLit_AppPrec_P1 = Dict +_test_ShowsPrecLit_AppPrec_N1 :: Dict (K.ShowsPrecLit AppPrec (N 1) "y" ~ "N 1y") +_test_ShowsPrecLit_AppPrec_N1 = Dict + +_test_ShowsPrecLit_AppPrec1_Z :: Dict (K.ShowsPrecLit AppPrec1 Z "y" ~ "Zy") +_test_ShowsPrecLit_AppPrec1_Z = Dict +_test_ShowsPrecLit_AppPrec1_P1 :: Dict (K.ShowsPrecLit AppPrec1 (P 1) "y" ~ "(P 1)y") +_test_ShowsPrecLit_AppPrec1_P1 = Dict +_test_ShowsPrecLit_AppPrec1_N1 :: Dict (K.ShowsPrecLit AppPrec1 (N 1) "y" ~ "(N 1)y") +_test_ShowsPrecLit_AppPrec1_N1 = Dict + +_test_Add_Z_Z :: Dict (Z P.+ Z ~ Z) +_test_Add_Z_Z = Dict +_test_Add_Z_N1 :: Dict (Z P.+ N 1 ~ N 1) +_test_Add_Z_N1 = Dict +_test_Add_Z_P1 :: Dict (Z P.+ P 1 ~ P 1) +_test_Add_Z_P1 = Dict +_test_Add_Z_N2 :: Dict (Z P.+ N 2 ~ N 2) +_test_Add_Z_N2 = Dict +_test_Add_Z_P2 :: Dict (Z P.+ P 2 ~ P 2) +_test_Add_Z_P2 = Dict + +_test_Add_N1_Z :: Dict (N 1 P.+ Z ~ N 1) +_test_Add_N1_Z = Dict +_test_Add_N1_N1 :: Dict (N 1 P.+ N 1 ~ N 2) +_test_Add_N1_N1 = Dict +_test_Add_N1_P1 :: Dict (N 1 P.+ P 1 ~ Z) +_test_Add_N1_P1 = Dict +_test_Add_N1_N2 :: Dict (N 1 P.+ N 2 ~ N 3) +_test_Add_N1_N2 = Dict +_test_Add_N1_P2 :: Dict (N 1 P.+ P 2 ~ P 1) +_test_Add_N1_P2 = Dict + +_test_Add_P1_Z :: Dict (P 1 P.+ Z ~ P 1) +_test_Add_P1_Z = Dict +_test_Add_P1_N1 :: Dict (P 1 P.+ N 1 ~ Z) +_test_Add_P1_N1 = Dict +_test_Add_P1_P1 :: Dict (P 1 P.+ P 1 ~ P 2) +_test_Add_P1_P1 = Dict +_test_Add_P1_N2 :: Dict (P 1 P.+ N 2 ~ N 1) +_test_Add_P1_N2 = Dict +_test_Add_P1_P2 :: Dict (P 1 P.+ P 2 ~ P 3) +_test_Add_P1_P2 = Dict + +_test_Add_N2_Z :: Dict (N 2 P.+ Z ~ N 2) +_test_Add_N2_Z = Dict +_test_Add_N2_N1 :: Dict (N 2 P.+ N 1 ~ N 3) +_test_Add_N2_N1 = Dict +_test_Add_N2_P1 :: Dict (N 2 P.+ P 1 ~ N 1) +_test_Add_N2_P1 = Dict +_test_Add_N2_N2 :: Dict (N 2 P.+ N 2 ~ N 4) +_test_Add_N2_N2 = Dict +_test_Add_N2_P2 :: Dict (N 2 P.+ P 2 ~ Z) +_test_Add_N2_P2 = Dict + +_test_Add_P2_Z :: Dict (P 2 P.+ Z ~ P 2) +_test_Add_P2_Z = Dict +_test_Add_P2_N1 :: Dict (P 2 P.+ N 1 ~ P 1) +_test_Add_P2_N1 = Dict +_test_Add_P2_P1 :: Dict (P 2 P.+ P 1 ~ P 3) +_test_Add_P2_P1 = Dict +_test_Add_P2_N2 :: Dict (P 2 P.+ N 2 ~ Z) +_test_Add_P2_N2 = Dict +_test_Add_P2_P2 :: Dict (P 2 P.+ P 2 ~ P 4) +_test_Add_P2_P2 = Dict + +_test_Sub_Z_Z :: Dict (Z P.- Z ~ Z) +_test_Sub_Z_Z = Dict +_test_Sub_Z_N1 :: Dict (Z P.- N 1 ~ P 1) +_test_Sub_Z_N1 = Dict +_test_Sub_Z_P1 :: Dict (Z P.- P 1 ~ N 1) +_test_Sub_Z_P1 = Dict +_test_Sub_Z_N2 :: Dict (Z P.- N 2 ~ P 2) +_test_Sub_Z_N2 = Dict +_test_Sub_Z_P2 :: Dict (Z P.- P 2 ~ N 2) +_test_Sub_Z_P2 = Dict + +_test_Sub_N1_Z :: Dict (N 1 P.- Z ~ N 1) +_test_Sub_N1_Z = Dict +_test_Sub_N1_N1 :: Dict (N 1 P.- N 1 ~ Z) +_test_Sub_N1_N1 = Dict +_test_Sub_N1_P1 :: Dict (N 1 P.- P 1 ~ N 2) +_test_Sub_N1_P1 = Dict +_test_Sub_N1_N2 :: Dict (N 1 P.- N 2 ~ P 1) +_test_Sub_N1_N2 = Dict +_test_Sub_N1_P2 :: Dict (N 1 P.- P 2 ~ N 3) +_test_Sub_N1_P2 = Dict + +_test_Sub_P1_Z :: Dict (P 1 P.- Z ~ P 1) +_test_Sub_P1_Z = Dict +_test_Sub_P1_N1 :: Dict (P 1 P.- N 1 ~ P 2) +_test_Sub_P1_N1 = Dict +_test_Sub_P1_P1 :: Dict (P 1 P.- P 1 ~ Z) +_test_Sub_P1_P1 = Dict +_test_Sub_P1_N2 :: Dict (P 1 P.- N 2 ~ P 3) +_test_Sub_P1_N2 = Dict +_test_Sub_P1_P2 :: Dict (P 1 P.- P 2 ~ N 1) +_test_Sub_P1_P2 = Dict + +_test_Sub_N2_Z :: Dict (N 2 P.- Z ~ N 2) +_test_Sub_N2_Z = Dict +_test_Sub_N2_N1 :: Dict (N 2 P.- N 1 ~ N 1) +_test_Sub_N2_N1 = Dict +_test_Sub_N2_P1 :: Dict (N 2 P.- P 1 ~ N 3) +_test_Sub_N2_P1 = Dict +_test_Sub_N2_N2 :: Dict (N 2 P.- N 2 ~ Z) +_test_Sub_N2_N2 = Dict +_test_Sub_N2_P2 :: Dict (N 2 P.- P 2 ~ N 4) +_test_Sub_N2_P2 = Dict + +_test_Sub_P2_Z :: Dict (P 2 P.- Z ~ P 2) +_test_Sub_P2_Z = Dict +_test_Sub_P2_N1 :: Dict (P 2 P.- N 1 ~ P 3) +_test_Sub_P2_N1 = Dict +_test_Sub_P2_P1 :: Dict (P 2 P.- P 1 ~ P 1) +_test_Sub_P2_P1 = Dict +_test_Sub_P2_N2 :: Dict (P 2 P.- N 2 ~ P 4) +_test_Sub_P2_N2 = Dict +_test_Sub_P2_P2 :: Dict (P 2 P.- P 2 ~ Z) +_test_Sub_P2_P2 = Dict + +_test_Mul_Z_Z :: Dict (Z P.* Z ~ Z) +_test_Mul_Z_Z = Dict +_test_Mul_Z_N1 :: Dict (Z P.* N 1 ~ Z) +_test_Mul_Z_N1 = Dict +_test_Mul_Z_P1 :: Dict (Z P.* P 1 ~ Z) +_test_Mul_Z_P1 = Dict +_test_Mul_Z_N2 :: Dict (Z P.* N 2 ~ Z) +_test_Mul_Z_N2 = Dict +_test_Mul_Z_P2 :: Dict (Z P.* P 2 ~ Z) +_test_Mul_Z_P2 = Dict + +_test_Mul_N1_Z :: Dict (N 1 P.* Z ~ Z) +_test_Mul_N1_Z = Dict +_test_Mul_N1_N1 :: Dict (N 1 P.* N 1 ~ P 1) +_test_Mul_N1_N1 = Dict +_test_Mul_N1_P1 :: Dict (N 1 P.* P 1 ~ N 1) +_test_Mul_N1_P1 = Dict +_test_Mul_N1_N2 :: Dict (N 1 P.* N 2 ~ P 2) +_test_Mul_N1_N2 = Dict +_test_Mul_N1_P2 :: Dict (N 1 P.* P 2 ~ N 2) +_test_Mul_N1_P2 = Dict + +_test_Mul_P1_Z :: Dict (P 1 P.* Z ~ Z) +_test_Mul_P1_Z = Dict +_test_Mul_P1_N1 :: Dict (P 1 P.* N 1 ~ N 1) +_test_Mul_P1_N1 = Dict +_test_Mul_P1_P1 :: Dict (P 1 P.* P 1 ~ P 1) +_test_Mul_P1_P1 = Dict +_test_Mul_P1_N2 :: Dict (P 1 P.* N 2 ~ N 2) +_test_Mul_P1_N2 = Dict +_test_Mul_P1_P2 :: Dict (P 1 P.* P 2 ~ P 2) +_test_Mul_P1_P2 = Dict + +_test_Mul_N2_Z :: Dict (N 2 P.* Z ~ Z) +_test_Mul_N2_Z = Dict +_test_Mul_N2_N1 :: Dict (N 2 P.* N 1 ~ P 2) +_test_Mul_N2_N1 = Dict +_test_Mul_N2_P1 :: Dict (N 2 P.* P 1 ~ N 2) +_test_Mul_N2_P1 = Dict +_test_Mul_N2_N2 :: Dict (N 2 P.* N 2 ~ P 4) +_test_Mul_N2_N2 = Dict +_test_Mul_N2_P2 :: Dict (N 2 P.* P 2 ~ N 4) +_test_Mul_N2_P2 = Dict + +_test_Mul_P2_Z :: Dict (P 2 P.* Z ~ Z) +_test_Mul_P2_Z = Dict +_test_Mul_P2_N1 :: Dict (P 2 P.* N 1 ~ N 2) +_test_Mul_P2_N1 = Dict +_test_Mul_P2_P1 :: Dict (P 2 P.* P 1 ~ P 2) +_test_Mul_P2_P1 = Dict +_test_Mul_P2_N2 :: Dict (P 2 P.* N 2 ~ N 4) +_test_Mul_P2_N2 = Dict +_test_Mul_P2_P2 :: Dict (P 2 P.* P 2 ~ P 4) +_test_Mul_P2_P2 = Dict + +_test_Pow_Z_Z :: Dict (Z K.^ 0 ~ P 1) +_test_Pow_Z_Z = Dict +_test_Pow_Z_1 :: Dict (Z K.^ 1 ~ Z) +_test_Pow_Z_1 = Dict +_test_Pow_Z_2 :: Dict (Z K.^ 2 ~ Z) +_test_Pow_Z_2 = Dict + +_test_Pow_N1_0 :: Dict (N 1 K.^ 0 ~ P 1) +_test_Pow_N1_0 = Dict +_test_Pow_N1_1 :: Dict (N 1 K.^ 1 ~ N 1) +_test_Pow_N1_1 = Dict +_test_Pow_N1_2 :: Dict (N 1 K.^ 2 ~ P 1) +_test_Pow_N1_2 = Dict + +_test_Pow_P1_Z :: Dict (P 1 K.^ 0 ~ P 1) +_test_Pow_P1_Z = Dict +_test_Pow_P1_P1 :: Dict (P 1 K.^ 1 ~ P 1) +_test_Pow_P1_P1 = Dict +_test_Pow_P1_P2 :: Dict (P 1 K.^ 2 ~ P 1) +_test_Pow_P1_P2 = Dict + +_test_Pow_N2_0 :: Dict (N 2 K.^ 0 ~ P 1) +_test_Pow_N2_0 = Dict +_test_Pow_N2_1 :: Dict (N 2 K.^ 1 ~ N 2) +_test_Pow_N2_1 = Dict +_test_Pow_N2_2 :: Dict (N 2 K.^ 2 ~ P 4) +_test_Pow_N2_2 = Dict + +_test_Pow_P2_0 :: Dict (P 2 K.^ 0 ~ P 1) +_test_Pow_P2_0 = Dict +_test_Pow_P2_1 :: Dict (P 2 K.^ 1 ~ P 2) +_test_Pow_P2_1 = Dict +_test_Pow_P2_2 :: Dict (P 2 K.^ 2 ~ P 4) +_test_Pow_P2_2 = Dict + +_test_ZigZag_Z :: Dict (K.ZigZag Z ~ 0) +_test_ZigZag_Z = Dict +_test_ZigZag_N1 :: Dict (K.ZigZag (N 1) ~ 1) +_test_ZigZag_N1 = Dict +_test_ZigZag_P1 :: Dict (K.ZigZag (P 1) ~ 2) +_test_ZigZag_P1 = Dict +_test_ZigZag_N2 :: Dict (K.ZigZag (N 2) ~ 3) +_test_ZigZag_N2 = Dict +_test_ZigZag_P2 :: Dict (K.ZigZag (P 2) ~ 4) +_test_ZigZag_P2 = Dict + +_test_ZagZig_Z :: Dict (K.ZagZig 0 ~ Z) +_test_ZagZig_Z = Dict +_test_ZagZig_N1 :: Dict (K.ZagZig 1 ~ N 1) +_test_ZagZig_N1 = Dict +_test_ZagZig_P1 :: Dict (K.ZagZig 2 ~ P 1) +_test_ZagZig_P1 = Dict +_test_ZagZig_N2 :: Dict (K.ZagZig 3 ~ N 2) +_test_ZagZig_N2 = Dict +_test_ZagZig_P2 :: Dict (K.ZagZig 4 ~ P 2) +_test_ZagZig_P2 = Dict + +_test_FromNatural_0 :: Dict (K.FromNatural 0 ~ Z) +_test_FromNatural_0 = Dict +_test_FromNatural_1 :: Dict (K.FromNatural 1 ~ P 1) +_test_FromNatural_1 = Dict +_test_FromNatural_2 :: Dict (K.FromNatural 2 ~ P 2) +_test_FromNatural_2 = Dict + +_test_Normalized_Z :: Dict (K.Normalized Z ~ Z) +_test_Normalized_Z = Dict +_test_Normalized_N1 :: Dict (K.Normalized (N 1) ~ N 1) +_test_Normalized_N1 = Dict +_test_Normalized_N2 :: Dict (K.Normalized (N 2) ~ N 2) +_test_Normalized_N2 = Dict +_test_Normalized_P1 :: Dict (K.Normalized (P 1) ~ P 1) +_test_Normalized_P1 = Dict +_test_Normalized_P2 :: Dict (K.Normalized (P 2) ~ P 2) +_test_Normalized_P2 = Dict + +_test_KnownInteger_Z :: Dict (K.KnownInteger Z) +_test_KnownInteger_Z = Dict +_test_KnownInteger_N1 :: Dict (K.KnownInteger (N 1)) +_test_KnownInteger_N1 = Dict +_test_KnownInteger_N2 :: Dict (K.KnownInteger (N 2)) +_test_KnownInteger_N2 = Dict +_test_KnownInteger_P1 :: Dict (K.KnownInteger (P 1)) +_test_KnownInteger_P1 = Dict +_test_KnownInteger_P2 :: Dict (K.KnownInteger (P 2)) +_test_KnownInteger_P2 = Dict