kind-rational (empty) → 0.1
raw patch · 6 files changed
+2661/−0 lines, 6 filesdep +basedep +ghc-primdep +kind-integer
Dependencies added: base, ghc-prim, kind-integer, kind-rational
Files
- CHANGELOG.md +3/−0
- LICENSE +27/−0
- README.md +4/−0
- kind-rational.cabal +49/−0
- lib/KindRational.hs +717/−0
- test/Main.hs +1861/−0
+ CHANGELOG.md view
@@ -0,0 +1,3 @@+# Version 0.1++* Initial version.
+ LICENSE view
@@ -0,0 +1,27 @@+Copyright (c) 2023, Renzo Carbonara.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are+met:++1. Redistributions of source code must retain the above copyright+notice, this list of conditions and the following disclaimer.++2. Redistributions in binary form must reproduce the above copyright+notice, this list of conditions and the following disclaimer in the+documentation and/or other materials provided with the distribution.++3. Neither the name of the copyright holder nor the names of its+contributors may be used to endorse or promote products derived from+this software without specific prior written permission. THIS SOFTWARE+IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ README.md view
@@ -0,0 +1,4 @@+# kind-rational++Haskell type-level `Rational`s. Like `KnownNat`, but for `Rational`s.+
+ kind-rational.cabal view
@@ -0,0 +1,49 @@+cabal-version: 2.4+name: kind-rational+version: 0.1+license: BSD-3-Clause+license-file: LICENSE+extra-source-files: README.md CHANGELOG.md+author: Renzo Carbonara+maintainer: renλren.zone+copyright: Copyright (c) Renzo Carbonara 2023+category: Types+build-type: Simple+synopsis: Type-level rationals. Like KnownNat, but for rationals.+description: Type-level rationals. Like KnownNat, but for rationals.+homepage: https://github.com/k0001/hs-kind+bug-reports: https://github.com/k0001/hs-kind/issues+tested-with: GHC ==9.4.3++source-repository head+ type: git+ location: https://github.com/k0001/hs-kind+ subdir: kind-rational++common basic+ default-language: GHC2021+ ghc-options: -O2 -Wall -Werror=incomplete-patterns+ build-depends:+ base ==4.*,+ kind-integer >=0.2,+ default-extensions:+ DataKinds+ NoStarIsType+ LambdaCase+ PatternSynonyms+ TypeFamilies+ TypeOperators+ ViewPatterns++library+ import: basic+ hs-source-dirs: lib+ build-depends: ghc-prim+ exposed-modules: KindRational++test-suite test+ import: basic+ type: exitcode-stdio-1.0+ hs-source-dirs: test+ main-is: Main.hs+ build-depends: kind-rational
+ lib/KindRational.hs view
@@ -0,0 +1,717 @@+{-# LANGUAGE UndecidableInstances #-}+{-# LANGUAGE UndecidableSuperClasses #-}++-- | This module provides a type-level representation for term-level+-- 'P.Rational's. This type-level representation is also named 'P.Rational',+-- So import this module qualified to avoid name conflicts.+--+-- @+-- import "KindRational" qualified as KR+-- @+--+-- 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 core API as much as possible until the day+-- @base@ provides its own type-level rationals, making this module redundant.+module KindRational {--}+ ( -- * Rational kind+ Rational+ , type (%)+ , type (/)+ , Normalize+ , Num+ , Den++ -- Prelude support+ , rational+ , fromPrelude+ , toPrelude+ , showsPrecTypeLit++ -- * Types ⇔ Terms+ , KnownRational(rationalSing)+ , rationalVal+ , SomeRational(..)+ , someRationalVal+ , sameRational++ -- * Singletons+ , SRational+ , pattern SRational+ , fromSRational+ , withSomeSRational+ , withKnownRational++ -- * Arithmethic+ , type (+)+ , type (*)+ , type (-)+ , Negate+ , Sign+ , Abs+ , Recip+ , Div+ , div+ , Mod+ , mod+ , Dif+ , dif+ , DivMod+ , divMod+ , DivDif+ , divDif+ , I.Round(..)++ -- * Decimals+ , Terminating+ , withTerminating+ , Terminates+ , terminates++ -- * Comparisons+ , CmpRational+ , cmpRational++ -- * Extra+ --+ -- | This stuff should be exported by the "Data.Type.Ord" module.+ , type (==?), type (==), type (/=?), type (/=)+ ) --}+ where++import qualified Control.Exception as Ex+import Control.Monad+import Data.Proxy+import Data.Type.Bool (If)+import Data.Type.Coercion+import Data.Type.Equality (TestEquality(..), (:~:)(..))+import Data.Type.Ord+import GHC.Base (WithDict(..))+import GHC.Read qualified as Read+import GHC.Real qualified as P (Ratio(..), (%))+import GHC.Show (appPrec, appPrec1)+import GHC.TypeLits qualified as L+import GHC.TypeNats qualified as N+import GHC.Types (TYPE, Constraint)+import KindInteger (Integer, N, P)+import KindInteger (type (==?), type (==), type (/=?), type (/=))+import KindInteger qualified as I+import Numeric.Natural (Natural)+import Prelude hiding (Rational, Integer, Num, div, mod, divMod)+import Prelude qualified as P+import Text.ParserCombinators.ReadPrec as Read+import Text.Read.Lex qualified as Read+import Unsafe.Coerce(unsafeCoerce)++--------------------------------------------------------------------------------++-- | Type-level version of 'P.Rational'. Use '/' to construct one, use '%' to+-- pattern-match on it.+--+-- 'Rational' is mostly used as a kind, with its types constructed+-- using '/'. However, it might also be used as type, with its terms+-- constructed using 'rational' or 'fromPrelude'. One reason why you may want a+-- 'Rational' at the term-level is so that you embed it in larger data-types+-- (for example, this 'Rational' embeds the 'I.Integer' similarly offered by+-- the "KindInteger" module). But perhaps more importantly, this 'Rational'+-- offers better safety than the 'P.Rational' from "Prelude", since it's not+-- possible to construct one with a zero denominator, or so large that+-- operating with it would exhaust system resources. Notwithstanding this, for+-- ergonomic reasons, all of the functions exported by this module take+-- "Prelude" 'Rational's as input and produce "Prelude" 'Rational's as outputs.+-- Internally, however, the beforementioned checks are always performed, and+-- fail with 'Ex.throw' if necessary. If you want to be sure those 'error's+-- never happen, just filter your "Prelude" 'Rational's with 'fromPrelude'. In+-- practice, it's very unlikely that you will be affected by this unless if+-- you are unsafelly constructing "Prelude" 'Rational's.+data Rational+ = -- | This constructor is /unsafe/ because it doesn't check for the things+ -- that 'rational' checks for.+ --+ -- * At the term-level, safely construct a 'Rational' using 'rational'+ -- or 'fromPrelude' instead.+ --+ -- * At the type-level, safely construct a 'Rational' using '/'.+ I.Integer :% Natural++num :: Rational -> I.Integer+num (n :% _) = n++den :: Rational -> Natural+den (_ :% d) = d++instance Eq Rational where+ a == b = toPrelude a == toPrelude b++instance Ord Rational where+ compare a b = compare (toPrelude a) (toPrelude b)+ a <= b = toPrelude a <= toPrelude b++-- | Same as "Prelude" 'P.Rational'.+instance Show Rational where+ showsPrec p = showsPrec p . toPrelude++-- | Same as "Prelude" 'P.Rational'.+instance Read Rational where+ readPrec = Read.parens $ Read.prec 7 $ do -- 7 is GHC.Real.ratioPrec+ n :: P.Integer <- Read.step Read.readPrec+ Read.expectP (Read.Symbol "%")+ d :: P.Integer <- Read.step Read.readPrec+ Just r <- pure (rational n d)+ pure r++-- | Shows the 'Rational' as it appears literally at the type-level.+--+-- This is different from normal 'show' for 'Rational', which shows+-- the term-level value.+--+-- @+-- 'shows' 0 ('rationalVal' ('Proxy' \@(1'/'2))) \"z\" == \"1 % 2z\"+-- 'showsPrecTypeLit' 0 ('rationalVal' ('Proxy' \@(1'/'2))) \"z\" == \"P 1 % 2z\"+-- @+showsPrecTypeLit :: Int -> Rational -> ShowS+showsPrecTypeLit p r = showParen (p > appPrec) $+ I.showsPrecTypeLit appPrec (num r) . showString " % " . shows (den r)++-- | Make a term-level "KindRational" 'Rational' number, provided that+-- the numerator is not @0@, and that its numerator and denominator are+-- not so large that they would exhaust system resources. The 'Rational'+-- is 'Normalize'd.+rational :: (Integral num, Integral den) => num -> den -> Maybe Rational+rational = \(toInteger -> n) (toInteger -> d) -> do+ guard (d /= 0 && abs n <= max_ && abs d <= max_)+ pure $ let n1 P.:% d1 = n P.% d+ in I.fromPrelude n1 :% fromInteger d1+ where+ max_ :: P.Integer -- Some big enough number. TODO: Pick good number.+ max_ = 10 ^ (1000 :: Int)++-- | Try to obtain a term-level "KindRational" 'Rational' from a term-level+-- "Prelude" 'P.Rational'. This can fail if the "Prelude" 'P.Rational' is+-- infinite, or if it is so big that it would exhaust system resources.+--+-- @+-- 'fromPrelude' . 'toPrelude' == 'Just'+-- 'fmap' 'toPrelude' . 'fromPrelude' == 'Just'+-- @+fromPrelude :: P.Rational -> Maybe Rational+fromPrelude (n P.:% d) = rational n d++-- | Like 'fromPrelude', but 'Ex.throw's in situations where+-- 'fromPrelude' fails with 'Nothing'.+unsafeFromPrelude :: P.Rational -> Rational+unsafeFromPrelude = \case+ n P.:% d+ | d == 0 -> Ex.throw Ex.RatioZeroDenominator+ | abs n > max_ || abs d > max_ -> Ex.throw Ex.Overflow+ | otherwise ->+ let n1 P.:% d1 = n P.% d+ in I.fromPrelude n1 :% fromInteger d1+ where+ max_ :: P.Integer -- Some big enough number. TODO: Pick good number.+ max_ = 10 ^ (1000 :: Int)++-- | Convert a term-level "KindRational" 'Rational' into a term-level+-- "Prelude" 'P.Rational'.+--+-- @+-- 'fromPrelude' . 'toPrelude' == 'Just'+-- 'fmap' 'toPrelude' . 'fromPrelude' == 'Just'+-- @+toPrelude :: Rational -> P.Rational+toPrelude r = I.toPrelude (num r) P.:% toInteger (den r)++--------------------------------------------------------------------------------++-- | 'Normalize'd /'Num'erator/ of the type-level 'Rational'.+type Num (r :: Rational) = Num_ (Normalize r) :: Integer+type family Num_ (r :: Rational) :: Integer where+ Num_ (n :% _) = n++-- | 'Normalize'd /'Den'ominator/ of the type-level 'Rational'.+type Den (r :: Rational) = Den_ (Normalize r) :: Natural+type family Den_ (r :: Rational) :: Natural where+ Den_ (_ :% d) = d++-- | Pattern-match on a type-level 'Rational'.+--+-- __NB:__ When /constructing/ a 'Rational' number, prefer to use '/',+-- which not only accepts more polymorphic inputs, but also 'Normalize's+-- the type-level 'Rational'. Also note that while @n '%' 0@ is a valid+-- type, all tools in the "KindRational" will reject such input.+type (n :: I.Integer) % (d :: Natural) = n ':% d :: Rational++-- | Normalize a type-level 'Rational' so that a /0/ denominator fails to+-- type-check, and that the 'Num'erator and denominator have no common factors.+--+-- Only 'Normalize'd 'Rational's can be reliably constrained for equality+-- using '~'.+--+-- All of the functions in the "KindRational" module accept both+-- 'Normalize'd and non-'Normalize'd inputs, but they always produce+-- 'Normalize'd output.+type family Normalize (r :: Rational) :: Rational where+ Normalize (_ % 0) = L.TypeError ('L.Text "KindRational: Denominator is zero")+ Normalize (P 0 % _) = P 0 % 1+ Normalize (N 0 % _) = P 0 % 1+ Normalize (P n % d) = P (L.Div n (GCD n d)) % L.Div d (GCD n d)+ Normalize (N n % d) = N (L.Div n (GCD n d)) % L.Div d (GCD n d)++--------------------------------------------------------------------------------++infixl 6 +, -+infixl 7 *, /+++type (/) :: kn -> kd -> Rational+-- | @n'/'d@ constructs and 'Normalize's a type-level 'Rational'+-- with numerator @n@ and denominator @d@.+--+-- This type-family accepts any combination of 'Natural', 'Integer' and+-- 'Rational' as input.+--+-- @+-- ('/') :: 'Natural' -> 'Natural' -> 'Rational'+-- ('/') :: 'Natural' -> 'Integer' -> 'Rational'+-- ('/') :: 'Natural' -> 'Rational' -> 'Rational'+--+-- ('/') :: 'Integer' -> 'Natural' -> 'Rational'+-- ('/') :: 'Integer' -> 'Integer' -> 'Rational'+-- ('/') :: 'Integer' -> 'Rational' -> 'Rational'+--+-- ('/') :: 'Rational' -> 'Natural' -> 'Rational'+-- ('/') :: 'Rational' -> 'Integer' -> 'Rational'+-- ('/') :: 'Rational' -> 'Rational' -> 'Rational'+-- @+--+-- It's not possible to pattern-match on @n'/'d@. Instead, you must+-- pattern match on @x'%'y@, where @x'%'y ~ n'/'d@.+type family n / d :: Rational where+ -- Natural/Natural+ (n :: Natural) / (d :: Natural) = Normalize (P n % d)+ -- Natural/Integer+ (n :: Natural) / (P d :: Integer) = Normalize (P n % d)+ (n :: Natural) / (N d :: Integer) = Normalize (N n % d)+ -- Natural/Rational+ (n :: Natural) / (d :: Rational) = (P n % 1) * Recip d+ -- Integer/Natural+ (i :: Integer) / (d :: Natural) = Normalize (i % d)+ -- Integer/Integer+ (P n :: Integer) / (P d :: Integer) = Normalize (P n % d)+ (N n :: Integer) / (N d :: Integer) = Normalize (P n % d)+ (P n :: Integer) / (N d :: Integer) = Normalize (N n % d)+ (N n :: Integer) / (P d :: Integer) = Normalize (N n % d)+ -- Integer/Rational+ (n :: Integer) / (d :: Rational) = (n % 1) * Recip d+ -- Rational/Natural+ (n :: Rational) / (d :: Natural) = n * Recip (P d % 1)+ -- Rational/Integer+ (n :: Rational) / (d :: Integer) = n * Recip (d % 1)+ -- Rational/Rational+ (n :: Rational) / (d :: Rational) = n * Recip d++--------------------------------------------------------------------------------++-- | /'Negate'/ a type-level 'Rational'. Also known as /additive inverse/.+type family Negate (r :: Rational) :: Rational where+ Negate (P n % d) = Normalize (N n % d)+ Negate (N n % d) = Normalize (P n % d)++-- | Sign of type-level 'Rational's, as a type-level 'Integer'.+--+-- * @'P' 0@ if zero.+--+-- * @'P' 1@ if positive.+--+-- * @'N' 1@ if negative.+type Sign (r :: Rational) = I.Sign (Num r) :: Integer++-- | /'Abs'olute/ value of a type-level 'Rational'.+type Abs (r :: Rational) = Normalize (P (I.Abs (Num_ r)) % Den_ r) :: Rational++--------------------------------------------------------------------------------++-- | @a t'*' b@ multiplies type-level 'Rational's @a@ and @b@.+type (a :: Rational) * (b :: Rational) =+ Mul_ (Normalize a) (Normalize b) :: Rational+type family Mul_ (a :: Rational) (b :: Rational) where+ Mul_ (n1 % d1) (n2 % d2) = Normalize ((n1 I.* n2) % (d1 L.* d2))++-- | /'Recip'rocal/ of the type-level 'Rational'.+-- Also known as /multiplicative inverse/.+type Recip (a :: Rational) = Recip_ (Normalize a) :: Rational+type family Recip_ (a :: Rational) :: Rational where+ Recip_ (P n % d) = Normalize (P d % n)+ Recip_ (N n % d) = Normalize (N d % n)++-- | @a t'+' b@ adds type-level 'Rational's @a@ and @b@.+type (a :: Rational) + (b :: Rational) =+ Add_ (Normalize a) (Normalize b) :: Rational+type family Add_ (a :: Rational) (r :: Rational) :: Rational where+ Add_ (an % ad) (bn % bd) =+ Normalize ((an I.* P bd I.+ bn I.* P ad) % (ad L.* bd))++-- | @a t'-' b@ subtracts the type-level 'Rational' @b@ from+-- the type-level 'Rational' @a@.+type (a :: Rational) - (b :: Rational) = a + Negate b :: Rational+++--------------------------------------------------------------------------------++-- | Quotient of the 'Div'ision of the 'Num'erator of type-level 'Rational' @a@+-- by its 'Den'ominator, using the specified 'I.Round'ing @r@.+--+-- @+-- forall (r :: 'I.Round') (a :: 'Rational').+-- ('Den' a '/=' 0) =>+-- 'Mod' r a '==' 'Num' a 'I.-' 'P' ('Den' a) 'I.*' 'Div' r a+-- @+type Div (r :: I.Round) (a :: Rational) =+ Div_ r (Normalize a) :: Integer+type Div_ (r :: I.Round) (a :: Rational) =+ I.Div r (Num_ a) (P (Den_ a)) :: Integer++-- | 'Mod'ulus of the division of the 'Num'erator of type-level 'Rational'+-- @a@ by its 'Den'ominator, using the specified 'I.Round'ing @r@.+--+-- @+-- forall (r :: 'I.Round') (a :: 'Rational').+-- ('Den' a '/=' 0) =>+-- 'Mod' r a '==' 'Num' a 'I.-' 'P' ('Den' a) 'I.*' 'Div' r a+-- @+type Mod (r :: I.Round) (a :: Rational) = Snd (DivMod r a) :: Integer++-- | Get both the quotient and the 'Mod'ulus of the 'Div'ision of the+-- 'Num'erator of type-level 'Rational' @a@ by its 'Den'ominator,+-- using the specified 'I.Round'ing @r@.+--+-- @+-- forall (r :: 'I.Round') (a :: 'Rational').+-- ('Den' a '/=' 0) =>+-- 'DivMod' r a '==' '('Div' r a, 'Mod' r a)+-- @+type DivMod (r :: I.Round) (a :: Rational) =+ DivMod_ r (Normalize a) :: (Integer, Integer)+type DivMod_ (r :: I.Round) (a :: Rational) =+ I.DivMod r (Num_ a) (P (Den_ a)) :: (Integer, Integer)++-- | 'Dif'ference of the type-level 'Rational' @a@ and the 'Div'ision of+-- its 'Num'erator by its 'Den'ominator, using the specified 'I.Round'ing @r@.+--+-- @+-- forall (r :: 'I.Round') (a :: 'Rational').+-- ('Den' a '/=' 0) =>+-- 'Dif' r a '==' a '-' 'Div' r a '%' 1+-- @+--+-- Note: We use the word /difference/ because talking about /remainder/ in this+-- context can be confusing, considering "Prelude"'s `rem`ainder function.+-- However, strictly speaking, @`Dif` r a@ is the 'Rational' that /remiains/+-- after performing the 'I.Round'ed 'Div'ision. So, yes, 'Dif' could potentially+-- have been called @Rem@ instead.+type Dif (r :: I.Round) (a :: Rational) = Snd (DivDif r a) :: Rational++-- | Get both the quotient and the 'Dif'ference of the 'Div'ision of the+-- 'Num'erator of type-level 'Rational' @a@ by its 'Den'ominator,+-- using the specified 'I.Round'ing @r@.+--+-- @+-- forall (r :: 'I.Round') (a :: 'Rational').+-- ('Den' a '/=' 0) =>+-- 'DivDif' r a '==' '('Div' r a, 'Dif' r a)+-- @+type DivDif (r :: I.Round) (a :: Rational) =+ DivDif_ r (Normalize a) :: (Integer, Rational)+type DivDif_ (r :: I.Round) (a :: Rational) =+ DivDif__ a (Div_ r a) :: (Integer, Rational)+type DivDif__ (a :: Rational) (q :: Integer) =+ '(q, a - q :% 1) :: (Integer, Rational)++-- | Term-level version of 'Div'.+--+-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Integer'.+div :: I.Round -> P.Rational -> P.Integer+div r = \(n P.:% d) -> f n d+ where f = I.div r++-- | Term-level version of 'Div'.+--+-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Integer'.+mod :: I.Round -> P.Rational -> P.Integer+mod r = \(n P.:% d) -> f n d+ where f = I.mod r++-- | Term-level version of 'DivMod'.+-- Takes a "Prelude" 'P.Rational' as input, returns a pair of "Prelude"+-- 'P.Integer's /(quotient, modulus)/.+--+-- @+-- forall ('r' :: 'I.Round') (a :: 'P.Rational').+-- ('P.denominator' a 'P./=' 0) =>+-- 'divMod' r a 'P.==' ('div' r a, 'mod' r a)+-- @+divMod :: I.Round -> P.Rational -> (P.Integer, P.Integer)+divMod r = \(n P.:% d) -> f n d+ where f = I.divMod r++-- | Term-level version of 'Dif'.+--+-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Rational'.+dif :: I.Round -> P.Rational -> P.Rational+dif r = \a -> a - toRational (f a)+ where f = div r++-- | Term-level version of 'DivDif'.+--+-- Takes a "Prelude" 'P.Rational' as input, returns a pair of "Prelude"+-- 'P.Rational's /(quotient, difference)/.+--+-- @+-- forall ('r' :: 'I.Round') (a :: 'P.Rational').+-- ('P.denominator' a 'P./=' 0) =>+-- 'divDif' r a 'P.==' ('div' r a, 'dif' r a)+-- @+divDif :: I.Round -> P.Rational -> (P.Integer, P.Rational)+divDif r = \a -> let q = f a in (q, a - toRational q)+ where f = div r++--------------------------------------------------------------------------------++-- | 'Constraint' version of @'Terminates' r@. Satisfied by all type-level+-- 'Rational's that can be represented as a finite decimal number.++-- Written as a class rather than as a type-synonym so that downstream doesn't+-- need to use UndecidableSuperClasses.+class (KnownRational r, Terminates r ~ True)+ => Terminating (r :: Rational)++-- Note: Even if @Terminates r ~ 'False@, GHC shows our @TypeError@ first.+instance+ ( KnownRational r+ , Terminates r ~ 'True+ , If (Terminates r)+ (() :: Constraint)+ (L.TypeError ('L.Text "‘" 'L.:<>: 'L.ShowType r 'L.:<>:+ 'L.Text "’ is not a terminating "+ 'L.:<>: 'L.ShowType Rational))+ ) => Terminating r++withTerminating+ :: forall r a+ . KnownRational r+ => (Terminating r => a)+ -> Maybe a+withTerminating g = do+ guard (terminates' (rationalVal' (Proxy @r)))+ case unsafeCoerce (Dict @(Terminating (P 1 % 1))) of+ (Dict :: Dict (Terminating r)) -> pure g++-- | Whether the type-level 'Rational' terminates. That is, whether+-- it can be fully represented as a finite decimal number.+type Terminates (r :: Rational) = Terminates_ (Den r) :: Bool+type family Terminates_ (n :: Natural) :: Bool where+ Terminates_ 5 = 'True+ Terminates_ 2 = 'True+ Terminates_ 1 = 'True+ Terminates_ d = Terminates_5 d (L.Mod d 5)++-- @Terminates_5@ is here to prevent @Terminates_@ from recursing into+-- @Terminates_ (Div d 5)@ if it would diverge.+type family Terminates_5 (d :: Natural) (md5 :: Natural) :: Bool where+ Terminates_5 d 0 = Terminates_ (L.Div d 5)+ Terminates_5 d _ = Terminates_2 d (L.Mod d 2)++-- @Terminates_2@ is here to prevent @Terminates_5@ from recursing into+-- @Terminates_ (Div d 2)@ if it would diverge, and also to prevent calculating+-- @Mod d 2@ unless necessary.+type family Terminates_2 (d :: Natural) (md2 :: Natural) :: Bool where+ Terminates_2 d 0 = Terminates_ (L.Div d 2)+ Terminates_2 _ _ = 'False++-- | Term-level version of the "Terminates" function.+-- Takes a "Prelude" 'P.Rational' as input.+terminates :: P.Rational -> Bool+terminates = terminates' . unsafeFromPrelude++-- | Term-level version of the "Terminates" function.+-- Takes a "KindRational" 'P.Rational' as input.+terminates' :: Rational -> Bool+terminates' = go . den+ where+ go = \case+ 5 -> True+ 2 -> True+ 1 -> True+ n | (q, 0) <- P.divMod n 5 -> go q+ | (q, 0) <- P.divMod n 2 -> go q+ _ -> False++--------------------------------------------------------------------------------++-- | Comparison of type-level 'Rational's, as a function.+type CmpRational (a :: Rational) (b :: Rational) =+ CmpRational_ (Normalize a) (Normalize b) :: Ordering+type family CmpRational_ (a :: Rational) (b :: Rational) :: Ordering where+ CmpRational_ a a = 'EQ+ CmpRational_ (an % ad) (bn % bd) = I.CmpInteger (an I.* P bd) (bn I.* P ad)++-- | "Data.Type.Ord" support for type-level 'Rational's.+type instance Compare (a :: Rational) (b :: Rational) = CmpRational a b++--------------------------------------------------------------------------------++-- | This class gives the rational associated with a type-level rational.+-- There are instances of the class for every rational.+class KnownRational (r :: Rational) where+ rationalSing :: SRational r++instance forall r n d.+ ( Normalize r ~ n % d+ , I.KnownInteger n+ , L.KnownNat d+ ) => KnownRational r where+ rationalSing = UnsafeSRational+ (I.fromPrelude (I.integerVal (Proxy @n)) :% N.natVal (Proxy @d))++-- | Term-level "KindRational" 'Rational' representation of the type-level+-- 'Rational' @r@.+rationalVal' :: forall r proxy. KnownRational r => proxy r -> Rational+rationalVal' _ = case rationalSing :: SRational r of+ UnsafeSRational x -> x++-- | Term-level "Prelude" 'P.Rational' representation of the type-level+-- 'Rational' @r@.+rationalVal :: forall r proxy. KnownRational r => proxy r -> P.Rational+rationalVal = toPrelude . rationalVal'++-- | This type represents unknown type-level 'Rational'.+data SomeRational = forall n. KnownRational n => SomeRational (Proxy n)++-- | Convert a term-level "Prelude" 'Rational' into an unknown+-- type-level 'Rational'.+someRationalVal :: P.Rational -> SomeRational+someRationalVal r =+ withSomeSRational (unsafeFromPrelude r) $ \(sr :: SRational r) ->+ withKnownRational sr (SomeRational @r Proxy)++instance Eq SomeRational where+ SomeRational x == SomeRational y = rationalVal x P.== rationalVal y++instance Ord SomeRational where+ SomeRational x <= SomeRational y =+ rationalVal x <= rationalVal y+ compare (SomeRational x) (SomeRational y) =+ compare (rationalVal x) (rationalVal y)++instance Show SomeRational where+ showsPrec p (SomeRational x) = showsPrec p (rationalVal x)++instance Read SomeRational where+ readsPrec p xs = do (a, ys) <- readsPrec p xs+ [(someRationalVal a, ys)]+++-- | We either get evidence that this function was instantiated with the+-- same type-level 'Rational's, or 'Nothing'.+sameRational+ :: forall a b proxy1 proxy2+ . (KnownRational a, KnownRational b)+ => proxy1 a+ -> proxy2 b+ -> Maybe (a :~: b)+sameRational _ _ = testEquality (rationalSing @a) (rationalSing @b)++-- | Like 'sameRational', but if the type-level 'Rational's aren't equal, this+-- additionally provides proof of 'LT' or 'GT'.+cmpRational+ :: forall a b proxy1 proxy2+ . (KnownRational a, KnownRational b)+ => proxy1 a+ -> proxy2 b+ -> OrderingI a b+cmpRational x y = case compare (rationalVal x) (rationalVal y) of+ EQ -> case unsafeCoerce Refl :: CmpRational a b :~: 'EQ of+ Refl -> case unsafeCoerce Refl :: a :~: b of+ Refl -> EQI+ LT -> case unsafeCoerce Refl :: (CmpRational a b :~: 'LT) of+ Refl -> LTI+ GT -> case unsafeCoerce Refl :: (CmpRational a b :~: 'GT) of+ Refl -> GTI++--------------------------------------------------------------------------------++-- | Singleton type for a type-level 'Rational' @r@.+newtype SRational (r :: Rational) = UnsafeSRational Rational++-- | A explicitly bidirectional pattern synonym relating an 'SRational' to a+-- 'KnownRational' constraint.+--+-- As an __expression__: Constructs an explicit @'SRational' r@ value from an+-- implicit @'KnownRational' r@ constraint:+--+-- @+-- 'SRational' @r :: 'KnownRational' r => 'SRational' r+-- @+--+-- As a __pattern__: Matches on an explicit @'SRational' r@ value bringing+-- an implicit @'KnownRational' r@ constraint into scope:+--+-- @+-- f :: 'SRational' r -> ..+-- f SRational = {- SRational r in scope -}+-- @+pattern SRational :: forall r. () => KnownRational r => SRational r+pattern SRational <- (knownRationalInstance -> KnownRationalegerInstance)+ where SRational = rationalSing++-- | An internal data type that is only used for defining the 'SRational' pattern+-- synonym.+data KnownRationalegerInstance (r :: Rational) where+ KnownRationalegerInstance :: KnownRational r => KnownRationalegerInstance r++-- | An internal function that is only used for defining the 'SRational' pattern+-- synonym.+knownRationalInstance :: SRational r -> KnownRationalegerInstance r+knownRationalInstance si = withKnownRational si KnownRationalegerInstance++instance Show (SRational r) where+ showsPrec p (UnsafeSRational r) = showParen (p > appPrec) $+ showString "SRational @" . showsPrecTypeLit appPrec1 r++instance TestEquality SRational where+ testEquality (UnsafeSRational x) (UnsafeSRational y) = do+ guard (toPrelude x P.== toPrelude y)+ pure (unsafeCoerce Refl)++instance TestCoercion SRational where+ testCoercion x y = fmap (\Refl -> Coercion) (testEquality x y)++-- | Return the term-level "Prelude" 'P.Rational' number corresponding+-- to @r@ in a @'SRational' r@ value.+fromSRational :: SRational r -> P.Rational+fromSRational (UnsafeSRational r) = toPrelude r++-- | Convert an explicit @'SRational' r@ value into an implicit+-- @'KnownRational' r@ constraint.+withKnownRational+ :: forall r rep (a :: TYPE rep). SRational r -> (KnownRational r => a) -> a+withKnownRational = withDict @(KnownRational r)++-- | Convert a "Prelude" 'P.Rational' number into an @'SRational' n@ value,+-- where @n@ is a fresh type-level 'Rational'.+withSomeSRational+ :: forall rep (a :: TYPE rep). Rational -> (forall r. SRational r -> a) -> a+withSomeSRational r k = k (UnsafeSRational r)+-- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats"+{-# NOINLINE withSomeSRational #-}++--------------------------------------------------------------------------------+-- Extra stuff that doesn't belong here.++-- | /Greatest Common Divisor/ of 'Natural' numbers @a@ and @b@.+type GCD (a :: Natural) (b :: Natural) = I.GCD (P a) (P b) :: Natural++data Dict c where Dict :: c => Dict c++type family Snd (ab :: (a, b)) :: b where Snd '(a, b) = b+
+ test/Main.hs view
@@ -0,0 +1,1861 @@+{-# OPTIONS_GHC -Wno-missing-signatures #-}+module Main {--}+ ( main+ ) --}+ where++import Control.Applicative+import Control.Monad+import Data.List qualified as List+import Data.Maybe+import Data.Proxy+import Data.Type.Ord (type (<=), type (<))+import GHC.Exts (Constraint)+import System.Exit+import Text.Read+import GHC.Real qualified as P+import Prelude hiding (Rational, Integer)+import Prelude qualified as P++import KindInteger (P, N)+import KindRational (type (%), type (/))+import KindRational qualified as K++--------------------------------------------------------------------------------++data Dict (c :: Constraint) where+ Dict :: c => Dict c++--------------------------------------------------------------------------------++_testNormalize = Dict+_testNormalize :: Dict+ ( P 0 % 1 ~ K.Normalize (P 0 % 1)+ , P 1 % 1 ~ K.Normalize (P 1 % 1)+ , P 2 % 1 ~ K.Normalize (P 2 % 1)+ , P 3 % 1 ~ K.Normalize (P 3 % 1)+ , P 4 % 1 ~ K.Normalize (P 4 % 1)+ , P 0 % 1 ~ K.Normalize (P 0 % 2)+ , P 1 % 1 ~ K.Normalize (P 2 % 2)+ , P 3 % 2 ~ K.Normalize (P 3 % 2)+ , P 2 % 1 ~ K.Normalize (P 4 % 2)+ , P 0 % 1 ~ K.Normalize (P 0 % 3)+ , P 1 % 3 ~ K.Normalize (P 1 % 3)+ , P 2 % 3 ~ K.Normalize (P 2 % 3)+ , P 1 % 1 ~ K.Normalize (P 3 % 3)+ , P 4 % 3 ~ K.Normalize (P 4 % 3)+ , P 0 % 1 ~ K.Normalize (P 0 % 4)+ , P 1 % 4 ~ K.Normalize (P 1 % 4)+ , P 1 % 2 ~ K.Normalize (P 2 % 4)+ , P 3 % 4 ~ K.Normalize (P 3 % 4)+ , P 1 % 1 ~ K.Normalize (P 4 % 4)+ , P 0 % 1 ~ K.Normalize (N 0 % 1)+ , N 1 % 1 ~ K.Normalize (N 1 % 1)+ , N 2 % 1 ~ K.Normalize (N 2 % 1)+ , N 3 % 1 ~ K.Normalize (N 3 % 1)+ , N 4 % 1 ~ K.Normalize (N 4 % 1)+ , P 0 % 1 ~ K.Normalize (N 0 % 2)+ , N 1 % 2 ~ K.Normalize (N 1 % 2)+ , N 1 % 1 ~ K.Normalize (N 2 % 2)+ , N 3 % 2 ~ K.Normalize (N 3 % 2)+ , N 2 % 1 ~ K.Normalize (N 4 % 2)+ , P 0 % 1 ~ K.Normalize (N 0 % 3)+ , N 1 % 3 ~ K.Normalize (N 1 % 3)+ , N 2 % 3 ~ K.Normalize (N 2 % 3)+ , N 1 % 1 ~ K.Normalize (N 3 % 3)+ , N 4 % 3 ~ K.Normalize (N 4 % 3)+ , P 0 % 1 ~ K.Normalize (N 0 % 4)+ , N 1 % 4 ~ K.Normalize (N 1 % 4)+ , N 1 % 2 ~ K.Normalize (N 2 % 4)+ , N 3 % 4 ~ K.Normalize (N 3 % 4)+ , N 1 % 1 ~ K.Normalize (N 4 % 4)+ )++_testNegate = Dict+_testNegate :: Dict+ ( P 0 % 1 ~ K.Negate (P 0 % 1)+ , P 0 % 1 ~ K.Negate (P 0 % 2)+ , P 0 % 1 ~ K.Negate (N 0 % 1)+ , P 0 % 1 ~ K.Negate (N 0 % 2)++ , P 1 % 1 ~ K.Negate (N 1 % 1)+ , P 1 % 2 ~ K.Negate (N 1 % 2)+ , P 1 % 1 ~ K.Negate (N 1 % 1)+ , P 1 % 2 ~ K.Negate (N 1 % 2)++ , N 1 % 1 ~ K.Negate (P 1 % 1)+ , N 1 % 2 ~ K.Negate (P 1 % 2)+ , N 1 % 1 ~ K.Negate (P 1 % 1)+ , N 1 % 2 ~ K.Negate (P 1 % 2)++ , P 1 % 1 ~ K.Negate (N 1 % 1)+ , P 2 % 1 ~ K.Negate (N 2 % 1)+ , P 1 % 1 ~ K.Negate (N 1 % 1)+ , P 2 % 1 ~ K.Negate (N 2 % 1)++ , N 1 % 1 ~ K.Negate (P 1 % 1)+ , N 2 % 1 ~ K.Negate (P 2 % 1)+ , N 1 % 1 ~ K.Negate (P 1 % 1)+ , N 2 % 1 ~ K.Negate (P 2 % 1)+ )++_testSign = Dict+_testSign :: Dict+ ( P 0 ~ K.Sign (P 0 % 1)+ , P 0 ~ K.Sign (P 0 % 2)+ , P 0 ~ K.Sign (N 0 % 1)+ , P 0 ~ K.Sign (N 0 % 2)++ , N 1 ~ K.Sign (N 1 % 1)+ , N 1 ~ K.Sign (N 1 % 2)+ , N 1 ~ K.Sign (N 1 % 1)+ , N 1 ~ K.Sign (N 1 % 2)++ , P 1 ~ K.Sign (P 1 % 1)+ , P 1 ~ K.Sign (P 1 % 2)+ , P 1 ~ K.Sign (P 1 % 1)+ , P 1 ~ K.Sign (P 1 % 2)++ , N 1 ~ K.Sign (N 1 % 1)+ , N 1 ~ K.Sign (N 2 % 1)+ , N 1 ~ K.Sign (N 1 % 1)+ , N 1 ~ K.Sign (N 2 % 1)++ , P 1 ~ K.Sign (P 1 % 1)+ , P 1 ~ K.Sign (P 2 % 1)+ , P 1 ~ K.Sign (P 1 % 1)+ , P 1 ~ K.Sign (P 2 % 1)+ )++_testAbs = Dict+_testAbs :: Dict+ ( P 0 % 1 ~ K.Abs (P 0 % 1)+ , P 0 % 1 ~ K.Abs (P 0 % 2)+ , P 0 % 1 ~ K.Abs (N 0 % 1)+ , P 0 % 1 ~ K.Abs (N 0 % 2)++ , P 1 % 1 ~ K.Abs (N 1 % 1)+ , P 1 % 2 ~ K.Abs (N 1 % 2)+ , P 1 % 1 ~ K.Abs (N 1 % 1)+ , P 1 % 2 ~ K.Abs (N 1 % 2)++ , P 1 % 1 ~ K.Abs (P 1 % 1)+ , P 1 % 2 ~ K.Abs (P 1 % 2)+ , P 1 % 1 ~ K.Abs (P 1 % 1)+ , P 1 % 2 ~ K.Abs (P 1 % 2)++ , P 1 % 1 ~ K.Abs (N 1 % 1)+ , P 2 % 1 ~ K.Abs (N 2 % 1)+ , P 1 % 1 ~ K.Abs (N 1 % 1)+ , P 2 % 1 ~ K.Abs (N 2 % 1)++ , P 1 % 1 ~ K.Abs (P 1 % 1)+ , P 2 % 1 ~ K.Abs (P 2 % 1)+ , P 1 % 1 ~ K.Abs (P 1 % 1)+ , P 2 % 1 ~ K.Abs (P 2 % 1)+ )+++_testEq = Dict+_testEq :: Dict+ ( 1/2 K.== 1/2+ , (1/2 K.==? 1/2) ~ 'True++ , 1/2 K.== 2/4+ , (1/2 K.==? 2/4) ~ 'True++ , 1/2 K./= 3/4+ , (1/2 K.==? 3/4) ~ 'False+ , (1/2 K./=? 3/4) ~ 'True+ )++_testCmp = Dict+_testCmp :: Dict+ ( 1/4 <= 1/4+ , 2/8 <= 1/4+ , 1/4 <= 1/2+ , 1/4 <= 2/4+ , 2/8 <= 1/2+ , 1/4 < 1/2+ , 1/4 < 2/4+ , 2/8 < 1/2+ , 2/8 < 2/4+ )++_testAdd = Dict+_testAdd :: Dict+ ( (P 0 / 1) ~ (N 0 / 1) K.+ (N 0 / 1)+ , (N 0 / 1) ~ (N 5 / 1) K.+ (P 5 / 1)+ , (N 5 / 9) ~ (N 0 / 1) K.+ (N 5 / 9)+ , (N 9 / 2) ~ (N 3 / 2) K.+ (N 3 / 1)+ , (9 / 2) ~ (3 / 2) K.+ (3 / 1)+ , (N 11 / 3)~ (N 3 / 1) K.+ (N 2 / 3)+ )++_testMul = Dict+_testMul :: Dict+ ( (0 / 1) ~ (N 0 / 1) K.* (N 0 / 1)+ , (N 25 / 1) ~ (N 5 / 1) K.* (5 / 1)+ , (N 1 / 1) ~ (N 5 / 1) K.* (1 / 5)+ , (5 / 9) ~ (N 1 / 1) K.* (N 5 / 9)+ , (9 / 1) ~ (N 3 / 1) K.* (N 3 / 1)+ , (2 / 1) ~ (N 3 / 1) K.* (N 2 / 3)+ , (1 / 1) ~ (P 3 / 2) K.* (P 2 / 3)+ )++_testRecip = Dict+_testRecip :: Dict+ ( (1 / 1) ~ K.Recip (1 / 1)+ , (1 / 2) ~ K.Recip (2 / 1)+ , (4 / 3) ~ K.Recip (3 / 4)+ , (N 1 / 1) ~ K.Recip (N 1 / 1)+ , (N 1 / 2) ~ K.Recip (N 2 / 1)+ , (N 4 / 3) ~ K.Recip (N 3 / 4)+ )++-- Most tests for these are in kind-integer.+_testDivMod = Dict+_testDivMod :: Dict+ ( '(P 1, P 1) ~ K.DivMod 'K.RoundDown (3 / 2)+ , '(P 2, N 1) ~ K.DivMod 'K.RoundUp (3 / 2)+ , '(P 1, P 1) ~ K.DivMod 'K.RoundZero (3 / 2)+ , '(P 2, N 1) ~ K.DivMod 'K.RoundAway (3 / 2)+ , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfDown (3 / 2)+ , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfUp (3 / 2)+ , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfZero (3 / 2)+ , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfAway (3 / 2)+ , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfEven (3 / 2)+ , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfOdd (3 / 2)++ , '(N 2, P 1) ~ K.DivMod 'K.RoundDown (N 3 / 2)+ , '(N 1, N 1) ~ K.DivMod 'K.RoundUp (N 3 / 2)+ , '(N 1, N 1) ~ K.DivMod 'K.RoundZero (N 3 / 2)+ , '(N 2, P 1) ~ K.DivMod 'K.RoundAway (N 3 / 2)+ , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfDown (N 3 / 2)+ , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfUp (N 3 / 2)+ , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfZero (N 3 / 2)+ , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfAway (N 3 / 2)+ , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfEven (N 3 / 2)+ , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfOdd (N 3 / 2)+ )++_testDiv = Dict+_testDiv :: Dict+ ( P 1 ~ K.Div 'K.RoundDown (3 / 2)+ , P 2 ~ K.Div 'K.RoundUp (3 / 2)+ , P 1 ~ K.Div 'K.RoundZero (3 / 2)+ , P 2 ~ K.Div 'K.RoundAway (3 / 2)+ , P 1 ~ K.Div 'K.RoundHalfDown (3 / 2)+ , P 2 ~ K.Div 'K.RoundHalfUp (3 / 2)+ , P 1 ~ K.Div 'K.RoundHalfZero (3 / 2)+ , P 2 ~ K.Div 'K.RoundHalfAway (3 / 2)+ , P 2 ~ K.Div 'K.RoundHalfEven (3 / 2)+ , P 1 ~ K.Div 'K.RoundHalfOdd (3 / 2)++ , N 2 ~ K.Div 'K.RoundDown (N 3 / 2)+ , N 1 ~ K.Div 'K.RoundUp (N 3 / 2)+ , N 1 ~ K.Div 'K.RoundZero (N 3 / 2)+ , N 2 ~ K.Div 'K.RoundAway (N 3 / 2)+ , N 2 ~ K.Div 'K.RoundHalfDown (N 3 / 2)+ , N 1 ~ K.Div 'K.RoundHalfUp (N 3 / 2)+ , N 1 ~ K.Div 'K.RoundHalfZero (N 3 / 2)+ , N 2 ~ K.Div 'K.RoundHalfAway (N 3 / 2)+ , N 2 ~ K.Div 'K.RoundHalfEven (N 3 / 2)+ , N 1 ~ K.Div 'K.RoundHalfOdd (N 3 / 2)++ , P 0 ~ K.Div 'K.RoundDown (3 / 4)+ , P 1 ~ K.Div 'K.RoundUp (3 / 4)+ , P 0 ~ K.Div 'K.RoundZero (3 / 4)+ , P 1 ~ K.Div 'K.RoundAway (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfDown (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfUp (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfZero (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfAway (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfEven (3 / 4)+ , P 1 ~ K.Div 'K.RoundHalfOdd (3 / 4)++ , N 1 ~ K.Div 'K.RoundDown (N 3 / 4)+ , P 0 ~ K.Div 'K.RoundUp (N 3 / 4)+ , P 0 ~ K.Div 'K.RoundZero (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundAway (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfDown (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfUp (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfZero (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfAway (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfEven (N 3 / 4)+ , N 1 ~ K.Div 'K.RoundHalfOdd (N 3 / 4)+ )++_testMod = Dict+_testMod :: Dict+ ( P 1 ~ K.Mod 'K.RoundDown (3 / 2)+ , N 1 ~ K.Mod 'K.RoundUp (3 / 2)+ , P 1 ~ K.Mod 'K.RoundZero (3 / 2)+ , N 1 ~ K.Mod 'K.RoundAway (3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfDown (3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfUp (3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfZero (3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfAway (3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfEven (3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfOdd (3 / 2)++ , P 1 ~ K.Mod 'K.RoundDown (N 3 / 2)+ , N 1 ~ K.Mod 'K.RoundUp (N 3 / 2)+ , N 1 ~ K.Mod 'K.RoundZero (N 3 / 2)+ , P 1 ~ K.Mod 'K.RoundAway (N 3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfDown (N 3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfUp (N 3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfZero (N 3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfAway (N 3 / 2)+ , P 1 ~ K.Mod 'K.RoundHalfEven (N 3 / 2)+ , N 1 ~ K.Mod 'K.RoundHalfOdd (N 3 / 2)+ )++_testDif = Dict+_testDif :: Dict+ ( P 1 / 2 ~ K.Dif 'K.RoundDown (3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundUp (3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundZero (3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundAway (3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfDown (3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfUp (3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfZero (3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfAway (3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfEven (3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfOdd (3 / 2)++ , P 1 / 2 ~ K.Dif 'K.RoundDown (N 3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundUp (N 3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundZero (N 3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundAway (N 3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfDown (N 3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfUp (N 3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfZero (N 3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfAway (N 3 / 2)+ , P 1 / 2 ~ K.Dif 'K.RoundHalfEven (N 3 / 2)+ , N 1 / 2 ~ K.Dif 'K.RoundHalfOdd (N 3 / 2)++ , P 3 / 4 ~ K.Dif 'K.RoundDown (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundUp (3 / 4)+ , P 3 / 4 ~ K.Dif 'K.RoundZero (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundAway (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfDown (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfUp (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfZero (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfAway (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfEven (3 / 4)+ , N 1 / 4 ~ K.Dif 'K.RoundHalfOdd (3 / 4)++ , P 1 / 4 ~ K.Dif 'K.RoundDown (N 3 / 4)+ , N 3 / 4 ~ K.Dif 'K.RoundUp (N 3 / 4)+ , N 3 / 4 ~ K.Dif 'K.RoundZero (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundAway (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfDown (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfUp (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfZero (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfAway (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfEven (N 3 / 4)+ , P 1 / 4 ~ K.Dif 'K.RoundHalfOdd (N 3 / 4)+ )++_testDivDif = Dict+_testDivDif :: Dict+ ( '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundDown (3 / 2)+ , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundUp (3 / 2)+ , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundZero (3 / 2)+ , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundAway (3 / 2)+ , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfDown (3 / 2)+ , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfUp (3 / 2)+ , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfZero (3 / 2)+ , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfAway (3 / 2)+ , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfEven (3 / 2)+ , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfOdd (3 / 2)++ , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundDown (N 3 / 2)+ , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundUp (N 3 / 2)+ , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundZero (N 3 / 2)+ , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundAway (N 3 / 2)+ , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfDown (N 3 / 2)+ , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfUp (N 3 / 2)+ , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfZero (N 3 / 2)+ , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfAway (N 3 / 2)+ , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfEven (N 3 / 2)+ , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfOdd (N 3 / 2)++ , '(P 0, P 3 / 4) ~ K.DivDif 'K.RoundDown (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundUp (3 / 4)+ , '(P 0, P 3 / 4) ~ K.DivDif 'K.RoundZero (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundAway (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfDown (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfUp (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfZero (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfAway (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfEven (3 / 4)+ , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfOdd (3 / 4)++ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundDown (N 3 / 4)+ , '(P 0, N 3 / 4) ~ K.DivDif 'K.RoundUp (N 3 / 4)+ , '(P 0, N 3 / 4) ~ K.DivDif 'K.RoundZero (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundAway (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfDown (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfUp (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfZero (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfAway (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfEven (N 3 / 4)+ , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfOdd (N 3 / 4)+ )++_testTerminates = Dict+_testTerminates :: Dict+ ( K.Terminating (0/1)+ , K.Terminating (N 1/1)+ , K.Terminating (2/1)+ , K.Terminating (N 1/2)+ , K.Terminating (1/4)+ , K.Terminating (N 1/5)+ , K.Terminating (1/10)+ , K.Terminating (N 1/20)+ , K.Terminating (1/50)+ , K.Terminating (N 1/10000000)++ , K.Terminating (3/1)+ , K.Terminating (N 3/1)+ , K.Terminating (3/2)+ , K.Terminating (N 3/3)+ , K.Terminating (3/4)+ , K.Terminating (N 3/5)+ , K.Terminating (3/6)+ , K.Terminating (N 3/10)+ , K.Terminating (3/20)+ , K.Terminating (N 3/50)+ , K.Terminating (3/10000000)++ , 'True ~ K.Terminates (N 0/1)+ , 'True ~ K.Terminates (1/1)+ , 'True ~ K.Terminates (N 2/1)+ , 'True ~ K.Terminates (1/2)+ , 'True ~ K.Terminates (N 1/4)+ , 'True ~ K.Terminates (1/5)+ , 'True ~ K.Terminates (N 1/10)+ , 'True ~ K.Terminates (1/20)+ , 'True ~ K.Terminates (N 1/50)+ , 'True ~ K.Terminates (1/10000000)++ , 'True ~ K.Terminates (N 3/1)+ , 'True ~ K.Terminates (3/1)+ , 'True ~ K.Terminates (N 3/2)+ , 'True ~ K.Terminates (3/3)+ , 'True ~ K.Terminates (N 3/4)+ , 'True ~ K.Terminates (3/5)+ , 'True ~ K.Terminates (N 3/6)+ , 'True ~ K.Terminates (3/10)+ , 'True ~ K.Terminates (N 3/20)+ , 'True ~ K.Terminates (3/50)+ , 'True ~ K.Terminates (N 3/10000000)++ , 'False ~ K.Terminates (1/3)+ , 'False ~ K.Terminates (N 1/12)+ , 'False ~ K.Terminates (1/15)+ , 'False ~ K.Terminates (N 2/3)+ , 'False ~ K.Terminates (75/7)+ , 'False ~ K.Terminates (N 8/3)+ )++--------------------------------------------------------------------------------++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++rats :: P.Integer -> [P.Rational]+rats i = do n <- [negate i .. i]+ d <- [negate i .. i]+ guard (d /= 0)+ pure (n P.% d)++main :: IO ()+main = testsMain $+ [ assert "rationalVal . someRationalVal == id" $+ flip all (rats 4) $ \r ->+ case K.someRationalVal r of+ K.SomeRational pa ->+ r == K.rationalVal pa++ , assert "sameRationalVal a a" $+ flip all (rats 4) $ \r ->+ case K.someRationalVal r of+ K.SomeRational pa ->+ isJust (K.sameRational pa pa)++ , assert "sameRationalVal a a'" $+ flip all (rats 4) $ \a ->+ case (K.someRationalVal a, K.someRationalVal a) of+ (K.SomeRational pa1, K.SomeRational pa2) ->+ isJust (K.sameRational pa1 pa2)++ , assert "sameRationalVal a b" $+ flip all (liftA2 (,) (rats 4) (rats 4)) $ \(a, b) ->+ case (K.someRationalVal a, K.someRationalVal b) of+ (K.SomeRational pa, K.SomeRational pb)+ | a == b -> isJust (K.sameRational pa pb)+ | otherwise -> isNothing (K.sameRational pa pb)++ , assert "Eq SomeRational" $+ flip all (liftA2 (,) (rats 4) (rats 4))$ \(a, b) ->+ (a == b) == (K.someRationalVal a == K.someRationalVal b)++ , assert "Ord SomeRational" $+ flip all (liftA2 (,) (rats 4) (rats 4))$ \(a, b) ->+ (a `compare` b) == (K.someRationalVal a `compare` K.someRationalVal b)++ , assert "Show SomeRational" $+ flip all (rats 4) $ \a ->+ show a == show (K.someRationalVal a)++ , assert "Read SomeRational" $+ flip all (rats 4) $ \r ->+ let str = show r+ in readMaybe @P.Rational str+ == fmap (\(K.SomeRational p) -> K.rationalVal p)+ (readMaybe @K.SomeRational str)++ ] <> testsDivModDif <> testsTerminating++testsDivModDif :: [IO Bool]+testsDivModDif = do+ a@(n P.:% d) <- rats 4+ r :: K.Round <- [minBound .. maxBound]+ let tname :: String -> ShowS+ tname t = showString t . showChar ' ' . shows r . showChar ' '+ . shows n . showChar ' ' . shows d+ [ assert (tname "divMod" "") $ case K.divMod r a of+ (q, m) -> m == n - d * q+ , assert (tname "divMod/div" "") $ fst (K.divMod r a) == K.div r a+ , assert (tname "divMod/mod" "") $ snd (K.divMod r a) == K.mod r a++ , assert (tname "divDif" "") $ case K.divDif r a of+ (q, x) -> a == toRational q + x+ , assert (tname "divDif/div" "") $ fst (K.divDif r a) == K.div r a+ , assert (tname "divDif/dif" "") $ snd (K.divDif r a) == K.dif r a+ ]++testsTerminating :: [IO Bool]+testsTerminating = concat+ [ do a <- ok+ pure $ assert ("withTerminating(ok) (" <> show a <> ")") $+ case K.someRationalVal a of+ K.SomeRational (_ :: Proxy a) ->+ isJust (K.withTerminating @a () :: Maybe ())++ , do a <- no+ pure $ assert ("withTerminating(no) (" <> show a <> ")") $+ case K.someRationalVal a of+ K.SomeRational (_ :: Proxy a) ->+ isNothing (K.withTerminating @a () :: Maybe ())+ ]+ where+ ok :: [P.Rational]+ ok = [ 0 P.% 1+ , -1 P.% 1+ , 2 P.% 1+ , -1 P.% 2+ , 1 P.% 4+ , -1 P.% 5+ , 1 P.% 10+ , -1 P.% 20+ , 1 P.% 50+ , -1 P.% 10000000+ , 3 P.% 1+ , -3 P.% 1+ , 3 P.% 2+ , -3 P.% 3+ , 3 P.% 4+ , -3 P.% 5+ , 3 P.% 6+ , -3 P.% 10+ , 3 P.% 20+ , -3 P.% 50+ , 3 P.% 10000000+ ]+ no :: [P.Rational]+ no = [ 1 P.% 3+ , -1 P.% 12+ , 1 P.% 15+ , -2 P.% 3+ , 75 P.% 7+ , -8 P.% 3+ ]+++_testSlash_Nat0_Nat1 = Dict @((P 0 % 1) ~ (0 / 1))+_testSlash_Nat0_Nat2 = Dict @((P 0 % 1) ~ (0 / 2))+_testSlash_Nat0_Nat3 = Dict @((P 0 % 1) ~ (0 / 3))+_testSlash_Nat0_Nat4 = Dict @((P 0 % 1) ~ (0 / 4))+_testSlash_Nat0_IntN4 = Dict @((P 0 % 1) ~ (0 / (N 4)))+_testSlash_Nat0_IntN3 = Dict @((P 0 % 1) ~ (0 / (N 3)))+_testSlash_Nat0_IntN2 = Dict @((P 0 % 1) ~ (0 / (N 2)))+_testSlash_Nat0_IntN1 = Dict @((P 0 % 1) ~ (0 / (N 1)))+_testSlash_Nat0_IntP1 = Dict @((P 0 % 1) ~ (0 / (P 1)))+_testSlash_Nat0_IntP2 = Dict @((P 0 % 1) ~ (0 / (P 2)))+_testSlash_Nat0_IntP3 = Dict @((P 0 % 1) ~ (0 / (P 3)))+_testSlash_Nat0_IntP4 = Dict @((P 0 % 1) ~ (0 / (P 4)))+_testSlash_Nat0_Rat4N1 = Dict @((P 0 % 1) ~ (0 / (N 4 % 1)))+_testSlash_Nat0_Rat3N1 = Dict @((P 0 % 1) ~ (0 / (N 3 % 1)))+_testSlash_Nat0_Rat2N1 = Dict @((P 0 % 1) ~ (0 / (N 2 % 1)))+_testSlash_Nat0_Rat3N2 = Dict @((P 0 % 1) ~ (0 / (N 3 % 2)))+_testSlash_Nat0_Rat4N3 = Dict @((P 0 % 1) ~ (0 / (N 4 % 3)))+_testSlash_Nat0_Rat1N1 = Dict @((P 0 % 1) ~ (0 / (N 1 % 1)))+_testSlash_Nat0_Rat3N4 = Dict @((P 0 % 1) ~ (0 / (N 3 % 4)))+_testSlash_Nat0_Rat2N3 = Dict @((P 0 % 1) ~ (0 / (N 2 % 3)))+_testSlash_Nat0_Rat1N2 = Dict @((P 0 % 1) ~ (0 / (N 1 % 2)))+_testSlash_Nat0_Rat1N3 = Dict @((P 0 % 1) ~ (0 / (N 1 % 3)))+_testSlash_Nat0_Rat1N4 = Dict @((P 0 % 1) ~ (0 / (N 1 % 4)))+_testSlash_Nat0_Rat1P4 = Dict @((P 0 % 1) ~ (0 / (P 1 % 4)))+_testSlash_Nat0_Rat1P3 = Dict @((P 0 % 1) ~ (0 / (P 1 % 3)))+_testSlash_Nat0_Rat1P2 = Dict @((P 0 % 1) ~ (0 / (P 1 % 2)))+_testSlash_Nat0_Rat2P3 = Dict @((P 0 % 1) ~ (0 / (P 2 % 3)))+_testSlash_Nat0_Rat3P4 = Dict @((P 0 % 1) ~ (0 / (P 3 % 4)))+_testSlash_Nat0_Rat1P1 = Dict @((P 0 % 1) ~ (0 / (P 1 % 1)))+_testSlash_Nat0_Rat4P3 = Dict @((P 0 % 1) ~ (0 / (P 4 % 3)))+_testSlash_Nat0_Rat3P2 = Dict @((P 0 % 1) ~ (0 / (P 3 % 2)))+_testSlash_Nat0_Rat2P1 = Dict @((P 0 % 1) ~ (0 / (P 2 % 1)))+_testSlash_Nat0_Rat3P1 = Dict @((P 0 % 1) ~ (0 / (P 3 % 1)))+_testSlash_Nat0_Rat4P1 = Dict @((P 0 % 1) ~ (0 / (P 4 % 1)))+_testSlash_Nat1_Nat1 = Dict @((P 1 % 1) ~ (1 / 1))+_testSlash_Nat1_Nat2 = Dict @((P 1 % 2) ~ (1 / 2))+_testSlash_Nat1_Nat3 = Dict @((P 1 % 3) ~ (1 / 3))+_testSlash_Nat1_Nat4 = Dict @((P 1 % 4) ~ (1 / 4))+_testSlash_Nat1_IntN4 = Dict @((N 1 % 4) ~ (1 / (N 4)))+_testSlash_Nat1_IntN3 = Dict @((N 1 % 3) ~ (1 / (N 3)))+_testSlash_Nat1_IntN2 = Dict @((N 1 % 2) ~ (1 / (N 2)))+_testSlash_Nat1_IntN1 = Dict @((N 1 % 1) ~ (1 / (N 1)))+_testSlash_Nat1_IntP1 = Dict @((P 1 % 1) ~ (1 / (P 1)))+_testSlash_Nat1_IntP2 = Dict @((P 1 % 2) ~ (1 / (P 2)))+_testSlash_Nat1_IntP3 = Dict @((P 1 % 3) ~ (1 / (P 3)))+_testSlash_Nat1_IntP4 = Dict @((P 1 % 4) ~ (1 / (P 4)))+_testSlash_Nat1_Rat4N1 = Dict @((N 1 % 4) ~ (1 / (N 4 % 1)))+_testSlash_Nat1_Rat3N1 = Dict @((N 1 % 3) ~ (1 / (N 3 % 1)))+_testSlash_Nat1_Rat2N1 = Dict @((N 1 % 2) ~ (1 / (N 2 % 1)))+_testSlash_Nat1_Rat3N2 = Dict @((N 2 % 3) ~ (1 / (N 3 % 2)))+_testSlash_Nat1_Rat4N3 = Dict @((N 3 % 4) ~ (1 / (N 4 % 3)))+_testSlash_Nat1_Rat1N1 = Dict @((N 1 % 1) ~ (1 / (N 1 % 1)))+_testSlash_Nat1_Rat3N4 = Dict @((N 4 % 3) ~ (1 / (N 3 % 4)))+_testSlash_Nat1_Rat2N3 = Dict @((N 3 % 2) ~ (1 / (N 2 % 3)))+_testSlash_Nat1_Rat1N2 = Dict @((N 2 % 1) ~ (1 / (N 1 % 2)))+_testSlash_Nat1_Rat1N3 = Dict @((N 3 % 1) ~ (1 / (N 1 % 3)))+_testSlash_Nat1_Rat1N4 = Dict @((N 4 % 1) ~ (1 / (N 1 % 4)))+_testSlash_Nat1_Rat1P4 = Dict @((P 4 % 1) ~ (1 / (P 1 % 4)))+_testSlash_Nat1_Rat1P3 = Dict @((P 3 % 1) ~ (1 / (P 1 % 3)))+_testSlash_Nat1_Rat1P2 = Dict @((P 2 % 1) ~ (1 / (P 1 % 2)))+_testSlash_Nat1_Rat2P3 = Dict @((P 3 % 2) ~ (1 / (P 2 % 3)))+_testSlash_Nat1_Rat3P4 = Dict @((P 4 % 3) ~ (1 / (P 3 % 4)))+_testSlash_Nat1_Rat1P1 = Dict @((P 1 % 1) ~ (1 / (P 1 % 1)))+_testSlash_Nat1_Rat4P3 = Dict @((P 3 % 4) ~ (1 / (P 4 % 3)))+_testSlash_Nat1_Rat3P2 = Dict @((P 2 % 3) ~ (1 / (P 3 % 2)))+_testSlash_Nat1_Rat2P1 = Dict @((P 1 % 2) ~ (1 / (P 2 % 1)))+_testSlash_Nat1_Rat3P1 = Dict @((P 1 % 3) ~ (1 / (P 3 % 1)))+_testSlash_Nat1_Rat4P1 = Dict @((P 1 % 4) ~ (1 / (P 4 % 1)))+_testSlash_Nat2_Nat1 = Dict @((P 2 % 1) ~ (2 / 1))+_testSlash_Nat2_Nat2 = Dict @((P 1 % 1) ~ (2 / 2))+_testSlash_Nat2_Nat3 = Dict @((P 2 % 3) ~ (2 / 3))+_testSlash_Nat2_Nat4 = Dict @((P 1 % 2) ~ (2 / 4))+_testSlash_Nat2_IntN4 = Dict @((N 1 % 2) ~ (2 / (N 4)))+_testSlash_Nat2_IntN3 = Dict @((N 2 % 3) ~ (2 / (N 3)))+_testSlash_Nat2_IntN2 = Dict @((N 1 % 1) ~ (2 / (N 2)))+_testSlash_Nat2_IntN1 = Dict @((N 2 % 1) ~ (2 / (N 1)))+_testSlash_Nat2_IntP1 = Dict @((P 2 % 1) ~ (2 / (P 1)))+_testSlash_Nat2_IntP2 = Dict @((P 1 % 1) ~ (2 / (P 2)))+_testSlash_Nat2_IntP3 = Dict @((P 2 % 3) ~ (2 / (P 3)))+_testSlash_Nat2_IntP4 = Dict @((P 1 % 2) ~ (2 / (P 4)))+_testSlash_Nat2_Rat4N1 = Dict @((N 1 % 2) ~ (2 / (N 4 % 1)))+_testSlash_Nat2_Rat3N1 = Dict @((N 2 % 3) ~ (2 / (N 3 % 1)))+_testSlash_Nat2_Rat2N1 = Dict @((N 1 % 1) ~ (2 / (N 2 % 1)))+_testSlash_Nat2_Rat3N2 = Dict @((N 4 % 3) ~ (2 / (N 3 % 2)))+_testSlash_Nat2_Rat4N3 = Dict @((N 3 % 2) ~ (2 / (N 4 % 3)))+_testSlash_Nat2_Rat1N1 = Dict @((N 2 % 1) ~ (2 / (N 1 % 1)))+_testSlash_Nat2_Rat3N4 = Dict @((N 8 % 3) ~ (2 / (N 3 % 4)))+_testSlash_Nat2_Rat2N3 = Dict @((N 3 % 1) ~ (2 / (N 2 % 3)))+_testSlash_Nat2_Rat1N2 = Dict @((N 4 % 1) ~ (2 / (N 1 % 2)))+_testSlash_Nat2_Rat1N3 = Dict @((N 6 % 1) ~ (2 / (N 1 % 3)))+_testSlash_Nat2_Rat1N4 = Dict @((N 8 % 1) ~ (2 / (N 1 % 4)))+_testSlash_Nat2_Rat1P4 = Dict @((P 8 % 1) ~ (2 / (P 1 % 4)))+_testSlash_Nat2_Rat1P3 = Dict @((P 6 % 1) ~ (2 / (P 1 % 3)))+_testSlash_Nat2_Rat1P2 = Dict @((P 4 % 1) ~ (2 / (P 1 % 2)))+_testSlash_Nat2_Rat2P3 = Dict @((P 3 % 1) ~ (2 / (P 2 % 3)))+_testSlash_Nat2_Rat3P4 = Dict @((P 8 % 3) ~ (2 / (P 3 % 4)))+_testSlash_Nat2_Rat1P1 = Dict @((P 2 % 1) ~ (2 / (P 1 % 1)))+_testSlash_Nat2_Rat4P3 = Dict @((P 3 % 2) ~ (2 / (P 4 % 3)))+_testSlash_Nat2_Rat3P2 = Dict @((P 4 % 3) ~ (2 / (P 3 % 2)))+_testSlash_Nat2_Rat2P1 = Dict @((P 1 % 1) ~ (2 / (P 2 % 1)))+_testSlash_Nat2_Rat3P1 = Dict @((P 2 % 3) ~ (2 / (P 3 % 1)))+_testSlash_Nat2_Rat4P1 = Dict @((P 1 % 2) ~ (2 / (P 4 % 1)))+_testSlash_Nat3_Nat1 = Dict @((P 3 % 1) ~ (3 / 1))+_testSlash_Nat3_Nat2 = Dict @((P 3 % 2) ~ (3 / 2))+_testSlash_Nat3_Nat3 = Dict @((P 1 % 1) ~ (3 / 3))+_testSlash_Nat3_Nat4 = Dict @((P 3 % 4) ~ (3 / 4))+_testSlash_Nat3_IntN4 = Dict @((N 3 % 4) ~ (3 / (N 4)))+_testSlash_Nat3_IntN3 = Dict @((N 1 % 1) ~ (3 / (N 3)))+_testSlash_Nat3_IntN2 = Dict @((N 3 % 2) ~ (3 / (N 2)))+_testSlash_Nat3_IntN1 = Dict @((N 3 % 1) ~ (3 / (N 1)))+_testSlash_Nat3_IntP1 = Dict @((P 3 % 1) ~ (3 / (P 1)))+_testSlash_Nat3_IntP2 = Dict @((P 3 % 2) ~ (3 / (P 2)))+_testSlash_Nat3_IntP3 = Dict @((P 1 % 1) ~ (3 / (P 3)))+_testSlash_Nat3_IntP4 = Dict @((P 3 % 4) ~ (3 / (P 4)))+_testSlash_Nat3_Rat4N1 = Dict @((N 3 % 4) ~ (3 / (N 4 % 1)))+_testSlash_Nat3_Rat3N1 = Dict @((N 1 % 1) ~ (3 / (N 3 % 1)))+_testSlash_Nat3_Rat2N1 = Dict @((N 3 % 2) ~ (3 / (N 2 % 1)))+_testSlash_Nat3_Rat3N2 = Dict @((N 2 % 1) ~ (3 / (N 3 % 2)))+_testSlash_Nat3_Rat4N3 = Dict @((N 9 % 4) ~ (3 / (N 4 % 3)))+_testSlash_Nat3_Rat1N1 = Dict @((N 3 % 1) ~ (3 / (N 1 % 1)))+_testSlash_Nat3_Rat3N4 = Dict @((N 4 % 1) ~ (3 / (N 3 % 4)))+_testSlash_Nat3_Rat2N3 = Dict @((N 9 % 2) ~ (3 / (N 2 % 3)))+_testSlash_Nat3_Rat1N2 = Dict @((N 6 % 1) ~ (3 / (N 1 % 2)))+_testSlash_Nat3_Rat1N3 = Dict @((N 9 % 1) ~ (3 / (N 1 % 3)))+_testSlash_Nat3_Rat1N4 = Dict @((N 12 % 1) ~ (3 / (N 1 % 4)))+_testSlash_Nat3_Rat1P4 = Dict @((P 12 % 1) ~ (3 / (P 1 % 4)))+_testSlash_Nat3_Rat1P3 = Dict @((P 9 % 1) ~ (3 / (P 1 % 3)))+_testSlash_Nat3_Rat1P2 = Dict @((P 6 % 1) ~ (3 / (P 1 % 2)))+_testSlash_Nat3_Rat2P3 = Dict @((P 9 % 2) ~ (3 / (P 2 % 3)))+_testSlash_Nat3_Rat3P4 = Dict @((P 4 % 1) ~ (3 / (P 3 % 4)))+_testSlash_Nat3_Rat1P1 = Dict @((P 3 % 1) ~ (3 / (P 1 % 1)))+_testSlash_Nat3_Rat4P3 = Dict @((P 9 % 4) ~ (3 / (P 4 % 3)))+_testSlash_Nat3_Rat3P2 = Dict @((P 2 % 1) ~ (3 / (P 3 % 2)))+_testSlash_Nat3_Rat2P1 = Dict @((P 3 % 2) ~ (3 / (P 2 % 1)))+_testSlash_Nat3_Rat3P1 = Dict @((P 1 % 1) ~ (3 / (P 3 % 1)))+_testSlash_Nat3_Rat4P1 = Dict @((P 3 % 4) ~ (3 / (P 4 % 1)))+_testSlash_Nat4_Nat1 = Dict @((P 4 % 1) ~ (4 / 1))+_testSlash_Nat4_Nat2 = Dict @((P 2 % 1) ~ (4 / 2))+_testSlash_Nat4_Nat3 = Dict @((P 4 % 3) ~ (4 / 3))+_testSlash_Nat4_Nat4 = Dict @((P 1 % 1) ~ (4 / 4))+_testSlash_Nat4_IntN4 = Dict @((N 1 % 1) ~ (4 / (N 4)))+_testSlash_Nat4_IntN3 = Dict @((N 4 % 3) ~ (4 / (N 3)))+_testSlash_Nat4_IntN2 = Dict @((N 2 % 1) ~ (4 / (N 2)))+_testSlash_Nat4_IntN1 = Dict @((N 4 % 1) ~ (4 / (N 1)))+_testSlash_Nat4_IntP1 = Dict @((P 4 % 1) ~ (4 / (P 1)))+_testSlash_Nat4_IntP2 = Dict @((P 2 % 1) ~ (4 / (P 2)))+_testSlash_Nat4_IntP3 = Dict @((P 4 % 3) ~ (4 / (P 3)))+_testSlash_Nat4_IntP4 = Dict @((P 1 % 1) ~ (4 / (P 4)))+_testSlash_Nat4_Rat4N1 = Dict @((N 1 % 1) ~ (4 / (N 4 % 1)))+_testSlash_Nat4_Rat3N1 = Dict @((N 4 % 3) ~ (4 / (N 3 % 1)))+_testSlash_Nat4_Rat2N1 = Dict @((N 2 % 1) ~ (4 / (N 2 % 1)))+_testSlash_Nat4_Rat3N2 = Dict @((N 8 % 3) ~ (4 / (N 3 % 2)))+_testSlash_Nat4_Rat4N3 = Dict @((N 3 % 1) ~ (4 / (N 4 % 3)))+_testSlash_Nat4_Rat1N1 = Dict @((N 4 % 1) ~ (4 / (N 1 % 1)))+_testSlash_Nat4_Rat3N4 = Dict @((N 16 % 3) ~ (4 / (N 3 % 4)))+_testSlash_Nat4_Rat2N3 = Dict @((N 6 % 1) ~ (4 / (N 2 % 3)))+_testSlash_Nat4_Rat1N2 = Dict @((N 8 % 1) ~ (4 / (N 1 % 2)))+_testSlash_Nat4_Rat1N3 = Dict @((N 12 % 1) ~ (4 / (N 1 % 3)))+_testSlash_Nat4_Rat1N4 = Dict @((N 16 % 1) ~ (4 / (N 1 % 4)))+_testSlash_Nat4_Rat1P4 = Dict @((P 16 % 1) ~ (4 / (P 1 % 4)))+_testSlash_Nat4_Rat1P3 = Dict @((P 12 % 1) ~ (4 / (P 1 % 3)))+_testSlash_Nat4_Rat1P2 = Dict @((P 8 % 1) ~ (4 / (P 1 % 2)))+_testSlash_Nat4_Rat2P3 = Dict @((P 6 % 1) ~ (4 / (P 2 % 3)))+_testSlash_Nat4_Rat3P4 = Dict @((P 16 % 3) ~ (4 / (P 3 % 4)))+_testSlash_Nat4_Rat1P1 = Dict @((P 4 % 1) ~ (4 / (P 1 % 1)))+_testSlash_Nat4_Rat4P3 = Dict @((P 3 % 1) ~ (4 / (P 4 % 3)))+_testSlash_Nat4_Rat3P2 = Dict @((P 8 % 3) ~ (4 / (P 3 % 2)))+_testSlash_Nat4_Rat2P1 = Dict @((P 2 % 1) ~ (4 / (P 2 % 1)))+_testSlash_Nat4_Rat3P1 = Dict @((P 4 % 3) ~ (4 / (P 3 % 1)))+_testSlash_Nat4_Rat4P1 = Dict @((P 1 % 1) ~ (4 / (P 4 % 1)))+_testSlash_IntN4_Nat1 = Dict @((N 4 % 1) ~ ((N 4) / 1))+_testSlash_IntN4_Nat2 = Dict @((N 2 % 1) ~ ((N 4) / 2))+_testSlash_IntN4_Nat3 = Dict @((N 4 % 3) ~ ((N 4) / 3))+_testSlash_IntN4_Nat4 = Dict @((N 1 % 1) ~ ((N 4) / 4))+_testSlash_IntN4_IntN4 = Dict @((P 1 % 1) ~ ((N 4) / (N 4)))+_testSlash_IntN4_IntN3 = Dict @((P 4 % 3) ~ ((N 4) / (N 3)))+_testSlash_IntN4_IntN2 = Dict @((P 2 % 1) ~ ((N 4) / (N 2)))+_testSlash_IntN4_IntN1 = Dict @((P 4 % 1) ~ ((N 4) / (N 1)))+_testSlash_IntN4_IntP1 = Dict @((N 4 % 1) ~ ((N 4) / (P 1)))+_testSlash_IntN4_IntP2 = Dict @((N 2 % 1) ~ ((N 4) / (P 2)))+_testSlash_IntN4_IntP3 = Dict @((N 4 % 3) ~ ((N 4) / (P 3)))+_testSlash_IntN4_IntP4 = Dict @((N 1 % 1) ~ ((N 4) / (P 4)))+_testSlash_IntN4_Rat4N1 = Dict @((P 1 % 1) ~ ((N 4) / (N 4 % 1)))+_testSlash_IntN4_Rat3N1 = Dict @((P 4 % 3) ~ ((N 4) / (N 3 % 1)))+_testSlash_IntN4_Rat2N1 = Dict @((P 2 % 1) ~ ((N 4) / (N 2 % 1)))+_testSlash_IntN4_Rat3N2 = Dict @((P 8 % 3) ~ ((N 4) / (N 3 % 2)))+_testSlash_IntN4_Rat4N3 = Dict @((P 3 % 1) ~ ((N 4) / (N 4 % 3)))+_testSlash_IntN4_Rat1N1 = Dict @((P 4 % 1) ~ ((N 4) / (N 1 % 1)))+_testSlash_IntN4_Rat3N4 = Dict @((P 16 % 3) ~ ((N 4) / (N 3 % 4)))+_testSlash_IntN4_Rat2N3 = Dict @((P 6 % 1) ~ ((N 4) / (N 2 % 3)))+_testSlash_IntN4_Rat1N2 = Dict @((P 8 % 1) ~ ((N 4) / (N 1 % 2)))+_testSlash_IntN4_Rat1N3 = Dict @((P 12 % 1) ~ ((N 4) / (N 1 % 3)))+_testSlash_IntN4_Rat1N4 = Dict @((P 16 % 1) ~ ((N 4) / (N 1 % 4)))+_testSlash_IntN4_Rat1P4 = Dict @((N 16 % 1) ~ ((N 4) / (P 1 % 4)))+_testSlash_IntN4_Rat1P3 = Dict @((N 12 % 1) ~ ((N 4) / (P 1 % 3)))+_testSlash_IntN4_Rat1P2 = Dict @((N 8 % 1) ~ ((N 4) / (P 1 % 2)))+_testSlash_IntN4_Rat2P3 = Dict @((N 6 % 1) ~ ((N 4) / (P 2 % 3)))+_testSlash_IntN4_Rat3P4 = Dict @((N 16 % 3) ~ ((N 4) / (P 3 % 4)))+_testSlash_IntN4_Rat1P1 = Dict @((N 4 % 1) ~ ((N 4) / (P 1 % 1)))+_testSlash_IntN4_Rat4P3 = Dict @((N 3 % 1) ~ ((N 4) / (P 4 % 3)))+_testSlash_IntN4_Rat3P2 = Dict @((N 8 % 3) ~ ((N 4) / (P 3 % 2)))+_testSlash_IntN4_Rat2P1 = Dict @((N 2 % 1) ~ ((N 4) / (P 2 % 1)))+_testSlash_IntN4_Rat3P1 = Dict @((N 4 % 3) ~ ((N 4) / (P 3 % 1)))+_testSlash_IntN4_Rat4P1 = Dict @((N 1 % 1) ~ ((N 4) / (P 4 % 1)))+_testSlash_IntN3_Nat1 = Dict @((N 3 % 1) ~ ((N 3) / 1))+_testSlash_IntN3_Nat2 = Dict @((N 3 % 2) ~ ((N 3) / 2))+_testSlash_IntN3_Nat3 = Dict @((N 1 % 1) ~ ((N 3) / 3))+_testSlash_IntN3_Nat4 = Dict @((N 3 % 4) ~ ((N 3) / 4))+_testSlash_IntN3_IntN4 = Dict @((P 3 % 4) ~ ((N 3) / (N 4)))+_testSlash_IntN3_IntN3 = Dict @((P 1 % 1) ~ ((N 3) / (N 3)))+_testSlash_IntN3_IntN2 = Dict @((P 3 % 2) ~ ((N 3) / (N 2)))+_testSlash_IntN3_IntN1 = Dict @((P 3 % 1) ~ ((N 3) / (N 1)))+_testSlash_IntN3_IntP1 = Dict @((N 3 % 1) ~ ((N 3) / (P 1)))+_testSlash_IntN3_IntP2 = Dict @((N 3 % 2) ~ ((N 3) / (P 2)))+_testSlash_IntN3_IntP3 = Dict @((N 1 % 1) ~ ((N 3) / (P 3)))+_testSlash_IntN3_IntP4 = Dict @((N 3 % 4) ~ ((N 3) / (P 4)))+_testSlash_IntN3_Rat4N1 = Dict @((P 3 % 4) ~ ((N 3) / (N 4 % 1)))+_testSlash_IntN3_Rat3N1 = Dict @((P 1 % 1) ~ ((N 3) / (N 3 % 1)))+_testSlash_IntN3_Rat2N1 = Dict @((P 3 % 2) ~ ((N 3) / (N 2 % 1)))+_testSlash_IntN3_Rat3N2 = Dict @((P 2 % 1) ~ ((N 3) / (N 3 % 2)))+_testSlash_IntN3_Rat4N3 = Dict @((P 9 % 4) ~ ((N 3) / (N 4 % 3)))+_testSlash_IntN3_Rat1N1 = Dict @((P 3 % 1) ~ ((N 3) / (N 1 % 1)))+_testSlash_IntN3_Rat3N4 = Dict @((P 4 % 1) ~ ((N 3) / (N 3 % 4)))+_testSlash_IntN3_Rat2N3 = Dict @((P 9 % 2) ~ ((N 3) / (N 2 % 3)))+_testSlash_IntN3_Rat1N2 = Dict @((P 6 % 1) ~ ((N 3) / (N 1 % 2)))+_testSlash_IntN3_Rat1N3 = Dict @((P 9 % 1) ~ ((N 3) / (N 1 % 3)))+_testSlash_IntN3_Rat1N4 = Dict @((P 12 % 1) ~ ((N 3) / (N 1 % 4)))+_testSlash_IntN3_Rat1P4 = Dict @((N 12 % 1) ~ ((N 3) / (P 1 % 4)))+_testSlash_IntN3_Rat1P3 = Dict @((N 9 % 1) ~ ((N 3) / (P 1 % 3)))+_testSlash_IntN3_Rat1P2 = Dict @((N 6 % 1) ~ ((N 3) / (P 1 % 2)))+_testSlash_IntN3_Rat2P3 = Dict @((N 9 % 2) ~ ((N 3) / (P 2 % 3)))+_testSlash_IntN3_Rat3P4 = Dict @((N 4 % 1) ~ ((N 3) / (P 3 % 4)))+_testSlash_IntN3_Rat1P1 = Dict @((N 3 % 1) ~ ((N 3) / (P 1 % 1)))+_testSlash_IntN3_Rat4P3 = Dict @((N 9 % 4) ~ ((N 3) / (P 4 % 3)))+_testSlash_IntN3_Rat3P2 = Dict @((N 2 % 1) ~ ((N 3) / (P 3 % 2)))+_testSlash_IntN3_Rat2P1 = Dict @((N 3 % 2) ~ ((N 3) / (P 2 % 1)))+_testSlash_IntN3_Rat3P1 = Dict @((N 1 % 1) ~ ((N 3) / (P 3 % 1)))+_testSlash_IntN3_Rat4P1 = Dict @((N 3 % 4) ~ ((N 3) / (P 4 % 1)))+_testSlash_IntN2_Nat1 = Dict @((N 2 % 1) ~ ((N 2) / 1))+_testSlash_IntN2_Nat2 = Dict @((N 1 % 1) ~ ((N 2) / 2))+_testSlash_IntN2_Nat3 = Dict @((N 2 % 3) ~ ((N 2) / 3))+_testSlash_IntN2_Nat4 = Dict @((N 1 % 2) ~ ((N 2) / 4))+_testSlash_IntN2_IntN4 = Dict @((P 1 % 2) ~ ((N 2) / (N 4)))+_testSlash_IntN2_IntN3 = Dict @((P 2 % 3) ~ ((N 2) / (N 3)))+_testSlash_IntN2_IntN2 = Dict @((P 1 % 1) ~ ((N 2) / (N 2)))+_testSlash_IntN2_IntN1 = Dict @((P 2 % 1) ~ ((N 2) / (N 1)))+_testSlash_IntN2_IntP1 = Dict @((N 2 % 1) ~ ((N 2) / (P 1)))+_testSlash_IntN2_IntP2 = Dict @((N 1 % 1) ~ ((N 2) / (P 2)))+_testSlash_IntN2_IntP3 = Dict @((N 2 % 3) ~ ((N 2) / (P 3)))+_testSlash_IntN2_IntP4 = Dict @((N 1 % 2) ~ ((N 2) / (P 4)))+_testSlash_IntN2_Rat4N1 = Dict @((P 1 % 2) ~ ((N 2) / (N 4 % 1)))+_testSlash_IntN2_Rat3N1 = Dict @((P 2 % 3) ~ ((N 2) / (N 3 % 1)))+_testSlash_IntN2_Rat2N1 = Dict @((P 1 % 1) ~ ((N 2) / (N 2 % 1)))+_testSlash_IntN2_Rat3N2 = Dict @((P 4 % 3) ~ ((N 2) / (N 3 % 2)))+_testSlash_IntN2_Rat4N3 = Dict @((P 3 % 2) ~ ((N 2) / (N 4 % 3)))+_testSlash_IntN2_Rat1N1 = Dict @((P 2 % 1) ~ ((N 2) / (N 1 % 1)))+_testSlash_IntN2_Rat3N4 = Dict @((P 8 % 3) ~ ((N 2) / (N 3 % 4)))+_testSlash_IntN2_Rat2N3 = Dict @((P 3 % 1) ~ ((N 2) / (N 2 % 3)))+_testSlash_IntN2_Rat1N2 = Dict @((P 4 % 1) ~ ((N 2) / (N 1 % 2)))+_testSlash_IntN2_Rat1N3 = Dict @((P 6 % 1) ~ ((N 2) / (N 1 % 3)))+_testSlash_IntN2_Rat1N4 = Dict @((P 8 % 1) ~ ((N 2) / (N 1 % 4)))+_testSlash_IntN2_Rat1P4 = Dict @((N 8 % 1) ~ ((N 2) / (P 1 % 4)))+_testSlash_IntN2_Rat1P3 = Dict @((N 6 % 1) ~ ((N 2) / (P 1 % 3)))+_testSlash_IntN2_Rat1P2 = Dict @((N 4 % 1) ~ ((N 2) / (P 1 % 2)))+_testSlash_IntN2_Rat2P3 = Dict @((N 3 % 1) ~ ((N 2) / (P 2 % 3)))+_testSlash_IntN2_Rat3P4 = Dict @((N 8 % 3) ~ ((N 2) / (P 3 % 4)))+_testSlash_IntN2_Rat1P1 = Dict @((N 2 % 1) ~ ((N 2) / (P 1 % 1)))+_testSlash_IntN2_Rat4P3 = Dict @((N 3 % 2) ~ ((N 2) / (P 4 % 3)))+_testSlash_IntN2_Rat3P2 = Dict @((N 4 % 3) ~ ((N 2) / (P 3 % 2)))+_testSlash_IntN2_Rat2P1 = Dict @((N 1 % 1) ~ ((N 2) / (P 2 % 1)))+_testSlash_IntN2_Rat3P1 = Dict @((N 2 % 3) ~ ((N 2) / (P 3 % 1)))+_testSlash_IntN2_Rat4P1 = Dict @((N 1 % 2) ~ ((N 2) / (P 4 % 1)))+_testSlash_IntN1_Nat1 = Dict @((N 1 % 1) ~ ((N 1) / 1))+_testSlash_IntN1_Nat2 = Dict @((N 1 % 2) ~ ((N 1) / 2))+_testSlash_IntN1_Nat3 = Dict @((N 1 % 3) ~ ((N 1) / 3))+_testSlash_IntN1_Nat4 = Dict @((N 1 % 4) ~ ((N 1) / 4))+_testSlash_IntN1_IntN4 = Dict @((P 1 % 4) ~ ((N 1) / (N 4)))+_testSlash_IntN1_IntN3 = Dict @((P 1 % 3) ~ ((N 1) / (N 3)))+_testSlash_IntN1_IntN2 = Dict @((P 1 % 2) ~ ((N 1) / (N 2)))+_testSlash_IntN1_IntN1 = Dict @((P 1 % 1) ~ ((N 1) / (N 1)))+_testSlash_IntN1_IntP1 = Dict @((N 1 % 1) ~ ((N 1) / (P 1)))+_testSlash_IntN1_IntP2 = Dict @((N 1 % 2) ~ ((N 1) / (P 2)))+_testSlash_IntN1_IntP3 = Dict @((N 1 % 3) ~ ((N 1) / (P 3)))+_testSlash_IntN1_IntP4 = Dict @((N 1 % 4) ~ ((N 1) / (P 4)))+_testSlash_IntN1_Rat4N1 = Dict @((P 1 % 4) ~ ((N 1) / (N 4 % 1)))+_testSlash_IntN1_Rat3N1 = Dict @((P 1 % 3) ~ ((N 1) / (N 3 % 1)))+_testSlash_IntN1_Rat2N1 = Dict @((P 1 % 2) ~ ((N 1) / (N 2 % 1)))+_testSlash_IntN1_Rat3N2 = Dict @((P 2 % 3) ~ ((N 1) / (N 3 % 2)))+_testSlash_IntN1_Rat4N3 = Dict @((P 3 % 4) ~ ((N 1) / (N 4 % 3)))+_testSlash_IntN1_Rat1N1 = Dict @((P 1 % 1) ~ ((N 1) / (N 1 % 1)))+_testSlash_IntN1_Rat3N4 = Dict @((P 4 % 3) ~ ((N 1) / (N 3 % 4)))+_testSlash_IntN1_Rat2N3 = Dict @((P 3 % 2) ~ ((N 1) / (N 2 % 3)))+_testSlash_IntN1_Rat1N2 = Dict @((P 2 % 1) ~ ((N 1) / (N 1 % 2)))+_testSlash_IntN1_Rat1N3 = Dict @((P 3 % 1) ~ ((N 1) / (N 1 % 3)))+_testSlash_IntN1_Rat1N4 = Dict @((P 4 % 1) ~ ((N 1) / (N 1 % 4)))+_testSlash_IntN1_Rat1P4 = Dict @((N 4 % 1) ~ ((N 1) / (P 1 % 4)))+_testSlash_IntN1_Rat1P3 = Dict @((N 3 % 1) ~ ((N 1) / (P 1 % 3)))+_testSlash_IntN1_Rat1P2 = Dict @((N 2 % 1) ~ ((N 1) / (P 1 % 2)))+_testSlash_IntN1_Rat2P3 = Dict @((N 3 % 2) ~ ((N 1) / (P 2 % 3)))+_testSlash_IntN1_Rat3P4 = Dict @((N 4 % 3) ~ ((N 1) / (P 3 % 4)))+_testSlash_IntN1_Rat1P1 = Dict @((N 1 % 1) ~ ((N 1) / (P 1 % 1)))+_testSlash_IntN1_Rat4P3 = Dict @((N 3 % 4) ~ ((N 1) / (P 4 % 3)))+_testSlash_IntN1_Rat3P2 = Dict @((N 2 % 3) ~ ((N 1) / (P 3 % 2)))+_testSlash_IntN1_Rat2P1 = Dict @((N 1 % 2) ~ ((N 1) / (P 2 % 1)))+_testSlash_IntN1_Rat3P1 = Dict @((N 1 % 3) ~ ((N 1) / (P 3 % 1)))+_testSlash_IntN1_Rat4P1 = Dict @((N 1 % 4) ~ ((N 1) / (P 4 % 1)))+_testSlash_IntP0_Nat1 = Dict @((P 0 % 1) ~ ((P 0) / 1))+_testSlash_IntP0_Nat2 = Dict @((P 0 % 1) ~ ((P 0) / 2))+_testSlash_IntP0_Nat3 = Dict @((P 0 % 1) ~ ((P 0) / 3))+_testSlash_IntP0_Nat4 = Dict @((P 0 % 1) ~ ((P 0) / 4))+_testSlash_IntP0_IntN4 = Dict @((P 0 % 1) ~ ((P 0) / (N 4)))+_testSlash_IntP0_IntN3 = Dict @((P 0 % 1) ~ ((P 0) / (N 3)))+_testSlash_IntP0_IntN2 = Dict @((P 0 % 1) ~ ((P 0) / (N 2)))+_testSlash_IntP0_IntN1 = Dict @((P 0 % 1) ~ ((P 0) / (N 1)))+_testSlash_IntP0_IntP1 = Dict @((P 0 % 1) ~ ((P 0) / (P 1)))+_testSlash_IntP0_IntP2 = Dict @((P 0 % 1) ~ ((P 0) / (P 2)))+_testSlash_IntP0_IntP3 = Dict @((P 0 % 1) ~ ((P 0) / (P 3)))+_testSlash_IntP0_IntP4 = Dict @((P 0 % 1) ~ ((P 0) / (P 4)))+_testSlash_IntP0_Rat4N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 4 % 1)))+_testSlash_IntP0_Rat3N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 1)))+_testSlash_IntP0_Rat2N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 2 % 1)))+_testSlash_IntP0_Rat3N2 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 2)))+_testSlash_IntP0_Rat4N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 4 % 3)))+_testSlash_IntP0_Rat1N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 1)))+_testSlash_IntP0_Rat3N4 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 4)))+_testSlash_IntP0_Rat2N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 2 % 3)))+_testSlash_IntP0_Rat1N2 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 2)))+_testSlash_IntP0_Rat1N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 3)))+_testSlash_IntP0_Rat1N4 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 4)))+_testSlash_IntP0_Rat1P4 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 4)))+_testSlash_IntP0_Rat1P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 3)))+_testSlash_IntP0_Rat1P2 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 2)))+_testSlash_IntP0_Rat2P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 2 % 3)))+_testSlash_IntP0_Rat3P4 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 4)))+_testSlash_IntP0_Rat1P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 1)))+_testSlash_IntP0_Rat4P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 4 % 3)))+_testSlash_IntP0_Rat3P2 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 2)))+_testSlash_IntP0_Rat2P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 2 % 1)))+_testSlash_IntP0_Rat3P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 1)))+_testSlash_IntP0_Rat4P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 4 % 1)))+_testSlash_IntP1_Nat1 = Dict @((P 1 % 1) ~ ((P 1) / 1))+_testSlash_IntP1_Nat2 = Dict @((P 1 % 2) ~ ((P 1) / 2))+_testSlash_IntP1_Nat3 = Dict @((P 1 % 3) ~ ((P 1) / 3))+_testSlash_IntP1_Nat4 = Dict @((P 1 % 4) ~ ((P 1) / 4))+_testSlash_IntP1_IntN4 = Dict @((N 1 % 4) ~ ((P 1) / (N 4)))+_testSlash_IntP1_IntN3 = Dict @((N 1 % 3) ~ ((P 1) / (N 3)))+_testSlash_IntP1_IntN2 = Dict @((N 1 % 2) ~ ((P 1) / (N 2)))+_testSlash_IntP1_IntN1 = Dict @((N 1 % 1) ~ ((P 1) / (N 1)))+_testSlash_IntP1_IntP1 = Dict @((P 1 % 1) ~ ((P 1) / (P 1)))+_testSlash_IntP1_IntP2 = Dict @((P 1 % 2) ~ ((P 1) / (P 2)))+_testSlash_IntP1_IntP3 = Dict @((P 1 % 3) ~ ((P 1) / (P 3)))+_testSlash_IntP1_IntP4 = Dict @((P 1 % 4) ~ ((P 1) / (P 4)))+_testSlash_IntP1_Rat4N1 = Dict @((N 1 % 4) ~ ((P 1) / (N 4 % 1)))+_testSlash_IntP1_Rat3N1 = Dict @((N 1 % 3) ~ ((P 1) / (N 3 % 1)))+_testSlash_IntP1_Rat2N1 = Dict @((N 1 % 2) ~ ((P 1) / (N 2 % 1)))+_testSlash_IntP1_Rat3N2 = Dict @((N 2 % 3) ~ ((P 1) / (N 3 % 2)))+_testSlash_IntP1_Rat4N3 = Dict @((N 3 % 4) ~ ((P 1) / (N 4 % 3)))+_testSlash_IntP1_Rat1N1 = Dict @((N 1 % 1) ~ ((P 1) / (N 1 % 1)))+_testSlash_IntP1_Rat3N4 = Dict @((N 4 % 3) ~ ((P 1) / (N 3 % 4)))+_testSlash_IntP1_Rat2N3 = Dict @((N 3 % 2) ~ ((P 1) / (N 2 % 3)))+_testSlash_IntP1_Rat1N2 = Dict @((N 2 % 1) ~ ((P 1) / (N 1 % 2)))+_testSlash_IntP1_Rat1N3 = Dict @((N 3 % 1) ~ ((P 1) / (N 1 % 3)))+_testSlash_IntP1_Rat1N4 = Dict @((N 4 % 1) ~ ((P 1) / (N 1 % 4)))+_testSlash_IntP1_Rat1P4 = Dict @((P 4 % 1) ~ ((P 1) / (P 1 % 4)))+_testSlash_IntP1_Rat1P3 = Dict @((P 3 % 1) ~ ((P 1) / (P 1 % 3)))+_testSlash_IntP1_Rat1P2 = Dict @((P 2 % 1) ~ ((P 1) / (P 1 % 2)))+_testSlash_IntP1_Rat2P3 = Dict @((P 3 % 2) ~ ((P 1) / (P 2 % 3)))+_testSlash_IntP1_Rat3P4 = Dict @((P 4 % 3) ~ ((P 1) / (P 3 % 4)))+_testSlash_IntP1_Rat1P1 = Dict @((P 1 % 1) ~ ((P 1) / (P 1 % 1)))+_testSlash_IntP1_Rat4P3 = Dict @((P 3 % 4) ~ ((P 1) / (P 4 % 3)))+_testSlash_IntP1_Rat3P2 = Dict @((P 2 % 3) ~ ((P 1) / (P 3 % 2)))+_testSlash_IntP1_Rat2P1 = Dict @((P 1 % 2) ~ ((P 1) / (P 2 % 1)))+_testSlash_IntP1_Rat3P1 = Dict @((P 1 % 3) ~ ((P 1) / (P 3 % 1)))+_testSlash_IntP1_Rat4P1 = Dict @((P 1 % 4) ~ ((P 1) / (P 4 % 1)))+_testSlash_IntP2_Nat1 = Dict @((P 2 % 1) ~ ((P 2) / 1))+_testSlash_IntP2_Nat2 = Dict @((P 1 % 1) ~ ((P 2) / 2))+_testSlash_IntP2_Nat3 = Dict @((P 2 % 3) ~ ((P 2) / 3))+_testSlash_IntP2_Nat4 = Dict @((P 1 % 2) ~ ((P 2) / 4))+_testSlash_IntP2_IntN4 = Dict @((N 1 % 2) ~ ((P 2) / (N 4)))+_testSlash_IntP2_IntN3 = Dict @((N 2 % 3) ~ ((P 2) / (N 3)))+_testSlash_IntP2_IntN2 = Dict @((N 1 % 1) ~ ((P 2) / (N 2)))+_testSlash_IntP2_IntN1 = Dict @((N 2 % 1) ~ ((P 2) / (N 1)))+_testSlash_IntP2_IntP1 = Dict @((P 2 % 1) ~ ((P 2) / (P 1)))+_testSlash_IntP2_IntP2 = Dict @((P 1 % 1) ~ ((P 2) / (P 2)))+_testSlash_IntP2_IntP3 = Dict @((P 2 % 3) ~ ((P 2) / (P 3)))+_testSlash_IntP2_IntP4 = Dict @((P 1 % 2) ~ ((P 2) / (P 4)))+_testSlash_IntP2_Rat4N1 = Dict @((N 1 % 2) ~ ((P 2) / (N 4 % 1)))+_testSlash_IntP2_Rat3N1 = Dict @((N 2 % 3) ~ ((P 2) / (N 3 % 1)))+_testSlash_IntP2_Rat2N1 = Dict @((N 1 % 1) ~ ((P 2) / (N 2 % 1)))+_testSlash_IntP2_Rat3N2 = Dict @((N 4 % 3) ~ ((P 2) / (N 3 % 2)))+_testSlash_IntP2_Rat4N3 = Dict @((N 3 % 2) ~ ((P 2) / (N 4 % 3)))+_testSlash_IntP2_Rat1N1 = Dict @((N 2 % 1) ~ ((P 2) / (N 1 % 1)))+_testSlash_IntP2_Rat3N4 = Dict @((N 8 % 3) ~ ((P 2) / (N 3 % 4)))+_testSlash_IntP2_Rat2N3 = Dict @((N 3 % 1) ~ ((P 2) / (N 2 % 3)))+_testSlash_IntP2_Rat1N2 = Dict @((N 4 % 1) ~ ((P 2) / (N 1 % 2)))+_testSlash_IntP2_Rat1N3 = Dict @((N 6 % 1) ~ ((P 2) / (N 1 % 3)))+_testSlash_IntP2_Rat1N4 = Dict @((N 8 % 1) ~ ((P 2) / (N 1 % 4)))+_testSlash_IntP2_Rat1P4 = Dict @((P 8 % 1) ~ ((P 2) / (P 1 % 4)))+_testSlash_IntP2_Rat1P3 = Dict @((P 6 % 1) ~ ((P 2) / (P 1 % 3)))+_testSlash_IntP2_Rat1P2 = Dict @((P 4 % 1) ~ ((P 2) / (P 1 % 2)))+_testSlash_IntP2_Rat2P3 = Dict @((P 3 % 1) ~ ((P 2) / (P 2 % 3)))+_testSlash_IntP2_Rat3P4 = Dict @((P 8 % 3) ~ ((P 2) / (P 3 % 4)))+_testSlash_IntP2_Rat1P1 = Dict @((P 2 % 1) ~ ((P 2) / (P 1 % 1)))+_testSlash_IntP2_Rat4P3 = Dict @((P 3 % 2) ~ ((P 2) / (P 4 % 3)))+_testSlash_IntP2_Rat3P2 = Dict @((P 4 % 3) ~ ((P 2) / (P 3 % 2)))+_testSlash_IntP2_Rat2P1 = Dict @((P 1 % 1) ~ ((P 2) / (P 2 % 1)))+_testSlash_IntP2_Rat3P1 = Dict @((P 2 % 3) ~ ((P 2) / (P 3 % 1)))+_testSlash_IntP2_Rat4P1 = Dict @((P 1 % 2) ~ ((P 2) / (P 4 % 1)))+_testSlash_IntP3_Nat1 = Dict @((P 3 % 1) ~ ((P 3) / 1))+_testSlash_IntP3_Nat2 = Dict @((P 3 % 2) ~ ((P 3) / 2))+_testSlash_IntP3_Nat3 = Dict @((P 1 % 1) ~ ((P 3) / 3))+_testSlash_IntP3_Nat4 = Dict @((P 3 % 4) ~ ((P 3) / 4))+_testSlash_IntP3_IntN4 = Dict @((N 3 % 4) ~ ((P 3) / (N 4)))+_testSlash_IntP3_IntN3 = Dict @((N 1 % 1) ~ ((P 3) / (N 3)))+_testSlash_IntP3_IntN2 = Dict @((N 3 % 2) ~ ((P 3) / (N 2)))+_testSlash_IntP3_IntN1 = Dict @((N 3 % 1) ~ ((P 3) / (N 1)))+_testSlash_IntP3_IntP1 = Dict @((P 3 % 1) ~ ((P 3) / (P 1)))+_testSlash_IntP3_IntP2 = Dict @((P 3 % 2) ~ ((P 3) / (P 2)))+_testSlash_IntP3_IntP3 = Dict @((P 1 % 1) ~ ((P 3) / (P 3)))+_testSlash_IntP3_IntP4 = Dict @((P 3 % 4) ~ ((P 3) / (P 4)))+_testSlash_IntP3_Rat4N1 = Dict @((N 3 % 4) ~ ((P 3) / (N 4 % 1)))+_testSlash_IntP3_Rat3N1 = Dict @((N 1 % 1) ~ ((P 3) / (N 3 % 1)))+_testSlash_IntP3_Rat2N1 = Dict @((N 3 % 2) ~ ((P 3) / (N 2 % 1)))+_testSlash_IntP3_Rat3N2 = Dict @((N 2 % 1) ~ ((P 3) / (N 3 % 2)))+_testSlash_IntP3_Rat4N3 = Dict @((N 9 % 4) ~ ((P 3) / (N 4 % 3)))+_testSlash_IntP3_Rat1N1 = Dict @((N 3 % 1) ~ ((P 3) / (N 1 % 1)))+_testSlash_IntP3_Rat3N4 = Dict @((N 4 % 1) ~ ((P 3) / (N 3 % 4)))+_testSlash_IntP3_Rat2N3 = Dict @((N 9 % 2) ~ ((P 3) / (N 2 % 3)))+_testSlash_IntP3_Rat1N2 = Dict @((N 6 % 1) ~ ((P 3) / (N 1 % 2)))+_testSlash_IntP3_Rat1N3 = Dict @((N 9 % 1) ~ ((P 3) / (N 1 % 3)))+_testSlash_IntP3_Rat1N4 = Dict @((N 12 % 1) ~ ((P 3) / (N 1 % 4)))+_testSlash_IntP3_Rat1P4 = Dict @((P 12 % 1) ~ ((P 3) / (P 1 % 4)))+_testSlash_IntP3_Rat1P3 = Dict @((P 9 % 1) ~ ((P 3) / (P 1 % 3)))+_testSlash_IntP3_Rat1P2 = Dict @((P 6 % 1) ~ ((P 3) / (P 1 % 2)))+_testSlash_IntP3_Rat2P3 = Dict @((P 9 % 2) ~ ((P 3) / (P 2 % 3)))+_testSlash_IntP3_Rat3P4 = Dict @((P 4 % 1) ~ ((P 3) / (P 3 % 4)))+_testSlash_IntP3_Rat1P1 = Dict @((P 3 % 1) ~ ((P 3) / (P 1 % 1)))+_testSlash_IntP3_Rat4P3 = Dict @((P 9 % 4) ~ ((P 3) / (P 4 % 3)))+_testSlash_IntP3_Rat3P2 = Dict @((P 2 % 1) ~ ((P 3) / (P 3 % 2)))+_testSlash_IntP3_Rat2P1 = Dict @((P 3 % 2) ~ ((P 3) / (P 2 % 1)))+_testSlash_IntP3_Rat3P1 = Dict @((P 1 % 1) ~ ((P 3) / (P 3 % 1)))+_testSlash_IntP3_Rat4P1 = Dict @((P 3 % 4) ~ ((P 3) / (P 4 % 1)))+_testSlash_IntP4_Nat1 = Dict @((P 4 % 1) ~ ((P 4) / 1))+_testSlash_IntP4_Nat2 = Dict @((P 2 % 1) ~ ((P 4) / 2))+_testSlash_IntP4_Nat3 = Dict @((P 4 % 3) ~ ((P 4) / 3))+_testSlash_IntP4_Nat4 = Dict @((P 1 % 1) ~ ((P 4) / 4))+_testSlash_IntP4_IntN4 = Dict @((N 1 % 1) ~ ((P 4) / (N 4)))+_testSlash_IntP4_IntN3 = Dict @((N 4 % 3) ~ ((P 4) / (N 3)))+_testSlash_IntP4_IntN2 = Dict @((N 2 % 1) ~ ((P 4) / (N 2)))+_testSlash_IntP4_IntN1 = Dict @((N 4 % 1) ~ ((P 4) / (N 1)))+_testSlash_IntP4_IntP1 = Dict @((P 4 % 1) ~ ((P 4) / (P 1)))+_testSlash_IntP4_IntP2 = Dict @((P 2 % 1) ~ ((P 4) / (P 2)))+_testSlash_IntP4_IntP3 = Dict @((P 4 % 3) ~ ((P 4) / (P 3)))+_testSlash_IntP4_IntP4 = Dict @((P 1 % 1) ~ ((P 4) / (P 4)))+_testSlash_IntP4_Rat4N1 = Dict @((N 1 % 1) ~ ((P 4) / (N 4 % 1)))+_testSlash_IntP4_Rat3N1 = Dict @((N 4 % 3) ~ ((P 4) / (N 3 % 1)))+_testSlash_IntP4_Rat2N1 = Dict @((N 2 % 1) ~ ((P 4) / (N 2 % 1)))+_testSlash_IntP4_Rat3N2 = Dict @((N 8 % 3) ~ ((P 4) / (N 3 % 2)))+_testSlash_IntP4_Rat4N3 = Dict @((N 3 % 1) ~ ((P 4) / (N 4 % 3)))+_testSlash_IntP4_Rat1N1 = Dict @((N 4 % 1) ~ ((P 4) / (N 1 % 1)))+_testSlash_IntP4_Rat3N4 = Dict @((N 16 % 3) ~ ((P 4) / (N 3 % 4)))+_testSlash_IntP4_Rat2N3 = Dict @((N 6 % 1) ~ ((P 4) / (N 2 % 3)))+_testSlash_IntP4_Rat1N2 = Dict @((N 8 % 1) ~ ((P 4) / (N 1 % 2)))+_testSlash_IntP4_Rat1N3 = Dict @((N 12 % 1) ~ ((P 4) / (N 1 % 3)))+_testSlash_IntP4_Rat1N4 = Dict @((N 16 % 1) ~ ((P 4) / (N 1 % 4)))+_testSlash_IntP4_Rat1P4 = Dict @((P 16 % 1) ~ ((P 4) / (P 1 % 4)))+_testSlash_IntP4_Rat1P3 = Dict @((P 12 % 1) ~ ((P 4) / (P 1 % 3)))+_testSlash_IntP4_Rat1P2 = Dict @((P 8 % 1) ~ ((P 4) / (P 1 % 2)))+_testSlash_IntP4_Rat2P3 = Dict @((P 6 % 1) ~ ((P 4) / (P 2 % 3)))+_testSlash_IntP4_Rat3P4 = Dict @((P 16 % 3) ~ ((P 4) / (P 3 % 4)))+_testSlash_IntP4_Rat1P1 = Dict @((P 4 % 1) ~ ((P 4) / (P 1 % 1)))+_testSlash_IntP4_Rat4P3 = Dict @((P 3 % 1) ~ ((P 4) / (P 4 % 3)))+_testSlash_IntP4_Rat3P2 = Dict @((P 8 % 3) ~ ((P 4) / (P 3 % 2)))+_testSlash_IntP4_Rat2P1 = Dict @((P 2 % 1) ~ ((P 4) / (P 2 % 1)))+_testSlash_IntP4_Rat3P1 = Dict @((P 4 % 3) ~ ((P 4) / (P 3 % 1)))+_testSlash_IntP4_Rat4P1 = Dict @((P 1 % 1) ~ ((P 4) / (P 4 % 1)))+_testSlash_Rat4N1_Nat1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / 1))+_testSlash_Rat4N1_Nat2 = Dict @((N 2 % 1) ~ ((N 4 % 1) / 2))+_testSlash_Rat4N1_Nat3 = Dict @((N 4 % 3) ~ ((N 4 % 1) / 3))+_testSlash_Rat4N1_Nat4 = Dict @((N 1 % 1) ~ ((N 4 % 1) / 4))+_testSlash_Rat4N1_IntN4 = Dict @((P 1 % 1) ~ ((N 4 % 1) / (N 4)))+_testSlash_Rat4N1_IntN3 = Dict @((P 4 % 3) ~ ((N 4 % 1) / (N 3)))+_testSlash_Rat4N1_IntN2 = Dict @((P 2 % 1) ~ ((N 4 % 1) / (N 2)))+_testSlash_Rat4N1_IntN1 = Dict @((P 4 % 1) ~ ((N 4 % 1) / (N 1)))+_testSlash_Rat4N1_IntP1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / (P 1)))+_testSlash_Rat4N1_IntP2 = Dict @((N 2 % 1) ~ ((N 4 % 1) / (P 2)))+_testSlash_Rat4N1_IntP3 = Dict @((N 4 % 3) ~ ((N 4 % 1) / (P 3)))+_testSlash_Rat4N1_IntP4 = Dict @((N 1 % 1) ~ ((N 4 % 1) / (P 4)))+_testSlash_Rat4N1_Rat4N1 = Dict @((P 1 % 1) ~ ((N 4 % 1) / (N 4 % 1)))+_testSlash_Rat4N1_Rat3N1 = Dict @((P 4 % 3) ~ ((N 4 % 1) / (N 3 % 1)))+_testSlash_Rat4N1_Rat2N1 = Dict @((P 2 % 1) ~ ((N 4 % 1) / (N 2 % 1)))+_testSlash_Rat4N1_Rat3N2 = Dict @((P 8 % 3) ~ ((N 4 % 1) / (N 3 % 2)))+_testSlash_Rat4N1_Rat4N3 = Dict @((P 3 % 1) ~ ((N 4 % 1) / (N 4 % 3)))+_testSlash_Rat4N1_Rat1N1 = Dict @((P 4 % 1) ~ ((N 4 % 1) / (N 1 % 1)))+_testSlash_Rat4N1_Rat3N4 = Dict @((P 16 % 3) ~ ((N 4 % 1) / (N 3 % 4)))+_testSlash_Rat4N1_Rat2N3 = Dict @((P 6 % 1) ~ ((N 4 % 1) / (N 2 % 3)))+_testSlash_Rat4N1_Rat1N2 = Dict @((P 8 % 1) ~ ((N 4 % 1) / (N 1 % 2)))+_testSlash_Rat4N1_Rat1N3 = Dict @((P 12 % 1) ~ ((N 4 % 1) / (N 1 % 3)))+_testSlash_Rat4N1_Rat1N4 = Dict @((P 16 % 1) ~ ((N 4 % 1) / (N 1 % 4)))+_testSlash_Rat4N1_Rat1P4 = Dict @((N 16 % 1) ~ ((N 4 % 1) / (P 1 % 4)))+_testSlash_Rat4N1_Rat1P3 = Dict @((N 12 % 1) ~ ((N 4 % 1) / (P 1 % 3)))+_testSlash_Rat4N1_Rat1P2 = Dict @((N 8 % 1) ~ ((N 4 % 1) / (P 1 % 2)))+_testSlash_Rat4N1_Rat2P3 = Dict @((N 6 % 1) ~ ((N 4 % 1) / (P 2 % 3)))+_testSlash_Rat4N1_Rat3P4 = Dict @((N 16 % 3) ~ ((N 4 % 1) / (P 3 % 4)))+_testSlash_Rat4N1_Rat1P1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / (P 1 % 1)))+_testSlash_Rat4N1_Rat4P3 = Dict @((N 3 % 1) ~ ((N 4 % 1) / (P 4 % 3)))+_testSlash_Rat4N1_Rat3P2 = Dict @((N 8 % 3) ~ ((N 4 % 1) / (P 3 % 2)))+_testSlash_Rat4N1_Rat2P1 = Dict @((N 2 % 1) ~ ((N 4 % 1) / (P 2 % 1)))+_testSlash_Rat4N1_Rat3P1 = Dict @((N 4 % 3) ~ ((N 4 % 1) / (P 3 % 1)))+_testSlash_Rat4N1_Rat4P1 = Dict @((N 1 % 1) ~ ((N 4 % 1) / (P 4 % 1)))+_testSlash_Rat3N1_Nat1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / 1))+_testSlash_Rat3N1_Nat2 = Dict @((N 3 % 2) ~ ((N 3 % 1) / 2))+_testSlash_Rat3N1_Nat3 = Dict @((N 1 % 1) ~ ((N 3 % 1) / 3))+_testSlash_Rat3N1_Nat4 = Dict @((N 3 % 4) ~ ((N 3 % 1) / 4))+_testSlash_Rat3N1_IntN4 = Dict @((P 3 % 4) ~ ((N 3 % 1) / (N 4)))+_testSlash_Rat3N1_IntN3 = Dict @((P 1 % 1) ~ ((N 3 % 1) / (N 3)))+_testSlash_Rat3N1_IntN2 = Dict @((P 3 % 2) ~ ((N 3 % 1) / (N 2)))+_testSlash_Rat3N1_IntN1 = Dict @((P 3 % 1) ~ ((N 3 % 1) / (N 1)))+_testSlash_Rat3N1_IntP1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / (P 1)))+_testSlash_Rat3N1_IntP2 = Dict @((N 3 % 2) ~ ((N 3 % 1) / (P 2)))+_testSlash_Rat3N1_IntP3 = Dict @((N 1 % 1) ~ ((N 3 % 1) / (P 3)))+_testSlash_Rat3N1_IntP4 = Dict @((N 3 % 4) ~ ((N 3 % 1) / (P 4)))+_testSlash_Rat3N1_Rat4N1 = Dict @((P 3 % 4) ~ ((N 3 % 1) / (N 4 % 1)))+_testSlash_Rat3N1_Rat3N1 = Dict @((P 1 % 1) ~ ((N 3 % 1) / (N 3 % 1)))+_testSlash_Rat3N1_Rat2N1 = Dict @((P 3 % 2) ~ ((N 3 % 1) / (N 2 % 1)))+_testSlash_Rat3N1_Rat3N2 = Dict @((P 2 % 1) ~ ((N 3 % 1) / (N 3 % 2)))+_testSlash_Rat3N1_Rat4N3 = Dict @((P 9 % 4) ~ ((N 3 % 1) / (N 4 % 3)))+_testSlash_Rat3N1_Rat1N1 = Dict @((P 3 % 1) ~ ((N 3 % 1) / (N 1 % 1)))+_testSlash_Rat3N1_Rat3N4 = Dict @((P 4 % 1) ~ ((N 3 % 1) / (N 3 % 4)))+_testSlash_Rat3N1_Rat2N3 = Dict @((P 9 % 2) ~ ((N 3 % 1) / (N 2 % 3)))+_testSlash_Rat3N1_Rat1N2 = Dict @((P 6 % 1) ~ ((N 3 % 1) / (N 1 % 2)))+_testSlash_Rat3N1_Rat1N3 = Dict @((P 9 % 1) ~ ((N 3 % 1) / (N 1 % 3)))+_testSlash_Rat3N1_Rat1N4 = Dict @((P 12 % 1) ~ ((N 3 % 1) / (N 1 % 4)))+_testSlash_Rat3N1_Rat1P4 = Dict @((N 12 % 1) ~ ((N 3 % 1) / (P 1 % 4)))+_testSlash_Rat3N1_Rat1P3 = Dict @((N 9 % 1) ~ ((N 3 % 1) / (P 1 % 3)))+_testSlash_Rat3N1_Rat1P2 = Dict @((N 6 % 1) ~ ((N 3 % 1) / (P 1 % 2)))+_testSlash_Rat3N1_Rat2P3 = Dict @((N 9 % 2) ~ ((N 3 % 1) / (P 2 % 3)))+_testSlash_Rat3N1_Rat3P4 = Dict @((N 4 % 1) ~ ((N 3 % 1) / (P 3 % 4)))+_testSlash_Rat3N1_Rat1P1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / (P 1 % 1)))+_testSlash_Rat3N1_Rat4P3 = Dict @((N 9 % 4) ~ ((N 3 % 1) / (P 4 % 3)))+_testSlash_Rat3N1_Rat3P2 = Dict @((N 2 % 1) ~ ((N 3 % 1) / (P 3 % 2)))+_testSlash_Rat3N1_Rat2P1 = Dict @((N 3 % 2) ~ ((N 3 % 1) / (P 2 % 1)))+_testSlash_Rat3N1_Rat3P1 = Dict @((N 1 % 1) ~ ((N 3 % 1) / (P 3 % 1)))+_testSlash_Rat3N1_Rat4P1 = Dict @((N 3 % 4) ~ ((N 3 % 1) / (P 4 % 1)))+_testSlash_Rat2N1_Nat1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / 1))+_testSlash_Rat2N1_Nat2 = Dict @((N 1 % 1) ~ ((N 2 % 1) / 2))+_testSlash_Rat2N1_Nat3 = Dict @((N 2 % 3) ~ ((N 2 % 1) / 3))+_testSlash_Rat2N1_Nat4 = Dict @((N 1 % 2) ~ ((N 2 % 1) / 4))+_testSlash_Rat2N1_IntN4 = Dict @((P 1 % 2) ~ ((N 2 % 1) / (N 4)))+_testSlash_Rat2N1_IntN3 = Dict @((P 2 % 3) ~ ((N 2 % 1) / (N 3)))+_testSlash_Rat2N1_IntN2 = Dict @((P 1 % 1) ~ ((N 2 % 1) / (N 2)))+_testSlash_Rat2N1_IntN1 = Dict @((P 2 % 1) ~ ((N 2 % 1) / (N 1)))+_testSlash_Rat2N1_IntP1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / (P 1)))+_testSlash_Rat2N1_IntP2 = Dict @((N 1 % 1) ~ ((N 2 % 1) / (P 2)))+_testSlash_Rat2N1_IntP3 = Dict @((N 2 % 3) ~ ((N 2 % 1) / (P 3)))+_testSlash_Rat2N1_IntP4 = Dict @((N 1 % 2) ~ ((N 2 % 1) / (P 4)))+_testSlash_Rat2N1_Rat4N1 = Dict @((P 1 % 2) ~ ((N 2 % 1) / (N 4 % 1)))+_testSlash_Rat2N1_Rat3N1 = Dict @((P 2 % 3) ~ ((N 2 % 1) / (N 3 % 1)))+_testSlash_Rat2N1_Rat2N1 = Dict @((P 1 % 1) ~ ((N 2 % 1) / (N 2 % 1)))+_testSlash_Rat2N1_Rat3N2 = Dict @((P 4 % 3) ~ ((N 2 % 1) / (N 3 % 2)))+_testSlash_Rat2N1_Rat4N3 = Dict @((P 3 % 2) ~ ((N 2 % 1) / (N 4 % 3)))+_testSlash_Rat2N1_Rat1N1 = Dict @((P 2 % 1) ~ ((N 2 % 1) / (N 1 % 1)))+_testSlash_Rat2N1_Rat3N4 = Dict @((P 8 % 3) ~ ((N 2 % 1) / (N 3 % 4)))+_testSlash_Rat2N1_Rat2N3 = Dict @((P 3 % 1) ~ ((N 2 % 1) / (N 2 % 3)))+_testSlash_Rat2N1_Rat1N2 = Dict @((P 4 % 1) ~ ((N 2 % 1) / (N 1 % 2)))+_testSlash_Rat2N1_Rat1N3 = Dict @((P 6 % 1) ~ ((N 2 % 1) / (N 1 % 3)))+_testSlash_Rat2N1_Rat1N4 = Dict @((P 8 % 1) ~ ((N 2 % 1) / (N 1 % 4)))+_testSlash_Rat2N1_Rat1P4 = Dict @((N 8 % 1) ~ ((N 2 % 1) / (P 1 % 4)))+_testSlash_Rat2N1_Rat1P3 = Dict @((N 6 % 1) ~ ((N 2 % 1) / (P 1 % 3)))+_testSlash_Rat2N1_Rat1P2 = Dict @((N 4 % 1) ~ ((N 2 % 1) / (P 1 % 2)))+_testSlash_Rat2N1_Rat2P3 = Dict @((N 3 % 1) ~ ((N 2 % 1) / (P 2 % 3)))+_testSlash_Rat2N1_Rat3P4 = Dict @((N 8 % 3) ~ ((N 2 % 1) / (P 3 % 4)))+_testSlash_Rat2N1_Rat1P1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / (P 1 % 1)))+_testSlash_Rat2N1_Rat4P3 = Dict @((N 3 % 2) ~ ((N 2 % 1) / (P 4 % 3)))+_testSlash_Rat2N1_Rat3P2 = Dict @((N 4 % 3) ~ ((N 2 % 1) / (P 3 % 2)))+_testSlash_Rat2N1_Rat2P1 = Dict @((N 1 % 1) ~ ((N 2 % 1) / (P 2 % 1)))+_testSlash_Rat2N1_Rat3P1 = Dict @((N 2 % 3) ~ ((N 2 % 1) / (P 3 % 1)))+_testSlash_Rat2N1_Rat4P1 = Dict @((N 1 % 2) ~ ((N 2 % 1) / (P 4 % 1)))+_testSlash_Rat3N2_Nat1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / 1))+_testSlash_Rat3N2_Nat2 = Dict @((N 3 % 4) ~ ((N 3 % 2) / 2))+_testSlash_Rat3N2_Nat3 = Dict @((N 1 % 2) ~ ((N 3 % 2) / 3))+_testSlash_Rat3N2_Nat4 = Dict @((N 3 % 8) ~ ((N 3 % 2) / 4))+_testSlash_Rat3N2_IntN4 = Dict @((P 3 % 8) ~ ((N 3 % 2) / (N 4)))+_testSlash_Rat3N2_IntN3 = Dict @((P 1 % 2) ~ ((N 3 % 2) / (N 3)))+_testSlash_Rat3N2_IntN2 = Dict @((P 3 % 4) ~ ((N 3 % 2) / (N 2)))+_testSlash_Rat3N2_IntN1 = Dict @((P 3 % 2) ~ ((N 3 % 2) / (N 1)))+_testSlash_Rat3N2_IntP1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / (P 1)))+_testSlash_Rat3N2_IntP2 = Dict @((N 3 % 4) ~ ((N 3 % 2) / (P 2)))+_testSlash_Rat3N2_IntP3 = Dict @((N 1 % 2) ~ ((N 3 % 2) / (P 3)))+_testSlash_Rat3N2_IntP4 = Dict @((N 3 % 8) ~ ((N 3 % 2) / (P 4)))+_testSlash_Rat3N2_Rat4N1 = Dict @((P 3 % 8) ~ ((N 3 % 2) / (N 4 % 1)))+_testSlash_Rat3N2_Rat3N1 = Dict @((P 1 % 2) ~ ((N 3 % 2) / (N 3 % 1)))+_testSlash_Rat3N2_Rat2N1 = Dict @((P 3 % 4) ~ ((N 3 % 2) / (N 2 % 1)))+_testSlash_Rat3N2_Rat3N2 = Dict @((P 1 % 1) ~ ((N 3 % 2) / (N 3 % 2)))+_testSlash_Rat3N2_Rat4N3 = Dict @((P 9 % 8) ~ ((N 3 % 2) / (N 4 % 3)))+_testSlash_Rat3N2_Rat1N1 = Dict @((P 3 % 2) ~ ((N 3 % 2) / (N 1 % 1)))+_testSlash_Rat3N2_Rat3N4 = Dict @((P 2 % 1) ~ ((N 3 % 2) / (N 3 % 4)))+_testSlash_Rat3N2_Rat2N3 = Dict @((P 9 % 4) ~ ((N 3 % 2) / (N 2 % 3)))+_testSlash_Rat3N2_Rat1N2 = Dict @((P 3 % 1) ~ ((N 3 % 2) / (N 1 % 2)))+_testSlash_Rat3N2_Rat1N3 = Dict @((P 9 % 2) ~ ((N 3 % 2) / (N 1 % 3)))+_testSlash_Rat3N2_Rat1N4 = Dict @((P 6 % 1) ~ ((N 3 % 2) / (N 1 % 4)))+_testSlash_Rat3N2_Rat1P4 = Dict @((N 6 % 1) ~ ((N 3 % 2) / (P 1 % 4)))+_testSlash_Rat3N2_Rat1P3 = Dict @((N 9 % 2) ~ ((N 3 % 2) / (P 1 % 3)))+_testSlash_Rat3N2_Rat1P2 = Dict @((N 3 % 1) ~ ((N 3 % 2) / (P 1 % 2)))+_testSlash_Rat3N2_Rat2P3 = Dict @((N 9 % 4) ~ ((N 3 % 2) / (P 2 % 3)))+_testSlash_Rat3N2_Rat3P4 = Dict @((N 2 % 1) ~ ((N 3 % 2) / (P 3 % 4)))+_testSlash_Rat3N2_Rat1P1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / (P 1 % 1)))+_testSlash_Rat3N2_Rat4P3 = Dict @((N 9 % 8) ~ ((N 3 % 2) / (P 4 % 3)))+_testSlash_Rat3N2_Rat3P2 = Dict @((N 1 % 1) ~ ((N 3 % 2) / (P 3 % 2)))+_testSlash_Rat3N2_Rat2P1 = Dict @((N 3 % 4) ~ ((N 3 % 2) / (P 2 % 1)))+_testSlash_Rat3N2_Rat3P1 = Dict @((N 1 % 2) ~ ((N 3 % 2) / (P 3 % 1)))+_testSlash_Rat3N2_Rat4P1 = Dict @((N 3 % 8) ~ ((N 3 % 2) / (P 4 % 1)))+_testSlash_Rat4N3_Nat1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / 1))+_testSlash_Rat4N3_Nat2 = Dict @((N 2 % 3) ~ ((N 4 % 3) / 2))+_testSlash_Rat4N3_Nat3 = Dict @((N 4 % 9) ~ ((N 4 % 3) / 3))+_testSlash_Rat4N3_Nat4 = Dict @((N 1 % 3) ~ ((N 4 % 3) / 4))+_testSlash_Rat4N3_IntN4 = Dict @((P 1 % 3) ~ ((N 4 % 3) / (N 4)))+_testSlash_Rat4N3_IntN3 = Dict @((P 4 % 9) ~ ((N 4 % 3) / (N 3)))+_testSlash_Rat4N3_IntN2 = Dict @((P 2 % 3) ~ ((N 4 % 3) / (N 2)))+_testSlash_Rat4N3_IntN1 = Dict @((P 4 % 3) ~ ((N 4 % 3) / (N 1)))+_testSlash_Rat4N3_IntP1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / (P 1)))+_testSlash_Rat4N3_IntP2 = Dict @((N 2 % 3) ~ ((N 4 % 3) / (P 2)))+_testSlash_Rat4N3_IntP3 = Dict @((N 4 % 9) ~ ((N 4 % 3) / (P 3)))+_testSlash_Rat4N3_IntP4 = Dict @((N 1 % 3) ~ ((N 4 % 3) / (P 4)))+_testSlash_Rat4N3_Rat4N1 = Dict @((P 1 % 3) ~ ((N 4 % 3) / (N 4 % 1)))+_testSlash_Rat4N3_Rat3N1 = Dict @((P 4 % 9) ~ ((N 4 % 3) / (N 3 % 1)))+_testSlash_Rat4N3_Rat2N1 = Dict @((P 2 % 3) ~ ((N 4 % 3) / (N 2 % 1)))+_testSlash_Rat4N3_Rat3N2 = Dict @((P 8 % 9) ~ ((N 4 % 3) / (N 3 % 2)))+_testSlash_Rat4N3_Rat4N3 = Dict @((P 1 % 1) ~ ((N 4 % 3) / (N 4 % 3)))+_testSlash_Rat4N3_Rat1N1 = Dict @((P 4 % 3) ~ ((N 4 % 3) / (N 1 % 1)))+_testSlash_Rat4N3_Rat3N4 = Dict @((P 16 % 9) ~ ((N 4 % 3) / (N 3 % 4)))+_testSlash_Rat4N3_Rat2N3 = Dict @((P 2 % 1) ~ ((N 4 % 3) / (N 2 % 3)))+_testSlash_Rat4N3_Rat1N2 = Dict @((P 8 % 3) ~ ((N 4 % 3) / (N 1 % 2)))+_testSlash_Rat4N3_Rat1N3 = Dict @((P 4 % 1) ~ ((N 4 % 3) / (N 1 % 3)))+_testSlash_Rat4N3_Rat1N4 = Dict @((P 16 % 3) ~ ((N 4 % 3) / (N 1 % 4)))+_testSlash_Rat4N3_Rat1P4 = Dict @((N 16 % 3) ~ ((N 4 % 3) / (P 1 % 4)))+_testSlash_Rat4N3_Rat1P3 = Dict @((N 4 % 1) ~ ((N 4 % 3) / (P 1 % 3)))+_testSlash_Rat4N3_Rat1P2 = Dict @((N 8 % 3) ~ ((N 4 % 3) / (P 1 % 2)))+_testSlash_Rat4N3_Rat2P3 = Dict @((N 2 % 1) ~ ((N 4 % 3) / (P 2 % 3)))+_testSlash_Rat4N3_Rat3P4 = Dict @((N 16 % 9) ~ ((N 4 % 3) / (P 3 % 4)))+_testSlash_Rat4N3_Rat1P1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / (P 1 % 1)))+_testSlash_Rat4N3_Rat4P3 = Dict @((N 1 % 1) ~ ((N 4 % 3) / (P 4 % 3)))+_testSlash_Rat4N3_Rat3P2 = Dict @((N 8 % 9) ~ ((N 4 % 3) / (P 3 % 2)))+_testSlash_Rat4N3_Rat2P1 = Dict @((N 2 % 3) ~ ((N 4 % 3) / (P 2 % 1)))+_testSlash_Rat4N3_Rat3P1 = Dict @((N 4 % 9) ~ ((N 4 % 3) / (P 3 % 1)))+_testSlash_Rat4N3_Rat4P1 = Dict @((N 1 % 3) ~ ((N 4 % 3) / (P 4 % 1)))+_testSlash_Rat1N1_Nat1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / 1))+_testSlash_Rat1N1_Nat2 = Dict @((N 1 % 2) ~ ((N 1 % 1) / 2))+_testSlash_Rat1N1_Nat3 = Dict @((N 1 % 3) ~ ((N 1 % 1) / 3))+_testSlash_Rat1N1_Nat4 = Dict @((N 1 % 4) ~ ((N 1 % 1) / 4))+_testSlash_Rat1N1_IntN4 = Dict @((P 1 % 4) ~ ((N 1 % 1) / (N 4)))+_testSlash_Rat1N1_IntN3 = Dict @((P 1 % 3) ~ ((N 1 % 1) / (N 3)))+_testSlash_Rat1N1_IntN2 = Dict @((P 1 % 2) ~ ((N 1 % 1) / (N 2)))+_testSlash_Rat1N1_IntN1 = Dict @((P 1 % 1) ~ ((N 1 % 1) / (N 1)))+_testSlash_Rat1N1_IntP1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / (P 1)))+_testSlash_Rat1N1_IntP2 = Dict @((N 1 % 2) ~ ((N 1 % 1) / (P 2)))+_testSlash_Rat1N1_IntP3 = Dict @((N 1 % 3) ~ ((N 1 % 1) / (P 3)))+_testSlash_Rat1N1_IntP4 = Dict @((N 1 % 4) ~ ((N 1 % 1) / (P 4)))+_testSlash_Rat1N1_Rat4N1 = Dict @((P 1 % 4) ~ ((N 1 % 1) / (N 4 % 1)))+_testSlash_Rat1N1_Rat3N1 = Dict @((P 1 % 3) ~ ((N 1 % 1) / (N 3 % 1)))+_testSlash_Rat1N1_Rat2N1 = Dict @((P 1 % 2) ~ ((N 1 % 1) / (N 2 % 1)))+_testSlash_Rat1N1_Rat3N2 = Dict @((P 2 % 3) ~ ((N 1 % 1) / (N 3 % 2)))+_testSlash_Rat1N1_Rat4N3 = Dict @((P 3 % 4) ~ ((N 1 % 1) / (N 4 % 3)))+_testSlash_Rat1N1_Rat1N1 = Dict @((P 1 % 1) ~ ((N 1 % 1) / (N 1 % 1)))+_testSlash_Rat1N1_Rat3N4 = Dict @((P 4 % 3) ~ ((N 1 % 1) / (N 3 % 4)))+_testSlash_Rat1N1_Rat2N3 = Dict @((P 3 % 2) ~ ((N 1 % 1) / (N 2 % 3)))+_testSlash_Rat1N1_Rat1N2 = Dict @((P 2 % 1) ~ ((N 1 % 1) / (N 1 % 2)))+_testSlash_Rat1N1_Rat1N3 = Dict @((P 3 % 1) ~ ((N 1 % 1) / (N 1 % 3)))+_testSlash_Rat1N1_Rat1N4 = Dict @((P 4 % 1) ~ ((N 1 % 1) / (N 1 % 4)))+_testSlash_Rat1N1_Rat1P4 = Dict @((N 4 % 1) ~ ((N 1 % 1) / (P 1 % 4)))+_testSlash_Rat1N1_Rat1P3 = Dict @((N 3 % 1) ~ ((N 1 % 1) / (P 1 % 3)))+_testSlash_Rat1N1_Rat1P2 = Dict @((N 2 % 1) ~ ((N 1 % 1) / (P 1 % 2)))+_testSlash_Rat1N1_Rat2P3 = Dict @((N 3 % 2) ~ ((N 1 % 1) / (P 2 % 3)))+_testSlash_Rat1N1_Rat3P4 = Dict @((N 4 % 3) ~ ((N 1 % 1) / (P 3 % 4)))+_testSlash_Rat1N1_Rat1P1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / (P 1 % 1)))+_testSlash_Rat1N1_Rat4P3 = Dict @((N 3 % 4) ~ ((N 1 % 1) / (P 4 % 3)))+_testSlash_Rat1N1_Rat3P2 = Dict @((N 2 % 3) ~ ((N 1 % 1) / (P 3 % 2)))+_testSlash_Rat1N1_Rat2P1 = Dict @((N 1 % 2) ~ ((N 1 % 1) / (P 2 % 1)))+_testSlash_Rat1N1_Rat3P1 = Dict @((N 1 % 3) ~ ((N 1 % 1) / (P 3 % 1)))+_testSlash_Rat1N1_Rat4P1 = Dict @((N 1 % 4) ~ ((N 1 % 1) / (P 4 % 1)))+_testSlash_Rat3N4_Nat1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / 1))+_testSlash_Rat3N4_Nat2 = Dict @((N 3 % 8) ~ ((N 3 % 4) / 2))+_testSlash_Rat3N4_Nat3 = Dict @((N 1 % 4) ~ ((N 3 % 4) / 3))+_testSlash_Rat3N4_Nat4 = Dict @((N 3 % 16) ~ ((N 3 % 4) / 4))+_testSlash_Rat3N4_IntN4 = Dict @((P 3 % 16) ~ ((N 3 % 4) / (N 4)))+_testSlash_Rat3N4_IntN3 = Dict @((P 1 % 4) ~ ((N 3 % 4) / (N 3)))+_testSlash_Rat3N4_IntN2 = Dict @((P 3 % 8) ~ ((N 3 % 4) / (N 2)))+_testSlash_Rat3N4_IntN1 = Dict @((P 3 % 4) ~ ((N 3 % 4) / (N 1)))+_testSlash_Rat3N4_IntP1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / (P 1)))+_testSlash_Rat3N4_IntP2 = Dict @((N 3 % 8) ~ ((N 3 % 4) / (P 2)))+_testSlash_Rat3N4_IntP3 = Dict @((N 1 % 4) ~ ((N 3 % 4) / (P 3)))+_testSlash_Rat3N4_IntP4 = Dict @((N 3 % 16) ~ ((N 3 % 4) / (P 4)))+_testSlash_Rat3N4_Rat4N1 = Dict @((P 3 % 16) ~ ((N 3 % 4) / (N 4 % 1)))+_testSlash_Rat3N4_Rat3N1 = Dict @((P 1 % 4) ~ ((N 3 % 4) / (N 3 % 1)))+_testSlash_Rat3N4_Rat2N1 = Dict @((P 3 % 8) ~ ((N 3 % 4) / (N 2 % 1)))+_testSlash_Rat3N4_Rat3N2 = Dict @((P 1 % 2) ~ ((N 3 % 4) / (N 3 % 2)))+_testSlash_Rat3N4_Rat4N3 = Dict @((P 9 % 16) ~ ((N 3 % 4) / (N 4 % 3)))+_testSlash_Rat3N4_Rat1N1 = Dict @((P 3 % 4) ~ ((N 3 % 4) / (N 1 % 1)))+_testSlash_Rat3N4_Rat3N4 = Dict @((P 1 % 1) ~ ((N 3 % 4) / (N 3 % 4)))+_testSlash_Rat3N4_Rat2N3 = Dict @((P 9 % 8) ~ ((N 3 % 4) / (N 2 % 3)))+_testSlash_Rat3N4_Rat1N2 = Dict @((P 3 % 2) ~ ((N 3 % 4) / (N 1 % 2)))+_testSlash_Rat3N4_Rat1N3 = Dict @((P 9 % 4) ~ ((N 3 % 4) / (N 1 % 3)))+_testSlash_Rat3N4_Rat1N4 = Dict @((P 3 % 1) ~ ((N 3 % 4) / (N 1 % 4)))+_testSlash_Rat3N4_Rat1P4 = Dict @((N 3 % 1) ~ ((N 3 % 4) / (P 1 % 4)))+_testSlash_Rat3N4_Rat1P3 = Dict @((N 9 % 4) ~ ((N 3 % 4) / (P 1 % 3)))+_testSlash_Rat3N4_Rat1P2 = Dict @((N 3 % 2) ~ ((N 3 % 4) / (P 1 % 2)))+_testSlash_Rat3N4_Rat2P3 = Dict @((N 9 % 8) ~ ((N 3 % 4) / (P 2 % 3)))+_testSlash_Rat3N4_Rat3P4 = Dict @((N 1 % 1) ~ ((N 3 % 4) / (P 3 % 4)))+_testSlash_Rat3N4_Rat1P1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / (P 1 % 1)))+_testSlash_Rat3N4_Rat4P3 = Dict @((N 9 % 16) ~ ((N 3 % 4) / (P 4 % 3)))+_testSlash_Rat3N4_Rat3P2 = Dict @((N 1 % 2) ~ ((N 3 % 4) / (P 3 % 2)))+_testSlash_Rat3N4_Rat2P1 = Dict @((N 3 % 8) ~ ((N 3 % 4) / (P 2 % 1)))+_testSlash_Rat3N4_Rat3P1 = Dict @((N 1 % 4) ~ ((N 3 % 4) / (P 3 % 1)))+_testSlash_Rat3N4_Rat4P1 = Dict @((N 3 % 16) ~ ((N 3 % 4) / (P 4 % 1)))+_testSlash_Rat2N3_Nat1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / 1))+_testSlash_Rat2N3_Nat2 = Dict @((N 1 % 3) ~ ((N 2 % 3) / 2))+_testSlash_Rat2N3_Nat3 = Dict @((N 2 % 9) ~ ((N 2 % 3) / 3))+_testSlash_Rat2N3_Nat4 = Dict @((N 1 % 6) ~ ((N 2 % 3) / 4))+_testSlash_Rat2N3_IntN4 = Dict @((P 1 % 6) ~ ((N 2 % 3) / (N 4)))+_testSlash_Rat2N3_IntN3 = Dict @((P 2 % 9) ~ ((N 2 % 3) / (N 3)))+_testSlash_Rat2N3_IntN2 = Dict @((P 1 % 3) ~ ((N 2 % 3) / (N 2)))+_testSlash_Rat2N3_IntN1 = Dict @((P 2 % 3) ~ ((N 2 % 3) / (N 1)))+_testSlash_Rat2N3_IntP1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / (P 1)))+_testSlash_Rat2N3_IntP2 = Dict @((N 1 % 3) ~ ((N 2 % 3) / (P 2)))+_testSlash_Rat2N3_IntP3 = Dict @((N 2 % 9) ~ ((N 2 % 3) / (P 3)))+_testSlash_Rat2N3_IntP4 = Dict @((N 1 % 6) ~ ((N 2 % 3) / (P 4)))+_testSlash_Rat2N3_Rat4N1 = Dict @((P 1 % 6) ~ ((N 2 % 3) / (N 4 % 1)))+_testSlash_Rat2N3_Rat3N1 = Dict @((P 2 % 9) ~ ((N 2 % 3) / (N 3 % 1)))+_testSlash_Rat2N3_Rat2N1 = Dict @((P 1 % 3) ~ ((N 2 % 3) / (N 2 % 1)))+_testSlash_Rat2N3_Rat3N2 = Dict @((P 4 % 9) ~ ((N 2 % 3) / (N 3 % 2)))+_testSlash_Rat2N3_Rat4N3 = Dict @((P 1 % 2) ~ ((N 2 % 3) / (N 4 % 3)))+_testSlash_Rat2N3_Rat1N1 = Dict @((P 2 % 3) ~ ((N 2 % 3) / (N 1 % 1)))+_testSlash_Rat2N3_Rat3N4 = Dict @((P 8 % 9) ~ ((N 2 % 3) / (N 3 % 4)))+_testSlash_Rat2N3_Rat2N3 = Dict @((P 1 % 1) ~ ((N 2 % 3) / (N 2 % 3)))+_testSlash_Rat2N3_Rat1N2 = Dict @((P 4 % 3) ~ ((N 2 % 3) / (N 1 % 2)))+_testSlash_Rat2N3_Rat1N3 = Dict @((P 2 % 1) ~ ((N 2 % 3) / (N 1 % 3)))+_testSlash_Rat2N3_Rat1N4 = Dict @((P 8 % 3) ~ ((N 2 % 3) / (N 1 % 4)))+_testSlash_Rat2N3_Rat1P4 = Dict @((N 8 % 3) ~ ((N 2 % 3) / (P 1 % 4)))+_testSlash_Rat2N3_Rat1P3 = Dict @((N 2 % 1) ~ ((N 2 % 3) / (P 1 % 3)))+_testSlash_Rat2N3_Rat1P2 = Dict @((N 4 % 3) ~ ((N 2 % 3) / (P 1 % 2)))+_testSlash_Rat2N3_Rat2P3 = Dict @((N 1 % 1) ~ ((N 2 % 3) / (P 2 % 3)))+_testSlash_Rat2N3_Rat3P4 = Dict @((N 8 % 9) ~ ((N 2 % 3) / (P 3 % 4)))+_testSlash_Rat2N3_Rat1P1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / (P 1 % 1)))+_testSlash_Rat2N3_Rat4P3 = Dict @((N 1 % 2) ~ ((N 2 % 3) / (P 4 % 3)))+_testSlash_Rat2N3_Rat3P2 = Dict @((N 4 % 9) ~ ((N 2 % 3) / (P 3 % 2)))+_testSlash_Rat2N3_Rat2P1 = Dict @((N 1 % 3) ~ ((N 2 % 3) / (P 2 % 1)))+_testSlash_Rat2N3_Rat3P1 = Dict @((N 2 % 9) ~ ((N 2 % 3) / (P 3 % 1)))+_testSlash_Rat2N3_Rat4P1 = Dict @((N 1 % 6) ~ ((N 2 % 3) / (P 4 % 1)))+_testSlash_Rat1N2_Nat1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / 1))+_testSlash_Rat1N2_Nat2 = Dict @((N 1 % 4) ~ ((N 1 % 2) / 2))+_testSlash_Rat1N2_Nat3 = Dict @((N 1 % 6) ~ ((N 1 % 2) / 3))+_testSlash_Rat1N2_Nat4 = Dict @((N 1 % 8) ~ ((N 1 % 2) / 4))+_testSlash_Rat1N2_IntN4 = Dict @((P 1 % 8) ~ ((N 1 % 2) / (N 4)))+_testSlash_Rat1N2_IntN3 = Dict @((P 1 % 6) ~ ((N 1 % 2) / (N 3)))+_testSlash_Rat1N2_IntN2 = Dict @((P 1 % 4) ~ ((N 1 % 2) / (N 2)))+_testSlash_Rat1N2_IntN1 = Dict @((P 1 % 2) ~ ((N 1 % 2) / (N 1)))+_testSlash_Rat1N2_IntP1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / (P 1)))+_testSlash_Rat1N2_IntP2 = Dict @((N 1 % 4) ~ ((N 1 % 2) / (P 2)))+_testSlash_Rat1N2_IntP3 = Dict @((N 1 % 6) ~ ((N 1 % 2) / (P 3)))+_testSlash_Rat1N2_IntP4 = Dict @((N 1 % 8) ~ ((N 1 % 2) / (P 4)))+_testSlash_Rat1N2_Rat4N1 = Dict @((P 1 % 8) ~ ((N 1 % 2) / (N 4 % 1)))+_testSlash_Rat1N2_Rat3N1 = Dict @((P 1 % 6) ~ ((N 1 % 2) / (N 3 % 1)))+_testSlash_Rat1N2_Rat2N1 = Dict @((P 1 % 4) ~ ((N 1 % 2) / (N 2 % 1)))+_testSlash_Rat1N2_Rat3N2 = Dict @((P 1 % 3) ~ ((N 1 % 2) / (N 3 % 2)))+_testSlash_Rat1N2_Rat4N3 = Dict @((P 3 % 8) ~ ((N 1 % 2) / (N 4 % 3)))+_testSlash_Rat1N2_Rat1N1 = Dict @((P 1 % 2) ~ ((N 1 % 2) / (N 1 % 1)))+_testSlash_Rat1N2_Rat3N4 = Dict @((P 2 % 3) ~ ((N 1 % 2) / (N 3 % 4)))+_testSlash_Rat1N2_Rat2N3 = Dict @((P 3 % 4) ~ ((N 1 % 2) / (N 2 % 3)))+_testSlash_Rat1N2_Rat1N2 = Dict @((P 1 % 1) ~ ((N 1 % 2) / (N 1 % 2)))+_testSlash_Rat1N2_Rat1N3 = Dict @((P 3 % 2) ~ ((N 1 % 2) / (N 1 % 3)))+_testSlash_Rat1N2_Rat1N4 = Dict @((P 2 % 1) ~ ((N 1 % 2) / (N 1 % 4)))+_testSlash_Rat1N2_Rat1P4 = Dict @((N 2 % 1) ~ ((N 1 % 2) / (P 1 % 4)))+_testSlash_Rat1N2_Rat1P3 = Dict @((N 3 % 2) ~ ((N 1 % 2) / (P 1 % 3)))+_testSlash_Rat1N2_Rat1P2 = Dict @((N 1 % 1) ~ ((N 1 % 2) / (P 1 % 2)))+_testSlash_Rat1N2_Rat2P3 = Dict @((N 3 % 4) ~ ((N 1 % 2) / (P 2 % 3)))+_testSlash_Rat1N2_Rat3P4 = Dict @((N 2 % 3) ~ ((N 1 % 2) / (P 3 % 4)))+_testSlash_Rat1N2_Rat1P1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / (P 1 % 1)))+_testSlash_Rat1N2_Rat4P3 = Dict @((N 3 % 8) ~ ((N 1 % 2) / (P 4 % 3)))+_testSlash_Rat1N2_Rat3P2 = Dict @((N 1 % 3) ~ ((N 1 % 2) / (P 3 % 2)))+_testSlash_Rat1N2_Rat2P1 = Dict @((N 1 % 4) ~ ((N 1 % 2) / (P 2 % 1)))+_testSlash_Rat1N2_Rat3P1 = Dict @((N 1 % 6) ~ ((N 1 % 2) / (P 3 % 1)))+_testSlash_Rat1N2_Rat4P1 = Dict @((N 1 % 8) ~ ((N 1 % 2) / (P 4 % 1)))+_testSlash_Rat1N3_Nat1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / 1))+_testSlash_Rat1N3_Nat2 = Dict @((N 1 % 6) ~ ((N 1 % 3) / 2))+_testSlash_Rat1N3_Nat3 = Dict @((N 1 % 9) ~ ((N 1 % 3) / 3))+_testSlash_Rat1N3_Nat4 = Dict @((N 1 % 12) ~ ((N 1 % 3) / 4))+_testSlash_Rat1N3_IntN4 = Dict @((P 1 % 12) ~ ((N 1 % 3) / (N 4)))+_testSlash_Rat1N3_IntN3 = Dict @((P 1 % 9) ~ ((N 1 % 3) / (N 3)))+_testSlash_Rat1N3_IntN2 = Dict @((P 1 % 6) ~ ((N 1 % 3) / (N 2)))+_testSlash_Rat1N3_IntN1 = Dict @((P 1 % 3) ~ ((N 1 % 3) / (N 1)))+_testSlash_Rat1N3_IntP1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / (P 1)))+_testSlash_Rat1N3_IntP2 = Dict @((N 1 % 6) ~ ((N 1 % 3) / (P 2)))+_testSlash_Rat1N3_IntP3 = Dict @((N 1 % 9) ~ ((N 1 % 3) / (P 3)))+_testSlash_Rat1N3_IntP4 = Dict @((N 1 % 12) ~ ((N 1 % 3) / (P 4)))+_testSlash_Rat1N3_Rat4N1 = Dict @((P 1 % 12) ~ ((N 1 % 3) / (N 4 % 1)))+_testSlash_Rat1N3_Rat3N1 = Dict @((P 1 % 9) ~ ((N 1 % 3) / (N 3 % 1)))+_testSlash_Rat1N3_Rat2N1 = Dict @((P 1 % 6) ~ ((N 1 % 3) / (N 2 % 1)))+_testSlash_Rat1N3_Rat3N2 = Dict @((P 2 % 9) ~ ((N 1 % 3) / (N 3 % 2)))+_testSlash_Rat1N3_Rat4N3 = Dict @((P 1 % 4) ~ ((N 1 % 3) / (N 4 % 3)))+_testSlash_Rat1N3_Rat1N1 = Dict @((P 1 % 3) ~ ((N 1 % 3) / (N 1 % 1)))+_testSlash_Rat1N3_Rat3N4 = Dict @((P 4 % 9) ~ ((N 1 % 3) / (N 3 % 4)))+_testSlash_Rat1N3_Rat2N3 = Dict @((P 1 % 2) ~ ((N 1 % 3) / (N 2 % 3)))+_testSlash_Rat1N3_Rat1N2 = Dict @((P 2 % 3) ~ ((N 1 % 3) / (N 1 % 2)))+_testSlash_Rat1N3_Rat1N3 = Dict @((P 1 % 1) ~ ((N 1 % 3) / (N 1 % 3)))+_testSlash_Rat1N3_Rat1N4 = Dict @((P 4 % 3) ~ ((N 1 % 3) / (N 1 % 4)))+_testSlash_Rat1N3_Rat1P4 = Dict @((N 4 % 3) ~ ((N 1 % 3) / (P 1 % 4)))+_testSlash_Rat1N3_Rat1P3 = Dict @((N 1 % 1) ~ ((N 1 % 3) / (P 1 % 3)))+_testSlash_Rat1N3_Rat1P2 = Dict @((N 2 % 3) ~ ((N 1 % 3) / (P 1 % 2)))+_testSlash_Rat1N3_Rat2P3 = Dict @((N 1 % 2) ~ ((N 1 % 3) / (P 2 % 3)))+_testSlash_Rat1N3_Rat3P4 = Dict @((N 4 % 9) ~ ((N 1 % 3) / (P 3 % 4)))+_testSlash_Rat1N3_Rat1P1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / (P 1 % 1)))+_testSlash_Rat1N3_Rat4P3 = Dict @((N 1 % 4) ~ ((N 1 % 3) / (P 4 % 3)))+_testSlash_Rat1N3_Rat3P2 = Dict @((N 2 % 9) ~ ((N 1 % 3) / (P 3 % 2)))+_testSlash_Rat1N3_Rat2P1 = Dict @((N 1 % 6) ~ ((N 1 % 3) / (P 2 % 1)))+_testSlash_Rat1N3_Rat3P1 = Dict @((N 1 % 9) ~ ((N 1 % 3) / (P 3 % 1)))+_testSlash_Rat1N3_Rat4P1 = Dict @((N 1 % 12) ~ ((N 1 % 3) / (P 4 % 1)))+_testSlash_Rat1N4_Nat1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / 1))+_testSlash_Rat1N4_Nat2 = Dict @((N 1 % 8) ~ ((N 1 % 4) / 2))+_testSlash_Rat1N4_Nat3 = Dict @((N 1 % 12) ~ ((N 1 % 4) / 3))+_testSlash_Rat1N4_Nat4 = Dict @((N 1 % 16) ~ ((N 1 % 4) / 4))+_testSlash_Rat1N4_IntN4 = Dict @((P 1 % 16) ~ ((N 1 % 4) / (N 4)))+_testSlash_Rat1N4_IntN3 = Dict @((P 1 % 12) ~ ((N 1 % 4) / (N 3)))+_testSlash_Rat1N4_IntN2 = Dict @((P 1 % 8) ~ ((N 1 % 4) / (N 2)))+_testSlash_Rat1N4_IntN1 = Dict @((P 1 % 4) ~ ((N 1 % 4) / (N 1)))+_testSlash_Rat1N4_IntP1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / (P 1)))+_testSlash_Rat1N4_IntP2 = Dict @((N 1 % 8) ~ ((N 1 % 4) / (P 2)))+_testSlash_Rat1N4_IntP3 = Dict @((N 1 % 12) ~ ((N 1 % 4) / (P 3)))+_testSlash_Rat1N4_IntP4 = Dict @((N 1 % 16) ~ ((N 1 % 4) / (P 4)))+_testSlash_Rat1N4_Rat4N1 = Dict @((P 1 % 16) ~ ((N 1 % 4) / (N 4 % 1)))+_testSlash_Rat1N4_Rat3N1 = Dict @((P 1 % 12) ~ ((N 1 % 4) / (N 3 % 1)))+_testSlash_Rat1N4_Rat2N1 = Dict @((P 1 % 8) ~ ((N 1 % 4) / (N 2 % 1)))+_testSlash_Rat1N4_Rat3N2 = Dict @((P 1 % 6) ~ ((N 1 % 4) / (N 3 % 2)))+_testSlash_Rat1N4_Rat4N3 = Dict @((P 3 % 16) ~ ((N 1 % 4) / (N 4 % 3)))+_testSlash_Rat1N4_Rat1N1 = Dict @((P 1 % 4) ~ ((N 1 % 4) / (N 1 % 1)))+_testSlash_Rat1N4_Rat3N4 = Dict @((P 1 % 3) ~ ((N 1 % 4) / (N 3 % 4)))+_testSlash_Rat1N4_Rat2N3 = Dict @((P 3 % 8) ~ ((N 1 % 4) / (N 2 % 3)))+_testSlash_Rat1N4_Rat1N2 = Dict @((P 1 % 2) ~ ((N 1 % 4) / (N 1 % 2)))+_testSlash_Rat1N4_Rat1N3 = Dict @((P 3 % 4) ~ ((N 1 % 4) / (N 1 % 3)))+_testSlash_Rat1N4_Rat1N4 = Dict @((P 1 % 1) ~ ((N 1 % 4) / (N 1 % 4)))+_testSlash_Rat1N4_Rat1P4 = Dict @((N 1 % 1) ~ ((N 1 % 4) / (P 1 % 4)))+_testSlash_Rat1N4_Rat1P3 = Dict @((N 3 % 4) ~ ((N 1 % 4) / (P 1 % 3)))+_testSlash_Rat1N4_Rat1P2 = Dict @((N 1 % 2) ~ ((N 1 % 4) / (P 1 % 2)))+_testSlash_Rat1N4_Rat2P3 = Dict @((N 3 % 8) ~ ((N 1 % 4) / (P 2 % 3)))+_testSlash_Rat1N4_Rat3P4 = Dict @((N 1 % 3) ~ ((N 1 % 4) / (P 3 % 4)))+_testSlash_Rat1N4_Rat1P1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / (P 1 % 1)))+_testSlash_Rat1N4_Rat4P3 = Dict @((N 3 % 16) ~ ((N 1 % 4) / (P 4 % 3)))+_testSlash_Rat1N4_Rat3P2 = Dict @((N 1 % 6) ~ ((N 1 % 4) / (P 3 % 2)))+_testSlash_Rat1N4_Rat2P1 = Dict @((N 1 % 8) ~ ((N 1 % 4) / (P 2 % 1)))+_testSlash_Rat1N4_Rat3P1 = Dict @((N 1 % 12) ~ ((N 1 % 4) / (P 3 % 1)))+_testSlash_Rat1N4_Rat4P1 = Dict @((N 1 % 16) ~ ((N 1 % 4) / (P 4 % 1)))+_testSlash_Rat0P1_Nat1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 1))+_testSlash_Rat0P1_Nat2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 2))+_testSlash_Rat0P1_Nat3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 3))+_testSlash_Rat0P1_Nat4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 4))+_testSlash_Rat0P1_IntN4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4)))+_testSlash_Rat0P1_IntN3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3)))+_testSlash_Rat0P1_IntN2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2)))+_testSlash_Rat0P1_IntN1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1)))+_testSlash_Rat0P1_IntP1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1)))+_testSlash_Rat0P1_IntP2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2)))+_testSlash_Rat0P1_IntP3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3)))+_testSlash_Rat0P1_IntP4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4)))+_testSlash_Rat0P1_Rat4N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4 % 1)))+_testSlash_Rat0P1_Rat3N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 1)))+_testSlash_Rat0P1_Rat2N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2 % 1)))+_testSlash_Rat0P1_Rat3N2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 2)))+_testSlash_Rat0P1_Rat4N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4 % 3)))+_testSlash_Rat0P1_Rat1N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 1)))+_testSlash_Rat0P1_Rat3N4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 4)))+_testSlash_Rat0P1_Rat2N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2 % 3)))+_testSlash_Rat0P1_Rat1N2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 2)))+_testSlash_Rat0P1_Rat1N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 3)))+_testSlash_Rat0P1_Rat1N4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 4)))+_testSlash_Rat0P1_Rat1P4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 4)))+_testSlash_Rat0P1_Rat1P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 3)))+_testSlash_Rat0P1_Rat1P2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 2)))+_testSlash_Rat0P1_Rat2P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2 % 3)))+_testSlash_Rat0P1_Rat3P4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 4)))+_testSlash_Rat0P1_Rat1P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 1)))+_testSlash_Rat0P1_Rat4P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4 % 3)))+_testSlash_Rat0P1_Rat3P2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 2)))+_testSlash_Rat0P1_Rat2P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2 % 1)))+_testSlash_Rat0P1_Rat3P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 1)))+_testSlash_Rat0P1_Rat4P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4 % 1)))+_testSlash_Rat1P4_Nat1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / 1))+_testSlash_Rat1P4_Nat2 = Dict @((P 1 % 8) ~ ((P 1 % 4) / 2))+_testSlash_Rat1P4_Nat3 = Dict @((P 1 % 12) ~ ((P 1 % 4) / 3))+_testSlash_Rat1P4_Nat4 = Dict @((P 1 % 16) ~ ((P 1 % 4) / 4))+_testSlash_Rat1P4_IntN4 = Dict @((N 1 % 16) ~ ((P 1 % 4) / (N 4)))+_testSlash_Rat1P4_IntN3 = Dict @((N 1 % 12) ~ ((P 1 % 4) / (N 3)))+_testSlash_Rat1P4_IntN2 = Dict @((N 1 % 8) ~ ((P 1 % 4) / (N 2)))+_testSlash_Rat1P4_IntN1 = Dict @((N 1 % 4) ~ ((P 1 % 4) / (N 1)))+_testSlash_Rat1P4_IntP1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / (P 1)))+_testSlash_Rat1P4_IntP2 = Dict @((P 1 % 8) ~ ((P 1 % 4) / (P 2)))+_testSlash_Rat1P4_IntP3 = Dict @((P 1 % 12) ~ ((P 1 % 4) / (P 3)))+_testSlash_Rat1P4_IntP4 = Dict @((P 1 % 16) ~ ((P 1 % 4) / (P 4)))+_testSlash_Rat1P4_Rat4N1 = Dict @((N 1 % 16) ~ ((P 1 % 4) / (N 4 % 1)))+_testSlash_Rat1P4_Rat3N1 = Dict @((N 1 % 12) ~ ((P 1 % 4) / (N 3 % 1)))+_testSlash_Rat1P4_Rat2N1 = Dict @((N 1 % 8) ~ ((P 1 % 4) / (N 2 % 1)))+_testSlash_Rat1P4_Rat3N2 = Dict @((N 1 % 6) ~ ((P 1 % 4) / (N 3 % 2)))+_testSlash_Rat1P4_Rat4N3 = Dict @((N 3 % 16) ~ ((P 1 % 4) / (N 4 % 3)))+_testSlash_Rat1P4_Rat1N1 = Dict @((N 1 % 4) ~ ((P 1 % 4) / (N 1 % 1)))+_testSlash_Rat1P4_Rat3N4 = Dict @((N 1 % 3) ~ ((P 1 % 4) / (N 3 % 4)))+_testSlash_Rat1P4_Rat2N3 = Dict @((N 3 % 8) ~ ((P 1 % 4) / (N 2 % 3)))+_testSlash_Rat1P4_Rat1N2 = Dict @((N 1 % 2) ~ ((P 1 % 4) / (N 1 % 2)))+_testSlash_Rat1P4_Rat1N3 = Dict @((N 3 % 4) ~ ((P 1 % 4) / (N 1 % 3)))+_testSlash_Rat1P4_Rat1N4 = Dict @((N 1 % 1) ~ ((P 1 % 4) / (N 1 % 4)))+_testSlash_Rat1P4_Rat1P4 = Dict @((P 1 % 1) ~ ((P 1 % 4) / (P 1 % 4)))+_testSlash_Rat1P4_Rat1P3 = Dict @((P 3 % 4) ~ ((P 1 % 4) / (P 1 % 3)))+_testSlash_Rat1P4_Rat1P2 = Dict @((P 1 % 2) ~ ((P 1 % 4) / (P 1 % 2)))+_testSlash_Rat1P4_Rat2P3 = Dict @((P 3 % 8) ~ ((P 1 % 4) / (P 2 % 3)))+_testSlash_Rat1P4_Rat3P4 = Dict @((P 1 % 3) ~ ((P 1 % 4) / (P 3 % 4)))+_testSlash_Rat1P4_Rat1P1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / (P 1 % 1)))+_testSlash_Rat1P4_Rat4P3 = Dict @((P 3 % 16) ~ ((P 1 % 4) / (P 4 % 3)))+_testSlash_Rat1P4_Rat3P2 = Dict @((P 1 % 6) ~ ((P 1 % 4) / (P 3 % 2)))+_testSlash_Rat1P4_Rat2P1 = Dict @((P 1 % 8) ~ ((P 1 % 4) / (P 2 % 1)))+_testSlash_Rat1P4_Rat3P1 = Dict @((P 1 % 12) ~ ((P 1 % 4) / (P 3 % 1)))+_testSlash_Rat1P4_Rat4P1 = Dict @((P 1 % 16) ~ ((P 1 % 4) / (P 4 % 1)))+_testSlash_Rat1P3_Nat1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / 1))+_testSlash_Rat1P3_Nat2 = Dict @((P 1 % 6) ~ ((P 1 % 3) / 2))+_testSlash_Rat1P3_Nat3 = Dict @((P 1 % 9) ~ ((P 1 % 3) / 3))+_testSlash_Rat1P3_Nat4 = Dict @((P 1 % 12) ~ ((P 1 % 3) / 4))+_testSlash_Rat1P3_IntN4 = Dict @((N 1 % 12) ~ ((P 1 % 3) / (N 4)))+_testSlash_Rat1P3_IntN3 = Dict @((N 1 % 9) ~ ((P 1 % 3) / (N 3)))+_testSlash_Rat1P3_IntN2 = Dict @((N 1 % 6) ~ ((P 1 % 3) / (N 2)))+_testSlash_Rat1P3_IntN1 = Dict @((N 1 % 3) ~ ((P 1 % 3) / (N 1)))+_testSlash_Rat1P3_IntP1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / (P 1)))+_testSlash_Rat1P3_IntP2 = Dict @((P 1 % 6) ~ ((P 1 % 3) / (P 2)))+_testSlash_Rat1P3_IntP3 = Dict @((P 1 % 9) ~ ((P 1 % 3) / (P 3)))+_testSlash_Rat1P3_IntP4 = Dict @((P 1 % 12) ~ ((P 1 % 3) / (P 4)))+_testSlash_Rat1P3_Rat4N1 = Dict @((N 1 % 12) ~ ((P 1 % 3) / (N 4 % 1)))+_testSlash_Rat1P3_Rat3N1 = Dict @((N 1 % 9) ~ ((P 1 % 3) / (N 3 % 1)))+_testSlash_Rat1P3_Rat2N1 = Dict @((N 1 % 6) ~ ((P 1 % 3) / (N 2 % 1)))+_testSlash_Rat1P3_Rat3N2 = Dict @((N 2 % 9) ~ ((P 1 % 3) / (N 3 % 2)))+_testSlash_Rat1P3_Rat4N3 = Dict @((N 1 % 4) ~ ((P 1 % 3) / (N 4 % 3)))+_testSlash_Rat1P3_Rat1N1 = Dict @((N 1 % 3) ~ ((P 1 % 3) / (N 1 % 1)))+_testSlash_Rat1P3_Rat3N4 = Dict @((N 4 % 9) ~ ((P 1 % 3) / (N 3 % 4)))+_testSlash_Rat1P3_Rat2N3 = Dict @((N 1 % 2) ~ ((P 1 % 3) / (N 2 % 3)))+_testSlash_Rat1P3_Rat1N2 = Dict @((N 2 % 3) ~ ((P 1 % 3) / (N 1 % 2)))+_testSlash_Rat1P3_Rat1N3 = Dict @((N 1 % 1) ~ ((P 1 % 3) / (N 1 % 3)))+_testSlash_Rat1P3_Rat1N4 = Dict @((N 4 % 3) ~ ((P 1 % 3) / (N 1 % 4)))+_testSlash_Rat1P3_Rat1P4 = Dict @((P 4 % 3) ~ ((P 1 % 3) / (P 1 % 4)))+_testSlash_Rat1P3_Rat1P3 = Dict @((P 1 % 1) ~ ((P 1 % 3) / (P 1 % 3)))+_testSlash_Rat1P3_Rat1P2 = Dict @((P 2 % 3) ~ ((P 1 % 3) / (P 1 % 2)))+_testSlash_Rat1P3_Rat2P3 = Dict @((P 1 % 2) ~ ((P 1 % 3) / (P 2 % 3)))+_testSlash_Rat1P3_Rat3P4 = Dict @((P 4 % 9) ~ ((P 1 % 3) / (P 3 % 4)))+_testSlash_Rat1P3_Rat1P1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / (P 1 % 1)))+_testSlash_Rat1P3_Rat4P3 = Dict @((P 1 % 4) ~ ((P 1 % 3) / (P 4 % 3)))+_testSlash_Rat1P3_Rat3P2 = Dict @((P 2 % 9) ~ ((P 1 % 3) / (P 3 % 2)))+_testSlash_Rat1P3_Rat2P1 = Dict @((P 1 % 6) ~ ((P 1 % 3) / (P 2 % 1)))+_testSlash_Rat1P3_Rat3P1 = Dict @((P 1 % 9) ~ ((P 1 % 3) / (P 3 % 1)))+_testSlash_Rat1P3_Rat4P1 = Dict @((P 1 % 12) ~ ((P 1 % 3) / (P 4 % 1)))+_testSlash_Rat1P2_Nat1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / 1))+_testSlash_Rat1P2_Nat2 = Dict @((P 1 % 4) ~ ((P 1 % 2) / 2))+_testSlash_Rat1P2_Nat3 = Dict @((P 1 % 6) ~ ((P 1 % 2) / 3))+_testSlash_Rat1P2_Nat4 = Dict @((P 1 % 8) ~ ((P 1 % 2) / 4))+_testSlash_Rat1P2_IntN4 = Dict @((N 1 % 8) ~ ((P 1 % 2) / (N 4)))+_testSlash_Rat1P2_IntN3 = Dict @((N 1 % 6) ~ ((P 1 % 2) / (N 3)))+_testSlash_Rat1P2_IntN2 = Dict @((N 1 % 4) ~ ((P 1 % 2) / (N 2)))+_testSlash_Rat1P2_IntN1 = Dict @((N 1 % 2) ~ ((P 1 % 2) / (N 1)))+_testSlash_Rat1P2_IntP1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / (P 1)))+_testSlash_Rat1P2_IntP2 = Dict @((P 1 % 4) ~ ((P 1 % 2) / (P 2)))+_testSlash_Rat1P2_IntP3 = Dict @((P 1 % 6) ~ ((P 1 % 2) / (P 3)))+_testSlash_Rat1P2_IntP4 = Dict @((P 1 % 8) ~ ((P 1 % 2) / (P 4)))+_testSlash_Rat1P2_Rat4N1 = Dict @((N 1 % 8) ~ ((P 1 % 2) / (N 4 % 1)))+_testSlash_Rat1P2_Rat3N1 = Dict @((N 1 % 6) ~ ((P 1 % 2) / (N 3 % 1)))+_testSlash_Rat1P2_Rat2N1 = Dict @((N 1 % 4) ~ ((P 1 % 2) / (N 2 % 1)))+_testSlash_Rat1P2_Rat3N2 = Dict @((N 1 % 3) ~ ((P 1 % 2) / (N 3 % 2)))+_testSlash_Rat1P2_Rat4N3 = Dict @((N 3 % 8) ~ ((P 1 % 2) / (N 4 % 3)))+_testSlash_Rat1P2_Rat1N1 = Dict @((N 1 % 2) ~ ((P 1 % 2) / (N 1 % 1)))+_testSlash_Rat1P2_Rat3N4 = Dict @((N 2 % 3) ~ ((P 1 % 2) / (N 3 % 4)))+_testSlash_Rat1P2_Rat2N3 = Dict @((N 3 % 4) ~ ((P 1 % 2) / (N 2 % 3)))+_testSlash_Rat1P2_Rat1N2 = Dict @((N 1 % 1) ~ ((P 1 % 2) / (N 1 % 2)))+_testSlash_Rat1P2_Rat1N3 = Dict @((N 3 % 2) ~ ((P 1 % 2) / (N 1 % 3)))+_testSlash_Rat1P2_Rat1N4 = Dict @((N 2 % 1) ~ ((P 1 % 2) / (N 1 % 4)))+_testSlash_Rat1P2_Rat1P4 = Dict @((P 2 % 1) ~ ((P 1 % 2) / (P 1 % 4)))+_testSlash_Rat1P2_Rat1P3 = Dict @((P 3 % 2) ~ ((P 1 % 2) / (P 1 % 3)))+_testSlash_Rat1P2_Rat1P2 = Dict @((P 1 % 1) ~ ((P 1 % 2) / (P 1 % 2)))+_testSlash_Rat1P2_Rat2P3 = Dict @((P 3 % 4) ~ ((P 1 % 2) / (P 2 % 3)))+_testSlash_Rat1P2_Rat3P4 = Dict @((P 2 % 3) ~ ((P 1 % 2) / (P 3 % 4)))+_testSlash_Rat1P2_Rat1P1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / (P 1 % 1)))+_testSlash_Rat1P2_Rat4P3 = Dict @((P 3 % 8) ~ ((P 1 % 2) / (P 4 % 3)))+_testSlash_Rat1P2_Rat3P2 = Dict @((P 1 % 3) ~ ((P 1 % 2) / (P 3 % 2)))+_testSlash_Rat1P2_Rat2P1 = Dict @((P 1 % 4) ~ ((P 1 % 2) / (P 2 % 1)))+_testSlash_Rat1P2_Rat3P1 = Dict @((P 1 % 6) ~ ((P 1 % 2) / (P 3 % 1)))+_testSlash_Rat1P2_Rat4P1 = Dict @((P 1 % 8) ~ ((P 1 % 2) / (P 4 % 1)))+_testSlash_Rat2P3_Nat1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / 1))+_testSlash_Rat2P3_Nat2 = Dict @((P 1 % 3) ~ ((P 2 % 3) / 2))+_testSlash_Rat2P3_Nat3 = Dict @((P 2 % 9) ~ ((P 2 % 3) / 3))+_testSlash_Rat2P3_Nat4 = Dict @((P 1 % 6) ~ ((P 2 % 3) / 4))+_testSlash_Rat2P3_IntN4 = Dict @((N 1 % 6) ~ ((P 2 % 3) / (N 4)))+_testSlash_Rat2P3_IntN3 = Dict @((N 2 % 9) ~ ((P 2 % 3) / (N 3)))+_testSlash_Rat2P3_IntN2 = Dict @((N 1 % 3) ~ ((P 2 % 3) / (N 2)))+_testSlash_Rat2P3_IntN1 = Dict @((N 2 % 3) ~ ((P 2 % 3) / (N 1)))+_testSlash_Rat2P3_IntP1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / (P 1)))+_testSlash_Rat2P3_IntP2 = Dict @((P 1 % 3) ~ ((P 2 % 3) / (P 2)))+_testSlash_Rat2P3_IntP3 = Dict @((P 2 % 9) ~ ((P 2 % 3) / (P 3)))+_testSlash_Rat2P3_IntP4 = Dict @((P 1 % 6) ~ ((P 2 % 3) / (P 4)))+_testSlash_Rat2P3_Rat4N1 = Dict @((N 1 % 6) ~ ((P 2 % 3) / (N 4 % 1)))+_testSlash_Rat2P3_Rat3N1 = Dict @((N 2 % 9) ~ ((P 2 % 3) / (N 3 % 1)))+_testSlash_Rat2P3_Rat2N1 = Dict @((N 1 % 3) ~ ((P 2 % 3) / (N 2 % 1)))+_testSlash_Rat2P3_Rat3N2 = Dict @((N 4 % 9) ~ ((P 2 % 3) / (N 3 % 2)))+_testSlash_Rat2P3_Rat4N3 = Dict @((N 1 % 2) ~ ((P 2 % 3) / (N 4 % 3)))+_testSlash_Rat2P3_Rat1N1 = Dict @((N 2 % 3) ~ ((P 2 % 3) / (N 1 % 1)))+_testSlash_Rat2P3_Rat3N4 = Dict @((N 8 % 9) ~ ((P 2 % 3) / (N 3 % 4)))+_testSlash_Rat2P3_Rat2N3 = Dict @((N 1 % 1) ~ ((P 2 % 3) / (N 2 % 3)))+_testSlash_Rat2P3_Rat1N2 = Dict @((N 4 % 3) ~ ((P 2 % 3) / (N 1 % 2)))+_testSlash_Rat2P3_Rat1N3 = Dict @((N 2 % 1) ~ ((P 2 % 3) / (N 1 % 3)))+_testSlash_Rat2P3_Rat1N4 = Dict @((N 8 % 3) ~ ((P 2 % 3) / (N 1 % 4)))+_testSlash_Rat2P3_Rat1P4 = Dict @((P 8 % 3) ~ ((P 2 % 3) / (P 1 % 4)))+_testSlash_Rat2P3_Rat1P3 = Dict @((P 2 % 1) ~ ((P 2 % 3) / (P 1 % 3)))+_testSlash_Rat2P3_Rat1P2 = Dict @((P 4 % 3) ~ ((P 2 % 3) / (P 1 % 2)))+_testSlash_Rat2P3_Rat2P3 = Dict @((P 1 % 1) ~ ((P 2 % 3) / (P 2 % 3)))+_testSlash_Rat2P3_Rat3P4 = Dict @((P 8 % 9) ~ ((P 2 % 3) / (P 3 % 4)))+_testSlash_Rat2P3_Rat1P1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / (P 1 % 1)))+_testSlash_Rat2P3_Rat4P3 = Dict @((P 1 % 2) ~ ((P 2 % 3) / (P 4 % 3)))+_testSlash_Rat2P3_Rat3P2 = Dict @((P 4 % 9) ~ ((P 2 % 3) / (P 3 % 2)))+_testSlash_Rat2P3_Rat2P1 = Dict @((P 1 % 3) ~ ((P 2 % 3) / (P 2 % 1)))+_testSlash_Rat2P3_Rat3P1 = Dict @((P 2 % 9) ~ ((P 2 % 3) / (P 3 % 1)))+_testSlash_Rat2P3_Rat4P1 = Dict @((P 1 % 6) ~ ((P 2 % 3) / (P 4 % 1)))+_testSlash_Rat3P4_Nat1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / 1))+_testSlash_Rat3P4_Nat2 = Dict @((P 3 % 8) ~ ((P 3 % 4) / 2))+_testSlash_Rat3P4_Nat3 = Dict @((P 1 % 4) ~ ((P 3 % 4) / 3))+_testSlash_Rat3P4_Nat4 = Dict @((P 3 % 16) ~ ((P 3 % 4) / 4))+_testSlash_Rat3P4_IntN4 = Dict @((N 3 % 16) ~ ((P 3 % 4) / (N 4)))+_testSlash_Rat3P4_IntN3 = Dict @((N 1 % 4) ~ ((P 3 % 4) / (N 3)))+_testSlash_Rat3P4_IntN2 = Dict @((N 3 % 8) ~ ((P 3 % 4) / (N 2)))+_testSlash_Rat3P4_IntN1 = Dict @((N 3 % 4) ~ ((P 3 % 4) / (N 1)))+_testSlash_Rat3P4_IntP1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / (P 1)))+_testSlash_Rat3P4_IntP2 = Dict @((P 3 % 8) ~ ((P 3 % 4) / (P 2)))+_testSlash_Rat3P4_IntP3 = Dict @((P 1 % 4) ~ ((P 3 % 4) / (P 3)))+_testSlash_Rat3P4_IntP4 = Dict @((P 3 % 16) ~ ((P 3 % 4) / (P 4)))+_testSlash_Rat3P4_Rat4N1 = Dict @((N 3 % 16) ~ ((P 3 % 4) / (N 4 % 1)))+_testSlash_Rat3P4_Rat3N1 = Dict @((N 1 % 4) ~ ((P 3 % 4) / (N 3 % 1)))+_testSlash_Rat3P4_Rat2N1 = Dict @((N 3 % 8) ~ ((P 3 % 4) / (N 2 % 1)))+_testSlash_Rat3P4_Rat3N2 = Dict @((N 1 % 2) ~ ((P 3 % 4) / (N 3 % 2)))+_testSlash_Rat3P4_Rat4N3 = Dict @((N 9 % 16) ~ ((P 3 % 4) / (N 4 % 3)))+_testSlash_Rat3P4_Rat1N1 = Dict @((N 3 % 4) ~ ((P 3 % 4) / (N 1 % 1)))+_testSlash_Rat3P4_Rat3N4 = Dict @((N 1 % 1) ~ ((P 3 % 4) / (N 3 % 4)))+_testSlash_Rat3P4_Rat2N3 = Dict @((N 9 % 8) ~ ((P 3 % 4) / (N 2 % 3)))+_testSlash_Rat3P4_Rat1N2 = Dict @((N 3 % 2) ~ ((P 3 % 4) / (N 1 % 2)))+_testSlash_Rat3P4_Rat1N3 = Dict @((N 9 % 4) ~ ((P 3 % 4) / (N 1 % 3)))+_testSlash_Rat3P4_Rat1N4 = Dict @((N 3 % 1) ~ ((P 3 % 4) / (N 1 % 4)))+_testSlash_Rat3P4_Rat1P4 = Dict @((P 3 % 1) ~ ((P 3 % 4) / (P 1 % 4)))+_testSlash_Rat3P4_Rat1P3 = Dict @((P 9 % 4) ~ ((P 3 % 4) / (P 1 % 3)))+_testSlash_Rat3P4_Rat1P2 = Dict @((P 3 % 2) ~ ((P 3 % 4) / (P 1 % 2)))+_testSlash_Rat3P4_Rat2P3 = Dict @((P 9 % 8) ~ ((P 3 % 4) / (P 2 % 3)))+_testSlash_Rat3P4_Rat3P4 = Dict @((P 1 % 1) ~ ((P 3 % 4) / (P 3 % 4)))+_testSlash_Rat3P4_Rat1P1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / (P 1 % 1)))+_testSlash_Rat3P4_Rat4P3 = Dict @((P 9 % 16) ~ ((P 3 % 4) / (P 4 % 3)))+_testSlash_Rat3P4_Rat3P2 = Dict @((P 1 % 2) ~ ((P 3 % 4) / (P 3 % 2)))+_testSlash_Rat3P4_Rat2P1 = Dict @((P 3 % 8) ~ ((P 3 % 4) / (P 2 % 1)))+_testSlash_Rat3P4_Rat3P1 = Dict @((P 1 % 4) ~ ((P 3 % 4) / (P 3 % 1)))+_testSlash_Rat3P4_Rat4P1 = Dict @((P 3 % 16) ~ ((P 3 % 4) / (P 4 % 1)))+_testSlash_Rat1P1_Nat1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / 1))+_testSlash_Rat1P1_Nat2 = Dict @((P 1 % 2) ~ ((P 1 % 1) / 2))+_testSlash_Rat1P1_Nat3 = Dict @((P 1 % 3) ~ ((P 1 % 1) / 3))+_testSlash_Rat1P1_Nat4 = Dict @((P 1 % 4) ~ ((P 1 % 1) / 4))+_testSlash_Rat1P1_IntN4 = Dict @((N 1 % 4) ~ ((P 1 % 1) / (N 4)))+_testSlash_Rat1P1_IntN3 = Dict @((N 1 % 3) ~ ((P 1 % 1) / (N 3)))+_testSlash_Rat1P1_IntN2 = Dict @((N 1 % 2) ~ ((P 1 % 1) / (N 2)))+_testSlash_Rat1P1_IntN1 = Dict @((N 1 % 1) ~ ((P 1 % 1) / (N 1)))+_testSlash_Rat1P1_IntP1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / (P 1)))+_testSlash_Rat1P1_IntP2 = Dict @((P 1 % 2) ~ ((P 1 % 1) / (P 2)))+_testSlash_Rat1P1_IntP3 = Dict @((P 1 % 3) ~ ((P 1 % 1) / (P 3)))+_testSlash_Rat1P1_IntP4 = Dict @((P 1 % 4) ~ ((P 1 % 1) / (P 4)))+_testSlash_Rat1P1_Rat4N1 = Dict @((N 1 % 4) ~ ((P 1 % 1) / (N 4 % 1)))+_testSlash_Rat1P1_Rat3N1 = Dict @((N 1 % 3) ~ ((P 1 % 1) / (N 3 % 1)))+_testSlash_Rat1P1_Rat2N1 = Dict @((N 1 % 2) ~ ((P 1 % 1) / (N 2 % 1)))+_testSlash_Rat1P1_Rat3N2 = Dict @((N 2 % 3) ~ ((P 1 % 1) / (N 3 % 2)))+_testSlash_Rat1P1_Rat4N3 = Dict @((N 3 % 4) ~ ((P 1 % 1) / (N 4 % 3)))+_testSlash_Rat1P1_Rat1N1 = Dict @((N 1 % 1) ~ ((P 1 % 1) / (N 1 % 1)))+_testSlash_Rat1P1_Rat3N4 = Dict @((N 4 % 3) ~ ((P 1 % 1) / (N 3 % 4)))+_testSlash_Rat1P1_Rat2N3 = Dict @((N 3 % 2) ~ ((P 1 % 1) / (N 2 % 3)))+_testSlash_Rat1P1_Rat1N2 = Dict @((N 2 % 1) ~ ((P 1 % 1) / (N 1 % 2)))+_testSlash_Rat1P1_Rat1N3 = Dict @((N 3 % 1) ~ ((P 1 % 1) / (N 1 % 3)))+_testSlash_Rat1P1_Rat1N4 = Dict @((N 4 % 1) ~ ((P 1 % 1) / (N 1 % 4)))+_testSlash_Rat1P1_Rat1P4 = Dict @((P 4 % 1) ~ ((P 1 % 1) / (P 1 % 4)))+_testSlash_Rat1P1_Rat1P3 = Dict @((P 3 % 1) ~ ((P 1 % 1) / (P 1 % 3)))+_testSlash_Rat1P1_Rat1P2 = Dict @((P 2 % 1) ~ ((P 1 % 1) / (P 1 % 2)))+_testSlash_Rat1P1_Rat2P3 = Dict @((P 3 % 2) ~ ((P 1 % 1) / (P 2 % 3)))+_testSlash_Rat1P1_Rat3P4 = Dict @((P 4 % 3) ~ ((P 1 % 1) / (P 3 % 4)))+_testSlash_Rat1P1_Rat1P1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / (P 1 % 1)))+_testSlash_Rat1P1_Rat4P3 = Dict @((P 3 % 4) ~ ((P 1 % 1) / (P 4 % 3)))+_testSlash_Rat1P1_Rat3P2 = Dict @((P 2 % 3) ~ ((P 1 % 1) / (P 3 % 2)))+_testSlash_Rat1P1_Rat2P1 = Dict @((P 1 % 2) ~ ((P 1 % 1) / (P 2 % 1)))+_testSlash_Rat1P1_Rat3P1 = Dict @((P 1 % 3) ~ ((P 1 % 1) / (P 3 % 1)))+_testSlash_Rat1P1_Rat4P1 = Dict @((P 1 % 4) ~ ((P 1 % 1) / (P 4 % 1)))+_testSlash_Rat4P3_Nat1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / 1))+_testSlash_Rat4P3_Nat2 = Dict @((P 2 % 3) ~ ((P 4 % 3) / 2))+_testSlash_Rat4P3_Nat3 = Dict @((P 4 % 9) ~ ((P 4 % 3) / 3))+_testSlash_Rat4P3_Nat4 = Dict @((P 1 % 3) ~ ((P 4 % 3) / 4))+_testSlash_Rat4P3_IntN4 = Dict @((N 1 % 3) ~ ((P 4 % 3) / (N 4)))+_testSlash_Rat4P3_IntN3 = Dict @((N 4 % 9) ~ ((P 4 % 3) / (N 3)))+_testSlash_Rat4P3_IntN2 = Dict @((N 2 % 3) ~ ((P 4 % 3) / (N 2)))+_testSlash_Rat4P3_IntN1 = Dict @((N 4 % 3) ~ ((P 4 % 3) / (N 1)))+_testSlash_Rat4P3_IntP1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / (P 1)))+_testSlash_Rat4P3_IntP2 = Dict @((P 2 % 3) ~ ((P 4 % 3) / (P 2)))+_testSlash_Rat4P3_IntP3 = Dict @((P 4 % 9) ~ ((P 4 % 3) / (P 3)))+_testSlash_Rat4P3_IntP4 = Dict @((P 1 % 3) ~ ((P 4 % 3) / (P 4)))+_testSlash_Rat4P3_Rat4N1 = Dict @((N 1 % 3) ~ ((P 4 % 3) / (N 4 % 1)))+_testSlash_Rat4P3_Rat3N1 = Dict @((N 4 % 9) ~ ((P 4 % 3) / (N 3 % 1)))+_testSlash_Rat4P3_Rat2N1 = Dict @((N 2 % 3) ~ ((P 4 % 3) / (N 2 % 1)))+_testSlash_Rat4P3_Rat3N2 = Dict @((N 8 % 9) ~ ((P 4 % 3) / (N 3 % 2)))+_testSlash_Rat4P3_Rat4N3 = Dict @((N 1 % 1) ~ ((P 4 % 3) / (N 4 % 3)))+_testSlash_Rat4P3_Rat1N1 = Dict @((N 4 % 3) ~ ((P 4 % 3) / (N 1 % 1)))+_testSlash_Rat4P3_Rat3N4 = Dict @((N 16 % 9) ~ ((P 4 % 3) / (N 3 % 4)))+_testSlash_Rat4P3_Rat2N3 = Dict @((N 2 % 1) ~ ((P 4 % 3) / (N 2 % 3)))+_testSlash_Rat4P3_Rat1N2 = Dict @((N 8 % 3) ~ ((P 4 % 3) / (N 1 % 2)))+_testSlash_Rat4P3_Rat1N3 = Dict @((N 4 % 1) ~ ((P 4 % 3) / (N 1 % 3)))+_testSlash_Rat4P3_Rat1N4 = Dict @((N 16 % 3) ~ ((P 4 % 3) / (N 1 % 4)))+_testSlash_Rat4P3_Rat1P4 = Dict @((P 16 % 3) ~ ((P 4 % 3) / (P 1 % 4)))+_testSlash_Rat4P3_Rat1P3 = Dict @((P 4 % 1) ~ ((P 4 % 3) / (P 1 % 3)))+_testSlash_Rat4P3_Rat1P2 = Dict @((P 8 % 3) ~ ((P 4 % 3) / (P 1 % 2)))+_testSlash_Rat4P3_Rat2P3 = Dict @((P 2 % 1) ~ ((P 4 % 3) / (P 2 % 3)))+_testSlash_Rat4P3_Rat3P4 = Dict @((P 16 % 9) ~ ((P 4 % 3) / (P 3 % 4)))+_testSlash_Rat4P3_Rat1P1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / (P 1 % 1)))+_testSlash_Rat4P3_Rat4P3 = Dict @((P 1 % 1) ~ ((P 4 % 3) / (P 4 % 3)))+_testSlash_Rat4P3_Rat3P2 = Dict @((P 8 % 9) ~ ((P 4 % 3) / (P 3 % 2)))+_testSlash_Rat4P3_Rat2P1 = Dict @((P 2 % 3) ~ ((P 4 % 3) / (P 2 % 1)))+_testSlash_Rat4P3_Rat3P1 = Dict @((P 4 % 9) ~ ((P 4 % 3) / (P 3 % 1)))+_testSlash_Rat4P3_Rat4P1 = Dict @((P 1 % 3) ~ ((P 4 % 3) / (P 4 % 1)))+_testSlash_Rat3P2_Nat1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / 1))+_testSlash_Rat3P2_Nat2 = Dict @((P 3 % 4) ~ ((P 3 % 2) / 2))+_testSlash_Rat3P2_Nat3 = Dict @((P 1 % 2) ~ ((P 3 % 2) / 3))+_testSlash_Rat3P2_Nat4 = Dict @((P 3 % 8) ~ ((P 3 % 2) / 4))+_testSlash_Rat3P2_IntN4 = Dict @((N 3 % 8) ~ ((P 3 % 2) / (N 4)))+_testSlash_Rat3P2_IntN3 = Dict @((N 1 % 2) ~ ((P 3 % 2) / (N 3)))+_testSlash_Rat3P2_IntN2 = Dict @((N 3 % 4) ~ ((P 3 % 2) / (N 2)))+_testSlash_Rat3P2_IntN1 = Dict @((N 3 % 2) ~ ((P 3 % 2) / (N 1)))+_testSlash_Rat3P2_IntP1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / (P 1)))+_testSlash_Rat3P2_IntP2 = Dict @((P 3 % 4) ~ ((P 3 % 2) / (P 2)))+_testSlash_Rat3P2_IntP3 = Dict @((P 1 % 2) ~ ((P 3 % 2) / (P 3)))+_testSlash_Rat3P2_IntP4 = Dict @((P 3 % 8) ~ ((P 3 % 2) / (P 4)))+_testSlash_Rat3P2_Rat4N1 = Dict @((N 3 % 8) ~ ((P 3 % 2) / (N 4 % 1)))+_testSlash_Rat3P2_Rat3N1 = Dict @((N 1 % 2) ~ ((P 3 % 2) / (N 3 % 1)))+_testSlash_Rat3P2_Rat2N1 = Dict @((N 3 % 4) ~ ((P 3 % 2) / (N 2 % 1)))+_testSlash_Rat3P2_Rat3N2 = Dict @((N 1 % 1) ~ ((P 3 % 2) / (N 3 % 2)))+_testSlash_Rat3P2_Rat4N3 = Dict @((N 9 % 8) ~ ((P 3 % 2) / (N 4 % 3)))+_testSlash_Rat3P2_Rat1N1 = Dict @((N 3 % 2) ~ ((P 3 % 2) / (N 1 % 1)))+_testSlash_Rat3P2_Rat3N4 = Dict @((N 2 % 1) ~ ((P 3 % 2) / (N 3 % 4)))+_testSlash_Rat3P2_Rat2N3 = Dict @((N 9 % 4) ~ ((P 3 % 2) / (N 2 % 3)))+_testSlash_Rat3P2_Rat1N2 = Dict @((N 3 % 1) ~ ((P 3 % 2) / (N 1 % 2)))+_testSlash_Rat3P2_Rat1N3 = Dict @((N 9 % 2) ~ ((P 3 % 2) / (N 1 % 3)))+_testSlash_Rat3P2_Rat1N4 = Dict @((N 6 % 1) ~ ((P 3 % 2) / (N 1 % 4)))+_testSlash_Rat3P2_Rat1P4 = Dict @((P 6 % 1) ~ ((P 3 % 2) / (P 1 % 4)))+_testSlash_Rat3P2_Rat1P3 = Dict @((P 9 % 2) ~ ((P 3 % 2) / (P 1 % 3)))+_testSlash_Rat3P2_Rat1P2 = Dict @((P 3 % 1) ~ ((P 3 % 2) / (P 1 % 2)))+_testSlash_Rat3P2_Rat2P3 = Dict @((P 9 % 4) ~ ((P 3 % 2) / (P 2 % 3)))+_testSlash_Rat3P2_Rat3P4 = Dict @((P 2 % 1) ~ ((P 3 % 2) / (P 3 % 4)))+_testSlash_Rat3P2_Rat1P1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / (P 1 % 1)))+_testSlash_Rat3P2_Rat4P3 = Dict @((P 9 % 8) ~ ((P 3 % 2) / (P 4 % 3)))+_testSlash_Rat3P2_Rat3P2 = Dict @((P 1 % 1) ~ ((P 3 % 2) / (P 3 % 2)))+_testSlash_Rat3P2_Rat2P1 = Dict @((P 3 % 4) ~ ((P 3 % 2) / (P 2 % 1)))+_testSlash_Rat3P2_Rat3P1 = Dict @((P 1 % 2) ~ ((P 3 % 2) / (P 3 % 1)))+_testSlash_Rat3P2_Rat4P1 = Dict @((P 3 % 8) ~ ((P 3 % 2) / (P 4 % 1)))+_testSlash_Rat2P1_Nat1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / 1))+_testSlash_Rat2P1_Nat2 = Dict @((P 1 % 1) ~ ((P 2 % 1) / 2))+_testSlash_Rat2P1_Nat3 = Dict @((P 2 % 3) ~ ((P 2 % 1) / 3))+_testSlash_Rat2P1_Nat4 = Dict @((P 1 % 2) ~ ((P 2 % 1) / 4))+_testSlash_Rat2P1_IntN4 = Dict @((N 1 % 2) ~ ((P 2 % 1) / (N 4)))+_testSlash_Rat2P1_IntN3 = Dict @((N 2 % 3) ~ ((P 2 % 1) / (N 3)))+_testSlash_Rat2P1_IntN2 = Dict @((N 1 % 1) ~ ((P 2 % 1) / (N 2)))+_testSlash_Rat2P1_IntN1 = Dict @((N 2 % 1) ~ ((P 2 % 1) / (N 1)))+_testSlash_Rat2P1_IntP1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / (P 1)))+_testSlash_Rat2P1_IntP2 = Dict @((P 1 % 1) ~ ((P 2 % 1) / (P 2)))+_testSlash_Rat2P1_IntP3 = Dict @((P 2 % 3) ~ ((P 2 % 1) / (P 3)))+_testSlash_Rat2P1_IntP4 = Dict @((P 1 % 2) ~ ((P 2 % 1) / (P 4)))+_testSlash_Rat2P1_Rat4N1 = Dict @((N 1 % 2) ~ ((P 2 % 1) / (N 4 % 1)))+_testSlash_Rat2P1_Rat3N1 = Dict @((N 2 % 3) ~ ((P 2 % 1) / (N 3 % 1)))+_testSlash_Rat2P1_Rat2N1 = Dict @((N 1 % 1) ~ ((P 2 % 1) / (N 2 % 1)))+_testSlash_Rat2P1_Rat3N2 = Dict @((N 4 % 3) ~ ((P 2 % 1) / (N 3 % 2)))+_testSlash_Rat2P1_Rat4N3 = Dict @((N 3 % 2) ~ ((P 2 % 1) / (N 4 % 3)))+_testSlash_Rat2P1_Rat1N1 = Dict @((N 2 % 1) ~ ((P 2 % 1) / (N 1 % 1)))+_testSlash_Rat2P1_Rat3N4 = Dict @((N 8 % 3) ~ ((P 2 % 1) / (N 3 % 4)))+_testSlash_Rat2P1_Rat2N3 = Dict @((N 3 % 1) ~ ((P 2 % 1) / (N 2 % 3)))+_testSlash_Rat2P1_Rat1N2 = Dict @((N 4 % 1) ~ ((P 2 % 1) / (N 1 % 2)))+_testSlash_Rat2P1_Rat1N3 = Dict @((N 6 % 1) ~ ((P 2 % 1) / (N 1 % 3)))+_testSlash_Rat2P1_Rat1N4 = Dict @((N 8 % 1) ~ ((P 2 % 1) / (N 1 % 4)))+_testSlash_Rat2P1_Rat1P4 = Dict @((P 8 % 1) ~ ((P 2 % 1) / (P 1 % 4)))+_testSlash_Rat2P1_Rat1P3 = Dict @((P 6 % 1) ~ ((P 2 % 1) / (P 1 % 3)))+_testSlash_Rat2P1_Rat1P2 = Dict @((P 4 % 1) ~ ((P 2 % 1) / (P 1 % 2)))+_testSlash_Rat2P1_Rat2P3 = Dict @((P 3 % 1) ~ ((P 2 % 1) / (P 2 % 3)))+_testSlash_Rat2P1_Rat3P4 = Dict @((P 8 % 3) ~ ((P 2 % 1) / (P 3 % 4)))+_testSlash_Rat2P1_Rat1P1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / (P 1 % 1)))+_testSlash_Rat2P1_Rat4P3 = Dict @((P 3 % 2) ~ ((P 2 % 1) / (P 4 % 3)))+_testSlash_Rat2P1_Rat3P2 = Dict @((P 4 % 3) ~ ((P 2 % 1) / (P 3 % 2)))+_testSlash_Rat2P1_Rat2P1 = Dict @((P 1 % 1) ~ ((P 2 % 1) / (P 2 % 1)))+_testSlash_Rat2P1_Rat3P1 = Dict @((P 2 % 3) ~ ((P 2 % 1) / (P 3 % 1)))+_testSlash_Rat2P1_Rat4P1 = Dict @((P 1 % 2) ~ ((P 2 % 1) / (P 4 % 1)))+_testSlash_Rat3P1_Nat1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / 1))+_testSlash_Rat3P1_Nat2 = Dict @((P 3 % 2) ~ ((P 3 % 1) / 2))+_testSlash_Rat3P1_Nat3 = Dict @((P 1 % 1) ~ ((P 3 % 1) / 3))+_testSlash_Rat3P1_Nat4 = Dict @((P 3 % 4) ~ ((P 3 % 1) / 4))+_testSlash_Rat3P1_IntN4 = Dict @((N 3 % 4) ~ ((P 3 % 1) / (N 4)))+_testSlash_Rat3P1_IntN3 = Dict @((N 1 % 1) ~ ((P 3 % 1) / (N 3)))+_testSlash_Rat3P1_IntN2 = Dict @((N 3 % 2) ~ ((P 3 % 1) / (N 2)))+_testSlash_Rat3P1_IntN1 = Dict @((N 3 % 1) ~ ((P 3 % 1) / (N 1)))+_testSlash_Rat3P1_IntP1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / (P 1)))+_testSlash_Rat3P1_IntP2 = Dict @((P 3 % 2) ~ ((P 3 % 1) / (P 2)))+_testSlash_Rat3P1_IntP3 = Dict @((P 1 % 1) ~ ((P 3 % 1) / (P 3)))+_testSlash_Rat3P1_IntP4 = Dict @((P 3 % 4) ~ ((P 3 % 1) / (P 4)))+_testSlash_Rat3P1_Rat4N1 = Dict @((N 3 % 4) ~ ((P 3 % 1) / (N 4 % 1)))+_testSlash_Rat3P1_Rat3N1 = Dict @((N 1 % 1) ~ ((P 3 % 1) / (N 3 % 1)))+_testSlash_Rat3P1_Rat2N1 = Dict @((N 3 % 2) ~ ((P 3 % 1) / (N 2 % 1)))+_testSlash_Rat3P1_Rat3N2 = Dict @((N 2 % 1) ~ ((P 3 % 1) / (N 3 % 2)))+_testSlash_Rat3P1_Rat4N3 = Dict @((N 9 % 4) ~ ((P 3 % 1) / (N 4 % 3)))+_testSlash_Rat3P1_Rat1N1 = Dict @((N 3 % 1) ~ ((P 3 % 1) / (N 1 % 1)))+_testSlash_Rat3P1_Rat3N4 = Dict @((N 4 % 1) ~ ((P 3 % 1) / (N 3 % 4)))+_testSlash_Rat3P1_Rat2N3 = Dict @((N 9 % 2) ~ ((P 3 % 1) / (N 2 % 3)))+_testSlash_Rat3P1_Rat1N2 = Dict @((N 6 % 1) ~ ((P 3 % 1) / (N 1 % 2)))+_testSlash_Rat3P1_Rat1N3 = Dict @((N 9 % 1) ~ ((P 3 % 1) / (N 1 % 3)))+_testSlash_Rat3P1_Rat1N4 = Dict @((N 12 % 1) ~ ((P 3 % 1) / (N 1 % 4)))+_testSlash_Rat3P1_Rat1P4 = Dict @((P 12 % 1) ~ ((P 3 % 1) / (P 1 % 4)))+_testSlash_Rat3P1_Rat1P3 = Dict @((P 9 % 1) ~ ((P 3 % 1) / (P 1 % 3)))+_testSlash_Rat3P1_Rat1P2 = Dict @((P 6 % 1) ~ ((P 3 % 1) / (P 1 % 2)))+_testSlash_Rat3P1_Rat2P3 = Dict @((P 9 % 2) ~ ((P 3 % 1) / (P 2 % 3)))+_testSlash_Rat3P1_Rat3P4 = Dict @((P 4 % 1) ~ ((P 3 % 1) / (P 3 % 4)))+_testSlash_Rat3P1_Rat1P1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / (P 1 % 1)))+_testSlash_Rat3P1_Rat4P3 = Dict @((P 9 % 4) ~ ((P 3 % 1) / (P 4 % 3)))+_testSlash_Rat3P1_Rat3P2 = Dict @((P 2 % 1) ~ ((P 3 % 1) / (P 3 % 2)))+_testSlash_Rat3P1_Rat2P1 = Dict @((P 3 % 2) ~ ((P 3 % 1) / (P 2 % 1)))+_testSlash_Rat3P1_Rat3P1 = Dict @((P 1 % 1) ~ ((P 3 % 1) / (P 3 % 1)))+_testSlash_Rat3P1_Rat4P1 = Dict @((P 3 % 4) ~ ((P 3 % 1) / (P 4 % 1)))+_testSlash_Rat4P1_Nat1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / 1))+_testSlash_Rat4P1_Nat2 = Dict @((P 2 % 1) ~ ((P 4 % 1) / 2))+_testSlash_Rat4P1_Nat3 = Dict @((P 4 % 3) ~ ((P 4 % 1) / 3))+_testSlash_Rat4P1_Nat4 = Dict @((P 1 % 1) ~ ((P 4 % 1) / 4))+_testSlash_Rat4P1_IntN4 = Dict @((N 1 % 1) ~ ((P 4 % 1) / (N 4)))+_testSlash_Rat4P1_IntN3 = Dict @((N 4 % 3) ~ ((P 4 % 1) / (N 3)))+_testSlash_Rat4P1_IntN2 = Dict @((N 2 % 1) ~ ((P 4 % 1) / (N 2)))+_testSlash_Rat4P1_IntN1 = Dict @((N 4 % 1) ~ ((P 4 % 1) / (N 1)))+_testSlash_Rat4P1_IntP1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / (P 1)))+_testSlash_Rat4P1_IntP2 = Dict @((P 2 % 1) ~ ((P 4 % 1) / (P 2)))+_testSlash_Rat4P1_IntP3 = Dict @((P 4 % 3) ~ ((P 4 % 1) / (P 3)))+_testSlash_Rat4P1_IntP4 = Dict @((P 1 % 1) ~ ((P 4 % 1) / (P 4)))+_testSlash_Rat4P1_Rat4N1 = Dict @((N 1 % 1) ~ ((P 4 % 1) / (N 4 % 1)))+_testSlash_Rat4P1_Rat3N1 = Dict @((N 4 % 3) ~ ((P 4 % 1) / (N 3 % 1)))+_testSlash_Rat4P1_Rat2N1 = Dict @((N 2 % 1) ~ ((P 4 % 1) / (N 2 % 1)))+_testSlash_Rat4P1_Rat3N2 = Dict @((N 8 % 3) ~ ((P 4 % 1) / (N 3 % 2)))+_testSlash_Rat4P1_Rat4N3 = Dict @((N 3 % 1) ~ ((P 4 % 1) / (N 4 % 3)))+_testSlash_Rat4P1_Rat1N1 = Dict @((N 4 % 1) ~ ((P 4 % 1) / (N 1 % 1)))+_testSlash_Rat4P1_Rat3N4 = Dict @((N 16 % 3) ~ ((P 4 % 1) / (N 3 % 4)))+_testSlash_Rat4P1_Rat2N3 = Dict @((N 6 % 1) ~ ((P 4 % 1) / (N 2 % 3)))+_testSlash_Rat4P1_Rat1N2 = Dict @((N 8 % 1) ~ ((P 4 % 1) / (N 1 % 2)))+_testSlash_Rat4P1_Rat1N3 = Dict @((N 12 % 1) ~ ((P 4 % 1) / (N 1 % 3)))+_testSlash_Rat4P1_Rat1N4 = Dict @((N 16 % 1) ~ ((P 4 % 1) / (N 1 % 4)))+_testSlash_Rat4P1_Rat1P4 = Dict @((P 16 % 1) ~ ((P 4 % 1) / (P 1 % 4)))+_testSlash_Rat4P1_Rat1P3 = Dict @((P 12 % 1) ~ ((P 4 % 1) / (P 1 % 3)))+_testSlash_Rat4P1_Rat1P2 = Dict @((P 8 % 1) ~ ((P 4 % 1) / (P 1 % 2)))+_testSlash_Rat4P1_Rat2P3 = Dict @((P 6 % 1) ~ ((P 4 % 1) / (P 2 % 3)))+_testSlash_Rat4P1_Rat3P4 = Dict @((P 16 % 3) ~ ((P 4 % 1) / (P 3 % 4)))+_testSlash_Rat4P1_Rat1P1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / (P 1 % 1)))+_testSlash_Rat4P1_Rat4P3 = Dict @((P 3 % 1) ~ ((P 4 % 1) / (P 4 % 3)))+_testSlash_Rat4P1_Rat3P2 = Dict @((P 8 % 3) ~ ((P 4 % 1) / (P 3 % 2)))+_testSlash_Rat4P1_Rat2P1 = Dict @((P 2 % 1) ~ ((P 4 % 1) / (P 2 % 1)))+_testSlash_Rat4P1_Rat3P1 = Dict @((P 4 % 3) ~ ((P 4 % 1) / (P 3 % 1)))+_testSlash_Rat4P1_Rat4P1 = Dict @((P 1 % 1) ~ ((P 4 % 1) / (P 4 % 1)))