diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,20 @@ +# Version 0.1.1 + +* COMPILER ASSISTED BREAKING CHANGE: Removed `Div`, `Mod`, `Quote` + and `Rem` in favour of more polymorphic `Div`, `Mod`. + +* COMPILER ASSISTED BREAKING CHANGE: Removed `integerVal'`. Nothing + wrong with it, just redundant. + +* Export `Sign`, `Abs`, `GCD`, `LCM`, `Odd`, `Even`, `toPrelude`, + `fromPrelude`, `showsPrecTypeLit`, `div`, `mod`, `divMod`, + `DivMod`. + +* Add `Eq`, `Ord`, `Show`, `Read` instances for `Integer`. + +* Minor cabal and documentation improvements. + + # Version 0.1 * Initial version. 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.1 +version: 0.2 license: BSD-3-Clause license-file: LICENSE extra-source-files: README.md CHANGELOG.md @@ -13,7 +13,7 @@ description: Type-level integers. Like KnownNat, but for integers. homepage: https://github.com/k0001/hs-kind bug-reports: https://github.com/k0001/hs-kind/issues -tested-with: GHC ==9.2.5, GHC ==9.4.3 +tested-with: GHC ==9.4.3 source-repository head type: git @@ -26,6 +26,7 @@ build-depends: base ==4.* default-extensions: DataKinds + MultiWayIf NoStarIsType PatternSynonyms TypeFamilies diff --git a/lib/KindInteger.hs b/lib/KindInteger.hs --- a/lib/KindInteger.hs +++ b/lib/KindInteger.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE MagicHash #-} {-# LANGUAGE UndecidableInstances #-} -- | This module provides a type-level representation for term-level @@ -6,27 +5,32 @@ -- So import this module qualified to avoid name conflicts. -- -- @ --- import "KindInteger" qualified as K +-- 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 +module KindInteger {--} + ( -- * Integer kind Integer , type P , type N , Normalize - -- * Linking type and value level - , KnownInteger(integerSing), integerVal, integerVal' + -- * Prelude support + , toPrelude + , fromPrelude + , showsPrecTypeLit + + -- * Types ⇔ Terms + , KnownInteger(integerSing), integerVal , SomeInteger(..) , someIntegerVal , sameInteger - -- ** Singleton values + -- * Singletons , SInteger , pattern SInteger , fromSInteger @@ -35,26 +39,41 @@ -- * Arithmethic , type (+), type (*), type (^), type (-) - , Negate, Div, Mod, Quot, Rem, Log2 + , Odd, Even, Abs, Sign, Negate, GCD, LCM, Log2 + -- ** Division + , Div + , Mod + , DivMod + , Round(..) + -- *** Term-level + , div + , mod + , divMod + -- * Comparisons , CmpInteger , cmpInteger + + -- * Extra , type (==?), type (==), type (/=?), type (/=) - ) where + ) --} + where -import GHC.Base (WithDict(..)) -import GHC.Types (TYPE, Constraint) -import GHC.Show (appPrec, appPrec1) -import GHC.Prim (Proxy#) -import GHC.TypeLits qualified as L +import Control.Exception qualified as Ex +import Data.Bits import Data.Proxy +import Data.Type.Bool (If) import Data.Type.Coercion import Data.Type.Equality (TestEquality(..), (:~:)(..)) -import Data.Type.Bool (If) import Data.Type.Ord +import GHC.Base (WithDict(..)) +import GHC.Real qualified as P +import GHC.Show (appPrec, appPrec1) +import GHC.TypeLits qualified as L +import GHC.Types (TYPE, Constraint) import Numeric.Natural (Natural) -import Prelude hiding (Integer, (==), (/=)) +import Prelude hiding (Integer, (==), (/=), divMod, div, mod) import Prelude qualified as P import Unsafe.Coerce(unsafeCoerce) @@ -72,36 +91,84 @@ -- @'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) data Integer - = Positive Natural - | Negative Natural + = P_ Natural + | N_ Natural +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) = 'Positive x :: 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) = 'Negative x :: Integer +type N (x :: Natural) = 'N_ x :: Integer --- Not used: +-- | Convert a term-level "KindInteger" 'Integer' into a term-level +-- "Prelude" 'P.Integer'. -- --- typeIntegerToTermInteger :: Integer -> P.Integer --- typeIntegerToTermInteger (P n) = toInteger n --- typeIntegerToTermInteger (N n) = negate (toInteger n) - -termIntegerToTypeInteger :: P.Integer -> Integer -termIntegerToTypeInteger i = let n = fromInteger i - in if i >= 0 then Positive n else Negative n +-- @ +-- 'fromPrelude' . 'toPrelude' == 'id' +-- 'toPrelude' . 'fromPrelude' == 'id' +-- @ +toPrelude :: Integer -> P.Integer +toPrelude (P_ n) = toInteger n +toPrelude (N_ n) = negate (toInteger n) --- | We are not interested in giving any instance to type-level 'Integer's, --- so we implement 'showsPrec' here. -showsPrecInteger :: Int -> Integer -> ShowS -showsPrecInteger p i = showParen (p > appPrec) $ case i of - Positive x -> showString "P " . shows x - Negative x -> showString "N " . shows x +-- | 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)) -------------------------------------------------------------------------------- @@ -122,10 +189,6 @@ integerVal :: forall i proxy. KnownInteger i => proxy i -> P.Integer integerVal _ = case integerSing :: SInteger i of UnsafeSInteger x -> x --- | Term-level 'P.Integer' representation of the type-level 'Integer' @i@. -integerVal' :: forall i. KnownInteger i => Proxy# i -> P.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) @@ -173,15 +236,39 @@ -------------------------------------------------------------------------------- infixl 6 +, - -infixl 7 *, `Div`, `Mod`, `Quot`, `Rem` +infixl 7 *, `Div`, `Mod` 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 @@ -210,63 +297,98 @@ -- | Subtraction of type-level 'Integer's. type (a :: Integer) - (b :: Integer) = a + Negate b :: Integer --- | Division ('floor'ed) of type-level 'Integer's. +-- | Get both the quotient and the 'Mod'ulus of the 'Div'ision of +-- type-level 'Integer's @a@ and @b@ using the specified 'Round'ing @r@. -- -- @ --- forall (a :: 'Integer') (b :: 'Integer'). --- /such that/ (b '/=' 0). --- a '==' 'Div' a b '*' 'Negate' b '+' 'Mod' a b +-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). +-- (b '/=' 0) => +-- 'DivMod' r a b '==' '('Div' r a b, 'Mod' r a b) -- @ --- --- * Division by /zero/ doesn't type-check. -type Div (a :: Integer) (b :: Integer) = Div_ (Normalize a) (Normalize b) :: Integer -type family Div_ (a :: Integer) (b :: Integer) :: Integer where - Div_ _ (P 0) = L.TypeError ('L.Text "KindInteger.Div: Division by zero") - Div_ (P a) (P b) = P (L.Div a b) - Div_ (N a) (N b) = Div_ (P a) (P b) - Div_ (P a) (N b) = NN (If (b L.* (L.Div a b) ==? a) (L.Div a b) (L.Div a b L.+ 1)) - Div_ (N a) (P b) = Div_ (P a) (N b) +type DivMod (r :: Round) (a :: Integer) (b :: Integer) = + '( Div r a b, Mod r a b ) :: (Integer, Integer) --- | Modulus ('floor'ed division) of type-level 'Integer's. +-- | Modulus of the division of type-level 'Integer' @a@ by @b@, +-- using the specified 'Round'ing @r@. -- -- @ --- forall (a :: 'Integer') (b :: 'Integer'). --- /such that/ (b '/=' 0). --- a '==' 'Div' a b '*' 'Negate' b '+' 'Mod' a b +-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer'). +-- (b '/=' 0) => +-- 'Mod' r a b '==' a '-' b '*' 'Div' r a b -- @ -- --- * Modulus by /zero/ doesn't type-check. -type Mod (a :: Integer) (b :: Integer) = Div a b * Negate b + a :: Integer +-- * Division by /zero/ doesn't type-check. +type Mod (r :: Round) (a :: Integer) (b :: Integer) = + a - b * Div r a b :: Integer --- | Division ('truncate'd) of type-level 'Integer's. --- --- @ --- forall (a :: 'Integer') (b :: 'Integer'). --- /such that/ (b '/=' 0). --- a '==' 'Quot' a b '*' 'Negate' b '+' 'Rem' a b --- @ +-- | Divide of type-level 'Integer' @a@ by @b@, +-- using the specified 'Round'ing @r@. -- -- * Division by /zero/ doesn't type-check. -type Quot (a :: Integer) (b :: Integer) = Quot_ (Normalize a) (Normalize b) :: Integer -type family Quot_ (a :: Integer) (b :: Integer) :: Integer where - Quot_ _ (P 0) = L.TypeError ('L.Text "KindInteger.Quot: Division by zero") - Quot_ (P a) (P b) = P (L.Div a b) - Quot_ (N a) (N b) = Quot_ (P a) (P b) - Quot_ (P a) (N b) = Negate (Quot_ (P a) (P b)) - Quot_ (N a) (P b) = Quot_ (P a) (N b) +type Div (r :: Round) (a :: Integer) (b :: Integer) = + Div_ r (Normalize a) (Normalize b) :: Integer --- | Remulus ('truncate'd division) of type-level 'Integer's. --- --- @ --- forall (a :: 'Integer') (b :: 'Integer'). --- /such that/ (b '/=' 0). --- a '==' 'Quot' a b '*' 'Negate' b '+' 'Rem' a b --- @ --- --- * Remulus by /zero/ doesn't type-check. -type Rem (a :: Integer) (b :: Integer) = Quot a b * Negate b + a :: 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 --- | Log base 2 ('floor'ed) of integer numbers. +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__ 'RoundUp (P a) b = Negate (Div__ 'RoundDown (N a) b) +-- Div__ 'RoundUp (N a) b = Negate (Div__ 'RoundDown (P 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. -- @@ -277,8 +399,30 @@ Log2_ (P a) = P (L.Log2 a) Log2_ (N a) = L.TypeError ('L.Text "KindInteger.Log2: Logarithm of negative number") --- | Comparison of type-level integers, as a function. -type CmpInteger (a :: Integer) (b :: Integer) = CmpInteger_ (Normalize a) (Normalize b) :: Ordering +-- | 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 @@ -287,7 +431,8 @@ CmpInteger_ (P _) (N _) = 'GT -- | "Data.Type.Ord" support for type-level 'Integer's. -type instance Compare (a :: Integer) (b :: Integer) = CmpInteger a b :: Ordering +type instance Compare (a :: Integer) (b :: Integer) = + CmpInteger a b :: Ordering -------------------------------------------------------------------------------- @@ -310,8 +455,9 @@ -> proxy2 b -> OrderingI a b cmpInteger x y = case compare (integerVal x) (integerVal y) of - EQ -> case unsafeCoerce (Refl, Refl) :: (CmpInteger a b :~: 'EQ, a :~: b) of - (Refl, Refl) -> EQI + 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 @@ -356,7 +502,7 @@ instance Show (SInteger i) where showsPrec p (UnsafeSInteger i) = showParen (p > appPrec) $ showString "SInteger @" . - showsPrecInteger appPrec1 (termIntegerToTypeInteger i) + showsPrec appPrec1 (fromPrelude i) instance TestEquality SInteger where testEquality (UnsafeSInteger x) (UnsafeSInteger y) @@ -366,7 +512,7 @@ instance TestCoercion SInteger where testCoercion x y = fmap (\Refl -> Coercion) (testEquality x y) --- | Return the type-level 'P.Integer' number corresponding to @i@ in +-- | Return the term-level 'P.Integer' number corresponding to @i@ in -- a @'SInteger' i@ value. fromSInteger :: SInteger i -> P.Integer fromSInteger (UnsafeSInteger i) = i @@ -386,19 +532,176 @@ {-# NOINLINE withSomeSInteger #-} -------------------------------------------------------------------------------- + +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' and + -- 'P.mod'. + | RoundZero + -- ^ Round towards __zero__. Also known as "Prelude"'s 'P.truncate'. This is + -- the type of rounding used by "Prelude"'s 'P.quot' and 'P.rem'. + | 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 'divMod'. +div :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> P.Integer -- ^ Quotient @q@. +div r a b = fst (divMod r a b) + +-- | Divide @a@ by @a@ using the specified 'Round'ing. +-- Return the modulus @m@. See 'divMod'. +mod :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> P.Integer -- ^ Modulus @m@. +mod r a b = snd (divMod r a b) + +-- | Divide @a@ by @a@ using the specified 'Round'ing. +-- Return the quotient @q@ and the modulus @m@. +-- +-- @ +-- forall (r :: 'Round') (a :: 'P.Integer') (b :: 'P.Integer'). +-- (b 'P./=' 0) => +-- case 'divMod' r a b of +-- (q, m) -> m 'P.==' a 'P.-' b 'P.*' q +-- @ +divMod + :: Round + -> P.Integer -- ^ Dividend @a@. + -> P.Integer -- ^ Divisor @b@. + -> (P.Integer, P.Integer) -- ^ Quotient @q@ and modulus @m@. +{-# NOINLINE divMod #-} +divMod RoundZero = \a (errDiv0 -> b) -> P.quotRem a b +divMod RoundDown = \a (errDiv0 -> b) -> P.divMod a b +divMod RoundUp = \a (errDiv0 -> b) -> _divModRoundUpNoCheck a b +divMod RoundAway = \a (errDiv0 -> b) -> + if xor (a < 0) (b < 0) + then P.divMod a b + else _divModRoundUpNoCheck a b +divMod RoundHalfUp = _divModHalf $ \_ _ up -> up +divMod RoundHalfDown = _divModHalf $ \_ down _ -> down +divMod RoundHalfZero = _divModHalf $ \neg down up -> + if neg then up else down +divMod RoundHalfAway = _divModHalf $ \neg down up -> + if neg then down else up +divMod RoundHalfEven = _divModHalf $ \_ down up -> + if even (fst down) then down else up +divMod RoundHalfOdd = _divModHalf $ \_ down up -> + if odd (fst down) then down else up + +_divModRoundUpNoCheck :: P.Integer -> P.Integer -> (P.Integer, P.Integer) +_divModRoundUpNoCheck a b = + let q = negate (P.div (negate a) b) + in (q, a - b * q) +{-# INLINE _divModRoundUpNoCheck #-} + +_divModHalf + :: (Bool -> + (P.Integer, P.Integer) -> + (P.Integer, P.Integer) -> + (P.Integer, P.Integer)) + -- ^ Negative -> divMod RoundDown -> divMod RoundDown -> Result + -> P.Integer -- ^ Dividend + -> P.Integer -- ^ Divisor + -> (P.Integer, P.Integer) +_divModHalf f = \a (errDiv0 -> b) -> + let neg = xor (a < 0) (b < 0) + down = P.divMod a b + up = _divModRoundUpNoCheck 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 _divModHalf #-} + +-------------------------------------------------------------------------------- -- Extras infixr 4 /=, /=?, ==, ==? --- | This should be exported by 'Data.Type.Ord'. +-- | 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'. +-- | 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'. +-- | 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'. +-- | 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 diff --git a/test/Main.hs b/test/Main.hs --- a/test/Main.hs +++ b/test/Main.hs @@ -1,374 +1,3320 @@ -{-# LANGUAGE MagicHash #-} -module Main (main) where - -import Control.Applicative -import Data.Maybe -import Data.Proxy -import Data.Type.Ord (type (<=)) -import GHC.Exts (Constraint, proxy#) -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 - ) - -_testDiv = Dict -_testDiv :: Dict - ( P 0 ~ P 0 `K.Div` P 1 - , P 0 ~ N 0 `K.Div` N 1 - , P 0 ~ P 0 `K.Div` N 1 - , P 0 ~ N 0 `K.Div` P 1 - - , P 1 ~ P 1 `K.Div` P 1 - , P 1 ~ N 1 `K.Div` N 1 - , N 1 ~ P 1 `K.Div` N 1 - , N 1 ~ N 1 `K.Div` P 1 - - , P 2 ~ P 2 `K.Div` P 1 - , P 2 ~ N 2 `K.Div` N 1 - , N 2 ~ P 2 `K.Div` N 1 - , N 2 ~ N 2 `K.Div` P 1 - - , P 1 ~ P 2 `K.Div` P 2 - , P 1 ~ N 2 `K.Div` N 2 - , N 1 ~ P 2 `K.Div` N 2 - , N 1 ~ N 2 `K.Div` P 2 - - , P 1 ~ P 3 `K.Div` P 2 - , P 1 ~ N 3 `K.Div` N 2 - , N 2 ~ P 3 `K.Div` N 2 - , N 2 ~ N 3 `K.Div` P 2 - - , P 0 ~ P 0 `K.Div` P 1 - , P 0 ~ N 0 `K.Div` N 1 - , P 0 ~ P 0 `K.Div` N 1 - , P 0 ~ N 0 `K.Div` P 1 - - , P 0 ~ P 1 `K.Div` P 2 - , P 0 ~ N 1 `K.Div` N 2 - , N 1 ~ P 1 `K.Div` N 2 - , N 1 ~ N 1 `K.Div` P 2 - ) - -_testMod = Dict -_testMod :: Dict - ( P 0 ~ P 0 `K.Mod` P 1 - , P 0 ~ N 0 `K.Mod` N 1 - , P 0 ~ P 0 `K.Mod` N 1 - , P 0 ~ N 0 `K.Mod` P 1 - - , P 0 ~ P 1 `K.Mod` P 1 - , P 0 ~ N 1 `K.Mod` N 1 - , P 0 ~ P 1 `K.Mod` N 1 - , P 0 ~ N 1 `K.Mod` P 1 - - , P 0 ~ P 2 `K.Mod` P 1 - , P 0 ~ N 2 `K.Mod` N 1 - , P 0 ~ P 2 `K.Mod` N 1 - , P 0 ~ N 2 `K.Mod` P 1 - - , P 0 ~ P 2 `K.Mod` P 2 - , P 0 ~ N 2 `K.Mod` N 2 - , P 0 ~ P 2 `K.Mod` N 2 - , P 0 ~ N 2 `K.Mod` P 2 - - , P 1 ~ P 3 `K.Mod` P 2 - , N 1 ~ N 3 `K.Mod` N 2 - , N 1 ~ P 3 `K.Mod` N 2 - , P 1 ~ N 3 `K.Mod` P 2 - - , P 0 ~ P 0 `K.Mod` P 1 - , P 0 ~ N 0 `K.Mod` N 1 - , P 0 ~ P 0 `K.Mod` N 1 - , P 0 ~ N 0 `K.Mod` P 1 - - , P 1 ~ P 1 `K.Mod` P 2 - , N 1 ~ N 1 `K.Mod` N 2 - , N 1 ~ P 1 `K.Mod` N 2 - , P 1 ~ N 1 `K.Mod` P 2 - ) - -_testQuot = Dict -_testQuot :: Dict - ( P 0 ~ P 0 `K.Quot` P 1 - , P 0 ~ N 0 `K.Quot` N 1 - , P 0 ~ P 0 `K.Quot` N 1 - , P 0 ~ N 0 `K.Quot` P 1 - - , P 1 ~ P 1 `K.Quot` P 1 - , P 1 ~ N 1 `K.Quot` N 1 - , N 1 ~ P 1 `K.Quot` N 1 - , N 1 ~ N 1 `K.Quot` P 1 - - , P 2 ~ P 2 `K.Quot` P 1 - , P 2 ~ N 2 `K.Quot` N 1 - , N 2 ~ P 2 `K.Quot` N 1 - , N 2 ~ N 2 `K.Quot` P 1 - - , P 1 ~ P 2 `K.Quot` P 2 - , P 1 ~ N 2 `K.Quot` N 2 - , N 1 ~ P 2 `K.Quot` N 2 - , N 1 ~ N 2 `K.Quot` P 2 - - , P 1 ~ P 3 `K.Quot` P 2 - , P 1 ~ N 3 `K.Quot` N 2 - , N 1 ~ P 3 `K.Quot` N 2 - , N 1 ~ N 3 `K.Quot` P 2 - - , P 0 ~ P 0 `K.Quot` P 1 - , P 0 ~ N 0 `K.Quot` N 1 - , P 0 ~ P 0 `K.Quot` N 1 - , P 0 ~ N 0 `K.Quot` P 1 - - , P 0 ~ P 1 `K.Quot` P 2 - , P 0 ~ N 1 `K.Quot` N 2 - , P 0 ~ P 1 `K.Quot` N 2 - , P 0 ~ N 1 `K.Quot` P 2 - ) - -_testRem = Dict -_testRem :: Dict - ( P 0 ~ P 0 `K.Rem` P 1 - , P 0 ~ N 0 `K.Rem` N 1 - , P 0 ~ P 0 `K.Rem` N 1 - , P 0 ~ N 0 `K.Rem` P 1 - - , P 0 ~ P 1 `K.Rem` P 1 - , P 0 ~ N 1 `K.Rem` N 1 - , P 0 ~ P 1 `K.Rem` N 1 - , P 0 ~ N 1 `K.Rem` P 1 - - , P 0 ~ P 2 `K.Rem` P 1 - , P 0 ~ N 2 `K.Rem` N 1 - , P 0 ~ P 2 `K.Rem` N 1 - , P 0 ~ N 2 `K.Rem` P 1 - - , P 0 ~ P 2 `K.Rem` P 2 - , P 0 ~ N 2 `K.Rem` N 2 - , P 0 ~ P 2 `K.Rem` N 2 - , P 0 ~ N 2 `K.Rem` P 2 - - , P 1 ~ P 3 `K.Rem` P 2 - , N 1 ~ N 3 `K.Rem` N 2 - , P 1 ~ P 3 `K.Rem` N 2 - , N 1 ~ N 3 `K.Rem` P 2 - - , P 0 ~ P 0 `K.Rem` P 1 - , P 0 ~ N 0 `K.Rem` N 1 - , P 0 ~ P 0 `K.Rem` N 1 - , P 0 ~ N 0 `K.Rem` P 1 - - , P 1 ~ P 1 `K.Rem` P 2 - , N 1 ~ N 1 `K.Rem` N 2 - , P 1 ~ P 1 `K.Rem` N 2 - , N 1 ~ N 1 `K.Rem` P 2 - ) - -_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) - ) - --------------------------------------------------------------------------------- - -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 - oks <- sequence xs - if and oks - then do putStrLn "All tests passed successfully." - exitSuccess - else do putStrLn "Some tests failed." - exitFailure - -main :: IO () -main = testsMain - [ assert "integerVal . someIntegerVal == id" $ - flip all [-5 .. 5] $ \a -> - case K.someIntegerVal a of - K.SomeInteger pa -> - a == K.integerVal pa - - , assert "integerVal' . someIntegerVal == id" $ - flip all [-5 .. 5] $ \a -> - case K.someIntegerVal a of - K.SomeInteger (_ :: Proxy a) -> - a == K.integerVal' (proxy# @a) - - , 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 "Eq SomeInteger" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - (a == b) == (K.someIntegerVal a == K.someIntegerVal b) - - , assert "Ord SomeInteger" $ - flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> - (a `compare` b) == (K.someIntegerVal a `compare` K.someIntegerVal b) - - , assert "Show SomeInteger" $ - flip all [-5 .. 5] $ \i -> - show i == show (K.someIntegerVal i) - - , assert "Read SomeInteger" $ - flip all [-5 .. 5] $ \i -> - let str = show (i :: Integer) - in readMaybe @Integer str - == fmap (\(K.SomeInteger p) -> K.integerVal p) - (readMaybe @K.SomeInteger str) - - ] - - +module Main {--} + ( main + ) --} + where + +import Control.Applicative +import Control.Exception qualified as Ex +import Control.Monad +import Data.List qualified as List +import Data.Maybe +import Data.Ratio as P +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 -> + 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 "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) -> + (a == b) == (K.someIntegerVal a == K.someIntegerVal b) + + , assert "Ord SomeInteger" $ + flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) -> + (a `compare` b) == (K.someIntegerVal a `compare` K.someIntegerVal b) + + , assert "Show SomeInteger" $ + flip all [-5 .. 5] $ \i -> + show i == show (K.someIntegerVal i) + + , assert "Read SomeInteger" $ + flip all [-5 .. 5] $ \i -> + let str = show (i :: P.Integer) + in readMaybe @P.Integer str + == fmap (\(K.SomeInteger p) -> K.integerVal p) + (readMaybe @K.SomeInteger str) + + ] <> testsDivMod + +testsDivMod :: [IO Bool] +testsDivMod = 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 "divMod" "") $ case K.divMod r a b of + (q, m) -> m == a - b * q + , assert (tname "div" "") $ fst (K.divMod r a b) == K.div r a b + , assert (tname "mod" "") $ snd (K.divMod r a b) == K.mod r a b + ] + + +-------------------------------------------------------------------------------- + +_divModTestCode :: String +_divModTestCode = unlines $ List.sort $ do + b <- [-4 .. 4] + guard (b P./= 0) + a <- [-4 .. 4] + r <- [minBound..maxBound] + let (q, m) = K.divMod 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" + sMod :: ShowS + sMod = sname "Mod" + . showString " :: Dict (K.Mod '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 "Mod" + . showString " = Dict" + ss :: ShowS + ss = sDiv . showChar '\n' . sMod + pure (ss "") + + +-- The following tests are generated by `_divModTestCode` in this module. +-- 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_Mod_RoundAway_N1_N1 :: Dict (K.Mod 'K.RoundAway (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N1_N2 :: Dict (K.Mod 'K.RoundAway (N 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundAway_N1_N3 :: Dict (K.Mod 'K.RoundAway (N 1) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundAway_N1_N4 :: Dict (K.Mod 'K.RoundAway (N 1) (N 4) ~ P 3) +_test_Mod_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_Mod_RoundAway_N1_P1 :: Dict (K.Mod 'K.RoundAway (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N1_P2 :: Dict (K.Mod 'K.RoundAway (N 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundAway_N1_P3 :: Dict (K.Mod 'K.RoundAway (N 1) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundAway_N1_P4 :: Dict (K.Mod 'K.RoundAway (N 1) (P 4) ~ P 3) +_test_Mod_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_Mod_RoundAway_N2_N1 :: Dict (K.Mod 'K.RoundAway (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N2_N2 :: Dict (K.Mod 'K.RoundAway (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_N2_N3 :: Dict (K.Mod 'K.RoundAway (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundAway_N2_N4 :: Dict (K.Mod 'K.RoundAway (N 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundAway_N2_P1 :: Dict (K.Mod 'K.RoundAway (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N2_P2 :: Dict (K.Mod 'K.RoundAway (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_N2_P3 :: Dict (K.Mod 'K.RoundAway (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundAway_N2_P4 :: Dict (K.Mod 'K.RoundAway (N 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundAway_N3_N1 :: Dict (K.Mod 'K.RoundAway (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N3_N2 :: Dict (K.Mod 'K.RoundAway (N 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundAway_N3_N3 :: Dict (K.Mod 'K.RoundAway (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_N3_N4 :: Dict (K.Mod 'K.RoundAway (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundAway_N3_P1 :: Dict (K.Mod 'K.RoundAway (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N3_P2 :: Dict (K.Mod 'K.RoundAway (N 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundAway_N3_P3 :: Dict (K.Mod 'K.RoundAway (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_N3_P4 :: Dict (K.Mod 'K.RoundAway (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundAway_N4_N1 :: Dict (K.Mod 'K.RoundAway (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N4_N2 :: Dict (K.Mod 'K.RoundAway (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_N4_N3 :: Dict (K.Mod 'K.RoundAway (N 4) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundAway_N4_N4 :: Dict (K.Mod 'K.RoundAway (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundAway_N4_P1 :: Dict (K.Mod 'K.RoundAway (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_N4_P2 :: Dict (K.Mod 'K.RoundAway (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_N4_P3 :: Dict (K.Mod 'K.RoundAway (N 4) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundAway_N4_P4 :: Dict (K.Mod 'K.RoundAway (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_N1 :: Dict (K.Mod 'K.RoundAway (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_N2 :: Dict (K.Mod 'K.RoundAway (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_N3 :: Dict (K.Mod 'K.RoundAway (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_N4 :: Dict (K.Mod 'K.RoundAway (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_P1 :: Dict (K.Mod 'K.RoundAway (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_P2 :: Dict (K.Mod 'K.RoundAway (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_P3 :: Dict (K.Mod 'K.RoundAway (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_P0_P4 :: Dict (K.Mod 'K.RoundAway (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundAway_P1_N1 :: Dict (K.Mod 'K.RoundAway (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P1_N2 :: Dict (K.Mod 'K.RoundAway (P 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundAway_P1_N3 :: Dict (K.Mod 'K.RoundAway (P 1) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundAway_P1_N4 :: Dict (K.Mod 'K.RoundAway (P 1) (N 4) ~ N 3) +_test_Mod_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_Mod_RoundAway_P1_P1 :: Dict (K.Mod 'K.RoundAway (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P1_P2 :: Dict (K.Mod 'K.RoundAway (P 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundAway_P1_P3 :: Dict (K.Mod 'K.RoundAway (P 1) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundAway_P1_P4 :: Dict (K.Mod 'K.RoundAway (P 1) (P 4) ~ N 3) +_test_Mod_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_Mod_RoundAway_P2_N1 :: Dict (K.Mod 'K.RoundAway (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P2_N2 :: Dict (K.Mod 'K.RoundAway (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P2_N3 :: Dict (K.Mod 'K.RoundAway (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundAway_P2_N4 :: Dict (K.Mod 'K.RoundAway (P 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundAway_P2_P1 :: Dict (K.Mod 'K.RoundAway (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P2_P2 :: Dict (K.Mod 'K.RoundAway (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P2_P3 :: Dict (K.Mod 'K.RoundAway (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundAway_P2_P4 :: Dict (K.Mod 'K.RoundAway (P 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundAway_P3_N1 :: Dict (K.Mod 'K.RoundAway (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P3_N2 :: Dict (K.Mod 'K.RoundAway (P 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundAway_P3_N3 :: Dict (K.Mod 'K.RoundAway (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_P3_N4 :: Dict (K.Mod 'K.RoundAway (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundAway_P3_P1 :: Dict (K.Mod 'K.RoundAway (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P3_P2 :: Dict (K.Mod 'K.RoundAway (P 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundAway_P3_P3 :: Dict (K.Mod 'K.RoundAway (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundAway_P3_P4 :: Dict (K.Mod 'K.RoundAway (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundAway_P4_N1 :: Dict (K.Mod 'K.RoundAway (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P4_N2 :: Dict (K.Mod 'K.RoundAway (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P4_N3 :: Dict (K.Mod 'K.RoundAway (P 4) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundAway_P4_N4 :: Dict (K.Mod 'K.RoundAway (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundAway_P4_P1 :: Dict (K.Mod 'K.RoundAway (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundAway_P4_P2 :: Dict (K.Mod 'K.RoundAway (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundAway_P4_P3 :: Dict (K.Mod 'K.RoundAway (P 4) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundAway_P4_P4 :: Dict (K.Mod 'K.RoundAway (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_N1_N1 :: Dict (K.Mod 'K.RoundDown (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N1_N2 :: Dict (K.Mod 'K.RoundDown (N 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundDown_N1_N3 :: Dict (K.Mod 'K.RoundDown (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundDown_N1_N4 :: Dict (K.Mod 'K.RoundDown (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundDown_N1_P1 :: Dict (K.Mod 'K.RoundDown (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N1_P2 :: Dict (K.Mod 'K.RoundDown (N 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundDown_N1_P3 :: Dict (K.Mod 'K.RoundDown (N 1) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundDown_N1_P4 :: Dict (K.Mod 'K.RoundDown (N 1) (P 4) ~ P 3) +_test_Mod_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_Mod_RoundDown_N2_N1 :: Dict (K.Mod 'K.RoundDown (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N2_N2 :: Dict (K.Mod 'K.RoundDown (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_N2_N3 :: Dict (K.Mod 'K.RoundDown (N 2) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundDown_N2_N4 :: Dict (K.Mod 'K.RoundDown (N 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundDown_N2_P1 :: Dict (K.Mod 'K.RoundDown (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N2_P2 :: Dict (K.Mod 'K.RoundDown (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_N2_P3 :: Dict (K.Mod 'K.RoundDown (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundDown_N2_P4 :: Dict (K.Mod 'K.RoundDown (N 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundDown_N3_N1 :: Dict (K.Mod 'K.RoundDown (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N3_N2 :: Dict (K.Mod 'K.RoundDown (N 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundDown_N3_N3 :: Dict (K.Mod 'K.RoundDown (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_N3_N4 :: Dict (K.Mod 'K.RoundDown (N 3) (N 4) ~ N 3) +_test_Mod_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_Mod_RoundDown_N3_P1 :: Dict (K.Mod 'K.RoundDown (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N3_P2 :: Dict (K.Mod 'K.RoundDown (N 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundDown_N3_P3 :: Dict (K.Mod 'K.RoundDown (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_N3_P4 :: Dict (K.Mod 'K.RoundDown (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundDown_N4_N1 :: Dict (K.Mod 'K.RoundDown (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N4_N2 :: Dict (K.Mod 'K.RoundDown (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_N4_N3 :: Dict (K.Mod 'K.RoundDown (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundDown_N4_N4 :: Dict (K.Mod 'K.RoundDown (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_N4_P1 :: Dict (K.Mod 'K.RoundDown (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_N4_P2 :: Dict (K.Mod 'K.RoundDown (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_N4_P3 :: Dict (K.Mod 'K.RoundDown (N 4) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundDown_N4_P4 :: Dict (K.Mod 'K.RoundDown (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_N1 :: Dict (K.Mod 'K.RoundDown (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_N2 :: Dict (K.Mod 'K.RoundDown (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_N3 :: Dict (K.Mod 'K.RoundDown (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_N4 :: Dict (K.Mod 'K.RoundDown (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_P1 :: Dict (K.Mod 'K.RoundDown (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_P2 :: Dict (K.Mod 'K.RoundDown (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_P3 :: Dict (K.Mod 'K.RoundDown (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_P0_P4 :: Dict (K.Mod 'K.RoundDown (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_P1_N1 :: Dict (K.Mod 'K.RoundDown (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P1_N2 :: Dict (K.Mod 'K.RoundDown (P 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundDown_P1_N3 :: Dict (K.Mod 'K.RoundDown (P 1) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundDown_P1_N4 :: Dict (K.Mod 'K.RoundDown (P 1) (N 4) ~ N 3) +_test_Mod_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_Mod_RoundDown_P1_P1 :: Dict (K.Mod 'K.RoundDown (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P1_P2 :: Dict (K.Mod 'K.RoundDown (P 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundDown_P1_P3 :: Dict (K.Mod 'K.RoundDown (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundDown_P1_P4 :: Dict (K.Mod 'K.RoundDown (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundDown_P2_N1 :: Dict (K.Mod 'K.RoundDown (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P2_N2 :: Dict (K.Mod 'K.RoundDown (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P2_N3 :: Dict (K.Mod 'K.RoundDown (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundDown_P2_N4 :: Dict (K.Mod 'K.RoundDown (P 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundDown_P2_P1 :: Dict (K.Mod 'K.RoundDown (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P2_P2 :: Dict (K.Mod 'K.RoundDown (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P2_P3 :: Dict (K.Mod 'K.RoundDown (P 2) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundDown_P2_P4 :: Dict (K.Mod 'K.RoundDown (P 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundDown_P3_N1 :: Dict (K.Mod 'K.RoundDown (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P3_N2 :: Dict (K.Mod 'K.RoundDown (P 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundDown_P3_N3 :: Dict (K.Mod 'K.RoundDown (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_P3_N4 :: Dict (K.Mod 'K.RoundDown (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundDown_P3_P1 :: Dict (K.Mod 'K.RoundDown (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P3_P2 :: Dict (K.Mod 'K.RoundDown (P 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundDown_P3_P3 :: Dict (K.Mod 'K.RoundDown (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundDown_P3_P4 :: Dict (K.Mod 'K.RoundDown (P 3) (P 4) ~ P 3) +_test_Mod_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_Mod_RoundDown_P4_N1 :: Dict (K.Mod 'K.RoundDown (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P4_N2 :: Dict (K.Mod 'K.RoundDown (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P4_N3 :: Dict (K.Mod 'K.RoundDown (P 4) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundDown_P4_N4 :: Dict (K.Mod 'K.RoundDown (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundDown_P4_P1 :: Dict (K.Mod 'K.RoundDown (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundDown_P4_P2 :: Dict (K.Mod 'K.RoundDown (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundDown_P4_P3 :: Dict (K.Mod 'K.RoundDown (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundDown_P4_P4 :: Dict (K.Mod 'K.RoundDown (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N1_N1 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N1_N2 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N1_N3 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N1_N4 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N1_P1 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N1_P2 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N1_P3 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N1_P4 :: Dict (K.Mod 'K.RoundHalfAway (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N2_N1 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N2_N2 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N2_N3 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N2_N4 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfAway_N2_P1 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N2_P2 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N2_P3 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N2_P4 :: Dict (K.Mod 'K.RoundHalfAway (N 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfAway_N3_N1 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N3_N2 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N3_N3 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N3_N4 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N3_P1 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N3_P2 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N3_P3 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N3_P4 :: Dict (K.Mod 'K.RoundHalfAway (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_N4_N1 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N4_N2 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N4_N3 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N4_N4 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N4_P1 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N4_P2 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_N4_P3 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_N4_P4 :: Dict (K.Mod 'K.RoundHalfAway (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_N1 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_N2 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_N3 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_N4 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_P1 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_P2 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_P3 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P0_P4 :: Dict (K.Mod 'K.RoundHalfAway (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P1_N1 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P1_N2 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P1_N3 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P1_N4 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P1_P1 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P1_P2 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P1_P3 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P1_P4 :: Dict (K.Mod 'K.RoundHalfAway (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P2_N1 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P2_N2 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P2_N3 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P2_N4 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfAway_P2_P1 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P2_P2 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P2_P3 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P2_P4 :: Dict (K.Mod 'K.RoundHalfAway (P 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfAway_P3_N1 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P3_N2 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P3_N3 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P3_N4 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P3_P1 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P3_P2 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P3_P3 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P3_P4 :: Dict (K.Mod 'K.RoundHalfAway (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfAway_P4_N1 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P4_N2 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P4_N3 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P4_N4 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P4_P1 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P4_P2 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfAway_P4_P3 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfAway_P4_P4 :: Dict (K.Mod 'K.RoundHalfAway (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N1_N1 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N1_N2 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N1_N3 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N1_N4 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N1_P1 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N1_P2 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N1_P3 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N1_P4 :: Dict (K.Mod 'K.RoundHalfDown (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N2_N1 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N2_N2 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N2_N3 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N2_N4 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfDown_N2_P1 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N2_P2 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N2_P3 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N2_P4 :: Dict (K.Mod 'K.RoundHalfDown (N 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfDown_N3_N1 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N3_N2 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N3_N3 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N3_N4 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N3_P1 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N3_P2 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N3_P3 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N3_P4 :: Dict (K.Mod 'K.RoundHalfDown (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_N4_N1 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N4_N2 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N4_N3 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N4_N4 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N4_P1 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N4_P2 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_N4_P3 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_N4_P4 :: Dict (K.Mod 'K.RoundHalfDown (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_N1 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_N2 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_N3 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_N4 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_P1 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_P2 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_P3 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P0_P4 :: Dict (K.Mod 'K.RoundHalfDown (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P1_N1 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P1_N2 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P1_N3 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P1_N4 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P1_P1 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P1_P2 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P1_P3 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P1_P4 :: Dict (K.Mod 'K.RoundHalfDown (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P2_N1 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P2_N2 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P2_N3 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P2_N4 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfDown_P2_P1 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P2_P2 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P2_P3 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P2_P4 :: Dict (K.Mod 'K.RoundHalfDown (P 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfDown_P3_N1 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P3_N2 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P3_N3 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P3_N4 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P3_P1 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P3_P2 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P3_P3 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P3_P4 :: Dict (K.Mod 'K.RoundHalfDown (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfDown_P4_N1 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P4_N2 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P4_N3 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P4_N4 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P4_P1 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P4_P2 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfDown_P4_P3 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfDown_P4_P4 :: Dict (K.Mod 'K.RoundHalfDown (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N1_N1 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N1_N2 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N1_N3 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N1_N4 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N1_P1 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N1_P2 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N1_P3 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N1_P4 :: Dict (K.Mod 'K.RoundHalfEven (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N2_N1 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N2_N2 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N2_N3 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N2_N4 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfEven_N2_P1 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N2_P2 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N2_P3 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N2_P4 :: Dict (K.Mod 'K.RoundHalfEven (N 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfEven_N3_N1 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N3_N2 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N3_N3 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N3_N4 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N3_P1 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N3_P2 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N3_P3 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N3_P4 :: Dict (K.Mod 'K.RoundHalfEven (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_N4_N1 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N4_N2 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N4_N3 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N4_N4 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N4_P1 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N4_P2 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_N4_P3 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_N4_P4 :: Dict (K.Mod 'K.RoundHalfEven (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_N1 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_N2 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_N3 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_N4 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_P1 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_P2 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_P3 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P0_P4 :: Dict (K.Mod 'K.RoundHalfEven (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P1_N1 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P1_N2 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P1_N3 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P1_N4 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P1_P1 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P1_P2 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P1_P3 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P1_P4 :: Dict (K.Mod 'K.RoundHalfEven (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P2_N1 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P2_N2 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P2_N3 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P2_N4 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfEven_P2_P1 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P2_P2 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P2_P3 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P2_P4 :: Dict (K.Mod 'K.RoundHalfEven (P 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfEven_P3_N1 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P3_N2 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P3_N3 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P3_N4 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P3_P1 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P3_P2 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P3_P3 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P3_P4 :: Dict (K.Mod 'K.RoundHalfEven (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfEven_P4_N1 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P4_N2 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P4_N3 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P4_N4 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P4_P1 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P4_P2 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfEven_P4_P3 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfEven_P4_P4 :: Dict (K.Mod 'K.RoundHalfEven (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N1_N1 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N1_N2 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N1_N3 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N1_N4 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N1_P1 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N1_P2 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N1_P3 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N1_P4 :: Dict (K.Mod 'K.RoundHalfOdd (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N2_N1 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N2_N2 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N2_N3 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N2_N4 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfOdd_N2_P1 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N2_P2 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N2_P3 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N2_P4 :: Dict (K.Mod 'K.RoundHalfOdd (N 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfOdd_N3_N1 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N3_N2 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N3_N3 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N3_N4 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N3_P1 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N3_P2 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N3_P3 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N3_P4 :: Dict (K.Mod 'K.RoundHalfOdd (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_N4_N1 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N4_N2 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N4_N3 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N4_N4 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N4_P1 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N4_P2 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_N4_P3 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_N4_P4 :: Dict (K.Mod 'K.RoundHalfOdd (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_N1 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_N2 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_N3 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_N4 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_P1 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_P2 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_P3 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P0_P4 :: Dict (K.Mod 'K.RoundHalfOdd (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P1_N1 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P1_N2 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P1_N3 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P1_N4 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P1_P1 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P1_P2 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P1_P3 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P1_P4 :: Dict (K.Mod 'K.RoundHalfOdd (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P2_N1 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P2_N2 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P2_N3 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P2_N4 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfOdd_P2_P1 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P2_P2 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P2_P3 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P2_P4 :: Dict (K.Mod 'K.RoundHalfOdd (P 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfOdd_P3_N1 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P3_N2 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P3_N3 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P3_N4 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P3_P1 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P3_P2 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P3_P3 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P3_P4 :: Dict (K.Mod 'K.RoundHalfOdd (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfOdd_P4_N1 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P4_N2 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P4_N3 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P4_N4 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P4_P1 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P4_P2 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfOdd_P4_P3 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfOdd_P4_P4 :: Dict (K.Mod 'K.RoundHalfOdd (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N1_N1 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N1_N2 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N1_N3 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N1_N4 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N1_P1 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N1_P2 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N1_P3 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N1_P4 :: Dict (K.Mod 'K.RoundHalfUp (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N2_N1 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N2_N2 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N2_N3 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N2_N4 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfUp_N2_P1 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N2_P2 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N2_P3 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N2_P4 :: Dict (K.Mod 'K.RoundHalfUp (N 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfUp_N3_N1 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N3_N2 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N3_N3 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N3_N4 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N3_P1 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N3_P2 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N3_P3 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N3_P4 :: Dict (K.Mod 'K.RoundHalfUp (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_N4_N1 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N4_N2 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N4_N3 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N4_N4 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N4_P1 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N4_P2 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_N4_P3 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_N4_P4 :: Dict (K.Mod 'K.RoundHalfUp (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_N1 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_N2 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_N3 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_N4 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_P1 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_P2 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_P3 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P0_P4 :: Dict (K.Mod 'K.RoundHalfUp (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P1_N1 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P1_N2 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P1_N3 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P1_N4 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P1_P1 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P1_P2 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P1_P3 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P1_P4 :: Dict (K.Mod 'K.RoundHalfUp (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P2_N1 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P2_N2 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P2_N3 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P2_N4 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfUp_P2_P1 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P2_P2 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P2_P3 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P2_P4 :: Dict (K.Mod 'K.RoundHalfUp (P 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfUp_P3_N1 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P3_N2 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P3_N3 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P3_N4 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P3_P1 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P3_P2 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P3_P3 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P3_P4 :: Dict (K.Mod 'K.RoundHalfUp (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfUp_P4_N1 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P4_N2 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P4_N3 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P4_N4 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P4_P1 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P4_P2 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfUp_P4_P3 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfUp_P4_P4 :: Dict (K.Mod 'K.RoundHalfUp (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N1_N1 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N1_N2 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N1_N3 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N1_N4 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N1_P1 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N1_P2 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N1_P3 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N1_P4 :: Dict (K.Mod 'K.RoundHalfZero (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N2_N1 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N2_N2 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N2_N3 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_N2_N4 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfZero_N2_P1 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N2_P2 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N2_P3 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_N2_P4 :: Dict (K.Mod 'K.RoundHalfZero (N 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundHalfZero_N3_N1 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N3_N2 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N3_N3 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N3_N4 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_N3_P1 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N3_P2 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N3_P3 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N3_P4 :: Dict (K.Mod 'K.RoundHalfZero (N 3) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_N4_N1 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N4_N2 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N4_N3 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N4_N4 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N4_P1 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N4_P2 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_N4_P3 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_N4_P4 :: Dict (K.Mod 'K.RoundHalfZero (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_N1 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_N2 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_N3 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_N4 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_P1 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_P2 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_P3 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P0_P4 :: Dict (K.Mod 'K.RoundHalfZero (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P1_N1 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P1_N2 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P1_N3 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P1_N4 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P1_P1 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P1_P2 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P1_P3 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P1_P4 :: Dict (K.Mod 'K.RoundHalfZero (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P2_N1 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P2_N2 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P2_N3 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_P2_N4 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfZero_P2_P1 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P2_P2 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P2_P3 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_P2_P4 :: Dict (K.Mod 'K.RoundHalfZero (P 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundHalfZero_P3_N1 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P3_N2 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P3_N3 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P3_N4 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_P3_P1 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P3_P2 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P3_P3 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P3_P4 :: Dict (K.Mod 'K.RoundHalfZero (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundHalfZero_P4_N1 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P4_N2 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P4_N3 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P4_N4 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P4_P1 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P4_P2 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundHalfZero_P4_P3 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundHalfZero_P4_P4 :: Dict (K.Mod 'K.RoundHalfZero (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_N1_N1 :: Dict (K.Mod 'K.RoundUp (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N1_N2 :: Dict (K.Mod 'K.RoundUp (N 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundUp_N1_N3 :: Dict (K.Mod 'K.RoundUp (N 1) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundUp_N1_N4 :: Dict (K.Mod 'K.RoundUp (N 1) (N 4) ~ P 3) +_test_Mod_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_Mod_RoundUp_N1_P1 :: Dict (K.Mod 'K.RoundUp (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N1_P2 :: Dict (K.Mod 'K.RoundUp (N 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundUp_N1_P3 :: Dict (K.Mod 'K.RoundUp (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundUp_N1_P4 :: Dict (K.Mod 'K.RoundUp (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundUp_N2_N1 :: Dict (K.Mod 'K.RoundUp (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N2_N2 :: Dict (K.Mod 'K.RoundUp (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_N2_N3 :: Dict (K.Mod 'K.RoundUp (N 2) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundUp_N2_N4 :: Dict (K.Mod 'K.RoundUp (N 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundUp_N2_P1 :: Dict (K.Mod 'K.RoundUp (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N2_P2 :: Dict (K.Mod 'K.RoundUp (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_N2_P3 :: Dict (K.Mod 'K.RoundUp (N 2) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundUp_N2_P4 :: Dict (K.Mod 'K.RoundUp (N 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundUp_N3_N1 :: Dict (K.Mod 'K.RoundUp (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N3_N2 :: Dict (K.Mod 'K.RoundUp (N 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundUp_N3_N3 :: Dict (K.Mod 'K.RoundUp (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_N3_N4 :: Dict (K.Mod 'K.RoundUp (N 3) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundUp_N3_P1 :: Dict (K.Mod 'K.RoundUp (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N3_P2 :: Dict (K.Mod 'K.RoundUp (N 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundUp_N3_P3 :: Dict (K.Mod 'K.RoundUp (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_N3_P4 :: Dict (K.Mod 'K.RoundUp (N 3) (P 4) ~ N 3) +_test_Mod_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_Mod_RoundUp_N4_N1 :: Dict (K.Mod 'K.RoundUp (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N4_N2 :: Dict (K.Mod 'K.RoundUp (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_N4_N3 :: Dict (K.Mod 'K.RoundUp (N 4) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundUp_N4_N4 :: Dict (K.Mod 'K.RoundUp (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_N4_P1 :: Dict (K.Mod 'K.RoundUp (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_N4_P2 :: Dict (K.Mod 'K.RoundUp (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_N4_P3 :: Dict (K.Mod 'K.RoundUp (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundUp_N4_P4 :: Dict (K.Mod 'K.RoundUp (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_N1 :: Dict (K.Mod 'K.RoundUp (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_N2 :: Dict (K.Mod 'K.RoundUp (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_N3 :: Dict (K.Mod 'K.RoundUp (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_N4 :: Dict (K.Mod 'K.RoundUp (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_P1 :: Dict (K.Mod 'K.RoundUp (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_P2 :: Dict (K.Mod 'K.RoundUp (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_P3 :: Dict (K.Mod 'K.RoundUp (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_P0_P4 :: Dict (K.Mod 'K.RoundUp (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_P1_N1 :: Dict (K.Mod 'K.RoundUp (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P1_N2 :: Dict (K.Mod 'K.RoundUp (P 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundUp_P1_N3 :: Dict (K.Mod 'K.RoundUp (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundUp_P1_N4 :: Dict (K.Mod 'K.RoundUp (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundUp_P1_P1 :: Dict (K.Mod 'K.RoundUp (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P1_P2 :: Dict (K.Mod 'K.RoundUp (P 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundUp_P1_P3 :: Dict (K.Mod 'K.RoundUp (P 1) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundUp_P1_P4 :: Dict (K.Mod 'K.RoundUp (P 1) (P 4) ~ N 3) +_test_Mod_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_Mod_RoundUp_P2_N1 :: Dict (K.Mod 'K.RoundUp (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P2_N2 :: Dict (K.Mod 'K.RoundUp (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P2_N3 :: Dict (K.Mod 'K.RoundUp (P 2) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundUp_P2_N4 :: Dict (K.Mod 'K.RoundUp (P 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundUp_P2_P1 :: Dict (K.Mod 'K.RoundUp (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P2_P2 :: Dict (K.Mod 'K.RoundUp (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P2_P3 :: Dict (K.Mod 'K.RoundUp (P 2) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundUp_P2_P4 :: Dict (K.Mod 'K.RoundUp (P 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundUp_P3_N1 :: Dict (K.Mod 'K.RoundUp (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P3_N2 :: Dict (K.Mod 'K.RoundUp (P 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundUp_P3_N3 :: Dict (K.Mod 'K.RoundUp (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_P3_N4 :: Dict (K.Mod 'K.RoundUp (P 3) (N 4) ~ P 3) +_test_Mod_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_Mod_RoundUp_P3_P1 :: Dict (K.Mod 'K.RoundUp (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P3_P2 :: Dict (K.Mod 'K.RoundUp (P 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundUp_P3_P3 :: Dict (K.Mod 'K.RoundUp (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundUp_P3_P4 :: Dict (K.Mod 'K.RoundUp (P 3) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundUp_P4_N1 :: Dict (K.Mod 'K.RoundUp (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P4_N2 :: Dict (K.Mod 'K.RoundUp (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P4_N3 :: Dict (K.Mod 'K.RoundUp (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundUp_P4_N4 :: Dict (K.Mod 'K.RoundUp (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundUp_P4_P1 :: Dict (K.Mod 'K.RoundUp (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundUp_P4_P2 :: Dict (K.Mod 'K.RoundUp (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundUp_P4_P3 :: Dict (K.Mod 'K.RoundUp (P 4) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundUp_P4_P4 :: Dict (K.Mod 'K.RoundUp (P 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_N1_N1 :: Dict (K.Mod 'K.RoundZero (N 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N1_N2 :: Dict (K.Mod 'K.RoundZero (N 1) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundZero_N1_N3 :: Dict (K.Mod 'K.RoundZero (N 1) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundZero_N1_N4 :: Dict (K.Mod 'K.RoundZero (N 1) (N 4) ~ N 1) +_test_Mod_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_Mod_RoundZero_N1_P1 :: Dict (K.Mod 'K.RoundZero (N 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N1_P2 :: Dict (K.Mod 'K.RoundZero (N 1) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundZero_N1_P3 :: Dict (K.Mod 'K.RoundZero (N 1) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundZero_N1_P4 :: Dict (K.Mod 'K.RoundZero (N 1) (P 4) ~ N 1) +_test_Mod_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_Mod_RoundZero_N2_N1 :: Dict (K.Mod 'K.RoundZero (N 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N2_N2 :: Dict (K.Mod 'K.RoundZero (N 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_N2_N3 :: Dict (K.Mod 'K.RoundZero (N 2) (N 3) ~ N 2) +_test_Mod_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_Mod_RoundZero_N2_N4 :: Dict (K.Mod 'K.RoundZero (N 2) (N 4) ~ N 2) +_test_Mod_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_Mod_RoundZero_N2_P1 :: Dict (K.Mod 'K.RoundZero (N 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N2_P2 :: Dict (K.Mod 'K.RoundZero (N 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_N2_P3 :: Dict (K.Mod 'K.RoundZero (N 2) (P 3) ~ N 2) +_test_Mod_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_Mod_RoundZero_N2_P4 :: Dict (K.Mod 'K.RoundZero (N 2) (P 4) ~ N 2) +_test_Mod_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_Mod_RoundZero_N3_N1 :: Dict (K.Mod 'K.RoundZero (N 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N3_N2 :: Dict (K.Mod 'K.RoundZero (N 3) (N 2) ~ N 1) +_test_Mod_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_Mod_RoundZero_N3_N3 :: Dict (K.Mod 'K.RoundZero (N 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_N3_N4 :: Dict (K.Mod 'K.RoundZero (N 3) (N 4) ~ N 3) +_test_Mod_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_Mod_RoundZero_N3_P1 :: Dict (K.Mod 'K.RoundZero (N 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N3_P2 :: Dict (K.Mod 'K.RoundZero (N 3) (P 2) ~ N 1) +_test_Mod_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_Mod_RoundZero_N3_P3 :: Dict (K.Mod 'K.RoundZero (N 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_N3_P4 :: Dict (K.Mod 'K.RoundZero (N 3) (P 4) ~ N 3) +_test_Mod_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_Mod_RoundZero_N4_N1 :: Dict (K.Mod 'K.RoundZero (N 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N4_N2 :: Dict (K.Mod 'K.RoundZero (N 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_N4_N3 :: Dict (K.Mod 'K.RoundZero (N 4) (N 3) ~ N 1) +_test_Mod_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_Mod_RoundZero_N4_N4 :: Dict (K.Mod 'K.RoundZero (N 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_N4_P1 :: Dict (K.Mod 'K.RoundZero (N 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_N4_P2 :: Dict (K.Mod 'K.RoundZero (N 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_N4_P3 :: Dict (K.Mod 'K.RoundZero (N 4) (P 3) ~ N 1) +_test_Mod_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_Mod_RoundZero_N4_P4 :: Dict (K.Mod 'K.RoundZero (N 4) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_N1 :: Dict (K.Mod 'K.RoundZero (P 0) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_N2 :: Dict (K.Mod 'K.RoundZero (P 0) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_N3 :: Dict (K.Mod 'K.RoundZero (P 0) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_N4 :: Dict (K.Mod 'K.RoundZero (P 0) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_P1 :: Dict (K.Mod 'K.RoundZero (P 0) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_P2 :: Dict (K.Mod 'K.RoundZero (P 0) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_P3 :: Dict (K.Mod 'K.RoundZero (P 0) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_P0_P4 :: Dict (K.Mod 'K.RoundZero (P 0) (P 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_P1_N1 :: Dict (K.Mod 'K.RoundZero (P 1) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P1_N2 :: Dict (K.Mod 'K.RoundZero (P 1) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundZero_P1_N3 :: Dict (K.Mod 'K.RoundZero (P 1) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundZero_P1_N4 :: Dict (K.Mod 'K.RoundZero (P 1) (N 4) ~ P 1) +_test_Mod_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_Mod_RoundZero_P1_P1 :: Dict (K.Mod 'K.RoundZero (P 1) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P1_P2 :: Dict (K.Mod 'K.RoundZero (P 1) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundZero_P1_P3 :: Dict (K.Mod 'K.RoundZero (P 1) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundZero_P1_P4 :: Dict (K.Mod 'K.RoundZero (P 1) (P 4) ~ P 1) +_test_Mod_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_Mod_RoundZero_P2_N1 :: Dict (K.Mod 'K.RoundZero (P 2) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P2_N2 :: Dict (K.Mod 'K.RoundZero (P 2) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P2_N3 :: Dict (K.Mod 'K.RoundZero (P 2) (N 3) ~ P 2) +_test_Mod_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_Mod_RoundZero_P2_N4 :: Dict (K.Mod 'K.RoundZero (P 2) (N 4) ~ P 2) +_test_Mod_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_Mod_RoundZero_P2_P1 :: Dict (K.Mod 'K.RoundZero (P 2) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P2_P2 :: Dict (K.Mod 'K.RoundZero (P 2) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P2_P3 :: Dict (K.Mod 'K.RoundZero (P 2) (P 3) ~ P 2) +_test_Mod_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_Mod_RoundZero_P2_P4 :: Dict (K.Mod 'K.RoundZero (P 2) (P 4) ~ P 2) +_test_Mod_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_Mod_RoundZero_P3_N1 :: Dict (K.Mod 'K.RoundZero (P 3) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P3_N2 :: Dict (K.Mod 'K.RoundZero (P 3) (N 2) ~ P 1) +_test_Mod_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_Mod_RoundZero_P3_N3 :: Dict (K.Mod 'K.RoundZero (P 3) (N 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_P3_N4 :: Dict (K.Mod 'K.RoundZero (P 3) (N 4) ~ P 3) +_test_Mod_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_Mod_RoundZero_P3_P1 :: Dict (K.Mod 'K.RoundZero (P 3) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P3_P2 :: Dict (K.Mod 'K.RoundZero (P 3) (P 2) ~ P 1) +_test_Mod_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_Mod_RoundZero_P3_P3 :: Dict (K.Mod 'K.RoundZero (P 3) (P 3) ~ P 0) +_test_Mod_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_Mod_RoundZero_P3_P4 :: Dict (K.Mod 'K.RoundZero (P 3) (P 4) ~ P 3) +_test_Mod_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_Mod_RoundZero_P4_N1 :: Dict (K.Mod 'K.RoundZero (P 4) (N 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P4_N2 :: Dict (K.Mod 'K.RoundZero (P 4) (N 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P4_N3 :: Dict (K.Mod 'K.RoundZero (P 4) (N 3) ~ P 1) +_test_Mod_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_Mod_RoundZero_P4_N4 :: Dict (K.Mod 'K.RoundZero (P 4) (N 4) ~ P 0) +_test_Mod_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_Mod_RoundZero_P4_P1 :: Dict (K.Mod 'K.RoundZero (P 4) (P 1) ~ P 0) +_test_Mod_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_Mod_RoundZero_P4_P2 :: Dict (K.Mod 'K.RoundZero (P 4) (P 2) ~ P 0) +_test_Mod_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_Mod_RoundZero_P4_P3 :: Dict (K.Mod 'K.RoundZero (P 4) (P 3) ~ P 1) +_test_Mod_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_Mod_RoundZero_P4_P4 :: Dict (K.Mod 'K.RoundZero (P 4) (P 4) ~ P 0) +_test_Mod_RoundZero_P4_P4 = Dict