diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## 1.3.0 (2024-04-13)
+* move type-level byte stuff to another package
+
+## 1.2.0 (2024-04-11)
+* fix type-level generic blen type family (needed defunctionalization)
+  * split out into its own even _more_ abstract library, generic-type-functions
+* add missing instance `Integral (ByteOrdered end a)`
+* add struct parser! design taken from flatparse. barebones combinators
+  * add type-level byte parsing. hahahaha
+* add `Bytezap.Poke.toStructPoke :: Poke s -> Struct.Poke s`
+
 ## 1.1.0 (2024-04-05)
 * add struct serializer
 * add type-level bytestring utilities (generalized from binrep)
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,11 +1,12 @@
+[hackage-binrep]: https://hackage.haskell.org/package/binrep
+
 # bytezap
 Build strict bytestrings with zero intermediate allocation.
 
 If you're looking for general high-performance serialization, you probably want
 [mason](https://hackage.haskell.org/package/mason). But if you're dealing with
 data that is already "shaped" like binary data, e.g. using types defined in
-[binrep](https://hackage.haskell.org/package/binrep), and you want the best
-performance possible, read on...
+[binrep][hackage-binrep], and you want the best performance possible, read on...
 
 ## Why?
 Most binary serialization libraries tend towards a model where the serializer
@@ -36,7 +37,14 @@
 ## So... why?
 Well, bytezap will be slightly faster where it's applicable, and the
 implementation is extremely simple. It's a fun niche to fill, and it's
-convenient for my [binrep](https://hackage.haskell.org/package/binrep) library.
+convenient for my [binrep][hackage-binrep] library.
+
+## Struct handling
+We define even simpler parser & serializer types which can only handle "C
+struct"-like types, where there is only one constructor and all fields have
+known length at compile time. The way these work, GHC is pretty much guaranteed
+to generate the fastest code possible. These are very experimental, but see
+[binrep][hackage-binrep] for example usage.
 
 ## Non-features
 ### Serialize to `ByteString` (pinned byte arrays) only
diff --git a/bytezap.cabal b/bytezap.cabal
--- a/bytezap.cabal
+++ b/bytezap.cabal
@@ -5,10 +5,10 @@
 -- see: https://github.com/sol/hpack
 
 name:           bytezap
-version:        1.1.0
+version:        1.3.0
 synopsis:       Bytestring builder with zero intermediate allocation
 description:    Please see README.md.
-category:       Data, Serialization
+category:       Data, Serialization, Generics
 homepage:       https://github.com/raehik/bytezap#readme
 bug-reports:    https://github.com/raehik/bytezap/issues
 author:         Ben Orchard
@@ -29,6 +29,10 @@
 library
   exposed-modules:
       Bytezap
+      Bytezap.Common.Generic
+      Bytezap.Parser.Struct
+      Bytezap.Parser.Struct.Generic
+      Bytezap.Parser.Struct.TypeLits.Bytes
       Bytezap.Poke
       Bytezap.Poke.Derived
       Bytezap.Poke.Derived.Endian
@@ -36,7 +40,7 @@
       Bytezap.Poke.KnownLen
       Bytezap.Struct
       Bytezap.Struct.Generic
-      Bytezap.Struct.TypeLits
+      Bytezap.Struct.TypeLits.Bytes
       Bytezap.Write
       Bytezap.Write.Derived
       Bytezap.Write.Internal
@@ -46,7 +50,6 @@
       Raehik.Compat.Data.Word.ByteSwap
       Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops
       Raehik.Compat.GHC.Exts.GHC910UnalignedAddrPrimops
-      Raehik.TypeLevelBytes
       Util.TypeNats
   other-modules:
       Paths_bytezap
@@ -69,6 +72,9 @@
   build-depends:
       base >=4.18.0.0 && <4.20
     , bytestring >=0.11.5.3 && <0.13.0.0
+    , defun-core ==0.1.*
+    , generic-type-functions >=0.1.0 && <0.2
     , primitive >=0.8.0.0 && <0.10.0.0
     , text >=2.0.2 && <2.2
+    , type-level-bytestrings >=0.1.0 && <0.2
   default-language: GHC2021
diff --git a/src/Bytezap/Common/Generic.hs b/src/Bytezap/Common/Generic.hs
new file mode 100644
--- /dev/null
+++ b/src/Bytezap/Common/Generic.hs
@@ -0,0 +1,16 @@
+module Bytezap.Common.Generic where
+
+import GHC.TypeNats
+import DeFun.Core ( type (~>), type App )
+import Generic.Type.Function.FoldMap ( type GTFoldMapC )
+
+type PlusSym :: Natural ~> Natural ~> Natural
+data PlusSym f
+type instance App PlusSym f = PlusSym1 f
+
+type PlusSym1 :: Natural -> Natural ~> Natural
+data PlusSym1 l r
+type instance App (PlusSym1 l) r = l + r
+
+-- | Generic type 'foldMap' using the addition monoid.
+type GTFoldMapCAddition f gf = GTFoldMapC PlusSym 0 f gf
diff --git a/src/Bytezap/Parser/Struct.hs b/src/Bytezap/Parser/Struct.hs
new file mode 100644
--- /dev/null
+++ b/src/Bytezap/Parser/Struct.hs
@@ -0,0 +1,160 @@
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE PatternSynonyms #-}
+{-# LANGUAGE BlockArguments #-}
+-- {-# LANGUAGE DataKinds #-} -- needed for manual ZeroBitType def (unsure why)
+-- {-# LANGUAGE FlexibleInstances #-}
+
+{- | Struct parser.
+
+We do still have to do failure checking, because unlike C we check some types
+(e.g. bitfields). Hopefully inlining can remove those checks when unnecessary.
+-}
+
+module Bytezap.Parser.Struct where
+
+import GHC.Exts
+import GHC.ForeignPtr
+import Data.Void ( Void )
+
+import Data.Word ( Word8 )
+import Data.ByteString.Internal qualified as B
+import System.IO.Unsafe ( unsafePerformIO )
+
+import Raehik.Compat.Data.Primitive.Types
+
+type PureMode = Proxy# Void
+type IOMode   = State# RealWorld
+type STMode s = State# s
+
+type ParserT# (st :: ZeroBitType) e a =
+       ForeignPtrContents {- ^ pointer provenance -}
+    -> Addr# {- ^ base address -}
+    -> Int#  {- ^ cursor offset from base -}
+    -> st    {- ^ state token -}
+    -> Res# st e a
+
+-- we take a 'ForeignPtrContents' because it lets us create bytestrings without
+-- copying if we want. it's useful
+newtype ParserT (st :: ZeroBitType) e a =
+    ParserT { runParserT# :: ParserT# st e a }
+
+instance Functor (ParserT st e) where
+  fmap f (ParserT g) = ParserT \fpc base os st0 -> case g fpc base os st0 of
+    OK# st1 a -> let !b = f a in OK# st1 b
+    x         -> unsafeCoerce# x
+  {-# inline fmap #-}
+
+-- No Applicative due to no offset passing.
+
+-- | The type of pure parsers.
+type Parser     = ParserT PureMode
+
+-- | The type of parsers which can embed `IO` actions.
+type ParserIO   = ParserT IOMode
+
+-- | The type of parsers which can embed `ST` actions.
+type ParserST s = ParserT (STMode s)
+
+-- | Primitive parser result wrapped with a state token.
+--
+-- You should rarely need to manipulate values of this type directly. Use the
+-- provided bidirectional pattern synonyms 'OK#', 'Fail#' and 'Err#'.
+type Res# (st :: ZeroBitType) e a =
+  (# st, ResI# e a #)
+
+-- | Primitive parser result.
+type ResI# e a =
+  (#
+    (# a #)
+  | (# #)
+  | (# e #)
+  #)
+
+-- | 'Res#' constructor for a successful parse.
+--   Contains the return value and a state token.
+pattern OK# :: (st :: ZeroBitType) -> a -> Res# st e a
+pattern OK# st a = (# st, (# (# a #) | | #) #)
+
+-- | 'Res#' constructor for recoverable failure.
+--   Contains only a state token.
+pattern Fail# :: (st :: ZeroBitType) -> Res# st e a
+pattern Fail# st = (# st, (# | (# #) | #) #)
+
+-- | 'Res#' constructor for errors which are by default non-recoverable.
+--    Contains the error, plus a state token.
+pattern Err# :: (st :: ZeroBitType) -> e -> Res# st e a
+pattern Err# st e = (# st, (# | | (# e #) #) #)
+{-# complete OK#, Fail#, Err# #-}
+
+-- | caller must guarantee that buffer is long enough for parser!!
+unsafeRunParserBs :: forall a e. B.ByteString -> Parser e a -> Result e a
+unsafeRunParserBs (B.BS fptr _) = unsafeRunParserFPtr fptr
+
+-- | caller must guarantee that buffer is long enough for parser!!
+unsafeRunParserPtr :: forall a e. Ptr Word8 -> Parser e a -> Result e a
+unsafeRunParserPtr (Ptr base#) = unsafeRunParser' base# FinalPtr
+
+-- | caller must guarantee that buffer is long enough for parser!!
+unsafeRunParserFPtr :: forall a e. ForeignPtr Word8 -> Parser e a -> Result e a
+unsafeRunParserFPtr fptr p =
+    unsafePerformIO $ B.unsafeWithForeignPtr fptr $ \ptr ->
+        pure $ unsafeRunParserPtr ptr p
+
+-- | caller must guarantee that buffer is long enough for parser!!
+unsafeRunParser'
+    :: forall a e. Addr# -> ForeignPtrContents -> Parser e a -> Result e a
+unsafeRunParser' base# fpc (ParserT p) =
+    case p fpc base# 0# proxy# of
+      OK#   _st1 a -> OK a
+      Fail# _st1   -> Fail
+      Err#  _st1 e -> Err e
+
+-- | Higher-level boxed data type for parsing results.
+data Result e a =
+    OK a    -- ^ Contains return value.
+  | Fail    -- ^ Recoverable-by-default failure.
+  | Err !e  -- ^ Unrecoverable-by-default error.
+  deriving Show
+
+-- | can't provide via 'pure' as no 'Applicative'
+constParse :: a -> ParserT st e a
+constParse a = ParserT \_fpc _base _os st -> OK# st a
+
+sequenceParsers
+    :: Int -> (a -> b -> c)
+    -> ParserT st e a -> ParserT st e b -> ParserT st e c
+sequenceParsers (I# len#) f (ParserT pa) (ParserT pb) =
+    ParserT \fpc base os# st0 ->
+        case pa fpc base os# st0 of
+          Fail# st1 ->  Fail# st1
+          Err# st1 e -> Err# st1 e
+          OK# st1 a ->
+            case pb fpc base (os# +# len#) st1 of
+              Fail# st2 ->  Fail# st2
+              Err# st2 e -> Err# st2 e
+              OK# st2 b -> OK# st2 (f a b)
+
+-- TODO using indexWord8OffAddrAs to permit pure mode. flatparse does this (at
+-- least for integers). guess it's OK?
+prim :: forall a st e. Prim' a => ParserT st e a
+prim = ParserT \_fpc base os st ->
+    case indexWord8OffAddrAs# base os of a -> OK# st a
+
+-- | parse literal
+lit :: Eq a => a -> ParserT st e a -> ParserT st e ()
+lit al (ParserT p) = ParserT \fpc base os st0 ->
+    case p fpc base os st0 of
+      Fail# st1    -> Fail# st1
+      Err#  st1 e  -> Err#  st1 e
+      OK#   st1 ar -> if al == ar then OK# st1 () else Fail# st1
+
+-- | parse literal (CPS)
+withLit
+    :: Eq a => Int# -> a -> ParserT st e a -> ParserT st e r -> ParserT st e r
+withLit len# al (ParserT p) (ParserT pCont) = ParserT \fpc base os# st0 ->
+    case p fpc base os# st0 of
+      Fail# st1    -> Fail# st1
+      Err#  st1 e  -> Err#  st1 e
+      OK#   st1 ar ->
+        if al == ar then pCont fpc base (os# +# len#) st1 else Fail# st1
diff --git a/src/Bytezap/Parser/Struct/Generic.hs b/src/Bytezap/Parser/Struct/Generic.hs
new file mode 100644
--- /dev/null
+++ b/src/Bytezap/Parser/Struct/Generic.hs
@@ -0,0 +1,53 @@
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE UndecidableInstances #-} -- thanks to type manipulation
+
+module Bytezap.Parser.Struct.Generic where
+
+import Bytezap.Parser.Struct
+import GHC.Generics
+import GHC.Exts
+import Data.Kind
+import GHC.TypeNats
+import Util.TypeNats ( natValInt )
+import Bytezap.Common.Generic ( type GTFoldMapCAddition )
+import DeFun.Core ( type (~>) )
+
+class GParseBase tag where
+    -- | The state token of the parser.
+    type GParseBaseSt tag :: ZeroBitType
+    type GParseBaseC tag a :: Constraint
+    type GParseBaseE tag :: Type
+
+    -- unlike the serializer we stay newtyped because we want our Functor
+    gParseBase
+        :: GParseBaseC tag a
+        => ParserT (GParseBaseSt tag) (GParseBaseE tag) a
+
+    -- | Defunctionalization symbol for a type family turning 'Type's into
+    --   'Natural's. (Needed as we can't partially apply type families.)
+    type GParseBaseLenTF tag :: Type ~> Natural
+
+class GParse tag gf where
+    gParse :: ParserT (GParseBaseSt tag) (GParseBaseE tag) (gf p)
+
+instance GParse tag gf => GParse tag (D1 cd gf) where
+    gParse = M1 <$> gParse @tag
+instance GParse tag gf => GParse tag (C1 cc gf) where
+    gParse = M1 <$> gParse @tag
+
+instance
+  ( GParse tag l
+  , GParse tag r
+  , GParseBase tag
+  , lenL ~ GTFoldMapCAddition (GParseBaseLenTF tag) l
+  , KnownNat lenL
+  ) => GParse tag (l :*: r) where
+    gParse = sequenceParsers len (:*:) (gParse @tag) (gParse @tag)
+      where
+        len = natValInt @lenL
+
+instance (GParseBase tag, GParseBaseC tag a) => GParse tag (S1 c (Rec0 a)) where
+    gParse = (M1 . K1) <$> gParseBase @tag
+
+-- | Wow, look! Nothing!
+instance GParse tag U1 where gParse = constParse U1
diff --git a/src/Bytezap/Parser/Struct/TypeLits/Bytes.hs b/src/Bytezap/Parser/Struct/TypeLits/Bytes.hs
new file mode 100644
--- /dev/null
+++ b/src/Bytezap/Parser/Struct/TypeLits/Bytes.hs
@@ -0,0 +1,95 @@
+{- | Efficient type-level bytestring parsing.
+
+One may implement this using the type-level serializing, but mirroring it for
+parsing does less work and allocation.
+-}
+
+{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}
+
+module Bytezap.Parser.Struct.TypeLits.Bytes where
+
+import Data.Type.Byte
+import Bytezap.Parser.Struct ( ParserT, prim, withLit, constParse )
+import Numeric.Natural ( Natural )
+
+class ParseReifyBytesW64 (ns :: [Natural]) where
+    parseReifyBytesW64 :: ParserT st e ()
+
+-- | Enough bytes to make a 'Word64'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ReifyW8 n3
+  , ReifyW8 n4
+  , ReifyW8 n5
+  , ReifyW8 n6
+  , ReifyW8 n7
+  , ReifyW8 n8
+  , ParseReifyBytesW64 ns
+  ) => ParseReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where
+    {-# INLINE parseReifyBytesW64 #-}
+    parseReifyBytesW64 = withLit 8# (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)
+        prim (parseReifyBytesW64 @ns)
+
+-- | Try to group 'Word32's next.
+instance ParseReifyBytesW32 ns => ParseReifyBytesW64 ns where
+    {-# INLINE parseReifyBytesW64 #-}
+    parseReifyBytesW64 = parseReifyBytesW32 @ns
+
+-- | Serialize a type-level bytestring, largest grouping 'Word32'.
+class ParseReifyBytesW32 (ns :: [Natural]) where
+    parseReifyBytesW32 :: ParserT st e ()
+
+-- | Enough bytes to make a 'Word32'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ReifyW8 n3
+  , ReifyW8 n4
+  , ParseReifyBytesW32 ns
+  ) => ParseReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where
+    {-# INLINE parseReifyBytesW32 #-}
+    parseReifyBytesW32 = withLit 4# (reifyW32 @n1 @n2 @n3 @n4)
+        prim (parseReifyBytesW32 @ns)
+
+-- | Try to group 'Word16's next.
+instance ParseReifyBytesW16 ns => ParseReifyBytesW32 ns where
+    {-# INLINE parseReifyBytesW32 #-}
+    parseReifyBytesW32 = parseReifyBytesW16 @ns
+
+-- | Serialize a type-level bytestring, largest grouping 'Word16'.
+class ParseReifyBytesW16 (ns :: [Natural]) where
+    parseReifyBytesW16 :: ParserT st e ()
+
+-- | Enough bytes to make a 'Word16'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ParseReifyBytesW16 ns
+  ) => ParseReifyBytesW16 (n1 ': n2 ': ns) where
+    {-# INLINE parseReifyBytesW16 #-}
+    parseReifyBytesW16 = withLit 2# (reifyW16 @n1 @n2)
+        prim (parseReifyBytesW16 @ns)
+
+-- | Reify byte-by-byte next.
+instance ParseReifyBytesW8 ns => ParseReifyBytesW16 ns where
+    {-# INLINE parseReifyBytesW16 #-}
+    parseReifyBytesW16 = parseReifyBytesW8 @ns
+
+-- | Serialize a type-level bytestring, byte-by-byte.
+class ParseReifyBytesW8 (ns :: [Natural]) where
+    parseReifyBytesW8 :: ParserT st e ()
+
+-- | Reify the next byte.
+instance
+  ( ReifyW8 n1
+  , ParseReifyBytesW8 ns
+  ) => ParseReifyBytesW8 (n1 ': ns) where
+    {-# INLINE parseReifyBytesW8 #-}
+    parseReifyBytesW8 = withLit 1# (reifyW8 @n1)
+        prim (parseReifyBytesW8 @ns)
+
+-- | End of the line.
+instance ParseReifyBytesW8 '[] where
+    {-# INLINE parseReifyBytesW8 #-}
+    parseReifyBytesW8 = constParse ()
diff --git a/src/Bytezap/Poke.hs b/src/Bytezap/Poke.hs
--- a/src/Bytezap/Poke.hs
+++ b/src/Bytezap/Poke.hs
@@ -95,3 +95,8 @@
 fromStructPoke :: Int -> Struct.Poke s -> Poke s
 fromStructPoke (I# len#) (Struct.Poke p) = Poke $ \base# os# s ->
     (# p base# os# s, os# +# len# #)
+
+-- | Use a struct poke as a regular poke by throwing away the return offset.
+toStructPoke :: Poke s -> Struct.Poke s
+toStructPoke (Poke p) = Struct.Poke $ \base# os0# s0 ->
+    case p base# os0# s0 of (# s1, _os1# #) -> s1
diff --git a/src/Bytezap/Struct/Generic.hs b/src/Bytezap/Struct/Generic.hs
--- a/src/Bytezap/Struct/Generic.hs
+++ b/src/Bytezap/Struct/Generic.hs
@@ -26,10 +26,11 @@
 import Bytezap.Struct
 import GHC.Generics
 import GHC.Exts
-
--- TODO fill in kind of a (some generic thing)
-type family UnwrapGenericS1 a where
-    UnwrapGenericS1 (S1 c (Rec0 a)) = a
+import Bytezap.Common.Generic ( type GTFoldMapCAddition )
+import Data.Kind
+import GHC.TypeNats
+import Util.TypeNats ( natValInt )
+import DeFun.Core ( type (~>) )
 
 -- | Class for holding info on class to use for poking base cases.
 --
@@ -39,42 +40,41 @@
 --
 -- We stay unboxed here because the internals are unboxed, just for convenience.
 -- Maybe this is bad, let me know.
-class GPokeBase idx where
+class GPokeBase tag where
     -- | The state token of our poker.
-    type GPokeBaseSt idx
+    type GPokeBaseSt tag
 
     -- | The type class that provides base case poking.
     --
     -- The type class should provide a function that looks like 'gPokeBase'.
-    type GPokeBaseC idx a :: Constraint
-
-    gPokeBase :: GPokeBaseC idx a => a -> Poke# (GPokeBaseSt idx)
+    type GPokeBaseC tag a :: Constraint
 
-    -- | The type class that provides poked length (known at compile time).
-    type KnownSizeOf' idx a :: Constraint
+    gPokeBase :: GPokeBaseC tag a => a -> Poke# (GPokeBaseSt tag)
 
-    -- | Get the poked length of the given type. Unboxed because I felt like it.
-    --
-    -- I think we have to pass a proxy, because of forall limitations on
-    -- instance signatures. This would be much better with explicit type
-    -- variables (GHC 9.10 or 9.12).
-    sizeOf' :: forall a. KnownSizeOf' idx a => Proxy# a -> Int#
+    type GPokeBaseLenTF tag :: Type ~> Natural
 
-class GPoke idx f where gPoke :: f p -> Poke# (GPokeBaseSt idx)
+class GPoke tag f where gPoke :: f p -> Poke# (GPokeBaseSt tag)
 
-instance GPoke idx f => GPoke idx (D1 c f) where gPoke = gPoke @idx . unM1
-instance GPoke idx f => GPoke idx (C1 c f) where gPoke = gPoke @idx . unM1
+instance GPoke tag f => GPoke tag (D1 c f) where gPoke = gPoke @tag . unM1
+instance GPoke tag f => GPoke tag (C1 c f) where gPoke = gPoke @tag . unM1
 
-instance (GPoke idx l, GPoke idx r, GPokeBase idx, KnownSizeOf' idx (UnwrapGenericS1 l))
-  => GPoke idx (l :*: r) where
+instance
+  ( GPoke tag l
+  , GPoke tag r
+  , GPokeBase tag
+  , lenL ~ GTFoldMapCAddition (GPokeBaseLenTF tag) l
+  , KnownNat lenL
+  ) => GPoke tag (l :*: r) where
     -- TODO moved os and s0 to RHS because base is const and those aren't?
     -- will this change anything?? idk!!!!
     gPoke (l :*: r) base# = \os# s0 ->
-        case gPoke @idx l base# os# s0 of
-          s1 -> gPoke @idx r base# (os# +# sizeOf' @idx @(UnwrapGenericS1 l) proxy#) s1
+        case gPoke @tag l base# os# s0 of
+          s1 -> gPoke @tag r base# (os# +# lenL#) s1
+      where
+        !(I# lenL#) = natValInt @lenL
 
-instance (GPokeBase idx, GPokeBaseC idx a) => GPoke idx (S1 c (Rec0 a)) where
-    gPoke = gPokeBase @idx . unK1 . unM1
+instance (GPokeBase tag, GPokeBaseC tag a) => GPoke tag (S1 c (Rec0 a)) where
+    gPoke = gPokeBase @tag . unK1 . unM1
 
 -- | Wow, look! Nothing!
-instance GPoke idx U1 where gPoke U1 _base# = \_os# s0 -> s0
+instance GPoke tag U1 where gPoke U1 _base# = \_os# s0 -> s0
diff --git a/src/Bytezap/Struct/TypeLits.hs b/src/Bytezap/Struct/TypeLits.hs
deleted file mode 100644
--- a/src/Bytezap/Struct/TypeLits.hs
+++ /dev/null
@@ -1,102 +0,0 @@
-{- | Efficient type-level bytestring serialization.
-
-@['Natural']@s have a convenient syntax, and we can use them as a type-level
-bytestring by asserting that each 'Natural' is <=255 when reifying. This module
-provides type classes which give you a serializer for a given @['Natural']@.
-
-We maximize efficiency by grouping bytes into machine words. We have to be
-pretty verbose to achieve this. Each type class attempts to group bytes into its
-machine word type, and if it can't (i.e. not enough bytes remain), it hands off
-to the next type class which handles the next smaller machine word.
-
-I did a quick Core check and found that GHC seems to successfully generate
-minimal code for this e.g. for an 8-byte magic, GHC will do one
-@writeWord64OffAddr#@ of a constant. Great!
--}
-
-{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}
-
-module Bytezap.Struct.TypeLits where
-
-import Raehik.TypeLevelBytes
-import Bytezap.Struct ( Poke, sequencePokes, emptyPoke, prim )
-import Numeric.Natural ( Natural )
-
--- | Serialize a type-level bytestring, largest grouping 'Word64'.
-class ReifyBytesW64 (ns :: [Natural]) where reifyBytesW64 :: Poke n
-
--- | Enough bytes to make a 'Word64'.
-instance {-# OVERLAPPING #-}
-  ( ReifyW8 n1
-  , ReifyW8 n2
-  , ReifyW8 n3
-  , ReifyW8 n4
-  , ReifyW8 n5
-  , ReifyW8 n6
-  , ReifyW8 n7
-  , ReifyW8 n8
-  , ReifyBytesW64 ns
-  ) => ReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where
-    {-# INLINE reifyBytesW64 #-}
-    reifyBytesW64 = sequencePokes
-        (prim (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)) 8 (reifyBytesW64 @ns)
-
--- | Try to group 'Word32's next.
-instance ReifyBytesW32 ns => ReifyBytesW64 ns where
-    {-# INLINE reifyBytesW64 #-}
-    reifyBytesW64 = reifyBytesW32 @ns
-
--- | Serialize a type-level bytestring, largest grouping 'Word32'.
-class ReifyBytesW32 (ns :: [Natural]) where reifyBytesW32 :: Poke s
-
--- | Enough bytes to make a 'Word32'.
-instance {-# OVERLAPPING #-}
-  ( ReifyW8 n1
-  , ReifyW8 n2
-  , ReifyW8 n3
-  , ReifyW8 n4
-  , ReifyBytesW32 ns
-  ) => ReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where
-    {-# INLINE reifyBytesW32 #-}
-    reifyBytesW32 = sequencePokes
-        (prim (reifyW32 @n1 @n2 @n3 @n4)) 4 (reifyBytesW32 @ns)
-
--- | Try to group 'Word16's next.
-instance ReifyBytesW16 ns => ReifyBytesW32 ns where
-    {-# INLINE reifyBytesW32 #-}
-    reifyBytesW32 = reifyBytesW16 @ns
-
--- | Serialize a type-level bytestring, largest grouping 'Word32'.
-class ReifyBytesW16 (ns :: [Natural]) where reifyBytesW16 :: Poke s
-
--- | Enough bytes to make a 'Word16'.
-instance
-  ( ReifyW8 n1
-  , ReifyW8 n2
-  , ReifyBytesW16 ns
-  ) => ReifyBytesW16 (n1 ': n2 ': ns) where
-    {-# INLINE reifyBytesW16 #-}
-    reifyBytesW16 = sequencePokes
-        (prim (reifyW16 @n1 @n2)) 2 (reifyBytesW16 @ns)
-
--- | Reify byte-by-byte next.
-instance ReifyBytesW8 ns => ReifyBytesW16 ns where
-    {-# INLINE reifyBytesW16 #-}
-    reifyBytesW16 = reifyBytesW8 @ns
-
--- | Serialize a type-level bytestring, byte-by-byte.
-class ReifyBytesW8 (ns :: [Natural]) where reifyBytesW8 :: Poke s
-
--- | Reify the next byte.
-instance
-  ( ReifyW8 n1
-  , ReifyBytesW8 ns
-  ) => ReifyBytesW8 (n1 ': ns) where
-    {-# INLINE reifyBytesW8 #-}
-    reifyBytesW8 = sequencePokes
-        (prim (reifyW8 @n1)) 1 (reifyBytesW8 @ns)
-
--- | End of the line.
-instance ReifyBytesW8 '[] where
-    {-# INLINE reifyBytesW8 #-}
-    reifyBytesW8 = emptyPoke
diff --git a/src/Bytezap/Struct/TypeLits/Bytes.hs b/src/Bytezap/Struct/TypeLits/Bytes.hs
new file mode 100644
--- /dev/null
+++ b/src/Bytezap/Struct/TypeLits/Bytes.hs
@@ -0,0 +1,107 @@
+{- | Efficient type-level bytestring serialization.
+
+@['Natural']@s have a convenient syntax, and we can use them as a type-level
+bytestring by asserting that each 'Natural' is <=255 when reifying. This module
+provides type classes which give you a serializer for a given @['Natural']@.
+
+We maximize efficiency by grouping bytes into machine words. We have to be
+pretty verbose to achieve this. Each type class attempts to group bytes into its
+machine word type, and if it can't (i.e. not enough bytes remain), it hands off
+to the next type class which handles the next smaller machine word.
+
+I did a quick Core check and found that GHC seems to successfully generate
+minimal code for this e.g. for an 8-byte magic, GHC will do one
+@writeWord64OffAddr#@ of a constant. Great!
+
+The only way I can think of to make this faster is to somehow obtain an 'Addr#'
+with a known length. With that, we could @memcpy@. But that would be slower for
+small magics, and maybe others. And I doubt we can conjure up an 'Addr#' at
+compile time. So I'm fairly confident that this is the best you're gonna get.
+-}
+
+{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}
+
+module Bytezap.Struct.TypeLits.Bytes where
+
+import Data.Type.Byte
+import Bytezap.Struct ( Poke, sequencePokes, emptyPoke, prim )
+import Numeric.Natural ( Natural )
+
+-- | Serialize a type-level bytestring, largest grouping 'Word64'.
+class ReifyBytesW64 (ns :: [Natural]) where reifyBytesW64 :: Poke s
+
+-- | Enough bytes to make a 'Word64'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ReifyW8 n3
+  , ReifyW8 n4
+  , ReifyW8 n5
+  , ReifyW8 n6
+  , ReifyW8 n7
+  , ReifyW8 n8
+  , ReifyBytesW64 ns
+  ) => ReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where
+    {-# INLINE reifyBytesW64 #-}
+    reifyBytesW64 = sequencePokes
+        (prim (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)) 8 (reifyBytesW64 @ns)
+
+-- | Try to group 'Word32's next.
+instance ReifyBytesW32 ns => ReifyBytesW64 ns where
+    {-# INLINE reifyBytesW64 #-}
+    reifyBytesW64 = reifyBytesW32 @ns
+
+-- | Serialize a type-level bytestring, largest grouping 'Word32'.
+class ReifyBytesW32 (ns :: [Natural]) where reifyBytesW32 :: Poke s
+
+-- | Enough bytes to make a 'Word32'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ReifyW8 n3
+  , ReifyW8 n4
+  , ReifyBytesW32 ns
+  ) => ReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where
+    {-# INLINE reifyBytesW32 #-}
+    reifyBytesW32 = sequencePokes
+        (prim (reifyW32 @n1 @n2 @n3 @n4)) 4 (reifyBytesW32 @ns)
+
+-- | Try to group 'Word16's next.
+instance ReifyBytesW16 ns => ReifyBytesW32 ns where
+    {-# INLINE reifyBytesW32 #-}
+    reifyBytesW32 = reifyBytesW16 @ns
+
+-- | Serialize a type-level bytestring, largest grouping 'Word16'.
+class ReifyBytesW16 (ns :: [Natural]) where reifyBytesW16 :: Poke s
+
+-- | Enough bytes to make a 'Word16'.
+instance {-# OVERLAPPING #-}
+  ( ReifyW8 n1
+  , ReifyW8 n2
+  , ReifyBytesW16 ns
+  ) => ReifyBytesW16 (n1 ': n2 ': ns) where
+    {-# INLINE reifyBytesW16 #-}
+    reifyBytesW16 = sequencePokes
+        (prim (reifyW16 @n1 @n2)) 2 (reifyBytesW16 @ns)
+
+-- | Reify byte-by-byte next.
+instance ReifyBytesW8 ns => ReifyBytesW16 ns where
+    {-# INLINE reifyBytesW16 #-}
+    reifyBytesW16 = reifyBytesW8 @ns
+
+-- | Serialize a type-level bytestring, byte-by-byte.
+class ReifyBytesW8 (ns :: [Natural]) where reifyBytesW8 :: Poke s
+
+-- | Reify the next byte.
+instance
+  ( ReifyW8 n1
+  , ReifyBytesW8 ns
+  ) => ReifyBytesW8 (n1 ': ns) where
+    {-# INLINE reifyBytesW8 #-}
+    reifyBytesW8 = sequencePokes
+        (prim (reifyW8 @n1)) 1 (reifyBytesW8 @ns)
+
+-- | End of the line.
+instance ReifyBytesW8 '[] where
+    {-# INLINE reifyBytesW8 #-}
+    reifyBytesW8 = emptyPoke
diff --git a/src/Raehik/Compat/Data/Primitive/Types/Endian.hs b/src/Raehik/Compat/Data/Primitive/Types/Endian.hs
--- a/src/Raehik/Compat/Data/Primitive/Types/Endian.hs
+++ b/src/Raehik/Compat/Data/Primitive/Types/Endian.hs
@@ -32,8 +32,8 @@
     byteSwap = castWord64ToDouble . byteSwap . castDoubleToWord64
 
 newtype ByteOrdered (end :: ByteOrder) a = ByteOrdered
-  { unByteOrdered :: a }
-    deriving (Ord, Eq, Show, Num) via a
+  { unByteOrdered :: a
+  } deriving (Ord, Eq, Show, Num, Real, Enum, Integral) via a
 
 -- | Newtype for easier instance derivation.
 newtype PrimByteSwapped a = PrimByteSwapped { unPrimByteSwapped :: a }
diff --git a/src/Raehik/TypeLevelBytes.hs b/src/Raehik/TypeLevelBytes.hs
deleted file mode 100644
--- a/src/Raehik/TypeLevelBytes.hs
+++ /dev/null
@@ -1,319 +0,0 @@
--- | Utilities for using @Natural@s as type-level bytes.
-
-{-# LANGUAGE AllowAmbiguousTypes #-}
-
-module Raehik.TypeLevelBytes where
-
-import Numeric.Natural ( Natural )
-import Data.Word ( Word8, Word16, Word32, Word64 )
-import Data.Bits ( unsafeShiftL, (.|.) )
-
-{-# INLINE reifyW64 #-}
--- | Reify 8 type-level bytes to a 'Word64'.
-reifyW64
-    :: forall n1 n2 n3 n4 n5 n6 n7 n8
-    .  ( ReifyW8 n1
-       , ReifyW8 n2
-       , ReifyW8 n3
-       , ReifyW8 n4
-       , ReifyW8 n5
-       , ReifyW8 n6
-       , ReifyW8 n7
-       , ReifyW8 n8
-    ) => Word64
-reifyW64 =            fI (reifyW8 @n1)
-    .|. unsafeShiftL (fI (reifyW8 @n2))  8
-    .|. unsafeShiftL (fI (reifyW8 @n3)) 16
-    .|. unsafeShiftL (fI (reifyW8 @n4)) 24
-    .|. unsafeShiftL (fI (reifyW8 @n5)) 32
-    .|. unsafeShiftL (fI (reifyW8 @n6)) 40
-    .|. unsafeShiftL (fI (reifyW8 @n7)) 48
-    .|. unsafeShiftL (fI (reifyW8 @n8)) 56
-  where fI = fromIntegral
-
-{-# INLINE reifyW32 #-}
--- | Reify 4 type-level bytes to a 'Word32'.
-reifyW32
-    :: forall n1 n2 n3 n4
-    .  ( ReifyW8 n1
-       , ReifyW8 n2
-       , ReifyW8 n3
-       , ReifyW8 n4
-    ) => Word32
-reifyW32 =            fI (reifyW8 @n1)
-    .|. unsafeShiftL (fI (reifyW8 @n2))  8
-    .|. unsafeShiftL (fI (reifyW8 @n3)) 16
-    .|. unsafeShiftL (fI (reifyW8 @n4)) 24
-  where fI = fromIntegral
-
-{-# INLINE reifyW16 #-}
--- | Reify 2 type-level bytes to a 'Word16'.
-reifyW16
-    :: forall n1 n2
-    .  ( ReifyW8 n1
-       , ReifyW8 n2
-    ) => Word16
-reifyW16 =            fI (reifyW8 @n1)
-    .|. unsafeShiftL (fI (reifyW8 @n2))  8
-  where fI = fromIntegral
-
--- | Reify a type-level byte (stored in a type-level 'Natural') to its 'Word8'.
---
--- Attempting to reify a 'Natural' larger than 255 results in a type error.
-class ReifyW8 (n :: Natural) where reifyW8 :: Word8
-instance ReifyW8 0x00 where reifyW8 = 0x00
-instance ReifyW8 0x01 where reifyW8 = 0x01
-instance ReifyW8 0x02 where reifyW8 = 0x02
-instance ReifyW8 0x03 where reifyW8 = 0x03
-instance ReifyW8 0x04 where reifyW8 = 0x04
-instance ReifyW8 0x05 where reifyW8 = 0x05
-instance ReifyW8 0x06 where reifyW8 = 0x06
-instance ReifyW8 0x07 where reifyW8 = 0x07
-instance ReifyW8 0x08 where reifyW8 = 0x08
-instance ReifyW8 0x09 where reifyW8 = 0x09
-instance ReifyW8 0x0a where reifyW8 = 0x0a
-instance ReifyW8 0x0b where reifyW8 = 0x0b
-instance ReifyW8 0x0c where reifyW8 = 0x0c
-instance ReifyW8 0x0d where reifyW8 = 0x0d
-instance ReifyW8 0x0e where reifyW8 = 0x0e
-instance ReifyW8 0x0f where reifyW8 = 0x0f
-instance ReifyW8 0x10 where reifyW8 = 0x10
-instance ReifyW8 0x11 where reifyW8 = 0x11
-instance ReifyW8 0x12 where reifyW8 = 0x12
-instance ReifyW8 0x13 where reifyW8 = 0x13
-instance ReifyW8 0x14 where reifyW8 = 0x14
-instance ReifyW8 0x15 where reifyW8 = 0x15
-instance ReifyW8 0x16 where reifyW8 = 0x16
-instance ReifyW8 0x17 where reifyW8 = 0x17
-instance ReifyW8 0x18 where reifyW8 = 0x18
-instance ReifyW8 0x19 where reifyW8 = 0x19
-instance ReifyW8 0x1a where reifyW8 = 0x1a
-instance ReifyW8 0x1b where reifyW8 = 0x1b
-instance ReifyW8 0x1c where reifyW8 = 0x1c
-instance ReifyW8 0x1d where reifyW8 = 0x1d
-instance ReifyW8 0x1e where reifyW8 = 0x1e
-instance ReifyW8 0x1f where reifyW8 = 0x1f
-instance ReifyW8 0x20 where reifyW8 = 0x20
-instance ReifyW8 0x21 where reifyW8 = 0x21
-instance ReifyW8 0x22 where reifyW8 = 0x22
-instance ReifyW8 0x23 where reifyW8 = 0x23
-instance ReifyW8 0x24 where reifyW8 = 0x24
-instance ReifyW8 0x25 where reifyW8 = 0x25
-instance ReifyW8 0x26 where reifyW8 = 0x26
-instance ReifyW8 0x27 where reifyW8 = 0x27
-instance ReifyW8 0x28 where reifyW8 = 0x28
-instance ReifyW8 0x29 where reifyW8 = 0x29
-instance ReifyW8 0x2a where reifyW8 = 0x2a
-instance ReifyW8 0x2b where reifyW8 = 0x2b
-instance ReifyW8 0x2c where reifyW8 = 0x2c
-instance ReifyW8 0x2d where reifyW8 = 0x2d
-instance ReifyW8 0x2e where reifyW8 = 0x2e
-instance ReifyW8 0x2f where reifyW8 = 0x2f
-instance ReifyW8 0x30 where reifyW8 = 0x30
-instance ReifyW8 0x31 where reifyW8 = 0x31
-instance ReifyW8 0x32 where reifyW8 = 0x32
-instance ReifyW8 0x33 where reifyW8 = 0x33
-instance ReifyW8 0x34 where reifyW8 = 0x34
-instance ReifyW8 0x35 where reifyW8 = 0x35
-instance ReifyW8 0x36 where reifyW8 = 0x36
-instance ReifyW8 0x37 where reifyW8 = 0x37
-instance ReifyW8 0x38 where reifyW8 = 0x38
-instance ReifyW8 0x39 where reifyW8 = 0x39
-instance ReifyW8 0x3a where reifyW8 = 0x3a
-instance ReifyW8 0x3b where reifyW8 = 0x3b
-instance ReifyW8 0x3c where reifyW8 = 0x3c
-instance ReifyW8 0x3d where reifyW8 = 0x3d
-instance ReifyW8 0x3e where reifyW8 = 0x3e
-instance ReifyW8 0x3f where reifyW8 = 0x3f
-instance ReifyW8 0x40 where reifyW8 = 0x40
-instance ReifyW8 0x41 where reifyW8 = 0x41
-instance ReifyW8 0x42 where reifyW8 = 0x42
-instance ReifyW8 0x43 where reifyW8 = 0x43
-instance ReifyW8 0x44 where reifyW8 = 0x44
-instance ReifyW8 0x45 where reifyW8 = 0x45
-instance ReifyW8 0x46 where reifyW8 = 0x46
-instance ReifyW8 0x47 where reifyW8 = 0x47
-instance ReifyW8 0x48 where reifyW8 = 0x48
-instance ReifyW8 0x49 where reifyW8 = 0x49
-instance ReifyW8 0x4a where reifyW8 = 0x4a
-instance ReifyW8 0x4b where reifyW8 = 0x4b
-instance ReifyW8 0x4c where reifyW8 = 0x4c
-instance ReifyW8 0x4d where reifyW8 = 0x4d
-instance ReifyW8 0x4e where reifyW8 = 0x4e
-instance ReifyW8 0x4f where reifyW8 = 0x4f
-instance ReifyW8 0x50 where reifyW8 = 0x50
-instance ReifyW8 0x51 where reifyW8 = 0x51
-instance ReifyW8 0x52 where reifyW8 = 0x52
-instance ReifyW8 0x53 where reifyW8 = 0x53
-instance ReifyW8 0x54 where reifyW8 = 0x54
-instance ReifyW8 0x55 where reifyW8 = 0x55
-instance ReifyW8 0x56 where reifyW8 = 0x56
-instance ReifyW8 0x57 where reifyW8 = 0x57
-instance ReifyW8 0x58 where reifyW8 = 0x58
-instance ReifyW8 0x59 where reifyW8 = 0x59
-instance ReifyW8 0x5a where reifyW8 = 0x5a
-instance ReifyW8 0x5b where reifyW8 = 0x5b
-instance ReifyW8 0x5c where reifyW8 = 0x5c
-instance ReifyW8 0x5d where reifyW8 = 0x5d
-instance ReifyW8 0x5e where reifyW8 = 0x5e
-instance ReifyW8 0x5f where reifyW8 = 0x5f
-instance ReifyW8 0x60 where reifyW8 = 0x60
-instance ReifyW8 0x61 where reifyW8 = 0x61
-instance ReifyW8 0x62 where reifyW8 = 0x62
-instance ReifyW8 0x63 where reifyW8 = 0x63
-instance ReifyW8 0x64 where reifyW8 = 0x64
-instance ReifyW8 0x65 where reifyW8 = 0x65
-instance ReifyW8 0x66 where reifyW8 = 0x66
-instance ReifyW8 0x67 where reifyW8 = 0x67
-instance ReifyW8 0x68 where reifyW8 = 0x68
-instance ReifyW8 0x69 where reifyW8 = 0x69
-instance ReifyW8 0x6a where reifyW8 = 0x6a
-instance ReifyW8 0x6b where reifyW8 = 0x6b
-instance ReifyW8 0x6c where reifyW8 = 0x6c
-instance ReifyW8 0x6d where reifyW8 = 0x6d
-instance ReifyW8 0x6e where reifyW8 = 0x6e
-instance ReifyW8 0x6f where reifyW8 = 0x6f
-instance ReifyW8 0x70 where reifyW8 = 0x70
-instance ReifyW8 0x71 where reifyW8 = 0x71
-instance ReifyW8 0x72 where reifyW8 = 0x72
-instance ReifyW8 0x73 where reifyW8 = 0x73
-instance ReifyW8 0x74 where reifyW8 = 0x74
-instance ReifyW8 0x75 where reifyW8 = 0x75
-instance ReifyW8 0x76 where reifyW8 = 0x76
-instance ReifyW8 0x77 where reifyW8 = 0x77
-instance ReifyW8 0x78 where reifyW8 = 0x78
-instance ReifyW8 0x79 where reifyW8 = 0x79
-instance ReifyW8 0x7a where reifyW8 = 0x7a
-instance ReifyW8 0x7b where reifyW8 = 0x7b
-instance ReifyW8 0x7c where reifyW8 = 0x7c
-instance ReifyW8 0x7d where reifyW8 = 0x7d
-instance ReifyW8 0x7e where reifyW8 = 0x7e
-instance ReifyW8 0x7f where reifyW8 = 0x7f
-instance ReifyW8 0x80 where reifyW8 = 0x80
-instance ReifyW8 0x81 where reifyW8 = 0x81
-instance ReifyW8 0x82 where reifyW8 = 0x82
-instance ReifyW8 0x83 where reifyW8 = 0x83
-instance ReifyW8 0x84 where reifyW8 = 0x84
-instance ReifyW8 0x85 where reifyW8 = 0x85
-instance ReifyW8 0x86 where reifyW8 = 0x86
-instance ReifyW8 0x87 where reifyW8 = 0x87
-instance ReifyW8 0x88 where reifyW8 = 0x88
-instance ReifyW8 0x89 where reifyW8 = 0x89
-instance ReifyW8 0x8a where reifyW8 = 0x8a
-instance ReifyW8 0x8b where reifyW8 = 0x8b
-instance ReifyW8 0x8c where reifyW8 = 0x8c
-instance ReifyW8 0x8d where reifyW8 = 0x8d
-instance ReifyW8 0x8e where reifyW8 = 0x8e
-instance ReifyW8 0x8f where reifyW8 = 0x8f
-instance ReifyW8 0x90 where reifyW8 = 0x90
-instance ReifyW8 0x91 where reifyW8 = 0x91
-instance ReifyW8 0x92 where reifyW8 = 0x92
-instance ReifyW8 0x93 where reifyW8 = 0x93
-instance ReifyW8 0x94 where reifyW8 = 0x94
-instance ReifyW8 0x95 where reifyW8 = 0x95
-instance ReifyW8 0x96 where reifyW8 = 0x96
-instance ReifyW8 0x97 where reifyW8 = 0x97
-instance ReifyW8 0x98 where reifyW8 = 0x98
-instance ReifyW8 0x99 where reifyW8 = 0x99
-instance ReifyW8 0x9a where reifyW8 = 0x9a
-instance ReifyW8 0x9b where reifyW8 = 0x9b
-instance ReifyW8 0x9c where reifyW8 = 0x9c
-instance ReifyW8 0x9d where reifyW8 = 0x9d
-instance ReifyW8 0x9e where reifyW8 = 0x9e
-instance ReifyW8 0x9f where reifyW8 = 0x9f
-instance ReifyW8 0xa0 where reifyW8 = 0xa0
-instance ReifyW8 0xa1 where reifyW8 = 0xa1
-instance ReifyW8 0xa2 where reifyW8 = 0xa2
-instance ReifyW8 0xa3 where reifyW8 = 0xa3
-instance ReifyW8 0xa4 where reifyW8 = 0xa4
-instance ReifyW8 0xa5 where reifyW8 = 0xa5
-instance ReifyW8 0xa6 where reifyW8 = 0xa6
-instance ReifyW8 0xa7 where reifyW8 = 0xa7
-instance ReifyW8 0xa8 where reifyW8 = 0xa8
-instance ReifyW8 0xa9 where reifyW8 = 0xa9
-instance ReifyW8 0xaa where reifyW8 = 0xaa
-instance ReifyW8 0xab where reifyW8 = 0xab
-instance ReifyW8 0xac where reifyW8 = 0xac
-instance ReifyW8 0xad where reifyW8 = 0xad
-instance ReifyW8 0xae where reifyW8 = 0xae
-instance ReifyW8 0xaf where reifyW8 = 0xaf
-instance ReifyW8 0xb0 where reifyW8 = 0xb0
-instance ReifyW8 0xb1 where reifyW8 = 0xb1
-instance ReifyW8 0xb2 where reifyW8 = 0xb2
-instance ReifyW8 0xb3 where reifyW8 = 0xb3
-instance ReifyW8 0xb4 where reifyW8 = 0xb4
-instance ReifyW8 0xb5 where reifyW8 = 0xb5
-instance ReifyW8 0xb6 where reifyW8 = 0xb6
-instance ReifyW8 0xb7 where reifyW8 = 0xb7
-instance ReifyW8 0xb8 where reifyW8 = 0xb8
-instance ReifyW8 0xb9 where reifyW8 = 0xb9
-instance ReifyW8 0xba where reifyW8 = 0xba
-instance ReifyW8 0xbb where reifyW8 = 0xbb
-instance ReifyW8 0xbc where reifyW8 = 0xbc
-instance ReifyW8 0xbd where reifyW8 = 0xbd
-instance ReifyW8 0xbe where reifyW8 = 0xbe
-instance ReifyW8 0xbf where reifyW8 = 0xbf
-instance ReifyW8 0xc0 where reifyW8 = 0xc0
-instance ReifyW8 0xc1 where reifyW8 = 0xc1
-instance ReifyW8 0xc2 where reifyW8 = 0xc2
-instance ReifyW8 0xc3 where reifyW8 = 0xc3
-instance ReifyW8 0xc4 where reifyW8 = 0xc4
-instance ReifyW8 0xc5 where reifyW8 = 0xc5
-instance ReifyW8 0xc6 where reifyW8 = 0xc6
-instance ReifyW8 0xc7 where reifyW8 = 0xc7
-instance ReifyW8 0xc8 where reifyW8 = 0xc8
-instance ReifyW8 0xc9 where reifyW8 = 0xc9
-instance ReifyW8 0xca where reifyW8 = 0xca
-instance ReifyW8 0xcb where reifyW8 = 0xcb
-instance ReifyW8 0xcc where reifyW8 = 0xcc
-instance ReifyW8 0xcd where reifyW8 = 0xcd
-instance ReifyW8 0xce where reifyW8 = 0xce
-instance ReifyW8 0xcf where reifyW8 = 0xcf
-instance ReifyW8 0xd0 where reifyW8 = 0xd0
-instance ReifyW8 0xd1 where reifyW8 = 0xd1
-instance ReifyW8 0xd2 where reifyW8 = 0xd2
-instance ReifyW8 0xd3 where reifyW8 = 0xd3
-instance ReifyW8 0xd4 where reifyW8 = 0xd4
-instance ReifyW8 0xd5 where reifyW8 = 0xd5
-instance ReifyW8 0xd6 where reifyW8 = 0xd6
-instance ReifyW8 0xd7 where reifyW8 = 0xd7
-instance ReifyW8 0xd8 where reifyW8 = 0xd8
-instance ReifyW8 0xd9 where reifyW8 = 0xd9
-instance ReifyW8 0xda where reifyW8 = 0xda
-instance ReifyW8 0xdb where reifyW8 = 0xdb
-instance ReifyW8 0xdc where reifyW8 = 0xdc
-instance ReifyW8 0xdd where reifyW8 = 0xdd
-instance ReifyW8 0xde where reifyW8 = 0xde
-instance ReifyW8 0xdf where reifyW8 = 0xdf
-instance ReifyW8 0xe0 where reifyW8 = 0xe0
-instance ReifyW8 0xe1 where reifyW8 = 0xe1
-instance ReifyW8 0xe2 where reifyW8 = 0xe2
-instance ReifyW8 0xe3 where reifyW8 = 0xe3
-instance ReifyW8 0xe4 where reifyW8 = 0xe4
-instance ReifyW8 0xe5 where reifyW8 = 0xe5
-instance ReifyW8 0xe6 where reifyW8 = 0xe6
-instance ReifyW8 0xe7 where reifyW8 = 0xe7
-instance ReifyW8 0xe8 where reifyW8 = 0xe8
-instance ReifyW8 0xe9 where reifyW8 = 0xe9
-instance ReifyW8 0xea where reifyW8 = 0xea
-instance ReifyW8 0xeb where reifyW8 = 0xeb
-instance ReifyW8 0xec where reifyW8 = 0xec
-instance ReifyW8 0xed where reifyW8 = 0xed
-instance ReifyW8 0xee where reifyW8 = 0xee
-instance ReifyW8 0xef where reifyW8 = 0xef
-instance ReifyW8 0xf0 where reifyW8 = 0xf0
-instance ReifyW8 0xf1 where reifyW8 = 0xf1
-instance ReifyW8 0xf2 where reifyW8 = 0xf2
-instance ReifyW8 0xf3 where reifyW8 = 0xf3
-instance ReifyW8 0xf4 where reifyW8 = 0xf4
-instance ReifyW8 0xf5 where reifyW8 = 0xf5
-instance ReifyW8 0xf6 where reifyW8 = 0xf6
-instance ReifyW8 0xf7 where reifyW8 = 0xf7
-instance ReifyW8 0xf8 where reifyW8 = 0xf8
-instance ReifyW8 0xf9 where reifyW8 = 0xf9
-instance ReifyW8 0xfa where reifyW8 = 0xfa
-instance ReifyW8 0xfb where reifyW8 = 0xfb
-instance ReifyW8 0xfc where reifyW8 = 0xfc
-instance ReifyW8 0xfd where reifyW8 = 0xfd
-instance ReifyW8 0xfe where reifyW8 = 0xfe
-instance ReifyW8 0xff where reifyW8 = 0xff