kind-integer 0.5 → 0.6.0

raw patch · 5 files changed

+5042/−4127 lines, 5 filesdep +singletons-basePVP ok

version bump matches the API change (PVP)

Dependencies added: singletons-base

API changes (from Hackage documentation)

Files

• CHANGELOG.md +36/−0
• kind-integer.cabal +8/−3
• lib/KindInteger.hs +1281/−763
• lib/KindInteger/Round.hs +73/−0
• test/Main.hs +3644/−3361

@@ -1,3 +1,39 @@+# Version 0.6.0++* COMPILER ASSISTED BREAKING CHANGE: `KindInteger.Integer` is now+  is now only ever used as a kind. So, all term-level functions in+  the `KindInteger` consume and produce `Prelude.Integer`s.++* COMPILER ASSISTED BREAKING CHANGE: Removed `Eq`, `Ord`, `Show` and+  `Read` instances for `KindInteger.Integer`.++* COMPILER ASSISTED BREAKING CHANGE: `Z` is now used to represent+  zero, instead of the previous `P 0`.++* COMPILER ASSISTED BREAKING CHANGE: `P 0` and `N 0` are not+  `KnownInteger`s anymore.++* COMPILER ASSISTED BREAKING CHANGE: `KnownInteger` is now a type-synonym+  that implies `Normalized i ~ i` and `KnownNat (Abs i)` as well.++* Added `readPrecTypeLit`.++* Added `Normalized`.++* Added `singletons-base` support for `Integer`, including `PNum`, `SNum`,+  `PEq`, `SEq`, `POrd`, `SOrd`, `PShow` and `SShow`. Most arithmetic+  functions are now exported through `PNum` and `SNum`, rather than standalone.++* Added `ShowLit`, `ShowsLit`, `ShowsPrecLit` and its singletons and+  promoted versions.++* Added `Fold` and `sFold`.++* Added defunctionalization symbols.++* Added ZigZag encoding and decoding tools.++ # Version 0.5  * COMPILER ASSISTED BREAKING CHANGE: `integerVal`, `someIntegerVal`,

@@ -1,6 +1,6 @@ cabal-version: 2.4 name: kind-integer-version: 0.5+version: 0.6.0 license: BSD-3-Clause license-file: LICENSE extra-source-files: README.md CHANGELOG.md@@ -23,9 +23,14 @@ common basic   default-language: GHC2021   ghc-options: -O2 -Wall -Werror=incomplete-patterns-  build-depends: base ==4.*+  build-depends:+    base ==4.*,+    singletons,+    singletons-base,   default-extensions:     DataKinds+    DerivingStrategies+    LambdaCase     MultiWayIf     NoStarIsType     RoleAnnotations@@ -36,9 +41,9 @@  library   import: basic-  build-depends: singletons   hs-source-dirs: lib   exposed-modules: KindInteger+  other-modules: KindInteger.Round  test-suite test   import: basic

@@ -1,764 +1,1282 @@-{-# LANGUAGE UndecidableInstances #-}---- | This module provides a type-level representation for term-level--- 'P.Integer's. This type-level representation is also named 'P.Integer',--- So import this module qualified to avoid name conflicts.------ @--- import "KindInteger" qualified as KI--- @------ The implementation details are the same as the ones for type-level 'Natural's--- in "GHC.TypeNats" as of @base-4.18@, and it will continue to evolve together--- with @base@, trying to follow its API as much as possible until the day--- @base@ provides its own type-level integer, making this module redundant.-module KindInteger {--}-  ( -- * Integer kind-    Integer-  , type P-  , type N-  , Normalize--    -- * Prelude support-  , toPrelude-  , fromPrelude-  , showsPrecTypeLit--    -- * Types ⇔ Terms-  , KnownInteger(integerSing), integerVal-  , SomeInteger(..)-  , someIntegerVal-  , sameInteger--    -- * Singletons-  , SInteger-  , pattern SInteger-  , fromSInteger-  , withSomeSInteger-  , withKnownInteger--    -- * Arithmethic-  , type (+), type (*), type (^), type (-)-  , Odd, Even, Abs, Sign, Negate, GCD, LCM, Log2--    -- ** Division-  , Div-  , Rem-  , DivRem-  , Round(..)-    -- *** Term-level-  , div-  , rem-  , divRem--    -- * Comparisons-  , CmpInteger-  , cmpInteger-  , eqIntegerRep--    -- * Extra-  , type (==?), type (==), type (/=?), type (/=)-  ) --}-  where--import Control.Exception qualified as Ex-import Data.Bits-import Data.Proxy-import Data.Singletons-import Data.Singletons.Decide-import Data.Type.Bool (If)-import Data.Type.Coercion-import Data.Type.Equality (TestEquality(..))-import Data.Type.Ord-import GHC.Base (WithDict(..))-import GHC.Exts (TYPE, Constraint)-import GHC.Real qualified as P-import GHC.Show (appPrec, appPrec1)-import GHC.TypeLits qualified as L-import Numeric.Natural (Natural)-import Prelude hiding (Integer, (==), (/=), div, rem)-import Prelude qualified as P-import Unsafe.Coerce(unsafeCoerce)-------------------------------------------------------------------------------------- | Type-level version of 'P.Integer', mostly used as a /kind/ for 'P' and 'N'.------ * A positive number /+x/ is represented as @'P' x@.------ * A negative number /-x/ is represented as @'N' x@.------ * /Zero/ can be represented as @'P' 0@ or @'N' 0@. For consistency, all--- /zero/ outputs from type families in this "KindInteger" module use the--- @'P' 0@, but don't assume that this will be the case elsewhere. So, if you--- need to treat /zero/ specially in some situation, be sure to handle both the--- @'P' 0@ and @'N' 0@ cases.------ __NB__: 'Integer' is mostly used as a kind, with its types constructed--- using 'P' and 'N'.  However, it might also be used as type, with its terms--- constructed using 'fromPrelude'. One reason why you may want a 'Integer'--- at the term-level is so that you embed it in larger data-types (for example,--- the "KindRational" module from the--- [@kind-rational@](https://hackage.haskell.org/package/kind-rational)--- library embeds this 'I.Integer' in its 'KindRational.Rational' type).--- Contrary to "Prelude"'s 'P.Integer', "KindInteger"'s 'Integer' preserves--- the internal distinction between @'P' 0@ and @'N' 0@, this is why functions--- such as 'fromSInteger' prefer to use "KindInteger"'s 'Integer' rather--- than "Prelude"'s 'P.Integer'.-data Integer-  = P_ Natural-  | N_ Natural---- | Note that @'P' 0 '==' 'N' 0@.-instance Eq Integer where-  a == b = toPrelude a P.== toPrelude b--instance Ord Integer where-  compare a b = compare (toPrelude a) (toPrelude b)-  a <= b = toPrelude a <= toPrelude b---- | Same as "Prelude" 'P.Integer'.-instance Show Integer where-  showsPrec p = showsPrec p . toPrelude---- | Same as "Prelude" 'P.Integer'.-instance Read Integer where-  readsPrec p xs = do (a, ys) <- readsPrec p xs-                      [(fromPrelude a, ys)]---- | Shows the 'Integer' as it appears literally at the type-level.------ This is different from normal 'show' for 'Integer', which shows--- the term-level value.------ @--- 'shows'            0 ('fromPrelude' 8) \"z\" == \"8z\"--- 'showsPrecTypeLit' 0 ('fromPrelude' 8) \"z\" == \"P 8z\"--- @-showsPrecTypeLit :: Int -> Integer -> ShowS-showsPrecTypeLit p i = showParen (p > appPrec) $ case i of-  P_ x -> showString "P " . shows x-  N_ x -> showString "N " . shows x---- | * A positive number /+x/ is represented as @'P' x@.------ * /Zero/ can be represented as @'P' 0@ (see notes at 'Integer').-type P (x :: Natural) = 'P_ x :: Integer---- | * A negative number /-x/ is represented as @'N' x@.------ * /Zero/ can be represented as @'N' 0@ (but often isn't, see notes at 'Integer').-type N (x :: Natural) = 'N_ x :: Integer---- | Convert a term-level "KindInteger" 'Integer' into a term-level--- "Prelude" 'P.Integer'.------ @--- 'fromPrelude' . 'toPrelude' == 'id'--- 'toPrelude' . 'fromPrelude' == 'id'--- @-toPrelude :: Integer -> P.Integer-toPrelude (P_ n) = toInteger n-toPrelude (N_ n) = negate (toInteger n)---- | Obtain a term-level "KindInteger" 'Integer' from a term-level--- "Prelude" 'P.Integer'. This can fail if the "Prelude" 'P.Integer' is--- infinite, or if it is so big that it would exhaust system resources.------ @--- 'fromPrelude' . 'toPrelude' == 'id'--- 'toPrelude' . 'fromPrelude' == 'id'--- @------ This function can be handy if you are passing "KindInteger"'s 'Integer'--- around for some reason. But, other than this, "KindInteger" doesn't offer--- any tool to deal with the internals of its 'Integer'.-fromPrelude :: P.Integer -> Integer-fromPrelude i = if i >= 0 then P_ (fromInteger i)-                          else N_ (fromInteger (negate i))-------------------------------------------------------------------------------------- | This class gives the integer associated with a type-level integer.--- There are instances of the class for every integer.-class KnownInteger (i :: Integer) where-  integerSing :: SInteger i---- | Positive numbers and zero.-instance L.KnownNat x => KnownInteger (P x) where-  integerSing = UnsafeSInteger (P_ (fromInteger (L.natVal (Proxy @x))))---- | Negative numbers and zero.------ Implementation note: Notice that @'N' 0@ will not be 'Normalize'd to--- @'P' 0@. This is so that 'SDecide', 'TestEquality' and 'TestCoercion'--- behave as expected. If you want a 'Normalize'd 'SInteger', then use--- @'integerSing' \@('Normalize' i)@.-instance L.KnownNat x => KnownInteger (N x) where-  integerSing = UnsafeSInteger (N_ (fromInteger (L.natVal (Proxy @x))))---- | Term-level "KindRational" 'Integer' representation of the type-level--- 'Integer' @i@.-integerVal :: forall i proxy. KnownInteger i => proxy i -> Integer-integerVal _ = case integerSing :: SInteger i of UnsafeSInteger x -> x---- | This type represents unknown type-level 'Integer'.-data SomeInteger = forall n. KnownInteger n => SomeInteger (Proxy n)---- | Convert a term-level "KindInteger" 'Integer' into an unknown--- type-level 'Integer'.-someIntegerVal :: Integer -> SomeInteger-someIntegerVal i = withSomeSInteger i $ \(si :: SInteger i) ->-                   withKnownInteger si (SomeInteger @i Proxy)---- | Note that @'P' 0 '==' 'N' 0@.-instance Eq SomeInteger where-  SomeInteger x == SomeInteger y = integerVal x P.== integerVal y--instance Ord SomeInteger where-  compare (SomeInteger x) (SomeInteger y) =-    compare (integerVal x) (integerVal y)--instance Show SomeInteger where-  showsPrec p (SomeInteger x) = showsPrec p (integerVal x)--instance Read SomeInteger where-  readsPrec p xs = do (a, ys) <- readsPrec p xs-                      [(someIntegerVal a, ys)]------------------------------------------------------------------------------------- Within this module, we use these “normalization” tools to make sure that--- /zero/ is always represented as @'P' 0@. We don't export any of these--- normalization tools to end-users because it seems like we can't make them--- reliable enough so as to offer a decent user experience. So, we just tell--- users to deal with the fact that both @'P' 0@ and @'N' 0@ mean /zero/.---- | Make sure /zero/ is represented as @'P' 0@, not as @'N' 0@------ Notice that all the tools in the "KindInteger" can readily handle--- non-'Normalize'd inputs. This 'Normalize' type-family is offered offered--- only as a convenience in case you want to simplify /your/ dealing with--- /zeros/.-type family Normalize (i :: Integer) :: Integer where-  Normalize (N 0) = P 0-  Normalize i     = i---- | Construct a 'Normalize'd 'N'egative type-level 'Integer'.------ To be used for producing all negative outputs in this module.-type NN (a :: Natural) = Normalize (N a) :: Integer------------------------------------------------------------------------------------infixl 6 +, --infixl 7 *, `Div`, `Rem`-infixr 8 ^---- | Whether a type-level 'Natural' is odd. /Zero/ is not considered odd.-type Odd (x :: Integer) = L.Mod (Abs x) 2 ==? 1 :: Bool---- | Whether a type-level 'Natural' is even. /Zero/ is considered even.-type Even (x :: Integer) = L.Mod (Abs x) 2 ==? 0 :: Bool---- | Negation of type-level 'Integer's.-type family Negate (x :: Integer) :: Integer where-  Negate (P 0) = P 0-  Negate (P x) = N x-  Negate (N x) = P x---- | Sign of type-level 'Integer's.------ * @'P' 0@ if zero.------ * @'P' 1@ if positive.------ * @'N' 1@ if negative.-type family Sign (x :: Integer) :: Integer where-  Sign (P 0) = P 0-  Sign (N 0) = P 0-  Sign (P _) = P 1-  Sign (N _) = N 1---- | Absolute value of a type-level 'Integer', as a type-level 'Natural'.-type family Abs (x :: Integer) :: Natural where-  Abs (P x) = x-  Abs (N x) = x---- | Addition of type-level 'Integer's.-type (a :: Integer) + (b :: Integer) = Add_ (Normalize a) (Normalize b) :: Integer-type family Add_ (a :: Integer) (b :: Integer) :: Integer where-  Add_ (P a) (P b) = P (a L.+ b)-  Add_ (N a) (N b) = NN (a L.+ b)-  Add_ (P a) (N b) = If (b <=? a) (P (a L.- b)) (NN (b L.- a))-  Add_ (N a) (P b) = Add_ (P b) (N a)---- | Multiplication of type-level 'Integer's.-type (a :: Integer) * (b :: Integer) = Mul_ (Normalize a) (Normalize b) :: Integer-type family Mul_ (a :: Integer) (b :: Integer) :: Integer where-  Mul_ (P a) (P b) = P (a L.* b)-  Mul_ (N a) (N b) = Mul_ (P a) (P b)-  Mul_ (P a) (N b) = NN (a L.* b)-  Mul_ (N a) (P b) = Mul_ (P a) (N b)---- | Exponentiation of type-level 'Integer's.------ * Exponentiation by negative 'Integer' doesn't type-check.-type (a :: Integer) ^ (b :: Integer) = Pow_ (Normalize a) (Normalize b) :: Integer-type family Pow_ (a :: Integer) (b :: Integer) :: Integer where-  Pow_ (P a) (P b) = P (a L.^ b)-  Pow_ (N a) (P b) = NN (a L.^ b)-  Pow_ _     (N _) = L.TypeError ('L.Text "KindInteger.(^): Negative exponent")---- | Subtraction of type-level 'Integer's.-type (a :: Integer) - (b :: Integer) = a + Negate b :: Integer---- | Get both the quotient and the 'Rem'ainder of the 'Div'ision of--- type-level 'Integer's @a@ and @b@ using the specified 'Round'ing @r@.------ @--- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer').---   (b '/=' 0) =>---     'DivRem' r a b '=='  '('Div' r a b, 'Rem' r a b)--- @-type DivRem (r :: Round) (a :: Integer) (b :: Integer) =-  '( Div r a b, Rem r a b ) :: (Integer, Integer)---- | 'Rem'ainder of the division of type-level 'Integer' @a@ by @b@,--- using the specified 'Round'ing @r@.------ @--- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer').---   (b '/=' 0) =>---     'Rem' r a b  '=='  a '-' b '*' 'Div' r a b--- @------ * Division by /zero/ doesn't type-check.-type Rem (r :: Round) (a :: Integer) (b :: Integer) =-  a - b * Div r a b :: Integer---- | Divide of type-level 'Integer' @a@ by @b@,--- using the specified 'Round'ing @r@.------ * Division by /zero/ doesn't type-check.-type Div (r :: Round) (a :: Integer) (b :: Integer) =-  Div_ r (Normalize a) (Normalize b) :: Integer--type family Div_ (r :: Round) (a :: Integer) (b :: Integer) :: Integer where-  Div_ r (P a) (P b) = Div__ r (P a) b-  Div_ r (N a) (N b) = Div__ r (P a) b-  Div_ r (P a) (N b) = Div__ r (N a) b-  Div_ r (N a) (P b) = Div__ r (N a) b--type family Div__ (r :: Round) (a :: Integer) (b :: Natural) :: Integer where-  Div__ _ _ 0 = L.TypeError ('L.Text "KindInteger.Div: Division by zero")-  Div__ _ (P 0) _ = P 0-  Div__ _ (N 0) _ = P 0--  Div__ 'RoundDown (P a) b = P (L.Div a b)-  Div__ 'RoundDown (N a) b = NN (If (b L.* L.Div a b ==? a)-                                    (L.Div a b)-                                    (L.Div a b L.+ 1))--  Div__ 'RoundUp a b = Negate (Div__ 'RoundDown (Negate a) b)--  Div__ 'RoundZero (P a) b = Div__ 'RoundDown (P a) b-  Div__ 'RoundZero (N a) b = Negate (Div__ 'RoundDown (P a) b)--  Div__ 'RoundAway (P a) b = Div__ 'RoundUp (P a) b-  Div__ 'RoundAway (N a) b = Div__ 'RoundDown (N a) b--  Div__ 'RoundHalfDown a b = If (HalfLT (R a b) (Div__ 'RoundUp a b))-                                (Div__ 'RoundUp a b)-                                (Div__ 'RoundDown a b)--  Div__ 'RoundHalfUp a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))-                              (Div__ 'RoundDown a b)-                              (Div__ 'RoundUp a b)--  Div__ 'RoundHalfEven a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))-                                (Div__ 'RoundDown a b)-                                (If (HalfLT (R a b) (Div__ 'RoundUp a b))-                                    (Div__ 'RoundUp a b)-                                    (If (Even (Div__ 'RoundDown a b))-                                        (Div__ 'RoundDown a b)-                                        (Div__ 'RoundUp a b)))--  Div__ 'RoundHalfOdd a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))-                               (Div__ 'RoundDown a b)-                               (If (HalfLT (R a b) (Div__ 'RoundUp a b))-                                   (Div__ 'RoundUp a b)-                                   (If (Odd (Div__ 'RoundDown a b))-                                       (Div__ 'RoundDown a b)-                                       (Div__ 'RoundUp a b)))--  Div__ 'RoundHalfZero a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))-                                (Div__ 'RoundDown a b)-                                (If (HalfLT (R a b) (Div__ 'RoundUp a b))-                                    (Div__ 'RoundUp a b)-                                    (Div__ 'RoundZero a b))--  Div__ 'RoundHalfAway (P a) b = Div__ 'RoundHalfUp   (P a) b-  Div__ 'RoundHalfAway (N a) b = Div__ 'RoundHalfDown (N a) b----- | Log base 2 ('floor'ed) of type-level 'Integer's.------ * Logarithm of /zero/ doesn't type-check.------ * Logarithm of negative number doesn't type-check.-type Log2 (a :: Integer) = Log2_ (Normalize a) :: Integer-type family Log2_ (a :: Integer) :: Integer where-  Log2_ (P 0) = L.TypeError ('L.Text "KindInteger.Log2: Logarithm of zero")-  Log2_ (P a) = P (L.Log2 a)-  Log2_ (N a) = L.TypeError ('L.Text "KindInteger.Log2: Logarithm of negative number")---- | Greatest Common Divisor of type-level 'Integer' numbers @a@ and @b@.------ Returns a 'Natural', since the Greatest Common Divisor is always positive.-type GCD (a :: Integer) (b :: Integer) = NatGCD (Abs a) (Abs b) :: Natural---- | Greatest Common Divisor of type-level 'Natural's @a@ and @b@.-type family NatGCD (a :: Natural) (b :: Natural) :: Natural where-  NatGCD a 0 = a-  NatGCD a b = NatGCD b (L.Mod a b)---- | Least Common Multiple of type-level 'Integer' numbers @a@ and @b@.------ Returns a 'Natural', since the Least Common Multiple is always positive.-type LCM (a :: Integer) (b :: Integer) = NatLCM (Abs a) (Abs b) :: Natural---- | Least Common Multiple of type-level 'Natural's @a@ and @b@.-type NatLCM (a :: Natural) (b :: Natural) =-  L.Div a (NatGCD a b) L.* b :: Natural-------------------------------------------------------------------------------------- | Comparison of type-level 'Integer's, as a function.-type CmpInteger (a :: Integer) (b :: Integer) =-  CmpInteger_ (Normalize a) (Normalize b) :: Ordering-type family CmpInteger_ (a :: Integer) (b :: Integer) :: Ordering where-  CmpInteger_ a a = 'EQ-  CmpInteger_ (P a) (P b) = Compare a b-  CmpInteger_ (N a) (N b) = Compare b a-  CmpInteger_ (N _) (P _) = 'LT-  CmpInteger_ (P _) (N _) = 'GT---- | "Data.Type.Ord" support for type-level 'Integer's.-type instance Compare (a :: Integer) (b :: Integer) =-  CmpInteger a b :: Ordering-------------------------------------------------------------------------------------- | We either get evidence that this function was instantiated with the--- same type-level 'Integer's, or 'Nothing'.-sameInteger-  :: forall a b proxy1 proxy2-  .  (KnownInteger a, KnownInteger b)-  => proxy1 a-  -> proxy2 b-  -> Maybe (a :~: b)-sameInteger _ _ = testEquality (integerSing @a) (integerSing @b)---- | Like 'sameInteger', but if the type-level 'Integer's aren't equal, this--- additionally provides proof of 'LT' or 'GT'.-cmpInteger-  :: forall a b proxy1 proxy2-  .  (KnownInteger a, KnownInteger b)-  => proxy1 a-  -> proxy2 b-  -> OrderingI a b-cmpInteger x y = case compare (integerVal x) (integerVal y) of-  EQ -> case unsafeCoerce Refl :: CmpInteger a b :~: 'EQ of-    Refl -> case unsafeCoerce Refl :: a :~: b of-      Refl -> EQI-  LT -> case unsafeCoerce Refl :: (CmpInteger a b :~: 'LT) of-    Refl -> LTI-  GT -> case unsafeCoerce Refl :: (CmpInteger a b :~: 'GT) of-    Refl -> GTI-------------------------------------------------------------------------------------- | Singleton type for a type-level 'Integer' @i@.-newtype SInteger (i :: Integer) = UnsafeSInteger Integer-type role SInteger representational---- | A explicitly bidirectional pattern synonym relating an 'SInteger' to a--- 'KnownInteger' constraint.------ As an __expression__: Constructs an explicit @'SInteger' i@ value from an--- implicit @'KnownInteger' i@ constraint:------ @--- 'SInteger' @i :: 'KnownInteger' i => 'SInteger' i--- @------ As a __pattern__: Matches on an explicit @'SInteger' i@ value bringing--- an implicit @'KnownInteger' i@ constraint into scope:------ @--- f :: 'SInteger' i -> ..--- f SInteger = {- SInteger i in scope -}--- @-pattern SInteger :: forall i. () => KnownInteger i => SInteger i-pattern SInteger <- (knownIntegerInstance -> KnownIntegeregerInstance)-  where SInteger = integerSing---- | An internal data type that is only used for defining the 'SInteger' pattern--- synonym.-data KnownIntegeregerInstance (i :: Integer) where-  KnownIntegeregerInstance :: KnownInteger i => KnownIntegeregerInstance i---- | An internal function that is only used for defining the 'SInteger' pattern--- synonym.-knownIntegerInstance :: SInteger i -> KnownIntegeregerInstance i-knownIntegerInstance si = withKnownInteger si KnownIntegeregerInstance--instance Show (SInteger i) where-  showsPrec p (UnsafeSInteger i) = showParen (p > appPrec) $-    showString "SInteger @" . showsPrecTypeLit appPrec1 i---- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@--- are not equal types, even if they are treated equally elsewhere in--- "KindInteger".-instance TestEquality SInteger where-  testEquality = decideEquality-  {-# INLINE testEquality #-}---- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@--- are not equal types, even if they are treated equally elsewhere in--- "KindInteger".-instance TestCoercion SInteger where-  testCoercion = decideCoercion-  {-# INLINE testCoercion #-}---- | Return the term-level "KindInteger" 'Integer' number corresponding to @i@--- in a @'SInteger' i@ value.-fromSInteger :: SInteger i -> Integer-fromSInteger (UnsafeSInteger i) = i-{-# INLINE fromSInteger #-}---- | Whether the internal representation of the 'Integer's are equal.------ Note that this is not the same as '(P.==)'. Use '(P.==)' unless you--- know what you are doing.-eqIntegerRep :: Integer -> Integer -> Bool-eqIntegerRep (N_ l) (N_ r) = l P.== r-eqIntegerRep (P_ l) (P_ r) = l P.== r-eqIntegerRep _      _      = False-{-# INLINE eqIntegerRep #-}---- | Convert an explicit @'SInteger' i@ value into an implicit--- @'KnownInteger' i@ constraint.-withKnownInteger-  :: forall i rep (r :: TYPE rep). SInteger i -> (KnownInteger i => r) -> r-withKnownInteger = withDict @(KnownInteger i)---- | Convert a "KindIiteger" 'Integer' number into an @'SInteger' n@ value,--- where @n@ is a fresh type-level 'Integer'.-withSomeSInteger-  :: forall rep (r :: TYPE rep). Integer -> (forall n. SInteger n -> r) -> r-withSomeSInteger n k = k (UnsafeSInteger n)--- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats"-{-# NOINLINE withSomeSInteger #-}------------------------------------------------------------------------------------type instance Sing = SInteger--instance KnownInteger i => SingI (i :: Integer) where-  sing = integerSing-  {-# INLINE sing #-}---- | 'Demote' refers to "KindInteger"'s 'Integer' rather than "Prelude"'s--- 'Integer' so that the 'SInteger''s internal representation is preserved.--- Use 'toPrelude' and 'fromPrelude' as necessary.-instance SingKind Integer where-  type Demote Integer = Integer-  fromSing = fromSInteger-  {-# INLINE fromSing #-}-  toSing i = withSomeSInteger i SomeSing-  {-# INLINE toSing #-}---- | Note that this checks for type equality. That is, @'P' 0@ and @'N' 0@--- are not equal types, even if they are treated equally elsewhere in--- "KindInteger".-instance SDecide Integer where-  UnsafeSInteger l %~ UnsafeSInteger r =-    case eqIntegerRep l r of-      True  -> Proved (unsafeCoerce Refl)-      False -> Disproved (\Refl -> error "SDecide.Integer")------------------------------------------------------------------------------------data Round-  = RoundUp-  -- ^ Round __up__ towards positive infinity.-  | RoundDown-  -- ^ Round __down__ towards negative infinity.  Also known as "Prelude"'s-  -- 'P.floor'. This is the type of rounding used by "Prelude"'s 'P.div',-  -- 'P.mod', 'P.divMod', 'L.Div', 'L.Mod'.-  | RoundZero-  -- ^ Round towards __zero__.  Also known as "Prelude"'s 'P.truncate'. This is-  -- the type of rounding used by "Prelude"'s 'P.quot', 'P.rem', 'P.quotRem'.-  | RoundAway-  -- ^ Round __away__ from zero.-  | RoundHalfUp-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round __up__ towards positive infinity.-  | RoundHalfDown-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round __down__ towards negative infinity.-  | RoundHalfZero-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round towards __zero__.-  | RoundHalfAway-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round __away__ from zero.-  | RoundHalfEven-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round towards the closest __even__ integer. Also known as "Prelude"'s-  -- 'P.round'.-  | RoundHalfOdd-  -- ^ Round towards the closest integer. If __half__way between two integers,-  -- round towards the closest __odd__ integer.-  deriving (Eq, Ord, Show, Read, Enum, Bounded)----- | Divide @a@ by @a@ using the specified 'Round'ing.--- Return the quotient @q@. See 'divRem'.-div :: Round-    -> P.Integer  -- ^ Dividend @a@.-    -> P.Integer  -- ^ Divisor @b@.-    -> P.Integer  -- ^ Quotient @q@.-div r a b = fst (divRem r a b)---- | Divide @a@ by @a@ using the specified 'Round'ing.--- Return the remainder @m@. See 'divRem'.-rem :: Round-    -> P.Integer  -- ^ Dividend @a@.-    -> P.Integer  -- ^ Divisor @b@.-    -> P.Integer  -- ^ Remainder @m@.-rem r a b = snd (divRem r a b)---- | Divide @a@ by @a@ using the specified 'Round'ing.--- Return the quotient @q@ and the remainder @m@.------ @--- forall (r :: 'Round') (a :: 'P.Integer') (b :: 'P.Integer').---   (b 'P./=' 0) =>---     case 'divRem' r a b of---       (q, m) -> m 'P.==' a 'P.-' b 'P.*' q--- @-divRem-  :: Round-  -> P.Integer  -- ^ Dividend @a@.-  -> P.Integer  -- ^ Divisor @b@.-  -> (P.Integer, P.Integer)  -- ^ Quotient @q@ and remainder @m@.-{-# NOINLINE divRem #-}-divRem RoundZero = \a (errDiv0 -> b) -> P.quotRem a b-divRem RoundDown = \a (errDiv0 -> b) -> P.divMod a b-divRem RoundUp = \a (errDiv0 -> b) -> _divRemRoundUpNoCheck a b-divRem RoundAway = \a (errDiv0 -> b) ->-  if xor (a < 0) (b < 0)-     then P.divMod a b-     else _divRemRoundUpNoCheck a b-divRem RoundHalfUp = _divRemHalf $ \_ _ up -> up-divRem RoundHalfDown = _divRemHalf $ \_ down _ -> down-divRem RoundHalfZero = _divRemHalf $ \neg down up ->-  if neg then up else down-divRem RoundHalfAway = _divRemHalf $ \neg down up ->-  if neg then down else up-divRem RoundHalfEven = _divRemHalf $ \_ down up ->-  if even (fst down) then down else up-divRem RoundHalfOdd = _divRemHalf $ \_ down up ->-  if odd (fst down) then down else up--_divRemRoundUpNoCheck :: P.Integer -> P.Integer -> (P.Integer, P.Integer)-_divRemRoundUpNoCheck a b =-  let q = negate (P.div (negate a) b)-  in (q, a - b * q)-{-# INLINE _divRemRoundUpNoCheck #-}--_divRemHalf-  :: (Bool ->-      (P.Integer, P.Integer) ->-      (P.Integer, P.Integer) ->-      (P.Integer, P.Integer))-  -- ^ Negative -> divRem RoundDown -> divRem RoundDown -> Result-  -> P.Integer  -- ^ Dividend-  -> P.Integer  -- ^ Divisor-  -> (P.Integer, P.Integer)-_divRemHalf f = \a (errDiv0 -> b) ->-  let neg  = xor (a < 0) (b < 0)-      down = P.divMod a b-      up   = _divRemRoundUpNoCheck a b-  in  case compare (a P.% b - toRational (fst down)) (1 P.:% 2) of-        LT -> down-        GT -> up-        EQ -> f neg down up-{-# INLINE _divRemHalf #-}------------------------------------------------------------------------------------- Extras--infixr 4 /=, /=?, ==, ==?---- | This should be exported by "Data.Type.Ord".-type (a :: k) ==? (b :: k) = OrdCond (Compare a b) 'False 'True 'False :: Bool---- | This should be exported by "Data.Type.Ord".-type (a :: k) == (b :: k) = (a ==? b) ~ 'True :: Constraint---- | This should be exported by "Data.Type.Ord".-type (a :: k) /=? (b :: k) = OrdCond (Compare a b) 'True 'False 'True :: Bool---- | This should be exported by "Data.Type.Ord".-type (a :: k) /= (b :: k) = (a /=? b) ~ 'True :: Constraint------------------------------------------------------------------------------------- Rational tools--data Rat = Rat Integer Natural--type family R (n :: Integer) (d :: Natural) :: Rat where-  R (P n) d = RatNormalize ('Rat (P n) d)-  R (N n) d = RatNormalize ('Rat (N n) d)--type family RatNormalize (r :: Rat) :: Rat where-  RatNormalize ('Rat _ 0) =-    L.TypeError ('L.Text "KindInteger: Denominator is 0")-  RatNormalize ('Rat (P 0) _) = 'Rat (P 0) 1-  RatNormalize ('Rat (N 0) _) = 'Rat (P 0) 1-  RatNormalize ('Rat (P n) d) = 'Rat (P (L.Div n (NatGCD n d)))-                                     (L.Div d (NatGCD n d))-  RatNormalize ('Rat (N n) d) = 'Rat (N (L.Div n (NatGCD n d)))-                                     (L.Div d (NatGCD n d))--type family RatAbs (a :: Rat) :: Rat where-  RatAbs ('Rat n d) = RatNormalize ('Rat (P (Abs n)) d)--type RatAdd (a :: Rat) (b :: Rat) =-  RatNormalize (RatAdd_ (RatNormalize a) (RatNormalize b)) :: Rat-type family RatAdd_ (a :: Rat) (b :: Rat) :: Rat where-  RatAdd_ ('Rat an ad) ('Rat bn bd) = 'Rat (an * P bd + bn * P ad) (ad L.* bd)--type family RatNegate (a :: Rat) :: Rat where-  RatNegate ('Rat n d) = RatNormalize ('Rat (Negate n) d)--type RatMinus (a :: Rat) (b :: Rat) = RatAdd a (RatNegate b)--type instance Compare (a :: Rat) (b :: Rat) = RatCmp a b-type RatCmp (a :: Rat) (b :: Rat) =-  RatCmp_ (RatNormalize a) (RatNormalize b) :: Ordering-type family RatCmp_ (a :: Rat) (b :: Rat) :: Ordering where-  RatCmp_ a a = 'EQ-  RatCmp_ ('Rat an ad) ('Rat bn bd) = CmpInteger (an * P bd) (bn * P ad)---- | ''True' if the distance between @a@ and @b@ is less than /0.5/.-type HalfLT (a :: Rat) (b :: Integer) =-  (RatAbs (RatMinus a ('Rat b 1))) <? ('Rat (P 1) 2) :: Bool--errDiv0 :: P.Integer -> P.Integer-errDiv0 0 = Ex.throw Ex.DivideByZero-errDiv0 i = i+{-# LANGUAGE StrictData #-}+{-# LANGUAGE TypeFamilyDependencies #-}+{-# LANGUAGE UndecidableInstances #-}++-- | This module provides a type-level representation for term-level+-- 'P.Integer's. This type-level representation is also named 'P.Integer',+-- So import this module qualified to avoid name conflicts.+--+-- @+-- import "KindInteger" qualified as KI+-- @+--+-- The implementation details are similar to the ones for type-level 'Natural's+-- as of @base-4.18@ and @singletons-base-3.1.1@, and they will continue to+-- evolve together with @base@ and @singletons-base@, trying to more or less+-- follow their API.+module KindInteger {--}+  ( -- * Integer+    Integer+  , type Z, pattern SZ+  , type N, pattern SN+  , type P, pattern SP+  , FromNatural, sFromNatural+  , Fold, sFold+    -- * SInteger+  , KnownInteger+  , Normalized+  , integerSing+  , integerVal+  , withKnownInteger+  , SomeInteger(..)+  , someIntegerVal+  , SInteger+  , pattern SInteger+  , fromSInteger+  , withSomeSInteger+    -- * Proofs+  , sNegateRefl+  , sZigZagRefl+  , sZagZigRefl++    -- * Show+    --+    -- | Besides the following /\*Lit/ tools, 'P.PShow' and 'P.SShow' can+    -- be used to display as "Prelude".'P.Integer' does.+  , ShowLit, showLit, sShowLit+  , ShowsLit, showsLit, sShowsLit+  , ShowsPrecLit, showsPrecLit, sShowsPrecLit+  , readPrecLit++    -- * Operations+    --+    -- | Additional arithmetic operations are provided through the 'P.PNum'+    -- and 'P.SNum' instances. Notably 'P.Abs', 'P.sAbs', 'P.Negate',+    -- 'P.sNegate', 'P.Signum', 'P.sSignum', 'P.+', 'P.-', 'P.*', 'P.%+',+    -- 'P.%-', 'P.%*'.+  , type (^), (%^)+  , Odd, sOdd+  , Even, sEven+  , Abs, sAbs+  , GCD, sGCD+  , LCM, sLCM+  , Log2, sLog2+  , Div, sDiv, div+  , Rem, sRem, rem+  , DivRem, sDivRem, divRem+    -- ** Rounding+  , Round(..)+  , SRound(..)++    -- * Comparisons+    --+    -- | Additional comparison tools are available at 'SDdecide',+    -- 'TestEquality', 'TestCoercion', 'P.PEq', 'P.SEq', 'P.POrd', 'P.SOrd'+    -- and 'Compare'.+  , cmpInteger+  , sameInteger++    -- * Misc+  , ZigZag, sZigZag+  , ZagZig, sZagZig++    -- * Defunctionalization+  , ZSym0+  , NSym0, NSym1+  , PSym0, PSym1+  , FromNaturalSym0, FromNaturalSym1+  , KnownIntegerSym0, KnownIntegerSym1+  , NormalizedSym0, NormalizedSym1+  , FoldSym0, FoldSym1, FoldSym2, FoldSym3, FoldSym4+  , type (^@#@$), type (^@#@$$), type (^@#@$$$)+  , OddSym0, OddSym1+  , EvenSym0, EvenSym1+  , GCDSym0, GCDSym1+  , LCMSym0, LCMSym1+  , Log2Sym0, Log2Sym1+  , DivSym0, DivSym1, DivSym2, DivSym3+  , RemSym0, RemSym1, RemSym2, RemSym3+  , DivRemSym0, DivRemSym1, DivRemSym2, DivRemSym3+  , ShowLitSym0, ShowLitSym1+  , ShowsLitSym0, ShowsLitSym1, ShowsLitSym2+  , ShowsPrecLitSym0, ShowsPrecLitSym1, ShowsPrecLitSym2, ShowsPrecLitSym3+  , RoundUpSym0+  , RoundDownSym0+  , RoundZeroSym0+  , RoundAwaySym0+  , RoundHalfUpSym0+  , RoundHalfDownSym0+  , RoundHalfZeroSym0+  , RoundHalfAwaySym0+  , RoundHalfEvenSym0+  , RoundHalfOddSym0+  ) --}+  where++import Control.Applicative+import Control.Exception qualified as Ex+import Control.Monad+import Data.Bits+import Data.Bool.Singletons (SBool(..))+import Data.Char qualified as Char+import Data.Eq.Singletons qualified as EqS+import Data.Maybe+import Data.Ord.Singletons qualified as OrdS+import Data.Proxy+import Data.Singletons+import Data.Singletons.Decide+import Data.String+import Data.Type.Bool (If)+import Data.Type.Coercion+import Data.Type.Equality (TestEquality(..))+import Data.Type.Ord+import GHC.Base (WithDict(..))+import GHC.Exts (TYPE, Constraint, coerce)+import GHC.Num.Integer (integerLog2)+import GHC.Real qualified as P+import GHC.Show (appPrec1)+import GHC.TypeLits qualified as L+import GHC.TypeLits.Singletons qualified as L hiding (natVal)+import Numeric.Natural (Natural)+import Prelude hiding (Show, Integer, (==), (/=), div, rem)+import Prelude qualified as P+import Prelude.Singletons qualified as P+import Text.ParserCombinators.ReadP qualified as ReadP+import Text.ParserCombinators.ReadPrec qualified as ReadPrec+import Text.Read qualified as Read+import Text.Show.Singletons (AppPrec1)+import Unsafe.Coerce (unsafeCoerce)++import KindInteger.Round++--------------------------------------------------------------------------------++-- | Type-level version of 'P.Integer', only used as a /kind/.+--+-- * Zero is represented as t'Z'.+--+-- * A positive number /+x/ is represented as @t'P' x@.+--+-- * A negative number /-x/ is represented as @t'N' x@.++-- __Note__: This representation is depressing. We hate it. It's not “total”,+-- because things such as @'N' 0@ and @'P' 0@ are not “valid”, and it's not+-- efficient, because we have to pay attention to three different constructors+-- rather than just one. The reason why we use this horrible representation+-- anyway is that type errors are easier to understand, since literals like+-- @'N' 2@ or 'Z' will show up in them. @'N' 0@ and @'P' 0@ will type-check+-- just fine on their own. However, tools in this module will reject them. For+-- example, there is no 'KnownInteger' instance for them, and 'Normalized'+-- will fail to type-check. Moreover, it is not possible to construct a+-- 'SInteger' for @'N' 0@ or @'P' 0@. If we could customize the way this+-- 'Integer' gets rendered in type-errors, we'd switch to a better internal+-- representation such as ZigZag. Also note that rather than exporting the+-- constructors directly, we export type-synonyms with the same name. This is+-- mostly so that users don't need to type the annoying preceeding tick.+data Integer+  = Z         -- ^ 0.+  | N Natural -- ^ Guaranteed to be greater than 0 only after going through+              -- 'KnownInteger', 'Normalized' or 'SInteger'.+  | P Natural -- ^ Guaranteed to be greater than 0 only after going through+              -- 'KnownInteger', 'Normalized' or 'SInteger'.++--------------------------------------------------------------------------------++-- | Zero is represented as t'Z'.+type Z = 'Z :: Integer++type ZSym0 :: Integer++type ZSym0 = Z++-- | A negative number /-x/ is represented as @t'N' x@.+--+-- While a standalone @t'N' 0@ type-checks, it is not considered valid,+-- so tools like 'KnownInteger' or 'Normalized' will reject it.+-- @t'N' 0@ itself is not rejected so that it can be used to pattern-match+-- against 'Integer's at the type-level if necessary.+type N (x :: Natural) = 'N x :: Integer++data NSym0 :: Natural ~> Integer+type NSym1 :: Natural -> Integer++type instance Apply NSym0 x = NSym1 x+type NSym1 x = N x++-- | A positive number /+x/ is represented as @t'P' x@.+--+-- While a standalone @t'P' 0@ type-checks, it is not considered valid,+-- so tools like 'KnownInteger' or 'Normalized' will reject it.+-- @t'P' 0@ itself is not rejected so that it can be used to pattern-match+-- against 'Integer's at the type-level if necessary.+type P (x :: Natural) = 'P x :: Integer++data PSym0 :: Natural ~> Integer+type PSym1 :: Natural -> Integer++type instance Apply PSym0 x = PSym1 x+type PSym1 x = P x++--------------------------------------------------------------------------------++-- | @'SZ' == 'sing' \@Z@+pattern SZ :: SInteger Z+pattern SZ <- UnsafeSInteger _+  where SZ = UnsafeSInteger 0+{-# COMPLETE SZ #-}++-- | @'SP' ('sing' \@1) == 'sing' \@(P 1)@+pattern SP :: (0 < x)+           => (KnownInteger (P x), L.KnownNat x)+           => Sing (x :: Natural)+           -> SInteger (P x)+pattern SP x <- (patternSP -> PatternSI x)+  where SP = UnsafeSInteger . toInteger . fromSing+{-# COMPLETE SP #-}++-- | @'SN' ('sing' \@1) == 'sing' \@(N 1)@+pattern SN :: (0 < x)+           => (KnownInteger (N x), L.KnownNat x)+           => Sing (x :: Natural)+           -> SInteger (N x)+pattern SN x <- (patternSN -> PatternSI x)+  where SN = UnsafeSInteger . negate . toInteger . fromSing+{-# COMPLETE SN #-}++-- | Internal. Used to implement 'SP' and 'SN'.+data PatternSI i n = (KnownInteger i, L.KnownNat n) => PatternSI (Sing n)++patternSI :: SInteger i -> PatternSI i (Abs i)+patternSI si@SInteger | sa <- sAbs si = L.withKnownNat sa (PatternSI sa)++patternSN :: SInteger (N x) -> PatternSI (N x) x+patternSN = unsafeCoerce . patternSI++patternSP :: SInteger (P x) -> PatternSI (P x) x+patternSP = unsafeCoerce . patternSI++--------------------------------------------------------------------------------++-- | @'Fold' z n p i@ evaluates to @z@ if @i@ is zero, otherwise applies @n@ to+-- the absolute value of @i@ if negative, or @p@ to the absolute value of @i@ if+-- positive. @t'N' 0@ and @t'P' 0@ fail to type-check.+type family Fold+     (z :: k)+     (n :: Natural ~> k)+     (p :: Natural ~> k)+     (i :: Integer)+     :: k where+  Fold _ _ _ (N 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘N 0’.")+  Fold _ _ _ (P 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘P 0’.")+  Fold z _ _  Z    = z+  Fold _ n _ (N x) = n @@ x+  Fold _ _ p (P x) = p @@ x++data FoldSym0 :: k ~> (Natural ~> k) ~> (Natural ~> k) ~> Integer ~> k+data FoldSym1 :: k -> (Natural ~> k) ~> (Natural ~> k) ~> Integer ~> k+data FoldSym2 :: k -> (Natural ~> k) -> (Natural ~> k) ~> Integer ~> k+data FoldSym3 :: k -> (Natural ~> k) -> (Natural ~> k) -> Integer ~> k+type FoldSym4 :: k -> (Natural ~> k) -> (Natural ~> k) -> Integer -> k++type instance Apply FoldSym0 z = FoldSym1 z+type instance Apply (FoldSym1 z) n = FoldSym2 z n+type instance Apply (FoldSym2 z n) p = FoldSym3 z n p+type instance Apply (FoldSym3 z n p) i = FoldSym4 z n p i+type FoldSym4 z n p i = Fold z n p i++-- | Singleton version of 'Fold'.+sFold+  :: SingKind k+  => Sing (z :: k)+  -> Sing (n :: Natural ~> k)+  -> Sing (p :: Natural ~> k)+  -> SInteger i+  -> Sing (Fold z n p i)+sFold sz sn sp si =+  case compare (fromSing si) 0 of+    EQ -> unsafeCoerce sz+    LT -> unsafeCoerce (sn @@ sAbs si)+    GT -> unsafeCoerce (sp @@ sAbs si)++--------------------------------------------------------------------------------++-- | Displays @i@ as it would show literally as a term.+--+-- @+-- 'P.Show_' ( t'N' 1) ~ \"-1\"+-- 'P.Show_'   t'Z'    ~  \"0\"+-- 'P.Show_' ( t'P' 1) ~  \"1\"+-- @+--+-- @t'N' 0@ and @t'P' 0@ fail to type-check.+instance P.PShow Integer where+  type ShowsPrec p i s = ShowsPrec_ p (Normalized i) s++type ShowsPrec_ :: Natural -> Integer -> L.Symbol -> L.Symbol+type family ShowsPrec_ p i s where+  ShowsPrec_ _  Z    s = P.Shows 0 s+  ShowsPrec_ p (N x) s =+    P.ShowParen (p P.>= AppPrec1) (P.ShowCharSym1 '-' P..@#@$$$ P.ShowsSym1 x) s+  ShowsPrec_ _ (P x) s = P.Shows x s++-- | Displays @i@ as it would show literally as a term.+--+-- @+-- 'fromSing' \@('P.sShow_' ('SN' ('sing' \@1))) == \"-1\"+-- 'fromSing' \@('P.sShow_' 'SZ')             ==  \"0\"+-- 'fromSing' \@('P.sShow_' ('SP' ('sing' \@1))) ==  \"1\"+-- @+instance P.SShow Integer where+  sShowsPrec _ si ss =+    withSomeSing (fromString (show (fromSing si)) <> fromSing ss) unsafeCoerce++--------------------------------------------------------------------------------++-- | Displays @i@ as it would show literally as a type.+--+-- @+-- 'P.ShowLit' ( t'N' 1) ~ \"P 1\"+-- 'P.ShowLit'   t'Z'    ~ \"Z\"+-- 'P.ShowLit' ( t'P' 1) ~ \"P 1\"+-- @+--+-- @t'N' 0@ and @t'P' 0@ fail to type-check.+type ShowLit (i :: Integer) = ShowsLit i "" :: L.Symbol++data ShowLitSym0 :: Integer ~> L.Symbol+type ShowLitSym1 :: Integer -> L.Symbol++type instance Apply ShowLitSym0 i = ShowLitSym1 i+type ShowLitSym1 i = ShowLit i++-- | Displays @i@ as it would show literally as a type. See 'ShowLit.+-- Behaves like 'P.Shows'.+type ShowsLit (i :: Integer) (s :: L.Symbol) = ShowsPrecLit 0 i s :: L.Symbol++data ShowsLitSym0 :: Integer ~> L.Symbol ~> L.Symbol+data ShowsLitSym1 :: Integer -> L.Symbol ~> L.Symbol+type ShowsLitSym2 :: Integer -> L.Symbol -> L.Symbol++type instance Apply ShowsLitSym0 i = ShowsLitSym1 i+type instance Apply (ShowsLitSym1 i) s = ShowsLitSym2 i s+type ShowsLitSym2 i s = ShowsLit i s++-- | Displays @i@ as it would show literally as a type. See 'ShowLit.+-- Behaves like 'P.ShowsPrec'.+type ShowsPrecLit :: Natural -> Integer -> L.Symbol -> L.Symbol+type ShowsPrecLit p i s = ShowsPrecLit_ p (Normalized i) s++type ShowsPrecLit_ :: Natural -> Integer -> L.Symbol -> L.Symbol+type family ShowsPrecLit_ p i s where+  ShowsPrecLit_ _ Z s = P.ShowString "Z" s+  ShowsPrecLit_ p (N n) s =+    P.ShowParen (p P.>= 11) (P.ShowStringSym1 "N " P..@#@$$$ P.ShowsSym1 n) s+  ShowsPrecLit_ p (P n) s =+    P.ShowParen (p P.>= 11) (P.ShowStringSym1 "P " P..@#@$$$ P.ShowsSym1 n) s++data ShowsPrecLitSym0 :: Natural ~> Integer ~> L.Symbol ~> L.Symbol+data ShowsPrecLitSym1 :: Natural -> Integer ~> L.Symbol ~> L.Symbol+data ShowsPrecLitSym2 :: Natural -> Integer -> L.Symbol ~> L.Symbol+type ShowsPrecLitSym3 :: Natural -> Integer -> L.Symbol -> L.Symbol++type instance Apply ShowsPrecLitSym0 p = ShowsPrecLitSym1 p+type instance Apply (ShowsPrecLitSym1 p) i = ShowsPrecLitSym2 p i+type instance Apply (ShowsPrecLitSym2 p i) s = ShowsPrecLitSym3 p i s+type ShowsPrecLitSym3 p i s = ShowsPrecLit p i s++-- | Singleton version of 'ShowLit'.+--+-- @+-- 'fromSing' \@('sShowLit' ('SN' ('sing' \@1))) == \"N 1\"+-- 'fromSing' \@('sShowLit' 'SZ')             == \"Z"+-- 'fromSing' \@('sShowLit' ('SP' ('sing' \@1))) == \"P 1\"+-- @+sShowLit :: SInteger i -> Sing (ShowLit i)+sShowLit si = sShowsLit si (sing @"")++-- | Demoted version of 'ShowLit'.+showLit :: P.Integer -> String+showLit i = showsLit i ""++-- | Singleton version of 'ShowsLit'.+sShowsLit :: SInteger i -> Sing (s :: P.Symbol) -> Sing (ShowsLit i s)+sShowsLit = sShowsPrecLit (sing @0)++-- | Demoted version of 'ShowsLit'.+showsLit :: P.Integer -> ShowS+showsLit = showsPrecLit 0++-- | Singleton version of 'ShowsPrecLit'.+sShowsPrecLit+  :: Sing (p :: Natural) -> SInteger i -> Sing (s :: P.Symbol)+  -> Sing (ShowsPrecLit p i s)+sShowsPrecLit sp si ss =+  let p = fromMaybe (error "sShowsPrecLit: invalid precedence")+                    (toIntegralSized (fromSing sp))+      t = fromString (showsPrecLit p (fromSing si) "")+  in withSomeSing (t <> fromSing ss) unsafeCoerce++-- | Demoted version of 'ShowsPrecLit'.+showsPrecLit :: Int -> P.Integer -> ShowS+showsPrecLit p | p < 0 = error "showsPrecLit: negative precedence"+showsPrecLit p = \case+  0         -> showChar 'Z'+  i | i > 0 -> showParen (p >= appPrec1) (showString "P " . shows i)+  i         -> showParen (p >= appPrec1) (showString "N " . shows (abs i))++-- | Inverse of 'showsPrecLit'.+readPrecLit :: ReadPrec.ReadPrec P.Integer+readPrecLit = Read.parens $ asum+    [ 0 <$ ReadPrec.lift (ReadP.char 'Z')+    , do ReadPrec.lift $ ReadP.char 'N' >> pSkipSpaces1+         n <- Read.parens (ReadPrec.lift pNatural)+         guard (n P./= 0)+         pure $ negate $ fromIntegral n+    , do ReadPrec.lift $ ReadP.char 'P' >> pSkipSpaces1+         n <- Read.parens (ReadPrec.lift pNatural)+         guard (n P./= 0)+         pure $ fromIntegral n+    ]+  where+    pNatural :: ReadP.ReadP Natural+    pNatural = read <$> ReadP.munch1 (\c -> c >= '0' && c <= '9')++--------------------------------------------------------------------------------++-- | This class gives the 'SInteger' associated with a type-level 'Integer'.+class KnownInteger_ (i :: Integer) where+  integerSing_ :: SInteger i++-- | Type-level 'Integer's satisfying 'KnownInteger' can be converted to+-- 'SInteger's using 'integerSing'. Every 'Integer' other than @'N' 0@ and+-- @'P' 0@ are 'KnownInteger's.++-- Note: Ideally, the constraints mentioned here would be superclasses to+-- 'KnownInteger_'. However, 'withDict' doesn't allow having a superclass+-- there, so we treat 'KnownInteger_' as internal an export 'KnownInteger' only.+-- The 'KnownNat (Abs i)' constraint is listed here as a convenience, seeing+-- as it is necessary to implement 'KnownInteger_' anyway.+type KnownInteger (i :: Integer) =+  (KnownInteger_ i, Normalized i ~ i, L.KnownNat (Abs i))++data KnownIntegerSym0 :: Integer ~> Constraint+type KnownIntegerSym1 :: Integer -> Constraint++type instance Apply KnownIntegerSym0 i = KnownIntegerSym1 i+type KnownIntegerSym1 i = KnownInteger i++-- | Convert an implicit 'KnownInteger' to an explicit 'SInteger'.+integerSing :: KnownInteger i => SInteger i+integerSing = integerSing_ -- The difference is in the constraint.+{-# INLINE integerSing #-}++instance KnownInteger_ Z where+  integerSing_ = UnsafeSInteger 0+  {-# INLINE integerSing_ #-}++instance (KnownInteger (N n), n ~ Abs (N n)) => KnownInteger_ (N n) where+  integerSing_ = UnsafeSInteger $! P.negate (L.natVal (Proxy @n))+  {-# INLINE integerSing_ #-}++instance (KnownInteger (P n), n ~ Abs (P n)) => KnownInteger_ (P n) where+  integerSing_ = UnsafeSInteger $! L.natVal (Proxy @n)+  {-# INLINE integerSing_ #-}++-- | @'Normalized' i@ is an identity function that fails to type-check+-- if @i@ is not in normalized form. That is, /zero/ is represented with t'Z',+-- not with @t'P' 0@ or @ t'N' 0@.+type family Normalized (i :: Integer) :: Integer where+  Normalized (N 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘N 0’.")+  Normalized (P 0) = L.TypeError ('L.Text "Use ‘Z’ instead of ‘P 0’.")+  Normalized i     = i++data NormalizedSym0 :: Integer ~> Integer+type NormalizedSym1 :: Integer -> Integer++type instance Apply NormalizedSym0 i = Normalized i+type NormalizedSym1 i = Normalized i++-- | 'SInteger' contains only 'Normalized' integers.+sNormalizedRefl :: SInteger i -> (i :~: Normalized i)+sNormalizedRefl !_ = unsafeCoerce Refl++-- | Term-level "Prelude".'P.Integer' representation of the type-level+-- 'Integer'.+integerVal :: forall i proxy. KnownInteger i => proxy i -> P.Integer+integerVal _ = case integerSing_ :: SInteger i of UnsafeSInteger x -> x+{-# INLINE integerVal #-}++-- | Term-level representation of an existentialized 'KnownInteger'.+data SomeInteger = forall i. KnownInteger i => SomeInteger (Proxy i)++-- | Convert a term-level "Prelude".'P.Integer' into an+-- extistentialized 'KnownInteger' wrapped in 'SomeInteger'.+someIntegerVal :: P.Integer -> SomeInteger+someIntegerVal = \i ->+  withSomeSInteger i $ \(si :: SInteger i) ->+  withKnownInteger si $ SomeInteger (Proxy @i)++instance Eq SomeInteger where+  SomeInteger x == SomeInteger y =+    integerVal x P.== integerVal y+  {-# INLINE (==) #-}++instance Ord SomeInteger where+  compare (SomeInteger x) (SomeInteger y) =+    compare (integerVal x) (integerVal y)+  {-# INLINE compare #-}++-- | As for "Prelude".'P.Integer'.+instance P.Show SomeInteger where+  showsPrec p (SomeInteger i) =+    showsPrec p (integerVal i)++-- | As for "Prelude".'P.Integer'.+instance Read SomeInteger where+  readPrec = fmap someIntegerVal Read.readPrec++--------------------------------------------------------------------------------++-- | Construct a type-level 'Integer' from a type-level 'Natural'.+type family FromNatural (x :: Natural) :: Integer where+  FromNatural 0 = Z+  FromNatural x = P x++data FromNaturalSym0 :: Natural ~> Integer+type FromNaturalSym1 :: Natural -> Integer++type instance Apply FromNaturalSym0 i = FromNatural i+type FromNaturalSym1 i = FromNatural i++-- | Singleton version of 'FromNatural'.+sFromNatural :: Sing (x :: Natural) -> SInteger (FromNatural x)+sFromNatural = UnsafeSInteger . toInteger . fromSing+{-# INLINE sFromNatural #-}++--------------------------------------------------------------------------------++-- | Demoted version of 'ZigZag'.+zigZag :: P.Integer -> Natural+zigZag 0 = 0+zigZag i = fromInteger (if i < 0 then abs i * 2 - 1 else i * 2)++-- | Singleton version of 'ZigZag'.+sZigZag :: SInteger i -> Sing (ZigZag i :: Natural)+sZigZag si = withSomeSing @Natural (zigZag (fromSing si)) unsafeCoerce++-- | Identity.+sZigZagRefl :: SInteger i -> (i :~: ZagZig (ZigZag i))+sZigZagRefl !_ = unsafeCoerce Refl++-- | Demoted version of 'ZagZig'.+zagZig :: Natural -> P.Integer+zagZig 0 = 0+zagZig n = if odd n then P.negate (P.toInteger (P.div (n + 1) 2))+                    else P.toInteger (P.div n 2)++-- | Singleton version of 'ZagZig'.+sZagZig :: Sing (n :: Natural) -> SInteger (ZagZig n)+sZagZig = UnsafeSInteger . zagZig . fromSing++-- | Identity.+sZagZigRefl :: Sing (n :: Natural) -> (n :~: ZigZag (ZagZig n))+sZagZigRefl !_ = unsafeCoerce Refl++-- | ZigZag encoding of an 'Integer'.+--+-- * /0/ is /0/+--+-- * /-x/ is /abs(x) * 2 - 1/+--+-- * /+x/ is /x * 2/+type ZigZag :: Integer -> Natural+type ZigZag (i :: Integer) = ZigZag_ (Normalized i) :: Natural+type family ZigZag_ (i :: Integer) :: Natural where+  ZigZag_  Z    = 0+  ZigZag_ (P x) = x P.* 2+  ZigZag_ (N x) = x P.* 2 P.- 1++data ZigZagSym0 :: Integer ~> Natural+type ZigZagSym1 :: Integer -> Natural++type instance Apply ZigZagSym0 i = ZigZagSym1 i+type ZigZagSym1 i = ZigZag i++-- | Inverse of 'ZigZag'.+type ZagZig :: Natural -> Integer+type ZagZig n = If (L.Mod n 2 P.== 1)+                   (P.Negate (FromNatural (L.Div (n L.+ 1) 2)))+                   (FromNatural (L.Div n 2))++data ZagZigSym0 :: Natural ~> Integer+type ZagZigSym1 :: Natural -> Integer++type instance Apply ZagZigSym0 n = ZagZigSym1 n+type ZagZigSym1 n = ZagZig n++--------------------------------------------------------------------------------+++-- | Whether a type-level 'Integer' is odd. /Zero/ is not considered odd.+type Odd (i :: Integer) = L.Mod (Abs i) 2 P.== 1 :: Bool++data OddSym0 :: Integer ~> Bool+type OddSym1 :: Integer -> Bool++type instance Apply OddSym0 i = Odd i+type OddSym1 i = Odd i++-- | Singleton version of 'Odd'.+sOdd :: SInteger i -> Sing (Odd i :: Bool)+sOdd si | odd (fromSing si) = unsafeCoerce STrue+        | otherwise         = unsafeCoerce SFalse++-- | Whether a type-level 'Integer' is even. /Zero/ is considered even.+type Even (i :: Integer) = L.Mod (Abs i) 2 P.== 0 :: Bool++data EvenSym0 :: Integer ~> Bool+type EvenSym1 :: Integer -> Bool++type instance Apply EvenSym0 i = Even i+type EvenSym1 i = Even i++-- | Singleton version of 'Even'.+sEven :: SInteger i -> Sing (Even i :: Bool)+sEven si | even (fromSing si) = unsafeCoerce STrue+         | otherwise          = unsafeCoerce SFalse++--------------------------------------------------------------------------------++-- | Double negation is identity.+sNegateRefl :: SInteger i -> (i :~: P.Negate (P.Negate i))+sNegateRefl !_ = unsafeCoerce Refl++--------------------------------------------------------------------------------++-- | Absolute value of a type-level 'Integer', as a type-level 'Natural'.+type Abs (i :: Integer) = Fold 0 P.IdSym0 P.IdSym0 i :: Natural++data AbsSym0 :: Integer ~> Natural+type AbsSym1 :: Integer -> Natural++type instance Apply AbsSym0 x = AbsSym1 x+type AbsSym1 x = Abs x++-- | Singleton version of 'Abs'.+sAbs :: SInteger i -> Sing (Abs i :: Natural)+sAbs si = withSomeSing @Natural (fromInteger (abs (fromSing si))) unsafeCoerce++--------------------------------------------------------------------------------++infixr 8 %^, ^, ^@#@$$$++-- | Singleton version of '^'.+(%^) :: Sing (b :: Integer) -> Sing (p :: Natural) -> Sing (b ^ p :: Integer)+sb %^ sp = UnsafeSInteger (fromSing sb ^ fromSing sp)+{-# INLINE (%^) #-}++-- | Exponentiation of type-level 'Integer's.+type (b :: Integer) ^ (p :: Natural) = Pow (Normalized b) p :: Integer++data (^@#@$) :: Integer ~> Natural ~> Integer+data (^@#@$$) :: Integer -> Natural ~> Integer+type (^@#@$$$) :: Integer -> Natural -> Integer++type instance Apply ((^@#@$$) b) p = (^@#@$$$) b p+type instance Apply (^@#@$) b = (^@#@$$) b+type (^@#@$$$) b p = b ^ p++type family Pow (b :: Integer) (p :: Natural) :: Integer where+  Pow _ 0 = P 1+  Pow Z _ = Z+  Pow (P b) p = FromNatural (b L.^ p)+  Pow (N b) p = FromNatural (b L.^ p) P.* If (Even (P p)) (P 1) (N 1)++--------------------------------------------------------------------------------++infixl 7 `Div`, `Rem`, `DivRem`++-- | Get both the quotient and the 'Rem'ainder of the 'Div'ision of+-- type-level 'Integer's @a@ and @b@ using the specified 'Round'ing @r@.+--+-- @+-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer').+--   (b '/=' 0) =>+--     'DivRem' r a b '=='  '('Div' r a b, 'Rem' r a b)+-- @+type DivRem (r :: Round) (a :: Integer) (b :: Integer) =+  '( Div r a b, Rem r a b ) :: (Integer, Integer)++data DivRemSym0 :: Round ~> Integer ~> Integer ~> (Integer, Integer)+data DivRemSym1 :: Round -> Integer ~> Integer ~> (Integer, Integer)+data DivRemSym2 :: Round -> Integer -> Integer ~> (Integer, Integer)+type DivRemSym3 :: Round -> Integer -> Integer -> (Integer, Integer)++type instance Apply DivRemSym0 r = DivRemSym1 r+type instance Apply (DivRemSym1 r) a = DivRemSym2 r a+type instance Apply (DivRemSym2 r a) b = DivRemSym3 r a b+type DivRemSym3 r a b = DivRem r a b++--------------------------------------------------------------------------------++-- | 'Rem'ainder of the division of type-level 'Integer' @a@ by @b@,+-- using the specified 'Round'ing @r@.+--+-- @+-- forall (r :: 'Round') (a :: 'Integer') (b :: 'Integer').+--   (b '/=' 0) =>+--     'Rem' r a b  '=='  a '-' b '*' 'Div' r a b+-- @+--+-- * Division by /zero/ doesn't type-check.+type Rem (r :: Round) (a :: Integer) (b :: Integer) =+  Rem_ r (Normalized a) (Normalized b) :: Integer+type Rem_ (r :: Round) (a :: Integer) (b :: Integer) =+  a P.- b P.* Div r a b :: Integer++data RemSym0 :: Round ~> Integer ~> Integer ~> Integer+data RemSym1 :: Round -> Integer ~> Integer ~> Integer+data RemSym2 :: Round -> Integer -> Integer ~> Integer+type RemSym3 :: Round -> Integer -> Integer -> Integer++type instance Apply RemSym0 r = RemSym1 r+type instance Apply (RemSym1 r) a = RemSym2 r a+type instance Apply (RemSym2 r a) b = RemSym3 r a b+type RemSym3 r a b = Rem r a b++-- | Demoted version of 'Rem'.+--+-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check.+rem :: Round+    -> P.Integer  -- ^ Dividend @a@.+    -> P.Integer  -- ^ Divisor @b@.+    -> P.Integer  -- ^ Remainder @m@.+rem r a b = snd (divRem r a b)++-- | Singleton version of 'Rem'.+sRem :: SRound r+     -> SInteger a  -- ^ Dividend.+     -> SInteger b  -- ^ Divisor.+     -> SInteger (Rem r a b)+sRem sr sa sb = snd (sDivRem sr sa sb)++--------------------------------------------------------------------------------++-- | Divide the type-level 'Integer' @a@ by @b@,+-- using the specified 'Round'ing @r@.+--+-- * Division by /zero/ doesn't type-check.+type Div (r :: Round) (a :: Integer) (b :: Integer) =+  Div_ r (Normalized a) (Normalized b) :: Integer+type family Div_ (r :: Round) (a :: Integer) (b :: Integer) :: Integer where+  Div_ r  Z     Z    = Div__ r Z 0+  Div_ r  Z    (P b) = Div__ r Z b+  Div_ r  Z    (N b) = Div__ r Z b+  Div_ r (P a) (P b) = Div__ r (P a) b+  Div_ r (N a) (N b) = Div__ r (P a) b+  Div_ r (P a) (N b) = Div__ r (N a) b+  Div_ r (N a) (P b) = Div__ r (N a) b++data DivSym0 :: Round ~> Integer ~> Integer ~> Integer+data DivSym1 :: Round -> Integer ~> Integer ~> Integer+data DivSym2 :: Round -> Integer -> Integer ~> Integer+type DivSym3 :: Round -> Integer -> Integer -> Integer++type instance Apply DivSym0 r = DivSym1 r+type instance Apply (DivSym1 r) a = DivSym2 r a+type instance Apply (DivSym2 r a) b = DivSym3 r a b+type DivSym3 r a b = Div r a b++type family Div__ (r :: Round) (a :: Integer) (b :: Natural) :: Integer where+  Div__ _ _   0 = L.TypeError ('L.Text "Division by zero")+  Div__ _ Z _ = Z++  Div__ 'RoundDown (P a) b = FromNatural (L.Div a b)+  Div__ 'RoundDown (N a) b = P.Negate (FromNatural (If (b L.* L.Div a b P.== a)+                                                       (L.Div a b)+                                                       (L.Div a b L.+ 1)))++  Div__ 'RoundUp a b = P.Negate (Div__ 'RoundDown (P.Negate a) b)++  Div__ 'RoundZero (P a) b = Div__ 'RoundDown (P a) b+  Div__ 'RoundZero (N a) b = P.Negate (Div__ 'RoundDown (P a) b)++  Div__ 'RoundAway (P a) b = Div__ 'RoundUp (P a) b+  Div__ 'RoundAway (N a) b = Div__ 'RoundDown (N a) b++  Div__ 'RoundHalfDown a b = If (HalfLT (R a b) (Div__ 'RoundUp a b))+                                (Div__ 'RoundUp a b)+                                (Div__ 'RoundDown a b)++  Div__ 'RoundHalfUp a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))+                              (Div__ 'RoundDown a b)+                              (Div__ 'RoundUp a b)++  Div__ 'RoundHalfEven a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))+                                (Div__ 'RoundDown a b)+                                (If (HalfLT (R a b) (Div__ 'RoundUp a b))+                                    (Div__ 'RoundUp a b)+                                    (If (Even (Div__ 'RoundDown a b))+                                        (Div__ 'RoundDown a b)+                                        (Div__ 'RoundUp a b)))++  Div__ 'RoundHalfOdd a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))+                               (Div__ 'RoundDown a b)+                               (If (HalfLT (R a b) (Div__ 'RoundUp a b))+                                   (Div__ 'RoundUp a b)+                                   (If (Odd (Div__ 'RoundDown a b))+                                       (Div__ 'RoundDown a b)+                                       (Div__ 'RoundUp a b)))++  Div__ 'RoundHalfZero a b = If (HalfLT (R a b) (Div__ 'RoundDown a b))+                                (Div__ 'RoundDown a b)+                                (If (HalfLT (R a b) (Div__ 'RoundUp a b))+                                    (Div__ 'RoundUp a b)+                                    (Div__ 'RoundZero a b))++  Div__ 'RoundHalfAway (P a) b = Div__ 'RoundHalfUp   (P a) b+  Div__ 'RoundHalfAway (N a) b = Div__ 'RoundHalfDown (N a) b++-- | Demoted version of 'Div'.+--+-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check.+div :: Round+    -> P.Integer  -- ^ Dividend @a@.+    -> P.Integer  -- ^ Divisor @b@.+    -> P.Integer  -- ^ Quotient @q@.+div r a b = fst (divRem r a b)++-- | Singleton version of 'Div'.+sDiv :: SRound r+     -> SInteger a  -- ^ Dividend.+     -> SInteger b  -- ^ Divisor.+     -> SInteger (Div r a b)+sDiv sr sa sb = fst (sDivRem sr sa sb)++--------------------------------------------------------------------------------++-- | Singleton version of 'Log2'.+sLog2 :: SInteger i -> Sing (Log2 i :: Natural)+sLog2 si = withSomeSing+             (fromIntegral (integerLog2 (fromSing si)) :: Natural)+             unsafeCoerce+++-- | Log base 2 ('floor'ed) of type-level 'Integer's.+--+-- * Logarithm of /zero/ doesn't type-check.+--+-- * Logarithm of negative number doesn't type-check.+type Log2 (a :: Integer) =+  Fold (L.TypeError ('L.Text "Logarithm of zero."))+       (P.ConstSym1 (L.TypeError ('L.Text "Logarithm of negative number.")))+       (L.Log2Sym0)+       a+    :: Natural++data Log2Sym0 :: Integer ~> Natural+type Log2Sym1 :: Integer -> Natural++type instance Apply Log2Sym0 a = Log2Sym1 a+type Log2Sym1 a = Log2 a++--------------------------------------------------------------------------------++-- | Singleton version of 'GCD'.+sGCD :: SInteger a -> SInteger b -> Sing (GCD a b :: Natural)+sGCD sa sb = withSomeSing @Natural+               (fromInteger (gcd (fromSing sa) (fromSing sb)))+               unsafeCoerce++-- | Greatest Common Divisor of type-level 'Integer' numbers @a@ and @b@.+--+-- Returns a 'Natural', since the Greatest Common Divisor is always positive.+type GCD (a :: Integer) (b :: Integer) = NatGCD (Abs a) (Abs b) :: Natural++data GCDSym0 :: Integer ~> Integer ~> Natural+data GCDSym1 :: Integer -> Integer ~> Natural+type GCDSym2 :: Integer -> Integer -> Natural++type instance Apply GCDSym0 a = GCDSym1 a+type instance Apply (GCDSym1 a) b = GCDSym2 a b+type GCDSym2 a b = GCD a b++-- | Greatest Common Divisor of type-level 'Natural's @a@ and @b@.+type family NatGCD (a :: Natural) (b :: Natural) :: Natural where+  NatGCD a 0 = a+  NatGCD a b = NatGCD b (L.Mod a b)++--------------------------------------------------------------------------------++-- | Singleton version of 'LCM'.+sLCM :: SInteger a -> SInteger b -> Sing (LCM a b :: Natural)+sLCM sa sb = withSomeSing @Natural+               (fromInteger (lcm (fromSing sa) (fromSing sb)))+               unsafeCoerce++-- | Least Common Multiple of type-level 'Integer' numbers @a@ and @b@.+--+-- Returns a 'Natural', since the Least Common Multiple is always positive.+type LCM (a :: Integer) (b :: Integer) = NatLCM (Abs a) (Abs b) :: Natural++data LCMSym0 :: Integer ~> Integer ~> Natural+data LCMSym1 :: Integer -> Integer ~> Natural+type LCMSym2 :: Integer -> Integer -> Natural++type instance Apply LCMSym0 a = LCMSym1 a+type instance Apply (LCMSym1 a) b = LCMSym2 a b+type LCMSym2 a b = LCM a b++-- | Least Common Multiple of type-level 'Natural's @a@ and @b@.+type NatLCM (a :: Natural) (b :: Natural) =+  L.Div a (NatGCD a b) L.* b :: Natural++--------------------------------------------------------------------------------++type Add_ :: Ordering -> Ordering ->  Natural -> Natural -> Integer+type family Add_ lc rc la ra where+  Add_ 'EQ 'EQ _ _ = Z+  Add_ 'EQ 'LT _ r = N r+  Add_ 'EQ 'GT _ r = P r+  Add_ 'LT 'EQ l _ = N l+  Add_ 'GT 'EQ l _ = P l+  Add_ 'LT 'LT l r = N (l L.+ r)+  Add_ 'LT 'GT l r = OrdCond (Compare l r) (P (r P.- l)) Z (N (l P.- r))+  Add_ 'GT 'GT l r = P (l L.+ r)+  Add_ 'GT 'LT l r = OrdCond (Compare l r) (N (r P.- l)) Z (P (l P.- r))++--------------------------------------------------------------------------------++type Mul_ :: Ordering -> Ordering ->  Natural -> Natural -> Integer+type family Mul_ lc rc la ra where+  Mul_ _   'EQ _ _ = Z+  Mul_ 'EQ _   _ _ = Z+  Mul_ x   x   l r = P (l L.* r)+  Mul_ _   _   l r = N (l L.* r)++--------------------------------------------------------------------------------++instance P.PNum Integer where+  type l + r = Add_ (Compare l Z) (Compare r Z) (Abs l) (Abs r)+  type l - r = l P.+ P.Negate r+  type l * r = Mul_ (Compare l Z) (Compare r Z) (Abs l) (Abs r)+  type Negate i = Fold Z PSym0 NSym0 i+  type Abs i = FromNatural (Abs i)+  type Signum i = Fold Z (P.ConstSym1 (N 1)) (P.ConstSym1 (P 1)) i+  type FromInteger i = FromNatural i++instance P.SNum Integer where+  l %+ r = UnsafeSInteger (fromSing l + fromSing r)+  l %- r = UnsafeSInteger (fromSing l - fromSing r)+  l %* r = UnsafeSInteger (fromSing l * fromSing r)+  sNegate = UnsafeSInteger . negate . fromSing+  sAbs = sFromNatural . sAbs+  sSignum = UnsafeSInteger . signum . fromSing+  sFromInteger = sFromNatural++--------------------------------------------------------------------------------++type instance Compare (l :: Integer) (r :: Integer) =+  CmpInteger_ (Fold 'EQ (P.ConstSym1 'LT) (P.ConstSym1 'GT) l)+              (Fold 'EQ (P.ConstSym1 'LT) (P.ConstSym1 'GT) r)+              (Abs l)+              (Abs r)++type CmpInteger_ :: Ordering -> Ordering -> Natural -> Natural -> Ordering+type family CmpInteger_ lc rc la ra where+  CmpInteger_ 'LT 'LT l r = Compare r l+  CmpInteger_ 'LT 'EQ _ _ = 'LT+  CmpInteger_ 'LT 'GT _ _ = 'LT+  CmpInteger_ 'EQ 'LT _ _ = 'GT+  CmpInteger_ 'EQ 'EQ _ _ = 'EQ+  CmpInteger_ 'EQ 'GT _ _ = 'LT+  CmpInteger_ 'GT 'LT _ _ = 'GT+  CmpInteger_ 'GT 'EQ _ _ = 'GT+  CmpInteger_ 'GT 'GT l r = Compare l r++instance OrdS.POrd Integer where+  type Compare l r = Data.Type.Ord.Compare l r++instance OrdS.SOrd Integer where+  sCompare sa sb =+    case compare (fromSing sa) (fromSing sb) of+      LT -> unsafeCoerce OrdS.SLT+      EQ -> unsafeCoerce OrdS.SEQ+      GT -> unsafeCoerce OrdS.SGT++--------------------------------------------------------------------------------++instance EqS.PEq Integer where+  type a == b = OrdCond (Compare a b) 'False 'True 'False++instance EqS.SEq Integer where+  sa %== sb = case fromSing sa P.== fromSing sb of+    True  -> unsafeCoerce STrue+    False -> unsafeCoerce SFalse++--------------------------------------------------------------------------------++-- | We either get evidence that this function was instantiated with the+-- same type-level 'Integer's, or 'Nothing'.+sameInteger+  :: forall a b proxy1 proxy2+  .  (KnownInteger a, KnownInteger b)+  => proxy1 a+  -> proxy2 b+  -> Maybe (a :~: b)+sameInteger _ _ = testEquality (sing @a) (sing @b)++-- | Like 'sameInteger', but if the type-level 'Integer's aren't equal, this+-- additionally provides proof of 'LT' or 'GT'.+cmpInteger+  :: forall a b proxy1 proxy2+  .  (KnownInteger a, KnownInteger b)+  => proxy1 a+  -> proxy2 b+  -> OrderingI a b+cmpInteger _ _ = case compare (demote @a) (demote @b) of+  EQ | Refl <- (unsafeCoerce Refl :: a :~: b)+     , Refl <- (unsafeCoerce Refl :: Compare a b :~: 'EQ) -> EQI+  LT | Refl <- (unsafeCoerce Refl :: Compare a b :~: 'LT) -> LTI+  GT | Refl <- (unsafeCoerce Refl :: Compare a b :~: 'GT) -> GTI++--------------------------------------------------------------------------------++-- | Singleton type for a type-level 'Integer' @i@.+newtype SInteger (i :: Integer) = UnsafeSInteger P.Integer+type role SInteger representational++-- | A explicitly bidirectional pattern synonym relating an 'SInteger' to a+-- 'KnownInteger' constraint.+--+-- As an __expression__: Constructs an explicit @'SInteger' i@ value from an+-- implicit @'KnownInteger' i@ constraint:+--+-- @+-- 'SInteger' @i :: 'KnownInteger' i => 'SInteger' i+-- @+--+-- As a __pattern__: Matches on an explicit @'SInteger' i@ value bringing+-- an implicit @'KnownInteger' i@ constraint into scope:+--+-- @+-- f :: 'SInteger' i -> ..+-- f si\@'SInteger' = /... both (si :: 'SInteger' i) and ('KnownInteger' i) in scope .../+-- @+pattern SInteger :: forall i. () => KnownInteger i => SInteger i+pattern SInteger <- (patternSInteger -> PatternSInteger)+  where SInteger = integerSing+{-# COMPLETE SInteger #-}++-- | Only used for defining the 'SInteger' pattern synonym.+data PatternSInteger (i :: Integer) where+  PatternSInteger :: KnownInteger i => PatternSInteger i++-- | Only used for defining the 'SInteger' pattern synonym.+patternSInteger :: SInteger i -> PatternSInteger i+patternSInteger si = withKnownInteger si PatternSInteger++instance Eq (SInteger i) where+  _ == _ = True++instance Ord (SInteger i) where+  compare _ _ = P.EQ++instance P.Show (SInteger i) where+  showsPrec p i =+    showParen (p >= appPrec1) $+      showString "SInteger @" .+      showsPrecLit appPrec1 (fromSing i)++instance forall i. KnownInteger i => Read (SInteger i) where+  readPrec = ReadPrec.lift $ do+    let si = integerSing @i+    _ <- ReadP.string "SInteger" >> pSkipSpaces1+    _ <- ReadP.char '@'+    _ <- ReadP.string (showsPrecLit appPrec1 (fromSing si) "")+    pure si++instance TestEquality SInteger where+  testEquality = decideEquality+  {-# INLINE testEquality #-}++instance TestCoercion SInteger where+  testCoercion = decideCoercion+  {-# INLINE testCoercion #-}++-- | Return the term-level "Prelude".'P.Integer' number corresponding to @i@.+fromSInteger :: SInteger i -> P.Integer+fromSInteger = coerce+{-# INLINE fromSInteger #-}++withKnownInteger_+  :: forall i rep (x :: TYPE rep)+  .  SInteger i+  -> (KnownInteger_ i => x)+  -> x+withKnownInteger_ = withDict @(KnownInteger_ i)++-- | Convert an explicit @'SInteger' i@ value into an implicit+-- @'KnownInteger' i@ constraint.+withKnownInteger+  :: forall i rep (x :: TYPE rep)+  .  SInteger i+  -> (KnownInteger i => x)+  -> x+withKnownInteger si x+  | sa :: Sing a <- sAbs si+  , Refl <- sNormalizedRefl si+  = L.withKnownNat sa (withKnownInteger_ si x)++-- | Convert a "Prelude".'P.Integer' number into an @'SInteger' n@ value,+-- where @n@ is a fresh type-level 'Integer'.+withSomeSInteger+  :: forall rep (x :: TYPE rep)+  .  P.Integer+  -> (forall (i :: Integer). Sing i -> x)+  -> x+withSomeSInteger i k = k (UnsafeSInteger i)+-- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats"+{-# NOINLINE withSomeSInteger #-}++--------------------------------------------------------------------------------++type instance Sing = SInteger++instance (KnownInteger i) => SingI (i :: Integer) where+  sing = integerSing+  {-# INLINE sing #-}++instance SingKind Integer where+  type Demote Integer = P.Integer+  fromSing = fromSInteger+  {-# INLINE fromSing #-}+  toSing i = withSomeSInteger i SomeSing+  {-# INLINE toSing #-}++instance SDecide Integer where+  l %~ r = case fromSing l P.== fromSing r of+    True  -> Proved (unsafeCoerce Refl)+    False -> Disproved (\Refl -> error "KindInteger.Integer: SDecide")++--------------------------------------------------------------------------------++-- | Demoted version of 'DivRem'.+--+-- Throws 'Ex.DivdeByZero' where 'Div' would fail to type-check.+divRem+  :: Round+  -> P.Integer  -- ^ Dividend @a@.+  -> P.Integer  -- ^ Divisor @b@.+  -> (P.Integer, P.Integer)  -- ^ Quotient @q@ and remainder @m@.+{-# NOINLINE divRem #-}+divRem RoundZero = \a (errDiv0 -> b) -> P.quotRem a b+divRem RoundDown = \a (errDiv0 -> b) -> P.divMod a b+divRem RoundUp = \a (errDiv0 -> b) -> _divRemRoundUpNoCheck a b+divRem RoundAway = \a (errDiv0 -> b) ->+  if xor (a < 0) (b < 0)+     then P.divMod a b+     else _divRemRoundUpNoCheck a b+divRem RoundHalfUp = _divRemHalf $ \_ _ up -> up+divRem RoundHalfDown = _divRemHalf $ \_ down _ -> down+divRem RoundHalfZero = _divRemHalf $ \neg down up ->+  if neg then up else down+divRem RoundHalfAway = _divRemHalf $ \neg down up ->+  if neg then down else up+divRem RoundHalfEven = _divRemHalf $ \_ down up ->+  if even (fst down) then down else up+divRem RoundHalfOdd = _divRemHalf $ \_ down up ->+  if odd (fst down) then down else up++_divRemRoundUpNoCheck :: P.Integer -> P.Integer -> (P.Integer, P.Integer)+_divRemRoundUpNoCheck a b =+  let q = negate (P.div (negate a) b)+  in (q, a - b * q)+{-# INLINE _divRemRoundUpNoCheck #-}++_divRemHalf+  :: (Bool ->+      (P.Integer, P.Integer) ->+      (P.Integer, P.Integer) ->+      (P.Integer, P.Integer))+  -- ^ Negative -> divRem RoundDown -> divRem RoundUp -> Result+  -> P.Integer  -- ^ Dividend+  -> P.Integer  -- ^ Divisor+  -> (P.Integer, P.Integer)+_divRemHalf f = \a (errDiv0 -> b) ->+  let neg  = xor (a < 0) (b < 0)+      down = P.divMod a b+      up   = _divRemRoundUpNoCheck a b+  in  case compare (a P.% b - toRational (fst down)) (1 P.:% 2) of+        LT -> down+        GT -> up+        EQ -> f neg down up+{-# INLINE _divRemHalf #-}++-- | Singleton version of 'DivRem'.+sDivRem :: SRound r+        -> SInteger a   -- ^ Dividend.+        -> SInteger b   -- ^ Divisor.+        -> (SInteger (Div r a b), SInteger (Rem r a b))+sDivRem sr sa sb =+  let (q, m) = divRem (fromSing sr) (fromSing sa) (fromSing sb)+  in withSomeSing q $ \sq ->+     withSomeSInteger m $ \sm ->+     (unsafeCoerce sq, unsafeCoerce sm)++--------------------------------------------------------------------------------+-- Rational tools necessary to support 'HalfLT'++data Rat = MkRat Integer Natural+  -- ^ Invariant: 'Natural' is never 0. This is enforced by the 'R' type-family.++type R :: Integer -> Natural -> Rat+type family R n d where+  R _ 0 = L.TypeError ('L.Text "Denominator is 0.")+  R n d = Fold ('MkRat Z 1) (RAuxSym2 NSym0 d) (RAuxSym2 PSym0 d) n++data RAuxSym2 :: (Natural ~> Integer) -> Natural -> Natural ~> Rat+type instance Apply (RAuxSym2 fn d) n = 'MkRat (fn @@ n) d++type RatReduce :: Rat -> Rat+type family RatReduce r where+  RatReduce ('MkRat n d) = 'MkRat+    (P.Signum n P.* FromNatural (L.Div (Abs n) (NatGCD (Abs n) d)))+    (L.Div d (NatGCD (Abs n) d))++type RatAbs :: Rat -> Rat+type family RatAbs r where+  RatAbs ('MkRat n d) = R (P.Abs n) d++type RatAdd :: Rat -> Rat -> Rat+type family RatAdd l r where+  RatAdd ('MkRat ln ld) ('MkRat rn rd) =+    RatReduce (R (ln P.* P rd P.+ rn P.* P ld) (ld P.* rd))++type RatNegate :: Rat -> Rat+type family RatNegate r where+  RatNegate ('MkRat n d) = R (P.Negate n) d++type RatMinus :: Rat -> Rat -> Rat+type RatMinus l r = RatAdd l (RatNegate r)++type RatCmp :: Rat -> Rat -> Ordering+type RatCmp l r = RatCmp_ (RatReduce l) (RatReduce r)+type family RatCmp_ (a :: Rat) (b :: Rat) :: Ordering where+  RatCmp_ a a = 'EQ+  RatCmp_ ('MkRat an ad) ('MkRat bn bd) = Compare (an P.* P bd) (bn P.* P ad)++-- | ''True' if the distance between @a@ and @b@ is less than /0.5/.+type HalfLT :: Rat -> Integer -> Bool+type HalfLT a b =+  'LT P.== RatCmp (RatAbs (RatMinus a ('MkRat b 1))) ('MkRat (P 1) 2)++--------------------------------------------------------------------------------++errDiv0 :: P.Integer -> P.Integer+errDiv0 0 = Ex.throw Ex.DivideByZero+errDiv0 i = i++pSkipSpaces1 :: ReadP.ReadP ()+pSkipSpaces1 = void $ ReadP.munch1 Char.isSpace 

@@ -0,0 +1,73 @@+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE UndecidableInstances #-}++-- | We define 'Round' here keep the TemplateHaskell stuff contained.+module KindInteger.Round {--}+  ( Round(..)+  , RoundUpSym0+  , RoundDownSym0+  , RoundZeroSym0+  , RoundAwaySym0+  , RoundHalfUpSym0+  , RoundHalfDownSym0+  , RoundHalfZeroSym0+  , RoundHalfAwaySym0+  , RoundHalfEvenSym0+  , RoundHalfOddSym0+  , SRound(..)+  ) --}+  where++import Data.Bool.Singletons+import Data.Eq.Singletons+import Data.Ord.Singletons+import Data.Singletons.TH+import Prelude.Singletons++--------------------------------------------------------------------------------++-- | Rounding strategy.+data Round+  = RoundUp+  -- ^ Round __up__ towards positive infinity.+  | RoundDown+  -- ^ Round __down__ towards negative infinity.  Also known as "Prelude"'s+  -- 'P.floor'. This is the type of rounding used by "Prelude"'s 'P.div',+  -- 'P.mod', 'P.divMod', 'L.Div', 'L.Mod'.+  | RoundZero+  -- ^ Round towards __zero__.  Also known as "Prelude"'s 'P.truncate'. This is+  -- the type of rounding used by "Prelude"'s 'P.quot', 'P.rem', 'P.quotRem'.+  | RoundAway+  -- ^ Round __away__ from zero.+  | RoundHalfUp+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round __up__ towards positive infinity.+  | RoundHalfDown+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round __down__ towards negative infinity.+  | RoundHalfZero+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round towards __zero__.+  | RoundHalfAway+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round __away__ from zero.+  | RoundHalfEven+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round towards the closest __even__ integer. Also known as "Prelude"'s+  -- 'P.round'.+  | RoundHalfOdd+  -- ^ Round towards the closest integer. If __half__way between two integers,+  -- round towards the closest __odd__ integer.+  deriving stock (Read)++$(fmap concat $ sequence+    [ genSingletons [''Round]+    , singletons [d|+      deriving stock instance Bounded Round+      deriving stock instance Enum Round+      deriving stock instance Eq Round+      deriving stock instance Ord Round+      deriving stock instance Show Round+      |]+    ])+

@@ -11,3364 +11,3647 @@ import Data.Ratio as P import Data.Type.Equality (TestEquality(..)) import Data.Type.Ord (type (<=))-import GHC.Exts (Constraint)-import Prelude hiding (Integer)-import Prelude qualified as P-import System.Exit-import Text.Read--import KindInteger (P, N)-import KindInteger qualified as K------------------------------------------------------------------------------------data Dict (c :: Constraint) where-  Dict :: c => Dict c------------------------------------------------------------------------------------_testEq =  Dict-_testEq :: Dict-  ( P 0 K.== P 0,   'True ~ (P 0 K.==? P 0)-  , N 0 K.== N 0,   'True ~ (N 0 K.==? N 0)-  , P 0 K.== N 0,   'True ~ (P 0 K.==? N 0)-  , N 0 K.== P 0,   'True ~ (N 0 K.==? P 0)--  , P 0 K./= P 1,   'True ~ (P 0 K./=? P 1)-  , P 0 K./= N 1,   'True ~ (P 0 K./=? N 1)--  , N 0 K./= N 1,   'True ~ (N 0 K./=? N 1)-  , N 0 K./= N 1,   'True ~ (N 0 K./=? N 1)--  , P 1 K./= P 0,   'True ~ (P 1 K./=? P 0)-  , P 1 K./= N 0,   'True ~ (P 1 K./=? N 0)--  , N 1 K./= N 0,   'True ~ (N 1 K./=? N 0)-  , N 1 K./= N 0,   'True ~ (N 1 K./=? N 0)-  )--_testCmp =  Dict-_testCmp :: Dict-  ( P 0 <= P 0-  , P 0 <= N 0-  , N 0 <= P 0-  , N 0 <= N 0--  , N 2 <= N 1-  , N 1 <= N 0-  , N 0 <= P 1--  , P 0 <= P 1-  , P 1 <= P 2-  )--_testAdd  = Dict-_testAdd :: Dict-  ( P 0 ~ P 0 K.+ P 0-  , P 0 ~ N 0 K.+ N 0-  , P 0 ~ P 0 K.+ N 0-  , P 0 ~ N 0 K.+ P 0--  , P 1 ~ P 1 K.+ P 0-  , N 1 ~ N 1 K.+ N 0-  , P 1 ~ P 1 K.+ N 0-  , N 1 ~ N 1 K.+ P 0--  , P 1 ~ P 0 K.+ P 1-  , N 1 ~ N 0 K.+ N 1-  , N 1 ~ P 0 K.+ N 1-  , P 1 ~ N 0 K.+ P 1--  , P 2 ~ P 1 K.+ P 1-  , N 2 ~ N 1 K.+ N 1-  , P 0 ~ P 1 K.+ N 1-  , P 0 ~ N 1 K.+ P 1-  )--_testMul  = Dict-_testMul :: Dict-  ( P 0 ~ P 0 K.* P 0-  , P 0 ~ N 0 K.* N 0-  , P 0 ~ P 0 K.* N 0-  , P 0 ~ N 0 K.* P 0--  , P 0 ~ P 1 K.* P 0-  , P 0 ~ N 1 K.* N 0-  , P 0 ~ P 1 K.* N 0-  , P 0 ~ N 1 K.* P 0--  , P 0 ~ P 0 K.* P 1-  , P 0 ~ N 0 K.* N 1-  , P 0 ~ P 0 K.* N 1-  , P 0 ~ N 0 K.* P 1--  , P 1 ~ P 1 K.* P 1-  , P 1 ~ N 1 K.* N 1-  , N 1 ~ P 1 K.* N 1-  , N 1 ~ N 1 K.* P 1--  , P 2 ~ P 2 K.* P 1-  , P 2 ~ N 2 K.* N 1-  , N 2 ~ P 2 K.* N 1-  , N 2 ~ N 2 K.* P 1--  , P 6 ~ P 2 K.* P 3-  , P 6 ~ N 2 K.* N 3-  , N 6 ~ P 2 K.* N 3-  , N 6 ~ N 2 K.* P 3-  )--_testLog2 =  Dict-_testLog2 :: Dict-  ( P 0 ~ K.Log2 (P 1)-  , P 1 ~ K.Log2 (P 2)-  , P 1 ~ K.Log2 (P 3)-  , P 2 ~ K.Log2 (P 4)-  , P 2 ~ K.Log2 (P 5)-  , P 2 ~ K.Log2 (P 6)-  , P 2 ~ K.Log2 (P 7)-  , P 3 ~ K.Log2 (P 8)-  , P 3 ~ K.Log2 (P 9)-  , P 3 ~ K.Log2 (P 10)-  , P 3 ~ K.Log2 (P 11)-  , P 3 ~ K.Log2 (P 12)-  , P 3 ~ K.Log2 (P 13)-  , P 3 ~ K.Log2 (P 14)-  , P 3 ~ K.Log2 (P 15)-  , P 4 ~ K.Log2 (P 16)-  , P 4 ~ K.Log2 (P 17)-  , P 4 ~ K.Log2 (P 18)-  , P 4 ~ K.Log2 (P 19)-  , P 4 ~ K.Log2 (P 20)-  , P 4 ~ K.Log2 (P 21)-  , P 4 ~ K.Log2 (P 22)-  , P 4 ~ K.Log2 (P 23)-  , P 4 ~ K.Log2 (P 24)-  , P 4 ~ K.Log2 (P 25)-  , P 4 ~ K.Log2 (P 26)-  , P 4 ~ K.Log2 (P 27)-  , P 4 ~ K.Log2 (P 28)-  , P 4 ~ K.Log2 (P 29)-  , P 4 ~ K.Log2 (P 30)-  , P 4 ~ K.Log2 (P 31)-  , P 5 ~ K.Log2 (P 32)-  )--_testNegate =  Dict-_testNegate :: Dict-  ( P 0 ~ K.Negate (P 0)-  , P 0 ~ K.Negate (N 0)-  , N 1 ~ K.Negate (P 1)-  , P 1 ~ K.Negate (N 1)-  , N 2 ~ K.Negate (P 2)-  , P 2 ~ K.Negate (N 2)-  )--_testSign =  Dict-_testSign :: Dict-  ( P 0 ~ K.Sign (P 0)-  , P 0 ~ K.Sign (N 0)-  , P 1 ~ K.Sign (P 1)-  , N 1 ~ K.Sign (N 1)-  , P 1 ~ K.Sign (P 2)-  , N 1 ~ K.Sign (N 2)-  )--_testAbs =  Dict-_testAbs :: Dict-  ( 0 ~ K.Abs (P 0)-  , 0 ~ K.Abs (N 0)-  , 1 ~ K.Abs (P 1)-  , 1 ~ K.Abs (N 1)-  , 2 ~ K.Abs (P 2)-  , 2 ~ K.Abs (N 2)-  )--_testEven =  Dict-_testEven :: Dict-  ( 'True  ~ K.Even (P 0)-  , 'True  ~ K.Even (N 0)-  , 'False ~ K.Even (P 1)-  , 'False ~ K.Even (N 1)-  , 'True  ~ K.Even (P 2)-  , 'True  ~ K.Even (N 2)-  )--_testOdd =  Dict-_testOdd :: Dict-  ( 'False  ~ K.Odd (P 0)-  , 'False  ~ K.Odd (N 0)-  , 'True   ~ K.Odd (P 1)-  , 'True   ~ K.Odd (N 1)-  , 'False  ~ K.Odd (P 2)-  , 'False  ~ K.Odd (N 2)-  )--_testGCD =  Dict-_testGCD :: Dict-  ( 0 ~ K.GCD (P 0) (P 0)-  , 0 ~ K.GCD (P 0) (N 0)-  , 0 ~ K.GCD (N 0) (P 0)-  , 0 ~ K.GCD (N 0) (N 0)--  , 1 ~ K.GCD (P 1) (P 0)-  , 1 ~ K.GCD (P 1) (N 0)-  , 1 ~ K.GCD (N 1) (P 0)-  , 1 ~ K.GCD (N 1) (N 0)--  , 1 ~ K.GCD (P 0) (P 1)-  , 1 ~ K.GCD (P 0) (N 1)-  , 1 ~ K.GCD (N 0) (P 1)-  , 1 ~ K.GCD (N 0) (N 1)--  , 1 ~ K.GCD (P 1) (P 2)-  , 1 ~ K.GCD (P 1) (N 2)-  , 1 ~ K.GCD (N 1) (P 2)-  , 1 ~ K.GCD (N 1) (N 2)--  , 1 ~ K.GCD (P 2) (P 1)-  , 1 ~ K.GCD (P 2) (N 1)-  , 1 ~ K.GCD (N 2) (P 1)-  , 1 ~ K.GCD (N 2) (N 1)--  , 3 ~ K.GCD (P 6) (P 9)-  , 3 ~ K.GCD (P 6) (N 9)-  , 3 ~ K.GCD (N 6) (P 9)-  , 3 ~ K.GCD (N 6) (N 9)--  , 3 ~ K.GCD (P 9) (P 6)-  , 3 ~ K.GCD (P 9) (N 6)-  , 3 ~ K.GCD (N 9) (P 6)-  , 3 ~ K.GCD (N 9) (N 6)-  )--_testLCM =  Dict-_testLCM :: Dict-  ( 0 ~ K.LCM (P 0) (P 0)-  , 0 ~ K.LCM (P 0) (N 0)-  , 0 ~ K.LCM (N 0) (P 0)-  , 0 ~ K.LCM (N 0) (N 0)--  , 0 ~ K.LCM (P 1) (P 0)-  , 0 ~ K.LCM (P 1) (N 0)-  , 0 ~ K.LCM (N 1) (P 0)-  , 0 ~ K.LCM (N 1) (N 0)--  , 0 ~ K.LCM (P 0) (P 1)-  , 0 ~ K.LCM (P 0) (N 1)-  , 0 ~ K.LCM (N 0) (P 1)-  , 0 ~ K.LCM (N 0) (N 1)--  , 2 ~ K.LCM (P 1) (P 2)-  , 2 ~ K.LCM (P 1) (N 2)-  , 2 ~ K.LCM (N 1) (P 2)-  , 2 ~ K.LCM (N 1) (N 2)--  , 2 ~ K.LCM (P 2) (P 1)-  , 2 ~ K.LCM (P 2) (N 1)-  , 2 ~ K.LCM (N 2) (P 1)-  , 2 ~ K.LCM (N 2) (N 1)--  , 18 ~ K.LCM (P 6) (P 9)-  , 18 ~ K.LCM (P 6) (N 9)-  , 18 ~ K.LCM (N 6) (P 9)-  , 18 ~ K.LCM (N 6) (N 9)--  , 18 ~ K.LCM (P 9) (P 6)-  , 18 ~ K.LCM (P 9) (N 6)-  , 18 ~ K.LCM (N 9) (P 6)-  , 18 ~ K.LCM (N 9) (N 6)-  )------------------------------------------------------------------------------------assert-  :: String  -- ^ Test name-  -> Bool    -- ^ Successful is true-  -> IO Bool -- ^ Return the same 'Bool' given as input.-assert n x = do-  putStrLn ((if x then "[OK] " else "[FAIL] ") <> n)-  pure x--testsMain :: [IO Bool] -> IO a-testsMain xs = do-  res <- sequence xs-  let (oks, bads) = List.partition id res-  putStrLn ("[TOTAL] OK: " <> show (length oks) <>-            ". FAIL: " <> show (length bads) <> ".")-  case bads of-    [] -> exitSuccess-    _  -> exitFailure--main :: IO ()-main = testsMain $-  [ assert "Prelude % throws RatioZeroDenominator" =<< do-      ea <- Ex.try (Ex.evaluate (1 P.% 0 :: P.Rational))-      pure (ea == Left Ex.RatioZeroDenominator)--  , assert "integerVal . someIntegerVal == id" $-    flip all [-5 .. 5] $ \a ->-      let a' = K.fromPrelude a-      in case K.someIntegerVal a' of-           K.SomeInteger pa ->-             a' == K.integerVal pa--  , assert "sameIntegerVal a a" $-    flip all [-5 .. 5] $ \a ->-      let a' = K.fromPrelude a-      in case K.someIntegerVal a' of-           K.SomeInteger pa ->-             isJust (K.sameInteger pa pa)--  , assert "sameIntegerVal a a'" $-    flip all [-5 .. 5] $ \a ->-      let a' = K.fromPrelude a-      in case (K.someIntegerVal a', K.someIntegerVal a') of-           (K.SomeInteger pa1, K.SomeInteger pa2) ->-             isJust (K.sameInteger pa1 pa2)--  , assert "sameIntegerVal a b" $-    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->-      let a' = K.fromPrelude a-          b' = K.fromPrelude b-      in case (K.someIntegerVal a', K.someIntegerVal b') of-           (K.SomeInteger pa, K.SomeInteger pb)-             | a == b    -> isJust    (K.sameInteger pa pb)-             | otherwise -> isNothing (K.sameInteger pa pb)--  , assert "Eq fromPrelude" $-    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->-      (a == b) == (K.fromPrelude a == K.fromPrelude b)--  , assert "Ord fromPrelude" $-    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->-      (a `compare` b) == (K.fromPrelude a `compare` K.fromPrelude b)--  , assert "Show fromPrelude" $-    flip all [-5 .. 5] $ \i ->-      show i == show (K.fromPrelude i)--  , assert "Read fromPrelude" $-    flip all [-5 .. 5] $ \i ->-      let str = show (i :: P.Integer)-      in readMaybe @P.Integer str-            == fmap K.toPrelude (readMaybe @K.Integer str)--  , assert "Eq SomeInteger" $-    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->-      let a' = K.fromPrelude a-          b' = K.fromPrelude b-      in (a == b) == (K.someIntegerVal a' == K.someIntegerVal b')--  , assert "Ord SomeInteger" $-    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->-      compare a b ==-         compare (K.someIntegerVal (K.fromPrelude a))-                 (K.someIntegerVal (K.fromPrelude b))--  , assert "Show SomeInteger" $-    flip all [-5 .. 5] $ \a ->-      let a' = K.fromPrelude a-      in show a == show (K.someIntegerVal a')--  , assert "Read SomeInteger" $-    flip all [-5 .. 5] $ \i ->-      let str = show (i :: P.Integer)-      in readMaybe @P.Integer str-            == fmap (\(K.SomeInteger p) -> K.toPrelude (K.integerVal p))-                    (readMaybe @K.SomeInteger str)--  , assert "TestEquality +0 +0" $-     isJust (testEquality (K.SInteger @(P 0)) (K.SInteger @(P 0)))-  , assert "TestEquality -0 -0" $-     isJust (testEquality (K.SInteger @(N 0)) (K.SInteger @(N 0)))-  , assert "TestEquality +0 -0" $-     isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(N 0)))-  , assert "TestEquality -0 +0" $-     isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(P 0)))-  , assert "TestEquality +0 +1" $-     isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(P 1)))-  , assert "TestEquality +0 -1" $-     isNothing (testEquality (K.SInteger @(P 0)) (K.SInteger @(N 1)))-  , assert "TestEquality -0 +1" $-     isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(P 1)))-  , assert "TestEquality -0 -1" $-     isNothing (testEquality (K.SInteger @(N 0)) (K.SInteger @(N 1)))-  , assert "TestEquality +1 +0" $-     isNothing (testEquality (K.SInteger @(P 1)) (K.SInteger @(P 0)))-  , assert "TestEquality +1 -0" $-     isNothing (testEquality (K.SInteger @(P 1)) (K.SInteger @(N 0)))-  , assert "TestEquality -1 +0" $-     isNothing (testEquality (K.SInteger @(N 1)) (K.SInteger @(P 0)))-  , assert "TestEquality -1 -0" $-     isNothing (testEquality (K.SInteger @(N 1)) (K.SInteger @(N 0)))--  , assert "Show Integer +0" $-     "0" == show (K.fromSInteger (K.SInteger @(P 0)))-  , assert "Show Integer -0" $-     "0" == show (K.fromSInteger (K.SInteger @(N 0)))-  , assert "Show Integer +1" $-     "1" == show (K.fromSInteger (K.SInteger @(P 1)))-  , assert "Show Integer -1" $-     "-1" == show (K.fromSInteger (K.SInteger @(N 1)))--  , assert "Show SInteger +0" $-     "SInteger @(P 0)" == show (K.SInteger @(P 0))-  , assert "Show SInteger -0" $-     "SInteger @(N 0)" == show (K.SInteger @(N 0))-  , assert "Show SInteger +1" $-     "SInteger @(P 1)" == show (K.SInteger @(P 1))-  , assert "Show SInteger -1" $-     "SInteger @(N 1)" == show (K.SInteger @(N 1))--  ] <> testsDivRem--testsDivRem :: [IO Bool]-testsDivRem = do-  b :: P.Integer <- [-5 .. 5]-  guard (b P./= 0)-  a :: P.Integer <- [-5 .. 5]-  r :: K.Round <- [minBound .. maxBound]-  let tname :: String -> ShowS-      tname t = showString t . showChar ' ' . shows r . showChar ' '-              . shows a . showChar ' ' . shows b-  [ assert (tname "divRem" "") $ case K.divRem r a b of-                                   (q, m) -> m == a - b * q-    , assert (tname "div" "") $ fst (K.divRem r a b) == K.div r a b-    , assert (tname "rem" "") $ snd (K.divRem r a b) == K.rem r a b-    ]-------------------------------------------------------------------------------------_divRemTestCode :: String-_divRemTestCode = unlines $ List.sort $ do-  b <- [-4 .. 4]-  guard (b P./= 0)-  a <- [-4 .. 4]-  r <- [minBound..maxBound]-  let (q, m) = K.divRem r a b-      sname :: String -> ShowS-      sname t = showString "_test_"-              . showString t-              . showChar '_'-              . showsPrec 0 r-              . showChar '_'-              . showChar (if a < 0 then 'N' else 'P')-              . shows (abs a)-              . showChar '_'-              . showChar (if b < 0 then 'N' else 'P')-              . shows (abs b)-      sDiv :: ShowS-      sDiv = sname "Div"-           . showString " :: Dict (K.Div 'K."-           . shows r-           . showChar ' '-           . K.showsPrecTypeLit 11 (K.fromPrelude a)-           . showChar ' '-           . K.showsPrecTypeLit 11 (K.fromPrelude b)-           . showString " ~ "-           . K.showsPrecTypeLit 0 (K.fromPrelude q)-           . showString ")\n"-           . sname "Div"-           . showString " =  Dict"-      sRem :: ShowS-      sRem = sname "Rem"-           . showString " :: Dict (K.Rem 'K."-           . shows r-           . showChar ' '-           . K.showsPrecTypeLit 11 (K.fromPrelude a)-           . showChar ' '-           . K.showsPrecTypeLit 11 (K.fromPrelude b)-           . showString " ~ "-           . K.showsPrecTypeLit 0 (K.fromPrelude m)-           . showString ")\n"-           . sname "Rem"-           . showString " =  Dict"-      ss :: ShowS-      ss = sDiv . showChar '\n' . sRem-  pure (ss "")----- The following tests are generated by `_divRemTestCode` in this remule.--- Copy and paste by hand.-_test_Div_RoundAway_N1_N1 :: Dict (K.Div 'K.RoundAway (N 1) (N 1) ~ P 1)-_test_Div_RoundAway_N1_N1 =  Dict-_test_Rem_RoundAway_N1_N1 :: Dict (K.Rem 'K.RoundAway (N 1) (N 1) ~ P 0)-_test_Rem_RoundAway_N1_N1 =  Dict-_test_Div_RoundAway_N1_N2 :: Dict (K.Div 'K.RoundAway (N 1) (N 2) ~ P 1)-_test_Div_RoundAway_N1_N2 =  Dict-_test_Rem_RoundAway_N1_N2 :: Dict (K.Rem 'K.RoundAway (N 1) (N 2) ~ P 1)-_test_Rem_RoundAway_N1_N2 =  Dict-_test_Div_RoundAway_N1_N3 :: Dict (K.Div 'K.RoundAway (N 1) (N 3) ~ P 1)-_test_Div_RoundAway_N1_N3 =  Dict-_test_Rem_RoundAway_N1_N3 :: Dict (K.Rem 'K.RoundAway (N 1) (N 3) ~ P 2)-_test_Rem_RoundAway_N1_N3 =  Dict-_test_Div_RoundAway_N1_N4 :: Dict (K.Div 'K.RoundAway (N 1) (N 4) ~ P 1)-_test_Div_RoundAway_N1_N4 =  Dict-_test_Rem_RoundAway_N1_N4 :: Dict (K.Rem 'K.RoundAway (N 1) (N 4) ~ P 3)-_test_Rem_RoundAway_N1_N4 =  Dict-_test_Div_RoundAway_N1_P1 :: Dict (K.Div 'K.RoundAway (N 1) (P 1) ~ N 1)-_test_Div_RoundAway_N1_P1 =  Dict-_test_Rem_RoundAway_N1_P1 :: Dict (K.Rem 'K.RoundAway (N 1) (P 1) ~ P 0)-_test_Rem_RoundAway_N1_P1 =  Dict-_test_Div_RoundAway_N1_P2 :: Dict (K.Div 'K.RoundAway (N 1) (P 2) ~ N 1)-_test_Div_RoundAway_N1_P2 =  Dict-_test_Rem_RoundAway_N1_P2 :: Dict (K.Rem 'K.RoundAway (N 1) (P 2) ~ P 1)-_test_Rem_RoundAway_N1_P2 =  Dict-_test_Div_RoundAway_N1_P3 :: Dict (K.Div 'K.RoundAway (N 1) (P 3) ~ N 1)-_test_Div_RoundAway_N1_P3 =  Dict-_test_Rem_RoundAway_N1_P3 :: Dict (K.Rem 'K.RoundAway (N 1) (P 3) ~ P 2)-_test_Rem_RoundAway_N1_P3 =  Dict-_test_Div_RoundAway_N1_P4 :: Dict (K.Div 'K.RoundAway (N 1) (P 4) ~ N 1)-_test_Div_RoundAway_N1_P4 =  Dict-_test_Rem_RoundAway_N1_P4 :: Dict (K.Rem 'K.RoundAway (N 1) (P 4) ~ P 3)-_test_Rem_RoundAway_N1_P4 =  Dict-_test_Div_RoundAway_N2_N1 :: Dict (K.Div 'K.RoundAway (N 2) (N 1) ~ P 2)-_test_Div_RoundAway_N2_N1 =  Dict-_test_Rem_RoundAway_N2_N1 :: Dict (K.Rem 'K.RoundAway (N 2) (N 1) ~ P 0)-_test_Rem_RoundAway_N2_N1 =  Dict-_test_Div_RoundAway_N2_N2 :: Dict (K.Div 'K.RoundAway (N 2) (N 2) ~ P 1)-_test_Div_RoundAway_N2_N2 =  Dict-_test_Rem_RoundAway_N2_N2 :: Dict (K.Rem 'K.RoundAway (N 2) (N 2) ~ P 0)-_test_Rem_RoundAway_N2_N2 =  Dict-_test_Div_RoundAway_N2_N3 :: Dict (K.Div 'K.RoundAway (N 2) (N 3) ~ P 1)-_test_Div_RoundAway_N2_N3 =  Dict-_test_Rem_RoundAway_N2_N3 :: Dict (K.Rem 'K.RoundAway (N 2) (N 3) ~ P 1)-_test_Rem_RoundAway_N2_N3 =  Dict-_test_Div_RoundAway_N2_N4 :: Dict (K.Div 'K.RoundAway (N 2) (N 4) ~ P 1)-_test_Div_RoundAway_N2_N4 =  Dict-_test_Rem_RoundAway_N2_N4 :: Dict (K.Rem 'K.RoundAway (N 2) (N 4) ~ P 2)-_test_Rem_RoundAway_N2_N4 =  Dict-_test_Div_RoundAway_N2_P1 :: Dict (K.Div 'K.RoundAway (N 2) (P 1) ~ N 2)-_test_Div_RoundAway_N2_P1 =  Dict-_test_Rem_RoundAway_N2_P1 :: Dict (K.Rem 'K.RoundAway (N 2) (P 1) ~ P 0)-_test_Rem_RoundAway_N2_P1 =  Dict-_test_Div_RoundAway_N2_P2 :: Dict (K.Div 'K.RoundAway (N 2) (P 2) ~ N 1)-_test_Div_RoundAway_N2_P2 =  Dict-_test_Rem_RoundAway_N2_P2 :: Dict (K.Rem 'K.RoundAway (N 2) (P 2) ~ P 0)-_test_Rem_RoundAway_N2_P2 =  Dict-_test_Div_RoundAway_N2_P3 :: Dict (K.Div 'K.RoundAway (N 2) (P 3) ~ N 1)-_test_Div_RoundAway_N2_P3 =  Dict-_test_Rem_RoundAway_N2_P3 :: Dict (K.Rem 'K.RoundAway (N 2) (P 3) ~ P 1)-_test_Rem_RoundAway_N2_P3 =  Dict-_test_Div_RoundAway_N2_P4 :: Dict (K.Div 'K.RoundAway (N 2) (P 4) ~ N 1)-_test_Div_RoundAway_N2_P4 =  Dict-_test_Rem_RoundAway_N2_P4 :: Dict (K.Rem 'K.RoundAway (N 2) (P 4) ~ P 2)-_test_Rem_RoundAway_N2_P4 =  Dict-_test_Div_RoundAway_N3_N1 :: Dict (K.Div 'K.RoundAway (N 3) (N 1) ~ P 3)-_test_Div_RoundAway_N3_N1 =  Dict-_test_Rem_RoundAway_N3_N1 :: Dict (K.Rem 'K.RoundAway (N 3) (N 1) ~ P 0)-_test_Rem_RoundAway_N3_N1 =  Dict-_test_Div_RoundAway_N3_N2 :: Dict (K.Div 'K.RoundAway (N 3) (N 2) ~ P 2)-_test_Div_RoundAway_N3_N2 =  Dict-_test_Rem_RoundAway_N3_N2 :: Dict (K.Rem 'K.RoundAway (N 3) (N 2) ~ P 1)-_test_Rem_RoundAway_N3_N2 =  Dict-_test_Div_RoundAway_N3_N3 :: Dict (K.Div 'K.RoundAway (N 3) (N 3) ~ P 1)-_test_Div_RoundAway_N3_N3 =  Dict-_test_Rem_RoundAway_N3_N3 :: Dict (K.Rem 'K.RoundAway (N 3) (N 3) ~ P 0)-_test_Rem_RoundAway_N3_N3 =  Dict-_test_Div_RoundAway_N3_N4 :: Dict (K.Div 'K.RoundAway (N 3) (N 4) ~ P 1)-_test_Div_RoundAway_N3_N4 =  Dict-_test_Rem_RoundAway_N3_N4 :: Dict (K.Rem 'K.RoundAway (N 3) (N 4) ~ P 1)-_test_Rem_RoundAway_N3_N4 =  Dict-_test_Div_RoundAway_N3_P1 :: Dict (K.Div 'K.RoundAway (N 3) (P 1) ~ N 3)-_test_Div_RoundAway_N3_P1 =  Dict-_test_Rem_RoundAway_N3_P1 :: Dict (K.Rem 'K.RoundAway (N 3) (P 1) ~ P 0)-_test_Rem_RoundAway_N3_P1 =  Dict-_test_Div_RoundAway_N3_P2 :: Dict (K.Div 'K.RoundAway (N 3) (P 2) ~ N 2)-_test_Div_RoundAway_N3_P2 =  Dict-_test_Rem_RoundAway_N3_P2 :: Dict (K.Rem 'K.RoundAway (N 3) (P 2) ~ P 1)-_test_Rem_RoundAway_N3_P2 =  Dict-_test_Div_RoundAway_N3_P3 :: Dict (K.Div 'K.RoundAway (N 3) (P 3) ~ N 1)-_test_Div_RoundAway_N3_P3 =  Dict-_test_Rem_RoundAway_N3_P3 :: Dict (K.Rem 'K.RoundAway (N 3) (P 3) ~ P 0)-_test_Rem_RoundAway_N3_P3 =  Dict-_test_Div_RoundAway_N3_P4 :: Dict (K.Div 'K.RoundAway (N 3) (P 4) ~ N 1)-_test_Div_RoundAway_N3_P4 =  Dict-_test_Rem_RoundAway_N3_P4 :: Dict (K.Rem 'K.RoundAway (N 3) (P 4) ~ P 1)-_test_Rem_RoundAway_N3_P4 =  Dict-_test_Div_RoundAway_N4_N1 :: Dict (K.Div 'K.RoundAway (N 4) (N 1) ~ P 4)-_test_Div_RoundAway_N4_N1 =  Dict-_test_Rem_RoundAway_N4_N1 :: Dict (K.Rem 'K.RoundAway (N 4) (N 1) ~ P 0)-_test_Rem_RoundAway_N4_N1 =  Dict-_test_Div_RoundAway_N4_N2 :: Dict (K.Div 'K.RoundAway (N 4) (N 2) ~ P 2)-_test_Div_RoundAway_N4_N2 =  Dict-_test_Rem_RoundAway_N4_N2 :: Dict (K.Rem 'K.RoundAway (N 4) (N 2) ~ P 0)-_test_Rem_RoundAway_N4_N2 =  Dict-_test_Div_RoundAway_N4_N3 :: Dict (K.Div 'K.RoundAway (N 4) (N 3) ~ P 2)-_test_Div_RoundAway_N4_N3 =  Dict-_test_Rem_RoundAway_N4_N3 :: Dict (K.Rem 'K.RoundAway (N 4) (N 3) ~ P 2)-_test_Rem_RoundAway_N4_N3 =  Dict-_test_Div_RoundAway_N4_N4 :: Dict (K.Div 'K.RoundAway (N 4) (N 4) ~ P 1)-_test_Div_RoundAway_N4_N4 =  Dict-_test_Rem_RoundAway_N4_N4 :: Dict (K.Rem 'K.RoundAway (N 4) (N 4) ~ P 0)-_test_Rem_RoundAway_N4_N4 =  Dict-_test_Div_RoundAway_N4_P1 :: Dict (K.Div 'K.RoundAway (N 4) (P 1) ~ N 4)-_test_Div_RoundAway_N4_P1 =  Dict-_test_Rem_RoundAway_N4_P1 :: Dict (K.Rem 'K.RoundAway (N 4) (P 1) ~ P 0)-_test_Rem_RoundAway_N4_P1 =  Dict-_test_Div_RoundAway_N4_P2 :: Dict (K.Div 'K.RoundAway (N 4) (P 2) ~ N 2)-_test_Div_RoundAway_N4_P2 =  Dict-_test_Rem_RoundAway_N4_P2 :: Dict (K.Rem 'K.RoundAway (N 4) (P 2) ~ P 0)-_test_Rem_RoundAway_N4_P2 =  Dict-_test_Div_RoundAway_N4_P3 :: Dict (K.Div 'K.RoundAway (N 4) (P 3) ~ N 2)-_test_Div_RoundAway_N4_P3 =  Dict-_test_Rem_RoundAway_N4_P3 :: Dict (K.Rem 'K.RoundAway (N 4) (P 3) ~ P 2)-_test_Rem_RoundAway_N4_P3 =  Dict-_test_Div_RoundAway_N4_P4 :: Dict (K.Div 'K.RoundAway (N 4) (P 4) ~ N 1)-_test_Div_RoundAway_N4_P4 =  Dict-_test_Rem_RoundAway_N4_P4 :: Dict (K.Rem 'K.RoundAway (N 4) (P 4) ~ P 0)-_test_Rem_RoundAway_N4_P4 =  Dict-_test_Div_RoundAway_P0_N1 :: Dict (K.Div 'K.RoundAway (P 0) (N 1) ~ P 0)-_test_Div_RoundAway_P0_N1 =  Dict-_test_Rem_RoundAway_P0_N1 :: Dict (K.Rem 'K.RoundAway (P 0) (N 1) ~ P 0)-_test_Rem_RoundAway_P0_N1 =  Dict-_test_Div_RoundAway_P0_N2 :: Dict (K.Div 'K.RoundAway (P 0) (N 2) ~ P 0)-_test_Div_RoundAway_P0_N2 =  Dict-_test_Rem_RoundAway_P0_N2 :: Dict (K.Rem 'K.RoundAway (P 0) (N 2) ~ P 0)-_test_Rem_RoundAway_P0_N2 =  Dict-_test_Div_RoundAway_P0_N3 :: Dict (K.Div 'K.RoundAway (P 0) (N 3) ~ P 0)-_test_Div_RoundAway_P0_N3 =  Dict-_test_Rem_RoundAway_P0_N3 :: Dict (K.Rem 'K.RoundAway (P 0) (N 3) ~ P 0)-_test_Rem_RoundAway_P0_N3 =  Dict-_test_Div_RoundAway_P0_N4 :: Dict (K.Div 'K.RoundAway (P 0) (N 4) ~ P 0)-_test_Div_RoundAway_P0_N4 =  Dict-_test_Rem_RoundAway_P0_N4 :: Dict (K.Rem 'K.RoundAway (P 0) (N 4) ~ P 0)-_test_Rem_RoundAway_P0_N4 =  Dict-_test_Div_RoundAway_P0_P1 :: Dict (K.Div 'K.RoundAway (P 0) (P 1) ~ P 0)-_test_Div_RoundAway_P0_P1 =  Dict-_test_Rem_RoundAway_P0_P1 :: Dict (K.Rem 'K.RoundAway (P 0) (P 1) ~ P 0)-_test_Rem_RoundAway_P0_P1 =  Dict-_test_Div_RoundAway_P0_P2 :: Dict (K.Div 'K.RoundAway (P 0) (P 2) ~ P 0)-_test_Div_RoundAway_P0_P2 =  Dict-_test_Rem_RoundAway_P0_P2 :: Dict (K.Rem 'K.RoundAway (P 0) (P 2) ~ P 0)-_test_Rem_RoundAway_P0_P2 =  Dict-_test_Div_RoundAway_P0_P3 :: Dict (K.Div 'K.RoundAway (P 0) (P 3) ~ P 0)-_test_Div_RoundAway_P0_P3 =  Dict-_test_Rem_RoundAway_P0_P3 :: Dict (K.Rem 'K.RoundAway (P 0) (P 3) ~ P 0)-_test_Rem_RoundAway_P0_P3 =  Dict-_test_Div_RoundAway_P0_P4 :: Dict (K.Div 'K.RoundAway (P 0) (P 4) ~ P 0)-_test_Div_RoundAway_P0_P4 =  Dict-_test_Rem_RoundAway_P0_P4 :: Dict (K.Rem 'K.RoundAway (P 0) (P 4) ~ P 0)-_test_Rem_RoundAway_P0_P4 =  Dict-_test_Div_RoundAway_P1_N1 :: Dict (K.Div 'K.RoundAway (P 1) (N 1) ~ N 1)-_test_Div_RoundAway_P1_N1 =  Dict-_test_Rem_RoundAway_P1_N1 :: Dict (K.Rem 'K.RoundAway (P 1) (N 1) ~ P 0)-_test_Rem_RoundAway_P1_N1 =  Dict-_test_Div_RoundAway_P1_N2 :: Dict (K.Div 'K.RoundAway (P 1) (N 2) ~ N 1)-_test_Div_RoundAway_P1_N2 =  Dict-_test_Rem_RoundAway_P1_N2 :: Dict (K.Rem 'K.RoundAway (P 1) (N 2) ~ N 1)-_test_Rem_RoundAway_P1_N2 =  Dict-_test_Div_RoundAway_P1_N3 :: Dict (K.Div 'K.RoundAway (P 1) (N 3) ~ N 1)-_test_Div_RoundAway_P1_N3 =  Dict-_test_Rem_RoundAway_P1_N3 :: Dict (K.Rem 'K.RoundAway (P 1) (N 3) ~ N 2)-_test_Rem_RoundAway_P1_N3 =  Dict-_test_Div_RoundAway_P1_N4 :: Dict (K.Div 'K.RoundAway (P 1) (N 4) ~ N 1)-_test_Div_RoundAway_P1_N4 =  Dict-_test_Rem_RoundAway_P1_N4 :: Dict (K.Rem 'K.RoundAway (P 1) (N 4) ~ N 3)-_test_Rem_RoundAway_P1_N4 =  Dict-_test_Div_RoundAway_P1_P1 :: Dict (K.Div 'K.RoundAway (P 1) (P 1) ~ P 1)-_test_Div_RoundAway_P1_P1 =  Dict-_test_Rem_RoundAway_P1_P1 :: Dict (K.Rem 'K.RoundAway (P 1) (P 1) ~ P 0)-_test_Rem_RoundAway_P1_P1 =  Dict-_test_Div_RoundAway_P1_P2 :: Dict (K.Div 'K.RoundAway (P 1) (P 2) ~ P 1)-_test_Div_RoundAway_P1_P2 =  Dict-_test_Rem_RoundAway_P1_P2 :: Dict (K.Rem 'K.RoundAway (P 1) (P 2) ~ N 1)-_test_Rem_RoundAway_P1_P2 =  Dict-_test_Div_RoundAway_P1_P3 :: Dict (K.Div 'K.RoundAway (P 1) (P 3) ~ P 1)-_test_Div_RoundAway_P1_P3 =  Dict-_test_Rem_RoundAway_P1_P3 :: Dict (K.Rem 'K.RoundAway (P 1) (P 3) ~ N 2)-_test_Rem_RoundAway_P1_P3 =  Dict-_test_Div_RoundAway_P1_P4 :: Dict (K.Div 'K.RoundAway (P 1) (P 4) ~ P 1)-_test_Div_RoundAway_P1_P4 =  Dict-_test_Rem_RoundAway_P1_P4 :: Dict (K.Rem 'K.RoundAway (P 1) (P 4) ~ N 3)-_test_Rem_RoundAway_P1_P4 =  Dict-_test_Div_RoundAway_P2_N1 :: Dict (K.Div 'K.RoundAway (P 2) (N 1) ~ N 2)-_test_Div_RoundAway_P2_N1 =  Dict-_test_Rem_RoundAway_P2_N1 :: Dict (K.Rem 'K.RoundAway (P 2) (N 1) ~ P 0)-_test_Rem_RoundAway_P2_N1 =  Dict-_test_Div_RoundAway_P2_N2 :: Dict (K.Div 'K.RoundAway (P 2) (N 2) ~ N 1)-_test_Div_RoundAway_P2_N2 =  Dict-_test_Rem_RoundAway_P2_N2 :: Dict (K.Rem 'K.RoundAway (P 2) (N 2) ~ P 0)-_test_Rem_RoundAway_P2_N2 =  Dict-_test_Div_RoundAway_P2_N3 :: Dict (K.Div 'K.RoundAway (P 2) (N 3) ~ N 1)-_test_Div_RoundAway_P2_N3 =  Dict-_test_Rem_RoundAway_P2_N3 :: Dict (K.Rem 'K.RoundAway (P 2) (N 3) ~ N 1)-_test_Rem_RoundAway_P2_N3 =  Dict-_test_Div_RoundAway_P2_N4 :: Dict (K.Div 'K.RoundAway (P 2) (N 4) ~ N 1)-_test_Div_RoundAway_P2_N4 =  Dict-_test_Rem_RoundAway_P2_N4 :: Dict (K.Rem 'K.RoundAway (P 2) (N 4) ~ N 2)-_test_Rem_RoundAway_P2_N4 =  Dict-_test_Div_RoundAway_P2_P1 :: Dict (K.Div 'K.RoundAway (P 2) (P 1) ~ P 2)-_test_Div_RoundAway_P2_P1 =  Dict-_test_Rem_RoundAway_P2_P1 :: Dict (K.Rem 'K.RoundAway (P 2) (P 1) ~ P 0)-_test_Rem_RoundAway_P2_P1 =  Dict-_test_Div_RoundAway_P2_P2 :: Dict (K.Div 'K.RoundAway (P 2) (P 2) ~ P 1)-_test_Div_RoundAway_P2_P2 =  Dict-_test_Rem_RoundAway_P2_P2 :: Dict (K.Rem 'K.RoundAway (P 2) (P 2) ~ P 0)-_test_Rem_RoundAway_P2_P2 =  Dict-_test_Div_RoundAway_P2_P3 :: Dict (K.Div 'K.RoundAway (P 2) (P 3) ~ P 1)-_test_Div_RoundAway_P2_P3 =  Dict-_test_Rem_RoundAway_P2_P3 :: Dict (K.Rem 'K.RoundAway (P 2) (P 3) ~ N 1)-_test_Rem_RoundAway_P2_P3 =  Dict-_test_Div_RoundAway_P2_P4 :: Dict (K.Div 'K.RoundAway (P 2) (P 4) ~ P 1)-_test_Div_RoundAway_P2_P4 =  Dict-_test_Rem_RoundAway_P2_P4 :: Dict (K.Rem 'K.RoundAway (P 2) (P 4) ~ N 2)-_test_Rem_RoundAway_P2_P4 =  Dict-_test_Div_RoundAway_P3_N1 :: Dict (K.Div 'K.RoundAway (P 3) (N 1) ~ N 3)-_test_Div_RoundAway_P3_N1 =  Dict-_test_Rem_RoundAway_P3_N1 :: Dict (K.Rem 'K.RoundAway (P 3) (N 1) ~ P 0)-_test_Rem_RoundAway_P3_N1 =  Dict-_test_Div_RoundAway_P3_N2 :: Dict (K.Div 'K.RoundAway (P 3) (N 2) ~ N 2)-_test_Div_RoundAway_P3_N2 =  Dict-_test_Rem_RoundAway_P3_N2 :: Dict (K.Rem 'K.RoundAway (P 3) (N 2) ~ N 1)-_test_Rem_RoundAway_P3_N2 =  Dict-_test_Div_RoundAway_P3_N3 :: Dict (K.Div 'K.RoundAway (P 3) (N 3) ~ N 1)-_test_Div_RoundAway_P3_N3 =  Dict-_test_Rem_RoundAway_P3_N3 :: Dict (K.Rem 'K.RoundAway (P 3) (N 3) ~ P 0)-_test_Rem_RoundAway_P3_N3 =  Dict-_test_Div_RoundAway_P3_N4 :: Dict (K.Div 'K.RoundAway (P 3) (N 4) ~ N 1)-_test_Div_RoundAway_P3_N4 =  Dict-_test_Rem_RoundAway_P3_N4 :: Dict (K.Rem 'K.RoundAway (P 3) (N 4) ~ N 1)-_test_Rem_RoundAway_P3_N4 =  Dict-_test_Div_RoundAway_P3_P1 :: Dict (K.Div 'K.RoundAway (P 3) (P 1) ~ P 3)-_test_Div_RoundAway_P3_P1 =  Dict-_test_Rem_RoundAway_P3_P1 :: Dict (K.Rem 'K.RoundAway (P 3) (P 1) ~ P 0)-_test_Rem_RoundAway_P3_P1 =  Dict-_test_Div_RoundAway_P3_P2 :: Dict (K.Div 'K.RoundAway (P 3) (P 2) ~ P 2)-_test_Div_RoundAway_P3_P2 =  Dict-_test_Rem_RoundAway_P3_P2 :: Dict (K.Rem 'K.RoundAway (P 3) (P 2) ~ N 1)-_test_Rem_RoundAway_P3_P2 =  Dict-_test_Div_RoundAway_P3_P3 :: Dict (K.Div 'K.RoundAway (P 3) (P 3) ~ P 1)-_test_Div_RoundAway_P3_P3 =  Dict-_test_Rem_RoundAway_P3_P3 :: Dict (K.Rem 'K.RoundAway (P 3) (P 3) ~ P 0)-_test_Rem_RoundAway_P3_P3 =  Dict-_test_Div_RoundAway_P3_P4 :: Dict (K.Div 'K.RoundAway (P 3) (P 4) ~ P 1)-_test_Div_RoundAway_P3_P4 =  Dict-_test_Rem_RoundAway_P3_P4 :: Dict (K.Rem 'K.RoundAway (P 3) (P 4) ~ N 1)-_test_Rem_RoundAway_P3_P4 =  Dict-_test_Div_RoundAway_P4_N1 :: Dict (K.Div 'K.RoundAway (P 4) (N 1) ~ N 4)-_test_Div_RoundAway_P4_N1 =  Dict-_test_Rem_RoundAway_P4_N1 :: Dict (K.Rem 'K.RoundAway (P 4) (N 1) ~ P 0)-_test_Rem_RoundAway_P4_N1 =  Dict-_test_Div_RoundAway_P4_N2 :: Dict (K.Div 'K.RoundAway (P 4) (N 2) ~ N 2)-_test_Div_RoundAway_P4_N2 =  Dict-_test_Rem_RoundAway_P4_N2 :: Dict (K.Rem 'K.RoundAway (P 4) (N 2) ~ P 0)-_test_Rem_RoundAway_P4_N2 =  Dict-_test_Div_RoundAway_P4_N3 :: Dict (K.Div 'K.RoundAway (P 4) (N 3) ~ N 2)-_test_Div_RoundAway_P4_N3 =  Dict-_test_Rem_RoundAway_P4_N3 :: Dict (K.Rem 'K.RoundAway (P 4) (N 3) ~ N 2)-_test_Rem_RoundAway_P4_N3 =  Dict-_test_Div_RoundAway_P4_N4 :: Dict (K.Div 'K.RoundAway (P 4) (N 4) ~ N 1)-_test_Div_RoundAway_P4_N4 =  Dict-_test_Rem_RoundAway_P4_N4 :: Dict (K.Rem 'K.RoundAway (P 4) (N 4) ~ P 0)-_test_Rem_RoundAway_P4_N4 =  Dict-_test_Div_RoundAway_P4_P1 :: Dict (K.Div 'K.RoundAway (P 4) (P 1) ~ P 4)-_test_Div_RoundAway_P4_P1 =  Dict-_test_Rem_RoundAway_P4_P1 :: Dict (K.Rem 'K.RoundAway (P 4) (P 1) ~ P 0)-_test_Rem_RoundAway_P4_P1 =  Dict-_test_Div_RoundAway_P4_P2 :: Dict (K.Div 'K.RoundAway (P 4) (P 2) ~ P 2)-_test_Div_RoundAway_P4_P2 =  Dict-_test_Rem_RoundAway_P4_P2 :: Dict (K.Rem 'K.RoundAway (P 4) (P 2) ~ P 0)-_test_Rem_RoundAway_P4_P2 =  Dict-_test_Div_RoundAway_P4_P3 :: Dict (K.Div 'K.RoundAway (P 4) (P 3) ~ P 2)-_test_Div_RoundAway_P4_P3 =  Dict-_test_Rem_RoundAway_P4_P3 :: Dict (K.Rem 'K.RoundAway (P 4) (P 3) ~ N 2)-_test_Rem_RoundAway_P4_P3 =  Dict-_test_Div_RoundAway_P4_P4 :: Dict (K.Div 'K.RoundAway (P 4) (P 4) ~ P 1)-_test_Div_RoundAway_P4_P4 =  Dict-_test_Rem_RoundAway_P4_P4 :: Dict (K.Rem 'K.RoundAway (P 4) (P 4) ~ P 0)-_test_Rem_RoundAway_P4_P4 =  Dict-_test_Div_RoundDown_N1_N1 :: Dict (K.Div 'K.RoundDown (N 1) (N 1) ~ P 1)-_test_Div_RoundDown_N1_N1 =  Dict-_test_Rem_RoundDown_N1_N1 :: Dict (K.Rem 'K.RoundDown (N 1) (N 1) ~ P 0)-_test_Rem_RoundDown_N1_N1 =  Dict-_test_Div_RoundDown_N1_N2 :: Dict (K.Div 'K.RoundDown (N 1) (N 2) ~ P 0)-_test_Div_RoundDown_N1_N2 =  Dict-_test_Rem_RoundDown_N1_N2 :: Dict (K.Rem 'K.RoundDown (N 1) (N 2) ~ N 1)-_test_Rem_RoundDown_N1_N2 =  Dict-_test_Div_RoundDown_N1_N3 :: Dict (K.Div 'K.RoundDown (N 1) (N 3) ~ P 0)-_test_Div_RoundDown_N1_N3 =  Dict-_test_Rem_RoundDown_N1_N3 :: Dict (K.Rem 'K.RoundDown (N 1) (N 3) ~ N 1)-_test_Rem_RoundDown_N1_N3 =  Dict-_test_Div_RoundDown_N1_N4 :: Dict (K.Div 'K.RoundDown (N 1) (N 4) ~ P 0)-_test_Div_RoundDown_N1_N4 =  Dict-_test_Rem_RoundDown_N1_N4 :: Dict (K.Rem 'K.RoundDown (N 1) (N 4) ~ N 1)-_test_Rem_RoundDown_N1_N4 =  Dict-_test_Div_RoundDown_N1_P1 :: Dict (K.Div 'K.RoundDown (N 1) (P 1) ~ N 1)-_test_Div_RoundDown_N1_P1 =  Dict-_test_Rem_RoundDown_N1_P1 :: Dict (K.Rem 'K.RoundDown (N 1) (P 1) ~ P 0)-_test_Rem_RoundDown_N1_P1 =  Dict-_test_Div_RoundDown_N1_P2 :: Dict (K.Div 'K.RoundDown (N 1) (P 2) ~ N 1)-_test_Div_RoundDown_N1_P2 =  Dict-_test_Rem_RoundDown_N1_P2 :: Dict (K.Rem 'K.RoundDown (N 1) (P 2) ~ P 1)-_test_Rem_RoundDown_N1_P2 =  Dict-_test_Div_RoundDown_N1_P3 :: Dict (K.Div 'K.RoundDown (N 1) (P 3) ~ N 1)-_test_Div_RoundDown_N1_P3 =  Dict-_test_Rem_RoundDown_N1_P3 :: Dict (K.Rem 'K.RoundDown (N 1) (P 3) ~ P 2)-_test_Rem_RoundDown_N1_P3 =  Dict-_test_Div_RoundDown_N1_P4 :: Dict (K.Div 'K.RoundDown (N 1) (P 4) ~ N 1)-_test_Div_RoundDown_N1_P4 =  Dict-_test_Rem_RoundDown_N1_P4 :: Dict (K.Rem 'K.RoundDown (N 1) (P 4) ~ P 3)-_test_Rem_RoundDown_N1_P4 =  Dict-_test_Div_RoundDown_N2_N1 :: Dict (K.Div 'K.RoundDown (N 2) (N 1) ~ P 2)-_test_Div_RoundDown_N2_N1 =  Dict-_test_Rem_RoundDown_N2_N1 :: Dict (K.Rem 'K.RoundDown (N 2) (N 1) ~ P 0)-_test_Rem_RoundDown_N2_N1 =  Dict-_test_Div_RoundDown_N2_N2 :: Dict (K.Div 'K.RoundDown (N 2) (N 2) ~ P 1)-_test_Div_RoundDown_N2_N2 =  Dict-_test_Rem_RoundDown_N2_N2 :: Dict (K.Rem 'K.RoundDown (N 2) (N 2) ~ P 0)-_test_Rem_RoundDown_N2_N2 =  Dict-_test_Div_RoundDown_N2_N3 :: Dict (K.Div 'K.RoundDown (N 2) (N 3) ~ P 0)-_test_Div_RoundDown_N2_N3 =  Dict-_test_Rem_RoundDown_N2_N3 :: Dict (K.Rem 'K.RoundDown (N 2) (N 3) ~ N 2)-_test_Rem_RoundDown_N2_N3 =  Dict-_test_Div_RoundDown_N2_N4 :: Dict (K.Div 'K.RoundDown (N 2) (N 4) ~ P 0)-_test_Div_RoundDown_N2_N4 =  Dict-_test_Rem_RoundDown_N2_N4 :: Dict (K.Rem 'K.RoundDown (N 2) (N 4) ~ N 2)-_test_Rem_RoundDown_N2_N4 =  Dict-_test_Div_RoundDown_N2_P1 :: Dict (K.Div 'K.RoundDown (N 2) (P 1) ~ N 2)-_test_Div_RoundDown_N2_P1 =  Dict-_test_Rem_RoundDown_N2_P1 :: Dict (K.Rem 'K.RoundDown (N 2) (P 1) ~ P 0)-_test_Rem_RoundDown_N2_P1 =  Dict-_test_Div_RoundDown_N2_P2 :: Dict (K.Div 'K.RoundDown (N 2) (P 2) ~ N 1)-_test_Div_RoundDown_N2_P2 =  Dict-_test_Rem_RoundDown_N2_P2 :: Dict (K.Rem 'K.RoundDown (N 2) (P 2) ~ P 0)-_test_Rem_RoundDown_N2_P2 =  Dict-_test_Div_RoundDown_N2_P3 :: Dict (K.Div 'K.RoundDown (N 2) (P 3) ~ N 1)-_test_Div_RoundDown_N2_P3 =  Dict-_test_Rem_RoundDown_N2_P3 :: Dict (K.Rem 'K.RoundDown (N 2) (P 3) ~ P 1)-_test_Rem_RoundDown_N2_P3 =  Dict-_test_Div_RoundDown_N2_P4 :: Dict (K.Div 'K.RoundDown (N 2) (P 4) ~ N 1)-_test_Div_RoundDown_N2_P4 =  Dict-_test_Rem_RoundDown_N2_P4 :: Dict (K.Rem 'K.RoundDown (N 2) (P 4) ~ P 2)-_test_Rem_RoundDown_N2_P4 =  Dict-_test_Div_RoundDown_N3_N1 :: Dict (K.Div 'K.RoundDown (N 3) (N 1) ~ P 3)-_test_Div_RoundDown_N3_N1 =  Dict-_test_Rem_RoundDown_N3_N1 :: Dict (K.Rem 'K.RoundDown (N 3) (N 1) ~ P 0)-_test_Rem_RoundDown_N3_N1 =  Dict-_test_Div_RoundDown_N3_N2 :: Dict (K.Div 'K.RoundDown (N 3) (N 2) ~ P 1)-_test_Div_RoundDown_N3_N2 =  Dict-_test_Rem_RoundDown_N3_N2 :: Dict (K.Rem 'K.RoundDown (N 3) (N 2) ~ N 1)-_test_Rem_RoundDown_N3_N2 =  Dict-_test_Div_RoundDown_N3_N3 :: Dict (K.Div 'K.RoundDown (N 3) (N 3) ~ P 1)-_test_Div_RoundDown_N3_N3 =  Dict-_test_Rem_RoundDown_N3_N3 :: Dict (K.Rem 'K.RoundDown (N 3) (N 3) ~ P 0)-_test_Rem_RoundDown_N3_N3 =  Dict-_test_Div_RoundDown_N3_N4 :: Dict (K.Div 'K.RoundDown (N 3) (N 4) ~ P 0)-_test_Div_RoundDown_N3_N4 =  Dict-_test_Rem_RoundDown_N3_N4 :: Dict (K.Rem 'K.RoundDown (N 3) (N 4) ~ N 3)-_test_Rem_RoundDown_N3_N4 =  Dict-_test_Div_RoundDown_N3_P1 :: Dict (K.Div 'K.RoundDown (N 3) (P 1) ~ N 3)-_test_Div_RoundDown_N3_P1 =  Dict-_test_Rem_RoundDown_N3_P1 :: Dict (K.Rem 'K.RoundDown (N 3) (P 1) ~ P 0)-_test_Rem_RoundDown_N3_P1 =  Dict-_test_Div_RoundDown_N3_P2 :: Dict (K.Div 'K.RoundDown (N 3) (P 2) ~ N 2)-_test_Div_RoundDown_N3_P2 =  Dict-_test_Rem_RoundDown_N3_P2 :: Dict (K.Rem 'K.RoundDown (N 3) (P 2) ~ P 1)-_test_Rem_RoundDown_N3_P2 =  Dict-_test_Div_RoundDown_N3_P3 :: Dict (K.Div 'K.RoundDown (N 3) (P 3) ~ N 1)-_test_Div_RoundDown_N3_P3 =  Dict-_test_Rem_RoundDown_N3_P3 :: Dict (K.Rem 'K.RoundDown (N 3) (P 3) ~ P 0)-_test_Rem_RoundDown_N3_P3 =  Dict-_test_Div_RoundDown_N3_P4 :: Dict (K.Div 'K.RoundDown (N 3) (P 4) ~ N 1)-_test_Div_RoundDown_N3_P4 =  Dict-_test_Rem_RoundDown_N3_P4 :: Dict (K.Rem 'K.RoundDown (N 3) (P 4) ~ P 1)-_test_Rem_RoundDown_N3_P4 =  Dict-_test_Div_RoundDown_N4_N1 :: Dict (K.Div 'K.RoundDown (N 4) (N 1) ~ P 4)-_test_Div_RoundDown_N4_N1 =  Dict-_test_Rem_RoundDown_N4_N1 :: Dict (K.Rem 'K.RoundDown (N 4) (N 1) ~ P 0)-_test_Rem_RoundDown_N4_N1 =  Dict-_test_Div_RoundDown_N4_N2 :: Dict (K.Div 'K.RoundDown (N 4) (N 2) ~ P 2)-_test_Div_RoundDown_N4_N2 =  Dict-_test_Rem_RoundDown_N4_N2 :: Dict (K.Rem 'K.RoundDown (N 4) (N 2) ~ P 0)-_test_Rem_RoundDown_N4_N2 =  Dict-_test_Div_RoundDown_N4_N3 :: Dict (K.Div 'K.RoundDown (N 4) (N 3) ~ P 1)-_test_Div_RoundDown_N4_N3 =  Dict-_test_Rem_RoundDown_N4_N3 :: Dict (K.Rem 'K.RoundDown (N 4) (N 3) ~ N 1)-_test_Rem_RoundDown_N4_N3 =  Dict-_test_Div_RoundDown_N4_N4 :: Dict (K.Div 'K.RoundDown (N 4) (N 4) ~ P 1)-_test_Div_RoundDown_N4_N4 =  Dict-_test_Rem_RoundDown_N4_N4 :: Dict (K.Rem 'K.RoundDown (N 4) (N 4) ~ P 0)-_test_Rem_RoundDown_N4_N4 =  Dict-_test_Div_RoundDown_N4_P1 :: Dict (K.Div 'K.RoundDown (N 4) (P 1) ~ N 4)-_test_Div_RoundDown_N4_P1 =  Dict-_test_Rem_RoundDown_N4_P1 :: Dict (K.Rem 'K.RoundDown (N 4) (P 1) ~ P 0)-_test_Rem_RoundDown_N4_P1 =  Dict-_test_Div_RoundDown_N4_P2 :: Dict (K.Div 'K.RoundDown (N 4) (P 2) ~ N 2)-_test_Div_RoundDown_N4_P2 =  Dict-_test_Rem_RoundDown_N4_P2 :: Dict (K.Rem 'K.RoundDown (N 4) (P 2) ~ P 0)-_test_Rem_RoundDown_N4_P2 =  Dict-_test_Div_RoundDown_N4_P3 :: Dict (K.Div 'K.RoundDown (N 4) (P 3) ~ N 2)-_test_Div_RoundDown_N4_P3 =  Dict-_test_Rem_RoundDown_N4_P3 :: Dict (K.Rem 'K.RoundDown (N 4) (P 3) ~ P 2)-_test_Rem_RoundDown_N4_P3 =  Dict-_test_Div_RoundDown_N4_P4 :: Dict (K.Div 'K.RoundDown (N 4) (P 4) ~ N 1)-_test_Div_RoundDown_N4_P4 =  Dict-_test_Rem_RoundDown_N4_P4 :: Dict (K.Rem 'K.RoundDown (N 4) (P 4) ~ P 0)-_test_Rem_RoundDown_N4_P4 =  Dict-_test_Div_RoundDown_P0_N1 :: Dict (K.Div 'K.RoundDown (P 0) (N 1) ~ P 0)-_test_Div_RoundDown_P0_N1 =  Dict-_test_Rem_RoundDown_P0_N1 :: Dict (K.Rem 'K.RoundDown (P 0) (N 1) ~ P 0)-_test_Rem_RoundDown_P0_N1 =  Dict-_test_Div_RoundDown_P0_N2 :: Dict (K.Div 'K.RoundDown (P 0) (N 2) ~ P 0)-_test_Div_RoundDown_P0_N2 =  Dict-_test_Rem_RoundDown_P0_N2 :: Dict (K.Rem 'K.RoundDown (P 0) (N 2) ~ P 0)-_test_Rem_RoundDown_P0_N2 =  Dict-_test_Div_RoundDown_P0_N3 :: Dict (K.Div 'K.RoundDown (P 0) (N 3) ~ P 0)-_test_Div_RoundDown_P0_N3 =  Dict-_test_Rem_RoundDown_P0_N3 :: Dict (K.Rem 'K.RoundDown (P 0) (N 3) ~ P 0)-_test_Rem_RoundDown_P0_N3 =  Dict-_test_Div_RoundDown_P0_N4 :: Dict (K.Div 'K.RoundDown (P 0) (N 4) ~ P 0)-_test_Div_RoundDown_P0_N4 =  Dict-_test_Rem_RoundDown_P0_N4 :: Dict (K.Rem 'K.RoundDown (P 0) (N 4) ~ P 0)-_test_Rem_RoundDown_P0_N4 =  Dict-_test_Div_RoundDown_P0_P1 :: Dict (K.Div 'K.RoundDown (P 0) (P 1) ~ P 0)-_test_Div_RoundDown_P0_P1 =  Dict-_test_Rem_RoundDown_P0_P1 :: Dict (K.Rem 'K.RoundDown (P 0) (P 1) ~ P 0)-_test_Rem_RoundDown_P0_P1 =  Dict-_test_Div_RoundDown_P0_P2 :: Dict (K.Div 'K.RoundDown (P 0) (P 2) ~ P 0)-_test_Div_RoundDown_P0_P2 =  Dict-_test_Rem_RoundDown_P0_P2 :: Dict (K.Rem 'K.RoundDown (P 0) (P 2) ~ P 0)-_test_Rem_RoundDown_P0_P2 =  Dict-_test_Div_RoundDown_P0_P3 :: Dict (K.Div 'K.RoundDown (P 0) (P 3) ~ P 0)-_test_Div_RoundDown_P0_P3 =  Dict-_test_Rem_RoundDown_P0_P3 :: Dict (K.Rem 'K.RoundDown (P 0) (P 3) ~ P 0)-_test_Rem_RoundDown_P0_P3 =  Dict-_test_Div_RoundDown_P0_P4 :: Dict (K.Div 'K.RoundDown (P 0) (P 4) ~ P 0)-_test_Div_RoundDown_P0_P4 =  Dict-_test_Rem_RoundDown_P0_P4 :: Dict (K.Rem 'K.RoundDown (P 0) (P 4) ~ P 0)-_test_Rem_RoundDown_P0_P4 =  Dict-_test_Div_RoundDown_P1_N1 :: Dict (K.Div 'K.RoundDown (P 1) (N 1) ~ N 1)-_test_Div_RoundDown_P1_N1 =  Dict-_test_Rem_RoundDown_P1_N1 :: Dict (K.Rem 'K.RoundDown (P 1) (N 1) ~ P 0)-_test_Rem_RoundDown_P1_N1 =  Dict-_test_Div_RoundDown_P1_N2 :: Dict (K.Div 'K.RoundDown (P 1) (N 2) ~ N 1)-_test_Div_RoundDown_P1_N2 =  Dict-_test_Rem_RoundDown_P1_N2 :: Dict (K.Rem 'K.RoundDown (P 1) (N 2) ~ N 1)-_test_Rem_RoundDown_P1_N2 =  Dict-_test_Div_RoundDown_P1_N3 :: Dict (K.Div 'K.RoundDown (P 1) (N 3) ~ N 1)-_test_Div_RoundDown_P1_N3 =  Dict-_test_Rem_RoundDown_P1_N3 :: Dict (K.Rem 'K.RoundDown (P 1) (N 3) ~ N 2)-_test_Rem_RoundDown_P1_N3 =  Dict-_test_Div_RoundDown_P1_N4 :: Dict (K.Div 'K.RoundDown (P 1) (N 4) ~ N 1)-_test_Div_RoundDown_P1_N4 =  Dict-_test_Rem_RoundDown_P1_N4 :: Dict (K.Rem 'K.RoundDown (P 1) (N 4) ~ N 3)-_test_Rem_RoundDown_P1_N4 =  Dict-_test_Div_RoundDown_P1_P1 :: Dict (K.Div 'K.RoundDown (P 1) (P 1) ~ P 1)-_test_Div_RoundDown_P1_P1 =  Dict-_test_Rem_RoundDown_P1_P1 :: Dict (K.Rem 'K.RoundDown (P 1) (P 1) ~ P 0)-_test_Rem_RoundDown_P1_P1 =  Dict-_test_Div_RoundDown_P1_P2 :: Dict (K.Div 'K.RoundDown (P 1) (P 2) ~ P 0)-_test_Div_RoundDown_P1_P2 =  Dict-_test_Rem_RoundDown_P1_P2 :: Dict (K.Rem 'K.RoundDown (P 1) (P 2) ~ P 1)-_test_Rem_RoundDown_P1_P2 =  Dict-_test_Div_RoundDown_P1_P3 :: Dict (K.Div 'K.RoundDown (P 1) (P 3) ~ P 0)-_test_Div_RoundDown_P1_P3 =  Dict-_test_Rem_RoundDown_P1_P3 :: Dict (K.Rem 'K.RoundDown (P 1) (P 3) ~ P 1)-_test_Rem_RoundDown_P1_P3 =  Dict-_test_Div_RoundDown_P1_P4 :: Dict (K.Div 'K.RoundDown (P 1) (P 4) ~ P 0)-_test_Div_RoundDown_P1_P4 =  Dict-_test_Rem_RoundDown_P1_P4 :: Dict (K.Rem 'K.RoundDown (P 1) (P 4) ~ P 1)-_test_Rem_RoundDown_P1_P4 =  Dict-_test_Div_RoundDown_P2_N1 :: Dict (K.Div 'K.RoundDown (P 2) (N 1) ~ N 2)-_test_Div_RoundDown_P2_N1 =  Dict-_test_Rem_RoundDown_P2_N1 :: Dict (K.Rem 'K.RoundDown (P 2) (N 1) ~ P 0)-_test_Rem_RoundDown_P2_N1 =  Dict-_test_Div_RoundDown_P2_N2 :: Dict (K.Div 'K.RoundDown (P 2) (N 2) ~ N 1)-_test_Div_RoundDown_P2_N2 =  Dict-_test_Rem_RoundDown_P2_N2 :: Dict (K.Rem 'K.RoundDown (P 2) (N 2) ~ P 0)-_test_Rem_RoundDown_P2_N2 =  Dict-_test_Div_RoundDown_P2_N3 :: Dict (K.Div 'K.RoundDown (P 2) (N 3) ~ N 1)-_test_Div_RoundDown_P2_N3 =  Dict-_test_Rem_RoundDown_P2_N3 :: Dict (K.Rem 'K.RoundDown (P 2) (N 3) ~ N 1)-_test_Rem_RoundDown_P2_N3 =  Dict-_test_Div_RoundDown_P2_N4 :: Dict (K.Div 'K.RoundDown (P 2) (N 4) ~ N 1)-_test_Div_RoundDown_P2_N4 =  Dict-_test_Rem_RoundDown_P2_N4 :: Dict (K.Rem 'K.RoundDown (P 2) (N 4) ~ N 2)-_test_Rem_RoundDown_P2_N4 =  Dict-_test_Div_RoundDown_P2_P1 :: Dict (K.Div 'K.RoundDown (P 2) (P 1) ~ P 2)-_test_Div_RoundDown_P2_P1 =  Dict-_test_Rem_RoundDown_P2_P1 :: Dict (K.Rem 'K.RoundDown (P 2) (P 1) ~ P 0)-_test_Rem_RoundDown_P2_P1 =  Dict-_test_Div_RoundDown_P2_P2 :: Dict (K.Div 'K.RoundDown (P 2) (P 2) ~ P 1)-_test_Div_RoundDown_P2_P2 =  Dict-_test_Rem_RoundDown_P2_P2 :: Dict (K.Rem 'K.RoundDown (P 2) (P 2) ~ P 0)-_test_Rem_RoundDown_P2_P2 =  Dict-_test_Div_RoundDown_P2_P3 :: Dict (K.Div 'K.RoundDown (P 2) (P 3) ~ P 0)-_test_Div_RoundDown_P2_P3 =  Dict-_test_Rem_RoundDown_P2_P3 :: Dict (K.Rem 'K.RoundDown (P 2) (P 3) ~ P 2)-_test_Rem_RoundDown_P2_P3 =  Dict-_test_Div_RoundDown_P2_P4 :: Dict (K.Div 'K.RoundDown (P 2) (P 4) ~ P 0)-_test_Div_RoundDown_P2_P4 =  Dict-_test_Rem_RoundDown_P2_P4 :: Dict (K.Rem 'K.RoundDown (P 2) (P 4) ~ P 2)-_test_Rem_RoundDown_P2_P4 =  Dict-_test_Div_RoundDown_P3_N1 :: Dict (K.Div 'K.RoundDown (P 3) (N 1) ~ N 3)-_test_Div_RoundDown_P3_N1 =  Dict-_test_Rem_RoundDown_P3_N1 :: Dict (K.Rem 'K.RoundDown (P 3) (N 1) ~ P 0)-_test_Rem_RoundDown_P3_N1 =  Dict-_test_Div_RoundDown_P3_N2 :: Dict (K.Div 'K.RoundDown (P 3) (N 2) ~ N 2)-_test_Div_RoundDown_P3_N2 =  Dict-_test_Rem_RoundDown_P3_N2 :: Dict (K.Rem 'K.RoundDown (P 3) (N 2) ~ N 1)-_test_Rem_RoundDown_P3_N2 =  Dict-_test_Div_RoundDown_P3_N3 :: Dict (K.Div 'K.RoundDown (P 3) (N 3) ~ N 1)-_test_Div_RoundDown_P3_N3 =  Dict-_test_Rem_RoundDown_P3_N3 :: Dict (K.Rem 'K.RoundDown (P 3) (N 3) ~ P 0)-_test_Rem_RoundDown_P3_N3 =  Dict-_test_Div_RoundDown_P3_N4 :: Dict (K.Div 'K.RoundDown (P 3) (N 4) ~ N 1)-_test_Div_RoundDown_P3_N4 =  Dict-_test_Rem_RoundDown_P3_N4 :: Dict (K.Rem 'K.RoundDown (P 3) (N 4) ~ N 1)-_test_Rem_RoundDown_P3_N4 =  Dict-_test_Div_RoundDown_P3_P1 :: Dict (K.Div 'K.RoundDown (P 3) (P 1) ~ P 3)-_test_Div_RoundDown_P3_P1 =  Dict-_test_Rem_RoundDown_P3_P1 :: Dict (K.Rem 'K.RoundDown (P 3) (P 1) ~ P 0)-_test_Rem_RoundDown_P3_P1 =  Dict-_test_Div_RoundDown_P3_P2 :: Dict (K.Div 'K.RoundDown (P 3) (P 2) ~ P 1)-_test_Div_RoundDown_P3_P2 =  Dict-_test_Rem_RoundDown_P3_P2 :: Dict (K.Rem 'K.RoundDown (P 3) (P 2) ~ P 1)-_test_Rem_RoundDown_P3_P2 =  Dict-_test_Div_RoundDown_P3_P3 :: Dict (K.Div 'K.RoundDown (P 3) (P 3) ~ P 1)-_test_Div_RoundDown_P3_P3 =  Dict-_test_Rem_RoundDown_P3_P3 :: Dict (K.Rem 'K.RoundDown (P 3) (P 3) ~ P 0)-_test_Rem_RoundDown_P3_P3 =  Dict-_test_Div_RoundDown_P3_P4 :: Dict (K.Div 'K.RoundDown (P 3) (P 4) ~ P 0)-_test_Div_RoundDown_P3_P4 =  Dict-_test_Rem_RoundDown_P3_P4 :: Dict (K.Rem 'K.RoundDown (P 3) (P 4) ~ P 3)-_test_Rem_RoundDown_P3_P4 =  Dict-_test_Div_RoundDown_P4_N1 :: Dict (K.Div 'K.RoundDown (P 4) (N 1) ~ N 4)-_test_Div_RoundDown_P4_N1 =  Dict-_test_Rem_RoundDown_P4_N1 :: Dict (K.Rem 'K.RoundDown (P 4) (N 1) ~ P 0)-_test_Rem_RoundDown_P4_N1 =  Dict-_test_Div_RoundDown_P4_N2 :: Dict (K.Div 'K.RoundDown (P 4) (N 2) ~ N 2)-_test_Div_RoundDown_P4_N2 =  Dict-_test_Rem_RoundDown_P4_N2 :: Dict (K.Rem 'K.RoundDown (P 4) (N 2) ~ P 0)-_test_Rem_RoundDown_P4_N2 =  Dict-_test_Div_RoundDown_P4_N3 :: Dict (K.Div 'K.RoundDown (P 4) (N 3) ~ N 2)-_test_Div_RoundDown_P4_N3 =  Dict-_test_Rem_RoundDown_P4_N3 :: Dict (K.Rem 'K.RoundDown (P 4) (N 3) ~ N 2)-_test_Rem_RoundDown_P4_N3 =  Dict-_test_Div_RoundDown_P4_N4 :: Dict (K.Div 'K.RoundDown (P 4) (N 4) ~ N 1)-_test_Div_RoundDown_P4_N4 =  Dict-_test_Rem_RoundDown_P4_N4 :: Dict (K.Rem 'K.RoundDown (P 4) (N 4) ~ P 0)-_test_Rem_RoundDown_P4_N4 =  Dict-_test_Div_RoundDown_P4_P1 :: Dict (K.Div 'K.RoundDown (P 4) (P 1) ~ P 4)-_test_Div_RoundDown_P4_P1 =  Dict-_test_Rem_RoundDown_P4_P1 :: Dict (K.Rem 'K.RoundDown (P 4) (P 1) ~ P 0)-_test_Rem_RoundDown_P4_P1 =  Dict-_test_Div_RoundDown_P4_P2 :: Dict (K.Div 'K.RoundDown (P 4) (P 2) ~ P 2)-_test_Div_RoundDown_P4_P2 =  Dict-_test_Rem_RoundDown_P4_P2 :: Dict (K.Rem 'K.RoundDown (P 4) (P 2) ~ P 0)-_test_Rem_RoundDown_P4_P2 =  Dict-_test_Div_RoundDown_P4_P3 :: Dict (K.Div 'K.RoundDown (P 4) (P 3) ~ P 1)-_test_Div_RoundDown_P4_P3 =  Dict-_test_Rem_RoundDown_P4_P3 :: Dict (K.Rem 'K.RoundDown (P 4) (P 3) ~ P 1)-_test_Rem_RoundDown_P4_P3 =  Dict-_test_Div_RoundDown_P4_P4 :: Dict (K.Div 'K.RoundDown (P 4) (P 4) ~ P 1)-_test_Div_RoundDown_P4_P4 =  Dict-_test_Rem_RoundDown_P4_P4 :: Dict (K.Rem 'K.RoundDown (P 4) (P 4) ~ P 0)-_test_Rem_RoundDown_P4_P4 =  Dict-_test_Div_RoundHalfAway_N1_N1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfAway_N1_N1 =  Dict-_test_Rem_RoundHalfAway_N1_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_N1_N1 =  Dict-_test_Div_RoundHalfAway_N1_N2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 2) ~ P 1)-_test_Div_RoundHalfAway_N1_N2 =  Dict-_test_Rem_RoundHalfAway_N1_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 2) ~ P 1)-_test_Rem_RoundHalfAway_N1_N2 =  Dict-_test_Div_RoundHalfAway_N1_N3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfAway_N1_N3 =  Dict-_test_Rem_RoundHalfAway_N1_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfAway_N1_N3 =  Dict-_test_Div_RoundHalfAway_N1_N4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfAway_N1_N4 =  Dict-_test_Rem_RoundHalfAway_N1_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfAway_N1_N4 =  Dict-_test_Div_RoundHalfAway_N1_P1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfAway_N1_P1 =  Dict-_test_Rem_RoundHalfAway_N1_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_N1_P1 =  Dict-_test_Div_RoundHalfAway_N1_P2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 2) ~ N 1)-_test_Div_RoundHalfAway_N1_P2 =  Dict-_test_Rem_RoundHalfAway_N1_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 2) ~ P 1)-_test_Rem_RoundHalfAway_N1_P2 =  Dict-_test_Div_RoundHalfAway_N1_P3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfAway_N1_P3 =  Dict-_test_Rem_RoundHalfAway_N1_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfAway_N1_P3 =  Dict-_test_Div_RoundHalfAway_N1_P4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfAway_N1_P4 =  Dict-_test_Rem_RoundHalfAway_N1_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfAway_N1_P4 =  Dict-_test_Div_RoundHalfAway_N2_N1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfAway_N2_N1 =  Dict-_test_Rem_RoundHalfAway_N2_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_N2_N1 =  Dict-_test_Div_RoundHalfAway_N2_N2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfAway_N2_N2 =  Dict-_test_Rem_RoundHalfAway_N2_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfAway_N2_N2 =  Dict-_test_Div_RoundHalfAway_N2_N3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfAway_N2_N3 =  Dict-_test_Rem_RoundHalfAway_N2_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfAway_N2_N3 =  Dict-_test_Div_RoundHalfAway_N2_N4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 4) ~ P 1)-_test_Div_RoundHalfAway_N2_N4 =  Dict-_test_Rem_RoundHalfAway_N2_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 4) ~ P 2)-_test_Rem_RoundHalfAway_N2_N4 =  Dict-_test_Div_RoundHalfAway_N2_P1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfAway_N2_P1 =  Dict-_test_Rem_RoundHalfAway_N2_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_N2_P1 =  Dict-_test_Div_RoundHalfAway_N2_P2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfAway_N2_P2 =  Dict-_test_Rem_RoundHalfAway_N2_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfAway_N2_P2 =  Dict-_test_Div_RoundHalfAway_N2_P3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfAway_N2_P3 =  Dict-_test_Rem_RoundHalfAway_N2_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfAway_N2_P3 =  Dict-_test_Div_RoundHalfAway_N2_P4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 4) ~ N 1)-_test_Div_RoundHalfAway_N2_P4 =  Dict-_test_Rem_RoundHalfAway_N2_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 4) ~ P 2)-_test_Rem_RoundHalfAway_N2_P4 =  Dict-_test_Div_RoundHalfAway_N3_N1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfAway_N3_N1 =  Dict-_test_Rem_RoundHalfAway_N3_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_N3_N1 =  Dict-_test_Div_RoundHalfAway_N3_N2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 2) ~ P 2)-_test_Div_RoundHalfAway_N3_N2 =  Dict-_test_Rem_RoundHalfAway_N3_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 2) ~ P 1)-_test_Rem_RoundHalfAway_N3_N2 =  Dict-_test_Div_RoundHalfAway_N3_N3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfAway_N3_N3 =  Dict-_test_Rem_RoundHalfAway_N3_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfAway_N3_N3 =  Dict-_test_Div_RoundHalfAway_N3_N4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfAway_N3_N4 =  Dict-_test_Rem_RoundHalfAway_N3_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfAway_N3_N4 =  Dict-_test_Div_RoundHalfAway_N3_P1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfAway_N3_P1 =  Dict-_test_Rem_RoundHalfAway_N3_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_N3_P1 =  Dict-_test_Div_RoundHalfAway_N3_P2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 2) ~ N 2)-_test_Div_RoundHalfAway_N3_P2 =  Dict-_test_Rem_RoundHalfAway_N3_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 2) ~ P 1)-_test_Rem_RoundHalfAway_N3_P2 =  Dict-_test_Div_RoundHalfAway_N3_P3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfAway_N3_P3 =  Dict-_test_Rem_RoundHalfAway_N3_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfAway_N3_P3 =  Dict-_test_Div_RoundHalfAway_N3_P4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfAway_N3_P4 =  Dict-_test_Rem_RoundHalfAway_N3_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfAway_N3_P4 =  Dict-_test_Div_RoundHalfAway_N4_N1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfAway_N4_N1 =  Dict-_test_Rem_RoundHalfAway_N4_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_N4_N1 =  Dict-_test_Div_RoundHalfAway_N4_N2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfAway_N4_N2 =  Dict-_test_Rem_RoundHalfAway_N4_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfAway_N4_N2 =  Dict-_test_Div_RoundHalfAway_N4_N3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfAway_N4_N3 =  Dict-_test_Rem_RoundHalfAway_N4_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfAway_N4_N3 =  Dict-_test_Div_RoundHalfAway_N4_N4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfAway_N4_N4 =  Dict-_test_Rem_RoundHalfAway_N4_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfAway_N4_N4 =  Dict-_test_Div_RoundHalfAway_N4_P1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfAway_N4_P1 =  Dict-_test_Rem_RoundHalfAway_N4_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_N4_P1 =  Dict-_test_Div_RoundHalfAway_N4_P2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfAway_N4_P2 =  Dict-_test_Rem_RoundHalfAway_N4_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfAway_N4_P2 =  Dict-_test_Div_RoundHalfAway_N4_P3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfAway_N4_P3 =  Dict-_test_Rem_RoundHalfAway_N4_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfAway_N4_P3 =  Dict-_test_Div_RoundHalfAway_N4_P4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfAway_N4_P4 =  Dict-_test_Rem_RoundHalfAway_N4_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfAway_N4_P4 =  Dict-_test_Div_RoundHalfAway_P0_N1 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfAway_P0_N1 =  Dict-_test_Rem_RoundHalfAway_P0_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_P0_N1 =  Dict-_test_Div_RoundHalfAway_P0_N2 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfAway_P0_N2 =  Dict-_test_Rem_RoundHalfAway_P0_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfAway_P0_N2 =  Dict-_test_Div_RoundHalfAway_P0_N3 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfAway_P0_N3 =  Dict-_test_Rem_RoundHalfAway_P0_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfAway_P0_N3 =  Dict-_test_Div_RoundHalfAway_P0_N4 :: Dict (K.Div 'K.RoundHalfAway (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfAway_P0_N4 =  Dict-_test_Rem_RoundHalfAway_P0_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfAway_P0_N4 =  Dict-_test_Div_RoundHalfAway_P0_P1 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfAway_P0_P1 =  Dict-_test_Rem_RoundHalfAway_P0_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_P0_P1 =  Dict-_test_Div_RoundHalfAway_P0_P2 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfAway_P0_P2 =  Dict-_test_Rem_RoundHalfAway_P0_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfAway_P0_P2 =  Dict-_test_Div_RoundHalfAway_P0_P3 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfAway_P0_P3 =  Dict-_test_Rem_RoundHalfAway_P0_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfAway_P0_P3 =  Dict-_test_Div_RoundHalfAway_P0_P4 :: Dict (K.Div 'K.RoundHalfAway (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfAway_P0_P4 =  Dict-_test_Rem_RoundHalfAway_P0_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfAway_P0_P4 =  Dict-_test_Div_RoundHalfAway_P1_N1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfAway_P1_N1 =  Dict-_test_Rem_RoundHalfAway_P1_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_P1_N1 =  Dict-_test_Div_RoundHalfAway_P1_N2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 2) ~ N 1)-_test_Div_RoundHalfAway_P1_N2 =  Dict-_test_Rem_RoundHalfAway_P1_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 2) ~ N 1)-_test_Rem_RoundHalfAway_P1_N2 =  Dict-_test_Div_RoundHalfAway_P1_N3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfAway_P1_N3 =  Dict-_test_Rem_RoundHalfAway_P1_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfAway_P1_N3 =  Dict-_test_Div_RoundHalfAway_P1_N4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfAway_P1_N4 =  Dict-_test_Rem_RoundHalfAway_P1_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfAway_P1_N4 =  Dict-_test_Div_RoundHalfAway_P1_P1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfAway_P1_P1 =  Dict-_test_Rem_RoundHalfAway_P1_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_P1_P1 =  Dict-_test_Div_RoundHalfAway_P1_P2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 2) ~ P 1)-_test_Div_RoundHalfAway_P1_P2 =  Dict-_test_Rem_RoundHalfAway_P1_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 2) ~ N 1)-_test_Rem_RoundHalfAway_P1_P2 =  Dict-_test_Div_RoundHalfAway_P1_P3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfAway_P1_P3 =  Dict-_test_Rem_RoundHalfAway_P1_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfAway_P1_P3 =  Dict-_test_Div_RoundHalfAway_P1_P4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfAway_P1_P4 =  Dict-_test_Rem_RoundHalfAway_P1_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfAway_P1_P4 =  Dict-_test_Div_RoundHalfAway_P2_N1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfAway_P2_N1 =  Dict-_test_Rem_RoundHalfAway_P2_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_P2_N1 =  Dict-_test_Div_RoundHalfAway_P2_N2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfAway_P2_N2 =  Dict-_test_Rem_RoundHalfAway_P2_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfAway_P2_N2 =  Dict-_test_Div_RoundHalfAway_P2_N3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfAway_P2_N3 =  Dict-_test_Rem_RoundHalfAway_P2_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfAway_P2_N3 =  Dict-_test_Div_RoundHalfAway_P2_N4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 4) ~ N 1)-_test_Div_RoundHalfAway_P2_N4 =  Dict-_test_Rem_RoundHalfAway_P2_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 4) ~ N 2)-_test_Rem_RoundHalfAway_P2_N4 =  Dict-_test_Div_RoundHalfAway_P2_P1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfAway_P2_P1 =  Dict-_test_Rem_RoundHalfAway_P2_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_P2_P1 =  Dict-_test_Div_RoundHalfAway_P2_P2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfAway_P2_P2 =  Dict-_test_Rem_RoundHalfAway_P2_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfAway_P2_P2 =  Dict-_test_Div_RoundHalfAway_P2_P3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfAway_P2_P3 =  Dict-_test_Rem_RoundHalfAway_P2_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfAway_P2_P3 =  Dict-_test_Div_RoundHalfAway_P2_P4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 4) ~ P 1)-_test_Div_RoundHalfAway_P2_P4 =  Dict-_test_Rem_RoundHalfAway_P2_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 4) ~ N 2)-_test_Rem_RoundHalfAway_P2_P4 =  Dict-_test_Div_RoundHalfAway_P3_N1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfAway_P3_N1 =  Dict-_test_Rem_RoundHalfAway_P3_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_P3_N1 =  Dict-_test_Div_RoundHalfAway_P3_N2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 2) ~ N 2)-_test_Div_RoundHalfAway_P3_N2 =  Dict-_test_Rem_RoundHalfAway_P3_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 2) ~ N 1)-_test_Rem_RoundHalfAway_P3_N2 =  Dict-_test_Div_RoundHalfAway_P3_N3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfAway_P3_N3 =  Dict-_test_Rem_RoundHalfAway_P3_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfAway_P3_N3 =  Dict-_test_Div_RoundHalfAway_P3_N4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfAway_P3_N4 =  Dict-_test_Rem_RoundHalfAway_P3_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfAway_P3_N4 =  Dict-_test_Div_RoundHalfAway_P3_P1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfAway_P3_P1 =  Dict-_test_Rem_RoundHalfAway_P3_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_P3_P1 =  Dict-_test_Div_RoundHalfAway_P3_P2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 2) ~ P 2)-_test_Div_RoundHalfAway_P3_P2 =  Dict-_test_Rem_RoundHalfAway_P3_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 2) ~ N 1)-_test_Rem_RoundHalfAway_P3_P2 =  Dict-_test_Div_RoundHalfAway_P3_P3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfAway_P3_P3 =  Dict-_test_Rem_RoundHalfAway_P3_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfAway_P3_P3 =  Dict-_test_Div_RoundHalfAway_P3_P4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfAway_P3_P4 =  Dict-_test_Rem_RoundHalfAway_P3_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfAway_P3_P4 =  Dict-_test_Div_RoundHalfAway_P4_N1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfAway_P4_N1 =  Dict-_test_Rem_RoundHalfAway_P4_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfAway_P4_N1 =  Dict-_test_Div_RoundHalfAway_P4_N2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfAway_P4_N2 =  Dict-_test_Rem_RoundHalfAway_P4_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfAway_P4_N2 =  Dict-_test_Div_RoundHalfAway_P4_N3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfAway_P4_N3 =  Dict-_test_Rem_RoundHalfAway_P4_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfAway_P4_N3 =  Dict-_test_Div_RoundHalfAway_P4_N4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfAway_P4_N4 =  Dict-_test_Rem_RoundHalfAway_P4_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfAway_P4_N4 =  Dict-_test_Div_RoundHalfAway_P4_P1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfAway_P4_P1 =  Dict-_test_Rem_RoundHalfAway_P4_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfAway_P4_P1 =  Dict-_test_Div_RoundHalfAway_P4_P2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfAway_P4_P2 =  Dict-_test_Rem_RoundHalfAway_P4_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfAway_P4_P2 =  Dict-_test_Div_RoundHalfAway_P4_P3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfAway_P4_P3 =  Dict-_test_Rem_RoundHalfAway_P4_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfAway_P4_P3 =  Dict-_test_Div_RoundHalfAway_P4_P4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfAway_P4_P4 =  Dict-_test_Rem_RoundHalfAway_P4_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfAway_P4_P4 =  Dict-_test_Div_RoundHalfDown_N1_N1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfDown_N1_N1 =  Dict-_test_Rem_RoundHalfDown_N1_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_N1_N1 =  Dict-_test_Div_RoundHalfDown_N1_N2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 2) ~ P 0)-_test_Div_RoundHalfDown_N1_N2 =  Dict-_test_Rem_RoundHalfDown_N1_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 2) ~ N 1)-_test_Rem_RoundHalfDown_N1_N2 =  Dict-_test_Div_RoundHalfDown_N1_N3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfDown_N1_N3 =  Dict-_test_Rem_RoundHalfDown_N1_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfDown_N1_N3 =  Dict-_test_Div_RoundHalfDown_N1_N4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfDown_N1_N4 =  Dict-_test_Rem_RoundHalfDown_N1_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfDown_N1_N4 =  Dict-_test_Div_RoundHalfDown_N1_P1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfDown_N1_P1 =  Dict-_test_Rem_RoundHalfDown_N1_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_N1_P1 =  Dict-_test_Div_RoundHalfDown_N1_P2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 2) ~ N 1)-_test_Div_RoundHalfDown_N1_P2 =  Dict-_test_Rem_RoundHalfDown_N1_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 2) ~ P 1)-_test_Rem_RoundHalfDown_N1_P2 =  Dict-_test_Div_RoundHalfDown_N1_P3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfDown_N1_P3 =  Dict-_test_Rem_RoundHalfDown_N1_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfDown_N1_P3 =  Dict-_test_Div_RoundHalfDown_N1_P4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfDown_N1_P4 =  Dict-_test_Rem_RoundHalfDown_N1_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfDown_N1_P4 =  Dict-_test_Div_RoundHalfDown_N2_N1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfDown_N2_N1 =  Dict-_test_Rem_RoundHalfDown_N2_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_N2_N1 =  Dict-_test_Div_RoundHalfDown_N2_N2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfDown_N2_N2 =  Dict-_test_Rem_RoundHalfDown_N2_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfDown_N2_N2 =  Dict-_test_Div_RoundHalfDown_N2_N3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfDown_N2_N3 =  Dict-_test_Rem_RoundHalfDown_N2_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfDown_N2_N3 =  Dict-_test_Div_RoundHalfDown_N2_N4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 4) ~ P 0)-_test_Div_RoundHalfDown_N2_N4 =  Dict-_test_Rem_RoundHalfDown_N2_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 4) ~ N 2)-_test_Rem_RoundHalfDown_N2_N4 =  Dict-_test_Div_RoundHalfDown_N2_P1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfDown_N2_P1 =  Dict-_test_Rem_RoundHalfDown_N2_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_N2_P1 =  Dict-_test_Div_RoundHalfDown_N2_P2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfDown_N2_P2 =  Dict-_test_Rem_RoundHalfDown_N2_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfDown_N2_P2 =  Dict-_test_Div_RoundHalfDown_N2_P3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfDown_N2_P3 =  Dict-_test_Rem_RoundHalfDown_N2_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfDown_N2_P3 =  Dict-_test_Div_RoundHalfDown_N2_P4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 4) ~ N 1)-_test_Div_RoundHalfDown_N2_P4 =  Dict-_test_Rem_RoundHalfDown_N2_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 4) ~ P 2)-_test_Rem_RoundHalfDown_N2_P4 =  Dict-_test_Div_RoundHalfDown_N3_N1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfDown_N3_N1 =  Dict-_test_Rem_RoundHalfDown_N3_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_N3_N1 =  Dict-_test_Div_RoundHalfDown_N3_N2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 2) ~ P 1)-_test_Div_RoundHalfDown_N3_N2 =  Dict-_test_Rem_RoundHalfDown_N3_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 2) ~ N 1)-_test_Rem_RoundHalfDown_N3_N2 =  Dict-_test_Div_RoundHalfDown_N3_N3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfDown_N3_N3 =  Dict-_test_Rem_RoundHalfDown_N3_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfDown_N3_N3 =  Dict-_test_Div_RoundHalfDown_N3_N4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfDown_N3_N4 =  Dict-_test_Rem_RoundHalfDown_N3_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfDown_N3_N4 =  Dict-_test_Div_RoundHalfDown_N3_P1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfDown_N3_P1 =  Dict-_test_Rem_RoundHalfDown_N3_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_N3_P1 =  Dict-_test_Div_RoundHalfDown_N3_P2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 2) ~ N 2)-_test_Div_RoundHalfDown_N3_P2 =  Dict-_test_Rem_RoundHalfDown_N3_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 2) ~ P 1)-_test_Rem_RoundHalfDown_N3_P2 =  Dict-_test_Div_RoundHalfDown_N3_P3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfDown_N3_P3 =  Dict-_test_Rem_RoundHalfDown_N3_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfDown_N3_P3 =  Dict-_test_Div_RoundHalfDown_N3_P4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfDown_N3_P4 =  Dict-_test_Rem_RoundHalfDown_N3_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfDown_N3_P4 =  Dict-_test_Div_RoundHalfDown_N4_N1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfDown_N4_N1 =  Dict-_test_Rem_RoundHalfDown_N4_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_N4_N1 =  Dict-_test_Div_RoundHalfDown_N4_N2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfDown_N4_N2 =  Dict-_test_Rem_RoundHalfDown_N4_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfDown_N4_N2 =  Dict-_test_Div_RoundHalfDown_N4_N3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfDown_N4_N3 =  Dict-_test_Rem_RoundHalfDown_N4_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfDown_N4_N3 =  Dict-_test_Div_RoundHalfDown_N4_N4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfDown_N4_N4 =  Dict-_test_Rem_RoundHalfDown_N4_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfDown_N4_N4 =  Dict-_test_Div_RoundHalfDown_N4_P1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfDown_N4_P1 =  Dict-_test_Rem_RoundHalfDown_N4_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_N4_P1 =  Dict-_test_Div_RoundHalfDown_N4_P2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfDown_N4_P2 =  Dict-_test_Rem_RoundHalfDown_N4_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfDown_N4_P2 =  Dict-_test_Div_RoundHalfDown_N4_P3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfDown_N4_P3 =  Dict-_test_Rem_RoundHalfDown_N4_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfDown_N4_P3 =  Dict-_test_Div_RoundHalfDown_N4_P4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfDown_N4_P4 =  Dict-_test_Rem_RoundHalfDown_N4_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfDown_N4_P4 =  Dict-_test_Div_RoundHalfDown_P0_N1 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfDown_P0_N1 =  Dict-_test_Rem_RoundHalfDown_P0_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_P0_N1 =  Dict-_test_Div_RoundHalfDown_P0_N2 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfDown_P0_N2 =  Dict-_test_Rem_RoundHalfDown_P0_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfDown_P0_N2 =  Dict-_test_Div_RoundHalfDown_P0_N3 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfDown_P0_N3 =  Dict-_test_Rem_RoundHalfDown_P0_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfDown_P0_N3 =  Dict-_test_Div_RoundHalfDown_P0_N4 :: Dict (K.Div 'K.RoundHalfDown (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfDown_P0_N4 =  Dict-_test_Rem_RoundHalfDown_P0_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfDown_P0_N4 =  Dict-_test_Div_RoundHalfDown_P0_P1 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfDown_P0_P1 =  Dict-_test_Rem_RoundHalfDown_P0_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_P0_P1 =  Dict-_test_Div_RoundHalfDown_P0_P2 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfDown_P0_P2 =  Dict-_test_Rem_RoundHalfDown_P0_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfDown_P0_P2 =  Dict-_test_Div_RoundHalfDown_P0_P3 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfDown_P0_P3 =  Dict-_test_Rem_RoundHalfDown_P0_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfDown_P0_P3 =  Dict-_test_Div_RoundHalfDown_P0_P4 :: Dict (K.Div 'K.RoundHalfDown (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfDown_P0_P4 =  Dict-_test_Rem_RoundHalfDown_P0_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfDown_P0_P4 =  Dict-_test_Div_RoundHalfDown_P1_N1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfDown_P1_N1 =  Dict-_test_Rem_RoundHalfDown_P1_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_P1_N1 =  Dict-_test_Div_RoundHalfDown_P1_N2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 2) ~ N 1)-_test_Div_RoundHalfDown_P1_N2 =  Dict-_test_Rem_RoundHalfDown_P1_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 2) ~ N 1)-_test_Rem_RoundHalfDown_P1_N2 =  Dict-_test_Div_RoundHalfDown_P1_N3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfDown_P1_N3 =  Dict-_test_Rem_RoundHalfDown_P1_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfDown_P1_N3 =  Dict-_test_Div_RoundHalfDown_P1_N4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfDown_P1_N4 =  Dict-_test_Rem_RoundHalfDown_P1_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfDown_P1_N4 =  Dict-_test_Div_RoundHalfDown_P1_P1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfDown_P1_P1 =  Dict-_test_Rem_RoundHalfDown_P1_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_P1_P1 =  Dict-_test_Div_RoundHalfDown_P1_P2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 2) ~ P 0)-_test_Div_RoundHalfDown_P1_P2 =  Dict-_test_Rem_RoundHalfDown_P1_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 2) ~ P 1)-_test_Rem_RoundHalfDown_P1_P2 =  Dict-_test_Div_RoundHalfDown_P1_P3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfDown_P1_P3 =  Dict-_test_Rem_RoundHalfDown_P1_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfDown_P1_P3 =  Dict-_test_Div_RoundHalfDown_P1_P4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfDown_P1_P4 =  Dict-_test_Rem_RoundHalfDown_P1_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfDown_P1_P4 =  Dict-_test_Div_RoundHalfDown_P2_N1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfDown_P2_N1 =  Dict-_test_Rem_RoundHalfDown_P2_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_P2_N1 =  Dict-_test_Div_RoundHalfDown_P2_N2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfDown_P2_N2 =  Dict-_test_Rem_RoundHalfDown_P2_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfDown_P2_N2 =  Dict-_test_Div_RoundHalfDown_P2_N3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfDown_P2_N3 =  Dict-_test_Rem_RoundHalfDown_P2_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfDown_P2_N3 =  Dict-_test_Div_RoundHalfDown_P2_N4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 4) ~ N 1)-_test_Div_RoundHalfDown_P2_N4 =  Dict-_test_Rem_RoundHalfDown_P2_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 4) ~ N 2)-_test_Rem_RoundHalfDown_P2_N4 =  Dict-_test_Div_RoundHalfDown_P2_P1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfDown_P2_P1 =  Dict-_test_Rem_RoundHalfDown_P2_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_P2_P1 =  Dict-_test_Div_RoundHalfDown_P2_P2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfDown_P2_P2 =  Dict-_test_Rem_RoundHalfDown_P2_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfDown_P2_P2 =  Dict-_test_Div_RoundHalfDown_P2_P3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfDown_P2_P3 =  Dict-_test_Rem_RoundHalfDown_P2_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfDown_P2_P3 =  Dict-_test_Div_RoundHalfDown_P2_P4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 4) ~ P 0)-_test_Div_RoundHalfDown_P2_P4 =  Dict-_test_Rem_RoundHalfDown_P2_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 4) ~ P 2)-_test_Rem_RoundHalfDown_P2_P4 =  Dict-_test_Div_RoundHalfDown_P3_N1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfDown_P3_N1 =  Dict-_test_Rem_RoundHalfDown_P3_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_P3_N1 =  Dict-_test_Div_RoundHalfDown_P3_N2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 2) ~ N 2)-_test_Div_RoundHalfDown_P3_N2 =  Dict-_test_Rem_RoundHalfDown_P3_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 2) ~ N 1)-_test_Rem_RoundHalfDown_P3_N2 =  Dict-_test_Div_RoundHalfDown_P3_N3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfDown_P3_N3 =  Dict-_test_Rem_RoundHalfDown_P3_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfDown_P3_N3 =  Dict-_test_Div_RoundHalfDown_P3_N4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfDown_P3_N4 =  Dict-_test_Rem_RoundHalfDown_P3_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfDown_P3_N4 =  Dict-_test_Div_RoundHalfDown_P3_P1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfDown_P3_P1 =  Dict-_test_Rem_RoundHalfDown_P3_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_P3_P1 =  Dict-_test_Div_RoundHalfDown_P3_P2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 2) ~ P 1)-_test_Div_RoundHalfDown_P3_P2 =  Dict-_test_Rem_RoundHalfDown_P3_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 2) ~ P 1)-_test_Rem_RoundHalfDown_P3_P2 =  Dict-_test_Div_RoundHalfDown_P3_P3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfDown_P3_P3 =  Dict-_test_Rem_RoundHalfDown_P3_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfDown_P3_P3 =  Dict-_test_Div_RoundHalfDown_P3_P4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfDown_P3_P4 =  Dict-_test_Rem_RoundHalfDown_P3_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfDown_P3_P4 =  Dict-_test_Div_RoundHalfDown_P4_N1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfDown_P4_N1 =  Dict-_test_Rem_RoundHalfDown_P4_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfDown_P4_N1 =  Dict-_test_Div_RoundHalfDown_P4_N2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfDown_P4_N2 =  Dict-_test_Rem_RoundHalfDown_P4_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfDown_P4_N2 =  Dict-_test_Div_RoundHalfDown_P4_N3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfDown_P4_N3 =  Dict-_test_Rem_RoundHalfDown_P4_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfDown_P4_N3 =  Dict-_test_Div_RoundHalfDown_P4_N4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfDown_P4_N4 =  Dict-_test_Rem_RoundHalfDown_P4_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfDown_P4_N4 =  Dict-_test_Div_RoundHalfDown_P4_P1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfDown_P4_P1 =  Dict-_test_Rem_RoundHalfDown_P4_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfDown_P4_P1 =  Dict-_test_Div_RoundHalfDown_P4_P2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfDown_P4_P2 =  Dict-_test_Rem_RoundHalfDown_P4_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfDown_P4_P2 =  Dict-_test_Div_RoundHalfDown_P4_P3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfDown_P4_P3 =  Dict-_test_Rem_RoundHalfDown_P4_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfDown_P4_P3 =  Dict-_test_Div_RoundHalfDown_P4_P4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfDown_P4_P4 =  Dict-_test_Rem_RoundHalfDown_P4_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfDown_P4_P4 =  Dict-_test_Div_RoundHalfEven_N1_N1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfEven_N1_N1 =  Dict-_test_Rem_RoundHalfEven_N1_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_N1_N1 =  Dict-_test_Div_RoundHalfEven_N1_N2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 2) ~ P 0)-_test_Div_RoundHalfEven_N1_N2 =  Dict-_test_Rem_RoundHalfEven_N1_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 2) ~ N 1)-_test_Rem_RoundHalfEven_N1_N2 =  Dict-_test_Div_RoundHalfEven_N1_N3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfEven_N1_N3 =  Dict-_test_Rem_RoundHalfEven_N1_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfEven_N1_N3 =  Dict-_test_Div_RoundHalfEven_N1_N4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfEven_N1_N4 =  Dict-_test_Rem_RoundHalfEven_N1_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfEven_N1_N4 =  Dict-_test_Div_RoundHalfEven_N1_P1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfEven_N1_P1 =  Dict-_test_Rem_RoundHalfEven_N1_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_N1_P1 =  Dict-_test_Div_RoundHalfEven_N1_P2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 2) ~ P 0)-_test_Div_RoundHalfEven_N1_P2 =  Dict-_test_Rem_RoundHalfEven_N1_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 2) ~ N 1)-_test_Rem_RoundHalfEven_N1_P2 =  Dict-_test_Div_RoundHalfEven_N1_P3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfEven_N1_P3 =  Dict-_test_Rem_RoundHalfEven_N1_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfEven_N1_P3 =  Dict-_test_Div_RoundHalfEven_N1_P4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfEven_N1_P4 =  Dict-_test_Rem_RoundHalfEven_N1_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfEven_N1_P4 =  Dict-_test_Div_RoundHalfEven_N2_N1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfEven_N2_N1 =  Dict-_test_Rem_RoundHalfEven_N2_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_N2_N1 =  Dict-_test_Div_RoundHalfEven_N2_N2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfEven_N2_N2 =  Dict-_test_Rem_RoundHalfEven_N2_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfEven_N2_N2 =  Dict-_test_Div_RoundHalfEven_N2_N3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfEven_N2_N3 =  Dict-_test_Rem_RoundHalfEven_N2_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfEven_N2_N3 =  Dict-_test_Div_RoundHalfEven_N2_N4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 4) ~ P 0)-_test_Div_RoundHalfEven_N2_N4 =  Dict-_test_Rem_RoundHalfEven_N2_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 4) ~ N 2)-_test_Rem_RoundHalfEven_N2_N4 =  Dict-_test_Div_RoundHalfEven_N2_P1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfEven_N2_P1 =  Dict-_test_Rem_RoundHalfEven_N2_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_N2_P1 =  Dict-_test_Div_RoundHalfEven_N2_P2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfEven_N2_P2 =  Dict-_test_Rem_RoundHalfEven_N2_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfEven_N2_P2 =  Dict-_test_Div_RoundHalfEven_N2_P3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfEven_N2_P3 =  Dict-_test_Rem_RoundHalfEven_N2_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfEven_N2_P3 =  Dict-_test_Div_RoundHalfEven_N2_P4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 4) ~ P 0)-_test_Div_RoundHalfEven_N2_P4 =  Dict-_test_Rem_RoundHalfEven_N2_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 4) ~ N 2)-_test_Rem_RoundHalfEven_N2_P4 =  Dict-_test_Div_RoundHalfEven_N3_N1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfEven_N3_N1 =  Dict-_test_Rem_RoundHalfEven_N3_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_N3_N1 =  Dict-_test_Div_RoundHalfEven_N3_N2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 2) ~ P 2)-_test_Div_RoundHalfEven_N3_N2 =  Dict-_test_Rem_RoundHalfEven_N3_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 2) ~ P 1)-_test_Rem_RoundHalfEven_N3_N2 =  Dict-_test_Div_RoundHalfEven_N3_N3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfEven_N3_N3 =  Dict-_test_Rem_RoundHalfEven_N3_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfEven_N3_N3 =  Dict-_test_Div_RoundHalfEven_N3_N4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfEven_N3_N4 =  Dict-_test_Rem_RoundHalfEven_N3_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfEven_N3_N4 =  Dict-_test_Div_RoundHalfEven_N3_P1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfEven_N3_P1 =  Dict-_test_Rem_RoundHalfEven_N3_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_N3_P1 =  Dict-_test_Div_RoundHalfEven_N3_P2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 2) ~ N 2)-_test_Div_RoundHalfEven_N3_P2 =  Dict-_test_Rem_RoundHalfEven_N3_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 2) ~ P 1)-_test_Rem_RoundHalfEven_N3_P2 =  Dict-_test_Div_RoundHalfEven_N3_P3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfEven_N3_P3 =  Dict-_test_Rem_RoundHalfEven_N3_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfEven_N3_P3 =  Dict-_test_Div_RoundHalfEven_N3_P4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfEven_N3_P4 =  Dict-_test_Rem_RoundHalfEven_N3_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfEven_N3_P4 =  Dict-_test_Div_RoundHalfEven_N4_N1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfEven_N4_N1 =  Dict-_test_Rem_RoundHalfEven_N4_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_N4_N1 =  Dict-_test_Div_RoundHalfEven_N4_N2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfEven_N4_N2 =  Dict-_test_Rem_RoundHalfEven_N4_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfEven_N4_N2 =  Dict-_test_Div_RoundHalfEven_N4_N3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfEven_N4_N3 =  Dict-_test_Rem_RoundHalfEven_N4_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfEven_N4_N3 =  Dict-_test_Div_RoundHalfEven_N4_N4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfEven_N4_N4 =  Dict-_test_Rem_RoundHalfEven_N4_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfEven_N4_N4 =  Dict-_test_Div_RoundHalfEven_N4_P1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfEven_N4_P1 =  Dict-_test_Rem_RoundHalfEven_N4_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_N4_P1 =  Dict-_test_Div_RoundHalfEven_N4_P2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfEven_N4_P2 =  Dict-_test_Rem_RoundHalfEven_N4_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfEven_N4_P2 =  Dict-_test_Div_RoundHalfEven_N4_P3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfEven_N4_P3 =  Dict-_test_Rem_RoundHalfEven_N4_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfEven_N4_P3 =  Dict-_test_Div_RoundHalfEven_N4_P4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfEven_N4_P4 =  Dict-_test_Rem_RoundHalfEven_N4_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfEven_N4_P4 =  Dict-_test_Div_RoundHalfEven_P0_N1 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfEven_P0_N1 =  Dict-_test_Rem_RoundHalfEven_P0_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_P0_N1 =  Dict-_test_Div_RoundHalfEven_P0_N2 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfEven_P0_N2 =  Dict-_test_Rem_RoundHalfEven_P0_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfEven_P0_N2 =  Dict-_test_Div_RoundHalfEven_P0_N3 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfEven_P0_N3 =  Dict-_test_Rem_RoundHalfEven_P0_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfEven_P0_N3 =  Dict-_test_Div_RoundHalfEven_P0_N4 :: Dict (K.Div 'K.RoundHalfEven (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfEven_P0_N4 =  Dict-_test_Rem_RoundHalfEven_P0_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfEven_P0_N4 =  Dict-_test_Div_RoundHalfEven_P0_P1 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfEven_P0_P1 =  Dict-_test_Rem_RoundHalfEven_P0_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_P0_P1 =  Dict-_test_Div_RoundHalfEven_P0_P2 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfEven_P0_P2 =  Dict-_test_Rem_RoundHalfEven_P0_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfEven_P0_P2 =  Dict-_test_Div_RoundHalfEven_P0_P3 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfEven_P0_P3 =  Dict-_test_Rem_RoundHalfEven_P0_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfEven_P0_P3 =  Dict-_test_Div_RoundHalfEven_P0_P4 :: Dict (K.Div 'K.RoundHalfEven (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfEven_P0_P4 =  Dict-_test_Rem_RoundHalfEven_P0_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfEven_P0_P4 =  Dict-_test_Div_RoundHalfEven_P1_N1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfEven_P1_N1 =  Dict-_test_Rem_RoundHalfEven_P1_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_P1_N1 =  Dict-_test_Div_RoundHalfEven_P1_N2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 2) ~ P 0)-_test_Div_RoundHalfEven_P1_N2 =  Dict-_test_Rem_RoundHalfEven_P1_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 2) ~ P 1)-_test_Rem_RoundHalfEven_P1_N2 =  Dict-_test_Div_RoundHalfEven_P1_N3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfEven_P1_N3 =  Dict-_test_Rem_RoundHalfEven_P1_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfEven_P1_N3 =  Dict-_test_Div_RoundHalfEven_P1_N4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfEven_P1_N4 =  Dict-_test_Rem_RoundHalfEven_P1_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfEven_P1_N4 =  Dict-_test_Div_RoundHalfEven_P1_P1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfEven_P1_P1 =  Dict-_test_Rem_RoundHalfEven_P1_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_P1_P1 =  Dict-_test_Div_RoundHalfEven_P1_P2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 2) ~ P 0)-_test_Div_RoundHalfEven_P1_P2 =  Dict-_test_Rem_RoundHalfEven_P1_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 2) ~ P 1)-_test_Rem_RoundHalfEven_P1_P2 =  Dict-_test_Div_RoundHalfEven_P1_P3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfEven_P1_P3 =  Dict-_test_Rem_RoundHalfEven_P1_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfEven_P1_P3 =  Dict-_test_Div_RoundHalfEven_P1_P4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfEven_P1_P4 =  Dict-_test_Rem_RoundHalfEven_P1_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfEven_P1_P4 =  Dict-_test_Div_RoundHalfEven_P2_N1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfEven_P2_N1 =  Dict-_test_Rem_RoundHalfEven_P2_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_P2_N1 =  Dict-_test_Div_RoundHalfEven_P2_N2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfEven_P2_N2 =  Dict-_test_Rem_RoundHalfEven_P2_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfEven_P2_N2 =  Dict-_test_Div_RoundHalfEven_P2_N3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfEven_P2_N3 =  Dict-_test_Rem_RoundHalfEven_P2_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfEven_P2_N3 =  Dict-_test_Div_RoundHalfEven_P2_N4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 4) ~ P 0)-_test_Div_RoundHalfEven_P2_N4 =  Dict-_test_Rem_RoundHalfEven_P2_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 4) ~ P 2)-_test_Rem_RoundHalfEven_P2_N4 =  Dict-_test_Div_RoundHalfEven_P2_P1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfEven_P2_P1 =  Dict-_test_Rem_RoundHalfEven_P2_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_P2_P1 =  Dict-_test_Div_RoundHalfEven_P2_P2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfEven_P2_P2 =  Dict-_test_Rem_RoundHalfEven_P2_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfEven_P2_P2 =  Dict-_test_Div_RoundHalfEven_P2_P3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfEven_P2_P3 =  Dict-_test_Rem_RoundHalfEven_P2_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfEven_P2_P3 =  Dict-_test_Div_RoundHalfEven_P2_P4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 4) ~ P 0)-_test_Div_RoundHalfEven_P2_P4 =  Dict-_test_Rem_RoundHalfEven_P2_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 4) ~ P 2)-_test_Rem_RoundHalfEven_P2_P4 =  Dict-_test_Div_RoundHalfEven_P3_N1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfEven_P3_N1 =  Dict-_test_Rem_RoundHalfEven_P3_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_P3_N1 =  Dict-_test_Div_RoundHalfEven_P3_N2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 2) ~ N 2)-_test_Div_RoundHalfEven_P3_N2 =  Dict-_test_Rem_RoundHalfEven_P3_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 2) ~ N 1)-_test_Rem_RoundHalfEven_P3_N2 =  Dict-_test_Div_RoundHalfEven_P3_N3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfEven_P3_N3 =  Dict-_test_Rem_RoundHalfEven_P3_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfEven_P3_N3 =  Dict-_test_Div_RoundHalfEven_P3_N4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfEven_P3_N4 =  Dict-_test_Rem_RoundHalfEven_P3_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfEven_P3_N4 =  Dict-_test_Div_RoundHalfEven_P3_P1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfEven_P3_P1 =  Dict-_test_Rem_RoundHalfEven_P3_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_P3_P1 =  Dict-_test_Div_RoundHalfEven_P3_P2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 2) ~ P 2)-_test_Div_RoundHalfEven_P3_P2 =  Dict-_test_Rem_RoundHalfEven_P3_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 2) ~ N 1)-_test_Rem_RoundHalfEven_P3_P2 =  Dict-_test_Div_RoundHalfEven_P3_P3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfEven_P3_P3 =  Dict-_test_Rem_RoundHalfEven_P3_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfEven_P3_P3 =  Dict-_test_Div_RoundHalfEven_P3_P4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfEven_P3_P4 =  Dict-_test_Rem_RoundHalfEven_P3_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfEven_P3_P4 =  Dict-_test_Div_RoundHalfEven_P4_N1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfEven_P4_N1 =  Dict-_test_Rem_RoundHalfEven_P4_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfEven_P4_N1 =  Dict-_test_Div_RoundHalfEven_P4_N2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfEven_P4_N2 =  Dict-_test_Rem_RoundHalfEven_P4_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfEven_P4_N2 =  Dict-_test_Div_RoundHalfEven_P4_N3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfEven_P4_N3 =  Dict-_test_Rem_RoundHalfEven_P4_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfEven_P4_N3 =  Dict-_test_Div_RoundHalfEven_P4_N4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfEven_P4_N4 =  Dict-_test_Rem_RoundHalfEven_P4_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfEven_P4_N4 =  Dict-_test_Div_RoundHalfEven_P4_P1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfEven_P4_P1 =  Dict-_test_Rem_RoundHalfEven_P4_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfEven_P4_P1 =  Dict-_test_Div_RoundHalfEven_P4_P2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfEven_P4_P2 =  Dict-_test_Rem_RoundHalfEven_P4_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfEven_P4_P2 =  Dict-_test_Div_RoundHalfEven_P4_P3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfEven_P4_P3 =  Dict-_test_Rem_RoundHalfEven_P4_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfEven_P4_P3 =  Dict-_test_Div_RoundHalfEven_P4_P4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfEven_P4_P4 =  Dict-_test_Rem_RoundHalfEven_P4_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfEven_P4_P4 =  Dict-_test_Div_RoundHalfOdd_N1_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfOdd_N1_N1 =  Dict-_test_Rem_RoundHalfOdd_N1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_N1_N1 =  Dict-_test_Div_RoundHalfOdd_N1_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 2) ~ P 1)-_test_Div_RoundHalfOdd_N1_N2 =  Dict-_test_Rem_RoundHalfOdd_N1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 2) ~ P 1)-_test_Rem_RoundHalfOdd_N1_N2 =  Dict-_test_Div_RoundHalfOdd_N1_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfOdd_N1_N3 =  Dict-_test_Rem_RoundHalfOdd_N1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfOdd_N1_N3 =  Dict-_test_Div_RoundHalfOdd_N1_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfOdd_N1_N4 =  Dict-_test_Rem_RoundHalfOdd_N1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfOdd_N1_N4 =  Dict-_test_Div_RoundHalfOdd_N1_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfOdd_N1_P1 =  Dict-_test_Rem_RoundHalfOdd_N1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_N1_P1 =  Dict-_test_Div_RoundHalfOdd_N1_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 2) ~ N 1)-_test_Div_RoundHalfOdd_N1_P2 =  Dict-_test_Rem_RoundHalfOdd_N1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 2) ~ P 1)-_test_Rem_RoundHalfOdd_N1_P2 =  Dict-_test_Div_RoundHalfOdd_N1_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfOdd_N1_P3 =  Dict-_test_Rem_RoundHalfOdd_N1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfOdd_N1_P3 =  Dict-_test_Div_RoundHalfOdd_N1_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfOdd_N1_P4 =  Dict-_test_Rem_RoundHalfOdd_N1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfOdd_N1_P4 =  Dict-_test_Div_RoundHalfOdd_N2_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfOdd_N2_N1 =  Dict-_test_Rem_RoundHalfOdd_N2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_N2_N1 =  Dict-_test_Div_RoundHalfOdd_N2_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfOdd_N2_N2 =  Dict-_test_Rem_RoundHalfOdd_N2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfOdd_N2_N2 =  Dict-_test_Div_RoundHalfOdd_N2_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfOdd_N2_N3 =  Dict-_test_Rem_RoundHalfOdd_N2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfOdd_N2_N3 =  Dict-_test_Div_RoundHalfOdd_N2_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 4) ~ P 1)-_test_Div_RoundHalfOdd_N2_N4 =  Dict-_test_Rem_RoundHalfOdd_N2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 4) ~ P 2)-_test_Rem_RoundHalfOdd_N2_N4 =  Dict-_test_Div_RoundHalfOdd_N2_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfOdd_N2_P1 =  Dict-_test_Rem_RoundHalfOdd_N2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_N2_P1 =  Dict-_test_Div_RoundHalfOdd_N2_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfOdd_N2_P2 =  Dict-_test_Rem_RoundHalfOdd_N2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfOdd_N2_P2 =  Dict-_test_Div_RoundHalfOdd_N2_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfOdd_N2_P3 =  Dict-_test_Rem_RoundHalfOdd_N2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfOdd_N2_P3 =  Dict-_test_Div_RoundHalfOdd_N2_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 4) ~ N 1)-_test_Div_RoundHalfOdd_N2_P4 =  Dict-_test_Rem_RoundHalfOdd_N2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 4) ~ P 2)-_test_Rem_RoundHalfOdd_N2_P4 =  Dict-_test_Div_RoundHalfOdd_N3_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfOdd_N3_N1 =  Dict-_test_Rem_RoundHalfOdd_N3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_N3_N1 =  Dict-_test_Div_RoundHalfOdd_N3_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 2) ~ P 1)-_test_Div_RoundHalfOdd_N3_N2 =  Dict-_test_Rem_RoundHalfOdd_N3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 2) ~ N 1)-_test_Rem_RoundHalfOdd_N3_N2 =  Dict-_test_Div_RoundHalfOdd_N3_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfOdd_N3_N3 =  Dict-_test_Rem_RoundHalfOdd_N3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfOdd_N3_N3 =  Dict-_test_Div_RoundHalfOdd_N3_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfOdd_N3_N4 =  Dict-_test_Rem_RoundHalfOdd_N3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfOdd_N3_N4 =  Dict-_test_Div_RoundHalfOdd_N3_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfOdd_N3_P1 =  Dict-_test_Rem_RoundHalfOdd_N3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_N3_P1 =  Dict-_test_Div_RoundHalfOdd_N3_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 2) ~ N 1)-_test_Div_RoundHalfOdd_N3_P2 =  Dict-_test_Rem_RoundHalfOdd_N3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 2) ~ N 1)-_test_Rem_RoundHalfOdd_N3_P2 =  Dict-_test_Div_RoundHalfOdd_N3_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfOdd_N3_P3 =  Dict-_test_Rem_RoundHalfOdd_N3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfOdd_N3_P3 =  Dict-_test_Div_RoundHalfOdd_N3_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfOdd_N3_P4 =  Dict-_test_Rem_RoundHalfOdd_N3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfOdd_N3_P4 =  Dict-_test_Div_RoundHalfOdd_N4_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfOdd_N4_N1 =  Dict-_test_Rem_RoundHalfOdd_N4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_N4_N1 =  Dict-_test_Div_RoundHalfOdd_N4_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfOdd_N4_N2 =  Dict-_test_Rem_RoundHalfOdd_N4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfOdd_N4_N2 =  Dict-_test_Div_RoundHalfOdd_N4_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfOdd_N4_N3 =  Dict-_test_Rem_RoundHalfOdd_N4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfOdd_N4_N3 =  Dict-_test_Div_RoundHalfOdd_N4_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfOdd_N4_N4 =  Dict-_test_Rem_RoundHalfOdd_N4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfOdd_N4_N4 =  Dict-_test_Div_RoundHalfOdd_N4_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfOdd_N4_P1 =  Dict-_test_Rem_RoundHalfOdd_N4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_N4_P1 =  Dict-_test_Div_RoundHalfOdd_N4_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfOdd_N4_P2 =  Dict-_test_Rem_RoundHalfOdd_N4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfOdd_N4_P2 =  Dict-_test_Div_RoundHalfOdd_N4_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfOdd_N4_P3 =  Dict-_test_Rem_RoundHalfOdd_N4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfOdd_N4_P3 =  Dict-_test_Div_RoundHalfOdd_N4_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfOdd_N4_P4 =  Dict-_test_Rem_RoundHalfOdd_N4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfOdd_N4_P4 =  Dict-_test_Div_RoundHalfOdd_P0_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfOdd_P0_N1 =  Dict-_test_Rem_RoundHalfOdd_P0_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_P0_N1 =  Dict-_test_Div_RoundHalfOdd_P0_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfOdd_P0_N2 =  Dict-_test_Rem_RoundHalfOdd_P0_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfOdd_P0_N2 =  Dict-_test_Div_RoundHalfOdd_P0_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfOdd_P0_N3 =  Dict-_test_Rem_RoundHalfOdd_P0_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfOdd_P0_N3 =  Dict-_test_Div_RoundHalfOdd_P0_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfOdd_P0_N4 =  Dict-_test_Rem_RoundHalfOdd_P0_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfOdd_P0_N4 =  Dict-_test_Div_RoundHalfOdd_P0_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfOdd_P0_P1 =  Dict-_test_Rem_RoundHalfOdd_P0_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_P0_P1 =  Dict-_test_Div_RoundHalfOdd_P0_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfOdd_P0_P2 =  Dict-_test_Rem_RoundHalfOdd_P0_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfOdd_P0_P2 =  Dict-_test_Div_RoundHalfOdd_P0_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfOdd_P0_P3 =  Dict-_test_Rem_RoundHalfOdd_P0_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfOdd_P0_P3 =  Dict-_test_Div_RoundHalfOdd_P0_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfOdd_P0_P4 =  Dict-_test_Rem_RoundHalfOdd_P0_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfOdd_P0_P4 =  Dict-_test_Div_RoundHalfOdd_P1_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfOdd_P1_N1 =  Dict-_test_Rem_RoundHalfOdd_P1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_P1_N1 =  Dict-_test_Div_RoundHalfOdd_P1_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 2) ~ N 1)-_test_Div_RoundHalfOdd_P1_N2 =  Dict-_test_Rem_RoundHalfOdd_P1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 2) ~ N 1)-_test_Rem_RoundHalfOdd_P1_N2 =  Dict-_test_Div_RoundHalfOdd_P1_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfOdd_P1_N3 =  Dict-_test_Rem_RoundHalfOdd_P1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfOdd_P1_N3 =  Dict-_test_Div_RoundHalfOdd_P1_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfOdd_P1_N4 =  Dict-_test_Rem_RoundHalfOdd_P1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfOdd_P1_N4 =  Dict-_test_Div_RoundHalfOdd_P1_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfOdd_P1_P1 =  Dict-_test_Rem_RoundHalfOdd_P1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_P1_P1 =  Dict-_test_Div_RoundHalfOdd_P1_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 2) ~ P 1)-_test_Div_RoundHalfOdd_P1_P2 =  Dict-_test_Rem_RoundHalfOdd_P1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 2) ~ N 1)-_test_Rem_RoundHalfOdd_P1_P2 =  Dict-_test_Div_RoundHalfOdd_P1_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfOdd_P1_P3 =  Dict-_test_Rem_RoundHalfOdd_P1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfOdd_P1_P3 =  Dict-_test_Div_RoundHalfOdd_P1_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfOdd_P1_P4 =  Dict-_test_Rem_RoundHalfOdd_P1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfOdd_P1_P4 =  Dict-_test_Div_RoundHalfOdd_P2_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfOdd_P2_N1 =  Dict-_test_Rem_RoundHalfOdd_P2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_P2_N1 =  Dict-_test_Div_RoundHalfOdd_P2_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfOdd_P2_N2 =  Dict-_test_Rem_RoundHalfOdd_P2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfOdd_P2_N2 =  Dict-_test_Div_RoundHalfOdd_P2_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfOdd_P2_N3 =  Dict-_test_Rem_RoundHalfOdd_P2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfOdd_P2_N3 =  Dict-_test_Div_RoundHalfOdd_P2_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 4) ~ N 1)-_test_Div_RoundHalfOdd_P2_N4 =  Dict-_test_Rem_RoundHalfOdd_P2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 4) ~ N 2)-_test_Rem_RoundHalfOdd_P2_N4 =  Dict-_test_Div_RoundHalfOdd_P2_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfOdd_P2_P1 =  Dict-_test_Rem_RoundHalfOdd_P2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_P2_P1 =  Dict-_test_Div_RoundHalfOdd_P2_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfOdd_P2_P2 =  Dict-_test_Rem_RoundHalfOdd_P2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfOdd_P2_P2 =  Dict-_test_Div_RoundHalfOdd_P2_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfOdd_P2_P3 =  Dict-_test_Rem_RoundHalfOdd_P2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfOdd_P2_P3 =  Dict-_test_Div_RoundHalfOdd_P2_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 4) ~ P 1)-_test_Div_RoundHalfOdd_P2_P4 =  Dict-_test_Rem_RoundHalfOdd_P2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 4) ~ N 2)-_test_Rem_RoundHalfOdd_P2_P4 =  Dict-_test_Div_RoundHalfOdd_P3_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfOdd_P3_N1 =  Dict-_test_Rem_RoundHalfOdd_P3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_P3_N1 =  Dict-_test_Div_RoundHalfOdd_P3_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 2) ~ N 1)-_test_Div_RoundHalfOdd_P3_N2 =  Dict-_test_Rem_RoundHalfOdd_P3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 2) ~ P 1)-_test_Rem_RoundHalfOdd_P3_N2 =  Dict-_test_Div_RoundHalfOdd_P3_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfOdd_P3_N3 =  Dict-_test_Rem_RoundHalfOdd_P3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfOdd_P3_N3 =  Dict-_test_Div_RoundHalfOdd_P3_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfOdd_P3_N4 =  Dict-_test_Rem_RoundHalfOdd_P3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfOdd_P3_N4 =  Dict-_test_Div_RoundHalfOdd_P3_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfOdd_P3_P1 =  Dict-_test_Rem_RoundHalfOdd_P3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_P3_P1 =  Dict-_test_Div_RoundHalfOdd_P3_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 2) ~ P 1)-_test_Div_RoundHalfOdd_P3_P2 =  Dict-_test_Rem_RoundHalfOdd_P3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 2) ~ P 1)-_test_Rem_RoundHalfOdd_P3_P2 =  Dict-_test_Div_RoundHalfOdd_P3_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfOdd_P3_P3 =  Dict-_test_Rem_RoundHalfOdd_P3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfOdd_P3_P3 =  Dict-_test_Div_RoundHalfOdd_P3_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfOdd_P3_P4 =  Dict-_test_Rem_RoundHalfOdd_P3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfOdd_P3_P4 =  Dict-_test_Div_RoundHalfOdd_P4_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfOdd_P4_N1 =  Dict-_test_Rem_RoundHalfOdd_P4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfOdd_P4_N1 =  Dict-_test_Div_RoundHalfOdd_P4_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfOdd_P4_N2 =  Dict-_test_Rem_RoundHalfOdd_P4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfOdd_P4_N2 =  Dict-_test_Div_RoundHalfOdd_P4_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfOdd_P4_N3 =  Dict-_test_Rem_RoundHalfOdd_P4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfOdd_P4_N3 =  Dict-_test_Div_RoundHalfOdd_P4_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfOdd_P4_N4 =  Dict-_test_Rem_RoundHalfOdd_P4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfOdd_P4_N4 =  Dict-_test_Div_RoundHalfOdd_P4_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfOdd_P4_P1 =  Dict-_test_Rem_RoundHalfOdd_P4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfOdd_P4_P1 =  Dict-_test_Div_RoundHalfOdd_P4_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfOdd_P4_P2 =  Dict-_test_Rem_RoundHalfOdd_P4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfOdd_P4_P2 =  Dict-_test_Div_RoundHalfOdd_P4_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfOdd_P4_P3 =  Dict-_test_Rem_RoundHalfOdd_P4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfOdd_P4_P3 =  Dict-_test_Div_RoundHalfOdd_P4_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfOdd_P4_P4 =  Dict-_test_Rem_RoundHalfOdd_P4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfOdd_P4_P4 =  Dict-_test_Div_RoundHalfUp_N1_N1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfUp_N1_N1 =  Dict-_test_Rem_RoundHalfUp_N1_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_N1_N1 =  Dict-_test_Div_RoundHalfUp_N1_N2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 2) ~ P 1)-_test_Div_RoundHalfUp_N1_N2 =  Dict-_test_Rem_RoundHalfUp_N1_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 2) ~ P 1)-_test_Rem_RoundHalfUp_N1_N2 =  Dict-_test_Div_RoundHalfUp_N1_N3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfUp_N1_N3 =  Dict-_test_Rem_RoundHalfUp_N1_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfUp_N1_N3 =  Dict-_test_Div_RoundHalfUp_N1_N4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfUp_N1_N4 =  Dict-_test_Rem_RoundHalfUp_N1_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfUp_N1_N4 =  Dict-_test_Div_RoundHalfUp_N1_P1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfUp_N1_P1 =  Dict-_test_Rem_RoundHalfUp_N1_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_N1_P1 =  Dict-_test_Div_RoundHalfUp_N1_P2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 2) ~ P 0)-_test_Div_RoundHalfUp_N1_P2 =  Dict-_test_Rem_RoundHalfUp_N1_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 2) ~ N 1)-_test_Rem_RoundHalfUp_N1_P2 =  Dict-_test_Div_RoundHalfUp_N1_P3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfUp_N1_P3 =  Dict-_test_Rem_RoundHalfUp_N1_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfUp_N1_P3 =  Dict-_test_Div_RoundHalfUp_N1_P4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfUp_N1_P4 =  Dict-_test_Rem_RoundHalfUp_N1_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfUp_N1_P4 =  Dict-_test_Div_RoundHalfUp_N2_N1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfUp_N2_N1 =  Dict-_test_Rem_RoundHalfUp_N2_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_N2_N1 =  Dict-_test_Div_RoundHalfUp_N2_N2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfUp_N2_N2 =  Dict-_test_Rem_RoundHalfUp_N2_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfUp_N2_N2 =  Dict-_test_Div_RoundHalfUp_N2_N3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfUp_N2_N3 =  Dict-_test_Rem_RoundHalfUp_N2_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfUp_N2_N3 =  Dict-_test_Div_RoundHalfUp_N2_N4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 4) ~ P 1)-_test_Div_RoundHalfUp_N2_N4 =  Dict-_test_Rem_RoundHalfUp_N2_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 4) ~ P 2)-_test_Rem_RoundHalfUp_N2_N4 =  Dict-_test_Div_RoundHalfUp_N2_P1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfUp_N2_P1 =  Dict-_test_Rem_RoundHalfUp_N2_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_N2_P1 =  Dict-_test_Div_RoundHalfUp_N2_P2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfUp_N2_P2 =  Dict-_test_Rem_RoundHalfUp_N2_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfUp_N2_P2 =  Dict-_test_Div_RoundHalfUp_N2_P3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfUp_N2_P3 =  Dict-_test_Rem_RoundHalfUp_N2_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfUp_N2_P3 =  Dict-_test_Div_RoundHalfUp_N2_P4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 4) ~ P 0)-_test_Div_RoundHalfUp_N2_P4 =  Dict-_test_Rem_RoundHalfUp_N2_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 4) ~ N 2)-_test_Rem_RoundHalfUp_N2_P4 =  Dict-_test_Div_RoundHalfUp_N3_N1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfUp_N3_N1 =  Dict-_test_Rem_RoundHalfUp_N3_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_N3_N1 =  Dict-_test_Div_RoundHalfUp_N3_N2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 2) ~ P 2)-_test_Div_RoundHalfUp_N3_N2 =  Dict-_test_Rem_RoundHalfUp_N3_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 2) ~ P 1)-_test_Rem_RoundHalfUp_N3_N2 =  Dict-_test_Div_RoundHalfUp_N3_N3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfUp_N3_N3 =  Dict-_test_Rem_RoundHalfUp_N3_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfUp_N3_N3 =  Dict-_test_Div_RoundHalfUp_N3_N4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfUp_N3_N4 =  Dict-_test_Rem_RoundHalfUp_N3_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfUp_N3_N4 =  Dict-_test_Div_RoundHalfUp_N3_P1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfUp_N3_P1 =  Dict-_test_Rem_RoundHalfUp_N3_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_N3_P1 =  Dict-_test_Div_RoundHalfUp_N3_P2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 2) ~ N 1)-_test_Div_RoundHalfUp_N3_P2 =  Dict-_test_Rem_RoundHalfUp_N3_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 2) ~ N 1)-_test_Rem_RoundHalfUp_N3_P2 =  Dict-_test_Div_RoundHalfUp_N3_P3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfUp_N3_P3 =  Dict-_test_Rem_RoundHalfUp_N3_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfUp_N3_P3 =  Dict-_test_Div_RoundHalfUp_N3_P4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfUp_N3_P4 =  Dict-_test_Rem_RoundHalfUp_N3_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfUp_N3_P4 =  Dict-_test_Div_RoundHalfUp_N4_N1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfUp_N4_N1 =  Dict-_test_Rem_RoundHalfUp_N4_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_N4_N1 =  Dict-_test_Div_RoundHalfUp_N4_N2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfUp_N4_N2 =  Dict-_test_Rem_RoundHalfUp_N4_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfUp_N4_N2 =  Dict-_test_Div_RoundHalfUp_N4_N3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfUp_N4_N3 =  Dict-_test_Rem_RoundHalfUp_N4_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfUp_N4_N3 =  Dict-_test_Div_RoundHalfUp_N4_N4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfUp_N4_N4 =  Dict-_test_Rem_RoundHalfUp_N4_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfUp_N4_N4 =  Dict-_test_Div_RoundHalfUp_N4_P1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfUp_N4_P1 =  Dict-_test_Rem_RoundHalfUp_N4_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_N4_P1 =  Dict-_test_Div_RoundHalfUp_N4_P2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfUp_N4_P2 =  Dict-_test_Rem_RoundHalfUp_N4_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfUp_N4_P2 =  Dict-_test_Div_RoundHalfUp_N4_P3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfUp_N4_P3 =  Dict-_test_Rem_RoundHalfUp_N4_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfUp_N4_P3 =  Dict-_test_Div_RoundHalfUp_N4_P4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfUp_N4_P4 =  Dict-_test_Rem_RoundHalfUp_N4_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfUp_N4_P4 =  Dict-_test_Div_RoundHalfUp_P0_N1 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfUp_P0_N1 =  Dict-_test_Rem_RoundHalfUp_P0_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_P0_N1 =  Dict-_test_Div_RoundHalfUp_P0_N2 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfUp_P0_N2 =  Dict-_test_Rem_RoundHalfUp_P0_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfUp_P0_N2 =  Dict-_test_Div_RoundHalfUp_P0_N3 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfUp_P0_N3 =  Dict-_test_Rem_RoundHalfUp_P0_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfUp_P0_N3 =  Dict-_test_Div_RoundHalfUp_P0_N4 :: Dict (K.Div 'K.RoundHalfUp (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfUp_P0_N4 =  Dict-_test_Rem_RoundHalfUp_P0_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfUp_P0_N4 =  Dict-_test_Div_RoundHalfUp_P0_P1 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfUp_P0_P1 =  Dict-_test_Rem_RoundHalfUp_P0_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_P0_P1 =  Dict-_test_Div_RoundHalfUp_P0_P2 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfUp_P0_P2 =  Dict-_test_Rem_RoundHalfUp_P0_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfUp_P0_P2 =  Dict-_test_Div_RoundHalfUp_P0_P3 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfUp_P0_P3 =  Dict-_test_Rem_RoundHalfUp_P0_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfUp_P0_P3 =  Dict-_test_Div_RoundHalfUp_P0_P4 :: Dict (K.Div 'K.RoundHalfUp (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfUp_P0_P4 =  Dict-_test_Rem_RoundHalfUp_P0_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfUp_P0_P4 =  Dict-_test_Div_RoundHalfUp_P1_N1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfUp_P1_N1 =  Dict-_test_Rem_RoundHalfUp_P1_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_P1_N1 =  Dict-_test_Div_RoundHalfUp_P1_N2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 2) ~ P 0)-_test_Div_RoundHalfUp_P1_N2 =  Dict-_test_Rem_RoundHalfUp_P1_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 2) ~ P 1)-_test_Rem_RoundHalfUp_P1_N2 =  Dict-_test_Div_RoundHalfUp_P1_N3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfUp_P1_N3 =  Dict-_test_Rem_RoundHalfUp_P1_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfUp_P1_N3 =  Dict-_test_Div_RoundHalfUp_P1_N4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfUp_P1_N4 =  Dict-_test_Rem_RoundHalfUp_P1_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfUp_P1_N4 =  Dict-_test_Div_RoundHalfUp_P1_P1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfUp_P1_P1 =  Dict-_test_Rem_RoundHalfUp_P1_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_P1_P1 =  Dict-_test_Div_RoundHalfUp_P1_P2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 2) ~ P 1)-_test_Div_RoundHalfUp_P1_P2 =  Dict-_test_Rem_RoundHalfUp_P1_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 2) ~ N 1)-_test_Rem_RoundHalfUp_P1_P2 =  Dict-_test_Div_RoundHalfUp_P1_P3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfUp_P1_P3 =  Dict-_test_Rem_RoundHalfUp_P1_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfUp_P1_P3 =  Dict-_test_Div_RoundHalfUp_P1_P4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfUp_P1_P4 =  Dict-_test_Rem_RoundHalfUp_P1_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfUp_P1_P4 =  Dict-_test_Div_RoundHalfUp_P2_N1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfUp_P2_N1 =  Dict-_test_Rem_RoundHalfUp_P2_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_P2_N1 =  Dict-_test_Div_RoundHalfUp_P2_N2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfUp_P2_N2 =  Dict-_test_Rem_RoundHalfUp_P2_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfUp_P2_N2 =  Dict-_test_Div_RoundHalfUp_P2_N3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfUp_P2_N3 =  Dict-_test_Rem_RoundHalfUp_P2_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfUp_P2_N3 =  Dict-_test_Div_RoundHalfUp_P2_N4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 4) ~ P 0)-_test_Div_RoundHalfUp_P2_N4 =  Dict-_test_Rem_RoundHalfUp_P2_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 4) ~ P 2)-_test_Rem_RoundHalfUp_P2_N4 =  Dict-_test_Div_RoundHalfUp_P2_P1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfUp_P2_P1 =  Dict-_test_Rem_RoundHalfUp_P2_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_P2_P1 =  Dict-_test_Div_RoundHalfUp_P2_P2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfUp_P2_P2 =  Dict-_test_Rem_RoundHalfUp_P2_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfUp_P2_P2 =  Dict-_test_Div_RoundHalfUp_P2_P3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfUp_P2_P3 =  Dict-_test_Rem_RoundHalfUp_P2_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfUp_P2_P3 =  Dict-_test_Div_RoundHalfUp_P2_P4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 4) ~ P 1)-_test_Div_RoundHalfUp_P2_P4 =  Dict-_test_Rem_RoundHalfUp_P2_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 4) ~ N 2)-_test_Rem_RoundHalfUp_P2_P4 =  Dict-_test_Div_RoundHalfUp_P3_N1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfUp_P3_N1 =  Dict-_test_Rem_RoundHalfUp_P3_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_P3_N1 =  Dict-_test_Div_RoundHalfUp_P3_N2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 2) ~ N 1)-_test_Div_RoundHalfUp_P3_N2 =  Dict-_test_Rem_RoundHalfUp_P3_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 2) ~ P 1)-_test_Rem_RoundHalfUp_P3_N2 =  Dict-_test_Div_RoundHalfUp_P3_N3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfUp_P3_N3 =  Dict-_test_Rem_RoundHalfUp_P3_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfUp_P3_N3 =  Dict-_test_Div_RoundHalfUp_P3_N4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfUp_P3_N4 =  Dict-_test_Rem_RoundHalfUp_P3_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfUp_P3_N4 =  Dict-_test_Div_RoundHalfUp_P3_P1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfUp_P3_P1 =  Dict-_test_Rem_RoundHalfUp_P3_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_P3_P1 =  Dict-_test_Div_RoundHalfUp_P3_P2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 2) ~ P 2)-_test_Div_RoundHalfUp_P3_P2 =  Dict-_test_Rem_RoundHalfUp_P3_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 2) ~ N 1)-_test_Rem_RoundHalfUp_P3_P2 =  Dict-_test_Div_RoundHalfUp_P3_P3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfUp_P3_P3 =  Dict-_test_Rem_RoundHalfUp_P3_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfUp_P3_P3 =  Dict-_test_Div_RoundHalfUp_P3_P4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfUp_P3_P4 =  Dict-_test_Rem_RoundHalfUp_P3_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfUp_P3_P4 =  Dict-_test_Div_RoundHalfUp_P4_N1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfUp_P4_N1 =  Dict-_test_Rem_RoundHalfUp_P4_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfUp_P4_N1 =  Dict-_test_Div_RoundHalfUp_P4_N2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfUp_P4_N2 =  Dict-_test_Rem_RoundHalfUp_P4_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfUp_P4_N2 =  Dict-_test_Div_RoundHalfUp_P4_N3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfUp_P4_N3 =  Dict-_test_Rem_RoundHalfUp_P4_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfUp_P4_N3 =  Dict-_test_Div_RoundHalfUp_P4_N4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfUp_P4_N4 =  Dict-_test_Rem_RoundHalfUp_P4_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfUp_P4_N4 =  Dict-_test_Div_RoundHalfUp_P4_P1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfUp_P4_P1 =  Dict-_test_Rem_RoundHalfUp_P4_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfUp_P4_P1 =  Dict-_test_Div_RoundHalfUp_P4_P2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfUp_P4_P2 =  Dict-_test_Rem_RoundHalfUp_P4_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfUp_P4_P2 =  Dict-_test_Div_RoundHalfUp_P4_P3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfUp_P4_P3 =  Dict-_test_Rem_RoundHalfUp_P4_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfUp_P4_P3 =  Dict-_test_Div_RoundHalfUp_P4_P4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfUp_P4_P4 =  Dict-_test_Rem_RoundHalfUp_P4_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfUp_P4_P4 =  Dict-_test_Div_RoundHalfZero_N1_N1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 1) ~ P 1)-_test_Div_RoundHalfZero_N1_N1 =  Dict-_test_Rem_RoundHalfZero_N1_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_N1_N1 =  Dict-_test_Div_RoundHalfZero_N1_N2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 2) ~ P 0)-_test_Div_RoundHalfZero_N1_N2 =  Dict-_test_Rem_RoundHalfZero_N1_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 2) ~ N 1)-_test_Rem_RoundHalfZero_N1_N2 =  Dict-_test_Div_RoundHalfZero_N1_N3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 3) ~ P 0)-_test_Div_RoundHalfZero_N1_N3 =  Dict-_test_Rem_RoundHalfZero_N1_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 3) ~ N 1)-_test_Rem_RoundHalfZero_N1_N3 =  Dict-_test_Div_RoundHalfZero_N1_N4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 4) ~ P 0)-_test_Div_RoundHalfZero_N1_N4 =  Dict-_test_Rem_RoundHalfZero_N1_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 4) ~ N 1)-_test_Rem_RoundHalfZero_N1_N4 =  Dict-_test_Div_RoundHalfZero_N1_P1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 1) ~ N 1)-_test_Div_RoundHalfZero_N1_P1 =  Dict-_test_Rem_RoundHalfZero_N1_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_N1_P1 =  Dict-_test_Div_RoundHalfZero_N1_P2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 2) ~ P 0)-_test_Div_RoundHalfZero_N1_P2 =  Dict-_test_Rem_RoundHalfZero_N1_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 2) ~ N 1)-_test_Rem_RoundHalfZero_N1_P2 =  Dict-_test_Div_RoundHalfZero_N1_P3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 3) ~ P 0)-_test_Div_RoundHalfZero_N1_P3 =  Dict-_test_Rem_RoundHalfZero_N1_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 3) ~ N 1)-_test_Rem_RoundHalfZero_N1_P3 =  Dict-_test_Div_RoundHalfZero_N1_P4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 4) ~ P 0)-_test_Div_RoundHalfZero_N1_P4 =  Dict-_test_Rem_RoundHalfZero_N1_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 4) ~ N 1)-_test_Rem_RoundHalfZero_N1_P4 =  Dict-_test_Div_RoundHalfZero_N2_N1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 1) ~ P 2)-_test_Div_RoundHalfZero_N2_N1 =  Dict-_test_Rem_RoundHalfZero_N2_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_N2_N1 =  Dict-_test_Div_RoundHalfZero_N2_N2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 2) ~ P 1)-_test_Div_RoundHalfZero_N2_N2 =  Dict-_test_Rem_RoundHalfZero_N2_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 2) ~ P 0)-_test_Rem_RoundHalfZero_N2_N2 =  Dict-_test_Div_RoundHalfZero_N2_N3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 3) ~ P 1)-_test_Div_RoundHalfZero_N2_N3 =  Dict-_test_Rem_RoundHalfZero_N2_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 3) ~ P 1)-_test_Rem_RoundHalfZero_N2_N3 =  Dict-_test_Div_RoundHalfZero_N2_N4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 4) ~ P 0)-_test_Div_RoundHalfZero_N2_N4 =  Dict-_test_Rem_RoundHalfZero_N2_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 4) ~ N 2)-_test_Rem_RoundHalfZero_N2_N4 =  Dict-_test_Div_RoundHalfZero_N2_P1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 1) ~ N 2)-_test_Div_RoundHalfZero_N2_P1 =  Dict-_test_Rem_RoundHalfZero_N2_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_N2_P1 =  Dict-_test_Div_RoundHalfZero_N2_P2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 2) ~ N 1)-_test_Div_RoundHalfZero_N2_P2 =  Dict-_test_Rem_RoundHalfZero_N2_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 2) ~ P 0)-_test_Rem_RoundHalfZero_N2_P2 =  Dict-_test_Div_RoundHalfZero_N2_P3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 3) ~ N 1)-_test_Div_RoundHalfZero_N2_P3 =  Dict-_test_Rem_RoundHalfZero_N2_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 3) ~ P 1)-_test_Rem_RoundHalfZero_N2_P3 =  Dict-_test_Div_RoundHalfZero_N2_P4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 4) ~ P 0)-_test_Div_RoundHalfZero_N2_P4 =  Dict-_test_Rem_RoundHalfZero_N2_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 4) ~ N 2)-_test_Rem_RoundHalfZero_N2_P4 =  Dict-_test_Div_RoundHalfZero_N3_N1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 1) ~ P 3)-_test_Div_RoundHalfZero_N3_N1 =  Dict-_test_Rem_RoundHalfZero_N3_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_N3_N1 =  Dict-_test_Div_RoundHalfZero_N3_N2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 2) ~ P 1)-_test_Div_RoundHalfZero_N3_N2 =  Dict-_test_Rem_RoundHalfZero_N3_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 2) ~ N 1)-_test_Rem_RoundHalfZero_N3_N2 =  Dict-_test_Div_RoundHalfZero_N3_N3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 3) ~ P 1)-_test_Div_RoundHalfZero_N3_N3 =  Dict-_test_Rem_RoundHalfZero_N3_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 3) ~ P 0)-_test_Rem_RoundHalfZero_N3_N3 =  Dict-_test_Div_RoundHalfZero_N3_N4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 4) ~ P 1)-_test_Div_RoundHalfZero_N3_N4 =  Dict-_test_Rem_RoundHalfZero_N3_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 4) ~ P 1)-_test_Rem_RoundHalfZero_N3_N4 =  Dict-_test_Div_RoundHalfZero_N3_P1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 1) ~ N 3)-_test_Div_RoundHalfZero_N3_P1 =  Dict-_test_Rem_RoundHalfZero_N3_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_N3_P1 =  Dict-_test_Div_RoundHalfZero_N3_P2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 2) ~ N 1)-_test_Div_RoundHalfZero_N3_P2 =  Dict-_test_Rem_RoundHalfZero_N3_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 2) ~ N 1)-_test_Rem_RoundHalfZero_N3_P2 =  Dict-_test_Div_RoundHalfZero_N3_P3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 3) ~ N 1)-_test_Div_RoundHalfZero_N3_P3 =  Dict-_test_Rem_RoundHalfZero_N3_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 3) ~ P 0)-_test_Rem_RoundHalfZero_N3_P3 =  Dict-_test_Div_RoundHalfZero_N3_P4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 4) ~ N 1)-_test_Div_RoundHalfZero_N3_P4 =  Dict-_test_Rem_RoundHalfZero_N3_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 4) ~ P 1)-_test_Rem_RoundHalfZero_N3_P4 =  Dict-_test_Div_RoundHalfZero_N4_N1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 1) ~ P 4)-_test_Div_RoundHalfZero_N4_N1 =  Dict-_test_Rem_RoundHalfZero_N4_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_N4_N1 =  Dict-_test_Div_RoundHalfZero_N4_N2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 2) ~ P 2)-_test_Div_RoundHalfZero_N4_N2 =  Dict-_test_Rem_RoundHalfZero_N4_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 2) ~ P 0)-_test_Rem_RoundHalfZero_N4_N2 =  Dict-_test_Div_RoundHalfZero_N4_N3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 3) ~ P 1)-_test_Div_RoundHalfZero_N4_N3 =  Dict-_test_Rem_RoundHalfZero_N4_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 3) ~ N 1)-_test_Rem_RoundHalfZero_N4_N3 =  Dict-_test_Div_RoundHalfZero_N4_N4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 4) ~ P 1)-_test_Div_RoundHalfZero_N4_N4 =  Dict-_test_Rem_RoundHalfZero_N4_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 4) ~ P 0)-_test_Rem_RoundHalfZero_N4_N4 =  Dict-_test_Div_RoundHalfZero_N4_P1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 1) ~ N 4)-_test_Div_RoundHalfZero_N4_P1 =  Dict-_test_Rem_RoundHalfZero_N4_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_N4_P1 =  Dict-_test_Div_RoundHalfZero_N4_P2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 2) ~ N 2)-_test_Div_RoundHalfZero_N4_P2 =  Dict-_test_Rem_RoundHalfZero_N4_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 2) ~ P 0)-_test_Rem_RoundHalfZero_N4_P2 =  Dict-_test_Div_RoundHalfZero_N4_P3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 3) ~ N 1)-_test_Div_RoundHalfZero_N4_P3 =  Dict-_test_Rem_RoundHalfZero_N4_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 3) ~ N 1)-_test_Rem_RoundHalfZero_N4_P3 =  Dict-_test_Div_RoundHalfZero_N4_P4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 4) ~ N 1)-_test_Div_RoundHalfZero_N4_P4 =  Dict-_test_Rem_RoundHalfZero_N4_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 4) ~ P 0)-_test_Rem_RoundHalfZero_N4_P4 =  Dict-_test_Div_RoundHalfZero_P0_N1 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 1) ~ P 0)-_test_Div_RoundHalfZero_P0_N1 =  Dict-_test_Rem_RoundHalfZero_P0_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_P0_N1 =  Dict-_test_Div_RoundHalfZero_P0_N2 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 2) ~ P 0)-_test_Div_RoundHalfZero_P0_N2 =  Dict-_test_Rem_RoundHalfZero_P0_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 2) ~ P 0)-_test_Rem_RoundHalfZero_P0_N2 =  Dict-_test_Div_RoundHalfZero_P0_N3 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 3) ~ P 0)-_test_Div_RoundHalfZero_P0_N3 =  Dict-_test_Rem_RoundHalfZero_P0_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 3) ~ P 0)-_test_Rem_RoundHalfZero_P0_N3 =  Dict-_test_Div_RoundHalfZero_P0_N4 :: Dict (K.Div 'K.RoundHalfZero (P 0) (N 4) ~ P 0)-_test_Div_RoundHalfZero_P0_N4 =  Dict-_test_Rem_RoundHalfZero_P0_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (N 4) ~ P 0)-_test_Rem_RoundHalfZero_P0_N4 =  Dict-_test_Div_RoundHalfZero_P0_P1 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 1) ~ P 0)-_test_Div_RoundHalfZero_P0_P1 =  Dict-_test_Rem_RoundHalfZero_P0_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_P0_P1 =  Dict-_test_Div_RoundHalfZero_P0_P2 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 2) ~ P 0)-_test_Div_RoundHalfZero_P0_P2 =  Dict-_test_Rem_RoundHalfZero_P0_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 2) ~ P 0)-_test_Rem_RoundHalfZero_P0_P2 =  Dict-_test_Div_RoundHalfZero_P0_P3 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 3) ~ P 0)-_test_Div_RoundHalfZero_P0_P3 =  Dict-_test_Rem_RoundHalfZero_P0_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 3) ~ P 0)-_test_Rem_RoundHalfZero_P0_P3 =  Dict-_test_Div_RoundHalfZero_P0_P4 :: Dict (K.Div 'K.RoundHalfZero (P 0) (P 4) ~ P 0)-_test_Div_RoundHalfZero_P0_P4 =  Dict-_test_Rem_RoundHalfZero_P0_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 0) (P 4) ~ P 0)-_test_Rem_RoundHalfZero_P0_P4 =  Dict-_test_Div_RoundHalfZero_P1_N1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 1) ~ N 1)-_test_Div_RoundHalfZero_P1_N1 =  Dict-_test_Rem_RoundHalfZero_P1_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_P1_N1 =  Dict-_test_Div_RoundHalfZero_P1_N2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 2) ~ P 0)-_test_Div_RoundHalfZero_P1_N2 =  Dict-_test_Rem_RoundHalfZero_P1_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 2) ~ P 1)-_test_Rem_RoundHalfZero_P1_N2 =  Dict-_test_Div_RoundHalfZero_P1_N3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 3) ~ P 0)-_test_Div_RoundHalfZero_P1_N3 =  Dict-_test_Rem_RoundHalfZero_P1_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 3) ~ P 1)-_test_Rem_RoundHalfZero_P1_N3 =  Dict-_test_Div_RoundHalfZero_P1_N4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 4) ~ P 0)-_test_Div_RoundHalfZero_P1_N4 =  Dict-_test_Rem_RoundHalfZero_P1_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 4) ~ P 1)-_test_Rem_RoundHalfZero_P1_N4 =  Dict-_test_Div_RoundHalfZero_P1_P1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 1) ~ P 1)-_test_Div_RoundHalfZero_P1_P1 =  Dict-_test_Rem_RoundHalfZero_P1_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_P1_P1 =  Dict-_test_Div_RoundHalfZero_P1_P2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 2) ~ P 0)-_test_Div_RoundHalfZero_P1_P2 =  Dict-_test_Rem_RoundHalfZero_P1_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 2) ~ P 1)-_test_Rem_RoundHalfZero_P1_P2 =  Dict-_test_Div_RoundHalfZero_P1_P3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 3) ~ P 0)-_test_Div_RoundHalfZero_P1_P3 =  Dict-_test_Rem_RoundHalfZero_P1_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 3) ~ P 1)-_test_Rem_RoundHalfZero_P1_P3 =  Dict-_test_Div_RoundHalfZero_P1_P4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 4) ~ P 0)-_test_Div_RoundHalfZero_P1_P4 =  Dict-_test_Rem_RoundHalfZero_P1_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 4) ~ P 1)-_test_Rem_RoundHalfZero_P1_P4 =  Dict-_test_Div_RoundHalfZero_P2_N1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 1) ~ N 2)-_test_Div_RoundHalfZero_P2_N1 =  Dict-_test_Rem_RoundHalfZero_P2_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_P2_N1 =  Dict-_test_Div_RoundHalfZero_P2_N2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 2) ~ N 1)-_test_Div_RoundHalfZero_P2_N2 =  Dict-_test_Rem_RoundHalfZero_P2_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 2) ~ P 0)-_test_Rem_RoundHalfZero_P2_N2 =  Dict-_test_Div_RoundHalfZero_P2_N3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 3) ~ N 1)-_test_Div_RoundHalfZero_P2_N3 =  Dict-_test_Rem_RoundHalfZero_P2_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 3) ~ N 1)-_test_Rem_RoundHalfZero_P2_N3 =  Dict-_test_Div_RoundHalfZero_P2_N4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 4) ~ P 0)-_test_Div_RoundHalfZero_P2_N4 =  Dict-_test_Rem_RoundHalfZero_P2_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 4) ~ P 2)-_test_Rem_RoundHalfZero_P2_N4 =  Dict-_test_Div_RoundHalfZero_P2_P1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 1) ~ P 2)-_test_Div_RoundHalfZero_P2_P1 =  Dict-_test_Rem_RoundHalfZero_P2_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_P2_P1 =  Dict-_test_Div_RoundHalfZero_P2_P2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 2) ~ P 1)-_test_Div_RoundHalfZero_P2_P2 =  Dict-_test_Rem_RoundHalfZero_P2_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 2) ~ P 0)-_test_Rem_RoundHalfZero_P2_P2 =  Dict-_test_Div_RoundHalfZero_P2_P3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 3) ~ P 1)-_test_Div_RoundHalfZero_P2_P3 =  Dict-_test_Rem_RoundHalfZero_P2_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 3) ~ N 1)-_test_Rem_RoundHalfZero_P2_P3 =  Dict-_test_Div_RoundHalfZero_P2_P4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 4) ~ P 0)-_test_Div_RoundHalfZero_P2_P4 =  Dict-_test_Rem_RoundHalfZero_P2_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 4) ~ P 2)-_test_Rem_RoundHalfZero_P2_P4 =  Dict-_test_Div_RoundHalfZero_P3_N1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 1) ~ N 3)-_test_Div_RoundHalfZero_P3_N1 =  Dict-_test_Rem_RoundHalfZero_P3_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_P3_N1 =  Dict-_test_Div_RoundHalfZero_P3_N2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 2) ~ N 1)-_test_Div_RoundHalfZero_P3_N2 =  Dict-_test_Rem_RoundHalfZero_P3_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 2) ~ P 1)-_test_Rem_RoundHalfZero_P3_N2 =  Dict-_test_Div_RoundHalfZero_P3_N3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 3) ~ N 1)-_test_Div_RoundHalfZero_P3_N3 =  Dict-_test_Rem_RoundHalfZero_P3_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 3) ~ P 0)-_test_Rem_RoundHalfZero_P3_N3 =  Dict-_test_Div_RoundHalfZero_P3_N4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 4) ~ N 1)-_test_Div_RoundHalfZero_P3_N4 =  Dict-_test_Rem_RoundHalfZero_P3_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 4) ~ N 1)-_test_Rem_RoundHalfZero_P3_N4 =  Dict-_test_Div_RoundHalfZero_P3_P1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 1) ~ P 3)-_test_Div_RoundHalfZero_P3_P1 =  Dict-_test_Rem_RoundHalfZero_P3_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_P3_P1 =  Dict-_test_Div_RoundHalfZero_P3_P2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 2) ~ P 1)-_test_Div_RoundHalfZero_P3_P2 =  Dict-_test_Rem_RoundHalfZero_P3_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 2) ~ P 1)-_test_Rem_RoundHalfZero_P3_P2 =  Dict-_test_Div_RoundHalfZero_P3_P3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 3) ~ P 1)-_test_Div_RoundHalfZero_P3_P3 =  Dict-_test_Rem_RoundHalfZero_P3_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 3) ~ P 0)-_test_Rem_RoundHalfZero_P3_P3 =  Dict-_test_Div_RoundHalfZero_P3_P4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 4) ~ P 1)-_test_Div_RoundHalfZero_P3_P4 =  Dict-_test_Rem_RoundHalfZero_P3_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 4) ~ N 1)-_test_Rem_RoundHalfZero_P3_P4 =  Dict-_test_Div_RoundHalfZero_P4_N1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 1) ~ N 4)-_test_Div_RoundHalfZero_P4_N1 =  Dict-_test_Rem_RoundHalfZero_P4_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 1) ~ P 0)-_test_Rem_RoundHalfZero_P4_N1 =  Dict-_test_Div_RoundHalfZero_P4_N2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 2) ~ N 2)-_test_Div_RoundHalfZero_P4_N2 =  Dict-_test_Rem_RoundHalfZero_P4_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 2) ~ P 0)-_test_Rem_RoundHalfZero_P4_N2 =  Dict-_test_Div_RoundHalfZero_P4_N3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 3) ~ N 1)-_test_Div_RoundHalfZero_P4_N3 =  Dict-_test_Rem_RoundHalfZero_P4_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 3) ~ P 1)-_test_Rem_RoundHalfZero_P4_N3 =  Dict-_test_Div_RoundHalfZero_P4_N4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 4) ~ N 1)-_test_Div_RoundHalfZero_P4_N4 =  Dict-_test_Rem_RoundHalfZero_P4_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 4) ~ P 0)-_test_Rem_RoundHalfZero_P4_N4 =  Dict-_test_Div_RoundHalfZero_P4_P1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 1) ~ P 4)-_test_Div_RoundHalfZero_P4_P1 =  Dict-_test_Rem_RoundHalfZero_P4_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 1) ~ P 0)-_test_Rem_RoundHalfZero_P4_P1 =  Dict-_test_Div_RoundHalfZero_P4_P2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 2) ~ P 2)-_test_Div_RoundHalfZero_P4_P2 =  Dict-_test_Rem_RoundHalfZero_P4_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 2) ~ P 0)-_test_Rem_RoundHalfZero_P4_P2 =  Dict-_test_Div_RoundHalfZero_P4_P3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 3) ~ P 1)-_test_Div_RoundHalfZero_P4_P3 =  Dict-_test_Rem_RoundHalfZero_P4_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 3) ~ P 1)-_test_Rem_RoundHalfZero_P4_P3 =  Dict-_test_Div_RoundHalfZero_P4_P4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 4) ~ P 1)-_test_Div_RoundHalfZero_P4_P4 =  Dict-_test_Rem_RoundHalfZero_P4_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 4) ~ P 0)-_test_Rem_RoundHalfZero_P4_P4 =  Dict-_test_Div_RoundUp_N1_N1 :: Dict (K.Div 'K.RoundUp (N 1) (N 1) ~ P 1)-_test_Div_RoundUp_N1_N1 =  Dict-_test_Rem_RoundUp_N1_N1 :: Dict (K.Rem 'K.RoundUp (N 1) (N 1) ~ P 0)-_test_Rem_RoundUp_N1_N1 =  Dict-_test_Div_RoundUp_N1_N2 :: Dict (K.Div 'K.RoundUp (N 1) (N 2) ~ P 1)-_test_Div_RoundUp_N1_N2 =  Dict-_test_Rem_RoundUp_N1_N2 :: Dict (K.Rem 'K.RoundUp (N 1) (N 2) ~ P 1)-_test_Rem_RoundUp_N1_N2 =  Dict-_test_Div_RoundUp_N1_N3 :: Dict (K.Div 'K.RoundUp (N 1) (N 3) ~ P 1)-_test_Div_RoundUp_N1_N3 =  Dict-_test_Rem_RoundUp_N1_N3 :: Dict (K.Rem 'K.RoundUp (N 1) (N 3) ~ P 2)-_test_Rem_RoundUp_N1_N3 =  Dict-_test_Div_RoundUp_N1_N4 :: Dict (K.Div 'K.RoundUp (N 1) (N 4) ~ P 1)-_test_Div_RoundUp_N1_N4 =  Dict-_test_Rem_RoundUp_N1_N4 :: Dict (K.Rem 'K.RoundUp (N 1) (N 4) ~ P 3)-_test_Rem_RoundUp_N1_N4 =  Dict-_test_Div_RoundUp_N1_P1 :: Dict (K.Div 'K.RoundUp (N 1) (P 1) ~ N 1)-_test_Div_RoundUp_N1_P1 =  Dict-_test_Rem_RoundUp_N1_P1 :: Dict (K.Rem 'K.RoundUp (N 1) (P 1) ~ P 0)-_test_Rem_RoundUp_N1_P1 =  Dict-_test_Div_RoundUp_N1_P2 :: Dict (K.Div 'K.RoundUp (N 1) (P 2) ~ P 0)-_test_Div_RoundUp_N1_P2 =  Dict-_test_Rem_RoundUp_N1_P2 :: Dict (K.Rem 'K.RoundUp (N 1) (P 2) ~ N 1)-_test_Rem_RoundUp_N1_P2 =  Dict-_test_Div_RoundUp_N1_P3 :: Dict (K.Div 'K.RoundUp (N 1) (P 3) ~ P 0)-_test_Div_RoundUp_N1_P3 =  Dict-_test_Rem_RoundUp_N1_P3 :: Dict (K.Rem 'K.RoundUp (N 1) (P 3) ~ N 1)-_test_Rem_RoundUp_N1_P3 =  Dict-_test_Div_RoundUp_N1_P4 :: Dict (K.Div 'K.RoundUp (N 1) (P 4) ~ P 0)-_test_Div_RoundUp_N1_P4 =  Dict-_test_Rem_RoundUp_N1_P4 :: Dict (K.Rem 'K.RoundUp (N 1) (P 4) ~ N 1)-_test_Rem_RoundUp_N1_P4 =  Dict-_test_Div_RoundUp_N2_N1 :: Dict (K.Div 'K.RoundUp (N 2) (N 1) ~ P 2)-_test_Div_RoundUp_N2_N1 =  Dict-_test_Rem_RoundUp_N2_N1 :: Dict (K.Rem 'K.RoundUp (N 2) (N 1) ~ P 0)-_test_Rem_RoundUp_N2_N1 =  Dict-_test_Div_RoundUp_N2_N2 :: Dict (K.Div 'K.RoundUp (N 2) (N 2) ~ P 1)-_test_Div_RoundUp_N2_N2 =  Dict-_test_Rem_RoundUp_N2_N2 :: Dict (K.Rem 'K.RoundUp (N 2) (N 2) ~ P 0)-_test_Rem_RoundUp_N2_N2 =  Dict-_test_Div_RoundUp_N2_N3 :: Dict (K.Div 'K.RoundUp (N 2) (N 3) ~ P 1)-_test_Div_RoundUp_N2_N3 =  Dict-_test_Rem_RoundUp_N2_N3 :: Dict (K.Rem 'K.RoundUp (N 2) (N 3) ~ P 1)-_test_Rem_RoundUp_N2_N3 =  Dict-_test_Div_RoundUp_N2_N4 :: Dict (K.Div 'K.RoundUp (N 2) (N 4) ~ P 1)-_test_Div_RoundUp_N2_N4 =  Dict-_test_Rem_RoundUp_N2_N4 :: Dict (K.Rem 'K.RoundUp (N 2) (N 4) ~ P 2)-_test_Rem_RoundUp_N2_N4 =  Dict-_test_Div_RoundUp_N2_P1 :: Dict (K.Div 'K.RoundUp (N 2) (P 1) ~ N 2)-_test_Div_RoundUp_N2_P1 =  Dict-_test_Rem_RoundUp_N2_P1 :: Dict (K.Rem 'K.RoundUp (N 2) (P 1) ~ P 0)-_test_Rem_RoundUp_N2_P1 =  Dict-_test_Div_RoundUp_N2_P2 :: Dict (K.Div 'K.RoundUp (N 2) (P 2) ~ N 1)-_test_Div_RoundUp_N2_P2 =  Dict-_test_Rem_RoundUp_N2_P2 :: Dict (K.Rem 'K.RoundUp (N 2) (P 2) ~ P 0)-_test_Rem_RoundUp_N2_P2 =  Dict-_test_Div_RoundUp_N2_P3 :: Dict (K.Div 'K.RoundUp (N 2) (P 3) ~ P 0)-_test_Div_RoundUp_N2_P3 =  Dict-_test_Rem_RoundUp_N2_P3 :: Dict (K.Rem 'K.RoundUp (N 2) (P 3) ~ N 2)-_test_Rem_RoundUp_N2_P3 =  Dict-_test_Div_RoundUp_N2_P4 :: Dict (K.Div 'K.RoundUp (N 2) (P 4) ~ P 0)-_test_Div_RoundUp_N2_P4 =  Dict-_test_Rem_RoundUp_N2_P4 :: Dict (K.Rem 'K.RoundUp (N 2) (P 4) ~ N 2)-_test_Rem_RoundUp_N2_P4 =  Dict-_test_Div_RoundUp_N3_N1 :: Dict (K.Div 'K.RoundUp (N 3) (N 1) ~ P 3)-_test_Div_RoundUp_N3_N1 =  Dict-_test_Rem_RoundUp_N3_N1 :: Dict (K.Rem 'K.RoundUp (N 3) (N 1) ~ P 0)-_test_Rem_RoundUp_N3_N1 =  Dict-_test_Div_RoundUp_N3_N2 :: Dict (K.Div 'K.RoundUp (N 3) (N 2) ~ P 2)-_test_Div_RoundUp_N3_N2 =  Dict-_test_Rem_RoundUp_N3_N2 :: Dict (K.Rem 'K.RoundUp (N 3) (N 2) ~ P 1)-_test_Rem_RoundUp_N3_N2 =  Dict-_test_Div_RoundUp_N3_N3 :: Dict (K.Div 'K.RoundUp (N 3) (N 3) ~ P 1)-_test_Div_RoundUp_N3_N3 =  Dict-_test_Rem_RoundUp_N3_N3 :: Dict (K.Rem 'K.RoundUp (N 3) (N 3) ~ P 0)-_test_Rem_RoundUp_N3_N3 =  Dict-_test_Div_RoundUp_N3_N4 :: Dict (K.Div 'K.RoundUp (N 3) (N 4) ~ P 1)-_test_Div_RoundUp_N3_N4 =  Dict-_test_Rem_RoundUp_N3_N4 :: Dict (K.Rem 'K.RoundUp (N 3) (N 4) ~ P 1)-_test_Rem_RoundUp_N3_N4 =  Dict-_test_Div_RoundUp_N3_P1 :: Dict (K.Div 'K.RoundUp (N 3) (P 1) ~ N 3)-_test_Div_RoundUp_N3_P1 =  Dict-_test_Rem_RoundUp_N3_P1 :: Dict (K.Rem 'K.RoundUp (N 3) (P 1) ~ P 0)-_test_Rem_RoundUp_N3_P1 =  Dict-_test_Div_RoundUp_N3_P2 :: Dict (K.Div 'K.RoundUp (N 3) (P 2) ~ N 1)-_test_Div_RoundUp_N3_P2 =  Dict-_test_Rem_RoundUp_N3_P2 :: Dict (K.Rem 'K.RoundUp (N 3) (P 2) ~ N 1)-_test_Rem_RoundUp_N3_P2 =  Dict-_test_Div_RoundUp_N3_P3 :: Dict (K.Div 'K.RoundUp (N 3) (P 3) ~ N 1)-_test_Div_RoundUp_N3_P3 =  Dict-_test_Rem_RoundUp_N3_P3 :: Dict (K.Rem 'K.RoundUp (N 3) (P 3) ~ P 0)-_test_Rem_RoundUp_N3_P3 =  Dict-_test_Div_RoundUp_N3_P4 :: Dict (K.Div 'K.RoundUp (N 3) (P 4) ~ P 0)-_test_Div_RoundUp_N3_P4 =  Dict-_test_Rem_RoundUp_N3_P4 :: Dict (K.Rem 'K.RoundUp (N 3) (P 4) ~ N 3)-_test_Rem_RoundUp_N3_P4 =  Dict-_test_Div_RoundUp_N4_N1 :: Dict (K.Div 'K.RoundUp (N 4) (N 1) ~ P 4)-_test_Div_RoundUp_N4_N1 =  Dict-_test_Rem_RoundUp_N4_N1 :: Dict (K.Rem 'K.RoundUp (N 4) (N 1) ~ P 0)-_test_Rem_RoundUp_N4_N1 =  Dict-_test_Div_RoundUp_N4_N2 :: Dict (K.Div 'K.RoundUp (N 4) (N 2) ~ P 2)-_test_Div_RoundUp_N4_N2 =  Dict-_test_Rem_RoundUp_N4_N2 :: Dict (K.Rem 'K.RoundUp (N 4) (N 2) ~ P 0)-_test_Rem_RoundUp_N4_N2 =  Dict-_test_Div_RoundUp_N4_N3 :: Dict (K.Div 'K.RoundUp (N 4) (N 3) ~ P 2)-_test_Div_RoundUp_N4_N3 =  Dict-_test_Rem_RoundUp_N4_N3 :: Dict (K.Rem 'K.RoundUp (N 4) (N 3) ~ P 2)-_test_Rem_RoundUp_N4_N3 =  Dict-_test_Div_RoundUp_N4_N4 :: Dict (K.Div 'K.RoundUp (N 4) (N 4) ~ P 1)-_test_Div_RoundUp_N4_N4 =  Dict-_test_Rem_RoundUp_N4_N4 :: Dict (K.Rem 'K.RoundUp (N 4) (N 4) ~ P 0)-_test_Rem_RoundUp_N4_N4 =  Dict-_test_Div_RoundUp_N4_P1 :: Dict (K.Div 'K.RoundUp (N 4) (P 1) ~ N 4)-_test_Div_RoundUp_N4_P1 =  Dict-_test_Rem_RoundUp_N4_P1 :: Dict (K.Rem 'K.RoundUp (N 4) (P 1) ~ P 0)-_test_Rem_RoundUp_N4_P1 =  Dict-_test_Div_RoundUp_N4_P2 :: Dict (K.Div 'K.RoundUp (N 4) (P 2) ~ N 2)-_test_Div_RoundUp_N4_P2 =  Dict-_test_Rem_RoundUp_N4_P2 :: Dict (K.Rem 'K.RoundUp (N 4) (P 2) ~ P 0)-_test_Rem_RoundUp_N4_P2 =  Dict-_test_Div_RoundUp_N4_P3 :: Dict (K.Div 'K.RoundUp (N 4) (P 3) ~ N 1)-_test_Div_RoundUp_N4_P3 =  Dict-_test_Rem_RoundUp_N4_P3 :: Dict (K.Rem 'K.RoundUp (N 4) (P 3) ~ N 1)-_test_Rem_RoundUp_N4_P3 =  Dict-_test_Div_RoundUp_N4_P4 :: Dict (K.Div 'K.RoundUp (N 4) (P 4) ~ N 1)-_test_Div_RoundUp_N4_P4 =  Dict-_test_Rem_RoundUp_N4_P4 :: Dict (K.Rem 'K.RoundUp (N 4) (P 4) ~ P 0)-_test_Rem_RoundUp_N4_P4 =  Dict-_test_Div_RoundUp_P0_N1 :: Dict (K.Div 'K.RoundUp (P 0) (N 1) ~ P 0)-_test_Div_RoundUp_P0_N1 =  Dict-_test_Rem_RoundUp_P0_N1 :: Dict (K.Rem 'K.RoundUp (P 0) (N 1) ~ P 0)-_test_Rem_RoundUp_P0_N1 =  Dict-_test_Div_RoundUp_P0_N2 :: Dict (K.Div 'K.RoundUp (P 0) (N 2) ~ P 0)-_test_Div_RoundUp_P0_N2 =  Dict-_test_Rem_RoundUp_P0_N2 :: Dict (K.Rem 'K.RoundUp (P 0) (N 2) ~ P 0)-_test_Rem_RoundUp_P0_N2 =  Dict-_test_Div_RoundUp_P0_N3 :: Dict (K.Div 'K.RoundUp (P 0) (N 3) ~ P 0)-_test_Div_RoundUp_P0_N3 =  Dict-_test_Rem_RoundUp_P0_N3 :: Dict (K.Rem 'K.RoundUp (P 0) (N 3) ~ P 0)-_test_Rem_RoundUp_P0_N3 =  Dict-_test_Div_RoundUp_P0_N4 :: Dict (K.Div 'K.RoundUp (P 0) (N 4) ~ P 0)-_test_Div_RoundUp_P0_N4 =  Dict-_test_Rem_RoundUp_P0_N4 :: Dict (K.Rem 'K.RoundUp (P 0) (N 4) ~ P 0)-_test_Rem_RoundUp_P0_N4 =  Dict-_test_Div_RoundUp_P0_P1 :: Dict (K.Div 'K.RoundUp (P 0) (P 1) ~ P 0)-_test_Div_RoundUp_P0_P1 =  Dict-_test_Rem_RoundUp_P0_P1 :: Dict (K.Rem 'K.RoundUp (P 0) (P 1) ~ P 0)-_test_Rem_RoundUp_P0_P1 =  Dict-_test_Div_RoundUp_P0_P2 :: Dict (K.Div 'K.RoundUp (P 0) (P 2) ~ P 0)-_test_Div_RoundUp_P0_P2 =  Dict-_test_Rem_RoundUp_P0_P2 :: Dict (K.Rem 'K.RoundUp (P 0) (P 2) ~ P 0)-_test_Rem_RoundUp_P0_P2 =  Dict-_test_Div_RoundUp_P0_P3 :: Dict (K.Div 'K.RoundUp (P 0) (P 3) ~ P 0)-_test_Div_RoundUp_P0_P3 =  Dict-_test_Rem_RoundUp_P0_P3 :: Dict (K.Rem 'K.RoundUp (P 0) (P 3) ~ P 0)-_test_Rem_RoundUp_P0_P3 =  Dict-_test_Div_RoundUp_P0_P4 :: Dict (K.Div 'K.RoundUp (P 0) (P 4) ~ P 0)-_test_Div_RoundUp_P0_P4 =  Dict-_test_Rem_RoundUp_P0_P4 :: Dict (K.Rem 'K.RoundUp (P 0) (P 4) ~ P 0)-_test_Rem_RoundUp_P0_P4 =  Dict-_test_Div_RoundUp_P1_N1 :: Dict (K.Div 'K.RoundUp (P 1) (N 1) ~ N 1)-_test_Div_RoundUp_P1_N1 =  Dict-_test_Rem_RoundUp_P1_N1 :: Dict (K.Rem 'K.RoundUp (P 1) (N 1) ~ P 0)-_test_Rem_RoundUp_P1_N1 =  Dict-_test_Div_RoundUp_P1_N2 :: Dict (K.Div 'K.RoundUp (P 1) (N 2) ~ P 0)-_test_Div_RoundUp_P1_N2 =  Dict-_test_Rem_RoundUp_P1_N2 :: Dict (K.Rem 'K.RoundUp (P 1) (N 2) ~ P 1)-_test_Rem_RoundUp_P1_N2 =  Dict-_test_Div_RoundUp_P1_N3 :: Dict (K.Div 'K.RoundUp (P 1) (N 3) ~ P 0)-_test_Div_RoundUp_P1_N3 =  Dict-_test_Rem_RoundUp_P1_N3 :: Dict (K.Rem 'K.RoundUp (P 1) (N 3) ~ P 1)-_test_Rem_RoundUp_P1_N3 =  Dict-_test_Div_RoundUp_P1_N4 :: Dict (K.Div 'K.RoundUp (P 1) (N 4) ~ P 0)-_test_Div_RoundUp_P1_N4 =  Dict-_test_Rem_RoundUp_P1_N4 :: Dict (K.Rem 'K.RoundUp (P 1) (N 4) ~ P 1)-_test_Rem_RoundUp_P1_N4 =  Dict-_test_Div_RoundUp_P1_P1 :: Dict (K.Div 'K.RoundUp (P 1) (P 1) ~ P 1)-_test_Div_RoundUp_P1_P1 =  Dict-_test_Rem_RoundUp_P1_P1 :: Dict (K.Rem 'K.RoundUp (P 1) (P 1) ~ P 0)-_test_Rem_RoundUp_P1_P1 =  Dict-_test_Div_RoundUp_P1_P2 :: Dict (K.Div 'K.RoundUp (P 1) (P 2) ~ P 1)-_test_Div_RoundUp_P1_P2 =  Dict-_test_Rem_RoundUp_P1_P2 :: Dict (K.Rem 'K.RoundUp (P 1) (P 2) ~ N 1)-_test_Rem_RoundUp_P1_P2 =  Dict-_test_Div_RoundUp_P1_P3 :: Dict (K.Div 'K.RoundUp (P 1) (P 3) ~ P 1)-_test_Div_RoundUp_P1_P3 =  Dict-_test_Rem_RoundUp_P1_P3 :: Dict (K.Rem 'K.RoundUp (P 1) (P 3) ~ N 2)-_test_Rem_RoundUp_P1_P3 =  Dict-_test_Div_RoundUp_P1_P4 :: Dict (K.Div 'K.RoundUp (P 1) (P 4) ~ P 1)-_test_Div_RoundUp_P1_P4 =  Dict-_test_Rem_RoundUp_P1_P4 :: Dict (K.Rem 'K.RoundUp (P 1) (P 4) ~ N 3)-_test_Rem_RoundUp_P1_P4 =  Dict-_test_Div_RoundUp_P2_N1 :: Dict (K.Div 'K.RoundUp (P 2) (N 1) ~ N 2)-_test_Div_RoundUp_P2_N1 =  Dict-_test_Rem_RoundUp_P2_N1 :: Dict (K.Rem 'K.RoundUp (P 2) (N 1) ~ P 0)-_test_Rem_RoundUp_P2_N1 =  Dict-_test_Div_RoundUp_P2_N2 :: Dict (K.Div 'K.RoundUp (P 2) (N 2) ~ N 1)-_test_Div_RoundUp_P2_N2 =  Dict-_test_Rem_RoundUp_P2_N2 :: Dict (K.Rem 'K.RoundUp (P 2) (N 2) ~ P 0)-_test_Rem_RoundUp_P2_N2 =  Dict-_test_Div_RoundUp_P2_N3 :: Dict (K.Div 'K.RoundUp (P 2) (N 3) ~ P 0)-_test_Div_RoundUp_P2_N3 =  Dict-_test_Rem_RoundUp_P2_N3 :: Dict (K.Rem 'K.RoundUp (P 2) (N 3) ~ P 2)-_test_Rem_RoundUp_P2_N3 =  Dict-_test_Div_RoundUp_P2_N4 :: Dict (K.Div 'K.RoundUp (P 2) (N 4) ~ P 0)-_test_Div_RoundUp_P2_N4 =  Dict-_test_Rem_RoundUp_P2_N4 :: Dict (K.Rem 'K.RoundUp (P 2) (N 4) ~ P 2)-_test_Rem_RoundUp_P2_N4 =  Dict-_test_Div_RoundUp_P2_P1 :: Dict (K.Div 'K.RoundUp (P 2) (P 1) ~ P 2)-_test_Div_RoundUp_P2_P1 =  Dict-_test_Rem_RoundUp_P2_P1 :: Dict (K.Rem 'K.RoundUp (P 2) (P 1) ~ P 0)-_test_Rem_RoundUp_P2_P1 =  Dict-_test_Div_RoundUp_P2_P2 :: Dict (K.Div 'K.RoundUp (P 2) (P 2) ~ P 1)-_test_Div_RoundUp_P2_P2 =  Dict-_test_Rem_RoundUp_P2_P2 :: Dict (K.Rem 'K.RoundUp (P 2) (P 2) ~ P 0)-_test_Rem_RoundUp_P2_P2 =  Dict-_test_Div_RoundUp_P2_P3 :: Dict (K.Div 'K.RoundUp (P 2) (P 3) ~ P 1)-_test_Div_RoundUp_P2_P3 =  Dict-_test_Rem_RoundUp_P2_P3 :: Dict (K.Rem 'K.RoundUp (P 2) (P 3) ~ N 1)-_test_Rem_RoundUp_P2_P3 =  Dict-_test_Div_RoundUp_P2_P4 :: Dict (K.Div 'K.RoundUp (P 2) (P 4) ~ P 1)-_test_Div_RoundUp_P2_P4 =  Dict-_test_Rem_RoundUp_P2_P4 :: Dict (K.Rem 'K.RoundUp (P 2) (P 4) ~ N 2)-_test_Rem_RoundUp_P2_P4 =  Dict-_test_Div_RoundUp_P3_N1 :: Dict (K.Div 'K.RoundUp (P 3) (N 1) ~ N 3)-_test_Div_RoundUp_P3_N1 =  Dict-_test_Rem_RoundUp_P3_N1 :: Dict (K.Rem 'K.RoundUp (P 3) (N 1) ~ P 0)-_test_Rem_RoundUp_P3_N1 =  Dict-_test_Div_RoundUp_P3_N2 :: Dict (K.Div 'K.RoundUp (P 3) (N 2) ~ N 1)-_test_Div_RoundUp_P3_N2 =  Dict-_test_Rem_RoundUp_P3_N2 :: Dict (K.Rem 'K.RoundUp (P 3) (N 2) ~ P 1)-_test_Rem_RoundUp_P3_N2 =  Dict-_test_Div_RoundUp_P3_N3 :: Dict (K.Div 'K.RoundUp (P 3) (N 3) ~ N 1)-_test_Div_RoundUp_P3_N3 =  Dict-_test_Rem_RoundUp_P3_N3 :: Dict (K.Rem 'K.RoundUp (P 3) (N 3) ~ P 0)-_test_Rem_RoundUp_P3_N3 =  Dict-_test_Div_RoundUp_P3_N4 :: Dict (K.Div 'K.RoundUp (P 3) (N 4) ~ P 0)-_test_Div_RoundUp_P3_N4 =  Dict-_test_Rem_RoundUp_P3_N4 :: Dict (K.Rem 'K.RoundUp (P 3) (N 4) ~ P 3)-_test_Rem_RoundUp_P3_N4 =  Dict-_test_Div_RoundUp_P3_P1 :: Dict (K.Div 'K.RoundUp (P 3) (P 1) ~ P 3)-_test_Div_RoundUp_P3_P1 =  Dict-_test_Rem_RoundUp_P3_P1 :: Dict (K.Rem 'K.RoundUp (P 3) (P 1) ~ P 0)-_test_Rem_RoundUp_P3_P1 =  Dict-_test_Div_RoundUp_P3_P2 :: Dict (K.Div 'K.RoundUp (P 3) (P 2) ~ P 2)-_test_Div_RoundUp_P3_P2 =  Dict-_test_Rem_RoundUp_P3_P2 :: Dict (K.Rem 'K.RoundUp (P 3) (P 2) ~ N 1)-_test_Rem_RoundUp_P3_P2 =  Dict-_test_Div_RoundUp_P3_P3 :: Dict (K.Div 'K.RoundUp (P 3) (P 3) ~ P 1)-_test_Div_RoundUp_P3_P3 =  Dict-_test_Rem_RoundUp_P3_P3 :: Dict (K.Rem 'K.RoundUp (P 3) (P 3) ~ P 0)-_test_Rem_RoundUp_P3_P3 =  Dict-_test_Div_RoundUp_P3_P4 :: Dict (K.Div 'K.RoundUp (P 3) (P 4) ~ P 1)-_test_Div_RoundUp_P3_P4 =  Dict-_test_Rem_RoundUp_P3_P4 :: Dict (K.Rem 'K.RoundUp (P 3) (P 4) ~ N 1)-_test_Rem_RoundUp_P3_P4 =  Dict-_test_Div_RoundUp_P4_N1 :: Dict (K.Div 'K.RoundUp (P 4) (N 1) ~ N 4)-_test_Div_RoundUp_P4_N1 =  Dict-_test_Rem_RoundUp_P4_N1 :: Dict (K.Rem 'K.RoundUp (P 4) (N 1) ~ P 0)-_test_Rem_RoundUp_P4_N1 =  Dict-_test_Div_RoundUp_P4_N2 :: Dict (K.Div 'K.RoundUp (P 4) (N 2) ~ N 2)-_test_Div_RoundUp_P4_N2 =  Dict-_test_Rem_RoundUp_P4_N2 :: Dict (K.Rem 'K.RoundUp (P 4) (N 2) ~ P 0)-_test_Rem_RoundUp_P4_N2 =  Dict-_test_Div_RoundUp_P4_N3 :: Dict (K.Div 'K.RoundUp (P 4) (N 3) ~ N 1)-_test_Div_RoundUp_P4_N3 =  Dict-_test_Rem_RoundUp_P4_N3 :: Dict (K.Rem 'K.RoundUp (P 4) (N 3) ~ P 1)-_test_Rem_RoundUp_P4_N3 =  Dict-_test_Div_RoundUp_P4_N4 :: Dict (K.Div 'K.RoundUp (P 4) (N 4) ~ N 1)-_test_Div_RoundUp_P4_N4 =  Dict-_test_Rem_RoundUp_P4_N4 :: Dict (K.Rem 'K.RoundUp (P 4) (N 4) ~ P 0)-_test_Rem_RoundUp_P4_N4 =  Dict-_test_Div_RoundUp_P4_P1 :: Dict (K.Div 'K.RoundUp (P 4) (P 1) ~ P 4)-_test_Div_RoundUp_P4_P1 =  Dict-_test_Rem_RoundUp_P4_P1 :: Dict (K.Rem 'K.RoundUp (P 4) (P 1) ~ P 0)-_test_Rem_RoundUp_P4_P1 =  Dict-_test_Div_RoundUp_P4_P2 :: Dict (K.Div 'K.RoundUp (P 4) (P 2) ~ P 2)-_test_Div_RoundUp_P4_P2 =  Dict-_test_Rem_RoundUp_P4_P2 :: Dict (K.Rem 'K.RoundUp (P 4) (P 2) ~ P 0)-_test_Rem_RoundUp_P4_P2 =  Dict-_test_Div_RoundUp_P4_P3 :: Dict (K.Div 'K.RoundUp (P 4) (P 3) ~ P 2)-_test_Div_RoundUp_P4_P3 =  Dict-_test_Rem_RoundUp_P4_P3 :: Dict (K.Rem 'K.RoundUp (P 4) (P 3) ~ N 2)-_test_Rem_RoundUp_P4_P3 =  Dict-_test_Div_RoundUp_P4_P4 :: Dict (K.Div 'K.RoundUp (P 4) (P 4) ~ P 1)-_test_Div_RoundUp_P4_P4 =  Dict-_test_Rem_RoundUp_P4_P4 :: Dict (K.Rem 'K.RoundUp (P 4) (P 4) ~ P 0)-_test_Rem_RoundUp_P4_P4 =  Dict-_test_Div_RoundZero_N1_N1 :: Dict (K.Div 'K.RoundZero (N 1) (N 1) ~ P 1)-_test_Div_RoundZero_N1_N1 =  Dict-_test_Rem_RoundZero_N1_N1 :: Dict (K.Rem 'K.RoundZero (N 1) (N 1) ~ P 0)-_test_Rem_RoundZero_N1_N1 =  Dict-_test_Div_RoundZero_N1_N2 :: Dict (K.Div 'K.RoundZero (N 1) (N 2) ~ P 0)-_test_Div_RoundZero_N1_N2 =  Dict-_test_Rem_RoundZero_N1_N2 :: Dict (K.Rem 'K.RoundZero (N 1) (N 2) ~ N 1)-_test_Rem_RoundZero_N1_N2 =  Dict-_test_Div_RoundZero_N1_N3 :: Dict (K.Div 'K.RoundZero (N 1) (N 3) ~ P 0)-_test_Div_RoundZero_N1_N3 =  Dict-_test_Rem_RoundZero_N1_N3 :: Dict (K.Rem 'K.RoundZero (N 1) (N 3) ~ N 1)-_test_Rem_RoundZero_N1_N3 =  Dict-_test_Div_RoundZero_N1_N4 :: Dict (K.Div 'K.RoundZero (N 1) (N 4) ~ P 0)-_test_Div_RoundZero_N1_N4 =  Dict-_test_Rem_RoundZero_N1_N4 :: Dict (K.Rem 'K.RoundZero (N 1) (N 4) ~ N 1)-_test_Rem_RoundZero_N1_N4 =  Dict-_test_Div_RoundZero_N1_P1 :: Dict (K.Div 'K.RoundZero (N 1) (P 1) ~ N 1)-_test_Div_RoundZero_N1_P1 =  Dict-_test_Rem_RoundZero_N1_P1 :: Dict (K.Rem 'K.RoundZero (N 1) (P 1) ~ P 0)-_test_Rem_RoundZero_N1_P1 =  Dict-_test_Div_RoundZero_N1_P2 :: Dict (K.Div 'K.RoundZero (N 1) (P 2) ~ P 0)-_test_Div_RoundZero_N1_P2 =  Dict-_test_Rem_RoundZero_N1_P2 :: Dict (K.Rem 'K.RoundZero (N 1) (P 2) ~ N 1)-_test_Rem_RoundZero_N1_P2 =  Dict-_test_Div_RoundZero_N1_P3 :: Dict (K.Div 'K.RoundZero (N 1) (P 3) ~ P 0)-_test_Div_RoundZero_N1_P3 =  Dict-_test_Rem_RoundZero_N1_P3 :: Dict (K.Rem 'K.RoundZero (N 1) (P 3) ~ N 1)-_test_Rem_RoundZero_N1_P3 =  Dict-_test_Div_RoundZero_N1_P4 :: Dict (K.Div 'K.RoundZero (N 1) (P 4) ~ P 0)-_test_Div_RoundZero_N1_P4 =  Dict-_test_Rem_RoundZero_N1_P4 :: Dict (K.Rem 'K.RoundZero (N 1) (P 4) ~ N 1)-_test_Rem_RoundZero_N1_P4 =  Dict-_test_Div_RoundZero_N2_N1 :: Dict (K.Div 'K.RoundZero (N 2) (N 1) ~ P 2)-_test_Div_RoundZero_N2_N1 =  Dict-_test_Rem_RoundZero_N2_N1 :: Dict (K.Rem 'K.RoundZero (N 2) (N 1) ~ P 0)-_test_Rem_RoundZero_N2_N1 =  Dict-_test_Div_RoundZero_N2_N2 :: Dict (K.Div 'K.RoundZero (N 2) (N 2) ~ P 1)-_test_Div_RoundZero_N2_N2 =  Dict-_test_Rem_RoundZero_N2_N2 :: Dict (K.Rem 'K.RoundZero (N 2) (N 2) ~ P 0)-_test_Rem_RoundZero_N2_N2 =  Dict-_test_Div_RoundZero_N2_N3 :: Dict (K.Div 'K.RoundZero (N 2) (N 3) ~ P 0)-_test_Div_RoundZero_N2_N3 =  Dict-_test_Rem_RoundZero_N2_N3 :: Dict (K.Rem 'K.RoundZero (N 2) (N 3) ~ N 2)-_test_Rem_RoundZero_N2_N3 =  Dict-_test_Div_RoundZero_N2_N4 :: Dict (K.Div 'K.RoundZero (N 2) (N 4) ~ P 0)-_test_Div_RoundZero_N2_N4 =  Dict-_test_Rem_RoundZero_N2_N4 :: Dict (K.Rem 'K.RoundZero (N 2) (N 4) ~ N 2)-_test_Rem_RoundZero_N2_N4 =  Dict-_test_Div_RoundZero_N2_P1 :: Dict (K.Div 'K.RoundZero (N 2) (P 1) ~ N 2)-_test_Div_RoundZero_N2_P1 =  Dict-_test_Rem_RoundZero_N2_P1 :: Dict (K.Rem 'K.RoundZero (N 2) (P 1) ~ P 0)-_test_Rem_RoundZero_N2_P1 =  Dict-_test_Div_RoundZero_N2_P2 :: Dict (K.Div 'K.RoundZero (N 2) (P 2) ~ N 1)-_test_Div_RoundZero_N2_P2 =  Dict-_test_Rem_RoundZero_N2_P2 :: Dict (K.Rem 'K.RoundZero (N 2) (P 2) ~ P 0)-_test_Rem_RoundZero_N2_P2 =  Dict-_test_Div_RoundZero_N2_P3 :: Dict (K.Div 'K.RoundZero (N 2) (P 3) ~ P 0)-_test_Div_RoundZero_N2_P3 =  Dict-_test_Rem_RoundZero_N2_P3 :: Dict (K.Rem 'K.RoundZero (N 2) (P 3) ~ N 2)-_test_Rem_RoundZero_N2_P3 =  Dict-_test_Div_RoundZero_N2_P4 :: Dict (K.Div 'K.RoundZero (N 2) (P 4) ~ P 0)-_test_Div_RoundZero_N2_P4 =  Dict-_test_Rem_RoundZero_N2_P4 :: Dict (K.Rem 'K.RoundZero (N 2) (P 4) ~ N 2)-_test_Rem_RoundZero_N2_P4 =  Dict-_test_Div_RoundZero_N3_N1 :: Dict (K.Div 'K.RoundZero (N 3) (N 1) ~ P 3)-_test_Div_RoundZero_N3_N1 =  Dict-_test_Rem_RoundZero_N3_N1 :: Dict (K.Rem 'K.RoundZero (N 3) (N 1) ~ P 0)-_test_Rem_RoundZero_N3_N1 =  Dict-_test_Div_RoundZero_N3_N2 :: Dict (K.Div 'K.RoundZero (N 3) (N 2) ~ P 1)-_test_Div_RoundZero_N3_N2 =  Dict-_test_Rem_RoundZero_N3_N2 :: Dict (K.Rem 'K.RoundZero (N 3) (N 2) ~ N 1)-_test_Rem_RoundZero_N3_N2 =  Dict-_test_Div_RoundZero_N3_N3 :: Dict (K.Div 'K.RoundZero (N 3) (N 3) ~ P 1)-_test_Div_RoundZero_N3_N3 =  Dict-_test_Rem_RoundZero_N3_N3 :: Dict (K.Rem 'K.RoundZero (N 3) (N 3) ~ P 0)-_test_Rem_RoundZero_N3_N3 =  Dict-_test_Div_RoundZero_N3_N4 :: Dict (K.Div 'K.RoundZero (N 3) (N 4) ~ P 0)-_test_Div_RoundZero_N3_N4 =  Dict-_test_Rem_RoundZero_N3_N4 :: Dict (K.Rem 'K.RoundZero (N 3) (N 4) ~ N 3)-_test_Rem_RoundZero_N3_N4 =  Dict-_test_Div_RoundZero_N3_P1 :: Dict (K.Div 'K.RoundZero (N 3) (P 1) ~ N 3)-_test_Div_RoundZero_N3_P1 =  Dict-_test_Rem_RoundZero_N3_P1 :: Dict (K.Rem 'K.RoundZero (N 3) (P 1) ~ P 0)-_test_Rem_RoundZero_N3_P1 =  Dict-_test_Div_RoundZero_N3_P2 :: Dict (K.Div 'K.RoundZero (N 3) (P 2) ~ N 1)-_test_Div_RoundZero_N3_P2 =  Dict-_test_Rem_RoundZero_N3_P2 :: Dict (K.Rem 'K.RoundZero (N 3) (P 2) ~ N 1)-_test_Rem_RoundZero_N3_P2 =  Dict-_test_Div_RoundZero_N3_P3 :: Dict (K.Div 'K.RoundZero (N 3) (P 3) ~ N 1)-_test_Div_RoundZero_N3_P3 =  Dict-_test_Rem_RoundZero_N3_P3 :: Dict (K.Rem 'K.RoundZero (N 3) (P 3) ~ P 0)-_test_Rem_RoundZero_N3_P3 =  Dict-_test_Div_RoundZero_N3_P4 :: Dict (K.Div 'K.RoundZero (N 3) (P 4) ~ P 0)-_test_Div_RoundZero_N3_P4 =  Dict-_test_Rem_RoundZero_N3_P4 :: Dict (K.Rem 'K.RoundZero (N 3) (P 4) ~ N 3)-_test_Rem_RoundZero_N3_P4 =  Dict-_test_Div_RoundZero_N4_N1 :: Dict (K.Div 'K.RoundZero (N 4) (N 1) ~ P 4)-_test_Div_RoundZero_N4_N1 =  Dict-_test_Rem_RoundZero_N4_N1 :: Dict (K.Rem 'K.RoundZero (N 4) (N 1) ~ P 0)-_test_Rem_RoundZero_N4_N1 =  Dict-_test_Div_RoundZero_N4_N2 :: Dict (K.Div 'K.RoundZero (N 4) (N 2) ~ P 2)-_test_Div_RoundZero_N4_N2 =  Dict-_test_Rem_RoundZero_N4_N2 :: Dict (K.Rem 'K.RoundZero (N 4) (N 2) ~ P 0)-_test_Rem_RoundZero_N4_N2 =  Dict-_test_Div_RoundZero_N4_N3 :: Dict (K.Div 'K.RoundZero (N 4) (N 3) ~ P 1)-_test_Div_RoundZero_N4_N3 =  Dict-_test_Rem_RoundZero_N4_N3 :: Dict (K.Rem 'K.RoundZero (N 4) (N 3) ~ N 1)-_test_Rem_RoundZero_N4_N3 =  Dict-_test_Div_RoundZero_N4_N4 :: Dict (K.Div 'K.RoundZero (N 4) (N 4) ~ P 1)-_test_Div_RoundZero_N4_N4 =  Dict-_test_Rem_RoundZero_N4_N4 :: Dict (K.Rem 'K.RoundZero (N 4) (N 4) ~ P 0)-_test_Rem_RoundZero_N4_N4 =  Dict-_test_Div_RoundZero_N4_P1 :: Dict (K.Div 'K.RoundZero (N 4) (P 1) ~ N 4)-_test_Div_RoundZero_N4_P1 =  Dict-_test_Rem_RoundZero_N4_P1 :: Dict (K.Rem 'K.RoundZero (N 4) (P 1) ~ P 0)-_test_Rem_RoundZero_N4_P1 =  Dict-_test_Div_RoundZero_N4_P2 :: Dict (K.Div 'K.RoundZero (N 4) (P 2) ~ N 2)-_test_Div_RoundZero_N4_P2 =  Dict-_test_Rem_RoundZero_N4_P2 :: Dict (K.Rem 'K.RoundZero (N 4) (P 2) ~ P 0)-_test_Rem_RoundZero_N4_P2 =  Dict-_test_Div_RoundZero_N4_P3 :: Dict (K.Div 'K.RoundZero (N 4) (P 3) ~ N 1)-_test_Div_RoundZero_N4_P3 =  Dict-_test_Rem_RoundZero_N4_P3 :: Dict (K.Rem 'K.RoundZero (N 4) (P 3) ~ N 1)-_test_Rem_RoundZero_N4_P3 =  Dict-_test_Div_RoundZero_N4_P4 :: Dict (K.Div 'K.RoundZero (N 4) (P 4) ~ N 1)-_test_Div_RoundZero_N4_P4 =  Dict-_test_Rem_RoundZero_N4_P4 :: Dict (K.Rem 'K.RoundZero (N 4) (P 4) ~ P 0)-_test_Rem_RoundZero_N4_P4 =  Dict-_test_Div_RoundZero_P0_N1 :: Dict (K.Div 'K.RoundZero (P 0) (N 1) ~ P 0)-_test_Div_RoundZero_P0_N1 =  Dict-_test_Rem_RoundZero_P0_N1 :: Dict (K.Rem 'K.RoundZero (P 0) (N 1) ~ P 0)-_test_Rem_RoundZero_P0_N1 =  Dict-_test_Div_RoundZero_P0_N2 :: Dict (K.Div 'K.RoundZero (P 0) (N 2) ~ P 0)-_test_Div_RoundZero_P0_N2 =  Dict-_test_Rem_RoundZero_P0_N2 :: Dict (K.Rem 'K.RoundZero (P 0) (N 2) ~ P 0)-_test_Rem_RoundZero_P0_N2 =  Dict-_test_Div_RoundZero_P0_N3 :: Dict (K.Div 'K.RoundZero (P 0) (N 3) ~ P 0)-_test_Div_RoundZero_P0_N3 =  Dict-_test_Rem_RoundZero_P0_N3 :: Dict (K.Rem 'K.RoundZero (P 0) (N 3) ~ P 0)-_test_Rem_RoundZero_P0_N3 =  Dict-_test_Div_RoundZero_P0_N4 :: Dict (K.Div 'K.RoundZero (P 0) (N 4) ~ P 0)-_test_Div_RoundZero_P0_N4 =  Dict-_test_Rem_RoundZero_P0_N4 :: Dict (K.Rem 'K.RoundZero (P 0) (N 4) ~ P 0)-_test_Rem_RoundZero_P0_N4 =  Dict-_test_Div_RoundZero_P0_P1 :: Dict (K.Div 'K.RoundZero (P 0) (P 1) ~ P 0)-_test_Div_RoundZero_P0_P1 =  Dict-_test_Rem_RoundZero_P0_P1 :: Dict (K.Rem 'K.RoundZero (P 0) (P 1) ~ P 0)-_test_Rem_RoundZero_P0_P1 =  Dict-_test_Div_RoundZero_P0_P2 :: Dict (K.Div 'K.RoundZero (P 0) (P 2) ~ P 0)-_test_Div_RoundZero_P0_P2 =  Dict-_test_Rem_RoundZero_P0_P2 :: Dict (K.Rem 'K.RoundZero (P 0) (P 2) ~ P 0)-_test_Rem_RoundZero_P0_P2 =  Dict-_test_Div_RoundZero_P0_P3 :: Dict (K.Div 'K.RoundZero (P 0) (P 3) ~ P 0)-_test_Div_RoundZero_P0_P3 =  Dict-_test_Rem_RoundZero_P0_P3 :: Dict (K.Rem 'K.RoundZero (P 0) (P 3) ~ P 0)-_test_Rem_RoundZero_P0_P3 =  Dict-_test_Div_RoundZero_P0_P4 :: Dict (K.Div 'K.RoundZero (P 0) (P 4) ~ P 0)-_test_Div_RoundZero_P0_P4 =  Dict-_test_Rem_RoundZero_P0_P4 :: Dict (K.Rem 'K.RoundZero (P 0) (P 4) ~ P 0)-_test_Rem_RoundZero_P0_P4 =  Dict-_test_Div_RoundZero_P1_N1 :: Dict (K.Div 'K.RoundZero (P 1) (N 1) ~ N 1)-_test_Div_RoundZero_P1_N1 =  Dict-_test_Rem_RoundZero_P1_N1 :: Dict (K.Rem 'K.RoundZero (P 1) (N 1) ~ P 0)-_test_Rem_RoundZero_P1_N1 =  Dict-_test_Div_RoundZero_P1_N2 :: Dict (K.Div 'K.RoundZero (P 1) (N 2) ~ P 0)-_test_Div_RoundZero_P1_N2 =  Dict-_test_Rem_RoundZero_P1_N2 :: Dict (K.Rem 'K.RoundZero (P 1) (N 2) ~ P 1)-_test_Rem_RoundZero_P1_N2 =  Dict-_test_Div_RoundZero_P1_N3 :: Dict (K.Div 'K.RoundZero (P 1) (N 3) ~ P 0)-_test_Div_RoundZero_P1_N3 =  Dict-_test_Rem_RoundZero_P1_N3 :: Dict (K.Rem 'K.RoundZero (P 1) (N 3) ~ P 1)-_test_Rem_RoundZero_P1_N3 =  Dict-_test_Div_RoundZero_P1_N4 :: Dict (K.Div 'K.RoundZero (P 1) (N 4) ~ P 0)-_test_Div_RoundZero_P1_N4 =  Dict-_test_Rem_RoundZero_P1_N4 :: Dict (K.Rem 'K.RoundZero (P 1) (N 4) ~ P 1)-_test_Rem_RoundZero_P1_N4 =  Dict-_test_Div_RoundZero_P1_P1 :: Dict (K.Div 'K.RoundZero (P 1) (P 1) ~ P 1)-_test_Div_RoundZero_P1_P1 =  Dict-_test_Rem_RoundZero_P1_P1 :: Dict (K.Rem 'K.RoundZero (P 1) (P 1) ~ P 0)-_test_Rem_RoundZero_P1_P1 =  Dict-_test_Div_RoundZero_P1_P2 :: Dict (K.Div 'K.RoundZero (P 1) (P 2) ~ P 0)-_test_Div_RoundZero_P1_P2 =  Dict-_test_Rem_RoundZero_P1_P2 :: Dict (K.Rem 'K.RoundZero (P 1) (P 2) ~ P 1)-_test_Rem_RoundZero_P1_P2 =  Dict-_test_Div_RoundZero_P1_P3 :: Dict (K.Div 'K.RoundZero (P 1) (P 3) ~ P 0)-_test_Div_RoundZero_P1_P3 =  Dict-_test_Rem_RoundZero_P1_P3 :: Dict (K.Rem 'K.RoundZero (P 1) (P 3) ~ P 1)-_test_Rem_RoundZero_P1_P3 =  Dict-_test_Div_RoundZero_P1_P4 :: Dict (K.Div 'K.RoundZero (P 1) (P 4) ~ P 0)-_test_Div_RoundZero_P1_P4 =  Dict-_test_Rem_RoundZero_P1_P4 :: Dict (K.Rem 'K.RoundZero (P 1) (P 4) ~ P 1)-_test_Rem_RoundZero_P1_P4 =  Dict-_test_Div_RoundZero_P2_N1 :: Dict (K.Div 'K.RoundZero (P 2) (N 1) ~ N 2)-_test_Div_RoundZero_P2_N1 =  Dict-_test_Rem_RoundZero_P2_N1 :: Dict (K.Rem 'K.RoundZero (P 2) (N 1) ~ P 0)-_test_Rem_RoundZero_P2_N1 =  Dict-_test_Div_RoundZero_P2_N2 :: Dict (K.Div 'K.RoundZero (P 2) (N 2) ~ N 1)-_test_Div_RoundZero_P2_N2 =  Dict-_test_Rem_RoundZero_P2_N2 :: Dict (K.Rem 'K.RoundZero (P 2) (N 2) ~ P 0)-_test_Rem_RoundZero_P2_N2 =  Dict-_test_Div_RoundZero_P2_N3 :: Dict (K.Div 'K.RoundZero (P 2) (N 3) ~ P 0)-_test_Div_RoundZero_P2_N3 =  Dict-_test_Rem_RoundZero_P2_N3 :: Dict (K.Rem 'K.RoundZero (P 2) (N 3) ~ P 2)-_test_Rem_RoundZero_P2_N3 =  Dict-_test_Div_RoundZero_P2_N4 :: Dict (K.Div 'K.RoundZero (P 2) (N 4) ~ P 0)-_test_Div_RoundZero_P2_N4 =  Dict-_test_Rem_RoundZero_P2_N4 :: Dict (K.Rem 'K.RoundZero (P 2) (N 4) ~ P 2)-_test_Rem_RoundZero_P2_N4 =  Dict-_test_Div_RoundZero_P2_P1 :: Dict (K.Div 'K.RoundZero (P 2) (P 1) ~ P 2)-_test_Div_RoundZero_P2_P1 =  Dict-_test_Rem_RoundZero_P2_P1 :: Dict (K.Rem 'K.RoundZero (P 2) (P 1) ~ P 0)-_test_Rem_RoundZero_P2_P1 =  Dict-_test_Div_RoundZero_P2_P2 :: Dict (K.Div 'K.RoundZero (P 2) (P 2) ~ P 1)-_test_Div_RoundZero_P2_P2 =  Dict-_test_Rem_RoundZero_P2_P2 :: Dict (K.Rem 'K.RoundZero (P 2) (P 2) ~ P 0)-_test_Rem_RoundZero_P2_P2 =  Dict-_test_Div_RoundZero_P2_P3 :: Dict (K.Div 'K.RoundZero (P 2) (P 3) ~ P 0)-_test_Div_RoundZero_P2_P3 =  Dict-_test_Rem_RoundZero_P2_P3 :: Dict (K.Rem 'K.RoundZero (P 2) (P 3) ~ P 2)-_test_Rem_RoundZero_P2_P3 =  Dict-_test_Div_RoundZero_P2_P4 :: Dict (K.Div 'K.RoundZero (P 2) (P 4) ~ P 0)-_test_Div_RoundZero_P2_P4 =  Dict-_test_Rem_RoundZero_P2_P4 :: Dict (K.Rem 'K.RoundZero (P 2) (P 4) ~ P 2)-_test_Rem_RoundZero_P2_P4 =  Dict-_test_Div_RoundZero_P3_N1 :: Dict (K.Div 'K.RoundZero (P 3) (N 1) ~ N 3)-_test_Div_RoundZero_P3_N1 =  Dict-_test_Rem_RoundZero_P3_N1 :: Dict (K.Rem 'K.RoundZero (P 3) (N 1) ~ P 0)-_test_Rem_RoundZero_P3_N1 =  Dict-_test_Div_RoundZero_P3_N2 :: Dict (K.Div 'K.RoundZero (P 3) (N 2) ~ N 1)-_test_Div_RoundZero_P3_N2 =  Dict-_test_Rem_RoundZero_P3_N2 :: Dict (K.Rem 'K.RoundZero (P 3) (N 2) ~ P 1)-_test_Rem_RoundZero_P3_N2 =  Dict-_test_Div_RoundZero_P3_N3 :: Dict (K.Div 'K.RoundZero (P 3) (N 3) ~ N 1)-_test_Div_RoundZero_P3_N3 =  Dict-_test_Rem_RoundZero_P3_N3 :: Dict (K.Rem 'K.RoundZero (P 3) (N 3) ~ P 0)-_test_Rem_RoundZero_P3_N3 =  Dict-_test_Div_RoundZero_P3_N4 :: Dict (K.Div 'K.RoundZero (P 3) (N 4) ~ P 0)-_test_Div_RoundZero_P3_N4 =  Dict-_test_Rem_RoundZero_P3_N4 :: Dict (K.Rem 'K.RoundZero (P 3) (N 4) ~ P 3)-_test_Rem_RoundZero_P3_N4 =  Dict-_test_Div_RoundZero_P3_P1 :: Dict (K.Div 'K.RoundZero (P 3) (P 1) ~ P 3)-_test_Div_RoundZero_P3_P1 =  Dict-_test_Rem_RoundZero_P3_P1 :: Dict (K.Rem 'K.RoundZero (P 3) (P 1) ~ P 0)-_test_Rem_RoundZero_P3_P1 =  Dict-_test_Div_RoundZero_P3_P2 :: Dict (K.Div 'K.RoundZero (P 3) (P 2) ~ P 1)-_test_Div_RoundZero_P3_P2 =  Dict-_test_Rem_RoundZero_P3_P2 :: Dict (K.Rem 'K.RoundZero (P 3) (P 2) ~ P 1)-_test_Rem_RoundZero_P3_P2 =  Dict-_test_Div_RoundZero_P3_P3 :: Dict (K.Div 'K.RoundZero (P 3) (P 3) ~ P 1)-_test_Div_RoundZero_P3_P3 =  Dict-_test_Rem_RoundZero_P3_P3 :: Dict (K.Rem 'K.RoundZero (P 3) (P 3) ~ P 0)-_test_Rem_RoundZero_P3_P3 =  Dict-_test_Div_RoundZero_P3_P4 :: Dict (K.Div 'K.RoundZero (P 3) (P 4) ~ P 0)-_test_Div_RoundZero_P3_P4 =  Dict-_test_Rem_RoundZero_P3_P4 :: Dict (K.Rem 'K.RoundZero (P 3) (P 4) ~ P 3)-_test_Rem_RoundZero_P3_P4 =  Dict-_test_Div_RoundZero_P4_N1 :: Dict (K.Div 'K.RoundZero (P 4) (N 1) ~ N 4)-_test_Div_RoundZero_P4_N1 =  Dict-_test_Rem_RoundZero_P4_N1 :: Dict (K.Rem 'K.RoundZero (P 4) (N 1) ~ P 0)-_test_Rem_RoundZero_P4_N1 =  Dict-_test_Div_RoundZero_P4_N2 :: Dict (K.Div 'K.RoundZero (P 4) (N 2) ~ N 2)-_test_Div_RoundZero_P4_N2 =  Dict-_test_Rem_RoundZero_P4_N2 :: Dict (K.Rem 'K.RoundZero (P 4) (N 2) ~ P 0)-_test_Rem_RoundZero_P4_N2 =  Dict-_test_Div_RoundZero_P4_N3 :: Dict (K.Div 'K.RoundZero (P 4) (N 3) ~ N 1)-_test_Div_RoundZero_P4_N3 =  Dict-_test_Rem_RoundZero_P4_N3 :: Dict (K.Rem 'K.RoundZero (P 4) (N 3) ~ P 1)-_test_Rem_RoundZero_P4_N3 =  Dict-_test_Div_RoundZero_P4_N4 :: Dict (K.Div 'K.RoundZero (P 4) (N 4) ~ N 1)-_test_Div_RoundZero_P4_N4 =  Dict-_test_Rem_RoundZero_P4_N4 :: Dict (K.Rem 'K.RoundZero (P 4) (N 4) ~ P 0)-_test_Rem_RoundZero_P4_N4 =  Dict-_test_Div_RoundZero_P4_P1 :: Dict (K.Div 'K.RoundZero (P 4) (P 1) ~ P 4)-_test_Div_RoundZero_P4_P1 =  Dict-_test_Rem_RoundZero_P4_P1 :: Dict (K.Rem 'K.RoundZero (P 4) (P 1) ~ P 0)-_test_Rem_RoundZero_P4_P1 =  Dict-_test_Div_RoundZero_P4_P2 :: Dict (K.Div 'K.RoundZero (P 4) (P 2) ~ P 2)-_test_Div_RoundZero_P4_P2 =  Dict-_test_Rem_RoundZero_P4_P2 :: Dict (K.Rem 'K.RoundZero (P 4) (P 2) ~ P 0)-_test_Rem_RoundZero_P4_P2 =  Dict-_test_Div_RoundZero_P4_P3 :: Dict (K.Div 'K.RoundZero (P 4) (P 3) ~ P 1)-_test_Div_RoundZero_P4_P3 =  Dict-_test_Rem_RoundZero_P4_P3 :: Dict (K.Rem 'K.RoundZero (P 4) (P 3) ~ P 1)-_test_Rem_RoundZero_P4_P3 =  Dict-_test_Div_RoundZero_P4_P4 :: Dict (K.Div 'K.RoundZero (P 4) (P 4) ~ P 1)-_test_Div_RoundZero_P4_P4 =  Dict-_test_Rem_RoundZero_P4_P4 :: Dict (K.Rem 'K.RoundZero (P 4) (P 4) ~ P 0)-_test_Rem_RoundZero_P4_P4 =  Dict+import Data.Singletons+import Data.String+import GHC.Exts (Constraint)+import GHC.TypeLits qualified as L+import Prelude hiding (Integer)+import Prelude qualified as P+import Prelude.Singletons qualified as P+import System.Exit+import Text.Read+import Text.ParserCombinators.ReadP qualified as ReadP+import Text.ParserCombinators.ReadPrec qualified as ReadPrec+import Text.Show.Singletons++import KindInteger (P, N, Z, pattern SP, pattern SN, pattern SZ,+  SInteger, pattern SInteger)+import KindInteger qualified as K++--------------------------------------------------------------------------------++data Dict (c :: Constraint) where+  Dict :: c => Dict c++readPrecMaybe :: ReadPrec a -> String -> Maybe a+readPrecMaybe p s =+  case readPrec_to_S (p <* ReadPrec.lift ReadP.skipSpaces) 0 s of+    [(x, "")] -> Just x+    _         -> Nothing++--------------------------------------------------------------------------------++_testShow =  Dict+_testShow :: Dict+  ( P.Show_ Z ~ "0"+  , P.Show_ (P 1) ~ "1"+  , P.Show_ (N 2) ~ "-2"+  , P.ShowsPrec AppPrec (N 2) "x" ~ "-2x"+  , P.ShowsPrec AppPrec1 (N 2) "x" ~ "(-2)x"+  , P.ShowsPrec AppPrec1 (P 2) "x" ~ "2x"+  )++_testShowLit =  Dict+_testShowLit :: Dict+  ( K.ShowLit Z ~ "Z"+  , K.ShowLit (P 1) ~ "P 1"+  , K.ShowLit (N 2) ~ "N 2"+  , K.ShowsPrecLit AppPrec (N 2) "x" ~ "N 2x"+  , K.ShowsPrecLit AppPrec1 (N 2) "x" ~ "(N 2)x"+  , K.ShowsPrecLit AppPrec1 (P 2) "x" ~ "(P 2)x"+  )++_testEq =  Dict+_testEq :: Dict+  ( 'True ~ (Z P.== Z)+  , 'True ~ (Z P.== Z)+  , 'True ~ (Z P.== Z)+  , 'True ~ (Z P.== Z)++  , 'True ~ (Z P./= P 1)+  , 'True ~ (Z P./= N 1)++  , 'True ~ (Z P./= N 1)+  , 'True ~ (Z P./= N 1)++  , 'True ~ (P 1 P./= Z)+  , 'True ~ (P 1 P./= Z)++  , 'True ~ (N 1 P./= Z)+  , 'True ~ (N 1 P./= Z)+  )++_testCmp =  Dict+_testCmp :: Dict+  ( Z <= Z+  , Z <= Z+  , Z <= Z+  , Z <= Z++  , N 2 <= N 1+  , N 1 <= Z+  , Z <= P 1++  , Z <= P 1+  , P 1 <= P 2+  )++_testAdd  = Dict+_testAdd :: Dict+  ( Z ~ Z P.+ Z+  , Z ~ Z P.+ Z+  , Z ~ Z P.+ Z+  , Z ~ Z P.+ Z++  , P 1 ~ P 1 P.+ Z+  , N 1 ~ N 1 P.+ Z+  , P 1 ~ P 1 P.+ Z+  , N 1 ~ N 1 P.+ Z++  , P 1 ~ Z P.+ P 1+  , N 1 ~ Z P.+ N 1+  , N 1 ~ Z P.+ N 1+  , P 1 ~ Z P.+ P 1++  , P 2 ~ P 1 P.+ P 1+  , N 2 ~ N 1 P.+ N 1+  , Z ~ P 1 P.+ N 1+  , Z ~ N 1 P.+ P 1+  )++_testMul  = Dict+_testMul :: Dict+  ( Z ~ Z P.* Z+  , Z ~ Z P.* Z+  , Z ~ Z P.* Z+  , Z ~ Z P.* Z++  , Z ~ P 1 P.* Z+  , Z ~ N 1 P.* Z+  , Z ~ P 1 P.* Z+  , Z ~ N 1 P.* Z++  , Z ~ Z P.* P 1+  , Z ~ Z P.* N 1+  , Z ~ Z P.* N 1+  , Z ~ Z P.* P 1++  , P 1 ~ P 1 P.* P 1+  , P 1 ~ N 1 P.* N 1+  , N 1 ~ P 1 P.* N 1+  , N 1 ~ N 1 P.* P 1++  , P 2 ~ P 2 P.* P 1+  , P 2 ~ N 2 P.* N 1+  , N 2 ~ P 2 P.* N 1+  , N 2 ~ N 2 P.* P 1++  , P 6 ~ P 2 P.* P 3+  , P 6 ~ N 2 P.* N 3+  , N 6 ~ P 2 P.* N 3+  , N 6 ~ N 2 P.* P 3+  )++_testLog2 =  Dict+_testLog2 :: Dict+  ( 0 ~ K.Log2 (P 1)+  , 1 ~ K.Log2 (P 2)+  , 1 ~ K.Log2 (P 3)+  , 2 ~ K.Log2 (P 4)+  , 2 ~ K.Log2 (P 5)+  , 2 ~ K.Log2 (P 6)+  , 2 ~ K.Log2 (P 7)+  , 3 ~ K.Log2 (P 8)+  , 3 ~ K.Log2 (P 9)+  , 3 ~ K.Log2 (P 10)+  , 3 ~ K.Log2 (P 11)+  , 3 ~ K.Log2 (P 12)+  , 3 ~ K.Log2 (P 13)+  , 3 ~ K.Log2 (P 14)+  , 3 ~ K.Log2 (P 15)+  , 4 ~ K.Log2 (P 16)+  , 4 ~ K.Log2 (P 17)+  , 4 ~ K.Log2 (P 18)+  , 4 ~ K.Log2 (P 19)+  , 4 ~ K.Log2 (P 20)+  , 4 ~ K.Log2 (P 21)+  , 4 ~ K.Log2 (P 22)+  , 4 ~ K.Log2 (P 23)+  , 4 ~ K.Log2 (P 24)+  , 4 ~ K.Log2 (P 25)+  , 4 ~ K.Log2 (P 26)+  , 4 ~ K.Log2 (P 27)+  , 4 ~ K.Log2 (P 28)+  , 4 ~ K.Log2 (P 29)+  , 4 ~ K.Log2 (P 30)+  , 4 ~ K.Log2 (P 31)+  , 5 ~ K.Log2 (P 32)+  )++_testNegate =  Dict+_testNegate :: Dict+  ( Z ~ P.Negate Z+  , Z ~ P.Negate Z+  , N 1 ~ P.Negate (P 1)+  , P 1 ~ P.Negate (N 1)+  , N 2 ~ P.Negate (P 2)+  , P 2 ~ P.Negate (N 2)+  )++_testSign =  Dict+_testSign :: Dict+  ( Z ~ P.Signum Z+  , Z ~ P.Signum Z+  , P 1 ~ P.Signum (P 1)+  , N 1 ~ P.Signum (N 1)+  , P 1 ~ P.Signum (P 2)+  , N 1 ~ P.Signum (N 2)+  )++_testAbs =  Dict+_testAbs :: Dict+  ( 0 ~ K.Abs Z+  , 0 ~ K.Abs Z+  , 1 ~ K.Abs (P 1)+  , 1 ~ K.Abs (N 1)+  , 2 ~ K.Abs (P 2)+  , 2 ~ K.Abs (N 2)+  )++_testEven =  Dict+_testEven :: Dict+  ( 'True  ~ K.Even Z+  , 'True  ~ K.Even Z+  , 'False ~ K.Even (P 1)+  , 'False ~ K.Even (N 1)+  , 'True  ~ K.Even (P 2)+  , 'True  ~ K.Even (N 2)+  )++_testOdd =  Dict+_testOdd :: Dict+  ( 'False  ~ K.Odd Z+  , 'False  ~ K.Odd Z+  , 'True   ~ K.Odd (P 1)+  , 'True   ~ K.Odd (N 1)+  , 'False  ~ K.Odd (P 2)+  , 'False  ~ K.Odd (N 2)+  )++_testGCD =  Dict+_testGCD :: Dict+  ( 0 ~ K.GCD Z Z+  , 0 ~ K.GCD Z Z+  , 0 ~ K.GCD Z Z+  , 0 ~ K.GCD Z Z++  , 1 ~ K.GCD (P 1) Z+  , 1 ~ K.GCD (P 1) Z+  , 1 ~ K.GCD (N 1) Z+  , 1 ~ K.GCD (N 1) Z++  , 1 ~ K.GCD Z (P 1)+  , 1 ~ K.GCD Z (N 1)+  , 1 ~ K.GCD Z (P 1)+  , 1 ~ K.GCD Z (N 1)++  , 1 ~ K.GCD (P 1) (P 2)+  , 1 ~ K.GCD (P 1) (N 2)+  , 1 ~ K.GCD (N 1) (P 2)+  , 1 ~ K.GCD (N 1) (N 2)++  , 1 ~ K.GCD (P 2) (P 1)+  , 1 ~ K.GCD (P 2) (N 1)+  , 1 ~ K.GCD (N 2) (P 1)+  , 1 ~ K.GCD (N 2) (N 1)++  , 3 ~ K.GCD (P 6) (P 9)+  , 3 ~ K.GCD (P 6) (N 9)+  , 3 ~ K.GCD (N 6) (P 9)+  , 3 ~ K.GCD (N 6) (N 9)++  , 3 ~ K.GCD (P 9) (P 6)+  , 3 ~ K.GCD (P 9) (N 6)+  , 3 ~ K.GCD (N 9) (P 6)+  , 3 ~ K.GCD (N 9) (N 6)+  )++_testLCM =  Dict+_testLCM :: Dict+  ( 0 ~ K.LCM Z Z+  , 0 ~ K.LCM Z Z+  , 0 ~ K.LCM Z Z+  , 0 ~ K.LCM Z Z++  , 0 ~ K.LCM (P 1) Z+  , 0 ~ K.LCM (P 1) Z+  , 0 ~ K.LCM (N 1) Z+  , 0 ~ K.LCM (N 1) Z++  , 0 ~ K.LCM Z (P 1)+  , 0 ~ K.LCM Z (N 1)+  , 0 ~ K.LCM Z (P 1)+  , 0 ~ K.LCM Z (N 1)++  , 2 ~ K.LCM (P 1) (P 2)+  , 2 ~ K.LCM (P 1) (N 2)+  , 2 ~ K.LCM (N 1) (P 2)+  , 2 ~ K.LCM (N 1) (N 2)++  , 2 ~ K.LCM (P 2) (P 1)+  , 2 ~ K.LCM (P 2) (N 1)+  , 2 ~ K.LCM (N 2) (P 1)+  , 2 ~ K.LCM (N 2) (N 1)++  , 18 ~ K.LCM (P 6) (P 9)+  , 18 ~ K.LCM (P 6) (N 9)+  , 18 ~ K.LCM (N 6) (P 9)+  , 18 ~ K.LCM (N 6) (N 9)++  , 18 ~ K.LCM (P 9) (P 6)+  , 18 ~ K.LCM (P 9) (N 6)+  , 18 ~ K.LCM (N 9) (P 6)+  , 18 ~ K.LCM (N 9) (N 6)+  )++--------------------------------------------------------------------------------++assert+  :: String  -- ^ Test name+  -> Bool    -- ^ Successful is true+  -> IO Bool -- ^ Return the same 'Bool' given as input.+assert n x = do+  putStrLn ((if x then "[OK] " else "[FAIL] ") <> n)+  pure x++testsMain :: [IO Bool] -> IO a+testsMain xs = do+  res <- sequence xs+  let (oks, bads) = List.partition id res+  putStrLn ("[TOTAL] OK: " <> show (length oks) <>+            ". FAIL: " <> show (length bads) <> ".")+  case bads of+    [] -> exitSuccess+    _  -> exitFailure++sn1, sz, sp1 :: K.SomeInteger+sn1 = K.SomeInteger (Proxy @(N 1))+sz = K.SomeInteger (Proxy @Z)+sp1 = K.SomeInteger (Proxy @(P 1))+++main :: IO ()+main = testsMain $+  [ assert "Prelude % throws RatioZeroDenominator" =<< do+      ea <- Ex.try (Ex.evaluate (1 P.% 0 :: P.Rational))+      pure (ea == Left Ex.RatioZeroDenominator)++  , assert "integerVal . someIntegerVal == id" $+    flip all [-5 .. 5] $ \a ->+      case K.someIntegerVal a of+        K.SomeInteger pa ->+          a == K.integerVal pa++  , assert "sameIntegerVal a a" $+    flip all [-5 .. 5] $ \a ->+      case K.someIntegerVal a of+        K.SomeInteger pa ->+          isJust (K.sameInteger pa pa)++  , assert "sameIntegerVal a a'" $+    flip all [-5 .. 5] $ \a ->+      case (K.someIntegerVal a, K.someIntegerVal a) of+        (K.SomeInteger pa1, K.SomeInteger pa2) ->+          isJust (K.sameInteger pa1 pa2)++  , assert "sameIntegerVal a b" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      case (K.someIntegerVal a, K.someIntegerVal b) of+        (K.SomeInteger pa, K.SomeInteger pb)+          | a == b    -> isJust    (K.sameInteger pa pb)+          | otherwise -> isNothing (K.sameInteger pa pb)++  , assert "demote @Z" $ demote @Z == (0 :: P.Integer)+  , assert "demote @(P 1)" $ demote @(P 1) == (1 :: P.Integer)+  , assert "demote @(N 1)" $ demote @(N 1) == ((-1) :: P.Integer)++  , assert "Eq SomeInteger" $+    flip all (liftA2 (,) [(-2)..2] [(-2)..2]) $ \(a, b) ->+      (==) (K.someIntegerVal a) (K.someIntegerVal b)+        == (==) a b++  , assert "Ord SomeInteger" $+    flip all (liftA2 (,) [(-2)..2] [(-2)..2]) $ \(a, b) ->+      compare (K.someIntegerVal a) (K.someIntegerVal b)+        == compare a b++  , assert "Show SomeInteger" $+    and [ show sn1 == "-1"+        , show sz == "0"+        , show sp1 == "1" ]++  , assert "Read SomeInteger" $+    and [ readMaybe "-1" == Just sn1+        , readMaybe "0" == Just sz+        , readMaybe "1" == Just sp1 ]++  , assert "TestEquality 0 0" $+     isJust (testEquality (SInteger @Z) (SInteger @Z))+  , assert "TestEquality 0 +1" $+     isNothing (testEquality (SInteger @Z) (SInteger @(P 1)))+  , assert "TestEquality 0 -1" $+     isNothing (testEquality (SInteger @Z) (SInteger @(N 1)))+  , assert "TestEquality +1 0" $+     isNothing (testEquality (SInteger @(P 1)) (SInteger @Z))+  , assert "TestEquality -1 0" $+     isNothing (testEquality (SInteger @(N 1)) (SInteger @Z))++  , assert "show SInteger 0" $+     "SInteger @Z" == show (SInteger @Z)+  , assert "show SInteger +1" $+     "SInteger @(P 1)" == show (SInteger @(P 1))+  , assert "show SInteger -1" $+     "SInteger @(N 1)" == show (SInteger @(N 1))++  , assert "sShow SInteger 0" $+     fromString "0" == fromSing (P.sShow_ (SInteger @Z))+  , assert "sShow SInteger +1" $+     fromString "1" == fromSing (P.sShow_ (SInteger @(P 1)))+  , assert "sShow SInteger -1" $+     fromString "-1" == fromSing (P.sShow_ (SInteger @(N 1)))++  , assert "sShowsPrec appPrec SInteger 0" $+     fromString "0y" == fromSing (P.sShowsPrec sAppPrec (SInteger @Z) (sing @"y"))+  , assert "sShowsPrec appPrec SInteger +1" $+     fromString "1y" == fromSing (P.sShowsPrec sAppPrec (SInteger @(P 1)) (sing @"y"))+  , assert "sShowPrec appPrec SInteger -1" $+     fromString "-1y" == fromSing (P.sShowsPrec sAppPrec (SInteger @(N 1)) (sing @"y"))++  , assert "sShowsPrec appPrec1 SInteger 0" $+     fromString "0y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @Z) (sing @"y"))+  , assert "sShowsPrec appPrec1 SInteger +1" $+     fromString "1y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @(P 1)) (sing @"y"))+  , assert "sShowPrec appPrec1 SInteger -1" $+     fromString "-1y" == fromSing (P.sShowsPrec sAppPrec1 (SInteger @(N 1)) (sing @"y"))++  , assert "sShowLit SInteger 0" $+     fromString "Z" == fromSing (K.sShowLit (SInteger @Z))+  , assert "sShowLit SInteger +1" $+     fromString "P 1" == fromSing (K.sShowLit (SInteger @(P 1)))+  , assert "sShowLit SInteger -1" $+     fromString "N 1" == fromSing (K.sShowLit (SInteger @(N 1)))++  , assert "sShowsPrecLit appPrec SInteger 0" $+     fromString "Zy" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @Z) (sing @"y"))+  , assert "sShowsPrecLit appPrec SInteger +1" $+     fromString "P 1y" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @(P 1)) (sing @"y"))+  , assert "sShowPrec appPrec SInteger -1" $+     fromString "N 1y" == fromSing (K.sShowsPrecLit sAppPrec (SInteger @(N 1)) (sing @"y"))++  , assert "sShowsPrecLit appPrec1 SInteger 0" $+     fromString "Zy" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @Z) (sing @"y"))+  , assert "sShowsPrecLit appPrec1 SInteger +1" $+     fromString "(P 1)y" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @(P 1)) (sing @"y"))+  , assert "sShowPrec appPrec1 SInteger -1" $+     fromString "(N 1)y" == fromSing (K.sShowsPrecLit sAppPrec1 (SInteger @(N 1)) (sing @"y"))++  , assert "readPrecLit Z" $+     readPrecMaybe K.readPrecLit "Z" == Just 0+  , assert "readPrecLit P" $+     readPrecMaybe K.readPrecLit "P 0" == Nothing &&+     readPrecMaybe K.readPrecLit "P 1" == Just 1+  , assert "readPrecLit N" $+     readPrecMaybe K.readPrecLit "N 0" == Nothing &&+     readPrecMaybe K.readPrecLit "N 1" == Just (-1)++  , assert "Read SInteger 0" $+     readMaybe @(SInteger Z) "SInteger @Z" == Just (SInteger @Z)+  , assert "Read SInteger +1" $+     readMaybe @(SInteger (P 1)) "SInteger @(P 1)" == Just (SInteger @(P 1))+  , assert "Read SInteger -1" $+     readMaybe @(SInteger (N 1)) "SInteger @(N 1)" == Just (SInteger @(N 1))++  , assert "SZ == SInteger @Z" $+    case SInteger @Z of+      SZ -> SZ == SInteger @Z++  , assert "SN (sing @1) == SInteger @(N 1)" $+    case SInteger @(N 1) of+      SN s1 -> (fromSing @L.Natural s1 == 1) &&+               (SN s1 == SInteger @(N 1))++  , assert "SP (sing @1) == SInteger @(P 1)" $+    case SInteger @(P 1) of+      SP s1 -> (fromSing @L.Natural s1 == 1) &&+               (SP s1 == SInteger @(P 1))++  , assert "KnownInteger i ==> KnownNat (Abs i)" $+    let fabs :: forall i. SInteger i -> P.Integer+        fabs si = K.withKnownInteger si (L.natVal (Proxy @(K.Abs i)))+    in and [ 1 == fabs (sing @(N 1))+           , 0 == fabs (sing @Z)+           , 1 == fabs (sing @(P 1)) ]++  , assert "sNegate" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      negate a == withSomeSing a (fromSing . P.sNegate)++  , assert "%+" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      a + b == (withSomeSing (a :: P.Integer) $ \sa ->+                withSomeSing (b :: P.Integer) $ \sb ->+                fromSing $ sa P.%+ sb)++  , assert "%-" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      a - b == (withSomeSing (a :: P.Integer) $ \sa ->+                withSomeSing (b :: P.Integer) $ \sb ->+                fromSing $ sa P.%- sb)++  , assert "%*" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      a * b == (withSomeSing (a :: P.Integer) $ \sa ->+                withSomeSing (b :: P.Integer) $ \sb ->+                fromSing $ sa P.%* sb)++  , assert "%^" $+    flip all (liftA2 (,) [-5 .. 5] [0 .. 5])$ \(a, b) ->+      a ^ b == (withSomeSing (a :: P.Integer) $ \sa ->+                withSomeSing (b :: L.Natural) $ \sb ->+                fromSing $ sa K.%^ sb)++  , assert "sOdd" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      odd a == withSomeSing a (fromSing . K.sOdd)++  , assert "sEven" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      even a == withSomeSing a (fromSing . K.sEven)++  , assert "sAbs" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      fromInteger @L.Natural (abs a)+        == withSomeSing a (fromSing . K.sAbs)++  , assert "sSignum" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      signum a == withSomeSing a (fromSing . P.sSignum)++  , assert "sGCD" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      fromInteger @L.Natural (gcd a b)+        == (withSomeSing (a :: P.Integer) $ \sa ->+            withSomeSing (b :: P.Integer) $ \sb ->+            fromSing $ K.sGCD sa sb)++  , assert "sLCM" $+    flip all (liftA2 (,) [-5 .. 5] [-5 .. 5])$ \(a, b) ->+      fromInteger @L.Natural (lcm a b)+        == (withSomeSing (a :: P.Integer) $ \sa ->+            withSomeSing (b :: P.Integer) $ \sb ->+            fromSing $ K.sLCM sa sb)++  , assert "sSign" $+    flip all [-5 .. 5] $ \(a :: P.Integer) ->+      signum a == withSomeSing a (fromSing . P.sSignum)++  , fmap and $ sequence $ do+     r :: K.Round <- [minBound .. maxBound]+     a :: P.Integer <- [-5 .. 5]+     b :: P.Integer <- filter (/= 0) [-5 .. 5]+     pure $ assert (mconcat ["sDivRem ", show r, " ", show a, " ", show b]) $+       K.divRem r a b == (withSomeSing r $ \sr ->+                          withSomeSing a $ \sa ->+                          withSomeSing b $ \sb ->+                          let (q, m) = K.sDivRem sr sa sb+                           in (fromSing q, fromSing m))++  , fmap and $ sequence $ do+     r :: K.Round <- [minBound .. maxBound]+     a :: P.Integer <- [-5 .. 5]+     b :: P.Integer <- filter (/= 0) [-5 .. 5]+     pure $ assert (mconcat ["sDiv ", show r, " ", show a, " ", show b]) $+       K.div r a b == (withSomeSing r $ \sr ->+                       withSomeSing a $ \sa ->+                       withSomeSing b $ \sb ->+                       fromSing (K.sDiv sr sa sb))++  , fmap and $ sequence $ do+     r :: K.Round <- [minBound .. maxBound]+     a :: P.Integer <- [-5 .. 5]+     b :: P.Integer <- filter (/= 0) [-5 .. 5]+     pure $ assert (mconcat ["sRem ", show r, " ", show a, " ", show b]) $+       K.rem r a b == (withSomeSing r $ \sr ->+                       withSomeSing a $ \sa ->+                       withSomeSing b $ \sb ->+                       fromSing (K.sRem sr sa sb))++  , fmap and $ sequence $ do+      n :: L.Natural <- [0..5]+      pure $ assert (mconcat ["sFromNatural ", show n]) $+        toInteger n == withSomeSing n (fromSing . K.sFromNatural)++  ] <> testsDivRem++++testsDivRem :: [IO Bool]+testsDivRem = do+  b :: P.Integer <- [-5 .. 5]+  guard (b P./= 0)+  a :: P.Integer <- [-5 .. 5]+  r :: K.Round <- [minBound .. maxBound]+  let tname :: String -> ShowS+      tname t = showString t . showChar ' ' . shows r . showChar ' '+              . shows a . showChar ' ' . shows b+  [ assert (tname "divRem" "") $ case K.divRem r a b of+                                   (q, m) -> m == a - b * q+    , assert (tname "div" "") $ fst (K.divRem r a b) == K.div r a b+    , assert (tname "rem" "") $ snd (K.divRem r a b) == K.rem r a b+    ]+++--------------------------------------------------------------------------------++-- _divRemTestCode :: String+-- _divRemTestCode = unlines $ List.sort $ do+--   b <- [-4 .. 4]+--   guard (b P./= 0)+--   a <- [-4 .. 4]+--   r <- [minBound..maxBound]+--   let (q, m) = K.divRem r a b+--       sname :: String -> ShowS+--       sname t = showString "_test_"+--               . showString t+--               . showChar '_'+--               . showsPrec 0 r+--               . showChar '_'+--               . showChar (if a < 0 then 'N' else 'P')+--               . shows (abs a)+--               . showChar '_'+--               . showChar (if b < 0 then 'N' else 'P')+--               . shows (abs b)+--       sDiv :: ShowS+--       sDiv = sname "Div"+--            . showString " :: Dict (K.Div 'K."+--            . shows r+--            . showChar ' '+--            . showsPrec appPrec1 (K.fromPrelude a)+--            . showChar ' '+--            . showsPrec appPrec1 (K.fromPrelude b)+--            . showString " ~ "+--            . showsPrec appPrec (K.fromPrelude q)+--            . showString ")\n"+--            . sname "Div"+--            . showString " =  Dict"+--       sRem :: ShowS+--       sRem = sname "Rem"+--            . showString " :: Dict (K.Rem 'K."+--            . shows r+--            . showChar ' '+--            . showsPrec appPrec1 (K.fromPrelude a)+--            . showChar ' '+--            . showsPrec appPrec1 (K.fromPrelude b)+--            . showString " ~ "+--            . showsPrec appPrec (K.fromPrelude m)+--            . showString ")\n"+--            . sname "Rem"+--            . showString " =  Dict"+--       ss :: ShowS+--       ss = sDiv . showChar '\n' . sRem+--   pure (ss "")+++-- The following tests are generated by `_divRemTestCode` in this remule.+-- Copy and paste by hand.+_test_Div_RoundAway_N1_N1 :: Dict (K.Div 'K.RoundAway (N 1) (N 1) ~ P 1)+_test_Div_RoundAway_N1_N1 =  Dict+_test_Rem_RoundAway_N1_N1 :: Dict (K.Rem 'K.RoundAway (N 1) (N 1) ~ Z)+_test_Rem_RoundAway_N1_N1 =  Dict+_test_Div_RoundAway_N1_N2 :: Dict (K.Div 'K.RoundAway (N 1) (N 2) ~ P 1)+_test_Div_RoundAway_N1_N2 =  Dict+_test_Rem_RoundAway_N1_N2 :: Dict (K.Rem 'K.RoundAway (N 1) (N 2) ~ P 1)+_test_Rem_RoundAway_N1_N2 =  Dict+_test_Div_RoundAway_N1_N3 :: Dict (K.Div 'K.RoundAway (N 1) (N 3) ~ P 1)+_test_Div_RoundAway_N1_N3 =  Dict+_test_Rem_RoundAway_N1_N3 :: Dict (K.Rem 'K.RoundAway (N 1) (N 3) ~ P 2)+_test_Rem_RoundAway_N1_N3 =  Dict+_test_Div_RoundAway_N1_N4 :: Dict (K.Div 'K.RoundAway (N 1) (N 4) ~ P 1)+_test_Div_RoundAway_N1_N4 =  Dict+_test_Rem_RoundAway_N1_N4 :: Dict (K.Rem 'K.RoundAway (N 1) (N 4) ~ P 3)+_test_Rem_RoundAway_N1_N4 =  Dict+_test_Div_RoundAway_N1_P1 :: Dict (K.Div 'K.RoundAway (N 1) (P 1) ~ N 1)+_test_Div_RoundAway_N1_P1 =  Dict+_test_Rem_RoundAway_N1_P1 :: Dict (K.Rem 'K.RoundAway (N 1) (P 1) ~ Z)+_test_Rem_RoundAway_N1_P1 =  Dict+_test_Div_RoundAway_N1_P2 :: Dict (K.Div 'K.RoundAway (N 1) (P 2) ~ N 1)+_test_Div_RoundAway_N1_P2 =  Dict+_test_Rem_RoundAway_N1_P2 :: Dict (K.Rem 'K.RoundAway (N 1) (P 2) ~ P 1)+_test_Rem_RoundAway_N1_P2 =  Dict+_test_Div_RoundAway_N1_P3 :: Dict (K.Div 'K.RoundAway (N 1) (P 3) ~ N 1)+_test_Div_RoundAway_N1_P3 =  Dict+_test_Rem_RoundAway_N1_P3 :: Dict (K.Rem 'K.RoundAway (N 1) (P 3) ~ P 2)+_test_Rem_RoundAway_N1_P3 =  Dict+_test_Div_RoundAway_N1_P4 :: Dict (K.Div 'K.RoundAway (N 1) (P 4) ~ N 1)+_test_Div_RoundAway_N1_P4 =  Dict+_test_Rem_RoundAway_N1_P4 :: Dict (K.Rem 'K.RoundAway (N 1) (P 4) ~ P 3)+_test_Rem_RoundAway_N1_P4 =  Dict+_test_Div_RoundAway_N2_N1 :: Dict (K.Div 'K.RoundAway (N 2) (N 1) ~ P 2)+_test_Div_RoundAway_N2_N1 =  Dict+_test_Rem_RoundAway_N2_N1 :: Dict (K.Rem 'K.RoundAway (N 2) (N 1) ~ Z)+_test_Rem_RoundAway_N2_N1 =  Dict+_test_Div_RoundAway_N2_N2 :: Dict (K.Div 'K.RoundAway (N 2) (N 2) ~ P 1)+_test_Div_RoundAway_N2_N2 =  Dict+_test_Rem_RoundAway_N2_N2 :: Dict (K.Rem 'K.RoundAway (N 2) (N 2) ~ Z)+_test_Rem_RoundAway_N2_N2 =  Dict+_test_Div_RoundAway_N2_N3 :: Dict (K.Div 'K.RoundAway (N 2) (N 3) ~ P 1)+_test_Div_RoundAway_N2_N3 =  Dict+_test_Rem_RoundAway_N2_N3 :: Dict (K.Rem 'K.RoundAway (N 2) (N 3) ~ P 1)+_test_Rem_RoundAway_N2_N3 =  Dict+_test_Div_RoundAway_N2_N4 :: Dict (K.Div 'K.RoundAway (N 2) (N 4) ~ P 1)+_test_Div_RoundAway_N2_N4 =  Dict+_test_Rem_RoundAway_N2_N4 :: Dict (K.Rem 'K.RoundAway (N 2) (N 4) ~ P 2)+_test_Rem_RoundAway_N2_N4 =  Dict+_test_Div_RoundAway_N2_P1 :: Dict (K.Div 'K.RoundAway (N 2) (P 1) ~ N 2)+_test_Div_RoundAway_N2_P1 =  Dict+_test_Rem_RoundAway_N2_P1 :: Dict (K.Rem 'K.RoundAway (N 2) (P 1) ~ Z)+_test_Rem_RoundAway_N2_P1 =  Dict+_test_Div_RoundAway_N2_P2 :: Dict (K.Div 'K.RoundAway (N 2) (P 2) ~ N 1)+_test_Div_RoundAway_N2_P2 =  Dict+_test_Rem_RoundAway_N2_P2 :: Dict (K.Rem 'K.RoundAway (N 2) (P 2) ~ Z)+_test_Rem_RoundAway_N2_P2 =  Dict+_test_Div_RoundAway_N2_P3 :: Dict (K.Div 'K.RoundAway (N 2) (P 3) ~ N 1)+_test_Div_RoundAway_N2_P3 =  Dict+_test_Rem_RoundAway_N2_P3 :: Dict (K.Rem 'K.RoundAway (N 2) (P 3) ~ P 1)+_test_Rem_RoundAway_N2_P3 =  Dict+_test_Div_RoundAway_N2_P4 :: Dict (K.Div 'K.RoundAway (N 2) (P 4) ~ N 1)+_test_Div_RoundAway_N2_P4 =  Dict+_test_Rem_RoundAway_N2_P4 :: Dict (K.Rem 'K.RoundAway (N 2) (P 4) ~ P 2)+_test_Rem_RoundAway_N2_P4 =  Dict+_test_Div_RoundAway_N3_N1 :: Dict (K.Div 'K.RoundAway (N 3) (N 1) ~ P 3)+_test_Div_RoundAway_N3_N1 =  Dict+_test_Rem_RoundAway_N3_N1 :: Dict (K.Rem 'K.RoundAway (N 3) (N 1) ~ Z)+_test_Rem_RoundAway_N3_N1 =  Dict+_test_Div_RoundAway_N3_N2 :: Dict (K.Div 'K.RoundAway (N 3) (N 2) ~ P 2)+_test_Div_RoundAway_N3_N2 =  Dict+_test_Rem_RoundAway_N3_N2 :: Dict (K.Rem 'K.RoundAway (N 3) (N 2) ~ P 1)+_test_Rem_RoundAway_N3_N2 =  Dict+_test_Div_RoundAway_N3_N3 :: Dict (K.Div 'K.RoundAway (N 3) (N 3) ~ P 1)+_test_Div_RoundAway_N3_N3 =  Dict+_test_Rem_RoundAway_N3_N3 :: Dict (K.Rem 'K.RoundAway (N 3) (N 3) ~ Z)+_test_Rem_RoundAway_N3_N3 =  Dict+_test_Div_RoundAway_N3_N4 :: Dict (K.Div 'K.RoundAway (N 3) (N 4) ~ P 1)+_test_Div_RoundAway_N3_N4 =  Dict+_test_Rem_RoundAway_N3_N4 :: Dict (K.Rem 'K.RoundAway (N 3) (N 4) ~ P 1)+_test_Rem_RoundAway_N3_N4 =  Dict+_test_Div_RoundAway_N3_P1 :: Dict (K.Div 'K.RoundAway (N 3) (P 1) ~ N 3)+_test_Div_RoundAway_N3_P1 =  Dict+_test_Rem_RoundAway_N3_P1 :: Dict (K.Rem 'K.RoundAway (N 3) (P 1) ~ Z)+_test_Rem_RoundAway_N3_P1 =  Dict+_test_Div_RoundAway_N3_P2 :: Dict (K.Div 'K.RoundAway (N 3) (P 2) ~ N 2)+_test_Div_RoundAway_N3_P2 =  Dict+_test_Rem_RoundAway_N3_P2 :: Dict (K.Rem 'K.RoundAway (N 3) (P 2) ~ P 1)+_test_Rem_RoundAway_N3_P2 =  Dict+_test_Div_RoundAway_N3_P3 :: Dict (K.Div 'K.RoundAway (N 3) (P 3) ~ N 1)+_test_Div_RoundAway_N3_P3 =  Dict+_test_Rem_RoundAway_N3_P3 :: Dict (K.Rem 'K.RoundAway (N 3) (P 3) ~ Z)+_test_Rem_RoundAway_N3_P3 =  Dict+_test_Div_RoundAway_N3_P4 :: Dict (K.Div 'K.RoundAway (N 3) (P 4) ~ N 1)+_test_Div_RoundAway_N3_P4 =  Dict+_test_Rem_RoundAway_N3_P4 :: Dict (K.Rem 'K.RoundAway (N 3) (P 4) ~ P 1)+_test_Rem_RoundAway_N3_P4 =  Dict+_test_Div_RoundAway_N4_N1 :: Dict (K.Div 'K.RoundAway (N 4) (N 1) ~ P 4)+_test_Div_RoundAway_N4_N1 =  Dict+_test_Rem_RoundAway_N4_N1 :: Dict (K.Rem 'K.RoundAway (N 4) (N 1) ~ Z)+_test_Rem_RoundAway_N4_N1 =  Dict+_test_Div_RoundAway_N4_N2 :: Dict (K.Div 'K.RoundAway (N 4) (N 2) ~ P 2)+_test_Div_RoundAway_N4_N2 =  Dict+_test_Rem_RoundAway_N4_N2 :: Dict (K.Rem 'K.RoundAway (N 4) (N 2) ~ Z)+_test_Rem_RoundAway_N4_N2 =  Dict+_test_Div_RoundAway_N4_N3 :: Dict (K.Div 'K.RoundAway (N 4) (N 3) ~ P 2)+_test_Div_RoundAway_N4_N3 =  Dict+_test_Rem_RoundAway_N4_N3 :: Dict (K.Rem 'K.RoundAway (N 4) (N 3) ~ P 2)+_test_Rem_RoundAway_N4_N3 =  Dict+_test_Div_RoundAway_N4_N4 :: Dict (K.Div 'K.RoundAway (N 4) (N 4) ~ P 1)+_test_Div_RoundAway_N4_N4 =  Dict+_test_Rem_RoundAway_N4_N4 :: Dict (K.Rem 'K.RoundAway (N 4) (N 4) ~ Z)+_test_Rem_RoundAway_N4_N4 =  Dict+_test_Div_RoundAway_N4_P1 :: Dict (K.Div 'K.RoundAway (N 4) (P 1) ~ N 4)+_test_Div_RoundAway_N4_P1 =  Dict+_test_Rem_RoundAway_N4_P1 :: Dict (K.Rem 'K.RoundAway (N 4) (P 1) ~ Z)+_test_Rem_RoundAway_N4_P1 =  Dict+_test_Div_RoundAway_N4_P2 :: Dict (K.Div 'K.RoundAway (N 4) (P 2) ~ N 2)+_test_Div_RoundAway_N4_P2 =  Dict+_test_Rem_RoundAway_N4_P2 :: Dict (K.Rem 'K.RoundAway (N 4) (P 2) ~ Z)+_test_Rem_RoundAway_N4_P2 =  Dict+_test_Div_RoundAway_N4_P3 :: Dict (K.Div 'K.RoundAway (N 4) (P 3) ~ N 2)+_test_Div_RoundAway_N4_P3 =  Dict+_test_Rem_RoundAway_N4_P3 :: Dict (K.Rem 'K.RoundAway (N 4) (P 3) ~ P 2)+_test_Rem_RoundAway_N4_P3 =  Dict+_test_Div_RoundAway_N4_P4 :: Dict (K.Div 'K.RoundAway (N 4) (P 4) ~ N 1)+_test_Div_RoundAway_N4_P4 =  Dict+_test_Rem_RoundAway_N4_P4 :: Dict (K.Rem 'K.RoundAway (N 4) (P 4) ~ Z)+_test_Rem_RoundAway_N4_P4 =  Dict+_test_Rem_RoundAway_Z_N1 :: Dict (K.Rem 'K.RoundAway Z (N 1) ~ Z)+_test_Rem_RoundAway_Z_N1 =  Dict+_test_Rem_RoundAway_Z_N2 :: Dict (K.Rem 'K.RoundAway Z (N 2) ~ Z)+_test_Rem_RoundAway_Z_N2 =  Dict+_test_Rem_RoundAway_Z_N3 :: Dict (K.Rem 'K.RoundAway Z (N 3) ~ Z)+_test_Rem_RoundAway_Z_N3 =  Dict+_test_Rem_RoundAway_Z_N4 :: Dict (K.Rem 'K.RoundAway Z (N 4) ~ Z)+_test_Rem_RoundAway_Z_N4 =  Dict+_test_Rem_RoundAway_Z_P1 :: Dict (K.Rem 'K.RoundAway Z (P 1) ~ Z)+_test_Rem_RoundAway_Z_P1 =  Dict+_test_Rem_RoundAway_Z_P2 :: Dict (K.Rem 'K.RoundAway Z (P 2) ~ Z)+_test_Rem_RoundAway_Z_P2 =  Dict+_test_Rem_RoundAway_Z_P3 :: Dict (K.Rem 'K.RoundAway Z (P 3) ~ Z)+_test_Rem_RoundAway_Z_P3 =  Dict+_test_Rem_RoundAway_Z_P4 :: Dict (K.Rem 'K.RoundAway Z (P 4) ~ Z)+_test_Rem_RoundAway_Z_P4 =  Dict+_test_Div_RoundAway_P1_N1 :: Dict (K.Div 'K.RoundAway (P 1) (N 1) ~ N 1)+_test_Div_RoundAway_P1_N1 =  Dict+_test_Rem_RoundAway_P1_N1 :: Dict (K.Rem 'K.RoundAway (P 1) (N 1) ~ Z)+_test_Rem_RoundAway_P1_N1 =  Dict+_test_Div_RoundAway_P1_N2 :: Dict (K.Div 'K.RoundAway (P 1) (N 2) ~ N 1)+_test_Div_RoundAway_P1_N2 =  Dict+_test_Rem_RoundAway_P1_N2 :: Dict (K.Rem 'K.RoundAway (P 1) (N 2) ~ N 1)+_test_Rem_RoundAway_P1_N2 =  Dict+_test_Div_RoundAway_P1_N3 :: Dict (K.Div 'K.RoundAway (P 1) (N 3) ~ N 1)+_test_Div_RoundAway_P1_N3 =  Dict+_test_Rem_RoundAway_P1_N3 :: Dict (K.Rem 'K.RoundAway (P 1) (N 3) ~ N 2)+_test_Rem_RoundAway_P1_N3 =  Dict+_test_Div_RoundAway_P1_N4 :: Dict (K.Div 'K.RoundAway (P 1) (N 4) ~ N 1)+_test_Div_RoundAway_P1_N4 =  Dict+_test_Rem_RoundAway_P1_N4 :: Dict (K.Rem 'K.RoundAway (P 1) (N 4) ~ N 3)+_test_Rem_RoundAway_P1_N4 =  Dict+_test_Div_RoundAway_P1_P1 :: Dict (K.Div 'K.RoundAway (P 1) (P 1) ~ P 1)+_test_Div_RoundAway_P1_P1 =  Dict+_test_Rem_RoundAway_P1_P1 :: Dict (K.Rem 'K.RoundAway (P 1) (P 1) ~ Z)+_test_Rem_RoundAway_P1_P1 =  Dict+_test_Div_RoundAway_P1_P2 :: Dict (K.Div 'K.RoundAway (P 1) (P 2) ~ P 1)+_test_Div_RoundAway_P1_P2 =  Dict+_test_Rem_RoundAway_P1_P2 :: Dict (K.Rem 'K.RoundAway (P 1) (P 2) ~ N 1)+_test_Rem_RoundAway_P1_P2 =  Dict+_test_Div_RoundAway_P1_P3 :: Dict (K.Div 'K.RoundAway (P 1) (P 3) ~ P 1)+_test_Div_RoundAway_P1_P3 =  Dict+_test_Rem_RoundAway_P1_P3 :: Dict (K.Rem 'K.RoundAway (P 1) (P 3) ~ N 2)+_test_Rem_RoundAway_P1_P3 =  Dict+_test_Div_RoundAway_P1_P4 :: Dict (K.Div 'K.RoundAway (P 1) (P 4) ~ P 1)+_test_Div_RoundAway_P1_P4 =  Dict+_test_Rem_RoundAway_P1_P4 :: Dict (K.Rem 'K.RoundAway (P 1) (P 4) ~ N 3)+_test_Rem_RoundAway_P1_P4 =  Dict+_test_Div_RoundAway_P2_N1 :: Dict (K.Div 'K.RoundAway (P 2) (N 1) ~ N 2)+_test_Div_RoundAway_P2_N1 =  Dict+_test_Rem_RoundAway_P2_N1 :: Dict (K.Rem 'K.RoundAway (P 2) (N 1) ~ Z)+_test_Rem_RoundAway_P2_N1 =  Dict+_test_Div_RoundAway_P2_N2 :: Dict (K.Div 'K.RoundAway (P 2) (N 2) ~ N 1)+_test_Div_RoundAway_P2_N2 =  Dict+_test_Rem_RoundAway_P2_N2 :: Dict (K.Rem 'K.RoundAway (P 2) (N 2) ~ Z)+_test_Rem_RoundAway_P2_N2 =  Dict+_test_Div_RoundAway_P2_N3 :: Dict (K.Div 'K.RoundAway (P 2) (N 3) ~ N 1)+_test_Div_RoundAway_P2_N3 =  Dict+_test_Rem_RoundAway_P2_N3 :: Dict (K.Rem 'K.RoundAway (P 2) (N 3) ~ N 1)+_test_Rem_RoundAway_P2_N3 =  Dict+_test_Div_RoundAway_P2_N4 :: Dict (K.Div 'K.RoundAway (P 2) (N 4) ~ N 1)+_test_Div_RoundAway_P2_N4 =  Dict+_test_Rem_RoundAway_P2_N4 :: Dict (K.Rem 'K.RoundAway (P 2) (N 4) ~ N 2)+_test_Rem_RoundAway_P2_N4 =  Dict+_test_Div_RoundAway_P2_P1 :: Dict (K.Div 'K.RoundAway (P 2) (P 1) ~ P 2)+_test_Div_RoundAway_P2_P1 =  Dict+_test_Rem_RoundAway_P2_P1 :: Dict (K.Rem 'K.RoundAway (P 2) (P 1) ~ Z)+_test_Rem_RoundAway_P2_P1 =  Dict+_test_Div_RoundAway_P2_P2 :: Dict (K.Div 'K.RoundAway (P 2) (P 2) ~ P 1)+_test_Div_RoundAway_P2_P2 =  Dict+_test_Rem_RoundAway_P2_P2 :: Dict (K.Rem 'K.RoundAway (P 2) (P 2) ~ Z)+_test_Rem_RoundAway_P2_P2 =  Dict+_test_Div_RoundAway_P2_P3 :: Dict (K.Div 'K.RoundAway (P 2) (P 3) ~ P 1)+_test_Div_RoundAway_P2_P3 =  Dict+_test_Rem_RoundAway_P2_P3 :: Dict (K.Rem 'K.RoundAway (P 2) (P 3) ~ N 1)+_test_Rem_RoundAway_P2_P3 =  Dict+_test_Div_RoundAway_P2_P4 :: Dict (K.Div 'K.RoundAway (P 2) (P 4) ~ P 1)+_test_Div_RoundAway_P2_P4 =  Dict+_test_Rem_RoundAway_P2_P4 :: Dict (K.Rem 'K.RoundAway (P 2) (P 4) ~ N 2)+_test_Rem_RoundAway_P2_P4 =  Dict+_test_Div_RoundAway_P3_N1 :: Dict (K.Div 'K.RoundAway (P 3) (N 1) ~ N 3)+_test_Div_RoundAway_P3_N1 =  Dict+_test_Rem_RoundAway_P3_N1 :: Dict (K.Rem 'K.RoundAway (P 3) (N 1) ~ Z)+_test_Rem_RoundAway_P3_N1 =  Dict+_test_Div_RoundAway_P3_N2 :: Dict (K.Div 'K.RoundAway (P 3) (N 2) ~ N 2)+_test_Div_RoundAway_P3_N2 =  Dict+_test_Rem_RoundAway_P3_N2 :: Dict (K.Rem 'K.RoundAway (P 3) (N 2) ~ N 1)+_test_Rem_RoundAway_P3_N2 =  Dict+_test_Div_RoundAway_P3_N3 :: Dict (K.Div 'K.RoundAway (P 3) (N 3) ~ N 1)+_test_Div_RoundAway_P3_N3 =  Dict+_test_Rem_RoundAway_P3_N3 :: Dict (K.Rem 'K.RoundAway (P 3) (N 3) ~ Z)+_test_Rem_RoundAway_P3_N3 =  Dict+_test_Div_RoundAway_P3_N4 :: Dict (K.Div 'K.RoundAway (P 3) (N 4) ~ N 1)+_test_Div_RoundAway_P3_N4 =  Dict+_test_Rem_RoundAway_P3_N4 :: Dict (K.Rem 'K.RoundAway (P 3) (N 4) ~ N 1)+_test_Rem_RoundAway_P3_N4 =  Dict+_test_Div_RoundAway_P3_P1 :: Dict (K.Div 'K.RoundAway (P 3) (P 1) ~ P 3)+_test_Div_RoundAway_P3_P1 =  Dict+_test_Rem_RoundAway_P3_P1 :: Dict (K.Rem 'K.RoundAway (P 3) (P 1) ~ Z)+_test_Rem_RoundAway_P3_P1 =  Dict+_test_Div_RoundAway_P3_P2 :: Dict (K.Div 'K.RoundAway (P 3) (P 2) ~ P 2)+_test_Div_RoundAway_P3_P2 =  Dict+_test_Rem_RoundAway_P3_P2 :: Dict (K.Rem 'K.RoundAway (P 3) (P 2) ~ N 1)+_test_Rem_RoundAway_P3_P2 =  Dict+_test_Div_RoundAway_P3_P3 :: Dict (K.Div 'K.RoundAway (P 3) (P 3) ~ P 1)+_test_Div_RoundAway_P3_P3 =  Dict+_test_Rem_RoundAway_P3_P3 :: Dict (K.Rem 'K.RoundAway (P 3) (P 3) ~ Z)+_test_Rem_RoundAway_P3_P3 =  Dict+_test_Div_RoundAway_P3_P4 :: Dict (K.Div 'K.RoundAway (P 3) (P 4) ~ P 1)+_test_Div_RoundAway_P3_P4 =  Dict+_test_Rem_RoundAway_P3_P4 :: Dict (K.Rem 'K.RoundAway (P 3) (P 4) ~ N 1)+_test_Rem_RoundAway_P3_P4 =  Dict+_test_Div_RoundAway_P4_N1 :: Dict (K.Div 'K.RoundAway (P 4) (N 1) ~ N 4)+_test_Div_RoundAway_P4_N1 =  Dict+_test_Rem_RoundAway_P4_N1 :: Dict (K.Rem 'K.RoundAway (P 4) (N 1) ~ Z)+_test_Rem_RoundAway_P4_N1 =  Dict+_test_Div_RoundAway_P4_N2 :: Dict (K.Div 'K.RoundAway (P 4) (N 2) ~ N 2)+_test_Div_RoundAway_P4_N2 =  Dict+_test_Rem_RoundAway_P4_N2 :: Dict (K.Rem 'K.RoundAway (P 4) (N 2) ~ Z)+_test_Rem_RoundAway_P4_N2 =  Dict+_test_Div_RoundAway_P4_N3 :: Dict (K.Div 'K.RoundAway (P 4) (N 3) ~ N 2)+_test_Div_RoundAway_P4_N3 =  Dict+_test_Rem_RoundAway_P4_N3 :: Dict (K.Rem 'K.RoundAway (P 4) (N 3) ~ N 2)+_test_Rem_RoundAway_P4_N3 =  Dict+_test_Div_RoundAway_P4_N4 :: Dict (K.Div 'K.RoundAway (P 4) (N 4) ~ N 1)+_test_Div_RoundAway_P4_N4 =  Dict+_test_Rem_RoundAway_P4_N4 :: Dict (K.Rem 'K.RoundAway (P 4) (N 4) ~ Z)+_test_Rem_RoundAway_P4_N4 =  Dict+_test_Div_RoundAway_P4_P1 :: Dict (K.Div 'K.RoundAway (P 4) (P 1) ~ P 4)+_test_Div_RoundAway_P4_P1 =  Dict+_test_Rem_RoundAway_P4_P1 :: Dict (K.Rem 'K.RoundAway (P 4) (P 1) ~ Z)+_test_Rem_RoundAway_P4_P1 =  Dict+_test_Div_RoundAway_P4_P2 :: Dict (K.Div 'K.RoundAway (P 4) (P 2) ~ P 2)+_test_Div_RoundAway_P4_P2 =  Dict+_test_Rem_RoundAway_P4_P2 :: Dict (K.Rem 'K.RoundAway (P 4) (P 2) ~ Z)+_test_Rem_RoundAway_P4_P2 =  Dict+_test_Div_RoundAway_P4_P3 :: Dict (K.Div 'K.RoundAway (P 4) (P 3) ~ P 2)+_test_Div_RoundAway_P4_P3 =  Dict+_test_Rem_RoundAway_P4_P3 :: Dict (K.Rem 'K.RoundAway (P 4) (P 3) ~ N 2)+_test_Rem_RoundAway_P4_P3 =  Dict+_test_Div_RoundAway_P4_P4 :: Dict (K.Div 'K.RoundAway (P 4) (P 4) ~ P 1)+_test_Div_RoundAway_P4_P4 =  Dict+_test_Rem_RoundAway_P4_P4 :: Dict (K.Rem 'K.RoundAway (P 4) (P 4) ~ Z)+_test_Rem_RoundAway_P4_P4 =  Dict+_test_Div_RoundDown_N1_N1 :: Dict (K.Div 'K.RoundDown (N 1) (N 1) ~ P 1)+_test_Div_RoundDown_N1_N1 =  Dict+_test_Rem_RoundDown_N1_N1 :: Dict (K.Rem 'K.RoundDown (N 1) (N 1) ~ Z)+_test_Rem_RoundDown_N1_N1 =  Dict+_test_Div_RoundDown_N1_N2 :: Dict (K.Div 'K.RoundDown (N 1) (N 2) ~ Z)+_test_Div_RoundDown_N1_N2 =  Dict+_test_Rem_RoundDown_N1_N2 :: Dict (K.Rem 'K.RoundDown (N 1) (N 2) ~ N 1)+_test_Rem_RoundDown_N1_N2 =  Dict+_test_Div_RoundDown_N1_N3 :: Dict (K.Div 'K.RoundDown (N 1) (N 3) ~ Z)+_test_Div_RoundDown_N1_N3 =  Dict+_test_Rem_RoundDown_N1_N3 :: Dict (K.Rem 'K.RoundDown (N 1) (N 3) ~ N 1)+_test_Rem_RoundDown_N1_N3 =  Dict+_test_Div_RoundDown_N1_N4 :: Dict (K.Div 'K.RoundDown (N 1) (N 4) ~ Z)+_test_Div_RoundDown_N1_N4 =  Dict+_test_Rem_RoundDown_N1_N4 :: Dict (K.Rem 'K.RoundDown (N 1) (N 4) ~ N 1)+_test_Rem_RoundDown_N1_N4 =  Dict+_test_Div_RoundDown_N1_P1 :: Dict (K.Div 'K.RoundDown (N 1) (P 1) ~ N 1)+_test_Div_RoundDown_N1_P1 =  Dict+_test_Rem_RoundDown_N1_P1 :: Dict (K.Rem 'K.RoundDown (N 1) (P 1) ~ Z)+_test_Rem_RoundDown_N1_P1 =  Dict+_test_Div_RoundDown_N1_P2 :: Dict (K.Div 'K.RoundDown (N 1) (P 2) ~ N 1)+_test_Div_RoundDown_N1_P2 =  Dict+_test_Rem_RoundDown_N1_P2 :: Dict (K.Rem 'K.RoundDown (N 1) (P 2) ~ P 1)+_test_Rem_RoundDown_N1_P2 =  Dict+_test_Div_RoundDown_N1_P3 :: Dict (K.Div 'K.RoundDown (N 1) (P 3) ~ N 1)+_test_Div_RoundDown_N1_P3 =  Dict+_test_Rem_RoundDown_N1_P3 :: Dict (K.Rem 'K.RoundDown (N 1) (P 3) ~ P 2)+_test_Rem_RoundDown_N1_P3 =  Dict+_test_Div_RoundDown_N1_P4 :: Dict (K.Div 'K.RoundDown (N 1) (P 4) ~ N 1)+_test_Div_RoundDown_N1_P4 =  Dict+_test_Rem_RoundDown_N1_P4 :: Dict (K.Rem 'K.RoundDown (N 1) (P 4) ~ P 3)+_test_Rem_RoundDown_N1_P4 =  Dict+_test_Div_RoundDown_N2_N1 :: Dict (K.Div 'K.RoundDown (N 2) (N 1) ~ P 2)+_test_Div_RoundDown_N2_N1 =  Dict+_test_Rem_RoundDown_N2_N1 :: Dict (K.Rem 'K.RoundDown (N 2) (N 1) ~ Z)+_test_Rem_RoundDown_N2_N1 =  Dict+_test_Div_RoundDown_N2_N2 :: Dict (K.Div 'K.RoundDown (N 2) (N 2) ~ P 1)+_test_Div_RoundDown_N2_N2 =  Dict+_test_Rem_RoundDown_N2_N2 :: Dict (K.Rem 'K.RoundDown (N 2) (N 2) ~ Z)+_test_Rem_RoundDown_N2_N2 =  Dict+_test_Div_RoundDown_N2_N3 :: Dict (K.Div 'K.RoundDown (N 2) (N 3) ~ Z)+_test_Div_RoundDown_N2_N3 =  Dict+_test_Rem_RoundDown_N2_N3 :: Dict (K.Rem 'K.RoundDown (N 2) (N 3) ~ N 2)+_test_Rem_RoundDown_N2_N3 =  Dict+_test_Div_RoundDown_N2_N4 :: Dict (K.Div 'K.RoundDown (N 2) (N 4) ~ Z)+_test_Div_RoundDown_N2_N4 =  Dict+_test_Rem_RoundDown_N2_N4 :: Dict (K.Rem 'K.RoundDown (N 2) (N 4) ~ N 2)+_test_Rem_RoundDown_N2_N4 =  Dict+_test_Div_RoundDown_N2_P1 :: Dict (K.Div 'K.RoundDown (N 2) (P 1) ~ N 2)+_test_Div_RoundDown_N2_P1 =  Dict+_test_Rem_RoundDown_N2_P1 :: Dict (K.Rem 'K.RoundDown (N 2) (P 1) ~ Z)+_test_Rem_RoundDown_N2_P1 =  Dict+_test_Div_RoundDown_N2_P2 :: Dict (K.Div 'K.RoundDown (N 2) (P 2) ~ N 1)+_test_Div_RoundDown_N2_P2 =  Dict+_test_Rem_RoundDown_N2_P2 :: Dict (K.Rem 'K.RoundDown (N 2) (P 2) ~ Z)+_test_Rem_RoundDown_N2_P2 =  Dict+_test_Div_RoundDown_N2_P3 :: Dict (K.Div 'K.RoundDown (N 2) (P 3) ~ N 1)+_test_Div_RoundDown_N2_P3 =  Dict+_test_Rem_RoundDown_N2_P3 :: Dict (K.Rem 'K.RoundDown (N 2) (P 3) ~ P 1)+_test_Rem_RoundDown_N2_P3 =  Dict+_test_Div_RoundDown_N2_P4 :: Dict (K.Div 'K.RoundDown (N 2) (P 4) ~ N 1)+_test_Div_RoundDown_N2_P4 =  Dict+_test_Rem_RoundDown_N2_P4 :: Dict (K.Rem 'K.RoundDown (N 2) (P 4) ~ P 2)+_test_Rem_RoundDown_N2_P4 =  Dict+_test_Div_RoundDown_N3_N1 :: Dict (K.Div 'K.RoundDown (N 3) (N 1) ~ P 3)+_test_Div_RoundDown_N3_N1 =  Dict+_test_Rem_RoundDown_N3_N1 :: Dict (K.Rem 'K.RoundDown (N 3) (N 1) ~ Z)+_test_Rem_RoundDown_N3_N1 =  Dict+_test_Div_RoundDown_N3_N2 :: Dict (K.Div 'K.RoundDown (N 3) (N 2) ~ P 1)+_test_Div_RoundDown_N3_N2 =  Dict+_test_Rem_RoundDown_N3_N2 :: Dict (K.Rem 'K.RoundDown (N 3) (N 2) ~ N 1)+_test_Rem_RoundDown_N3_N2 =  Dict+_test_Div_RoundDown_N3_N3 :: Dict (K.Div 'K.RoundDown (N 3) (N 3) ~ P 1)+_test_Div_RoundDown_N3_N3 =  Dict+_test_Rem_RoundDown_N3_N3 :: Dict (K.Rem 'K.RoundDown (N 3) (N 3) ~ Z)+_test_Rem_RoundDown_N3_N3 =  Dict+_test_Div_RoundDown_N3_N4 :: Dict (K.Div 'K.RoundDown (N 3) (N 4) ~ Z)+_test_Div_RoundDown_N3_N4 =  Dict+_test_Rem_RoundDown_N3_N4 :: Dict (K.Rem 'K.RoundDown (N 3) (N 4) ~ N 3)+_test_Rem_RoundDown_N3_N4 =  Dict+_test_Div_RoundDown_N3_P1 :: Dict (K.Div 'K.RoundDown (N 3) (P 1) ~ N 3)+_test_Div_RoundDown_N3_P1 =  Dict+_test_Rem_RoundDown_N3_P1 :: Dict (K.Rem 'K.RoundDown (N 3) (P 1) ~ Z)+_test_Rem_RoundDown_N3_P1 =  Dict+_test_Div_RoundDown_N3_P2 :: Dict (K.Div 'K.RoundDown (N 3) (P 2) ~ N 2)+_test_Div_RoundDown_N3_P2 =  Dict+_test_Rem_RoundDown_N3_P2 :: Dict (K.Rem 'K.RoundDown (N 3) (P 2) ~ P 1)+_test_Rem_RoundDown_N3_P2 =  Dict+_test_Div_RoundDown_N3_P3 :: Dict (K.Div 'K.RoundDown (N 3) (P 3) ~ N 1)+_test_Div_RoundDown_N3_P3 =  Dict+_test_Rem_RoundDown_N3_P3 :: Dict (K.Rem 'K.RoundDown (N 3) (P 3) ~ Z)+_test_Rem_RoundDown_N3_P3 =  Dict+_test_Div_RoundDown_N3_P4 :: Dict (K.Div 'K.RoundDown (N 3) (P 4) ~ N 1)+_test_Div_RoundDown_N3_P4 =  Dict+_test_Rem_RoundDown_N3_P4 :: Dict (K.Rem 'K.RoundDown (N 3) (P 4) ~ P 1)+_test_Rem_RoundDown_N3_P4 =  Dict+_test_Div_RoundDown_N4_N1 :: Dict (K.Div 'K.RoundDown (N 4) (N 1) ~ P 4)+_test_Div_RoundDown_N4_N1 =  Dict+_test_Rem_RoundDown_N4_N1 :: Dict (K.Rem 'K.RoundDown (N 4) (N 1) ~ Z)+_test_Rem_RoundDown_N4_N1 =  Dict+_test_Div_RoundDown_N4_N2 :: Dict (K.Div 'K.RoundDown (N 4) (N 2) ~ P 2)+_test_Div_RoundDown_N4_N2 =  Dict+_test_Rem_RoundDown_N4_N2 :: Dict (K.Rem 'K.RoundDown (N 4) (N 2) ~ Z)+_test_Rem_RoundDown_N4_N2 =  Dict+_test_Div_RoundDown_N4_N3 :: Dict (K.Div 'K.RoundDown (N 4) (N 3) ~ P 1)+_test_Div_RoundDown_N4_N3 =  Dict+_test_Rem_RoundDown_N4_N3 :: Dict (K.Rem 'K.RoundDown (N 4) (N 3) ~ N 1)+_test_Rem_RoundDown_N4_N3 =  Dict+_test_Div_RoundDown_N4_N4 :: Dict (K.Div 'K.RoundDown (N 4) (N 4) ~ P 1)+_test_Div_RoundDown_N4_N4 =  Dict+_test_Rem_RoundDown_N4_N4 :: Dict (K.Rem 'K.RoundDown (N 4) (N 4) ~ Z)+_test_Rem_RoundDown_N4_N4 =  Dict+_test_Div_RoundDown_N4_P1 :: Dict (K.Div 'K.RoundDown (N 4) (P 1) ~ N 4)+_test_Div_RoundDown_N4_P1 =  Dict+_test_Rem_RoundDown_N4_P1 :: Dict (K.Rem 'K.RoundDown (N 4) (P 1) ~ Z)+_test_Rem_RoundDown_N4_P1 =  Dict+_test_Div_RoundDown_N4_P2 :: Dict (K.Div 'K.RoundDown (N 4) (P 2) ~ N 2)+_test_Div_RoundDown_N4_P2 =  Dict+_test_Rem_RoundDown_N4_P2 :: Dict (K.Rem 'K.RoundDown (N 4) (P 2) ~ Z)+_test_Rem_RoundDown_N4_P2 =  Dict+_test_Div_RoundDown_N4_P3 :: Dict (K.Div 'K.RoundDown (N 4) (P 3) ~ N 2)+_test_Div_RoundDown_N4_P3 =  Dict+_test_Rem_RoundDown_N4_P3 :: Dict (K.Rem 'K.RoundDown (N 4) (P 3) ~ P 2)+_test_Rem_RoundDown_N4_P3 =  Dict+_test_Div_RoundDown_N4_P4 :: Dict (K.Div 'K.RoundDown (N 4) (P 4) ~ N 1)+_test_Div_RoundDown_N4_P4 =  Dict+_test_Rem_RoundDown_N4_P4 :: Dict (K.Rem 'K.RoundDown (N 4) (P 4) ~ Z)+_test_Rem_RoundDown_N4_P4 =  Dict+_test_Rem_RoundDown_Z_N1 :: Dict (K.Rem 'K.RoundDown Z (N 1) ~ Z)+_test_Rem_RoundDown_Z_N1 =  Dict+_test_Rem_RoundDown_Z_N2 :: Dict (K.Rem 'K.RoundDown Z (N 2) ~ Z)+_test_Rem_RoundDown_Z_N2 =  Dict+_test_Rem_RoundDown_Z_N3 :: Dict (K.Rem 'K.RoundDown Z (N 3) ~ Z)+_test_Rem_RoundDown_Z_N3 =  Dict+_test_Rem_RoundDown_Z_N4 :: Dict (K.Rem 'K.RoundDown Z (N 4) ~ Z)+_test_Rem_RoundDown_Z_N4 =  Dict+_test_Rem_RoundDown_Z_P1 :: Dict (K.Rem 'K.RoundDown Z (P 1) ~ Z)+_test_Rem_RoundDown_Z_P1 =  Dict+_test_Rem_RoundDown_Z_P2 :: Dict (K.Rem 'K.RoundDown Z (P 2) ~ Z)+_test_Rem_RoundDown_Z_P2 =  Dict+_test_Rem_RoundDown_Z_P3 :: Dict (K.Rem 'K.RoundDown Z (P 3) ~ Z)+_test_Rem_RoundDown_Z_P3 =  Dict+_test_Rem_RoundDown_Z_P4 :: Dict (K.Rem 'K.RoundDown Z (P 4) ~ Z)+_test_Rem_RoundDown_Z_P4 =  Dict+_test_Rem_RoundDown_P1_N1 :: Dict (K.Rem 'K.RoundDown (P 1) (N 1) ~ Z)+_test_Rem_RoundDown_P1_N1 =  Dict+_test_Rem_RoundDown_P1_N2 :: Dict (K.Rem 'K.RoundDown (P 1) (N 2) ~ N 1)+_test_Rem_RoundDown_P1_N2 =  Dict+_test_Rem_RoundDown_P1_N3 :: Dict (K.Rem 'K.RoundDown (P 1) (N 3) ~ N 2)+_test_Rem_RoundDown_P1_N3 =  Dict+_test_Rem_RoundDown_P1_N4 :: Dict (K.Rem 'K.RoundDown (P 1) (N 4) ~ N 3)+_test_Rem_RoundDown_P1_N4 =  Dict+_test_Div_RoundDown_P1_P1 :: Dict (K.Div 'K.RoundDown (P 1) (P 1) ~ P 1)+_test_Div_RoundDown_P1_P1 =  Dict+_test_Rem_RoundDown_P1_P1 :: Dict (K.Rem 'K.RoundDown (P 1) (P 1) ~ Z)+_test_Rem_RoundDown_P1_P1 =  Dict+_test_Div_RoundDown_P1_P2 :: Dict (K.Div 'K.RoundDown (P 1) (P 2) ~ Z)+_test_Div_RoundDown_P1_P2 =  Dict+_test_Rem_RoundDown_P1_P2 :: Dict (K.Rem 'K.RoundDown (P 1) (P 2) ~ P 1)+_test_Rem_RoundDown_P1_P2 =  Dict+_test_Div_RoundDown_P1_P3 :: Dict (K.Div 'K.RoundDown (P 1) (P 3) ~ Z)+_test_Div_RoundDown_P1_P3 =  Dict+_test_Rem_RoundDown_P1_P3 :: Dict (K.Rem 'K.RoundDown (P 1) (P 3) ~ P 1)+_test_Rem_RoundDown_P1_P3 =  Dict+_test_Div_RoundDown_P1_P4 :: Dict (K.Div 'K.RoundDown (P 1) (P 4) ~ Z)+_test_Div_RoundDown_P1_P4 =  Dict+_test_Rem_RoundDown_P1_P4 :: Dict (K.Rem 'K.RoundDown (P 1) (P 4) ~ P 1)+_test_Rem_RoundDown_P1_P4 =  Dict+_test_Div_RoundDown_P2_N1 :: Dict (K.Div 'K.RoundDown (P 2) (N 1) ~ N 2)+_test_Div_RoundDown_P2_N1 =  Dict+_test_Rem_RoundDown_P2_N1 :: Dict (K.Rem 'K.RoundDown (P 2) (N 1) ~ Z)+_test_Rem_RoundDown_P2_N1 =  Dict+_test_Div_RoundDown_P2_N2 :: Dict (K.Div 'K.RoundDown (P 2) (N 2) ~ N 1)+_test_Div_RoundDown_P2_N2 =  Dict+_test_Rem_RoundDown_P2_N2 :: Dict (K.Rem 'K.RoundDown (P 2) (N 2) ~ Z)+_test_Rem_RoundDown_P2_N2 =  Dict+_test_Div_RoundDown_P2_N3 :: Dict (K.Div 'K.RoundDown (P 2) (N 3) ~ N 1)+_test_Div_RoundDown_P2_N3 =  Dict+_test_Rem_RoundDown_P2_N3 :: Dict (K.Rem 'K.RoundDown (P 2) (N 3) ~ N 1)+_test_Rem_RoundDown_P2_N3 =  Dict+_test_Div_RoundDown_P2_N4 :: Dict (K.Div 'K.RoundDown (P 2) (N 4) ~ N 1)+_test_Div_RoundDown_P2_N4 =  Dict+_test_Rem_RoundDown_P2_N4 :: Dict (K.Rem 'K.RoundDown (P 2) (N 4) ~ N 2)+_test_Rem_RoundDown_P2_N4 =  Dict+_test_Div_RoundDown_P2_P1 :: Dict (K.Div 'K.RoundDown (P 2) (P 1) ~ P 2)+_test_Div_RoundDown_P2_P1 =  Dict+_test_Rem_RoundDown_P2_P1 :: Dict (K.Rem 'K.RoundDown (P 2) (P 1) ~ Z)+_test_Rem_RoundDown_P2_P1 =  Dict+_test_Div_RoundDown_P2_P2 :: Dict (K.Div 'K.RoundDown (P 2) (P 2) ~ P 1)+_test_Div_RoundDown_P2_P2 =  Dict+_test_Rem_RoundDown_P2_P2 :: Dict (K.Rem 'K.RoundDown (P 2) (P 2) ~ Z)+_test_Rem_RoundDown_P2_P2 =  Dict+_test_Div_RoundDown_P2_P3 :: Dict (K.Div 'K.RoundDown (P 2) (P 3) ~ Z)+_test_Div_RoundDown_P2_P3 =  Dict+_test_Rem_RoundDown_P2_P3 :: Dict (K.Rem 'K.RoundDown (P 2) (P 3) ~ P 2)+_test_Rem_RoundDown_P2_P3 =  Dict+_test_Div_RoundDown_P2_P4 :: Dict (K.Div 'K.RoundDown (P 2) (P 4) ~ Z)+_test_Div_RoundDown_P2_P4 =  Dict+_test_Rem_RoundDown_P2_P4 :: Dict (K.Rem 'K.RoundDown (P 2) (P 4) ~ P 2)+_test_Rem_RoundDown_P2_P4 =  Dict+_test_Div_RoundDown_P3_N1 :: Dict (K.Div 'K.RoundDown (P 3) (N 1) ~ N 3)+_test_Div_RoundDown_P3_N1 =  Dict+_test_Rem_RoundDown_P3_N1 :: Dict (K.Rem 'K.RoundDown (P 3) (N 1) ~ Z)+_test_Rem_RoundDown_P3_N1 =  Dict+_test_Div_RoundDown_P3_N2 :: Dict (K.Div 'K.RoundDown (P 3) (N 2) ~ N 2)+_test_Div_RoundDown_P3_N2 =  Dict+_test_Rem_RoundDown_P3_N2 :: Dict (K.Rem 'K.RoundDown (P 3) (N 2) ~ N 1)+_test_Rem_RoundDown_P3_N2 =  Dict+_test_Div_RoundDown_P3_N3 :: Dict (K.Div 'K.RoundDown (P 3) (N 3) ~ N 1)+_test_Div_RoundDown_P3_N3 =  Dict+_test_Rem_RoundDown_P3_N3 :: Dict (K.Rem 'K.RoundDown (P 3) (N 3) ~ Z)+_test_Rem_RoundDown_P3_N3 =  Dict+_test_Div_RoundDown_P3_N4 :: Dict (K.Div 'K.RoundDown (P 3) (N 4) ~ N 1)+_test_Div_RoundDown_P3_N4 =  Dict+_test_Rem_RoundDown_P3_N4 :: Dict (K.Rem 'K.RoundDown (P 3) (N 4) ~ N 1)+_test_Rem_RoundDown_P3_N4 =  Dict+_test_Div_RoundDown_P3_P1 :: Dict (K.Div 'K.RoundDown (P 3) (P 1) ~ P 3)+_test_Div_RoundDown_P3_P1 =  Dict+_test_Rem_RoundDown_P3_P1 :: Dict (K.Rem 'K.RoundDown (P 3) (P 1) ~ Z)+_test_Rem_RoundDown_P3_P1 =  Dict+_test_Div_RoundDown_P3_P2 :: Dict (K.Div 'K.RoundDown (P 3) (P 2) ~ P 1)+_test_Div_RoundDown_P3_P2 =  Dict+_test_Rem_RoundDown_P3_P2 :: Dict (K.Rem 'K.RoundDown (P 3) (P 2) ~ P 1)+_test_Rem_RoundDown_P3_P2 =  Dict+_test_Div_RoundDown_P3_P3 :: Dict (K.Div 'K.RoundDown (P 3) (P 3) ~ P 1)+_test_Div_RoundDown_P3_P3 =  Dict+_test_Rem_RoundDown_P3_P3 :: Dict (K.Rem 'K.RoundDown (P 3) (P 3) ~ Z)+_test_Rem_RoundDown_P3_P3 =  Dict+_test_Div_RoundDown_P3_P4 :: Dict (K.Div 'K.RoundDown (P 3) (P 4) ~ Z)+_test_Div_RoundDown_P3_P4 =  Dict+_test_Rem_RoundDown_P3_P4 :: Dict (K.Rem 'K.RoundDown (P 3) (P 4) ~ P 3)+_test_Rem_RoundDown_P3_P4 =  Dict+_test_Div_RoundDown_P4_N1 :: Dict (K.Div 'K.RoundDown (P 4) (N 1) ~ N 4)+_test_Div_RoundDown_P4_N1 =  Dict+_test_Rem_RoundDown_P4_N1 :: Dict (K.Rem 'K.RoundDown (P 4) (N 1) ~ Z)+_test_Rem_RoundDown_P4_N1 =  Dict+_test_Div_RoundDown_P4_N2 :: Dict (K.Div 'K.RoundDown (P 4) (N 2) ~ N 2)+_test_Div_RoundDown_P4_N2 =  Dict+_test_Rem_RoundDown_P4_N2 :: Dict (K.Rem 'K.RoundDown (P 4) (N 2) ~ Z)+_test_Rem_RoundDown_P4_N2 =  Dict+_test_Div_RoundDown_P4_N3 :: Dict (K.Div 'K.RoundDown (P 4) (N 3) ~ N 2)+_test_Div_RoundDown_P4_N3 =  Dict+_test_Rem_RoundDown_P4_N3 :: Dict (K.Rem 'K.RoundDown (P 4) (N 3) ~ N 2)+_test_Rem_RoundDown_P4_N3 =  Dict+_test_Div_RoundDown_P4_N4 :: Dict (K.Div 'K.RoundDown (P 4) (N 4) ~ N 1)+_test_Div_RoundDown_P4_N4 =  Dict+_test_Rem_RoundDown_P4_N4 :: Dict (K.Rem 'K.RoundDown (P 4) (N 4) ~ Z)+_test_Rem_RoundDown_P4_N4 =  Dict+_test_Div_RoundDown_P4_P1 :: Dict (K.Div 'K.RoundDown (P 4) (P 1) ~ P 4)+_test_Div_RoundDown_P4_P1 =  Dict+_test_Rem_RoundDown_P4_P1 :: Dict (K.Rem 'K.RoundDown (P 4) (P 1) ~ Z)+_test_Rem_RoundDown_P4_P1 =  Dict+_test_Div_RoundDown_P4_P2 :: Dict (K.Div 'K.RoundDown (P 4) (P 2) ~ P 2)+_test_Div_RoundDown_P4_P2 =  Dict+_test_Rem_RoundDown_P4_P2 :: Dict (K.Rem 'K.RoundDown (P 4) (P 2) ~ Z)+_test_Rem_RoundDown_P4_P2 =  Dict+_test_Div_RoundDown_P4_P3 :: Dict (K.Div 'K.RoundDown (P 4) (P 3) ~ P 1)+_test_Div_RoundDown_P4_P3 =  Dict+_test_Rem_RoundDown_P4_P3 :: Dict (K.Rem 'K.RoundDown (P 4) (P 3) ~ P 1)+_test_Rem_RoundDown_P4_P3 =  Dict+_test_Div_RoundDown_P4_P4 :: Dict (K.Div 'K.RoundDown (P 4) (P 4) ~ P 1)+_test_Div_RoundDown_P4_P4 =  Dict+_test_Rem_RoundDown_P4_P4 :: Dict (K.Rem 'K.RoundDown (P 4) (P 4) ~ Z)+_test_Rem_RoundDown_P4_P4 =  Dict+_test_Div_RoundHalfAway_N1_N1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfAway_N1_N1 =  Dict+_test_Rem_RoundHalfAway_N1_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfAway_N1_N1 =  Dict+_test_Div_RoundHalfAway_N1_N2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 2) ~ P 1)+_test_Div_RoundHalfAway_N1_N2 =  Dict+_test_Rem_RoundHalfAway_N1_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 2) ~ P 1)+_test_Rem_RoundHalfAway_N1_N2 =  Dict+_test_Div_RoundHalfAway_N1_N3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 3) ~ Z)+_test_Div_RoundHalfAway_N1_N3 =  Dict+_test_Rem_RoundHalfAway_N1_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfAway_N1_N3 =  Dict+_test_Div_RoundHalfAway_N1_N4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (N 4) ~ Z)+_test_Div_RoundHalfAway_N1_N4 =  Dict+_test_Rem_RoundHalfAway_N1_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfAway_N1_N4 =  Dict+_test_Div_RoundHalfAway_N1_P1 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfAway_N1_P1 =  Dict+_test_Rem_RoundHalfAway_N1_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfAway_N1_P1 =  Dict+_test_Div_RoundHalfAway_N1_P2 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 2) ~ N 1)+_test_Div_RoundHalfAway_N1_P2 =  Dict+_test_Rem_RoundHalfAway_N1_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 2) ~ P 1)+_test_Rem_RoundHalfAway_N1_P2 =  Dict+_test_Div_RoundHalfAway_N1_P3 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 3) ~ Z)+_test_Div_RoundHalfAway_N1_P3 =  Dict+_test_Rem_RoundHalfAway_N1_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfAway_N1_P3 =  Dict+_test_Div_RoundHalfAway_N1_P4 :: Dict (K.Div 'K.RoundHalfAway (N 1) (P 4) ~ Z)+_test_Div_RoundHalfAway_N1_P4 =  Dict+_test_Rem_RoundHalfAway_N1_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfAway_N1_P4 =  Dict+_test_Div_RoundHalfAway_N2_N1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfAway_N2_N1 =  Dict+_test_Rem_RoundHalfAway_N2_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfAway_N2_N1 =  Dict+_test_Div_RoundHalfAway_N2_N2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfAway_N2_N2 =  Dict+_test_Rem_RoundHalfAway_N2_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfAway_N2_N2 =  Dict+_test_Div_RoundHalfAway_N2_N3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfAway_N2_N3 =  Dict+_test_Rem_RoundHalfAway_N2_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfAway_N2_N3 =  Dict+_test_Div_RoundHalfAway_N2_N4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (N 4) ~ P 1)+_test_Div_RoundHalfAway_N2_N4 =  Dict+_test_Rem_RoundHalfAway_N2_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (N 4) ~ P 2)+_test_Rem_RoundHalfAway_N2_N4 =  Dict+_test_Div_RoundHalfAway_N2_P1 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfAway_N2_P1 =  Dict+_test_Rem_RoundHalfAway_N2_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfAway_N2_P1 =  Dict+_test_Div_RoundHalfAway_N2_P2 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfAway_N2_P2 =  Dict+_test_Rem_RoundHalfAway_N2_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfAway_N2_P2 =  Dict+_test_Div_RoundHalfAway_N2_P3 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfAway_N2_P3 =  Dict+_test_Rem_RoundHalfAway_N2_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfAway_N2_P3 =  Dict+_test_Div_RoundHalfAway_N2_P4 :: Dict (K.Div 'K.RoundHalfAway (N 2) (P 4) ~ N 1)+_test_Div_RoundHalfAway_N2_P4 =  Dict+_test_Rem_RoundHalfAway_N2_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 2) (P 4) ~ P 2)+_test_Rem_RoundHalfAway_N2_P4 =  Dict+_test_Div_RoundHalfAway_N3_N1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfAway_N3_N1 =  Dict+_test_Rem_RoundHalfAway_N3_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfAway_N3_N1 =  Dict+_test_Div_RoundHalfAway_N3_N2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 2) ~ P 2)+_test_Div_RoundHalfAway_N3_N2 =  Dict+_test_Rem_RoundHalfAway_N3_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 2) ~ P 1)+_test_Rem_RoundHalfAway_N3_N2 =  Dict+_test_Div_RoundHalfAway_N3_N3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfAway_N3_N3 =  Dict+_test_Rem_RoundHalfAway_N3_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfAway_N3_N3 =  Dict+_test_Div_RoundHalfAway_N3_N4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfAway_N3_N4 =  Dict+_test_Rem_RoundHalfAway_N3_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfAway_N3_N4 =  Dict+_test_Div_RoundHalfAway_N3_P1 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfAway_N3_P1 =  Dict+_test_Rem_RoundHalfAway_N3_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfAway_N3_P1 =  Dict+_test_Div_RoundHalfAway_N3_P2 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 2) ~ N 2)+_test_Div_RoundHalfAway_N3_P2 =  Dict+_test_Rem_RoundHalfAway_N3_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 2) ~ P 1)+_test_Rem_RoundHalfAway_N3_P2 =  Dict+_test_Div_RoundHalfAway_N3_P3 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfAway_N3_P3 =  Dict+_test_Rem_RoundHalfAway_N3_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfAway_N3_P3 =  Dict+_test_Div_RoundHalfAway_N3_P4 :: Dict (K.Div 'K.RoundHalfAway (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfAway_N3_P4 =  Dict+_test_Rem_RoundHalfAway_N3_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfAway_N3_P4 =  Dict+_test_Div_RoundHalfAway_N4_N1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfAway_N4_N1 =  Dict+_test_Rem_RoundHalfAway_N4_N1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfAway_N4_N1 =  Dict+_test_Div_RoundHalfAway_N4_N2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfAway_N4_N2 =  Dict+_test_Rem_RoundHalfAway_N4_N2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfAway_N4_N2 =  Dict+_test_Div_RoundHalfAway_N4_N3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfAway_N4_N3 =  Dict+_test_Rem_RoundHalfAway_N4_N3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfAway_N4_N3 =  Dict+_test_Div_RoundHalfAway_N4_N4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfAway_N4_N4 =  Dict+_test_Rem_RoundHalfAway_N4_N4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfAway_N4_N4 =  Dict+_test_Div_RoundHalfAway_N4_P1 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfAway_N4_P1 =  Dict+_test_Rem_RoundHalfAway_N4_P1 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfAway_N4_P1 =  Dict+_test_Div_RoundHalfAway_N4_P2 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfAway_N4_P2 =  Dict+_test_Rem_RoundHalfAway_N4_P2 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfAway_N4_P2 =  Dict+_test_Div_RoundHalfAway_N4_P3 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfAway_N4_P3 =  Dict+_test_Rem_RoundHalfAway_N4_P3 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfAway_N4_P3 =  Dict+_test_Div_RoundHalfAway_N4_P4 :: Dict (K.Div 'K.RoundHalfAway (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfAway_N4_P4 =  Dict+_test_Rem_RoundHalfAway_N4_P4 :: Dict (K.Rem 'K.RoundHalfAway (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfAway_N4_P4 =  Dict+_test_Rem_RoundHalfAway_Z_N1 :: Dict (K.Rem 'K.RoundHalfAway Z (N 1) ~ Z)+_test_Rem_RoundHalfAway_Z_N1 =  Dict+_test_Rem_RoundHalfAway_Z_N2 :: Dict (K.Rem 'K.RoundHalfAway Z (N 2) ~ Z)+_test_Rem_RoundHalfAway_Z_N2 =  Dict+_test_Rem_RoundHalfAway_Z_N3 :: Dict (K.Rem 'K.RoundHalfAway Z (N 3) ~ Z)+_test_Rem_RoundHalfAway_Z_N3 =  Dict+_test_Rem_RoundHalfAway_Z_N4 :: Dict (K.Rem 'K.RoundHalfAway Z (N 4) ~ Z)+_test_Rem_RoundHalfAway_Z_N4 =  Dict+_test_Rem_RoundHalfAway_Z_P1 :: Dict (K.Rem 'K.RoundHalfAway Z (P 1) ~ Z)+_test_Rem_RoundHalfAway_Z_P1 =  Dict+_test_Rem_RoundHalfAway_Z_P2 :: Dict (K.Rem 'K.RoundHalfAway Z (P 2) ~ Z)+_test_Rem_RoundHalfAway_Z_P2 =  Dict+_test_Rem_RoundHalfAway_Z_P3 :: Dict (K.Rem 'K.RoundHalfAway Z (P 3) ~ Z)+_test_Rem_RoundHalfAway_Z_P3 =  Dict+_test_Rem_RoundHalfAway_Z_P4 :: Dict (K.Rem 'K.RoundHalfAway Z (P 4) ~ Z)+_test_Rem_RoundHalfAway_Z_P4 =  Dict+_test_Div_RoundHalfAway_P1_N1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfAway_P1_N1 =  Dict+_test_Rem_RoundHalfAway_P1_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfAway_P1_N1 =  Dict+_test_Div_RoundHalfAway_P1_N2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 2) ~ N 1)+_test_Div_RoundHalfAway_P1_N2 =  Dict+_test_Rem_RoundHalfAway_P1_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 2) ~ N 1)+_test_Rem_RoundHalfAway_P1_N2 =  Dict+_test_Div_RoundHalfAway_P1_N3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 3) ~ Z)+_test_Div_RoundHalfAway_P1_N3 =  Dict+_test_Rem_RoundHalfAway_P1_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfAway_P1_N3 =  Dict+_test_Div_RoundHalfAway_P1_N4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (N 4) ~ Z)+_test_Div_RoundHalfAway_P1_N4 =  Dict+_test_Rem_RoundHalfAway_P1_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfAway_P1_N4 =  Dict+_test_Div_RoundHalfAway_P1_P1 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfAway_P1_P1 =  Dict+_test_Rem_RoundHalfAway_P1_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfAway_P1_P1 =  Dict+_test_Div_RoundHalfAway_P1_P2 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 2) ~ P 1)+_test_Div_RoundHalfAway_P1_P2 =  Dict+_test_Rem_RoundHalfAway_P1_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 2) ~ N 1)+_test_Rem_RoundHalfAway_P1_P2 =  Dict+_test_Div_RoundHalfAway_P1_P3 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 3) ~ Z)+_test_Div_RoundHalfAway_P1_P3 =  Dict+_test_Rem_RoundHalfAway_P1_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfAway_P1_P3 =  Dict+_test_Div_RoundHalfAway_P1_P4 :: Dict (K.Div 'K.RoundHalfAway (P 1) (P 4) ~ Z)+_test_Div_RoundHalfAway_P1_P4 =  Dict+_test_Rem_RoundHalfAway_P1_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfAway_P1_P4 =  Dict+_test_Div_RoundHalfAway_P2_N1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfAway_P2_N1 =  Dict+_test_Rem_RoundHalfAway_P2_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfAway_P2_N1 =  Dict+_test_Div_RoundHalfAway_P2_N2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfAway_P2_N2 =  Dict+_test_Rem_RoundHalfAway_P2_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfAway_P2_N2 =  Dict+_test_Div_RoundHalfAway_P2_N3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfAway_P2_N3 =  Dict+_test_Rem_RoundHalfAway_P2_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfAway_P2_N3 =  Dict+_test_Div_RoundHalfAway_P2_N4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (N 4) ~ N 1)+_test_Div_RoundHalfAway_P2_N4 =  Dict+_test_Rem_RoundHalfAway_P2_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (N 4) ~ N 2)+_test_Rem_RoundHalfAway_P2_N4 =  Dict+_test_Div_RoundHalfAway_P2_P1 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfAway_P2_P1 =  Dict+_test_Rem_RoundHalfAway_P2_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfAway_P2_P1 =  Dict+_test_Div_RoundHalfAway_P2_P2 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfAway_P2_P2 =  Dict+_test_Rem_RoundHalfAway_P2_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfAway_P2_P2 =  Dict+_test_Div_RoundHalfAway_P2_P3 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfAway_P2_P3 =  Dict+_test_Rem_RoundHalfAway_P2_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfAway_P2_P3 =  Dict+_test_Div_RoundHalfAway_P2_P4 :: Dict (K.Div 'K.RoundHalfAway (P 2) (P 4) ~ P 1)+_test_Div_RoundHalfAway_P2_P4 =  Dict+_test_Rem_RoundHalfAway_P2_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 2) (P 4) ~ N 2)+_test_Rem_RoundHalfAway_P2_P4 =  Dict+_test_Div_RoundHalfAway_P3_N1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfAway_P3_N1 =  Dict+_test_Rem_RoundHalfAway_P3_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfAway_P3_N1 =  Dict+_test_Div_RoundHalfAway_P3_N2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 2) ~ N 2)+_test_Div_RoundHalfAway_P3_N2 =  Dict+_test_Rem_RoundHalfAway_P3_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 2) ~ N 1)+_test_Rem_RoundHalfAway_P3_N2 =  Dict+_test_Div_RoundHalfAway_P3_N3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfAway_P3_N3 =  Dict+_test_Rem_RoundHalfAway_P3_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfAway_P3_N3 =  Dict+_test_Div_RoundHalfAway_P3_N4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfAway_P3_N4 =  Dict+_test_Rem_RoundHalfAway_P3_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfAway_P3_N4 =  Dict+_test_Div_RoundHalfAway_P3_P1 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfAway_P3_P1 =  Dict+_test_Rem_RoundHalfAway_P3_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfAway_P3_P1 =  Dict+_test_Div_RoundHalfAway_P3_P2 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 2) ~ P 2)+_test_Div_RoundHalfAway_P3_P2 =  Dict+_test_Rem_RoundHalfAway_P3_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 2) ~ N 1)+_test_Rem_RoundHalfAway_P3_P2 =  Dict+_test_Div_RoundHalfAway_P3_P3 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfAway_P3_P3 =  Dict+_test_Rem_RoundHalfAway_P3_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfAway_P3_P3 =  Dict+_test_Div_RoundHalfAway_P3_P4 :: Dict (K.Div 'K.RoundHalfAway (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfAway_P3_P4 =  Dict+_test_Rem_RoundHalfAway_P3_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfAway_P3_P4 =  Dict+_test_Div_RoundHalfAway_P4_N1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfAway_P4_N1 =  Dict+_test_Rem_RoundHalfAway_P4_N1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfAway_P4_N1 =  Dict+_test_Div_RoundHalfAway_P4_N2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfAway_P4_N2 =  Dict+_test_Rem_RoundHalfAway_P4_N2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfAway_P4_N2 =  Dict+_test_Div_RoundHalfAway_P4_N3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfAway_P4_N3 =  Dict+_test_Rem_RoundHalfAway_P4_N3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfAway_P4_N3 =  Dict+_test_Div_RoundHalfAway_P4_N4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfAway_P4_N4 =  Dict+_test_Rem_RoundHalfAway_P4_N4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfAway_P4_N4 =  Dict+_test_Div_RoundHalfAway_P4_P1 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfAway_P4_P1 =  Dict+_test_Rem_RoundHalfAway_P4_P1 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfAway_P4_P1 =  Dict+_test_Div_RoundHalfAway_P4_P2 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfAway_P4_P2 =  Dict+_test_Rem_RoundHalfAway_P4_P2 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfAway_P4_P2 =  Dict+_test_Div_RoundHalfAway_P4_P3 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfAway_P4_P3 =  Dict+_test_Rem_RoundHalfAway_P4_P3 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfAway_P4_P3 =  Dict+_test_Div_RoundHalfAway_P4_P4 :: Dict (K.Div 'K.RoundHalfAway (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfAway_P4_P4 =  Dict+_test_Rem_RoundHalfAway_P4_P4 :: Dict (K.Rem 'K.RoundHalfAway (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfAway_P4_P4 =  Dict+_test_Div_RoundHalfDown_N1_N1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfDown_N1_N1 =  Dict+_test_Rem_RoundHalfDown_N1_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfDown_N1_N1 =  Dict+_test_Div_RoundHalfDown_N1_N2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 2) ~ Z)+_test_Div_RoundHalfDown_N1_N2 =  Dict+_test_Rem_RoundHalfDown_N1_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 2) ~ N 1)+_test_Rem_RoundHalfDown_N1_N2 =  Dict+_test_Div_RoundHalfDown_N1_N3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 3) ~ Z)+_test_Div_RoundHalfDown_N1_N3 =  Dict+_test_Rem_RoundHalfDown_N1_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfDown_N1_N3 =  Dict+_test_Div_RoundHalfDown_N1_N4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (N 4) ~ Z)+_test_Div_RoundHalfDown_N1_N4 =  Dict+_test_Rem_RoundHalfDown_N1_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfDown_N1_N4 =  Dict+_test_Div_RoundHalfDown_N1_P1 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfDown_N1_P1 =  Dict+_test_Rem_RoundHalfDown_N1_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfDown_N1_P1 =  Dict+_test_Div_RoundHalfDown_N1_P2 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 2) ~ N 1)+_test_Div_RoundHalfDown_N1_P2 =  Dict+_test_Rem_RoundHalfDown_N1_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 2) ~ P 1)+_test_Rem_RoundHalfDown_N1_P2 =  Dict+_test_Div_RoundHalfDown_N1_P3 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 3) ~ Z)+_test_Div_RoundHalfDown_N1_P3 =  Dict+_test_Rem_RoundHalfDown_N1_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfDown_N1_P3 =  Dict+_test_Div_RoundHalfDown_N1_P4 :: Dict (K.Div 'K.RoundHalfDown (N 1) (P 4) ~ Z)+_test_Div_RoundHalfDown_N1_P4 =  Dict+_test_Rem_RoundHalfDown_N1_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfDown_N1_P4 =  Dict+_test_Div_RoundHalfDown_N2_N1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfDown_N2_N1 =  Dict+_test_Rem_RoundHalfDown_N2_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfDown_N2_N1 =  Dict+_test_Div_RoundHalfDown_N2_N2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfDown_N2_N2 =  Dict+_test_Rem_RoundHalfDown_N2_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfDown_N2_N2 =  Dict+_test_Div_RoundHalfDown_N2_N3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfDown_N2_N3 =  Dict+_test_Rem_RoundHalfDown_N2_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfDown_N2_N3 =  Dict+_test_Div_RoundHalfDown_N2_N4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (N 4) ~ Z)+_test_Div_RoundHalfDown_N2_N4 =  Dict+_test_Rem_RoundHalfDown_N2_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (N 4) ~ N 2)+_test_Rem_RoundHalfDown_N2_N4 =  Dict+_test_Div_RoundHalfDown_N2_P1 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfDown_N2_P1 =  Dict+_test_Rem_RoundHalfDown_N2_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfDown_N2_P1 =  Dict+_test_Div_RoundHalfDown_N2_P2 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfDown_N2_P2 =  Dict+_test_Rem_RoundHalfDown_N2_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfDown_N2_P2 =  Dict+_test_Div_RoundHalfDown_N2_P3 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfDown_N2_P3 =  Dict+_test_Rem_RoundHalfDown_N2_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfDown_N2_P3 =  Dict+_test_Div_RoundHalfDown_N2_P4 :: Dict (K.Div 'K.RoundHalfDown (N 2) (P 4) ~ N 1)+_test_Div_RoundHalfDown_N2_P4 =  Dict+_test_Rem_RoundHalfDown_N2_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 2) (P 4) ~ P 2)+_test_Rem_RoundHalfDown_N2_P4 =  Dict+_test_Div_RoundHalfDown_N3_N1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfDown_N3_N1 =  Dict+_test_Rem_RoundHalfDown_N3_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfDown_N3_N1 =  Dict+_test_Div_RoundHalfDown_N3_N2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 2) ~ P 1)+_test_Div_RoundHalfDown_N3_N2 =  Dict+_test_Rem_RoundHalfDown_N3_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 2) ~ N 1)+_test_Rem_RoundHalfDown_N3_N2 =  Dict+_test_Div_RoundHalfDown_N3_N3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfDown_N3_N3 =  Dict+_test_Rem_RoundHalfDown_N3_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfDown_N3_N3 =  Dict+_test_Div_RoundHalfDown_N3_N4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfDown_N3_N4 =  Dict+_test_Rem_RoundHalfDown_N3_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfDown_N3_N4 =  Dict+_test_Div_RoundHalfDown_N3_P1 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfDown_N3_P1 =  Dict+_test_Rem_RoundHalfDown_N3_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfDown_N3_P1 =  Dict+_test_Div_RoundHalfDown_N3_P2 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 2) ~ N 2)+_test_Div_RoundHalfDown_N3_P2 =  Dict+_test_Rem_RoundHalfDown_N3_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 2) ~ P 1)+_test_Rem_RoundHalfDown_N3_P2 =  Dict+_test_Div_RoundHalfDown_N3_P3 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfDown_N3_P3 =  Dict+_test_Rem_RoundHalfDown_N3_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfDown_N3_P3 =  Dict+_test_Div_RoundHalfDown_N3_P4 :: Dict (K.Div 'K.RoundHalfDown (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfDown_N3_P4 =  Dict+_test_Rem_RoundHalfDown_N3_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfDown_N3_P4 =  Dict+_test_Div_RoundHalfDown_N4_N1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfDown_N4_N1 =  Dict+_test_Rem_RoundHalfDown_N4_N1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfDown_N4_N1 =  Dict+_test_Div_RoundHalfDown_N4_N2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfDown_N4_N2 =  Dict+_test_Rem_RoundHalfDown_N4_N2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfDown_N4_N2 =  Dict+_test_Div_RoundHalfDown_N4_N3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfDown_N4_N3 =  Dict+_test_Rem_RoundHalfDown_N4_N3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfDown_N4_N3 =  Dict+_test_Div_RoundHalfDown_N4_N4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfDown_N4_N4 =  Dict+_test_Rem_RoundHalfDown_N4_N4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfDown_N4_N4 =  Dict+_test_Div_RoundHalfDown_N4_P1 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfDown_N4_P1 =  Dict+_test_Rem_RoundHalfDown_N4_P1 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfDown_N4_P1 =  Dict+_test_Div_RoundHalfDown_N4_P2 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfDown_N4_P2 =  Dict+_test_Rem_RoundHalfDown_N4_P2 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfDown_N4_P2 =  Dict+_test_Div_RoundHalfDown_N4_P3 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfDown_N4_P3 =  Dict+_test_Rem_RoundHalfDown_N4_P3 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfDown_N4_P3 =  Dict+_test_Div_RoundHalfDown_N4_P4 :: Dict (K.Div 'K.RoundHalfDown (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfDown_N4_P4 =  Dict+_test_Rem_RoundHalfDown_N4_P4 :: Dict (K.Rem 'K.RoundHalfDown (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfDown_N4_P4 =  Dict+_test_Rem_RoundHalfDown_Z_N1 :: Dict (K.Rem 'K.RoundHalfDown Z (N 1) ~ Z)+_test_Rem_RoundHalfDown_Z_N1 =  Dict+_test_Rem_RoundHalfDown_Z_N2 :: Dict (K.Rem 'K.RoundHalfDown Z (N 2) ~ Z)+_test_Rem_RoundHalfDown_Z_N2 =  Dict+_test_Rem_RoundHalfDown_Z_N3 :: Dict (K.Rem 'K.RoundHalfDown Z (N 3) ~ Z)+_test_Rem_RoundHalfDown_Z_N3 =  Dict+_test_Rem_RoundHalfDown_Z_N4 :: Dict (K.Rem 'K.RoundHalfDown Z (N 4) ~ Z)+_test_Rem_RoundHalfDown_Z_N4 =  Dict+_test_Rem_RoundHalfDown_Z_P1 :: Dict (K.Rem 'K.RoundHalfDown Z (P 1) ~ Z)+_test_Rem_RoundHalfDown_Z_P1 =  Dict+_test_Rem_RoundHalfDown_Z_P2 :: Dict (K.Rem 'K.RoundHalfDown Z (P 2) ~ Z)+_test_Rem_RoundHalfDown_Z_P2 =  Dict+_test_Rem_RoundHalfDown_Z_P3 :: Dict (K.Rem 'K.RoundHalfDown Z (P 3) ~ Z)+_test_Rem_RoundHalfDown_Z_P3 =  Dict+_test_Rem_RoundHalfDown_Z_P4 :: Dict (K.Rem 'K.RoundHalfDown Z (P 4) ~ Z)+_test_Rem_RoundHalfDown_Z_P4 =  Dict+_test_Div_RoundHalfDown_P1_N1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfDown_P1_N1 =  Dict+_test_Rem_RoundHalfDown_P1_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfDown_P1_N1 =  Dict+_test_Div_RoundHalfDown_P1_N2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 2) ~ N 1)+_test_Div_RoundHalfDown_P1_N2 =  Dict+_test_Rem_RoundHalfDown_P1_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 2) ~ N 1)+_test_Rem_RoundHalfDown_P1_N2 =  Dict+_test_Div_RoundHalfDown_P1_N3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 3) ~ Z)+_test_Div_RoundHalfDown_P1_N3 =  Dict+_test_Rem_RoundHalfDown_P1_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfDown_P1_N3 =  Dict+_test_Div_RoundHalfDown_P1_N4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (N 4) ~ Z)+_test_Div_RoundHalfDown_P1_N4 =  Dict+_test_Rem_RoundHalfDown_P1_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfDown_P1_N4 =  Dict+_test_Div_RoundHalfDown_P1_P1 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfDown_P1_P1 =  Dict+_test_Rem_RoundHalfDown_P1_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfDown_P1_P1 =  Dict+_test_Div_RoundHalfDown_P1_P2 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 2) ~ Z)+_test_Div_RoundHalfDown_P1_P2 =  Dict+_test_Rem_RoundHalfDown_P1_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 2) ~ P 1)+_test_Rem_RoundHalfDown_P1_P2 =  Dict+_test_Div_RoundHalfDown_P1_P3 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 3) ~ Z)+_test_Div_RoundHalfDown_P1_P3 =  Dict+_test_Rem_RoundHalfDown_P1_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfDown_P1_P3 =  Dict+_test_Div_RoundHalfDown_P1_P4 :: Dict (K.Div 'K.RoundHalfDown (P 1) (P 4) ~ Z)+_test_Div_RoundHalfDown_P1_P4 =  Dict+_test_Rem_RoundHalfDown_P1_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfDown_P1_P4 =  Dict+_test_Div_RoundHalfDown_P2_N1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfDown_P2_N1 =  Dict+_test_Rem_RoundHalfDown_P2_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfDown_P2_N1 =  Dict+_test_Div_RoundHalfDown_P2_N2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfDown_P2_N2 =  Dict+_test_Rem_RoundHalfDown_P2_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfDown_P2_N2 =  Dict+_test_Div_RoundHalfDown_P2_N3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfDown_P2_N3 =  Dict+_test_Rem_RoundHalfDown_P2_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfDown_P2_N3 =  Dict+_test_Div_RoundHalfDown_P2_N4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (N 4) ~ N 1)+_test_Div_RoundHalfDown_P2_N4 =  Dict+_test_Rem_RoundHalfDown_P2_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (N 4) ~ N 2)+_test_Rem_RoundHalfDown_P2_N4 =  Dict+_test_Div_RoundHalfDown_P2_P1 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfDown_P2_P1 =  Dict+_test_Rem_RoundHalfDown_P2_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfDown_P2_P1 =  Dict+_test_Div_RoundHalfDown_P2_P2 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfDown_P2_P2 =  Dict+_test_Rem_RoundHalfDown_P2_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfDown_P2_P2 =  Dict+_test_Div_RoundHalfDown_P2_P3 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfDown_P2_P3 =  Dict+_test_Rem_RoundHalfDown_P2_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfDown_P2_P3 =  Dict+_test_Div_RoundHalfDown_P2_P4 :: Dict (K.Div 'K.RoundHalfDown (P 2) (P 4) ~ Z)+_test_Div_RoundHalfDown_P2_P4 =  Dict+_test_Rem_RoundHalfDown_P2_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 2) (P 4) ~ P 2)+_test_Rem_RoundHalfDown_P2_P4 =  Dict+_test_Div_RoundHalfDown_P3_N1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfDown_P3_N1 =  Dict+_test_Rem_RoundHalfDown_P3_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfDown_P3_N1 =  Dict+_test_Div_RoundHalfDown_P3_N2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 2) ~ N 2)+_test_Div_RoundHalfDown_P3_N2 =  Dict+_test_Rem_RoundHalfDown_P3_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 2) ~ N 1)+_test_Rem_RoundHalfDown_P3_N2 =  Dict+_test_Div_RoundHalfDown_P3_N3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfDown_P3_N3 =  Dict+_test_Rem_RoundHalfDown_P3_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfDown_P3_N3 =  Dict+_test_Div_RoundHalfDown_P3_N4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfDown_P3_N4 =  Dict+_test_Rem_RoundHalfDown_P3_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfDown_P3_N4 =  Dict+_test_Div_RoundHalfDown_P3_P1 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfDown_P3_P1 =  Dict+_test_Rem_RoundHalfDown_P3_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfDown_P3_P1 =  Dict+_test_Div_RoundHalfDown_P3_P2 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 2) ~ P 1)+_test_Div_RoundHalfDown_P3_P2 =  Dict+_test_Rem_RoundHalfDown_P3_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 2) ~ P 1)+_test_Rem_RoundHalfDown_P3_P2 =  Dict+_test_Div_RoundHalfDown_P3_P3 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfDown_P3_P3 =  Dict+_test_Rem_RoundHalfDown_P3_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfDown_P3_P3 =  Dict+_test_Div_RoundHalfDown_P3_P4 :: Dict (K.Div 'K.RoundHalfDown (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfDown_P3_P4 =  Dict+_test_Rem_RoundHalfDown_P3_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfDown_P3_P4 =  Dict+_test_Div_RoundHalfDown_P4_N1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfDown_P4_N1 =  Dict+_test_Rem_RoundHalfDown_P4_N1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfDown_P4_N1 =  Dict+_test_Div_RoundHalfDown_P4_N2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfDown_P4_N2 =  Dict+_test_Rem_RoundHalfDown_P4_N2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfDown_P4_N2 =  Dict+_test_Div_RoundHalfDown_P4_N3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfDown_P4_N3 =  Dict+_test_Rem_RoundHalfDown_P4_N3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfDown_P4_N3 =  Dict+_test_Div_RoundHalfDown_P4_N4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfDown_P4_N4 =  Dict+_test_Rem_RoundHalfDown_P4_N4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfDown_P4_N4 =  Dict+_test_Div_RoundHalfDown_P4_P1 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfDown_P4_P1 =  Dict+_test_Rem_RoundHalfDown_P4_P1 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfDown_P4_P1 =  Dict+_test_Div_RoundHalfDown_P4_P2 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfDown_P4_P2 =  Dict+_test_Rem_RoundHalfDown_P4_P2 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfDown_P4_P2 =  Dict+_test_Div_RoundHalfDown_P4_P3 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfDown_P4_P3 =  Dict+_test_Rem_RoundHalfDown_P4_P3 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfDown_P4_P3 =  Dict+_test_Div_RoundHalfDown_P4_P4 :: Dict (K.Div 'K.RoundHalfDown (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfDown_P4_P4 =  Dict+_test_Rem_RoundHalfDown_P4_P4 :: Dict (K.Rem 'K.RoundHalfDown (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfDown_P4_P4 =  Dict+_test_Div_RoundHalfEven_N1_N1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfEven_N1_N1 =  Dict+_test_Rem_RoundHalfEven_N1_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfEven_N1_N1 =  Dict+_test_Div_RoundHalfEven_N1_N2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 2) ~ Z)+_test_Div_RoundHalfEven_N1_N2 =  Dict+_test_Rem_RoundHalfEven_N1_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 2) ~ N 1)+_test_Rem_RoundHalfEven_N1_N2 =  Dict+_test_Div_RoundHalfEven_N1_N3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 3) ~ Z)+_test_Div_RoundHalfEven_N1_N3 =  Dict+_test_Rem_RoundHalfEven_N1_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfEven_N1_N3 =  Dict+_test_Div_RoundHalfEven_N1_N4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (N 4) ~ Z)+_test_Div_RoundHalfEven_N1_N4 =  Dict+_test_Rem_RoundHalfEven_N1_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfEven_N1_N4 =  Dict+_test_Div_RoundHalfEven_N1_P1 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfEven_N1_P1 =  Dict+_test_Rem_RoundHalfEven_N1_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfEven_N1_P1 =  Dict+_test_Div_RoundHalfEven_N1_P2 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 2) ~ Z)+_test_Div_RoundHalfEven_N1_P2 =  Dict+_test_Rem_RoundHalfEven_N1_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 2) ~ N 1)+_test_Rem_RoundHalfEven_N1_P2 =  Dict+_test_Div_RoundHalfEven_N1_P3 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 3) ~ Z)+_test_Div_RoundHalfEven_N1_P3 =  Dict+_test_Rem_RoundHalfEven_N1_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfEven_N1_P3 =  Dict+_test_Div_RoundHalfEven_N1_P4 :: Dict (K.Div 'K.RoundHalfEven (N 1) (P 4) ~ Z)+_test_Div_RoundHalfEven_N1_P4 =  Dict+_test_Rem_RoundHalfEven_N1_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfEven_N1_P4 =  Dict+_test_Div_RoundHalfEven_N2_N1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfEven_N2_N1 =  Dict+_test_Rem_RoundHalfEven_N2_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfEven_N2_N1 =  Dict+_test_Div_RoundHalfEven_N2_N2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfEven_N2_N2 =  Dict+_test_Rem_RoundHalfEven_N2_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfEven_N2_N2 =  Dict+_test_Div_RoundHalfEven_N2_N3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfEven_N2_N3 =  Dict+_test_Rem_RoundHalfEven_N2_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfEven_N2_N3 =  Dict+_test_Div_RoundHalfEven_N2_N4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (N 4) ~ Z)+_test_Div_RoundHalfEven_N2_N4 =  Dict+_test_Rem_RoundHalfEven_N2_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (N 4) ~ N 2)+_test_Rem_RoundHalfEven_N2_N4 =  Dict+_test_Div_RoundHalfEven_N2_P1 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfEven_N2_P1 =  Dict+_test_Rem_RoundHalfEven_N2_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfEven_N2_P1 =  Dict+_test_Div_RoundHalfEven_N2_P2 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfEven_N2_P2 =  Dict+_test_Rem_RoundHalfEven_N2_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfEven_N2_P2 =  Dict+_test_Div_RoundHalfEven_N2_P3 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfEven_N2_P3 =  Dict+_test_Rem_RoundHalfEven_N2_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfEven_N2_P3 =  Dict+_test_Div_RoundHalfEven_N2_P4 :: Dict (K.Div 'K.RoundHalfEven (N 2) (P 4) ~ Z)+_test_Div_RoundHalfEven_N2_P4 =  Dict+_test_Rem_RoundHalfEven_N2_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 2) (P 4) ~ N 2)+_test_Rem_RoundHalfEven_N2_P4 =  Dict+_test_Div_RoundHalfEven_N3_N1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfEven_N3_N1 =  Dict+_test_Rem_RoundHalfEven_N3_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfEven_N3_N1 =  Dict+_test_Div_RoundHalfEven_N3_N2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 2) ~ P 2)+_test_Div_RoundHalfEven_N3_N2 =  Dict+_test_Rem_RoundHalfEven_N3_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 2) ~ P 1)+_test_Rem_RoundHalfEven_N3_N2 =  Dict+_test_Div_RoundHalfEven_N3_N3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfEven_N3_N3 =  Dict+_test_Rem_RoundHalfEven_N3_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfEven_N3_N3 =  Dict+_test_Div_RoundHalfEven_N3_N4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfEven_N3_N4 =  Dict+_test_Rem_RoundHalfEven_N3_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfEven_N3_N4 =  Dict+_test_Div_RoundHalfEven_N3_P1 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfEven_N3_P1 =  Dict+_test_Rem_RoundHalfEven_N3_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfEven_N3_P1 =  Dict+_test_Div_RoundHalfEven_N3_P2 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 2) ~ N 2)+_test_Div_RoundHalfEven_N3_P2 =  Dict+_test_Rem_RoundHalfEven_N3_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 2) ~ P 1)+_test_Rem_RoundHalfEven_N3_P2 =  Dict+_test_Div_RoundHalfEven_N3_P3 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfEven_N3_P3 =  Dict+_test_Rem_RoundHalfEven_N3_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfEven_N3_P3 =  Dict+_test_Div_RoundHalfEven_N3_P4 :: Dict (K.Div 'K.RoundHalfEven (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfEven_N3_P4 =  Dict+_test_Rem_RoundHalfEven_N3_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfEven_N3_P4 =  Dict+_test_Div_RoundHalfEven_N4_N1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfEven_N4_N1 =  Dict+_test_Rem_RoundHalfEven_N4_N1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfEven_N4_N1 =  Dict+_test_Div_RoundHalfEven_N4_N2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfEven_N4_N2 =  Dict+_test_Rem_RoundHalfEven_N4_N2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfEven_N4_N2 =  Dict+_test_Div_RoundHalfEven_N4_N3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfEven_N4_N3 =  Dict+_test_Rem_RoundHalfEven_N4_N3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfEven_N4_N3 =  Dict+_test_Div_RoundHalfEven_N4_N4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfEven_N4_N4 =  Dict+_test_Rem_RoundHalfEven_N4_N4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfEven_N4_N4 =  Dict+_test_Div_RoundHalfEven_N4_P1 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfEven_N4_P1 =  Dict+_test_Rem_RoundHalfEven_N4_P1 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfEven_N4_P1 =  Dict+_test_Div_RoundHalfEven_N4_P2 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfEven_N4_P2 =  Dict+_test_Rem_RoundHalfEven_N4_P2 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfEven_N4_P2 =  Dict+_test_Div_RoundHalfEven_N4_P3 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfEven_N4_P3 =  Dict+_test_Rem_RoundHalfEven_N4_P3 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfEven_N4_P3 =  Dict+_test_Div_RoundHalfEven_N4_P4 :: Dict (K.Div 'K.RoundHalfEven (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfEven_N4_P4 =  Dict+_test_Rem_RoundHalfEven_N4_P4 :: Dict (K.Rem 'K.RoundHalfEven (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfEven_N4_P4 =  Dict+_test_Rem_RoundHalfEven_Z_N1 :: Dict (K.Rem 'K.RoundHalfEven Z (N 1) ~ Z)+_test_Rem_RoundHalfEven_Z_N1 =  Dict+_test_Rem_RoundHalfEven_Z_N2 :: Dict (K.Rem 'K.RoundHalfEven Z (N 2) ~ Z)+_test_Rem_RoundHalfEven_Z_N2 =  Dict+_test_Rem_RoundHalfEven_Z_N3 :: Dict (K.Rem 'K.RoundHalfEven Z (N 3) ~ Z)+_test_Rem_RoundHalfEven_Z_N3 =  Dict+_test_Rem_RoundHalfEven_Z_N4 :: Dict (K.Rem 'K.RoundHalfEven Z (N 4) ~ Z)+_test_Rem_RoundHalfEven_Z_N4 =  Dict+_test_Rem_RoundHalfEven_Z_P1 :: Dict (K.Rem 'K.RoundHalfEven Z (P 1) ~ Z)+_test_Rem_RoundHalfEven_Z_P1 =  Dict+_test_Rem_RoundHalfEven_Z_P2 :: Dict (K.Rem 'K.RoundHalfEven Z (P 2) ~ Z)+_test_Rem_RoundHalfEven_Z_P2 =  Dict+_test_Rem_RoundHalfEven_Z_P3 :: Dict (K.Rem 'K.RoundHalfEven Z (P 3) ~ Z)+_test_Rem_RoundHalfEven_Z_P3 =  Dict+_test_Rem_RoundHalfEven_Z_P4 :: Dict (K.Rem 'K.RoundHalfEven Z (P 4) ~ Z)+_test_Rem_RoundHalfEven_Z_P4 =  Dict+_test_Div_RoundHalfEven_P1_N1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfEven_P1_N1 =  Dict+_test_Rem_RoundHalfEven_P1_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfEven_P1_N1 =  Dict+_test_Div_RoundHalfEven_P1_N2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 2) ~ Z)+_test_Div_RoundHalfEven_P1_N2 =  Dict+_test_Rem_RoundHalfEven_P1_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 2) ~ P 1)+_test_Rem_RoundHalfEven_P1_N2 =  Dict+_test_Div_RoundHalfEven_P1_N3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 3) ~ Z)+_test_Div_RoundHalfEven_P1_N3 =  Dict+_test_Rem_RoundHalfEven_P1_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfEven_P1_N3 =  Dict+_test_Div_RoundHalfEven_P1_N4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (N 4) ~ Z)+_test_Div_RoundHalfEven_P1_N4 =  Dict+_test_Rem_RoundHalfEven_P1_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfEven_P1_N4 =  Dict+_test_Div_RoundHalfEven_P1_P1 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfEven_P1_P1 =  Dict+_test_Rem_RoundHalfEven_P1_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfEven_P1_P1 =  Dict+_test_Div_RoundHalfEven_P1_P2 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 2) ~ Z)+_test_Div_RoundHalfEven_P1_P2 =  Dict+_test_Rem_RoundHalfEven_P1_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 2) ~ P 1)+_test_Rem_RoundHalfEven_P1_P2 =  Dict+_test_Div_RoundHalfEven_P1_P3 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 3) ~ Z)+_test_Div_RoundHalfEven_P1_P3 =  Dict+_test_Rem_RoundHalfEven_P1_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfEven_P1_P3 =  Dict+_test_Div_RoundHalfEven_P1_P4 :: Dict (K.Div 'K.RoundHalfEven (P 1) (P 4) ~ Z)+_test_Div_RoundHalfEven_P1_P4 =  Dict+_test_Rem_RoundHalfEven_P1_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfEven_P1_P4 =  Dict+_test_Div_RoundHalfEven_P2_N1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfEven_P2_N1 =  Dict+_test_Rem_RoundHalfEven_P2_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfEven_P2_N1 =  Dict+_test_Div_RoundHalfEven_P2_N2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfEven_P2_N2 =  Dict+_test_Rem_RoundHalfEven_P2_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfEven_P2_N2 =  Dict+_test_Div_RoundHalfEven_P2_N3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfEven_P2_N3 =  Dict+_test_Rem_RoundHalfEven_P2_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfEven_P2_N3 =  Dict+_test_Div_RoundHalfEven_P2_N4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (N 4) ~ Z)+_test_Div_RoundHalfEven_P2_N4 =  Dict+_test_Rem_RoundHalfEven_P2_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (N 4) ~ P 2)+_test_Rem_RoundHalfEven_P2_N4 =  Dict+_test_Div_RoundHalfEven_P2_P1 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfEven_P2_P1 =  Dict+_test_Rem_RoundHalfEven_P2_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfEven_P2_P1 =  Dict+_test_Div_RoundHalfEven_P2_P2 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfEven_P2_P2 =  Dict+_test_Rem_RoundHalfEven_P2_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfEven_P2_P2 =  Dict+_test_Div_RoundHalfEven_P2_P3 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfEven_P2_P3 =  Dict+_test_Rem_RoundHalfEven_P2_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfEven_P2_P3 =  Dict+_test_Div_RoundHalfEven_P2_P4 :: Dict (K.Div 'K.RoundHalfEven (P 2) (P 4) ~ Z)+_test_Div_RoundHalfEven_P2_P4 =  Dict+_test_Rem_RoundHalfEven_P2_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 2) (P 4) ~ P 2)+_test_Rem_RoundHalfEven_P2_P4 =  Dict+_test_Div_RoundHalfEven_P3_N1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfEven_P3_N1 =  Dict+_test_Rem_RoundHalfEven_P3_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfEven_P3_N1 =  Dict+_test_Div_RoundHalfEven_P3_N2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 2) ~ N 2)+_test_Div_RoundHalfEven_P3_N2 =  Dict+_test_Rem_RoundHalfEven_P3_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 2) ~ N 1)+_test_Rem_RoundHalfEven_P3_N2 =  Dict+_test_Div_RoundHalfEven_P3_N3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfEven_P3_N3 =  Dict+_test_Rem_RoundHalfEven_P3_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfEven_P3_N3 =  Dict+_test_Div_RoundHalfEven_P3_N4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfEven_P3_N4 =  Dict+_test_Rem_RoundHalfEven_P3_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfEven_P3_N4 =  Dict+_test_Div_RoundHalfEven_P3_P1 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfEven_P3_P1 =  Dict+_test_Rem_RoundHalfEven_P3_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfEven_P3_P1 =  Dict+_test_Div_RoundHalfEven_P3_P2 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 2) ~ P 2)+_test_Div_RoundHalfEven_P3_P2 =  Dict+_test_Rem_RoundHalfEven_P3_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 2) ~ N 1)+_test_Rem_RoundHalfEven_P3_P2 =  Dict+_test_Div_RoundHalfEven_P3_P3 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfEven_P3_P3 =  Dict+_test_Rem_RoundHalfEven_P3_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfEven_P3_P3 =  Dict+_test_Div_RoundHalfEven_P3_P4 :: Dict (K.Div 'K.RoundHalfEven (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfEven_P3_P4 =  Dict+_test_Rem_RoundHalfEven_P3_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfEven_P3_P4 =  Dict+_test_Div_RoundHalfEven_P4_N1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfEven_P4_N1 =  Dict+_test_Rem_RoundHalfEven_P4_N1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfEven_P4_N1 =  Dict+_test_Div_RoundHalfEven_P4_N2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfEven_P4_N2 =  Dict+_test_Rem_RoundHalfEven_P4_N2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfEven_P4_N2 =  Dict+_test_Div_RoundHalfEven_P4_N3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfEven_P4_N3 =  Dict+_test_Rem_RoundHalfEven_P4_N3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfEven_P4_N3 =  Dict+_test_Div_RoundHalfEven_P4_N4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfEven_P4_N4 =  Dict+_test_Rem_RoundHalfEven_P4_N4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfEven_P4_N4 =  Dict+_test_Div_RoundHalfEven_P4_P1 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfEven_P4_P1 =  Dict+_test_Rem_RoundHalfEven_P4_P1 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfEven_P4_P1 =  Dict+_test_Div_RoundHalfEven_P4_P2 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfEven_P4_P2 =  Dict+_test_Rem_RoundHalfEven_P4_P2 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfEven_P4_P2 =  Dict+_test_Div_RoundHalfEven_P4_P3 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfEven_P4_P3 =  Dict+_test_Rem_RoundHalfEven_P4_P3 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfEven_P4_P3 =  Dict+_test_Div_RoundHalfEven_P4_P4 :: Dict (K.Div 'K.RoundHalfEven (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfEven_P4_P4 =  Dict+_test_Rem_RoundHalfEven_P4_P4 :: Dict (K.Rem 'K.RoundHalfEven (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfEven_P4_P4 =  Dict+_test_Div_RoundHalfOdd_N1_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfOdd_N1_N1 =  Dict+_test_Rem_RoundHalfOdd_N1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_N1_N1 =  Dict+_test_Div_RoundHalfOdd_N1_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 2) ~ P 1)+_test_Div_RoundHalfOdd_N1_N2 =  Dict+_test_Rem_RoundHalfOdd_N1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 2) ~ P 1)+_test_Rem_RoundHalfOdd_N1_N2 =  Dict+_test_Div_RoundHalfOdd_N1_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 3) ~ Z)+_test_Div_RoundHalfOdd_N1_N3 =  Dict+_test_Rem_RoundHalfOdd_N1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfOdd_N1_N3 =  Dict+_test_Div_RoundHalfOdd_N1_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (N 4) ~ Z)+_test_Div_RoundHalfOdd_N1_N4 =  Dict+_test_Rem_RoundHalfOdd_N1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfOdd_N1_N4 =  Dict+_test_Div_RoundHalfOdd_N1_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfOdd_N1_P1 =  Dict+_test_Rem_RoundHalfOdd_N1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_N1_P1 =  Dict+_test_Div_RoundHalfOdd_N1_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 2) ~ N 1)+_test_Div_RoundHalfOdd_N1_P2 =  Dict+_test_Rem_RoundHalfOdd_N1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 2) ~ P 1)+_test_Rem_RoundHalfOdd_N1_P2 =  Dict+_test_Div_RoundHalfOdd_N1_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 3) ~ Z)+_test_Div_RoundHalfOdd_N1_P3 =  Dict+_test_Rem_RoundHalfOdd_N1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfOdd_N1_P3 =  Dict+_test_Div_RoundHalfOdd_N1_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 1) (P 4) ~ Z)+_test_Div_RoundHalfOdd_N1_P4 =  Dict+_test_Rem_RoundHalfOdd_N1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfOdd_N1_P4 =  Dict+_test_Div_RoundHalfOdd_N2_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfOdd_N2_N1 =  Dict+_test_Rem_RoundHalfOdd_N2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_N2_N1 =  Dict+_test_Div_RoundHalfOdd_N2_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfOdd_N2_N2 =  Dict+_test_Rem_RoundHalfOdd_N2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfOdd_N2_N2 =  Dict+_test_Div_RoundHalfOdd_N2_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfOdd_N2_N3 =  Dict+_test_Rem_RoundHalfOdd_N2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfOdd_N2_N3 =  Dict+_test_Div_RoundHalfOdd_N2_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (N 4) ~ P 1)+_test_Div_RoundHalfOdd_N2_N4 =  Dict+_test_Rem_RoundHalfOdd_N2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (N 4) ~ P 2)+_test_Rem_RoundHalfOdd_N2_N4 =  Dict+_test_Div_RoundHalfOdd_N2_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfOdd_N2_P1 =  Dict+_test_Rem_RoundHalfOdd_N2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_N2_P1 =  Dict+_test_Div_RoundHalfOdd_N2_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfOdd_N2_P2 =  Dict+_test_Rem_RoundHalfOdd_N2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfOdd_N2_P2 =  Dict+_test_Div_RoundHalfOdd_N2_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfOdd_N2_P3 =  Dict+_test_Rem_RoundHalfOdd_N2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfOdd_N2_P3 =  Dict+_test_Div_RoundHalfOdd_N2_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 2) (P 4) ~ N 1)+_test_Div_RoundHalfOdd_N2_P4 =  Dict+_test_Rem_RoundHalfOdd_N2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 2) (P 4) ~ P 2)+_test_Rem_RoundHalfOdd_N2_P4 =  Dict+_test_Div_RoundHalfOdd_N3_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfOdd_N3_N1 =  Dict+_test_Rem_RoundHalfOdd_N3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_N3_N1 =  Dict+_test_Div_RoundHalfOdd_N3_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 2) ~ P 1)+_test_Div_RoundHalfOdd_N3_N2 =  Dict+_test_Rem_RoundHalfOdd_N3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 2) ~ N 1)+_test_Rem_RoundHalfOdd_N3_N2 =  Dict+_test_Div_RoundHalfOdd_N3_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfOdd_N3_N3 =  Dict+_test_Rem_RoundHalfOdd_N3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfOdd_N3_N3 =  Dict+_test_Div_RoundHalfOdd_N3_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfOdd_N3_N4 =  Dict+_test_Rem_RoundHalfOdd_N3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfOdd_N3_N4 =  Dict+_test_Div_RoundHalfOdd_N3_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfOdd_N3_P1 =  Dict+_test_Rem_RoundHalfOdd_N3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_N3_P1 =  Dict+_test_Div_RoundHalfOdd_N3_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 2) ~ N 1)+_test_Div_RoundHalfOdd_N3_P2 =  Dict+_test_Rem_RoundHalfOdd_N3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 2) ~ N 1)+_test_Rem_RoundHalfOdd_N3_P2 =  Dict+_test_Div_RoundHalfOdd_N3_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfOdd_N3_P3 =  Dict+_test_Rem_RoundHalfOdd_N3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfOdd_N3_P3 =  Dict+_test_Div_RoundHalfOdd_N3_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfOdd_N3_P4 =  Dict+_test_Rem_RoundHalfOdd_N3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfOdd_N3_P4 =  Dict+_test_Div_RoundHalfOdd_N4_N1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfOdd_N4_N1 =  Dict+_test_Rem_RoundHalfOdd_N4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_N4_N1 =  Dict+_test_Div_RoundHalfOdd_N4_N2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfOdd_N4_N2 =  Dict+_test_Rem_RoundHalfOdd_N4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfOdd_N4_N2 =  Dict+_test_Div_RoundHalfOdd_N4_N3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfOdd_N4_N3 =  Dict+_test_Rem_RoundHalfOdd_N4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfOdd_N4_N3 =  Dict+_test_Div_RoundHalfOdd_N4_N4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfOdd_N4_N4 =  Dict+_test_Rem_RoundHalfOdd_N4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfOdd_N4_N4 =  Dict+_test_Div_RoundHalfOdd_N4_P1 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfOdd_N4_P1 =  Dict+_test_Rem_RoundHalfOdd_N4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_N4_P1 =  Dict+_test_Div_RoundHalfOdd_N4_P2 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfOdd_N4_P2 =  Dict+_test_Rem_RoundHalfOdd_N4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfOdd_N4_P2 =  Dict+_test_Div_RoundHalfOdd_N4_P3 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfOdd_N4_P3 =  Dict+_test_Rem_RoundHalfOdd_N4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfOdd_N4_P3 =  Dict+_test_Div_RoundHalfOdd_N4_P4 :: Dict (K.Div 'K.RoundHalfOdd (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfOdd_N4_P4 =  Dict+_test_Rem_RoundHalfOdd_N4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfOdd_N4_P4 =  Dict+_test_Rem_RoundHalfOdd_Z_N1 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 1) ~ Z)+_test_Rem_RoundHalfOdd_Z_N1 =  Dict+_test_Rem_RoundHalfOdd_Z_N2 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 2) ~ Z)+_test_Rem_RoundHalfOdd_Z_N2 =  Dict+_test_Rem_RoundHalfOdd_Z_N3 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 3) ~ Z)+_test_Rem_RoundHalfOdd_Z_N3 =  Dict+_test_Rem_RoundHalfOdd_Z_N4 :: Dict (K.Rem 'K.RoundHalfOdd Z (N 4) ~ Z)+_test_Rem_RoundHalfOdd_Z_N4 =  Dict+_test_Rem_RoundHalfOdd_Z_P1 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 1) ~ Z)+_test_Rem_RoundHalfOdd_Z_P1 =  Dict+_test_Rem_RoundHalfOdd_Z_P2 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 2) ~ Z)+_test_Rem_RoundHalfOdd_Z_P2 =  Dict+_test_Rem_RoundHalfOdd_Z_P3 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 3) ~ Z)+_test_Rem_RoundHalfOdd_Z_P3 =  Dict+_test_Rem_RoundHalfOdd_Z_P4 :: Dict (K.Rem 'K.RoundHalfOdd Z (P 4) ~ Z)+_test_Rem_RoundHalfOdd_Z_P4 =  Dict+_test_Div_RoundHalfOdd_P1_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfOdd_P1_N1 =  Dict+_test_Rem_RoundHalfOdd_P1_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_P1_N1 =  Dict+_test_Div_RoundHalfOdd_P1_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 2) ~ N 1)+_test_Div_RoundHalfOdd_P1_N2 =  Dict+_test_Rem_RoundHalfOdd_P1_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 2) ~ N 1)+_test_Rem_RoundHalfOdd_P1_N2 =  Dict+_test_Div_RoundHalfOdd_P1_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 3) ~ Z)+_test_Div_RoundHalfOdd_P1_N3 =  Dict+_test_Rem_RoundHalfOdd_P1_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfOdd_P1_N3 =  Dict+_test_Div_RoundHalfOdd_P1_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (N 4) ~ Z)+_test_Div_RoundHalfOdd_P1_N4 =  Dict+_test_Rem_RoundHalfOdd_P1_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfOdd_P1_N4 =  Dict+_test_Div_RoundHalfOdd_P1_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfOdd_P1_P1 =  Dict+_test_Rem_RoundHalfOdd_P1_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_P1_P1 =  Dict+_test_Div_RoundHalfOdd_P1_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 2) ~ P 1)+_test_Div_RoundHalfOdd_P1_P2 =  Dict+_test_Rem_RoundHalfOdd_P1_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 2) ~ N 1)+_test_Rem_RoundHalfOdd_P1_P2 =  Dict+_test_Div_RoundHalfOdd_P1_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 3) ~ Z)+_test_Div_RoundHalfOdd_P1_P3 =  Dict+_test_Rem_RoundHalfOdd_P1_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfOdd_P1_P3 =  Dict+_test_Div_RoundHalfOdd_P1_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 1) (P 4) ~ Z)+_test_Div_RoundHalfOdd_P1_P4 =  Dict+_test_Rem_RoundHalfOdd_P1_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfOdd_P1_P4 =  Dict+_test_Div_RoundHalfOdd_P2_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfOdd_P2_N1 =  Dict+_test_Rem_RoundHalfOdd_P2_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_P2_N1 =  Dict+_test_Div_RoundHalfOdd_P2_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfOdd_P2_N2 =  Dict+_test_Rem_RoundHalfOdd_P2_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfOdd_P2_N2 =  Dict+_test_Div_RoundHalfOdd_P2_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfOdd_P2_N3 =  Dict+_test_Rem_RoundHalfOdd_P2_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfOdd_P2_N3 =  Dict+_test_Div_RoundHalfOdd_P2_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (N 4) ~ N 1)+_test_Div_RoundHalfOdd_P2_N4 =  Dict+_test_Rem_RoundHalfOdd_P2_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (N 4) ~ N 2)+_test_Rem_RoundHalfOdd_P2_N4 =  Dict+_test_Div_RoundHalfOdd_P2_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfOdd_P2_P1 =  Dict+_test_Rem_RoundHalfOdd_P2_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_P2_P1 =  Dict+_test_Div_RoundHalfOdd_P2_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfOdd_P2_P2 =  Dict+_test_Rem_RoundHalfOdd_P2_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfOdd_P2_P2 =  Dict+_test_Div_RoundHalfOdd_P2_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfOdd_P2_P3 =  Dict+_test_Rem_RoundHalfOdd_P2_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfOdd_P2_P3 =  Dict+_test_Div_RoundHalfOdd_P2_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 2) (P 4) ~ P 1)+_test_Div_RoundHalfOdd_P2_P4 =  Dict+_test_Rem_RoundHalfOdd_P2_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 2) (P 4) ~ N 2)+_test_Rem_RoundHalfOdd_P2_P4 =  Dict+_test_Div_RoundHalfOdd_P3_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfOdd_P3_N1 =  Dict+_test_Rem_RoundHalfOdd_P3_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_P3_N1 =  Dict+_test_Div_RoundHalfOdd_P3_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 2) ~ N 1)+_test_Div_RoundHalfOdd_P3_N2 =  Dict+_test_Rem_RoundHalfOdd_P3_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 2) ~ P 1)+_test_Rem_RoundHalfOdd_P3_N2 =  Dict+_test_Div_RoundHalfOdd_P3_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfOdd_P3_N3 =  Dict+_test_Rem_RoundHalfOdd_P3_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfOdd_P3_N3 =  Dict+_test_Div_RoundHalfOdd_P3_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfOdd_P3_N4 =  Dict+_test_Rem_RoundHalfOdd_P3_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfOdd_P3_N4 =  Dict+_test_Div_RoundHalfOdd_P3_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfOdd_P3_P1 =  Dict+_test_Rem_RoundHalfOdd_P3_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_P3_P1 =  Dict+_test_Div_RoundHalfOdd_P3_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 2) ~ P 1)+_test_Div_RoundHalfOdd_P3_P2 =  Dict+_test_Rem_RoundHalfOdd_P3_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 2) ~ P 1)+_test_Rem_RoundHalfOdd_P3_P2 =  Dict+_test_Div_RoundHalfOdd_P3_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfOdd_P3_P3 =  Dict+_test_Rem_RoundHalfOdd_P3_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfOdd_P3_P3 =  Dict+_test_Div_RoundHalfOdd_P3_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfOdd_P3_P4 =  Dict+_test_Rem_RoundHalfOdd_P3_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfOdd_P3_P4 =  Dict+_test_Div_RoundHalfOdd_P4_N1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfOdd_P4_N1 =  Dict+_test_Rem_RoundHalfOdd_P4_N1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfOdd_P4_N1 =  Dict+_test_Div_RoundHalfOdd_P4_N2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfOdd_P4_N2 =  Dict+_test_Rem_RoundHalfOdd_P4_N2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfOdd_P4_N2 =  Dict+_test_Div_RoundHalfOdd_P4_N3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfOdd_P4_N3 =  Dict+_test_Rem_RoundHalfOdd_P4_N3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfOdd_P4_N3 =  Dict+_test_Div_RoundHalfOdd_P4_N4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfOdd_P4_N4 =  Dict+_test_Rem_RoundHalfOdd_P4_N4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfOdd_P4_N4 =  Dict+_test_Div_RoundHalfOdd_P4_P1 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfOdd_P4_P1 =  Dict+_test_Rem_RoundHalfOdd_P4_P1 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfOdd_P4_P1 =  Dict+_test_Div_RoundHalfOdd_P4_P2 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfOdd_P4_P2 =  Dict+_test_Rem_RoundHalfOdd_P4_P2 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfOdd_P4_P2 =  Dict+_test_Div_RoundHalfOdd_P4_P3 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfOdd_P4_P3 =  Dict+_test_Rem_RoundHalfOdd_P4_P3 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfOdd_P4_P3 =  Dict+_test_Div_RoundHalfOdd_P4_P4 :: Dict (K.Div 'K.RoundHalfOdd (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfOdd_P4_P4 =  Dict+_test_Rem_RoundHalfOdd_P4_P4 :: Dict (K.Rem 'K.RoundHalfOdd (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfOdd_P4_P4 =  Dict+_test_Div_RoundHalfUp_N1_N1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfUp_N1_N1 =  Dict+_test_Rem_RoundHalfUp_N1_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfUp_N1_N1 =  Dict+_test_Div_RoundHalfUp_N1_N2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 2) ~ P 1)+_test_Div_RoundHalfUp_N1_N2 =  Dict+_test_Rem_RoundHalfUp_N1_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 2) ~ P 1)+_test_Rem_RoundHalfUp_N1_N2 =  Dict+_test_Div_RoundHalfUp_N1_N3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 3) ~ Z)+_test_Div_RoundHalfUp_N1_N3 =  Dict+_test_Rem_RoundHalfUp_N1_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfUp_N1_N3 =  Dict+_test_Div_RoundHalfUp_N1_N4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (N 4) ~ Z)+_test_Div_RoundHalfUp_N1_N4 =  Dict+_test_Rem_RoundHalfUp_N1_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfUp_N1_N4 =  Dict+_test_Div_RoundHalfUp_N1_P1 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfUp_N1_P1 =  Dict+_test_Rem_RoundHalfUp_N1_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfUp_N1_P1 =  Dict+_test_Div_RoundHalfUp_N1_P2 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 2) ~ Z)+_test_Div_RoundHalfUp_N1_P2 =  Dict+_test_Rem_RoundHalfUp_N1_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 2) ~ N 1)+_test_Rem_RoundHalfUp_N1_P2 =  Dict+_test_Div_RoundHalfUp_N1_P3 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 3) ~ Z)+_test_Div_RoundHalfUp_N1_P3 =  Dict+_test_Rem_RoundHalfUp_N1_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfUp_N1_P3 =  Dict+_test_Div_RoundHalfUp_N1_P4 :: Dict (K.Div 'K.RoundHalfUp (N 1) (P 4) ~ Z)+_test_Div_RoundHalfUp_N1_P4 =  Dict+_test_Rem_RoundHalfUp_N1_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfUp_N1_P4 =  Dict+_test_Div_RoundHalfUp_N2_N1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfUp_N2_N1 =  Dict+_test_Rem_RoundHalfUp_N2_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfUp_N2_N1 =  Dict+_test_Div_RoundHalfUp_N2_N2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfUp_N2_N2 =  Dict+_test_Rem_RoundHalfUp_N2_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfUp_N2_N2 =  Dict+_test_Div_RoundHalfUp_N2_N3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfUp_N2_N3 =  Dict+_test_Rem_RoundHalfUp_N2_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfUp_N2_N3 =  Dict+_test_Div_RoundHalfUp_N2_N4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (N 4) ~ P 1)+_test_Div_RoundHalfUp_N2_N4 =  Dict+_test_Rem_RoundHalfUp_N2_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (N 4) ~ P 2)+_test_Rem_RoundHalfUp_N2_N4 =  Dict+_test_Div_RoundHalfUp_N2_P1 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfUp_N2_P1 =  Dict+_test_Rem_RoundHalfUp_N2_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfUp_N2_P1 =  Dict+_test_Div_RoundHalfUp_N2_P2 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfUp_N2_P2 =  Dict+_test_Rem_RoundHalfUp_N2_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfUp_N2_P2 =  Dict+_test_Div_RoundHalfUp_N2_P3 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfUp_N2_P3 =  Dict+_test_Rem_RoundHalfUp_N2_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfUp_N2_P3 =  Dict+_test_Div_RoundHalfUp_N2_P4 :: Dict (K.Div 'K.RoundHalfUp (N 2) (P 4) ~ Z)+_test_Div_RoundHalfUp_N2_P4 =  Dict+_test_Rem_RoundHalfUp_N2_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 2) (P 4) ~ N 2)+_test_Rem_RoundHalfUp_N2_P4 =  Dict+_test_Div_RoundHalfUp_N3_N1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfUp_N3_N1 =  Dict+_test_Rem_RoundHalfUp_N3_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfUp_N3_N1 =  Dict+_test_Div_RoundHalfUp_N3_N2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 2) ~ P 2)+_test_Div_RoundHalfUp_N3_N2 =  Dict+_test_Rem_RoundHalfUp_N3_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 2) ~ P 1)+_test_Rem_RoundHalfUp_N3_N2 =  Dict+_test_Div_RoundHalfUp_N3_N3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfUp_N3_N3 =  Dict+_test_Rem_RoundHalfUp_N3_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfUp_N3_N3 =  Dict+_test_Div_RoundHalfUp_N3_N4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfUp_N3_N4 =  Dict+_test_Rem_RoundHalfUp_N3_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfUp_N3_N4 =  Dict+_test_Div_RoundHalfUp_N3_P1 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfUp_N3_P1 =  Dict+_test_Rem_RoundHalfUp_N3_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfUp_N3_P1 =  Dict+_test_Div_RoundHalfUp_N3_P2 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 2) ~ N 1)+_test_Div_RoundHalfUp_N3_P2 =  Dict+_test_Rem_RoundHalfUp_N3_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 2) ~ N 1)+_test_Rem_RoundHalfUp_N3_P2 =  Dict+_test_Div_RoundHalfUp_N3_P3 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfUp_N3_P3 =  Dict+_test_Rem_RoundHalfUp_N3_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfUp_N3_P3 =  Dict+_test_Div_RoundHalfUp_N3_P4 :: Dict (K.Div 'K.RoundHalfUp (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfUp_N3_P4 =  Dict+_test_Rem_RoundHalfUp_N3_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfUp_N3_P4 =  Dict+_test_Div_RoundHalfUp_N4_N1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfUp_N4_N1 =  Dict+_test_Rem_RoundHalfUp_N4_N1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfUp_N4_N1 =  Dict+_test_Div_RoundHalfUp_N4_N2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfUp_N4_N2 =  Dict+_test_Rem_RoundHalfUp_N4_N2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfUp_N4_N2 =  Dict+_test_Div_RoundHalfUp_N4_N3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfUp_N4_N3 =  Dict+_test_Rem_RoundHalfUp_N4_N3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfUp_N4_N3 =  Dict+_test_Div_RoundHalfUp_N4_N4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfUp_N4_N4 =  Dict+_test_Rem_RoundHalfUp_N4_N4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfUp_N4_N4 =  Dict+_test_Div_RoundHalfUp_N4_P1 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfUp_N4_P1 =  Dict+_test_Rem_RoundHalfUp_N4_P1 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfUp_N4_P1 =  Dict+_test_Div_RoundHalfUp_N4_P2 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfUp_N4_P2 =  Dict+_test_Rem_RoundHalfUp_N4_P2 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfUp_N4_P2 =  Dict+_test_Div_RoundHalfUp_N4_P3 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfUp_N4_P3 =  Dict+_test_Rem_RoundHalfUp_N4_P3 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfUp_N4_P3 =  Dict+_test_Div_RoundHalfUp_N4_P4 :: Dict (K.Div 'K.RoundHalfUp (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfUp_N4_P4 =  Dict+_test_Rem_RoundHalfUp_N4_P4 :: Dict (K.Rem 'K.RoundHalfUp (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfUp_N4_P4 =  Dict+_test_Rem_RoundHalfUp_Z_N1 :: Dict (K.Rem 'K.RoundHalfUp Z (N 1) ~ Z)+_test_Rem_RoundHalfUp_Z_N1 =  Dict+_test_Rem_RoundHalfUp_Z_N2 :: Dict (K.Rem 'K.RoundHalfUp Z (N 2) ~ Z)+_test_Rem_RoundHalfUp_Z_N2 =  Dict+_test_Rem_RoundHalfUp_Z_N3 :: Dict (K.Rem 'K.RoundHalfUp Z (N 3) ~ Z)+_test_Rem_RoundHalfUp_Z_N3 =  Dict+_test_Rem_RoundHalfUp_Z_N4 :: Dict (K.Rem 'K.RoundHalfUp Z (N 4) ~ Z)+_test_Rem_RoundHalfUp_Z_N4 =  Dict+_test_Rem_RoundHalfUp_Z_P1 :: Dict (K.Rem 'K.RoundHalfUp Z (P 1) ~ Z)+_test_Rem_RoundHalfUp_Z_P1 =  Dict+_test_Rem_RoundHalfUp_Z_P2 :: Dict (K.Rem 'K.RoundHalfUp Z (P 2) ~ Z)+_test_Rem_RoundHalfUp_Z_P2 =  Dict+_test_Rem_RoundHalfUp_Z_P3 :: Dict (K.Rem 'K.RoundHalfUp Z (P 3) ~ Z)+_test_Rem_RoundHalfUp_Z_P3 =  Dict+_test_Rem_RoundHalfUp_Z_P4 :: Dict (K.Rem 'K.RoundHalfUp Z (P 4) ~ Z)+_test_Rem_RoundHalfUp_Z_P4 =  Dict+_test_Div_RoundHalfUp_P1_N1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfUp_P1_N1 =  Dict+_test_Rem_RoundHalfUp_P1_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfUp_P1_N1 =  Dict+_test_Div_RoundHalfUp_P1_N2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 2) ~ Z)+_test_Div_RoundHalfUp_P1_N2 =  Dict+_test_Rem_RoundHalfUp_P1_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 2) ~ P 1)+_test_Rem_RoundHalfUp_P1_N2 =  Dict+_test_Div_RoundHalfUp_P1_N3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 3) ~ Z)+_test_Div_RoundHalfUp_P1_N3 =  Dict+_test_Rem_RoundHalfUp_P1_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfUp_P1_N3 =  Dict+_test_Div_RoundHalfUp_P1_N4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (N 4) ~ Z)+_test_Div_RoundHalfUp_P1_N4 =  Dict+_test_Rem_RoundHalfUp_P1_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfUp_P1_N4 =  Dict+_test_Div_RoundHalfUp_P1_P1 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfUp_P1_P1 =  Dict+_test_Rem_RoundHalfUp_P1_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfUp_P1_P1 =  Dict+_test_Div_RoundHalfUp_P1_P2 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 2) ~ P 1)+_test_Div_RoundHalfUp_P1_P2 =  Dict+_test_Rem_RoundHalfUp_P1_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 2) ~ N 1)+_test_Rem_RoundHalfUp_P1_P2 =  Dict+_test_Div_RoundHalfUp_P1_P3 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 3) ~ Z)+_test_Div_RoundHalfUp_P1_P3 =  Dict+_test_Rem_RoundHalfUp_P1_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfUp_P1_P3 =  Dict+_test_Div_RoundHalfUp_P1_P4 :: Dict (K.Div 'K.RoundHalfUp (P 1) (P 4) ~ Z)+_test_Div_RoundHalfUp_P1_P4 =  Dict+_test_Rem_RoundHalfUp_P1_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfUp_P1_P4 =  Dict+_test_Div_RoundHalfUp_P2_N1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfUp_P2_N1 =  Dict+_test_Rem_RoundHalfUp_P2_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfUp_P2_N1 =  Dict+_test_Div_RoundHalfUp_P2_N2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfUp_P2_N2 =  Dict+_test_Rem_RoundHalfUp_P2_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfUp_P2_N2 =  Dict+_test_Div_RoundHalfUp_P2_N3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfUp_P2_N3 =  Dict+_test_Rem_RoundHalfUp_P2_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfUp_P2_N3 =  Dict+_test_Div_RoundHalfUp_P2_N4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (N 4) ~ Z)+_test_Div_RoundHalfUp_P2_N4 =  Dict+_test_Rem_RoundHalfUp_P2_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (N 4) ~ P 2)+_test_Rem_RoundHalfUp_P2_N4 =  Dict+_test_Div_RoundHalfUp_P2_P1 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfUp_P2_P1 =  Dict+_test_Rem_RoundHalfUp_P2_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfUp_P2_P1 =  Dict+_test_Div_RoundHalfUp_P2_P2 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfUp_P2_P2 =  Dict+_test_Rem_RoundHalfUp_P2_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfUp_P2_P2 =  Dict+_test_Div_RoundHalfUp_P2_P3 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfUp_P2_P3 =  Dict+_test_Rem_RoundHalfUp_P2_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfUp_P2_P3 =  Dict+_test_Div_RoundHalfUp_P2_P4 :: Dict (K.Div 'K.RoundHalfUp (P 2) (P 4) ~ P 1)+_test_Div_RoundHalfUp_P2_P4 =  Dict+_test_Rem_RoundHalfUp_P2_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 2) (P 4) ~ N 2)+_test_Rem_RoundHalfUp_P2_P4 =  Dict+_test_Div_RoundHalfUp_P3_N1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfUp_P3_N1 =  Dict+_test_Rem_RoundHalfUp_P3_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfUp_P3_N1 =  Dict+_test_Div_RoundHalfUp_P3_N2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 2) ~ N 1)+_test_Div_RoundHalfUp_P3_N2 =  Dict+_test_Rem_RoundHalfUp_P3_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 2) ~ P 1)+_test_Rem_RoundHalfUp_P3_N2 =  Dict+_test_Div_RoundHalfUp_P3_N3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfUp_P3_N3 =  Dict+_test_Rem_RoundHalfUp_P3_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfUp_P3_N3 =  Dict+_test_Div_RoundHalfUp_P3_N4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfUp_P3_N4 =  Dict+_test_Rem_RoundHalfUp_P3_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfUp_P3_N4 =  Dict+_test_Div_RoundHalfUp_P3_P1 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfUp_P3_P1 =  Dict+_test_Rem_RoundHalfUp_P3_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfUp_P3_P1 =  Dict+_test_Div_RoundHalfUp_P3_P2 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 2) ~ P 2)+_test_Div_RoundHalfUp_P3_P2 =  Dict+_test_Rem_RoundHalfUp_P3_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 2) ~ N 1)+_test_Rem_RoundHalfUp_P3_P2 =  Dict+_test_Div_RoundHalfUp_P3_P3 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfUp_P3_P3 =  Dict+_test_Rem_RoundHalfUp_P3_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfUp_P3_P3 =  Dict+_test_Div_RoundHalfUp_P3_P4 :: Dict (K.Div 'K.RoundHalfUp (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfUp_P3_P4 =  Dict+_test_Rem_RoundHalfUp_P3_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfUp_P3_P4 =  Dict+_test_Div_RoundHalfUp_P4_N1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfUp_P4_N1 =  Dict+_test_Rem_RoundHalfUp_P4_N1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfUp_P4_N1 =  Dict+_test_Div_RoundHalfUp_P4_N2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfUp_P4_N2 =  Dict+_test_Rem_RoundHalfUp_P4_N2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfUp_P4_N2 =  Dict+_test_Div_RoundHalfUp_P4_N3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfUp_P4_N3 =  Dict+_test_Rem_RoundHalfUp_P4_N3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfUp_P4_N3 =  Dict+_test_Div_RoundHalfUp_P4_N4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfUp_P4_N4 =  Dict+_test_Rem_RoundHalfUp_P4_N4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfUp_P4_N4 =  Dict+_test_Div_RoundHalfUp_P4_P1 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfUp_P4_P1 =  Dict+_test_Rem_RoundHalfUp_P4_P1 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfUp_P4_P1 =  Dict+_test_Div_RoundHalfUp_P4_P2 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfUp_P4_P2 =  Dict+_test_Rem_RoundHalfUp_P4_P2 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfUp_P4_P2 =  Dict+_test_Div_RoundHalfUp_P4_P3 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfUp_P4_P3 =  Dict+_test_Rem_RoundHalfUp_P4_P3 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfUp_P4_P3 =  Dict+_test_Div_RoundHalfUp_P4_P4 :: Dict (K.Div 'K.RoundHalfUp (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfUp_P4_P4 =  Dict+_test_Rem_RoundHalfUp_P4_P4 :: Dict (K.Rem 'K.RoundHalfUp (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfUp_P4_P4 =  Dict+_test_Div_RoundHalfZero_N1_N1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 1) ~ P 1)+_test_Div_RoundHalfZero_N1_N1 =  Dict+_test_Rem_RoundHalfZero_N1_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 1) ~ Z)+_test_Rem_RoundHalfZero_N1_N1 =  Dict+_test_Div_RoundHalfZero_N1_N2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 2) ~ Z)+_test_Div_RoundHalfZero_N1_N2 =  Dict+_test_Rem_RoundHalfZero_N1_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 2) ~ N 1)+_test_Rem_RoundHalfZero_N1_N2 =  Dict+_test_Div_RoundHalfZero_N1_N3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 3) ~ Z)+_test_Div_RoundHalfZero_N1_N3 =  Dict+_test_Rem_RoundHalfZero_N1_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 3) ~ N 1)+_test_Rem_RoundHalfZero_N1_N3 =  Dict+_test_Div_RoundHalfZero_N1_N4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (N 4) ~ Z)+_test_Div_RoundHalfZero_N1_N4 =  Dict+_test_Rem_RoundHalfZero_N1_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (N 4) ~ N 1)+_test_Rem_RoundHalfZero_N1_N4 =  Dict+_test_Div_RoundHalfZero_N1_P1 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 1) ~ N 1)+_test_Div_RoundHalfZero_N1_P1 =  Dict+_test_Rem_RoundHalfZero_N1_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 1) ~ Z)+_test_Rem_RoundHalfZero_N1_P1 =  Dict+_test_Div_RoundHalfZero_N1_P2 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 2) ~ Z)+_test_Div_RoundHalfZero_N1_P2 =  Dict+_test_Rem_RoundHalfZero_N1_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 2) ~ N 1)+_test_Rem_RoundHalfZero_N1_P2 =  Dict+_test_Div_RoundHalfZero_N1_P3 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 3) ~ Z)+_test_Div_RoundHalfZero_N1_P3 =  Dict+_test_Rem_RoundHalfZero_N1_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 3) ~ N 1)+_test_Rem_RoundHalfZero_N1_P3 =  Dict+_test_Div_RoundHalfZero_N1_P4 :: Dict (K.Div 'K.RoundHalfZero (N 1) (P 4) ~ Z)+_test_Div_RoundHalfZero_N1_P4 =  Dict+_test_Rem_RoundHalfZero_N1_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 1) (P 4) ~ N 1)+_test_Rem_RoundHalfZero_N1_P4 =  Dict+_test_Div_RoundHalfZero_N2_N1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 1) ~ P 2)+_test_Div_RoundHalfZero_N2_N1 =  Dict+_test_Rem_RoundHalfZero_N2_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 1) ~ Z)+_test_Rem_RoundHalfZero_N2_N1 =  Dict+_test_Div_RoundHalfZero_N2_N2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 2) ~ P 1)+_test_Div_RoundHalfZero_N2_N2 =  Dict+_test_Rem_RoundHalfZero_N2_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 2) ~ Z)+_test_Rem_RoundHalfZero_N2_N2 =  Dict+_test_Div_RoundHalfZero_N2_N3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 3) ~ P 1)+_test_Div_RoundHalfZero_N2_N3 =  Dict+_test_Rem_RoundHalfZero_N2_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 3) ~ P 1)+_test_Rem_RoundHalfZero_N2_N3 =  Dict+_test_Div_RoundHalfZero_N2_N4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (N 4) ~ Z)+_test_Div_RoundHalfZero_N2_N4 =  Dict+_test_Rem_RoundHalfZero_N2_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (N 4) ~ N 2)+_test_Rem_RoundHalfZero_N2_N4 =  Dict+_test_Div_RoundHalfZero_N2_P1 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 1) ~ N 2)+_test_Div_RoundHalfZero_N2_P1 =  Dict+_test_Rem_RoundHalfZero_N2_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 1) ~ Z)+_test_Rem_RoundHalfZero_N2_P1 =  Dict+_test_Div_RoundHalfZero_N2_P2 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 2) ~ N 1)+_test_Div_RoundHalfZero_N2_P2 =  Dict+_test_Rem_RoundHalfZero_N2_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 2) ~ Z)+_test_Rem_RoundHalfZero_N2_P2 =  Dict+_test_Div_RoundHalfZero_N2_P3 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 3) ~ N 1)+_test_Div_RoundHalfZero_N2_P3 =  Dict+_test_Rem_RoundHalfZero_N2_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 3) ~ P 1)+_test_Rem_RoundHalfZero_N2_P3 =  Dict+_test_Div_RoundHalfZero_N2_P4 :: Dict (K.Div 'K.RoundHalfZero (N 2) (P 4) ~ Z)+_test_Div_RoundHalfZero_N2_P4 =  Dict+_test_Rem_RoundHalfZero_N2_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 2) (P 4) ~ N 2)+_test_Rem_RoundHalfZero_N2_P4 =  Dict+_test_Div_RoundHalfZero_N3_N1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 1) ~ P 3)+_test_Div_RoundHalfZero_N3_N1 =  Dict+_test_Rem_RoundHalfZero_N3_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 1) ~ Z)+_test_Rem_RoundHalfZero_N3_N1 =  Dict+_test_Div_RoundHalfZero_N3_N2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 2) ~ P 1)+_test_Div_RoundHalfZero_N3_N2 =  Dict+_test_Rem_RoundHalfZero_N3_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 2) ~ N 1)+_test_Rem_RoundHalfZero_N3_N2 =  Dict+_test_Div_RoundHalfZero_N3_N3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 3) ~ P 1)+_test_Div_RoundHalfZero_N3_N3 =  Dict+_test_Rem_RoundHalfZero_N3_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 3) ~ Z)+_test_Rem_RoundHalfZero_N3_N3 =  Dict+_test_Div_RoundHalfZero_N3_N4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (N 4) ~ P 1)+_test_Div_RoundHalfZero_N3_N4 =  Dict+_test_Rem_RoundHalfZero_N3_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (N 4) ~ P 1)+_test_Rem_RoundHalfZero_N3_N4 =  Dict+_test_Div_RoundHalfZero_N3_P1 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 1) ~ N 3)+_test_Div_RoundHalfZero_N3_P1 =  Dict+_test_Rem_RoundHalfZero_N3_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 1) ~ Z)+_test_Rem_RoundHalfZero_N3_P1 =  Dict+_test_Div_RoundHalfZero_N3_P2 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 2) ~ N 1)+_test_Div_RoundHalfZero_N3_P2 =  Dict+_test_Rem_RoundHalfZero_N3_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 2) ~ N 1)+_test_Rem_RoundHalfZero_N3_P2 =  Dict+_test_Div_RoundHalfZero_N3_P3 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 3) ~ N 1)+_test_Div_RoundHalfZero_N3_P3 =  Dict+_test_Rem_RoundHalfZero_N3_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 3) ~ Z)+_test_Rem_RoundHalfZero_N3_P3 =  Dict+_test_Div_RoundHalfZero_N3_P4 :: Dict (K.Div 'K.RoundHalfZero (N 3) (P 4) ~ N 1)+_test_Div_RoundHalfZero_N3_P4 =  Dict+_test_Rem_RoundHalfZero_N3_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 3) (P 4) ~ P 1)+_test_Rem_RoundHalfZero_N3_P4 =  Dict+_test_Div_RoundHalfZero_N4_N1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 1) ~ P 4)+_test_Div_RoundHalfZero_N4_N1 =  Dict+_test_Rem_RoundHalfZero_N4_N1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 1) ~ Z)+_test_Rem_RoundHalfZero_N4_N1 =  Dict+_test_Div_RoundHalfZero_N4_N2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 2) ~ P 2)+_test_Div_RoundHalfZero_N4_N2 =  Dict+_test_Rem_RoundHalfZero_N4_N2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 2) ~ Z)+_test_Rem_RoundHalfZero_N4_N2 =  Dict+_test_Div_RoundHalfZero_N4_N3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 3) ~ P 1)+_test_Div_RoundHalfZero_N4_N3 =  Dict+_test_Rem_RoundHalfZero_N4_N3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 3) ~ N 1)+_test_Rem_RoundHalfZero_N4_N3 =  Dict+_test_Div_RoundHalfZero_N4_N4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (N 4) ~ P 1)+_test_Div_RoundHalfZero_N4_N4 =  Dict+_test_Rem_RoundHalfZero_N4_N4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (N 4) ~ Z)+_test_Rem_RoundHalfZero_N4_N4 =  Dict+_test_Div_RoundHalfZero_N4_P1 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 1) ~ N 4)+_test_Div_RoundHalfZero_N4_P1 =  Dict+_test_Rem_RoundHalfZero_N4_P1 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 1) ~ Z)+_test_Rem_RoundHalfZero_N4_P1 =  Dict+_test_Div_RoundHalfZero_N4_P2 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 2) ~ N 2)+_test_Div_RoundHalfZero_N4_P2 =  Dict+_test_Rem_RoundHalfZero_N4_P2 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 2) ~ Z)+_test_Rem_RoundHalfZero_N4_P2 =  Dict+_test_Div_RoundHalfZero_N4_P3 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 3) ~ N 1)+_test_Div_RoundHalfZero_N4_P3 =  Dict+_test_Rem_RoundHalfZero_N4_P3 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 3) ~ N 1)+_test_Rem_RoundHalfZero_N4_P3 =  Dict+_test_Div_RoundHalfZero_N4_P4 :: Dict (K.Div 'K.RoundHalfZero (N 4) (P 4) ~ N 1)+_test_Div_RoundHalfZero_N4_P4 =  Dict+_test_Rem_RoundHalfZero_N4_P4 :: Dict (K.Rem 'K.RoundHalfZero (N 4) (P 4) ~ Z)+_test_Rem_RoundHalfZero_N4_P4 =  Dict+_test_Rem_RoundHalfZero_Z_N1 :: Dict (K.Rem 'K.RoundHalfZero Z (N 1) ~ Z)+_test_Rem_RoundHalfZero_Z_N1 =  Dict+_test_Rem_RoundHalfZero_Z_N2 :: Dict (K.Rem 'K.RoundHalfZero Z (N 2) ~ Z)+_test_Rem_RoundHalfZero_Z_N2 =  Dict+_test_Rem_RoundHalfZero_Z_N3 :: Dict (K.Rem 'K.RoundHalfZero Z (N 3) ~ Z)+_test_Rem_RoundHalfZero_Z_N3 =  Dict+_test_Div_RoundHalfZero_Z_N4 :: Dict (K.Div 'K.RoundHalfZero Z (N 4) ~ Z)+_test_Div_RoundHalfZero_Z_N4 =  Dict+_test_Rem_RoundHalfZero_Z_P1 :: Dict (K.Rem 'K.RoundHalfZero Z (P 1) ~ Z)+_test_Rem_RoundHalfZero_Z_P1 =  Dict+_test_Div_RoundHalfZero_Z_P2 :: Dict (K.Div 'K.RoundHalfZero Z (P 2) ~ Z)+_test_Div_RoundHalfZero_Z_P2 =  Dict+_test_Rem_RoundHalfZero_Z_P3 :: Dict (K.Rem 'K.RoundHalfZero Z (P 3) ~ Z)+_test_Rem_RoundHalfZero_Z_P3 =  Dict+_test_Div_RoundHalfZero_Z_P4 :: Dict (K.Div 'K.RoundHalfZero Z (P 4) ~ Z)+_test_Div_RoundHalfZero_Z_P4 =  Dict+_test_Div_RoundHalfZero_P1_N1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 1) ~ N 1)+_test_Div_RoundHalfZero_P1_N1 =  Dict+_test_Rem_RoundHalfZero_P1_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 1) ~ Z)+_test_Rem_RoundHalfZero_P1_N1 =  Dict+_test_Div_RoundHalfZero_P1_N2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 2) ~ Z)+_test_Div_RoundHalfZero_P1_N2 =  Dict+_test_Rem_RoundHalfZero_P1_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 2) ~ P 1)+_test_Rem_RoundHalfZero_P1_N2 =  Dict+_test_Div_RoundHalfZero_P1_N3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 3) ~ Z)+_test_Div_RoundHalfZero_P1_N3 =  Dict+_test_Rem_RoundHalfZero_P1_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 3) ~ P 1)+_test_Rem_RoundHalfZero_P1_N3 =  Dict+_test_Div_RoundHalfZero_P1_N4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (N 4) ~ Z)+_test_Div_RoundHalfZero_P1_N4 =  Dict+_test_Rem_RoundHalfZero_P1_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (N 4) ~ P 1)+_test_Rem_RoundHalfZero_P1_N4 =  Dict+_test_Div_RoundHalfZero_P1_P1 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 1) ~ P 1)+_test_Div_RoundHalfZero_P1_P1 =  Dict+_test_Rem_RoundHalfZero_P1_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 1) ~ Z)+_test_Rem_RoundHalfZero_P1_P1 =  Dict+_test_Div_RoundHalfZero_P1_P2 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 2) ~ Z)+_test_Div_RoundHalfZero_P1_P2 =  Dict+_test_Rem_RoundHalfZero_P1_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 2) ~ P 1)+_test_Rem_RoundHalfZero_P1_P2 =  Dict+_test_Div_RoundHalfZero_P1_P3 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 3) ~ Z)+_test_Div_RoundHalfZero_P1_P3 =  Dict+_test_Rem_RoundHalfZero_P1_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 3) ~ P 1)+_test_Rem_RoundHalfZero_P1_P3 =  Dict+_test_Div_RoundHalfZero_P1_P4 :: Dict (K.Div 'K.RoundHalfZero (P 1) (P 4) ~ Z)+_test_Div_RoundHalfZero_P1_P4 =  Dict+_test_Rem_RoundHalfZero_P1_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 1) (P 4) ~ P 1)+_test_Rem_RoundHalfZero_P1_P4 =  Dict+_test_Div_RoundHalfZero_P2_N1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 1) ~ N 2)+_test_Div_RoundHalfZero_P2_N1 =  Dict+_test_Rem_RoundHalfZero_P2_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 1) ~ Z)+_test_Rem_RoundHalfZero_P2_N1 =  Dict+_test_Div_RoundHalfZero_P2_N2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 2) ~ N 1)+_test_Div_RoundHalfZero_P2_N2 =  Dict+_test_Rem_RoundHalfZero_P2_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 2) ~ Z)+_test_Rem_RoundHalfZero_P2_N2 =  Dict+_test_Div_RoundHalfZero_P2_N3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 3) ~ N 1)+_test_Div_RoundHalfZero_P2_N3 =  Dict+_test_Rem_RoundHalfZero_P2_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 3) ~ N 1)+_test_Rem_RoundHalfZero_P2_N3 =  Dict+_test_Div_RoundHalfZero_P2_N4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (N 4) ~ Z)+_test_Div_RoundHalfZero_P2_N4 =  Dict+_test_Rem_RoundHalfZero_P2_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (N 4) ~ P 2)+_test_Rem_RoundHalfZero_P2_N4 =  Dict+_test_Div_RoundHalfZero_P2_P1 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 1) ~ P 2)+_test_Div_RoundHalfZero_P2_P1 =  Dict+_test_Rem_RoundHalfZero_P2_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 1) ~ Z)+_test_Rem_RoundHalfZero_P2_P1 =  Dict+_test_Div_RoundHalfZero_P2_P2 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 2) ~ P 1)+_test_Div_RoundHalfZero_P2_P2 =  Dict+_test_Rem_RoundHalfZero_P2_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 2) ~ Z)+_test_Rem_RoundHalfZero_P2_P2 =  Dict+_test_Div_RoundHalfZero_P2_P3 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 3) ~ P 1)+_test_Div_RoundHalfZero_P2_P3 =  Dict+_test_Rem_RoundHalfZero_P2_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 3) ~ N 1)+_test_Rem_RoundHalfZero_P2_P3 =  Dict+_test_Div_RoundHalfZero_P2_P4 :: Dict (K.Div 'K.RoundHalfZero (P 2) (P 4) ~ Z)+_test_Div_RoundHalfZero_P2_P4 =  Dict+_test_Rem_RoundHalfZero_P2_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 2) (P 4) ~ P 2)+_test_Rem_RoundHalfZero_P2_P4 =  Dict+_test_Div_RoundHalfZero_P3_N1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 1) ~ N 3)+_test_Div_RoundHalfZero_P3_N1 =  Dict+_test_Rem_RoundHalfZero_P3_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 1) ~ Z)+_test_Rem_RoundHalfZero_P3_N1 =  Dict+_test_Div_RoundHalfZero_P3_N2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 2) ~ N 1)+_test_Div_RoundHalfZero_P3_N2 =  Dict+_test_Rem_RoundHalfZero_P3_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 2) ~ P 1)+_test_Rem_RoundHalfZero_P3_N2 =  Dict+_test_Div_RoundHalfZero_P3_N3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 3) ~ N 1)+_test_Div_RoundHalfZero_P3_N3 =  Dict+_test_Rem_RoundHalfZero_P3_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 3) ~ Z)+_test_Rem_RoundHalfZero_P3_N3 =  Dict+_test_Div_RoundHalfZero_P3_N4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (N 4) ~ N 1)+_test_Div_RoundHalfZero_P3_N4 =  Dict+_test_Rem_RoundHalfZero_P3_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (N 4) ~ N 1)+_test_Rem_RoundHalfZero_P3_N4 =  Dict+_test_Div_RoundHalfZero_P3_P1 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 1) ~ P 3)+_test_Div_RoundHalfZero_P3_P1 =  Dict+_test_Rem_RoundHalfZero_P3_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 1) ~ Z)+_test_Rem_RoundHalfZero_P3_P1 =  Dict+_test_Div_RoundHalfZero_P3_P2 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 2) ~ P 1)+_test_Div_RoundHalfZero_P3_P2 =  Dict+_test_Rem_RoundHalfZero_P3_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 2) ~ P 1)+_test_Rem_RoundHalfZero_P3_P2 =  Dict+_test_Div_RoundHalfZero_P3_P3 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 3) ~ P 1)+_test_Div_RoundHalfZero_P3_P3 =  Dict+_test_Rem_RoundHalfZero_P3_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 3) ~ Z)+_test_Rem_RoundHalfZero_P3_P3 =  Dict+_test_Div_RoundHalfZero_P3_P4 :: Dict (K.Div 'K.RoundHalfZero (P 3) (P 4) ~ P 1)+_test_Div_RoundHalfZero_P3_P4 =  Dict+_test_Rem_RoundHalfZero_P3_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 3) (P 4) ~ N 1)+_test_Rem_RoundHalfZero_P3_P4 =  Dict+_test_Div_RoundHalfZero_P4_N1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 1) ~ N 4)+_test_Div_RoundHalfZero_P4_N1 =  Dict+_test_Rem_RoundHalfZero_P4_N1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 1) ~ Z)+_test_Rem_RoundHalfZero_P4_N1 =  Dict+_test_Div_RoundHalfZero_P4_N2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 2) ~ N 2)+_test_Div_RoundHalfZero_P4_N2 =  Dict+_test_Rem_RoundHalfZero_P4_N2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 2) ~ Z)+_test_Rem_RoundHalfZero_P4_N2 =  Dict+_test_Div_RoundHalfZero_P4_N3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 3) ~ N 1)+_test_Div_RoundHalfZero_P4_N3 =  Dict+_test_Rem_RoundHalfZero_P4_N3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 3) ~ P 1)+_test_Rem_RoundHalfZero_P4_N3 =  Dict+_test_Div_RoundHalfZero_P4_N4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (N 4) ~ N 1)+_test_Div_RoundHalfZero_P4_N4 =  Dict+_test_Rem_RoundHalfZero_P4_N4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (N 4) ~ Z)+_test_Rem_RoundHalfZero_P4_N4 =  Dict+_test_Div_RoundHalfZero_P4_P1 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 1) ~ P 4)+_test_Div_RoundHalfZero_P4_P1 =  Dict+_test_Rem_RoundHalfZero_P4_P1 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 1) ~ Z)+_test_Rem_RoundHalfZero_P4_P1 =  Dict+_test_Div_RoundHalfZero_P4_P2 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 2) ~ P 2)+_test_Div_RoundHalfZero_P4_P2 =  Dict+_test_Rem_RoundHalfZero_P4_P2 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 2) ~ Z)+_test_Rem_RoundHalfZero_P4_P2 =  Dict+_test_Div_RoundHalfZero_P4_P3 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 3) ~ P 1)+_test_Div_RoundHalfZero_P4_P3 =  Dict+_test_Rem_RoundHalfZero_P4_P3 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 3) ~ P 1)+_test_Rem_RoundHalfZero_P4_P3 =  Dict+_test_Div_RoundHalfZero_P4_P4 :: Dict (K.Div 'K.RoundHalfZero (P 4) (P 4) ~ P 1)+_test_Div_RoundHalfZero_P4_P4 =  Dict+_test_Rem_RoundHalfZero_P4_P4 :: Dict (K.Rem 'K.RoundHalfZero (P 4) (P 4) ~ Z)+_test_Rem_RoundHalfZero_P4_P4 =  Dict+_test_Div_RoundUp_N1_N1 :: Dict (K.Div 'K.RoundUp (N 1) (N 1) ~ P 1)+_test_Div_RoundUp_N1_N1 =  Dict+_test_Rem_RoundUp_N1_N1 :: Dict (K.Rem 'K.RoundUp (N 1) (N 1) ~ Z)+_test_Rem_RoundUp_N1_N1 =  Dict+_test_Div_RoundUp_N1_N2 :: Dict (K.Div 'K.RoundUp (N 1) (N 2) ~ P 1)+_test_Div_RoundUp_N1_N2 =  Dict+_test_Rem_RoundUp_N1_N2 :: Dict (K.Rem 'K.RoundUp (N 1) (N 2) ~ P 1)+_test_Rem_RoundUp_N1_N2 =  Dict+_test_Div_RoundUp_N1_N3 :: Dict (K.Div 'K.RoundUp (N 1) (N 3) ~ P 1)+_test_Div_RoundUp_N1_N3 =  Dict+_test_Rem_RoundUp_N1_N3 :: Dict (K.Rem 'K.RoundUp (N 1) (N 3) ~ P 2)+_test_Rem_RoundUp_N1_N3 =  Dict+_test_Div_RoundUp_N1_N4 :: Dict (K.Div 'K.RoundUp (N 1) (N 4) ~ P 1)+_test_Div_RoundUp_N1_N4 =  Dict+_test_Rem_RoundUp_N1_N4 :: Dict (K.Rem 'K.RoundUp (N 1) (N 4) ~ P 3)+_test_Rem_RoundUp_N1_N4 =  Dict+_test_Div_RoundUp_N1_P1 :: Dict (K.Div 'K.RoundUp (N 1) (P 1) ~ N 1)+_test_Div_RoundUp_N1_P1 =  Dict+_test_Rem_RoundUp_N1_P1 :: Dict (K.Rem 'K.RoundUp (N 1) (P 1) ~ Z)+_test_Rem_RoundUp_N1_P1 =  Dict+_test_Div_RoundUp_N1_P2 :: Dict (K.Div 'K.RoundUp (N 1) (P 2) ~ Z)+_test_Div_RoundUp_N1_P2 =  Dict+_test_Rem_RoundUp_N1_P2 :: Dict (K.Rem 'K.RoundUp (N 1) (P 2) ~ N 1)+_test_Rem_RoundUp_N1_P2 =  Dict+_test_Div_RoundUp_N1_P3 :: Dict (K.Div 'K.RoundUp (N 1) (P 3) ~ Z)+_test_Div_RoundUp_N1_P3 =  Dict+_test_Rem_RoundUp_N1_P3 :: Dict (K.Rem 'K.RoundUp (N 1) (P 3) ~ N 1)+_test_Rem_RoundUp_N1_P3 =  Dict+_test_Div_RoundUp_N1_P4 :: Dict (K.Div 'K.RoundUp (N 1) (P 4) ~ Z)+_test_Div_RoundUp_N1_P4 =  Dict+_test_Rem_RoundUp_N1_P4 :: Dict (K.Rem 'K.RoundUp (N 1) (P 4) ~ N 1)+_test_Rem_RoundUp_N1_P4 =  Dict+_test_Div_RoundUp_N2_N1 :: Dict (K.Div 'K.RoundUp (N 2) (N 1) ~ P 2)+_test_Div_RoundUp_N2_N1 =  Dict+_test_Rem_RoundUp_N2_N1 :: Dict (K.Rem 'K.RoundUp (N 2) (N 1) ~ Z)+_test_Rem_RoundUp_N2_N1 =  Dict+_test_Div_RoundUp_N2_N2 :: Dict (K.Div 'K.RoundUp (N 2) (N 2) ~ P 1)+_test_Div_RoundUp_N2_N2 =  Dict+_test_Rem_RoundUp_N2_N2 :: Dict (K.Rem 'K.RoundUp (N 2) (N 2) ~ Z)+_test_Rem_RoundUp_N2_N2 =  Dict+_test_Div_RoundUp_N2_N3 :: Dict (K.Div 'K.RoundUp (N 2) (N 3) ~ P 1)+_test_Div_RoundUp_N2_N3 =  Dict+_test_Rem_RoundUp_N2_N3 :: Dict (K.Rem 'K.RoundUp (N 2) (N 3) ~ P 1)+_test_Rem_RoundUp_N2_N3 =  Dict+_test_Div_RoundUp_N2_N4 :: Dict (K.Div 'K.RoundUp (N 2) (N 4) ~ P 1)+_test_Div_RoundUp_N2_N4 =  Dict+_test_Rem_RoundUp_N2_N4 :: Dict (K.Rem 'K.RoundUp (N 2) (N 4) ~ P 2)+_test_Rem_RoundUp_N2_N4 =  Dict+_test_Div_RoundUp_N2_P1 :: Dict (K.Div 'K.RoundUp (N 2) (P 1) ~ N 2)+_test_Div_RoundUp_N2_P1 =  Dict+_test_Rem_RoundUp_N2_P1 :: Dict (K.Rem 'K.RoundUp (N 2) (P 1) ~ Z)+_test_Rem_RoundUp_N2_P1 =  Dict+_test_Div_RoundUp_N2_P2 :: Dict (K.Div 'K.RoundUp (N 2) (P 2) ~ N 1)+_test_Div_RoundUp_N2_P2 =  Dict+_test_Rem_RoundUp_N2_P2 :: Dict (K.Rem 'K.RoundUp (N 2) (P 2) ~ Z)+_test_Rem_RoundUp_N2_P2 =  Dict+_test_Div_RoundUp_N2_P3 :: Dict (K.Div 'K.RoundUp (N 2) (P 3) ~ Z)+_test_Div_RoundUp_N2_P3 =  Dict+_test_Rem_RoundUp_N2_P3 :: Dict (K.Rem 'K.RoundUp (N 2) (P 3) ~ N 2)+_test_Rem_RoundUp_N2_P3 =  Dict+_test_Div_RoundUp_N2_P4 :: Dict (K.Div 'K.RoundUp (N 2) (P 4) ~ Z)+_test_Div_RoundUp_N2_P4 =  Dict+_test_Rem_RoundUp_N2_P4 :: Dict (K.Rem 'K.RoundUp (N 2) (P 4) ~ N 2)+_test_Rem_RoundUp_N2_P4 =  Dict+_test_Div_RoundUp_N3_N1 :: Dict (K.Div 'K.RoundUp (N 3) (N 1) ~ P 3)+_test_Div_RoundUp_N3_N1 =  Dict+_test_Rem_RoundUp_N3_N1 :: Dict (K.Rem 'K.RoundUp (N 3) (N 1) ~ Z)+_test_Rem_RoundUp_N3_N1 =  Dict+_test_Div_RoundUp_N3_N2 :: Dict (K.Div 'K.RoundUp (N 3) (N 2) ~ P 2)+_test_Div_RoundUp_N3_N2 =  Dict+_test_Rem_RoundUp_N3_N2 :: Dict (K.Rem 'K.RoundUp (N 3) (N 2) ~ P 1)+_test_Rem_RoundUp_N3_N2 =  Dict+_test_Div_RoundUp_N3_N3 :: Dict (K.Div 'K.RoundUp (N 3) (N 3) ~ P 1)+_test_Div_RoundUp_N3_N3 =  Dict+_test_Rem_RoundUp_N3_N3 :: Dict (K.Rem 'K.RoundUp (N 3) (N 3) ~ Z)+_test_Rem_RoundUp_N3_N3 =  Dict+_test_Div_RoundUp_N3_N4 :: Dict (K.Div 'K.RoundUp (N 3) (N 4) ~ P 1)+_test_Div_RoundUp_N3_N4 =  Dict+_test_Rem_RoundUp_N3_N4 :: Dict (K.Rem 'K.RoundUp (N 3) (N 4) ~ P 1)+_test_Rem_RoundUp_N3_N4 =  Dict+_test_Div_RoundUp_N3_P1 :: Dict (K.Div 'K.RoundUp (N 3) (P 1) ~ N 3)+_test_Div_RoundUp_N3_P1 =  Dict+_test_Rem_RoundUp_N3_P1 :: Dict (K.Rem 'K.RoundUp (N 3) (P 1) ~ Z)+_test_Rem_RoundUp_N3_P1 =  Dict+_test_Div_RoundUp_N3_P2 :: Dict (K.Div 'K.RoundUp (N 3) (P 2) ~ N 1)+_test_Div_RoundUp_N3_P2 =  Dict+_test_Rem_RoundUp_N3_P2 :: Dict (K.Rem 'K.RoundUp (N 3) (P 2) ~ N 1)+_test_Rem_RoundUp_N3_P2 =  Dict+_test_Div_RoundUp_N3_P3 :: Dict (K.Div 'K.RoundUp (N 3) (P 3) ~ N 1)+_test_Div_RoundUp_N3_P3 =  Dict+_test_Rem_RoundUp_N3_P3 :: Dict (K.Rem 'K.RoundUp (N 3) (P 3) ~ Z)+_test_Rem_RoundUp_N3_P3 =  Dict+_test_Div_RoundUp_N3_P4 :: Dict (K.Div 'K.RoundUp (N 3) (P 4) ~ Z)+_test_Div_RoundUp_N3_P4 =  Dict+_test_Rem_RoundUp_N3_P4 :: Dict (K.Rem 'K.RoundUp (N 3) (P 4) ~ N 3)+_test_Rem_RoundUp_N3_P4 =  Dict+_test_Div_RoundUp_N4_N1 :: Dict (K.Div 'K.RoundUp (N 4) (N 1) ~ P 4)+_test_Div_RoundUp_N4_N1 =  Dict+_test_Rem_RoundUp_N4_N1 :: Dict (K.Rem 'K.RoundUp (N 4) (N 1) ~ Z)+_test_Rem_RoundUp_N4_N1 =  Dict+_test_Div_RoundUp_N4_N2 :: Dict (K.Div 'K.RoundUp (N 4) (N 2) ~ P 2)+_test_Div_RoundUp_N4_N2 =  Dict+_test_Rem_RoundUp_N4_N2 :: Dict (K.Rem 'K.RoundUp (N 4) (N 2) ~ Z)+_test_Rem_RoundUp_N4_N2 =  Dict+_test_Div_RoundUp_N4_N3 :: Dict (K.Div 'K.RoundUp (N 4) (N 3) ~ P 2)+_test_Div_RoundUp_N4_N3 =  Dict+_test_Rem_RoundUp_N4_N3 :: Dict (K.Rem 'K.RoundUp (N 4) (N 3) ~ P 2)+_test_Rem_RoundUp_N4_N3 =  Dict+_test_Div_RoundUp_N4_N4 :: Dict (K.Div 'K.RoundUp (N 4) (N 4) ~ P 1)+_test_Div_RoundUp_N4_N4 =  Dict+_test_Rem_RoundUp_N4_N4 :: Dict (K.Rem 'K.RoundUp (N 4) (N 4) ~ Z)+_test_Rem_RoundUp_N4_N4 =  Dict+_test_Div_RoundUp_N4_P1 :: Dict (K.Div 'K.RoundUp (N 4) (P 1) ~ N 4)+_test_Div_RoundUp_N4_P1 =  Dict+_test_Rem_RoundUp_N4_P1 :: Dict (K.Rem 'K.RoundUp (N 4) (P 1) ~ Z)+_test_Rem_RoundUp_N4_P1 =  Dict+_test_Div_RoundUp_N4_P2 :: Dict (K.Div 'K.RoundUp (N 4) (P 2) ~ N 2)+_test_Div_RoundUp_N4_P2 =  Dict+_test_Rem_RoundUp_N4_P2 :: Dict (K.Rem 'K.RoundUp (N 4) (P 2) ~ Z)+_test_Rem_RoundUp_N4_P2 =  Dict+_test_Div_RoundUp_N4_P3 :: Dict (K.Div 'K.RoundUp (N 4) (P 3) ~ N 1)+_test_Div_RoundUp_N4_P3 =  Dict+_test_Rem_RoundUp_N4_P3 :: Dict (K.Rem 'K.RoundUp (N 4) (P 3) ~ N 1)+_test_Rem_RoundUp_N4_P3 =  Dict+_test_Div_RoundUp_N4_P4 :: Dict (K.Div 'K.RoundUp (N 4) (P 4) ~ N 1)+_test_Div_RoundUp_N4_P4 =  Dict+_test_Rem_RoundUp_N4_P4 :: Dict (K.Rem 'K.RoundUp (N 4) (P 4) ~ Z)+_test_Rem_RoundUp_N4_P4 =  Dict+_test_Div_RoundUp_Z_N1 :: Dict (K.Div 'K.RoundUp Z (N 1) ~ Z)+_test_Div_RoundUp_Z_N1 =  Dict+_test_Rem_RoundUp_Z_N2 :: Dict (K.Rem 'K.RoundUp Z (N 2) ~ Z)+_test_Rem_RoundUp_Z_N2 =  Dict+_test_Div_RoundUp_Z_N3 :: Dict (K.Div 'K.RoundUp Z (N 3) ~ Z)+_test_Div_RoundUp_Z_N3 =  Dict+_test_Rem_RoundUp_Z_N4 :: Dict (K.Rem 'K.RoundUp Z (N 4) ~ Z)+_test_Rem_RoundUp_Z_N4 =  Dict+_test_Div_RoundUp_Z_P1 :: Dict (K.Div 'K.RoundUp Z (P 1) ~ Z)+_test_Div_RoundUp_Z_P1 =  Dict+_test_Rem_RoundUp_Z_P2 :: Dict (K.Rem 'K.RoundUp Z (P 2) ~ Z)+_test_Rem_RoundUp_Z_P2 =  Dict+_test_Div_RoundUp_Z_P3 :: Dict (K.Div 'K.RoundUp Z (P 3) ~ Z)+_test_Div_RoundUp_Z_P3 =  Dict+_test_Rem_RoundUp_Z_P4 :: Dict (K.Rem 'K.RoundUp Z (P 4) ~ Z)+_test_Rem_RoundUp_Z_P4 =  Dict+_test_Div_RoundUp_P1_N1 :: Dict (K.Div 'K.RoundUp (P 1) (N 1) ~ N 1)+_test_Div_RoundUp_P1_N1 =  Dict+_test_Rem_RoundUp_P1_N1 :: Dict (K.Rem 'K.RoundUp (P 1) (N 1) ~ Z)+_test_Rem_RoundUp_P1_N1 =  Dict+_test_Div_RoundUp_P1_N2 :: Dict (K.Div 'K.RoundUp (P 1) (N 2) ~ Z)+_test_Div_RoundUp_P1_N2 =  Dict+_test_Rem_RoundUp_P1_N2 :: Dict (K.Rem 'K.RoundUp (P 1) (N 2) ~ P 1)+_test_Rem_RoundUp_P1_N2 =  Dict+_test_Div_RoundUp_P1_N3 :: Dict (K.Div 'K.RoundUp (P 1) (N 3) ~ Z)+_test_Div_RoundUp_P1_N3 =  Dict+_test_Rem_RoundUp_P1_N3 :: Dict (K.Rem 'K.RoundUp (P 1) (N 3) ~ P 1)+_test_Rem_RoundUp_P1_N3 =  Dict+_test_Div_RoundUp_P1_N4 :: Dict (K.Div 'K.RoundUp (P 1) (N 4) ~ Z)+_test_Div_RoundUp_P1_N4 =  Dict+_test_Rem_RoundUp_P1_N4 :: Dict (K.Rem 'K.RoundUp (P 1) (N 4) ~ P 1)+_test_Rem_RoundUp_P1_N4 =  Dict+_test_Div_RoundUp_P1_P1 :: Dict (K.Div 'K.RoundUp (P 1) (P 1) ~ P 1)+_test_Div_RoundUp_P1_P1 =  Dict+_test_Rem_RoundUp_P1_P1 :: Dict (K.Rem 'K.RoundUp (P 1) (P 1) ~ Z)+_test_Rem_RoundUp_P1_P1 =  Dict+_test_Div_RoundUp_P1_P2 :: Dict (K.Div 'K.RoundUp (P 1) (P 2) ~ P 1)+_test_Div_RoundUp_P1_P2 =  Dict+_test_Rem_RoundUp_P1_P2 :: Dict (K.Rem 'K.RoundUp (P 1) (P 2) ~ N 1)+_test_Rem_RoundUp_P1_P2 =  Dict+_test_Div_RoundUp_P1_P3 :: Dict (K.Div 'K.RoundUp (P 1) (P 3) ~ P 1)+_test_Div_RoundUp_P1_P3 =  Dict+_test_Rem_RoundUp_P1_P3 :: Dict (K.Rem 'K.RoundUp (P 1) (P 3) ~ N 2)+_test_Rem_RoundUp_P1_P3 =  Dict+_test_Div_RoundUp_P1_P4 :: Dict (K.Div 'K.RoundUp (P 1) (P 4) ~ P 1)+_test_Div_RoundUp_P1_P4 =  Dict+_test_Rem_RoundUp_P1_P4 :: Dict (K.Rem 'K.RoundUp (P 1) (P 4) ~ N 3)+_test_Rem_RoundUp_P1_P4 =  Dict+_test_Div_RoundUp_P2_N1 :: Dict (K.Div 'K.RoundUp (P 2) (N 1) ~ N 2)+_test_Div_RoundUp_P2_N1 =  Dict+_test_Rem_RoundUp_P2_N1 :: Dict (K.Rem 'K.RoundUp (P 2) (N 1) ~ Z)+_test_Rem_RoundUp_P2_N1 =  Dict+_test_Div_RoundUp_P2_N2 :: Dict (K.Div 'K.RoundUp (P 2) (N 2) ~ N 1)+_test_Div_RoundUp_P2_N2 =  Dict+_test_Rem_RoundUp_P2_N2 :: Dict (K.Rem 'K.RoundUp (P 2) (N 2) ~ Z)+_test_Rem_RoundUp_P2_N2 =  Dict+_test_Div_RoundUp_P2_N3 :: Dict (K.Div 'K.RoundUp (P 2) (N 3) ~ Z)+_test_Div_RoundUp_P2_N3 =  Dict+_test_Rem_RoundUp_P2_N3 :: Dict (K.Rem 'K.RoundUp (P 2) (N 3) ~ P 2)+_test_Rem_RoundUp_P2_N3 =  Dict+_test_Div_RoundUp_P2_N4 :: Dict (K.Div 'K.RoundUp (P 2) (N 4) ~ Z)+_test_Div_RoundUp_P2_N4 =  Dict+_test_Rem_RoundUp_P2_N4 :: Dict (K.Rem 'K.RoundUp (P 2) (N 4) ~ P 2)+_test_Rem_RoundUp_P2_N4 =  Dict+_test_Div_RoundUp_P2_P1 :: Dict (K.Div 'K.RoundUp (P 2) (P 1) ~ P 2)+_test_Div_RoundUp_P2_P1 =  Dict+_test_Rem_RoundUp_P2_P1 :: Dict (K.Rem 'K.RoundUp (P 2) (P 1) ~ Z)+_test_Rem_RoundUp_P2_P1 =  Dict+_test_Div_RoundUp_P2_P2 :: Dict (K.Div 'K.RoundUp (P 2) (P 2) ~ P 1)+_test_Div_RoundUp_P2_P2 =  Dict+_test_Rem_RoundUp_P2_P2 :: Dict (K.Rem 'K.RoundUp (P 2) (P 2) ~ Z)+_test_Rem_RoundUp_P2_P2 =  Dict+_test_Div_RoundUp_P2_P3 :: Dict (K.Div 'K.RoundUp (P 2) (P 3) ~ P 1)+_test_Div_RoundUp_P2_P3 =  Dict+_test_Rem_RoundUp_P2_P3 :: Dict (K.Rem 'K.RoundUp (P 2) (P 3) ~ N 1)+_test_Rem_RoundUp_P2_P3 =  Dict+_test_Div_RoundUp_P2_P4 :: Dict (K.Div 'K.RoundUp (P 2) (P 4) ~ P 1)+_test_Div_RoundUp_P2_P4 =  Dict+_test_Rem_RoundUp_P2_P4 :: Dict (K.Rem 'K.RoundUp (P 2) (P 4) ~ N 2)+_test_Rem_RoundUp_P2_P4 =  Dict+_test_Div_RoundUp_P3_N1 :: Dict (K.Div 'K.RoundUp (P 3) (N 1) ~ N 3)+_test_Div_RoundUp_P3_N1 =  Dict+_test_Rem_RoundUp_P3_N1 :: Dict (K.Rem 'K.RoundUp (P 3) (N 1) ~ Z)+_test_Rem_RoundUp_P3_N1 =  Dict+_test_Div_RoundUp_P3_N2 :: Dict (K.Div 'K.RoundUp (P 3) (N 2) ~ N 1)+_test_Div_RoundUp_P3_N2 =  Dict+_test_Rem_RoundUp_P3_N2 :: Dict (K.Rem 'K.RoundUp (P 3) (N 2) ~ P 1)+_test_Rem_RoundUp_P3_N2 =  Dict+_test_Div_RoundUp_P3_N3 :: Dict (K.Div 'K.RoundUp (P 3) (N 3) ~ N 1)+_test_Div_RoundUp_P3_N3 =  Dict+_test_Rem_RoundUp_P3_N3 :: Dict (K.Rem 'K.RoundUp (P 3) (N 3) ~ Z)+_test_Rem_RoundUp_P3_N3 =  Dict+_test_Div_RoundUp_P3_N4 :: Dict (K.Div 'K.RoundUp (P 3) (N 4) ~ Z)+_test_Div_RoundUp_P3_N4 =  Dict+_test_Rem_RoundUp_P3_N4 :: Dict (K.Rem 'K.RoundUp (P 3) (N 4) ~ P 3)+_test_Rem_RoundUp_P3_N4 =  Dict+_test_Div_RoundUp_P3_P1 :: Dict (K.Div 'K.RoundUp (P 3) (P 1) ~ P 3)+_test_Div_RoundUp_P3_P1 =  Dict+_test_Rem_RoundUp_P3_P1 :: Dict (K.Rem 'K.RoundUp (P 3) (P 1) ~ Z)+_test_Rem_RoundUp_P3_P1 =  Dict+_test_Div_RoundUp_P3_P2 :: Dict (K.Div 'K.RoundUp (P 3) (P 2) ~ P 2)+_test_Div_RoundUp_P3_P2 =  Dict+_test_Rem_RoundUp_P3_P2 :: Dict (K.Rem 'K.RoundUp (P 3) (P 2) ~ N 1)+_test_Rem_RoundUp_P3_P2 =  Dict+_test_Div_RoundUp_P3_P3 :: Dict (K.Div 'K.RoundUp (P 3) (P 3) ~ P 1)+_test_Div_RoundUp_P3_P3 =  Dict+_test_Rem_RoundUp_P3_P3 :: Dict (K.Rem 'K.RoundUp (P 3) (P 3) ~ Z)+_test_Rem_RoundUp_P3_P3 =  Dict+_test_Div_RoundUp_P3_P4 :: Dict (K.Div 'K.RoundUp (P 3) (P 4) ~ P 1)+_test_Div_RoundUp_P3_P4 =  Dict+_test_Rem_RoundUp_P3_P4 :: Dict (K.Rem 'K.RoundUp (P 3) (P 4) ~ N 1)+_test_Rem_RoundUp_P3_P4 =  Dict+_test_Div_RoundUp_P4_N1 :: Dict (K.Div 'K.RoundUp (P 4) (N 1) ~ N 4)+_test_Div_RoundUp_P4_N1 =  Dict+_test_Rem_RoundUp_P4_N1 :: Dict (K.Rem 'K.RoundUp (P 4) (N 1) ~ Z)+_test_Rem_RoundUp_P4_N1 =  Dict+_test_Div_RoundUp_P4_N2 :: Dict (K.Div 'K.RoundUp (P 4) (N 2) ~ N 2)+_test_Div_RoundUp_P4_N2 =  Dict+_test_Rem_RoundUp_P4_N2 :: Dict (K.Rem 'K.RoundUp (P 4) (N 2) ~ Z)+_test_Rem_RoundUp_P4_N2 =  Dict+_test_Div_RoundUp_P4_N3 :: Dict (K.Div 'K.RoundUp (P 4) (N 3) ~ N 1)+_test_Div_RoundUp_P4_N3 =  Dict+_test_Rem_RoundUp_P4_N3 :: Dict (K.Rem 'K.RoundUp (P 4) (N 3) ~ P 1)+_test_Rem_RoundUp_P4_N3 =  Dict+_test_Div_RoundUp_P4_N4 :: Dict (K.Div 'K.RoundUp (P 4) (N 4) ~ N 1)+_test_Div_RoundUp_P4_N4 =  Dict+_test_Rem_RoundUp_P4_N4 :: Dict (K.Rem 'K.RoundUp (P 4) (N 4) ~ Z)+_test_Rem_RoundUp_P4_N4 =  Dict+_test_Div_RoundUp_P4_P1 :: Dict (K.Div 'K.RoundUp (P 4) (P 1) ~ P 4)+_test_Div_RoundUp_P4_P1 =  Dict+_test_Rem_RoundUp_P4_P1 :: Dict (K.Rem 'K.RoundUp (P 4) (P 1) ~ Z)+_test_Rem_RoundUp_P4_P1 =  Dict+_test_Div_RoundUp_P4_P2 :: Dict (K.Div 'K.RoundUp (P 4) (P 2) ~ P 2)+_test_Div_RoundUp_P4_P2 =  Dict+_test_Rem_RoundUp_P4_P2 :: Dict (K.Rem 'K.RoundUp (P 4) (P 2) ~ Z)+_test_Rem_RoundUp_P4_P2 =  Dict+_test_Div_RoundUp_P4_P3 :: Dict (K.Div 'K.RoundUp (P 4) (P 3) ~ P 2)+_test_Div_RoundUp_P4_P3 =  Dict+_test_Rem_RoundUp_P4_P3 :: Dict (K.Rem 'K.RoundUp (P 4) (P 3) ~ N 2)+_test_Rem_RoundUp_P4_P3 =  Dict+_test_Div_RoundUp_P4_P4 :: Dict (K.Div 'K.RoundUp (P 4) (P 4) ~ P 1)+_test_Div_RoundUp_P4_P4 =  Dict+_test_Rem_RoundUp_P4_P4 :: Dict (K.Rem 'K.RoundUp (P 4) (P 4) ~ Z)+_test_Rem_RoundUp_P4_P4 =  Dict+_test_Div_RoundZero_N1_N1 :: Dict (K.Div 'K.RoundZero (N 1) (N 1) ~ P 1)+_test_Div_RoundZero_N1_N1 =  Dict+_test_Rem_RoundZero_N1_N1 :: Dict (K.Rem 'K.RoundZero (N 1) (N 1) ~ Z)+_test_Rem_RoundZero_N1_N1 =  Dict+_test_Div_RoundZero_N1_N2 :: Dict (K.Div 'K.RoundZero (N 1) (N 2) ~ Z)+_test_Div_RoundZero_N1_N2 =  Dict+_test_Rem_RoundZero_N1_N2 :: Dict (K.Rem 'K.RoundZero (N 1) (N 2) ~ N 1)+_test_Rem_RoundZero_N1_N2 =  Dict+_test_Div_RoundZero_N1_N3 :: Dict (K.Div 'K.RoundZero (N 1) (N 3) ~ Z)+_test_Div_RoundZero_N1_N3 =  Dict+_test_Rem_RoundZero_N1_N3 :: Dict (K.Rem 'K.RoundZero (N 1) (N 3) ~ N 1)+_test_Rem_RoundZero_N1_N3 =  Dict+_test_Div_RoundZero_N1_N4 :: Dict (K.Div 'K.RoundZero (N 1) (N 4) ~ Z)+_test_Div_RoundZero_N1_N4 =  Dict+_test_Rem_RoundZero_N1_N4 :: Dict (K.Rem 'K.RoundZero (N 1) (N 4) ~ N 1)+_test_Rem_RoundZero_N1_N4 =  Dict+_test_Div_RoundZero_N1_P1 :: Dict (K.Div 'K.RoundZero (N 1) (P 1) ~ N 1)+_test_Div_RoundZero_N1_P1 =  Dict+_test_Rem_RoundZero_N1_P1 :: Dict (K.Rem 'K.RoundZero (N 1) (P 1) ~ Z)+_test_Rem_RoundZero_N1_P1 =  Dict+_test_Div_RoundZero_N1_P2 :: Dict (K.Div 'K.RoundZero (N 1) (P 2) ~ Z)+_test_Div_RoundZero_N1_P2 =  Dict+_test_Rem_RoundZero_N1_P2 :: Dict (K.Rem 'K.RoundZero (N 1) (P 2) ~ N 1)+_test_Rem_RoundZero_N1_P2 =  Dict+_test_Div_RoundZero_N1_P3 :: Dict (K.Div 'K.RoundZero (N 1) (P 3) ~ Z)+_test_Div_RoundZero_N1_P3 =  Dict+_test_Rem_RoundZero_N1_P3 :: Dict (K.Rem 'K.RoundZero (N 1) (P 3) ~ N 1)+_test_Rem_RoundZero_N1_P3 =  Dict+_test_Div_RoundZero_N1_P4 :: Dict (K.Div 'K.RoundZero (N 1) (P 4) ~ Z)+_test_Div_RoundZero_N1_P4 =  Dict+_test_Rem_RoundZero_N1_P4 :: Dict (K.Rem 'K.RoundZero (N 1) (P 4) ~ N 1)+_test_Rem_RoundZero_N1_P4 =  Dict+_test_Div_RoundZero_N2_N1 :: Dict (K.Div 'K.RoundZero (N 2) (N 1) ~ P 2)+_test_Div_RoundZero_N2_N1 =  Dict+_test_Rem_RoundZero_N2_N1 :: Dict (K.Rem 'K.RoundZero (N 2) (N 1) ~ Z)+_test_Rem_RoundZero_N2_N1 =  Dict+_test_Div_RoundZero_N2_N2 :: Dict (K.Div 'K.RoundZero (N 2) (N 2) ~ P 1)+_test_Div_RoundZero_N2_N2 =  Dict+_test_Rem_RoundZero_N2_N2 :: Dict (K.Rem 'K.RoundZero (N 2) (N 2) ~ Z)+_test_Rem_RoundZero_N2_N2 =  Dict+_test_Div_RoundZero_N2_N3 :: Dict (K.Div 'K.RoundZero (N 2) (N 3) ~ Z)+_test_Div_RoundZero_N2_N3 =  Dict+_test_Rem_RoundZero_N2_N3 :: Dict (K.Rem 'K.RoundZero (N 2) (N 3) ~ N 2)+_test_Rem_RoundZero_N2_N3 =  Dict+_test_Div_RoundZero_N2_N4 :: Dict (K.Div 'K.RoundZero (N 2) (N 4) ~ Z)+_test_Div_RoundZero_N2_N4 =  Dict+_test_Rem_RoundZero_N2_N4 :: Dict (K.Rem 'K.RoundZero (N 2) (N 4) ~ N 2)+_test_Rem_RoundZero_N2_N4 =  Dict+_test_Div_RoundZero_N2_P1 :: Dict (K.Div 'K.RoundZero (N 2) (P 1) ~ N 2)+_test_Div_RoundZero_N2_P1 =  Dict+_test_Rem_RoundZero_N2_P1 :: Dict (K.Rem 'K.RoundZero (N 2) (P 1) ~ Z)+_test_Rem_RoundZero_N2_P1 =  Dict+_test_Div_RoundZero_N2_P2 :: Dict (K.Div 'K.RoundZero (N 2) (P 2) ~ N 1)+_test_Div_RoundZero_N2_P2 =  Dict+_test_Rem_RoundZero_N2_P2 :: Dict (K.Rem 'K.RoundZero (N 2) (P 2) ~ Z)+_test_Rem_RoundZero_N2_P2 =  Dict+_test_Div_RoundZero_N2_P3 :: Dict (K.Div 'K.RoundZero (N 2) (P 3) ~ Z)+_test_Div_RoundZero_N2_P3 =  Dict+_test_Rem_RoundZero_N2_P3 :: Dict (K.Rem 'K.RoundZero (N 2) (P 3) ~ N 2)+_test_Rem_RoundZero_N2_P3 =  Dict+_test_Div_RoundZero_N2_P4 :: Dict (K.Div 'K.RoundZero (N 2) (P 4) ~ Z)+_test_Div_RoundZero_N2_P4 =  Dict+_test_Rem_RoundZero_N2_P4 :: Dict (K.Rem 'K.RoundZero (N 2) (P 4) ~ N 2)+_test_Rem_RoundZero_N2_P4 =  Dict+_test_Div_RoundZero_N3_N1 :: Dict (K.Div 'K.RoundZero (N 3) (N 1) ~ P 3)+_test_Div_RoundZero_N3_N1 =  Dict+_test_Rem_RoundZero_N3_N1 :: Dict (K.Rem 'K.RoundZero (N 3) (N 1) ~ Z)+_test_Rem_RoundZero_N3_N1 =  Dict+_test_Div_RoundZero_N3_N2 :: Dict (K.Div 'K.RoundZero (N 3) (N 2) ~ P 1)+_test_Div_RoundZero_N3_N2 =  Dict+_test_Rem_RoundZero_N3_N2 :: Dict (K.Rem 'K.RoundZero (N 3) (N 2) ~ N 1)+_test_Rem_RoundZero_N3_N2 =  Dict+_test_Div_RoundZero_N3_N3 :: Dict (K.Div 'K.RoundZero (N 3) (N 3) ~ P 1)+_test_Div_RoundZero_N3_N3 =  Dict+_test_Rem_RoundZero_N3_N3 :: Dict (K.Rem 'K.RoundZero (N 3) (N 3) ~ Z)+_test_Rem_RoundZero_N3_N3 =  Dict+_test_Div_RoundZero_N3_N4 :: Dict (K.Div 'K.RoundZero (N 3) (N 4) ~ Z)+_test_Div_RoundZero_N3_N4 =  Dict+_test_Rem_RoundZero_N3_N4 :: Dict (K.Rem 'K.RoundZero (N 3) (N 4) ~ N 3)+_test_Rem_RoundZero_N3_N4 =  Dict+_test_Div_RoundZero_N3_P1 :: Dict (K.Div 'K.RoundZero (N 3) (P 1) ~ N 3)+_test_Div_RoundZero_N3_P1 =  Dict+_test_Rem_RoundZero_N3_P1 :: Dict (K.Rem 'K.RoundZero (N 3) (P 1) ~ Z)+_test_Rem_RoundZero_N3_P1 =  Dict+_test_Div_RoundZero_N3_P2 :: Dict (K.Div 'K.RoundZero (N 3) (P 2) ~ N 1)+_test_Div_RoundZero_N3_P2 =  Dict+_test_Rem_RoundZero_N3_P2 :: Dict (K.Rem 'K.RoundZero (N 3) (P 2) ~ N 1)+_test_Rem_RoundZero_N3_P2 =  Dict+_test_Div_RoundZero_N3_P3 :: Dict (K.Div 'K.RoundZero (N 3) (P 3) ~ N 1)+_test_Div_RoundZero_N3_P3 =  Dict+_test_Rem_RoundZero_N3_P3 :: Dict (K.Rem 'K.RoundZero (N 3) (P 3) ~ Z)+_test_Rem_RoundZero_N3_P3 =  Dict+_test_Div_RoundZero_N3_P4 :: Dict (K.Div 'K.RoundZero (N 3) (P 4) ~ Z)+_test_Div_RoundZero_N3_P4 =  Dict+_test_Rem_RoundZero_N3_P4 :: Dict (K.Rem 'K.RoundZero (N 3) (P 4) ~ N 3)+_test_Rem_RoundZero_N3_P4 =  Dict+_test_Div_RoundZero_N4_N1 :: Dict (K.Div 'K.RoundZero (N 4) (N 1) ~ P 4)+_test_Div_RoundZero_N4_N1 =  Dict+_test_Rem_RoundZero_N4_N1 :: Dict (K.Rem 'K.RoundZero (N 4) (N 1) ~ Z)+_test_Rem_RoundZero_N4_N1 =  Dict+_test_Div_RoundZero_N4_N2 :: Dict (K.Div 'K.RoundZero (N 4) (N 2) ~ P 2)+_test_Div_RoundZero_N4_N2 =  Dict+_test_Rem_RoundZero_N4_N2 :: Dict (K.Rem 'K.RoundZero (N 4) (N 2) ~ Z)+_test_Rem_RoundZero_N4_N2 =  Dict+_test_Div_RoundZero_N4_N3 :: Dict (K.Div 'K.RoundZero (N 4) (N 3) ~ P 1)+_test_Div_RoundZero_N4_N3 =  Dict+_test_Rem_RoundZero_N4_N3 :: Dict (K.Rem 'K.RoundZero (N 4) (N 3) ~ N 1)+_test_Rem_RoundZero_N4_N3 =  Dict+_test_Div_RoundZero_N4_N4 :: Dict (K.Div 'K.RoundZero (N 4) (N 4) ~ P 1)+_test_Div_RoundZero_N4_N4 =  Dict+_test_Rem_RoundZero_N4_N4 :: Dict (K.Rem 'K.RoundZero (N 4) (N 4) ~ Z)+_test_Rem_RoundZero_N4_N4 =  Dict+_test_Div_RoundZero_N4_P1 :: Dict (K.Div 'K.RoundZero (N 4) (P 1) ~ N 4)+_test_Div_RoundZero_N4_P1 =  Dict+_test_Rem_RoundZero_N4_P1 :: Dict (K.Rem 'K.RoundZero (N 4) (P 1) ~ Z)+_test_Rem_RoundZero_N4_P1 =  Dict+_test_Div_RoundZero_N4_P2 :: Dict (K.Div 'K.RoundZero (N 4) (P 2) ~ N 2)+_test_Div_RoundZero_N4_P2 =  Dict+_test_Rem_RoundZero_N4_P2 :: Dict (K.Rem 'K.RoundZero (N 4) (P 2) ~ Z)+_test_Rem_RoundZero_N4_P2 =  Dict+_test_Div_RoundZero_N4_P3 :: Dict (K.Div 'K.RoundZero (N 4) (P 3) ~ N 1)+_test_Div_RoundZero_N4_P3 =  Dict+_test_Rem_RoundZero_N4_P3 :: Dict (K.Rem 'K.RoundZero (N 4) (P 3) ~ N 1)+_test_Rem_RoundZero_N4_P3 =  Dict+_test_Div_RoundZero_N4_P4 :: Dict (K.Div 'K.RoundZero (N 4) (P 4) ~ N 1)+_test_Div_RoundZero_N4_P4 =  Dict+_test_Rem_RoundZero_N4_P4 :: Dict (K.Rem 'K.RoundZero (N 4) (P 4) ~ Z)+_test_Rem_RoundZero_N4_P4 =  Dict+_test_Div_RoundZero_Z_N1 :: Dict (K.Div 'K.RoundZero Z (N 1) ~ Z)+_test_Div_RoundZero_Z_N1 =  Dict+_test_Div_RoundZero_Z_N2 :: Dict (K.Div 'K.RoundZero Z (N 2) ~ Z)+_test_Div_RoundZero_Z_N2 =  Dict+_test_Div_RoundZero_Z_N3 :: Dict (K.Div 'K.RoundZero Z (N 3) ~ Z)+_test_Div_RoundZero_Z_N3 =  Dict+_test_Div_RoundZero_Z_N4 :: Dict (K.Div 'K.RoundZero Z (N 4) ~ Z)+_test_Div_RoundZero_Z_N4 =  Dict+_test_Div_RoundZero_Z_P1 :: Dict (K.Div 'K.RoundZero Z (P 1) ~ Z)+_test_Div_RoundZero_Z_P1 =  Dict+_test_Div_RoundZero_Z_P2 :: Dict (K.Div 'K.RoundZero Z (P 2) ~ Z)+_test_Div_RoundZero_Z_P2 =  Dict+_test_Div_RoundZero_Z_P3 :: Dict (K.Div 'K.RoundZero Z (P 3) ~ Z)+_test_Div_RoundZero_Z_P3 =  Dict+_test_Div_RoundZero_Z_P4 :: Dict (K.Div 'K.RoundZero Z (P 4) ~ Z)+_test_Div_RoundZero_Z_P4 =  Dict+_test_Div_RoundZero_P1_N1 :: Dict (K.Div 'K.RoundZero (P 1) (N 1) ~ N 1)+_test_Div_RoundZero_P1_N1 =  Dict+_test_Rem_RoundZero_P1_N1 :: Dict (K.Rem 'K.RoundZero (P 1) (N 1) ~ Z)+_test_Rem_RoundZero_P1_N1 =  Dict+_test_Div_RoundZero_P1_N2 :: Dict (K.Div 'K.RoundZero (P 1) (N 2) ~ Z)+_test_Div_RoundZero_P1_N2 =  Dict+_test_Rem_RoundZero_P1_N2 :: Dict (K.Rem 'K.RoundZero (P 1) (N 2) ~ P 1)+_test_Rem_RoundZero_P1_N2 =  Dict+_test_Div_RoundZero_P1_N3 :: Dict (K.Div 'K.RoundZero (P 1) (N 3) ~ Z)+_test_Div_RoundZero_P1_N3 =  Dict+_test_Rem_RoundZero_P1_N3 :: Dict (K.Rem 'K.RoundZero (P 1) (N 3) ~ P 1)+_test_Rem_RoundZero_P1_N3 =  Dict+_test_Div_RoundZero_P1_N4 :: Dict (K.Div 'K.RoundZero (P 1) (N 4) ~ Z)+_test_Div_RoundZero_P1_N4 =  Dict+_test_Rem_RoundZero_P1_N4 :: Dict (K.Rem 'K.RoundZero (P 1) (N 4) ~ P 1)+_test_Rem_RoundZero_P1_N4 =  Dict+_test_Div_RoundZero_P1_P1 :: Dict (K.Div 'K.RoundZero (P 1) (P 1) ~ P 1)+_test_Div_RoundZero_P1_P1 =  Dict+_test_Rem_RoundZero_P1_P1 :: Dict (K.Rem 'K.RoundZero (P 1) (P 1) ~ Z)+_test_Rem_RoundZero_P1_P1 =  Dict+_test_Div_RoundZero_P1_P2 :: Dict (K.Div 'K.RoundZero (P 1) (P 2) ~ Z)+_test_Div_RoundZero_P1_P2 =  Dict+_test_Rem_RoundZero_P1_P2 :: Dict (K.Rem 'K.RoundZero (P 1) (P 2) ~ P 1)+_test_Rem_RoundZero_P1_P2 =  Dict+_test_Div_RoundZero_P1_P3 :: Dict (K.Div 'K.RoundZero (P 1) (P 3) ~ Z)+_test_Div_RoundZero_P1_P3 =  Dict+_test_Rem_RoundZero_P1_P3 :: Dict (K.Rem 'K.RoundZero (P 1) (P 3) ~ P 1)+_test_Rem_RoundZero_P1_P3 =  Dict+_test_Div_RoundZero_P1_P4 :: Dict (K.Div 'K.RoundZero (P 1) (P 4) ~ Z)+_test_Div_RoundZero_P1_P4 =  Dict+_test_Rem_RoundZero_P1_P4 :: Dict (K.Rem 'K.RoundZero (P 1) (P 4) ~ P 1)+_test_Rem_RoundZero_P1_P4 =  Dict+_test_Div_RoundZero_P2_N1 :: Dict (K.Div 'K.RoundZero (P 2) (N 1) ~ N 2)+_test_Div_RoundZero_P2_N1 =  Dict+_test_Rem_RoundZero_P2_N1 :: Dict (K.Rem 'K.RoundZero (P 2) (N 1) ~ Z)+_test_Rem_RoundZero_P2_N1 =  Dict+_test_Div_RoundZero_P2_N2 :: Dict (K.Div 'K.RoundZero (P 2) (N 2) ~ N 1)+_test_Div_RoundZero_P2_N2 =  Dict+_test_Rem_RoundZero_P2_N2 :: Dict (K.Rem 'K.RoundZero (P 2) (N 2) ~ Z)+_test_Rem_RoundZero_P2_N2 =  Dict+_test_Div_RoundZero_P2_N3 :: Dict (K.Div 'K.RoundZero (P 2) (N 3) ~ Z)+_test_Div_RoundZero_P2_N3 =  Dict+_test_Rem_RoundZero_P2_N3 :: Dict (K.Rem 'K.RoundZero (P 2) (N 3) ~ P 2)+_test_Rem_RoundZero_P2_N3 =  Dict+_test_Div_RoundZero_P2_N4 :: Dict (K.Div 'K.RoundZero (P 2) (N 4) ~ Z)+_test_Div_RoundZero_P2_N4 =  Dict+_test_Rem_RoundZero_P2_N4 :: Dict (K.Rem 'K.RoundZero (P 2) (N 4) ~ P 2)+_test_Rem_RoundZero_P2_N4 =  Dict+_test_Div_RoundZero_P2_P1 :: Dict (K.Div 'K.RoundZero (P 2) (P 1) ~ P 2)+_test_Div_RoundZero_P2_P1 =  Dict+_test_Rem_RoundZero_P2_P1 :: Dict (K.Rem 'K.RoundZero (P 2) (P 1) ~ Z)+_test_Rem_RoundZero_P2_P1 =  Dict+_test_Div_RoundZero_P2_P2 :: Dict (K.Div 'K.RoundZero (P 2) (P 2) ~ P 1)+_test_Div_RoundZero_P2_P2 =  Dict+_test_Rem_RoundZero_P2_P2 :: Dict (K.Rem 'K.RoundZero (P 2) (P 2) ~ Z)+_test_Rem_RoundZero_P2_P2 =  Dict+_test_Div_RoundZero_P2_P3 :: Dict (K.Div 'K.RoundZero (P 2) (P 3) ~ Z)+_test_Div_RoundZero_P2_P3 =  Dict+_test_Rem_RoundZero_P2_P3 :: Dict (K.Rem 'K.RoundZero (P 2) (P 3) ~ P 2)+_test_Rem_RoundZero_P2_P3 =  Dict+_test_Div_RoundZero_P2_P4 :: Dict (K.Div 'K.RoundZero (P 2) (P 4) ~ Z)+_test_Div_RoundZero_P2_P4 =  Dict+_test_Rem_RoundZero_P2_P4 :: Dict (K.Rem 'K.RoundZero (P 2) (P 4) ~ P 2)+_test_Rem_RoundZero_P2_P4 =  Dict+_test_Div_RoundZero_P3_N1 :: Dict (K.Div 'K.RoundZero (P 3) (N 1) ~ N 3)+_test_Div_RoundZero_P3_N1 =  Dict+_test_Rem_RoundZero_P3_N1 :: Dict (K.Rem 'K.RoundZero (P 3) (N 1) ~ Z)+_test_Rem_RoundZero_P3_N1 =  Dict+_test_Div_RoundZero_P3_N2 :: Dict (K.Div 'K.RoundZero (P 3) (N 2) ~ N 1)+_test_Div_RoundZero_P3_N2 =  Dict+_test_Rem_RoundZero_P3_N2 :: Dict (K.Rem 'K.RoundZero (P 3) (N 2) ~ P 1)+_test_Rem_RoundZero_P3_N2 =  Dict+_test_Div_RoundZero_P3_N3 :: Dict (K.Div 'K.RoundZero (P 3) (N 3) ~ N 1)+_test_Div_RoundZero_P3_N3 =  Dict+_test_Rem_RoundZero_P3_N3 :: Dict (K.Rem 'K.RoundZero (P 3) (N 3) ~ Z)+_test_Rem_RoundZero_P3_N3 =  Dict+_test_Div_RoundZero_P3_N4 :: Dict (K.Div 'K.RoundZero (P 3) (N 4) ~ Z)+_test_Div_RoundZero_P3_N4 =  Dict+_test_Rem_RoundZero_P3_N4 :: Dict (K.Rem 'K.RoundZero (P 3) (N 4) ~ P 3)+_test_Rem_RoundZero_P3_N4 =  Dict+_test_Div_RoundZero_P3_P1 :: Dict (K.Div 'K.RoundZero (P 3) (P 1) ~ P 3)+_test_Div_RoundZero_P3_P1 =  Dict+_test_Rem_RoundZero_P3_P1 :: Dict (K.Rem 'K.RoundZero (P 3) (P 1) ~ Z)+_test_Rem_RoundZero_P3_P1 =  Dict+_test_Div_RoundZero_P3_P2 :: Dict (K.Div 'K.RoundZero (P 3) (P 2) ~ P 1)+_test_Div_RoundZero_P3_P2 =  Dict+_test_Rem_RoundZero_P3_P2 :: Dict (K.Rem 'K.RoundZero (P 3) (P 2) ~ P 1)+_test_Rem_RoundZero_P3_P2 =  Dict+_test_Div_RoundZero_P3_P3 :: Dict (K.Div 'K.RoundZero (P 3) (P 3) ~ P 1)+_test_Div_RoundZero_P3_P3 =  Dict+_test_Rem_RoundZero_P3_P3 :: Dict (K.Rem 'K.RoundZero (P 3) (P 3) ~ Z)+_test_Rem_RoundZero_P3_P3 =  Dict+_test_Div_RoundZero_P3_P4 :: Dict (K.Div 'K.RoundZero (P 3) (P 4) ~ Z)+_test_Div_RoundZero_P3_P4 =  Dict+_test_Rem_RoundZero_P3_P4 :: Dict (K.Rem 'K.RoundZero (P 3) (P 4) ~ P 3)+_test_Rem_RoundZero_P3_P4 =  Dict+_test_Div_RoundZero_P4_N1 :: Dict (K.Div 'K.RoundZero (P 4) (N 1) ~ N 4)+_test_Div_RoundZero_P4_N1 =  Dict+_test_Rem_RoundZero_P4_N1 :: Dict (K.Rem 'K.RoundZero (P 4) (N 1) ~ Z)+_test_Rem_RoundZero_P4_N1 =  Dict+_test_Div_RoundZero_P4_N2 :: Dict (K.Div 'K.RoundZero (P 4) (N 2) ~ N 2)+_test_Div_RoundZero_P4_N2 =  Dict+_test_Rem_RoundZero_P4_N2 :: Dict (K.Rem 'K.RoundZero (P 4) (N 2) ~ Z)+_test_Rem_RoundZero_P4_N2 =  Dict+_test_Div_RoundZero_P4_N3 :: Dict (K.Div 'K.RoundZero (P 4) (N 3) ~ N 1)+_test_Div_RoundZero_P4_N3 =  Dict+_test_Rem_RoundZero_P4_N3 :: Dict (K.Rem 'K.RoundZero (P 4) (N 3) ~ P 1)+_test_Rem_RoundZero_P4_N3 =  Dict+_test_Div_RoundZero_P4_N4 :: Dict (K.Div 'K.RoundZero (P 4) (N 4) ~ N 1)+_test_Div_RoundZero_P4_N4 =  Dict+_test_Rem_RoundZero_P4_N4 :: Dict (K.Rem 'K.RoundZero (P 4) (N 4) ~ Z)+_test_Rem_RoundZero_P4_N4 =  Dict+_test_Div_RoundZero_P4_P1 :: Dict (K.Div 'K.RoundZero (P 4) (P 1) ~ P 4)+_test_Div_RoundZero_P4_P1 =  Dict+_test_Rem_RoundZero_P4_P1 :: Dict (K.Rem 'K.RoundZero (P 4) (P 1) ~ Z)+_test_Rem_RoundZero_P4_P1 =  Dict+_test_Div_RoundZero_P4_P2 :: Dict (K.Div 'K.RoundZero (P 4) (P 2) ~ P 2)+_test_Div_RoundZero_P4_P2 =  Dict+_test_Rem_RoundZero_P4_P2 :: Dict (K.Rem 'K.RoundZero (P 4) (P 2) ~ Z)+_test_Rem_RoundZero_P4_P2 =  Dict+_test_Div_RoundZero_P4_P3 :: Dict (K.Div 'K.RoundZero (P 4) (P 3) ~ P 1)+_test_Div_RoundZero_P4_P3 =  Dict+_test_Rem_RoundZero_P4_P3 :: Dict (K.Rem 'K.RoundZero (P 4) (P 3) ~ P 1)+_test_Rem_RoundZero_P4_P3 =  Dict+_test_Div_RoundZero_P4_P4 :: Dict (K.Div 'K.RoundZero (P 4) (P 4) ~ P 1)+_test_Div_RoundZero_P4_P4 =  Dict+_test_Rem_RoundZero_P4_P4 :: Dict (K.Rem 'K.RoundZero (P 4) (P 4) ~ Z)+_test_Rem_RoundZero_P4_P4 =  Dict++_test_ShowsPrec_AppPrec_Z :: Dict (P.ShowsPrec AppPrec Z "y" ~ "0y")+_test_ShowsPrec_AppPrec_Z =  Dict+_test_ShowsPrec_AppPrec_P1 :: Dict (P.ShowsPrec AppPrec (P 1) "y" ~ "1y")+_test_ShowsPrec_AppPrec_P1 =  Dict+_test_ShowsPrec_AppPrec_N1 :: Dict (P.ShowsPrec AppPrec (N 1) "y" ~ "-1y")+_test_ShowsPrec_AppPrec_N1 =  Dict++_test_ShowsPrec_AppPrec1_Z :: Dict (P.ShowsPrec AppPrec1 Z "y" ~ "0y")+_test_ShowsPrec_AppPrec1_Z =  Dict+_test_ShowsPrec_AppPrec1_P1 :: Dict (P.ShowsPrec AppPrec1 (P 1) "y" ~ "1y")+_test_ShowsPrec_AppPrec1_P1 =  Dict+_test_ShowsPrec_AppPrec1_N1 :: Dict (P.ShowsPrec AppPrec1 (N 1) "y" ~ "(-1)y")+_test_ShowsPrec_AppPrec1_N1 =  Dict++_test_ShowsPrecLit_AppPrec_Z :: Dict (K.ShowsPrecLit AppPrec Z "y" ~ "Zy")+_test_ShowsPrecLit_AppPrec_Z =  Dict+_test_ShowsPrecLit_AppPrec_P1 :: Dict (K.ShowsPrecLit AppPrec (P 1) "y" ~ "P 1y")+_test_ShowsPrecLit_AppPrec_P1 =  Dict+_test_ShowsPrecLit_AppPrec_N1 :: Dict (K.ShowsPrecLit AppPrec (N 1) "y" ~ "N 1y")+_test_ShowsPrecLit_AppPrec_N1 =  Dict++_test_ShowsPrecLit_AppPrec1_Z :: Dict (K.ShowsPrecLit AppPrec1 Z "y" ~ "Zy")+_test_ShowsPrecLit_AppPrec1_Z =  Dict+_test_ShowsPrecLit_AppPrec1_P1 :: Dict (K.ShowsPrecLit AppPrec1 (P 1) "y" ~ "(P 1)y")+_test_ShowsPrecLit_AppPrec1_P1 =  Dict+_test_ShowsPrecLit_AppPrec1_N1 :: Dict (K.ShowsPrecLit AppPrec1 (N 1) "y" ~ "(N 1)y")+_test_ShowsPrecLit_AppPrec1_N1 =  Dict++_test_Add_Z_Z :: Dict (Z P.+ Z ~ Z)+_test_Add_Z_Z =  Dict+_test_Add_Z_N1 :: Dict (Z P.+ N 1 ~ N 1)+_test_Add_Z_N1 =  Dict+_test_Add_Z_P1 :: Dict (Z P.+ P 1 ~ P 1)+_test_Add_Z_P1 =  Dict+_test_Add_Z_N2 :: Dict (Z P.+ N 2 ~ N 2)+_test_Add_Z_N2 =  Dict+_test_Add_Z_P2 :: Dict (Z P.+ P 2 ~ P 2)+_test_Add_Z_P2 =  Dict++_test_Add_N1_Z :: Dict (N 1 P.+ Z ~ N 1)+_test_Add_N1_Z =  Dict+_test_Add_N1_N1 :: Dict (N 1 P.+ N 1 ~ N 2)+_test_Add_N1_N1 =  Dict+_test_Add_N1_P1 :: Dict (N 1 P.+ P 1 ~ Z)+_test_Add_N1_P1 =  Dict+_test_Add_N1_N2 :: Dict (N 1 P.+ N 2 ~ N 3)+_test_Add_N1_N2 =  Dict+_test_Add_N1_P2 :: Dict (N 1 P.+ P 2 ~ P 1)+_test_Add_N1_P2 =  Dict++_test_Add_P1_Z :: Dict (P 1 P.+ Z ~ P 1)+_test_Add_P1_Z =  Dict+_test_Add_P1_N1 :: Dict (P 1 P.+ N 1 ~ Z)+_test_Add_P1_N1 =  Dict+_test_Add_P1_P1 :: Dict (P 1 P.+ P 1 ~ P 2)+_test_Add_P1_P1 =  Dict+_test_Add_P1_N2 :: Dict (P 1 P.+ N 2 ~ N 1)+_test_Add_P1_N2 =  Dict+_test_Add_P1_P2 :: Dict (P 1 P.+ P 2 ~ P 3)+_test_Add_P1_P2 =  Dict++_test_Add_N2_Z :: Dict (N 2 P.+ Z ~ N 2)+_test_Add_N2_Z =  Dict+_test_Add_N2_N1 :: Dict (N 2 P.+ N 1 ~ N 3)+_test_Add_N2_N1 =  Dict+_test_Add_N2_P1 :: Dict (N 2 P.+ P 1 ~ N 1)+_test_Add_N2_P1 =  Dict+_test_Add_N2_N2 :: Dict (N 2 P.+ N 2 ~ N 4)+_test_Add_N2_N2 =  Dict+_test_Add_N2_P2 :: Dict (N 2 P.+ P 2 ~ Z)+_test_Add_N2_P2 =  Dict++_test_Add_P2_Z :: Dict (P 2 P.+ Z ~ P 2)+_test_Add_P2_Z =  Dict+_test_Add_P2_N1 :: Dict (P 2 P.+ N 1 ~ P 1)+_test_Add_P2_N1 =  Dict+_test_Add_P2_P1 :: Dict (P 2 P.+ P 1 ~ P 3)+_test_Add_P2_P1 =  Dict+_test_Add_P2_N2 :: Dict (P 2 P.+ N 2 ~ Z)+_test_Add_P2_N2 =  Dict+_test_Add_P2_P2 :: Dict (P 2 P.+ P 2 ~ P 4)+_test_Add_P2_P2 =  Dict++_test_Sub_Z_Z :: Dict (Z P.- Z ~ Z)+_test_Sub_Z_Z =  Dict+_test_Sub_Z_N1 :: Dict (Z P.- N 1 ~ P 1)+_test_Sub_Z_N1 =  Dict+_test_Sub_Z_P1 :: Dict (Z P.- P 1 ~ N 1)+_test_Sub_Z_P1 =  Dict+_test_Sub_Z_N2 :: Dict (Z P.- N 2 ~ P 2)+_test_Sub_Z_N2 =  Dict+_test_Sub_Z_P2 :: Dict (Z P.- P 2 ~ N 2)+_test_Sub_Z_P2 =  Dict++_test_Sub_N1_Z :: Dict (N 1 P.- Z ~ N 1)+_test_Sub_N1_Z =  Dict+_test_Sub_N1_N1 :: Dict (N 1 P.- N 1 ~ Z)+_test_Sub_N1_N1 =  Dict+_test_Sub_N1_P1 :: Dict (N 1 P.- P 1 ~ N 2)+_test_Sub_N1_P1 =  Dict+_test_Sub_N1_N2 :: Dict (N 1 P.- N 2 ~ P 1)+_test_Sub_N1_N2 =  Dict+_test_Sub_N1_P2 :: Dict (N 1 P.- P 2 ~ N 3)+_test_Sub_N1_P2 =  Dict++_test_Sub_P1_Z :: Dict (P 1 P.- Z ~ P 1)+_test_Sub_P1_Z =  Dict+_test_Sub_P1_N1 :: Dict (P 1 P.- N 1 ~ P 2)+_test_Sub_P1_N1 =  Dict+_test_Sub_P1_P1 :: Dict (P 1 P.- P 1 ~ Z)+_test_Sub_P1_P1 =  Dict+_test_Sub_P1_N2 :: Dict (P 1 P.- N 2 ~ P 3)+_test_Sub_P1_N2 =  Dict+_test_Sub_P1_P2 :: Dict (P 1 P.- P 2 ~ N 1)+_test_Sub_P1_P2 =  Dict++_test_Sub_N2_Z :: Dict (N 2 P.- Z ~ N 2)+_test_Sub_N2_Z =  Dict+_test_Sub_N2_N1 :: Dict (N 2 P.- N 1 ~ N 1)+_test_Sub_N2_N1 =  Dict+_test_Sub_N2_P1 :: Dict (N 2 P.- P 1 ~ N 3)+_test_Sub_N2_P1 =  Dict+_test_Sub_N2_N2 :: Dict (N 2 P.- N 2 ~ Z)+_test_Sub_N2_N2 =  Dict+_test_Sub_N2_P2 :: Dict (N 2 P.- P 2 ~ N 4)+_test_Sub_N2_P2 =  Dict++_test_Sub_P2_Z :: Dict (P 2 P.- Z ~ P 2)+_test_Sub_P2_Z =  Dict+_test_Sub_P2_N1 :: Dict (P 2 P.- N 1 ~ P 3)+_test_Sub_P2_N1 =  Dict+_test_Sub_P2_P1 :: Dict (P 2 P.- P 1 ~ P 1)+_test_Sub_P2_P1 =  Dict+_test_Sub_P2_N2 :: Dict (P 2 P.- N 2 ~ P 4)+_test_Sub_P2_N2 =  Dict+_test_Sub_P2_P2 :: Dict (P 2 P.- P 2 ~ Z)+_test_Sub_P2_P2 =  Dict++_test_Mul_Z_Z :: Dict (Z P.* Z ~ Z)+_test_Mul_Z_Z =  Dict+_test_Mul_Z_N1 :: Dict (Z P.* N 1 ~ Z)+_test_Mul_Z_N1 =  Dict+_test_Mul_Z_P1 :: Dict (Z P.* P 1 ~ Z)+_test_Mul_Z_P1 =  Dict+_test_Mul_Z_N2 :: Dict (Z P.* N 2 ~ Z)+_test_Mul_Z_N2 =  Dict+_test_Mul_Z_P2 :: Dict (Z P.* P 2 ~ Z)+_test_Mul_Z_P2 =  Dict++_test_Mul_N1_Z :: Dict (N 1 P.* Z ~ Z)+_test_Mul_N1_Z =  Dict+_test_Mul_N1_N1 :: Dict (N 1 P.* N 1 ~ P 1)+_test_Mul_N1_N1 =  Dict+_test_Mul_N1_P1 :: Dict (N 1 P.* P 1 ~ N 1)+_test_Mul_N1_P1 =  Dict+_test_Mul_N1_N2 :: Dict (N 1 P.* N 2 ~ P 2)+_test_Mul_N1_N2 =  Dict+_test_Mul_N1_P2 :: Dict (N 1 P.* P 2 ~ N 2)+_test_Mul_N1_P2 =  Dict++_test_Mul_P1_Z :: Dict (P 1 P.* Z ~ Z)+_test_Mul_P1_Z =  Dict+_test_Mul_P1_N1 :: Dict (P 1 P.* N 1 ~ N 1)+_test_Mul_P1_N1 =  Dict+_test_Mul_P1_P1 :: Dict (P 1 P.* P 1 ~ P 1)+_test_Mul_P1_P1 =  Dict+_test_Mul_P1_N2 :: Dict (P 1 P.* N 2 ~ N 2)+_test_Mul_P1_N2 =  Dict+_test_Mul_P1_P2 :: Dict (P 1 P.* P 2 ~ P 2)+_test_Mul_P1_P2 =  Dict++_test_Mul_N2_Z :: Dict (N 2 P.* Z ~ Z)+_test_Mul_N2_Z =  Dict+_test_Mul_N2_N1 :: Dict (N 2 P.* N 1 ~ P 2)+_test_Mul_N2_N1 =  Dict+_test_Mul_N2_P1 :: Dict (N 2 P.* P 1 ~ N 2)+_test_Mul_N2_P1 =  Dict+_test_Mul_N2_N2 :: Dict (N 2 P.* N 2 ~ P 4)+_test_Mul_N2_N2 =  Dict+_test_Mul_N2_P2 :: Dict (N 2 P.* P 2 ~ N 4)+_test_Mul_N2_P2 =  Dict++_test_Mul_P2_Z :: Dict (P 2 P.* Z ~ Z)+_test_Mul_P2_Z =  Dict+_test_Mul_P2_N1 :: Dict (P 2 P.* N 1 ~ N 2)+_test_Mul_P2_N1 =  Dict+_test_Mul_P2_P1 :: Dict (P 2 P.* P 1 ~ P 2)+_test_Mul_P2_P1 =  Dict+_test_Mul_P2_N2 :: Dict (P 2 P.* N 2 ~ N 4)+_test_Mul_P2_N2 =  Dict+_test_Mul_P2_P2 :: Dict (P 2 P.* P 2 ~ P 4)+_test_Mul_P2_P2 =  Dict++_test_Pow_Z_Z :: Dict (Z K.^ 0 ~ P 1)+_test_Pow_Z_Z =  Dict+_test_Pow_Z_1 :: Dict (Z K.^ 1 ~ Z)+_test_Pow_Z_1 =  Dict+_test_Pow_Z_2 :: Dict (Z K.^ 2 ~ Z)+_test_Pow_Z_2 =  Dict++_test_Pow_N1_0 :: Dict (N 1 K.^ 0 ~ P 1)+_test_Pow_N1_0 =  Dict+_test_Pow_N1_1 :: Dict (N 1 K.^ 1 ~ N 1)+_test_Pow_N1_1 =  Dict+_test_Pow_N1_2 :: Dict (N 1 K.^ 2 ~ P 1)+_test_Pow_N1_2 =  Dict++_test_Pow_P1_Z :: Dict (P 1 K.^ 0 ~ P 1)+_test_Pow_P1_Z =  Dict+_test_Pow_P1_P1 :: Dict (P 1 K.^ 1 ~ P 1)+_test_Pow_P1_P1 =  Dict+_test_Pow_P1_P2 :: Dict (P 1 K.^ 2 ~ P 1)+_test_Pow_P1_P2 =  Dict++_test_Pow_N2_0 :: Dict (N 2 K.^ 0 ~ P 1)+_test_Pow_N2_0 =  Dict+_test_Pow_N2_1 :: Dict (N 2 K.^ 1 ~ N 2)+_test_Pow_N2_1 =  Dict+_test_Pow_N2_2 :: Dict (N 2 K.^ 2 ~ P 4)+_test_Pow_N2_2 =  Dict++_test_Pow_P2_0 :: Dict (P 2 K.^ 0 ~ P 1)+_test_Pow_P2_0 =  Dict+_test_Pow_P2_1 :: Dict (P 2 K.^ 1 ~ P 2)+_test_Pow_P2_1 =  Dict+_test_Pow_P2_2 :: Dict (P 2 K.^ 2 ~ P 4)+_test_Pow_P2_2 =  Dict++_test_ZigZag_Z :: Dict (K.ZigZag Z ~ 0)+_test_ZigZag_Z =  Dict+_test_ZigZag_N1 :: Dict (K.ZigZag (N 1) ~ 1)+_test_ZigZag_N1 =  Dict+_test_ZigZag_P1 :: Dict (K.ZigZag (P 1) ~ 2)+_test_ZigZag_P1 =  Dict+_test_ZigZag_N2 :: Dict (K.ZigZag (N 2) ~ 3)+_test_ZigZag_N2 =  Dict+_test_ZigZag_P2 :: Dict (K.ZigZag (P 2) ~ 4)+_test_ZigZag_P2 =  Dict++_test_ZagZig_Z :: Dict (K.ZagZig 0 ~ Z)+_test_ZagZig_Z =  Dict+_test_ZagZig_N1 :: Dict (K.ZagZig 1 ~ N 1)+_test_ZagZig_N1 =  Dict+_test_ZagZig_P1 :: Dict (K.ZagZig 2 ~ P 1)+_test_ZagZig_P1 =  Dict+_test_ZagZig_N2 :: Dict (K.ZagZig 3 ~ N 2)+_test_ZagZig_N2 =  Dict+_test_ZagZig_P2 :: Dict (K.ZagZig 4 ~ P 2)+_test_ZagZig_P2 =  Dict++_test_FromNatural_0 :: Dict (K.FromNatural 0 ~ Z)+_test_FromNatural_0 =  Dict+_test_FromNatural_1 :: Dict (K.FromNatural 1 ~ P 1)+_test_FromNatural_1 =  Dict+_test_FromNatural_2 :: Dict (K.FromNatural 2 ~ P 2)+_test_FromNatural_2 =  Dict++_test_Normalized_Z :: Dict (K.Normalized Z ~ Z)+_test_Normalized_Z =  Dict+_test_Normalized_N1 :: Dict (K.Normalized (N 1) ~ N 1)+_test_Normalized_N1 =  Dict+_test_Normalized_N2 :: Dict (K.Normalized (N 2) ~ N 2)+_test_Normalized_N2 =  Dict+_test_Normalized_P1 :: Dict (K.Normalized (P 1) ~ P 1)+_test_Normalized_P1 =  Dict+_test_Normalized_P2 :: Dict (K.Normalized (P 2) ~ P 2)+_test_Normalized_P2 =  Dict++_test_KnownInteger_Z :: Dict (K.KnownInteger Z)+_test_KnownInteger_Z =  Dict+_test_KnownInteger_N1 :: Dict (K.KnownInteger (N 1))+_test_KnownInteger_N1 =  Dict+_test_KnownInteger_N2 :: Dict (K.KnownInteger (N 2))+_test_KnownInteger_N2 =  Dict+_test_KnownInteger_P1 :: Dict (K.KnownInteger (P 1))+_test_KnownInteger_P1 =  Dict+_test_KnownInteger_P2 :: Dict (K.KnownInteger (P 2))+_test_KnownInteger_P2 =  Dict