diff --git a/.ctags b/.ctags
new file mode 100644
--- /dev/null
+++ b/.ctags
@@ -0,0 +1,4 @@
+--langdef=KEMPE
+--langmap=KEMPE:.kmp
+--regex-KEMPE=/([[:lower:]][[:alnum:]]+ *:)/\1/f,function/
+--regex-KEMPE=/type *([[:upper:]][[:alnum:]]+) */\1/t,type/
diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # kempe
 
+## 0.2.0.2
+
+  * Improve performance + generated code
+  * Fix bug in monomorphization of patterns
+
 ## 0.2.0.1
 
   * Performance improvements when assembling x86
diff --git a/docs/manual.pdf b/docs/manual.pdf
Binary files a/docs/manual.pdf and b/docs/manual.pdf differ
diff --git a/examples/os.kmp b/examples/os.kmp
new file mode 100644
--- /dev/null
+++ b/examples/os.kmp
@@ -0,0 +1,11 @@
+type OS { Macos | Linux | Windows | Freebsd }
+
+isUnix : OS -- Bool
+       =: [
+    { case
+        | Windows -> False
+        | _       -> True
+    }
+]
+
+%foreign cabi isUnix
diff --git a/kempe.cabal b/kempe.cabal
--- a/kempe.cabal
+++ b/kempe.cabal
@@ -1,6 +1,6 @@
 cabal-version:   3.0
 name:            kempe
-version:         0.2.0.1
+version:         0.2.0.2
 license:         BSD-3-Clause
 license-file:    LICENSE
 copyright:       Copyright: (c) 2020-2021 Vanessa McHale
@@ -21,6 +21,7 @@
     prelude/*.kmp
     lib/*.kmp
     docs/manual.pdf
+    .ctags
 
 extra-doc-files:
     README.md
@@ -79,6 +80,7 @@
         Kempe.Proc.As
         Kempe.Debug
         Prettyprinter.Ext
+        Prettyprinter.Debug
         Data.Foldable.Ext
         Data.Copointed
 
@@ -219,7 +221,8 @@
         temporary,
         filepath,
         tasty-golden,
-        tasty-hunit
+        tasty-hunit,
+        extra
 
     if impl(ghc >=8.0)
         ghc-options:
diff --git a/src/Kempe/AST.hs b/src/Kempe/AST.hs
--- a/src/Kempe/AST.hs
+++ b/src/Kempe/AST.hs
@@ -240,6 +240,9 @@
 prettyModuleGeneral atomizer (Module [] ds) = prettyDeclarationsGeneral atomizer ds
 prettyModuleGeneral atomizer (Module is ds) = prettyLines (fmap prettyImport is) <##> prettyDeclarationsGeneral atomizer ds
 
+prettyDecls :: Declarations a c b -> Doc ann
+prettyDecls = prettyDeclarationsGeneral pretty
+
 prettyFancyModule :: Declarations () (ConsAnn (StackType ())) (StackType ()) -> Doc ann
 prettyFancyModule = prettyTypedModule . fmap (first consTy)
 
diff --git a/src/Kempe/AST/Size.hs b/src/Kempe/AST/Size.hs
--- a/src/Kempe/AST/Size.hs
+++ b/src/Kempe/AST/Size.hs
@@ -44,7 +44,7 @@
 
 type MonoStackType = ([KempeTy ()], [KempeTy ()])
 
-prettyMonoStackType :: MonoStackType -> Doc a
+prettyMonoStackType :: ([KempeTy a], [KempeTy a]) -> Doc ann
 prettyMonoStackType (is, os) = sep (fmap pretty is) <+> "--" <+> sep (fmap pretty os)
 
 data BuiltinTy = TyInt
diff --git a/src/Kempe/Asm/Arm/Trans.hs b/src/Kempe/Asm/Arm/Trans.hs
--- a/src/Kempe/Asm/Arm/Trans.hs
+++ b/src/Kempe/Asm/Arm/Trans.hs
@@ -3,7 +3,7 @@
 module Kempe.Asm.Arm.Trans ( irToAarch64
                            ) where
 
-import           Data.Bits          (shiftR, (.&.))
+import           Data.Bits          (rotateR, (.&.))
 import           Data.Foldable.Ext  (foldMapA)
 import           Data.Int           (Int64)
 import           Data.List          (scanl')
@@ -106,9 +106,9 @@
 movRWord :: AbsReg -> Word -> [Arm AbsReg ()]
 movRWord r w = [MovRWord () r (fromIntegral b0), MovRK () r (fromIntegral b1) 16, MovRK () r (fromIntegral b2) 32, MovRK () r (fromIntegral b3) 48]
     where b0 = w .&. 0xFFFF
-          b1 = (w .&. 0xFFFF0000) `shiftR` 16
-          b2 = (w .&. 0xFFFF00000000) `shiftR` 32
-          b3 = (w .&. 0xFFFF000000000000) `shiftR` 48
+          b1 = (w .&. 0xFFFF0000) `rotateR` 16
+          b2 = (w .&. 0xFFFF00000000) `rotateR` 32
+          b3 = (w .&. 0xFFFF000000000000) `rotateR` 48
           -- TODO: only MovRK if nonzero
 
 evalE :: IR.Exp -> IR.Temp -> WriteM [Arm AbsReg ()]
diff --git a/src/Kempe/Asm/Liveness.hs b/src/Kempe/Asm/Liveness.hs
--- a/src/Kempe/Asm/Liveness.hs
+++ b/src/Kempe/Asm/Liveness.hs
@@ -5,12 +5,11 @@
                           , reconstruct
                           ) where
 
-import           Control.Composition (thread)
 import           Data.Copointed
 -- this seems to be faster
-import qualified Data.IntMap.Lazy    as IM
-import qualified Data.IntSet         as IS
-import           Data.Semigroup      ((<>))
+import qualified Data.IntMap.Lazy as IM
+import qualified Data.IntSet      as IS
+import           Data.Semigroup   ((<>))
 import           Kempe.Asm.Type
 
 emptyLiveness :: Liveness
@@ -56,8 +55,8 @@
     where nSt' = {-# SCC "iterNodes" #-} iterNodes is nSt
 
 iterNodes :: [Int] -> LivenessMap -> LivenessMap
--- this is fickle, thread will seemingly thunk leak (??) if optimizations aren't on
 iterNodes is = thread (fmap stepNode is)
+    where thread = foldr (.) id
 
 stepNode :: Int -> LivenessMap -> LivenessMap
 stepNode n ns = {-# SCC "stepNode" #-} IM.insert n (c, Liveness ins' out') ns
diff --git a/src/Kempe/IR.hs b/src/Kempe/IR.hs
--- a/src/Kempe/IR.hs
+++ b/src/Kempe/IR.hs
@@ -415,13 +415,23 @@
           -> Int64 -- ^ src offset
           -> Int64 -- ^ Number of bytes to copy
           -> [Stmt]
-copyBytes off1 off2 b
-    | b `mod` 8 == 0 =
-        let is = fmap (8*) [0..(b `div` 8 - 1)] in
-            [ MovMem (dataPointerPlus (i + off1)) 8 (Mem 8 $ dataPointerPlus (i + off2)) | i <- is ]
-    -- TODO: 4 byte chunks, &c. (would require more registers).
-    | otherwise =
-        [ MovMem (dataPointerPlus (i + off1)) 1 (Mem 1 $ dataPointerPlus (i + off2)) | i <- [0..(b-1)] ]
+copyBytes off1 off2 b =
+    let (b8, b1) = b `quotRem` 8
+        in copyBytes8 off1 off2 b8 ++ copyBytes1 (off1 + b8 * 8) (off2 + b8 * 8) b1
+        -- copyBytesPlain
+
+-- | Copy bytes 8 at a time. Note that @b@ must be divisible by 8.
+copyBytes8 :: Int64
+           -> Int64
+           -> Int64 -- ^ @b@ (number 8-byte chunks to copy)
+           -> [Stmt]
+copyBytes8 off1 off2 b =
+    let is = fmap (8*) [0..(b - 1)] in
+        [ MovMem (dataPointerPlus (i + off1)) 8 (Mem 8 $ dataPointerPlus (i + off2)) | i <- is ]
+
+copyBytes1 :: Int64 -> Int64 -> Int64 -> [Stmt]
+copyBytes1 off1 off2 b =
+    [ MovMem (dataPointerPlus (i + off1)) 1 (Mem 1 $ dataPointerPlus (i + off2)) | i <- [0..(b-1)] ]
 
 dataPointerDec :: Int64 -> Stmt
 dataPointerDec i = MovTemp DataPointer (ExprIntBinOp IntMinusIR (Reg DataPointer) (ConstInt i))
diff --git a/src/Kempe/Monomorphize.hs b/src/Kempe/Monomorphize.hs
--- a/src/Kempe/Monomorphize.hs
+++ b/src/Kempe/Monomorphize.hs
@@ -40,6 +40,8 @@
 import           Kempe.Unique
 import           Lens.Micro                 (Lens')
 import           Lens.Micro.Mtl             (modifying)
+import           Prettyprinter              (Doc, Pretty, vsep)
+import           Prettyprinter.Debug
 
 -- | New function names, keyed by name + specialized type
 --
@@ -52,6 +54,9 @@
 
 type MonoM = StateT RenameEnv (Either (Error ()))
 
+prettyDumpBinds :: (Pretty b, Pretty k) => M.Map k b -> Doc a
+prettyDumpBinds b = vsep (prettyBind <$> M.toList b)
+
 maxStateLens :: Lens' RenameEnv Int
 maxStateLens f s = fmap (\x -> s { maxState = x }) (f (maxState s))
 
@@ -258,7 +263,7 @@
     modifying fnEnvLens (M.insert (i, newStackType) j)
     pure (Name t' j newStackType)
 
-closure :: Ord b => (Declarations a b b, ModuleMap a b b) -> S.Set (Name b, b)
+closure :: (Declarations a (StackType ()) (StackType ()), ModuleMap a (StackType ()) (StackType ())) -> S.Set (Name (StackType ()), StackType ())
 closure (m, key) = loop roots S.empty
     where roots = S.fromList (exports m)
           loop ns avoid =
@@ -271,13 +276,13 @@
                 Just decl -> namesInDecl decl
                 Nothing   -> error "Internal error! module map should contain all names."
 
-namesInDecl :: Ord b => KempeDecl a b b -> S.Set (Name b, b)
+namesInDecl :: KempeDecl a (StackType ()) (StackType ()) -> S.Set (Name (StackType ()), StackType ())
 namesInDecl TyDecl{}             = S.empty
 namesInDecl ExtFnDecl{}          = S.empty
 namesInDecl Export{}             = S.empty
 namesInDecl (FunDecl _ _ _ _ as) = foldMap namesInAtom as
 
-namesInAtom :: Ord a => Atom a a -> S.Set (Name a, a)
+namesInAtom :: Atom (StackType ()) (StackType ()) -> S.Set (Name (StackType ()), StackType ())
 namesInAtom AtBuiltin{}                = S.empty
 namesInAtom (If _ as as')              = foldMap namesInAtom as <> foldMap namesInAtom as'
 namesInAtom (Dip _ as)                 = foldMap namesInAtom as
@@ -287,7 +292,11 @@
 namesInAtom BoolLit{}                  = S.empty
 namesInAtom Int8Lit{}                  = S.empty
 namesInAtom WordLit{}                  = S.empty
-namesInAtom (Case _ as)                = foldMap namesInAtom (foldMap snd as) -- FIXME: patterns too
+namesInAtom (Case _ as)                = foldMap namesInAtom (foldMap snd as) <> foldMap (namesInPattern . fst) as
+
+namesInPattern :: Pattern (StackType ()) (StackType ()) -> S.Set (Name (StackType ()), StackType ())
+namesInPattern (PatternCons _ tn@(Name _ _ l)) = S.singleton (tn, flipStackType l) -- we have to flipStackType here because the type is the reverse of the constructor that we want to look up
+namesInPattern _                               = S.empty
 
 exports :: Declarations a c b -> [(Name b, b)]
 exports = mapMaybe exportsDecl
diff --git a/src/Kempe/TyAssign.hs b/src/Kempe/TyAssign.hs
--- a/src/Kempe/TyAssign.hs
+++ b/src/Kempe/TyAssign.hs
@@ -29,6 +29,7 @@
 import           Lens.Micro                 (Lens', over)
 import           Lens.Micro.Mtl             (modifying, (.=))
 import           Prettyprinter              (Doc, Pretty (pretty), hardline, indent, vsep, (<+>))
+import           Prettyprinter.Debug
 import           Prettyprinter.Ext
 
 type TyEnv a = IM.IntMap (StackType a)
@@ -41,9 +42,6 @@
                          , constraints      :: S.Set (KempeTy a, KempeTy a) -- Just need equality between simple types? (do have tyapp but yeah)
                          }
 
-(<#*>) :: Doc a -> Doc a -> Doc a
-(<#*>) x y = x <> hardline <> indent 2 y
-
 instance Pretty (TyState a) where
     pretty (TyState _ te _ r _ cs) =
         "type environment:" <#> vsep (prettyBound <$> IM.toList te)
@@ -53,17 +51,11 @@
 prettyConstraints :: S.Set (KempeTy a, KempeTy a) -> Doc ann
 prettyConstraints cs = vsep (prettyEq <$> S.toList cs)
 
-prettyBound :: (Int, StackType a) -> Doc b
-prettyBound (i, e) = pretty i <+> "←" <#*> pretty e
-
 prettyEq :: (KempeTy a, KempeTy a) -> Doc ann
 prettyEq (ty, ty') = pretty ty <+> "≡" <+> pretty ty'
 
 prettyDumpBinds :: Pretty b => IM.IntMap b -> Doc a
 prettyDumpBinds b = vsep (prettyBind <$> IM.toList b)
-
-prettyBind :: Pretty b => (Int, b) -> Doc a
-prettyBind (i, j) = pretty i <+> "→" <+> pretty j
 
 emptyStackType :: StackType a
 emptyStackType = StackType mempty [] []
diff --git a/src/Prettyprinter/Debug.hs b/src/Prettyprinter/Debug.hs
new file mode 100644
--- /dev/null
+++ b/src/Prettyprinter/Debug.hs
@@ -0,0 +1,18 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Prettyprinter.Debug ( prettyBind
+                           , prettyBound
+                           , (<#*>)
+                           ) where
+
+import           Prettyprinter (Doc, Pretty (pretty), hardline, indent, (<+>))
+
+
+(<#*>) :: Doc a -> Doc a -> Doc a
+(<#*>) x y = x <> hardline <> indent 2 y
+
+prettyBind :: (Pretty c, Pretty b) => (c, b) -> Doc a
+prettyBind (i, j) = pretty i <+> "→" <+> pretty j
+
+prettyBound :: (Pretty a, Pretty c) => (a, c) -> Doc b
+prettyBound (i, e) = pretty i <+> "←" <#*> pretty e
diff --git a/test/Backend.hs b/test/Backend.hs
--- a/test/Backend.hs
+++ b/test/Backend.hs
@@ -30,6 +30,7 @@
         , irNoYeet "examples/splitmix.kmp"
         , irNoYeet "examples/factorial.kmp"
         , irNoYeet "test/data/maybeC.kmp"
+        , irNoYeet "examples/os.kmp"
         , x86NoYeet "examples/factorial.kmp"
         , x86NoYeet "examples/splitmix.kmp"
         , armNoYeet "examples/factorial.kmp"
diff --git a/test/Golden.hs b/test/Golden.hs
--- a/test/Golden.hs
+++ b/test/Golden.hs
@@ -1,28 +1,28 @@
 module Main (main) where
 
+import           Data.Tuple.Extra (uncurry3)
 import           Harness
-import           System.Info (arch)
+import           System.Info      (arch)
 import           Test.Tasty
 
 main :: IO ()
 main = defaultMain $
     testGroup "Golden output tests" $
-        [ goldenOutput "examples/factorial.kmp" "test/harness/factorial.c" "test/golden/factorial.out"
-        , goldenOutput "test/examples/splitmix.kmp" "test/harness/splitmix.c" "test/golden/splitmix.out"
-        , goldenOutput "lib/numbertheory.kmp" "test/harness/numbertheory.c" "test/golden/numbertheory.out"
-        , goldenOutput "test/examples/hamming.kmp" "test/harness/hamming.c" "test/golden/hamming.out"
-        , goldenOutput "test/examples/bool.kmp" "test/harness/bool.c" "test/golden/bool.out"
-        , goldenOutput "test/examples/const.kmp" "test/harness/const.c" "test/golden/const.out"
-        ] ++ crossTests
+        fmap (uncurry3 goldenOutput) allGoldens ++ crossTests
 
 -- These are redundant on arm
 crossTests :: [TestTree]
 crossTests = case arch of
-    "x86_64" -> [ compileArm "examples/factorial.kmp"
-                , compileArm "lib/numbertheory.kmp"
-                , compileArm "test/examples/bool.kmp"
-                , compileArm "examples/splitmix.kmp"
-                , compileArm "lib/gaussian.kmp"
-                ]
+    "x86_64"  -> fmap (uncurry3 crossGolden) allGoldens
     "aarch64" -> []
-    _ -> error "Test suite must be run on x86_64 or aarch64"
+    _         -> error "Test suite must be run on x86_64 or aarch64"
+
+allGoldens :: [(FilePath, FilePath, FilePath)]
+allGoldens =
+    [ ("examples/factorial.kmp", "test/harness/factorial.c", "test/golden/factorial.out")
+    , ("test/examples/splitmix.kmp", "test/harness/splitmix.c", "test/golden/splitmix.out")
+    , ("lib/numbertheory.kmp", "test/harness/numbertheory.c", "test/golden/numbertheory.out")
+    , ("test/examples/hamming.kmp", "test/harness/hamming.c", "test/golden/hamming.out")
+    , ("test/examples/bool.kmp", "test/harness/bool.c", "test/golden/bool.out")
+    , ("test/examples/const.kmp", "test/harness/const.c", "test/golden/const.out")
+    ]
diff --git a/test/Harness.hs b/test/Harness.hs
--- a/test/Harness.hs
+++ b/test/Harness.hs
@@ -1,5 +1,5 @@
 module Harness ( goldenOutput
-               , compileArm
+               , crossGolden
                ) where
 
 import qualified Data.ByteString.Lazy       as BSL
@@ -9,24 +9,24 @@
 import           System.FilePath            ((</>))
 import           System.IO.Temp
 import           System.Info                (arch)
-import           System.Process             (CreateProcess (std_err), StdStream (Inherit), proc, readCreateProcess)
+import           System.Process             (CreateProcess (env, std_err), StdStream (Inherit), proc, readCreateProcess)
 import           Test.Tasty
 import           Test.Tasty.Golden          (goldenVsString)
 import           Test.Tasty.HUnit           (assertBool, testCase)
 
--- | Assemble using @nasm@, output in some file.
-runGcc :: [FilePath]
+data CC = CC
+        | ArmCC
+
+instance Show CC where
+    show CC    = "cc"
+    show ArmCC = "aarch64-linux-gnu-gcc"
+
+runGcc :: CC
+       -> [FilePath]
        -> FilePath
        -> IO ()
-runGcc fps o =
-    void $ readCreateProcess ((proc "cc" (fps ++ ["-o", o])) { std_err = Inherit }) ""
-
-compileArm :: FilePath -> TestTree
-compileArm fp = testCase "Assembles arm" $
-    withSystemTempDirectory "kmp" $ \dir -> do
-        let oFile = dir </> "kempe.o"
-        armCompile fp oFile False
-        assertBool "Doesn't throw exception" True
+runGcc cc fps o =
+    void $ readCreateProcess ((proc (show cc) (fps ++ ["-o", o])) { std_err = Inherit }) ""
 
 compileOutput :: FilePath
               -> FilePath
@@ -40,13 +40,33 @@
                 "aarch64" -> armCompile
                 _         -> error "Internal error in test suite! Must run on either x86_64 or aarch64"
         compiler fp oFile False
-        runGcc [oFile, harness] exe
+        runGcc CC [oFile, harness] exe
         readExe exe
     where readExe fp' = ASCII.pack <$> readCreateProcess ((proc fp' []) { std_err = Inherit }) ""
 
+crossCompileOutput :: FilePath
+                   -> FilePath
+                   -> IO BSL.ByteString
+crossCompileOutput fp harness =
+    withSystemTempDirectory "kmp" $ \dir -> do
+        let oFile = dir </> "kempe.o"
+            exe = dir </> "kempe"
+        armCompile fp oFile False
+        runGcc ArmCC [oFile, harness] exe
+        readExe exe
+    where readExe fp' = ASCII.pack <$> readCreateProcess ((proc "qemu-aarch64-static" [fp']) { std_err = Inherit, env = qemuEnv }) ""
+          qemuEnv = Just [("QEMU_LD_PREFIX", "/usr/aarch64-linux-gnu/")]
+
 goldenOutput :: FilePath -- ^ Kempe file
              -> FilePath -- ^ C test harness
              -> FilePath -- ^ Golden file path
              -> TestTree
 goldenOutput kFp cFp golden =
     goldenVsString kFp golden (compileOutput kFp cFp)
+
+crossGolden :: FilePath -- ^ Kempe file
+            -> FilePath -- ^ C test harness
+            -> FilePath -- ^ Golden file path
+            -> TestTree
+crossGolden kFp cFp golden =
+    goldenVsString kFp golden (crossCompileOutput kFp cFp)
diff --git a/test/err/badWildcard.kmp b/test/err/badWildcard.kmp
new file mode 100644
--- /dev/null
+++ b/test/err/badWildcard.kmp
@@ -0,0 +1,10 @@
+type Maybe a { Just a | Nothing }
+
+return0 : (Maybe a) -- Int
+       =: [
+    { case
+        | _ -> 2
+    }
+]
+
+%foreign kabi return0
diff --git a/test/golden/gaussian.ir b/test/golden/gaussian.ir
--- a/test/golden/gaussian.ir
+++ b/test/golden/gaussian.ir
@@ -6,22 +6,8 @@
 kmp2:
 (movtemp datapointer (- (reg datapointer) (int 17)))
 (call kmp1)
-(movmem (reg datapointer) (mem [1] (+ (reg datapointer) (int 17))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 18))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 19))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 20))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 21))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 22))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 23))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 24))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 25))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 26))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 27))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 28))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 29))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 30))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 31))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 32))))
+(movmem (reg datapointer) (mem [8] (+ (reg datapointer) (int 17))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (+ (reg datapointer) (int 25))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 33))))
 (movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 24))))
 (movmem (- (reg datapointer) (int 24)) (mem [8] (- (reg datapointer) (int 16))))
@@ -46,22 +32,8 @@
 kmp3:
 (movtemp datapointer (- (reg datapointer) (int 17)))
 (call kmp1)
-(movmem (reg datapointer) (mem [1] (+ (reg datapointer) (int 17))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 18))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 19))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 20))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 21))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 22))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 23))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 24))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 25))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 26))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 27))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 28))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 29))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 30))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 31))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 32))))
+(movmem (reg datapointer) (mem [8] (+ (reg datapointer) (int 17))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (+ (reg datapointer) (int 25))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 33))))
 (movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 24))))
 (movmem (- (reg datapointer) (int 24)) (mem [8] (- (reg datapointer) (int 16))))
@@ -86,198 +58,44 @@
 (ret)
 
 kmp4:
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 17))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 16))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 15))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 14))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 13))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 12))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 11))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 10))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 9))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 8))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 7))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 6))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 5))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 4))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 3))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 2))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 17))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (- (reg datapointer) (int 9))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 34))))
-(movmem (- (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 33))))
-(movmem (- (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 32))))
-(movmem (- (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 31))))
-(movmem (- (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 30))))
-(movmem (- (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 29))))
-(movmem (- (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 28))))
-(movmem (- (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 27))))
-(movmem (- (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 26))))
-(movmem (- (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 25))))
-(movmem (- (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 24))))
-(movmem (- (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 23))))
-(movmem (- (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 22))))
-(movmem (- (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 21))))
-(movmem (- (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 20))))
-(movmem (- (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 19))))
+(movmem (- (reg datapointer) (int 17)) (mem [8] (- (reg datapointer) (int 34))))
+(movmem (- (reg datapointer) (int 9)) (mem [8] (- (reg datapointer) (int 26))))
 (movmem (- (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 18))))
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 0))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 0))))
 (movtemp datapointer (+ (reg datapointer) (int 17)))
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 34))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 33))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 32))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 31))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 30))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 29))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 28))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 27))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 26))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 25))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 24))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 23))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 22))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 21))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 20))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 19))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 34))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (- (reg datapointer) (int 26))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 18))))
-(movmem (- (reg datapointer) (int 34)) (mem [1] (- (reg datapointer) (int 17))))
-(movmem (- (reg datapointer) (int 33)) (mem [1] (- (reg datapointer) (int 16))))
-(movmem (- (reg datapointer) (int 32)) (mem [1] (- (reg datapointer) (int 15))))
-(movmem (- (reg datapointer) (int 31)) (mem [1] (- (reg datapointer) (int 14))))
-(movmem (- (reg datapointer) (int 30)) (mem [1] (- (reg datapointer) (int 13))))
-(movmem (- (reg datapointer) (int 29)) (mem [1] (- (reg datapointer) (int 12))))
-(movmem (- (reg datapointer) (int 28)) (mem [1] (- (reg datapointer) (int 11))))
-(movmem (- (reg datapointer) (int 27)) (mem [1] (- (reg datapointer) (int 10))))
-(movmem (- (reg datapointer) (int 26)) (mem [1] (- (reg datapointer) (int 9))))
-(movmem (- (reg datapointer) (int 25)) (mem [1] (- (reg datapointer) (int 8))))
-(movmem (- (reg datapointer) (int 24)) (mem [1] (- (reg datapointer) (int 7))))
-(movmem (- (reg datapointer) (int 23)) (mem [1] (- (reg datapointer) (int 6))))
-(movmem (- (reg datapointer) (int 22)) (mem [1] (- (reg datapointer) (int 5))))
-(movmem (- (reg datapointer) (int 21)) (mem [1] (- (reg datapointer) (int 4))))
-(movmem (- (reg datapointer) (int 20)) (mem [1] (- (reg datapointer) (int 3))))
-(movmem (- (reg datapointer) (int 19)) (mem [1] (- (reg datapointer) (int 2))))
+(movmem (- (reg datapointer) (int 34)) (mem [8] (- (reg datapointer) (int 17))))
+(movmem (- (reg datapointer) (int 26)) (mem [8] (- (reg datapointer) (int 9))))
 (movmem (- (reg datapointer) (int 18)) (mem [1] (- (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 0))))
-(movmem (- (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 2))))
-(movmem (- (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 3))))
-(movmem (- (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 4))))
-(movmem (- (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 5))))
-(movmem (- (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 6))))
-(movmem (- (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 7))))
-(movmem (- (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 8))))
-(movmem (- (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 9))))
-(movmem (- (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 10))))
-(movmem (- (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 11))))
-(movmem (- (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 12))))
-(movmem (- (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 13))))
-(movmem (- (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 14))))
-(movmem (- (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 15))))
+(movmem (- (reg datapointer) (int 17)) (mem [8] (- (reg datapointer) (int 0))))
+(movmem (- (reg datapointer) (int 9)) (mem [8] (+ (reg datapointer) (int 8))))
 (movmem (- (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 16))))
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 17))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 16))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 15))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 14))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 13))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 12))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 11))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 10))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 9))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 8))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 7))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 6))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 5))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 4))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 3))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 2))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 17))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (- (reg datapointer) (int 9))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 34))))
-(movmem (- (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 33))))
-(movmem (- (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 32))))
-(movmem (- (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 31))))
-(movmem (- (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 30))))
-(movmem (- (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 29))))
-(movmem (- (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 28))))
-(movmem (- (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 27))))
-(movmem (- (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 26))))
-(movmem (- (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 25))))
-(movmem (- (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 24))))
-(movmem (- (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 23))))
-(movmem (- (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 22))))
-(movmem (- (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 21))))
-(movmem (- (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 20))))
-(movmem (- (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 19))))
+(movmem (- (reg datapointer) (int 17)) (mem [8] (- (reg datapointer) (int 34))))
+(movmem (- (reg datapointer) (int 9)) (mem [8] (- (reg datapointer) (int 26))))
 (movmem (- (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 18))))
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 0))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 0))))
 (movtemp datapointer (+ (reg datapointer) (int 17)))
-(movmem (reg datapointer) (mem [1] (- (reg datapointer) (int 34))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (- (reg datapointer) (int 33))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (- (reg datapointer) (int 32))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (- (reg datapointer) (int 31))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (- (reg datapointer) (int 30))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (- (reg datapointer) (int 29))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (- (reg datapointer) (int 28))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (- (reg datapointer) (int 27))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (- (reg datapointer) (int 26))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (- (reg datapointer) (int 25))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (- (reg datapointer) (int 24))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (- (reg datapointer) (int 23))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (- (reg datapointer) (int 22))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (- (reg datapointer) (int 21))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (- (reg datapointer) (int 20))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (- (reg datapointer) (int 19))))
+(movmem (reg datapointer) (mem [8] (- (reg datapointer) (int 34))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (- (reg datapointer) (int 26))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (- (reg datapointer) (int 18))))
-(movmem (- (reg datapointer) (int 34)) (mem [1] (- (reg datapointer) (int 17))))
-(movmem (- (reg datapointer) (int 33)) (mem [1] (- (reg datapointer) (int 16))))
-(movmem (- (reg datapointer) (int 32)) (mem [1] (- (reg datapointer) (int 15))))
-(movmem (- (reg datapointer) (int 31)) (mem [1] (- (reg datapointer) (int 14))))
-(movmem (- (reg datapointer) (int 30)) (mem [1] (- (reg datapointer) (int 13))))
-(movmem (- (reg datapointer) (int 29)) (mem [1] (- (reg datapointer) (int 12))))
-(movmem (- (reg datapointer) (int 28)) (mem [1] (- (reg datapointer) (int 11))))
-(movmem (- (reg datapointer) (int 27)) (mem [1] (- (reg datapointer) (int 10))))
-(movmem (- (reg datapointer) (int 26)) (mem [1] (- (reg datapointer) (int 9))))
-(movmem (- (reg datapointer) (int 25)) (mem [1] (- (reg datapointer) (int 8))))
-(movmem (- (reg datapointer) (int 24)) (mem [1] (- (reg datapointer) (int 7))))
-(movmem (- (reg datapointer) (int 23)) (mem [1] (- (reg datapointer) (int 6))))
-(movmem (- (reg datapointer) (int 22)) (mem [1] (- (reg datapointer) (int 5))))
-(movmem (- (reg datapointer) (int 21)) (mem [1] (- (reg datapointer) (int 4))))
-(movmem (- (reg datapointer) (int 20)) (mem [1] (- (reg datapointer) (int 3))))
-(movmem (- (reg datapointer) (int 19)) (mem [1] (- (reg datapointer) (int 2))))
+(movmem (- (reg datapointer) (int 34)) (mem [8] (- (reg datapointer) (int 17))))
+(movmem (- (reg datapointer) (int 26)) (mem [8] (- (reg datapointer) (int 9))))
 (movmem (- (reg datapointer) (int 18)) (mem [1] (- (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 17)) (mem [1] (- (reg datapointer) (int 0))))
-(movmem (- (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 1))))
-(movmem (- (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 2))))
-(movmem (- (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 3))))
-(movmem (- (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 4))))
-(movmem (- (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 5))))
-(movmem (- (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 6))))
-(movmem (- (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 7))))
-(movmem (- (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 8))))
-(movmem (- (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 9))))
-(movmem (- (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 10))))
-(movmem (- (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 11))))
-(movmem (- (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 12))))
-(movmem (- (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 13))))
-(movmem (- (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 14))))
-(movmem (- (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 15))))
+(movmem (- (reg datapointer) (int 17)) (mem [8] (- (reg datapointer) (int 0))))
+(movmem (- (reg datapointer) (int 9)) (mem [8] (+ (reg datapointer) (int 8))))
 (movmem (- (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 16))))
 (movtemp datapointer (- (reg datapointer) (int 17)))
 (call kmp1)
-(movmem (reg datapointer) (mem [1] (+ (reg datapointer) (int 17))))
-(movmem (+ (reg datapointer) (int 1)) (mem [1] (+ (reg datapointer) (int 18))))
-(movmem (+ (reg datapointer) (int 2)) (mem [1] (+ (reg datapointer) (int 19))))
-(movmem (+ (reg datapointer) (int 3)) (mem [1] (+ (reg datapointer) (int 20))))
-(movmem (+ (reg datapointer) (int 4)) (mem [1] (+ (reg datapointer) (int 21))))
-(movmem (+ (reg datapointer) (int 5)) (mem [1] (+ (reg datapointer) (int 22))))
-(movmem (+ (reg datapointer) (int 6)) (mem [1] (+ (reg datapointer) (int 23))))
-(movmem (+ (reg datapointer) (int 7)) (mem [1] (+ (reg datapointer) (int 24))))
-(movmem (+ (reg datapointer) (int 8)) (mem [1] (+ (reg datapointer) (int 25))))
-(movmem (+ (reg datapointer) (int 9)) (mem [1] (+ (reg datapointer) (int 26))))
-(movmem (+ (reg datapointer) (int 10)) (mem [1] (+ (reg datapointer) (int 27))))
-(movmem (+ (reg datapointer) (int 11)) (mem [1] (+ (reg datapointer) (int 28))))
-(movmem (+ (reg datapointer) (int 12)) (mem [1] (+ (reg datapointer) (int 29))))
-(movmem (+ (reg datapointer) (int 13)) (mem [1] (+ (reg datapointer) (int 30))))
-(movmem (+ (reg datapointer) (int 14)) (mem [1] (+ (reg datapointer) (int 31))))
-(movmem (+ (reg datapointer) (int 15)) (mem [1] (+ (reg datapointer) (int 32))))
+(movmem (reg datapointer) (mem [8] (+ (reg datapointer) (int 17))))
+(movmem (+ (reg datapointer) (int 8)) (mem [8] (+ (reg datapointer) (int 25))))
 (movmem (+ (reg datapointer) (int 16)) (mem [1] (+ (reg datapointer) (int 33))))
 (movtemp datapointer (- (reg datapointer) (int 16)))
 (movtemp t_11 (mem [8] (reg datapointer)))