Cabalize ext-core tools

I cabalized the ext-core tools, so now they can be built as
a library. The driver program has to be built separately.

Also updated genprimopcode to reflect the new module hierarchy
for the Core tools.

diff --git a/utils/ext-core/Driver.hs b/utils/ext-core/Driver.hs
index 927a95d..c2eee43 100644 (file)
--- a/utils/ext-core/Driver.hs
+++ b/utils/ext-core/Driver.hs
@@ -1,5 +1,4 @@
 {-# OPTIONS -Wall #-}
-
 {- A simple driver that loads, typechecks, prepares, re-typechecks, and interprets the 
     GHC standard Prelude modules and an application module called Main. 
 
@@ -17,15 +16,14 @@ import System.Environment
 import System.Exit
 import System.FilePath
 
-import Core
-import Dependencies
-import Overrides
-import Prims
-import Check
-import Prep
-import Interp
-
-import ParsecParser
+import Language.Core.Core
+import Language.Core.Dependencies
+import Language.Core.Overrides
+import Language.Core.Prims
+import Language.Core.Check
+import Language.Core.Prep
+import Language.Core.Interp
+import Language.Core.ParsecParser
 
 -- You may need to change this.
 baseDir :: FilePath
@@ -57,8 +55,8 @@ options =
    Option ['n'] ["no-deps"] (NoArg NoDeps) "don't compute dependencies automatically"
   ]
 
-process :: Bool -> (Check.Menv,[Module]) -> (FilePath, Module)
-             -> IO (Check.Menv,[Module])
+process :: Bool -> (Menv,[Module]) -> (FilePath, Module)
+             -> IO (Menv,[Module])
 process _ (senv,modules) p@(f,m) | isLib p && not typecheckLibs = do
   -- if it's a library and we set typecheckLibs to False:
   -- prep, but don't typecheck
@@ -84,7 +82,7 @@ process doTest (senv,modules) (f, m@(Module mn _ _)) = catch (do
                      ++ " while processing " ++ f)
            return (senv, modules)
 
-prepM :: Check.Menv -> Module -> FilePath -> IO Module
+prepM :: Menv -> Module -> FilePath -> IO Module
 prepM senv' m _f = do
   let m' = prepModule senv' m
   --writeFile (f </> ".prepped") (show m')

diff --git a/utils/ext-core/Check.hs b/utils/ext-core/Language/Core/Check.hs
similarity index 99%
rename from utils/ext-core/Check.hs
rename to utils/ext-core/Language/Core/Check.hs
index e379cd7..db15601 100644 (file)
--- a/utils/ext-core/Check.hs
+++ b/utils/ext-core/Language/Core/Check.hs
@@ -1,19 +1,19 @@
 {-# OPTIONS -Wall -fno-warn-name-shadowing #-}
-module Check(
+module Language.Core.Check(
   checkModule, envsModule,
   checkExpr, checkType, 
   primCoercionError, 
   Menv, Venv, Tvenv, Envs(..),
   CheckRes(..), splitTy, substl) where
 
-import Maybe
-import Control.Monad.Reader
+import Language.Core.Core
+import Language.Core.Printer()
+import Language.Core.PrimEnv
+import Language.Core.Env
 
-import Core
-import Printer()
-import List
-import Env
-import PrimEnv
+import Control.Monad.Reader
+import Data.List
+import Data.Maybe
 
 {- Checking is done in a simple error monad.  In addition to
    allowing errors to be captured, this makes it easy to guarantee

diff --git a/utils/ext-core/Core.hs b/utils/ext-core/Language/Core/Core.hs
similarity index 94%
rename from utils/ext-core/Core.hs
rename to utils/ext-core/Language/Core/Core.hs
index a581d3c..74442bd 100644 (file)
--- a/utils/ext-core/Core.hs
+++ b/utils/ext-core/Language/Core/Core.hs
@@ -1,9 +1,10 @@
-module Core where
+{-# OPTIONS -fno-warn-missing-signatures #-}
+module Language.Core.Core where
 
-import Encoding
+import Language.Core.Encoding
 
 import Data.Generics
-import List (elemIndex)
+import Data.List (elemIndex)
 
 data Module 
  = Module AnMname [Tdef] [Vdefg]
@@ -162,22 +163,25 @@ splitTyConApp_maybe (Tapp rator rand) =
       Nothing     -> case rator of
                        Tcon tc -> Just (tc,[rand])
                        _       -> Nothing
-splitTyConApp_maybe t@(Tforall _ _) = Nothing
+splitTyConApp_maybe (Tforall _ _) = Nothing
+-- coercions
+splitTyConApp_maybe _ = Nothing
 
 -- This used to be called nearlyEqualTy, but now that
 -- we don't need to expand newtypes anymore, it seems
 -- like equality to me!
+equalTy :: Ty -> Ty -> Bool
 equalTy t1 t2 =  eqTy [] [] t1 t2 
   where eqTy e1 e2 (Tvar v1) (Tvar v2) =
             case (elemIndex v1 e1,elemIndex v2 e2) of
                (Just i1, Just i2) -> i1 == i2
                (Nothing, Nothing)  -> v1 == v2
                _ -> False
-       eqTy e1 e2 (Tcon c1) (Tcon c2) = c1 == c2
+       eqTy _ _ (Tcon c1) (Tcon c2) = c1 == c2
         eqTy e1 e2 (Tapp t1a t1b) (Tapp t2a t2b) =
              eqTy e1 e2 t1a t2a && eqTy e1 e2 t1b t2b
-        eqTy e1 e2 (Tforall (tv1,tk1) t1) (Tforall (tv2,tk2) t2) =
-             tk1 `eqKind` tk2 && eqTy (tv1:e1) (tv2:e2) t1 t2 
+        eqTy e1 e2 (Tforall (tv1,tk1) b1) (Tforall (tv2,tk2) b2) =
+             tk1 `eqKind` tk2 && eqTy (tv1:e1) (tv2:e2) b1 b2 
        eqTy _ _ _ _ = False
 instance Eq Ty where (==) = equalTy
 

diff --git a/utils/ext-core/Dependencies.hs b/utils/ext-core/Language/Core/Dependencies.hs
similarity index 97%
rename from utils/ext-core/Dependencies.hs
rename to utils/ext-core/Language/Core/Dependencies.hs
index eef2899..a90650a 100644 (file)
--- a/utils/ext-core/Dependencies.hs
+++ b/utils/ext-core/Language/Core/Dependencies.hs
@@ -1,9 +1,8 @@
-{-# OPTIONS -Wall #-}
-module Dependencies(getDependencies) where
+module Language.Core.Dependencies(getDependencies) where
 
-import Core
-import Encoding
-import ParsecParser
+import Language.Core.Core
+import Language.Core.Encoding
+import Language.Core.ParsecParser
 
 import Control.Monad.State
 import Data.Generics

diff --git a/utils/ext-core/Language/Core/Driver.hs b/utils/ext-core/Language/Core/Driver.hs
new file mode 100644 (file)
index 0000000..4a71691
--- /dev/null
+++ b/utils/ext-core/Language/Core/Driver.hs
@@ -0,0 +1,147 @@
+{-# OPTIONS -Wall #-}
+
+{- A simple driver that loads, typechecks, prepares, re-typechecks, and interprets the 
+    GHC standard Prelude modules and an application module called Main. 
+
+   Note that, if compiled under GHC, this requires a very large heap to run!
+-}
+
+import Control.Exception
+import Data.List
+import Data.Maybe
+import Monad
+import Prelude hiding (catch)
+import System.Cmd
+import System.Console.GetOpt
+import System.Environment
+import System.Exit
+import System.FilePath
+
+import Language.Core.Core
+import Language.Core.Dependencies
+import Language.Core.Overrides
+import Language.Core.Prims
+import Language.Core.Check
+import Language.Core.Prep
+import Language.Core.Interp
+import Language.Core.ParsecParser
+
+-- You may need to change this.
+baseDir :: FilePath
+baseDir = "../../libraries/"
+-- change to True to typecheck library files as well as reading type signatures
+typecheckLibs :: Bool
+typecheckLibs = False
+
+-- You shouldn't *need* to change anything below this line...                  
+
+-- Code to check that the external and GHC printers print the same results
+validateResults :: FilePath -> Module -> IO ()
+validateResults origFile m = do
+  let genFile = origFile </> "parsed"
+  writeFile genFile (show m) 
+  resultCode <- system $ "diff -u " ++ origFile ++ " " ++ genFile
+  putStrLn $ case resultCode of
+    ExitSuccess   -> "Parse validated for " ++ origFile
+    ExitFailure 1 -> "Parse failed to validate for " ++ origFile
+    _             -> "Error diffing files: " ++ origFile ++ " " ++ genFile
+------------------------------------------------------------------------------
+
+data Flag = Test | NoDeps
+  deriving Eq
+
+options :: [OptDescr Flag]
+options =
+  [Option ['t'] ["test"] (NoArg Test) "validate prettyprinted code",
+   Option ['n'] ["no-deps"] (NoArg NoDeps) "don't compute dependencies automatically"
+  ]
+
+process :: Bool -> (Check.Menv,[Module]) -> (FilePath, Module)
+             -> IO (Check.Menv,[Module])
+process _ (senv,modules) p@(f,m) | isLib p && not typecheckLibs = do
+  -- if it's a library and we set typecheckLibs to False:
+  -- prep, but don't typecheck
+  m' <- prepM senv m f
+  return (senv, modules ++ [m'])
+    where isLib (fp,_) = baseDir `isPrefixOf` fp
+process doTest (senv,modules) (f, m@(Module mn _ _)) = catch (do
+        when doTest $ validateResults f m
+       (case checkModule senv m of
+           OkC senv' ->
+            do putStrLn $ "Check succeeded for " ++ show mn
+                m' <- prepM senv' m f
+               case checkModule senv' m' of
+                  OkC senv'' ->
+                     do putStrLn "Recheck succeeded"
+                         return (senv'',modules ++ [m'])
+                 FailC s -> 
+                     do putStrLn ("Recheck failed: " ++ s)
+                        error "quit"
+          FailC s -> error ("Typechecking failed: " ++ s))) handler
+   where handler e = do
+           putStrLn ("WARNING: we caught an exception " ++ show e 
+                     ++ " while processing " ++ f)
+           return (senv, modules)
+
+prepM :: Check.Menv -> Module -> FilePath -> IO Module
+prepM senv' m _f = do
+  let m' = prepModule senv' m
+  --writeFile (f </> ".prepped") (show m')
+  return m'
+
+main :: IO ()
+main = do
+  args <- getArgs
+  case getOpt Permute options args of
+    (opts, fnames@(_:_), _) ->
+       let doTest      = Test `elem` opts
+           computeDeps = NoDeps `notElem` opts in
+         doOneProgram computeDeps doTest fnames
+    _ -> error "usage: ./Driver [filename]"
+  where  doOneProgram :: Bool -> Bool -> [FilePath] -> IO ()
+         doOneProgram computeDeps doTest fns = do
+               putStrLn $ "========== Program " ++ (show fns) ++ " ============="
+               deps <- if computeDeps 
+                         then
+                           getDependencies fns
+                         else (liftM catMaybes) (mapM findModuleDirect fns)
+               putStrLn $ "deps = " ++ show (fst (unzip deps))
+               {-
+                 Note that we scan over the libraries twice:
+                 first to gather together all type sigs, then to typecheck them
+                 (the latter of which doesn't necessarily have to be done every time.)
+                 This is a hack to avoid dealing with circular dependencies. 
+                -}
+               -- notice: scan over libraries *and* input modules first, not just libs
+               topEnv <- mkInitialEnv (snd (unzip deps))
+               (_,modules) <- foldM (process doTest) (topEnv,[]) deps
+               let succeeded = length modules
+               putStrLn ("Finished typechecking. Successfully checked " 
+                          ++ show succeeded)
+               overridden <- override modules
+               result <- evalProgram overridden
+               putStrLn ("Result = " ++ show result)
+               putStrLn "All done\n============================================="
+
+         mkInitialEnv :: [Module] -> IO Menv
+         mkInitialEnv libs = foldM mkTypeEnv initialEnv libs
+
+         mkTypeEnv :: Menv -> Module -> IO Menv
+         mkTypeEnv globalEnv m@(Module mn _ _) = 
+                catch (return (envsModule globalEnv m)) handler
+                  where handler e = do
+                          putStrLn ("WARNING: mkTypeEnv caught an exception " ++ show e 
+                                    ++ " while processing " ++ show mn)
+                          return globalEnv
+
+findModuleDirect :: FilePath -> IO (Maybe (FilePath, Module))
+-- kludge to let us run "make libtest" -- 
+-- this module (in the Cabal package) causes an uncaught exception
+-- from Prelude.chr, which I haven't been able to track down
+findModuleDirect fn | "PackageDescription.hcr" `isSuffixOf` fn = return Nothing
+findModuleDirect fn = do
+  putStrLn $ "Finding " ++ show fn
+  res <- parseCore fn
+  case res of
+    Left err -> error (show err)
+    Right m -> return $ Just (fn,m)
\ No newline at end of file

diff --git a/utils/ext-core/Encoding.hs b/utils/ext-core/Language/Core/Encoding.hs
similarity index 98%
rename from utils/ext-core/Encoding.hs
rename to utils/ext-core/Language/Core/Encoding.hs
index c276932..c952148 100644 (file)
--- a/utils/ext-core/Encoding.hs
+++ b/utils/ext-core/Language/Core/Encoding.hs
@@ -1,4 +1,6 @@
-module Encoding where
+{-# OPTIONS -fno-warn-name-shadowing #-}
+
+module Language.Core.Encoding where
 
 import Data.Char
 import Numeric

diff --git a/utils/ext-core/Env.hs b/utils/ext-core/Language/Core/Env.hs
similarity index 91%
rename from utils/ext-core/Env.hs
rename to utils/ext-core/Language/Core/Env.hs
index 642df00..8ef9c69 100644 (file)
--- a/utils/ext-core/Env.hs
+++ b/utils/ext-core/Language/Core/Env.hs
@@ -3,7 +3,7 @@
   Sadly it doesn't seem to matter much. --tjc
 -}
 
-module Env (Env,
+module Language.Core.Env (Env,
            eempty,
            elookup,
            eextend,
@@ -15,7 +15,6 @@ module Env (Env,
 where
 
 import qualified Data.Map as M
-import Data.List
 
 data Env a b = Env (M.Map a b)
  deriving Show
@@ -45,5 +44,5 @@ eremove :: (Eq a, Ord a)  => Env a b -> a -> Env a b
 eremove (Env l) k = Env (M.delete k l)
 
 efilter :: Ord a => Env a b -> (a -> Bool) -> Env a b
-efilter (Env l) p = Env (M.filterWithKey (\ k a -> p k) l)
+efilter (Env l) p = Env (M.filterWithKey (\ k _ -> p k) l)
 

diff --git a/utils/ext-core/Interp.hs b/utils/ext-core/Language/Core/Interp.hs
similarity index 99%
rename from utils/ext-core/Interp.hs
rename to utils/ext-core/Language/Core/Interp.hs
index 2c3f65e..0a4ac65 100644 (file)
--- a/utils/ext-core/Interp.hs
+++ b/utils/ext-core/Language/Core/Interp.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS -Wall -fno-warn-name-shadowing -XPatternGuards #-}
+{-# OPTIONS -Wall -fno-warn-name-shadowing -XPatternGuards -fglasgow-exts #-}
 {- 
 Interprets the subset of well-typed Core programs for which
        (a) All constructor and primop applications are saturated
@@ -15,7 +15,7 @@ The only major omission is garbage collection.
 Just a sampling of primitive types and operators are included.
 -}
 
-module Interp ( evalProgram ) where
+module Language.Core.Interp ( evalProgram ) where
 
 import Control.Monad.Error
 import Control.Monad.State
@@ -25,9 +25,9 @@ import Data.List
 import GHC.Exts hiding (Ptr)
 import System.IO
 
-import Core
-import Env
-import Printer()
+import Language.Core.Core
+import Language.Core.Env
+import Language.Core.Printer()
 
 data HeapValue = 
     Hconstr Dcon [Value]       -- constructed value (note: no qualifier needed!)

diff --git a/utils/ext-core/Lex.hs b/utils/ext-core/Language/Core/Lex.hs
similarity index 100%
rename from utils/ext-core/Lex.hs
rename to utils/ext-core/Language/Core/Lex.hs

diff --git a/utils/ext-core/Overrides.hs b/utils/ext-core/Language/Core/Overrides.hs
similarity index 95%
rename from utils/ext-core/Overrides.hs
rename to utils/ext-core/Language/Core/Overrides.hs
index 1542e09..a545a25 100644 (file)
--- a/utils/ext-core/Overrides.hs
+++ b/utils/ext-core/Language/Core/Overrides.hs
@@ -11,12 +11,12 @@
 
    It's kind of ugly.
 -}
-module Overrides (override) where
+module Language.Core.Overrides (override) where
 
-import Core
-import Encoding
-import ParsecParser
-import Prims
+import Language.Core.Core
+import Language.Core.Encoding
+import Language.Core.ParsecParser
+import Language.Core.Prims
 
 import Data.Generics
 import System.FilePath

diff --git a/utils/ext-core/ParseGlue.hs b/utils/ext-core/Language/Core/ParseGlue.hs
similarity index 64%
rename from utils/ext-core/ParseGlue.hs
rename to utils/ext-core/Language/Core/ParseGlue.hs
index 2e196c0..3743792 100644 (file)
--- a/utils/ext-core/ParseGlue.hs
+++ b/utils/ext-core/Language/Core/ParseGlue.hs
@@ -1,4 +1,4 @@
-module ParseGlue where
+module Language.Core.ParseGlue where
 
 import Encoding
 
@@ -60,28 +60,3 @@ data Token =
  | TKstring String 
  | TKchar Char 
  | TKEOF
-
--- ugh
-splitModuleName mn = 
-   let decoded = zDecodeString mn
-       -- Triple ugh.
-       -- We re-encode the individual parts so that:
-       -- main:Foo_Bar.Quux.baz
-       -- prints as:
-       -- main:FoozuBarziQuux.baz
-       -- and not:
-       -- main:Foo_BarziQuux.baz
-       parts   = map zEncodeString $ filter (notElem '.') $ groupBy 
-                   (\ c1 c2 -> c1 /= '.' && c2 /= '.') 
-                 decoded in
-     (take (length parts - 1) parts, last parts)
-
-
-
-
-
-
-
-
-
-

diff --git a/utils/ext-core/ParsecParser.hs b/utils/ext-core/Language/Core/ParsecParser.hs
similarity index 95%
rename from utils/ext-core/ParsecParser.hs
rename to utils/ext-core/Language/Core/ParsecParser.hs
index 41a18a5..3fd3f17 100644 (file)
--- a/utils/ext-core/ParsecParser.hs
+++ b/utils/ext-core/Language/Core/ParsecParser.hs
@@ -1,16 +1,17 @@
 {-# OPTIONS -Wall -fno-warn-missing-signatures #-}
 
-module ParsecParser (parseCore) where
+module Language.Core.ParsecParser (parseCore) where
 
-import Core
-import ParseGlue
-import Check
-import PrimCoercions
+import Language.Core.Core
+import Language.Core.Check
+import Language.Core.Encoding
+import Language.Core.PrimCoercions
 
 import Text.ParserCombinators.Parsec
 import qualified Text.ParserCombinators.Parsec.Token as P
 import Text.ParserCombinators.Parsec.Language
 import Data.Char
+import Data.List
 import Data.Ratio
 
 parseCore :: FilePath -> IO (Either ParseError Module)
@@ -491,6 +492,21 @@ defaultAlt = do
   rhs <- coreFullExp
   return $ Adefault rhs
 ----------------
+-- ugh
+splitModuleName mn = 
+   let decoded = zDecodeString mn
+       -- Triple ugh.
+       -- We re-encode the individual parts so that:
+       -- main:Foo_Bar.Quux.baz
+       -- prints as:
+       -- main:FoozuBarziQuux.baz
+       -- and not:
+       -- main:Foo_BarziQuux.baz
+       parts   = map zEncodeString $ filter (notElem '.') $ groupBy 
+                   (\ c1 c2 -> c1 /= '.' && c2 /= '.') 
+                 decoded in
+     (take (length parts - 1) parts, last parts)
+----------------
 extCore = P.makeTokenParser extCoreDef
 
 parens          = P.parens extCore    

diff --git a/utils/ext-core/Prep.hs b/utils/ext-core/Language/Core/Prep.hs
similarity index 97%
rename from utils/ext-core/Prep.hs
rename to utils/ext-core/Language/Core/Prep.hs
index df664a5..e6f015f 100644 (file)
--- a/utils/ext-core/Prep.hs
+++ b/utils/ext-core/Language/Core/Prep.hs
@@ -9,17 +9,16 @@ After these preprocessing steps, Core can be interpreted (or given an operationa
 -}
 
 
-module Prep where
+module Language.Core.Prep where
 
 import Data.Either
-
-import Prims
-import Core
-import Env
-import Check
-
 import Data.List
 
+import Language.Core.Prims
+import Language.Core.Core
+import Language.Core.Env
+import Language.Core.Check
+
 prepModule :: Menv -> Module -> Module
 prepModule globalEnv (Module mn tdefs vdefgs) = 
     Module mn tdefs vdefgs' 

diff --git a/utils/ext-core/PrimCoercions.hs b/utils/ext-core/Language/Core/PrimCoercions.hs
similarity index 89%
rename from utils/ext-core/PrimCoercions.hs
rename to utils/ext-core/Language/Core/PrimCoercions.hs
index 8dd0176..e6851d8 100644 (file)
--- a/utils/ext-core/PrimCoercions.hs
+++ b/utils/ext-core/Language/Core/PrimCoercions.hs
@@ -1,6 +1,6 @@
 {-# OPTIONS -Wall -fno-warn-missing-signatures #-}
-module PrimCoercions where
-import Core
+module Language.Core.PrimCoercions where
+import Language.Core.Core
 
 -- Stuff the parser needs to know about
 

diff --git a/utils/ext-core/Language/Core/PrimEnv.hs b/utils/ext-core/Language/Core/PrimEnv.hs
new file mode 100644 (file)
index 0000000..ed36668
--- /dev/null
+++ b/utils/ext-core/Language/Core/PrimEnv.hs
@@ -0,0 +1,373 @@
+-----------------------------------------------------------------------
+-- This module is automatically generated by the GHC utility
+-- "genprimopcode". Do not edit!
+-----------------------------------------------------------------------
+module Language.Core.PrimEnv(primTcs, primVals, intLitTypes, ratLitTypes,
+ charLitTypes, stringLitTypes) where
+import Language.Core.Core
+import Language.Core.Encoding
+
+primTcs :: [(Tcon, Kind)]
+primTcs = [
+      (zEncodeString "Char#", Kunlifted),
+      (zEncodeString "Int#", Kunlifted),
+      (zEncodeString "Word#", Kunlifted),
+      (zEncodeString "Int64#", Kunlifted),
+      (zEncodeString "Word64#", Kunlifted),
+      (zEncodeString "Double#", Kunlifted),
+      (zEncodeString "Float#", Kunlifted),
+      (zEncodeString "Array#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "MutArr#", (Karrow Klifted (Karrow Klifted Kunlifted))),
+      (zEncodeString "ByteArr#", Kunlifted),
+      (zEncodeString "MutByteArr#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "Addr#", Kunlifted),
+      (zEncodeString "MutVar#", (Karrow Klifted (Karrow Klifted Kunlifted))),
+      (zEncodeString "TVar#", (Karrow Klifted (Karrow Klifted Kunlifted))),
+      (zEncodeString "MVar#", (Karrow Klifted (Karrow Klifted Kunlifted))),
+      (zEncodeString "State#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "RealWorld", Klifted),
+      (zEncodeString "ThreadId#", Kunlifted),
+      (zEncodeString "Weak#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "StablePtr#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "StableName#", (Karrow Klifted Kunlifted)),
+      (zEncodeString "BCO#", Kunlifted),
+      (zEncodeString "Any", Klifted)   ]
+primVals :: [(Var, Ty)]
+primVals = [
+      (zEncodeString "gtChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "geChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "eqChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "neChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "ltChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "leChar#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "ord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "+#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "-#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "*#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "mulIntMayOflo#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "quotInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "remInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "gcdInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "negateInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "addIntC#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))))),
+      (zEncodeString "subIntC#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))))),
+      (zEncodeString ">#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString ">=#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "==#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "/=#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "<#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "<=#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "chr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Char#")))),
+      (zEncodeString "int2Word#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#")))),
+      (zEncodeString "int2Float#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "int2Double#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "int2Integer#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "uncheckedIShiftL#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "uncheckedIShiftRA#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "uncheckedIShiftRL#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "plusWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "minusWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "timesWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "quotWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "remWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "and#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "or#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "xor#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "not#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#")))),
+      (zEncodeString "uncheckedShiftL#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "uncheckedShiftRL#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "word2Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "word2Integer#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "gtWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "geWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "eqWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "neWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "ltWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "leWord#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "narrow8Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "narrow16Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "narrow32Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "narrow8Word#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#")))),
+      (zEncodeString "narrow16Word#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#")))),
+      (zEncodeString "narrow32Word#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) ((Tcon (Just primMname, zEncodeString "Word#")))),
+      (zEncodeString "int64ToInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int64#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "word64ToInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word64#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "plusInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "minusInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "timesInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "gcdInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "gcdIntegerInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "divExactInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "quotInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "remInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "cmpInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))))),
+      (zEncodeString "cmpIntegerInt#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "quotRemInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tapp (Tapp (Tcon (Just primMname, "Z4H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "divModInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tapp (Tapp (Tcon (Just primMname, "Z4H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "integer2Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "integer2Word#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "andInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "orInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "xorInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))))),
+      (zEncodeString "complementInteger#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#"))))))),
+      (zEncodeString ">##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString ">=##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "==##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "/=##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "<##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "<=##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "+##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "-##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "*##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "/##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "negateDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "double2Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "double2Float#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "expDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "logDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "sqrtDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "sinDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "cosDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "tanDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "asinDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "acosDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "atanDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "sinhDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "coshDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "tanhDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "**##", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "decodeDouble#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "gtFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "geFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "eqFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "neFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "ltFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "leFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "plusFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "minusFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "timesFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "divideFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "negateFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "float2Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "expFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "logFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "sqrtFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "sinFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "cosFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "tanFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "asinFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "acosFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "atanFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "sinhFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "coshFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "tanhFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#")))),
+      (zEncodeString "powerFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "float2Double#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tcon (Just primMname, zEncodeString "Double#")))),
+      (zEncodeString "decodeFloat#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))),
+      (zEncodeString "newArray#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))))))))),
+      (zEncodeString "sameMutableArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))) ((Tcon (Just boolMname, zEncodeString "Bool"))))))),
+      (zEncodeString "readArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tvar "a"))))))))),
+      (zEncodeString "writeArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s")))))))))),
+      (zEncodeString "indexArray#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "Array#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tcon (Just primMname, "Z1H")) ((Tvar "a"))))))),
+      (zEncodeString "unsafeFreezeArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "Array#")) ((Tvar "a")))))))))),
+      (zEncodeString "unsafeThawArray#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "Array#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutableArray#")) ((Tvar "s"))) ((Tvar "a")))))))))),
+      (zEncodeString "newByteArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))))))),
+      (zEncodeString "newPinnedByteArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))))))),
+      (zEncodeString "byteArrayContents#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Addr#")))),
+      (zEncodeString "sameMutableByteArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) ((Tcon (Just boolMname, zEncodeString "Bool")))))),
+      (zEncodeString "unsafeFreezeByteArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))))),
+      (zEncodeString "sizeofByteArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "sizeofMutableByteArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexCharArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Char#"))))),
+      (zEncodeString "indexWideCharArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Char#"))))),
+      (zEncodeString "indexIntArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexWordArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexAddrArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Addr#"))))),
+      (zEncodeString "indexFloatArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "indexDoubleArray#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "indexStablePtrArray#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))))),
+      (zEncodeString "indexInt8Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt16Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt32Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt64Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int64#"))))),
+      (zEncodeString "indexWord8Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord16Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord32Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord64Array#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word64#"))))),
+      (zEncodeString "readCharArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Char#"))))))))),
+      (zEncodeString "readWideCharArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Char#"))))))))),
+      (zEncodeString "readIntArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readWordArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readAddrArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Addr#"))))))))),
+      (zEncodeString "readFloatArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Float#"))))))))),
+      (zEncodeString "readDoubleArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Double#"))))))))),
+      (zEncodeString "readStablePtrArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))))))))),
+      (zEncodeString "readInt8Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt16Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt32Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt64Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int64#"))))))))),
+      (zEncodeString "readWord8Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord16Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord32Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord64Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word64#"))))))))),
+      (zEncodeString "writeCharArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWideCharArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeIntArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWordArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeAddrArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeFloatArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeDoubleArray#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeStablePtrArray#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s")))))))))),
+      (zEncodeString "writeInt8Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt16Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt32Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt64Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int64#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord8Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord16Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord32Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord64Array#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "MutableByteArray#")) ((Tvar "s"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word64#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "nullAddr#", (Tcon (Just primMname, zEncodeString "Addr#"))),
+      (zEncodeString "plusAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Addr#"))))),
+      (zEncodeString "minusAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "remAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "addr2Int#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just primMname, zEncodeString "Int#")))),
+      (zEncodeString "int2Addr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Addr#")))),
+      (zEncodeString "gtAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "geAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "eqAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "neAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "ltAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "leAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tcon (Just boolMname, zEncodeString "Bool"))))),
+      (zEncodeString "indexCharOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Char#"))))),
+      (zEncodeString "indexWideCharOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Char#"))))),
+      (zEncodeString "indexIntOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexWordOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexAddrOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Addr#"))))),
+      (zEncodeString "indexFloatOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Float#"))))),
+      (zEncodeString "indexDoubleOffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Double#"))))),
+      (zEncodeString "indexStablePtrOffAddr#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))))),
+      (zEncodeString "indexInt8OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt16OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt32OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "indexInt64OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Int64#"))))),
+      (zEncodeString "indexWord8OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord16OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord32OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word#"))))),
+      (zEncodeString "indexWord64OffAddr#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tcon (Just primMname, zEncodeString "Word64#"))))),
+      (zEncodeString "readCharOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Char#"))))))))),
+      (zEncodeString "readWideCharOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Char#"))))))))),
+      (zEncodeString "readIntOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readWordOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readAddrOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Addr#"))))))))),
+      (zEncodeString "readFloatOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Float#"))))))))),
+      (zEncodeString "readDoubleOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Double#"))))))))),
+      (zEncodeString "readStablePtrOffAddr#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))))))))),
+      (zEncodeString "readInt8OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt16OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt32OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "readInt64OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int64#"))))))))),
+      (zEncodeString "readWord8OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord16OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord32OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word#"))))))))),
+      (zEncodeString "readWord64OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Word64#"))))))))),
+      (zEncodeString "writeCharOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWideCharOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Char#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeIntOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWordOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeAddrOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeFloatOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Float#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeDoubleOffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Double#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeStablePtrOffAddr#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s")))))))))),
+      (zEncodeString "writeInt8OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt16OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt32OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeInt64OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int64#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord8OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord16OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord32OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "writeWord64OffAddr#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Word64#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "newMutVar#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a")))))))))),
+      (zEncodeString "readMutVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tvar "a")))))))),
+      (zEncodeString "writeMutVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "sameMutVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a"))))) ((Tcon (Just boolMname, zEncodeString "Bool"))))))),
+      (zEncodeString "atomicModifyMutVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tforall ("c", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MutVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tvar "b")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tvar "c"))))))))))),
+      (zEncodeString "catch#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))))),
+      (zEncodeString "raise#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tvar "b"))))),
+      (zEncodeString "raiseIO#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "b")))))))),
+      (zEncodeString "blockAsyncExceptions#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))),
+      (zEncodeString "unblockAsyncExceptions#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))),
+      (zEncodeString "atomically#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))),
+      (zEncodeString "retry#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))),
+      (zEncodeString "catchRetry#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))))),
+      (zEncodeString "catchSTM#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))))),
+      (zEncodeString "check#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a")))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just baseMname, zEncodeString "()")))))))),
+      (zEncodeString "newTVar#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "TVar#")) ((Tvar "s"))) ((Tvar "a")))))))))),
+      (zEncodeString "readTVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "TVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tvar "a")))))))),
+      (zEncodeString "writeTVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "TVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "sameTVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "TVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "TVar#")) ((Tvar "s"))) ((Tvar "a"))))) ((Tcon (Just boolMname, zEncodeString "Bool"))))))),
+      (zEncodeString "newMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))))))),
+      (zEncodeString "takeMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tvar "a")))))))),
+      (zEncodeString "tryTakeMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tvar "a")))))))),
+      (zEncodeString "putMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))))),
+      (zEncodeString "tryPutMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#")))))))))),
+      (zEncodeString "sameMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) ((Tcon (Just boolMname, zEncodeString "Bool"))))))),
+      (zEncodeString "isEmptyMVar#", Tforall ("s", Klifted) (Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tapp (Tcon (Just primMname, zEncodeString "MVar#")) ((Tvar "s"))) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))),
+      (zEncodeString "delay#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))),
+      (zEncodeString "waitRead#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))),
+      (zEncodeString "waitWrite#", Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))))),
+      (zEncodeString "fork#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "ThreadId#")))))))),
+      (zEncodeString "forkOn#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "ThreadId#"))))))))),
+      (zEncodeString "killThread#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ThreadId#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld"))))))))),
+      (zEncodeString "yield#", Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))),
+      (zEncodeString "myThreadId#", Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "ThreadId#")))))),
+      (zEncodeString "labelThread#", Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ThreadId#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))))),
+      (zEncodeString "isCurrentThreadBound#", Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "noDuplicate#", Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))),
+      (zEncodeString "mkWeak#", Tforall ("o", Kopen) (Tforall ("b", Klifted) (Tforall ("c", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "o"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "c"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "Weak#")) ((Tvar "b"))))))))))))),
+      (zEncodeString "deRefWeak#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "Weak#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tvar "a"))))))),
+      (zEncodeString "finalizeWeak#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "Weak#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tcon (Just baseMname, zEncodeString "()"))))))))))),
+      (zEncodeString "touch#", Tforall ("o", Kopen) (Tapp (Tapp (Tcon tcArrow) ((Tvar "o"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))))),
+      (zEncodeString "makeStablePtr#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))))))),
+      (zEncodeString "deRefStablePtr#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tvar "a"))))))),
+      (zEncodeString "eqStablePtr#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StablePtr#")) ((Tvar "a"))))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "makeStableName#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tcon (Just primMname, zEncodeString "RealWorld")))))) ((Tapp (Tcon (Just primMname, zEncodeString "StableName#")) ((Tvar "a"))))))))),
+      (zEncodeString "eqStableName#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StableName#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StableName#")) ((Tvar "a"))))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "stableNameToInt#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "StableName#")) ((Tvar "a"))))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "reallyUnsafePtrEquality#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tcon (Just primMname, zEncodeString "Int#")))))),
+      (zEncodeString "par#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "parGlobal#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))))),
+      (zEncodeString "parLocal#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))))),
+      (zEncodeString "parAt#", Tforall ("b", Klifted) (Tforall ("a", Klifted) (Tforall ("c", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "c"))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))))))),
+      (zEncodeString "parAtAbs#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) ((Tcon (Just primMname, zEncodeString "Int#")))))))))))),
+      (zEncodeString "parAtRel#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) ((Tcon (Just primMname, zEncodeString "Int#")))))))))))),
+      (zEncodeString "parAtForNow#", Tforall ("b", Klifted) (Tforall ("a", Klifted) (Tforall ("c", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "c"))) ((Tcon (Just primMname, zEncodeString "Int#"))))))))))))),
+      (zEncodeString "dataToTag#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tcon (Just primMname, zEncodeString "Int#"))))),
+      (zEncodeString "tagToEnum#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tvar "a")))),
+      (zEncodeString "addrToHValue#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tapp (Tcon (Just primMname, "Z1H")) ((Tvar "a")))))),
+      (zEncodeString "mkApUpd0#", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "BCO#")))) ((Tapp (Tcon (Just primMname, "Z1H")) ((Tvar "a")))))),
+      (zEncodeString "newBCO#", Tforall ("a", Klifted) (Tforall ("s", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "Array#")) ((Tvar "a"))))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "ByteArray#")))) (Tapp (Tapp (Tcon tcArrow) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tapp (Tcon (Just primMname, zEncodeString "State#")) ((Tvar "s"))))) ((Tcon (Just primMname, zEncodeString "BCO#"))))))))))))),
+      (zEncodeString "unpackClosure#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tapp (Tapp (Tapp (Tcon (Just primMname, "Z3H")) ((Tcon (Just primMname, zEncodeString "Addr#")))) ((Tapp (Tcon (Just primMname, zEncodeString "Array#")) ((Tvar "b"))))) ((Tcon (Just primMname, zEncodeString "ByteArray#")))))))),
+      (zEncodeString "getApStackVal#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tapp (Tapp (Tcon (Just primMname, "Z2H")) ((Tcon (Just primMname, zEncodeString "Int#")))) ((Tvar "b")))))))),
+      (zEncodeString "seq", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) (Tapp (Tapp (Tcon tcArrow) ((Tvar "b"))) ((Tvar "b")))))),
+      (zEncodeString "inline", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tvar "a")))),
+      (zEncodeString "lazy", Tforall ("a", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tvar "a")))),
+      (zEncodeString "unsafeCoerce#", Tforall ("a", Klifted) (Tforall ("b", Klifted) (Tapp (Tapp (Tcon tcArrow) ((Tvar "a"))) ((Tvar "b")))))]
+intLitTypes :: [Ty]
+intLitTypes = [
+   (Tcon (Just primMname, zEncodeString "Char#")),
+   (Tcon (Just primMname, zEncodeString "Int#")),
+   (Tcon (Just primMname, zEncodeString "Word#")),
+   (Tcon (Just primMname, zEncodeString "Int64#")),
+   (Tcon (Just primMname, zEncodeString "Word64#")),
+   (Tcon (Just primMname, zEncodeString "Addr#"))]
+ratLitTypes :: [Ty]
+ratLitTypes = [
+   (Tcon (Just primMname, zEncodeString "Double#")),
+   (Tcon (Just primMname, zEncodeString "Float#"))]
+charLitTypes :: [Ty]
+charLitTypes = [
+   (Tcon (Just primMname, zEncodeString "Char#"))]
+stringLitTypes :: [Ty]
+stringLitTypes = [
+   (Tcon (Just primMname, zEncodeString "Addr#"))]
+

diff --git a/utils/ext-core/Prims.hs b/utils/ext-core/Language/Core/Prims.hs
similarity index 92%
rename from utils/ext-core/Prims.hs
rename to utils/ext-core/Language/Core/Prims.hs
index 5193848..0c682d4 100644 (file)
--- a/utils/ext-core/Prims.hs
+++ b/utils/ext-core/Language/Core/Prims.hs
@@ -4,15 +4,14 @@
    Most are defined in PrimEnv, which is automatically generated from
    GHC's primops.txt. -}
 
-module Prims(initialEnv, primEnv, newPrimVars) where
-
-import Core
-import Encoding
-import Env
-import Check
-import PrimCoercions
-
-import PrimEnv
+module Language.Core.Prims(initialEnv, primEnv, newPrimVars) where
+
+import Language.Core.Core
+import Language.Core.Encoding
+import Language.Core.Env
+import Language.Core.Check
+import Language.Core.PrimCoercions
+import Language.Core.PrimEnv
 
 initialEnv :: Menv
 initialEnv = efromlist [(primMname,primEnv),

diff --git a/utils/ext-core/Printer.hs b/utils/ext-core/Language/Core/Printer.hs
similarity index 97%
rename from utils/ext-core/Printer.hs
rename to utils/ext-core/Language/Core/Printer.hs
index 0acdc5d..0a3e2cf 100644 (file)
--- a/utils/ext-core/Printer.hs
+++ b/utils/ext-core/Language/Core/Printer.hs
@@ -1,13 +1,13 @@
 {-# OPTIONS -Werror -Wall -fno-warn-missing-signatures #-}
 
-module Printer where
+module Language.Core.Printer where
 
 import Text.PrettyPrint.HughesPJ
-import Char
+import Data.Char
 
-import Core
-import Encoding
-import PrimCoercions
+import Language.Core.Core
+import Language.Core.Encoding
+import Language.Core.PrimCoercions
 
 instance Show Module where
   showsPrec _ m = shows (pmodule m)

diff --git a/utils/ext-core/Makefile b/utils/ext-core/Makefile
index ec228e7..99bd6d2 100644 (file)
--- a/utils/ext-core/Makefile
+++ b/utils/ext-core/Makefile
@@ -1,26 +1,11 @@
-all:   extcorelibs Check.hs Core.hs Driver.hs Env.hs Interp.hs ParsecParser.hs ParseGlue.hs Prep.hs PrimCoercions.hs Prims.hs Printer.hs
-       ghc -O2 --make -fglasgow-exts -o Driver Driver.hs
-
-extcorelibs:
-       $(MAKE) -C lib/GHC_ExtCore
-
-# Run this when the primops.txt file changes
-prims:  ../../compiler/prelude/primops.txt
-       ../genprimopcode/genprimopcode --make-ext-core-source < ../../compiler/prelude/primops.txt > PrimEnv.hs
-
-#Parser.hs: Parser.y
-#      happy -ad -ihappy.debug -o Parser.hs Parser.y
+# This makefile is just for running the tests. For everything else,
+# use Cabal! (The tests could be run with Cabal too, I'm just too lazy
+# to figure out how.)
 
 # The following assumes that you've built all the GHC libs with -fext-core...
-libtest: all
+libtest:
        ./Driver -n `find ../../libraries -print | grep .hcr$$ | grep -v bootstrapping`
 
 # ...or built all the nofib programs with -fext-core.
-nofibtest: all
+nofibtest:
        ./Driver `find ../../nofib -print | grep .hcr$$`
-
-clean:
-       rm -f Driver *.hi *.o
-
-reallyclean: clean
-       rm PrimEnv.hs
\ No newline at end of file

diff --git a/utils/ext-core/README b/utils/ext-core/README
index 84f213d..6a0dc13 100644 (file)
--- a/utils/ext-core/README
+++ b/utils/ext-core/README
@@ -54,11 +54,20 @@ running "make" under libraries/.
 Then you need to edit Driver.hs and change "baseDir" to point to your GHC
 libraries directory.
 
-Once you've done that:
-1. make prims (to generate the primops file)
-2. make
-3. make nofibtest (to run the parser/checker on all nofib programs...
+Once you've done that, the ext-core library can be built in the usual
+Cabal manner:
+1. runhaskell Setup.lhs configure
+2. runhaskell Setup.lhs build
+3. runhaskell Setup.lhs install
+
+Then, you can build the example Driver program with:
+  ghc -package extcore Driver.hs -o Driver
+
+And finally, you can use the included Makefile to run tests:
+
+  make nofibtest (to run the parser/checker on all nofib programs...
    for example.)
+  make libtest (to typecheck all the libraries)
 
 Tested with GHC 6.8.2. I make no claims of portability.
 

diff --git a/utils/ext-core/Setup.lhs b/utils/ext-core/Setup.lhs
new file mode 100644 (file)
index 0000000..bdcd784
--- /dev/null
+++ b/utils/ext-core/Setup.lhs
@@ -0,0 +1,56 @@
+#!/usr/bin/env runhaskell
+\begin{code}
+{-# OPTIONS -Wall #-}
+
+import Control.Monad
+import Data.List
+import Distribution.PackageDescription
+import Distribution.Simple
+import Distribution.Simple.LocalBuildInfo
+import Distribution.Simple.Utils
+import System.Cmd
+import System.FilePath
+import System.Exit
+import System.Directory
+import Control.Exception (try)
+
+main :: IO ()
+main = do
+   let hooks = defaultUserHooks {
+                 buildHook = build_primitive_sources 
+                           $ buildHook defaultUserHooks
+            }
+   defaultMainWithHooks hooks
+\end{code}
+
+Mostly snarfed from ghc-prim's Setup.hs.
+
+\begin{code}
+type Hook a = PackageDescription -> LocalBuildInfo -> UserHooks -> a -> IO ()
+
+build_primitive_sources :: Hook a -> Hook a
+build_primitive_sources f pd lbi uhs x
+ = do when (compilerFlavor (compiler lbi) == GHC) $ do
+          let genprimopcode = joinPath ["..", "..", "utils",
+                                        "genprimopcode", "genprimopcode"]
+              primops = joinPath ["..", "..", "compiler", "prelude",
+                                  "primops.txt"]
+              primhs = joinPath ["Language", "Core", "PrimEnv.hs"]
+              primhs_tmp = addExtension primhs "tmp"
+          maybeExit $ system (genprimopcode ++ " --make-ext-core-source < "
+                           ++ primops ++ " > " ++ primhs_tmp)
+          maybeUpdateFile primhs_tmp primhs
+          maybeExit $ system ("make -C lib/GHC_ExtCore")
+      f pd lbi uhs x
+
+-- Replace a file only if the new version is different from the old.
+-- This prevents make from doing unnecessary work after we run 'setup makefile'
+maybeUpdateFile :: FilePath -> FilePath -> IO ()
+maybeUpdateFile source target = do
+  r <- rawSystem "cmp" ["-s" {-quiet-}, source, target]
+  case r of
+    ExitSuccess   -> removeFile source
+    ExitFailure _ -> do try (removeFile target); renameFile source target
+
+
+\end{code}
\ No newline at end of file

diff --git a/utils/ext-core/extcore.cabal b/utils/ext-core/extcore.cabal
new file mode 100644 (file)
index 0000000..fd1e2df
--- /dev/null
+++ b/utils/ext-core/extcore.cabal
@@ -0,0 +1,19 @@
+name:                extcore
+version:             0.1
+synopsis:            Libraries for processing GHC Core
+description:         Libraries for processing GHC Core
+category:            Language
+license:             BSD3
+license-file:        LICENSE
+author:              Andrew Tolmach, Tim Chevalier, The GHC Team
+maintainer:          chevalier@alum.wellesley.edu
+stability:           alpha
+build-depends:       base, containers, directory, filepath, mtl, parsec, pretty
+exposed-modules:     Language.Core.Check, Language.Core.Dependencies, Language.Core.Core, Language.Core.Interp, Language.Core.Overrides, Language.Core.ParsecParser, Language.Core.Prep, Language.Core.Prims, Language.Core.Printer
+other-modules:       Language.Core.Encoding, Language.Core.Env,Language.Core.PrimCoercions, Language.Core.PrimEnv
+extensions:          DeriveDataTypeable PatternGuards
+ghc-options:         -Wall -O2
+tested-with:         GHC ==6.8.2
+data-files:          README
+build-type:          Simple
+

diff --git a/utils/genprimopcode/Main.hs b/utils/genprimopcode/Main.hs
index 54bdc8d..d228045 100644 (file)
--- a/utils/genprimopcode/Main.hs
+++ b/utils/genprimopcode/Main.hs
@@ -190,8 +190,9 @@ gen_ext_core_source entries =
    ++ "-- This module is automatically generated by the GHC utility\n"
    ++ "-- \"genprimopcode\". Do not edit!\n"
    ++ "-----------------------------------------------------------------------\n"
-   ++ "module PrimEnv(primTcs, primVals, intLitTypes, ratLitTypes,\n"
-   ++ "    charLitTypes, stringLitTypes) where\nimport Core\nimport Encoding\n\n"
+   ++ "module Language.Core.PrimEnv(primTcs, primVals, intLitTypes, ratLitTypes,"
+   ++ "\n charLitTypes, stringLitTypes) where\nimport Language.Core.Core"
+   ++ "\nimport Language.Core.Encoding\n\n"
    ++ "primTcs :: [(Tcon, Kind)]\n"
    ++ "primTcs = [\n"
    ++ printList tcEnt entries