kind-integer 0.1 → 0.2
raw patch · 4 files changed
+3737/−470 lines, 4 files
Files
- CHANGELOG.md +17/−0
- kind-integer.cabal +3/−2
- lib/KindInteger.hs +397/−94
- test/Main.hs +3320/−374
CHANGELOG.md view
@@ -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.
kind-integer.cabal view
@@ -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
lib/KindInteger.hs view
@@ -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))) <? ('Rat (P 1) 2) :: Bool++errDiv0 :: P.Integer -> P.Integer+errDiv0 0 = Ex.throw Ex.DivideByZero+errDiv0 i = i
test/Main.hs view
@@ -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