bytezap 1.0.0 → 1.1.0

raw patch · 8 files changed

+663/−23 lines, 8 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• bytezap.cabal +7/−1
• cbits/aligned-static-hs-data.c +26/−0
• src/Bytezap/Poke.hs +42/−22
• src/Bytezap/Struct.hs +83/−0
• src/Bytezap/Struct/Generic.hs +80/−0
• src/Bytezap/Struct/TypeLits.hs +102/−0
• src/Raehik/TypeLevelBytes.hs +319/−0

@@ -1,2 +1,6 @@+## 1.1.0 (2024-04-05)+* add struct serializer+* add type-level bytestring utilities (generalized from binrep)+ ## 1.0.0 (2024-03-17) * initial release, finally its own package

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           bytezap-version:        1.0.0+version:        1.1.0 synopsis:       Bytestring builder with zero intermediate allocation description:    Please see README.md. category:       Data, Serialization@@ -34,6 +34,9 @@       Bytezap.Poke.Derived.Endian       Bytezap.Poke.Json       Bytezap.Poke.KnownLen+      Bytezap.Struct+      Bytezap.Struct.Generic+      Bytezap.Struct.TypeLits       Bytezap.Write       Bytezap.Write.Derived       Bytezap.Write.Internal@@ -43,6 +46,7 @@       Raehik.Compat.Data.Word.ByteSwap       Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops       Raehik.Compat.GHC.Exts.GHC910UnalignedAddrPrimops+      Raehik.TypeLevelBytes       Util.TypeNats   other-modules:       Paths_bytezap@@ -60,6 +64,8 @@       DataKinds       MagicHash   ghc-options: -Wall+  c-sources:+      cbits/aligned-static-hs-data.c   build-depends:       base >=4.18.0.0 && <4.20     , bytestring >=0.11.5.3 && <0.13.0.0

@@ -0,0 +1,26 @@+// This file contains various chunks of raw static data that we can't+// put into GHC-Haskell primitive string literals because we perform+// /aligned/ reads with them.++#include "MachDeps.h"+#include <stdint.h>++extern const char hs_bytestring_lower_hex_table[513];+const char hs_bytestring_lower_hex_table[513]+  __attribute__(( aligned(ALIGNMENT_WORD16) ))+  = "000102030405060708090a0b0c0d0e0f"+    "101112131415161718191a1b1c1d1e1f"+    "202122232425262728292a2b2c2d2e2f"+    "303132333435363738393a3b3c3d3e3f"+    "404142434445464748494a4b4c4d4e4f"+    "505152535455565758595a5b5c5d5e5f"+    "606162636465666768696a6b6c6d6e6f"+    "707172737475767778797a7b7c7d7e7f"+    "808182838485868788898a8b8c8d8e8f"+    "909192939495969798999a9b9c9d9e9f"+    "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"+    "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"+    "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"+    "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"+    "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"+    "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";

@@ -7,8 +7,7 @@ import GHC.Exts import Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops -import GHC.IO-import GHC.Word+import GHC.Word ( Word8(W8#) )  import Data.ByteString qualified as BS import Data.ByteString.Internal qualified as BS@@ -19,6 +18,10 @@  import GHC.ForeignPtr +import Control.Monad.Primitive++import Bytezap.Struct qualified as Struct+ type Poke# s = Addr# -> Int# -> State# s -> (# State# s, Int# #)  -- | Poke newtype wrapper.@@ -26,52 +29,69 @@  -- | Sequence two 'Poke's left-to-right. instance Semigroup (Poke s) where-    Poke l <> Poke r = Poke $ \addr# os0# s0 ->-        case l addr# os0# s0 of (# s1, os1# #) -> r addr# os1# s1+    Poke l <> Poke r = Poke $ \base# os0# s0 ->+        case l base# os0# s0 of (# s1, os1# #) -> r base# os1# s1  instance Monoid (Poke s) where-    mempty = Poke $ \_addr# os# s -> (# s, os# #)+    mempty = Poke $ \_base# os# s -> (# s, os# #)  -- | Execute a 'Poke' at a fresh 'BS.ByteString' of the given length. unsafeRunPokeBS :: Int -> Poke RealWorld -> BS.ByteString-unsafeRunPokeBS len = BS.unsafeCreate len . wrapIO--wrapIO :: Poke RealWorld -> Ptr Word8 -> IO ()-wrapIO f p = void (wrapIOUptoN f p)--wrapIOUptoN :: Poke RealWorld -> Ptr Word8 -> IO Int-wrapIOUptoN (Poke p) (Ptr addr#) = IO $ \s0 ->-    case p addr# 0# s0 of (# s1, len# #) -> (# s1, I# len# #)+unsafeRunPokeBS len p = BS.unsafeCreate len (void <$> unsafeRunPoke p)  -- | Execute a 'Poke' at a fresh 'BS.ByteString' of the given maximum length. --   Does not reallocate if final size is less than estimated. unsafeRunPokeBSUptoN :: Int -> Poke RealWorld -> BS.ByteString-unsafeRunPokeBSUptoN len = BS.unsafeCreateUptoN len . wrapIOUptoN+unsafeRunPokeBSUptoN len = BS.unsafeCreateUptoN len . unsafeRunPoke +-- | Execute a 'Poke' at a pointer. Returns the number of bytes written.+--+-- The pointer must be a mutable buffer with enough space to hold the poke.+-- Absolutely none of this is checked. Use with caution. Sensible uses:+--+-- * implementing pokes to ByteStrings and the like+-- * executing known-length (!!) pokes to known-length (!!) buffers e.g.+--   together with allocaBytes+unsafeRunPoke :: MonadPrim s m => Poke s -> Ptr Word8 -> m Int+unsafeRunPoke (Poke p) (Ptr base#) = primitive $ \s0 ->+    case p base# 0# s0 of (# s1, os# #) -> (# s1, I# os# #)+ -- | Poke a type via its 'Prim'' instance. prim :: forall a s. Prim' a => a -> Poke s-prim a = Poke $ \addr# os# s0 ->-    case writeWord8OffAddrAs# addr# os# a s0 of+prim a = Poke $ \base# os# s0 ->+    case writeWord8OffAddrAs# base# os# a s0 of       s1 -> (# s1, os# +# sizeOf# (undefined :: a) #)  -- we reimplement withForeignPtr because it's too high level. -- keepAlive# has the wrong type before GHC 9.10, but it doesn't matter here -- because copyAddrToAddrNonOverlapping# forces RealWorld. byteString :: BS.ByteString -> Poke RealWorld-byteString (BS.BS (ForeignPtr p# r) (I# len#)) = Poke $ \addr# os# s0 ->+byteString (BS.BS (ForeignPtr p# r) (I# len#)) = Poke $ \base# os# s0 ->     keepAlive# r s0 $ \s1 ->-        case copyAddrToAddrNonOverlapping# p# (addr# `plusAddr#` os#) len# s1 of+        case copyAddrToAddrNonOverlapping# p# (base# `plusAddr#` os#) len# s1 of           s2 -> (# s2, os# +# len# #)  byteArray# :: ByteArray# -> Int# -> Int# -> Poke s-byteArray# ba# baos# balen# = Poke $ \addr# os# s0 ->-    case copyByteArrayToAddr# ba# baos# (addr# `plusAddr#` os#) balen# s0 of+byteArray# ba# baos# balen# = Poke $ \base# os# s0 ->+    case copyByteArrayToAddr# ba# baos# (base# `plusAddr#` os#) balen# s0 of       s1 -> (# s1, os# +# balen# #)  -- | essentially memset replicateByte :: Int -> Word8 -> Poke RealWorld-replicateByte (I# len#) (W8# byte#) = Poke $ \addr# os# s0 ->-    case setAddrRange# (addr# `plusAddr#` os#) len# byteAsInt# s0 of+replicateByte (I# len#) (W8# byte#) = Poke $ \base# os# s0 ->+    case setAddrRange# (base# `plusAddr#` os#) len# byteAsInt# s0 of       s1 -> (# s1, os# +# len# #)   where     byteAsInt# = word2Int# (word8ToWord# byte#)++-- | Use a struct poke as a regular poke.+--+-- To do this, we must associate a constant byte length with an existing poker.+-- Note that pokers don't expose the type of the data they are serializing,+-- so this is a very clumsy operation by itself. You should only be using this+-- when you have such types in scope, and the constant length should be obtained+-- in a sensible manner (e.g. 'Bytezap.Struct.Generic.KnownSizeOf' for generic+-- struct pokers, or your own constant size class if you're doing funky stuff).+fromStructPoke :: Int -> Struct.Poke s -> Poke s+fromStructPoke (I# len#) (Struct.Poke p) = Poke $ \base# os# s ->+    (# p base# os# s, os# +# len# #)

@@ -0,0 +1,83 @@+{-# LANGUAGE UnboxedTuples #-}++{- | Struct serializer: serialize fields of known length.++In Haskell-ish terminology, one may consider a C struct to be a product type+where each field is of known length. Thus, fields may be accessed by a fixed+offset from the struct start. This is convenient for efficient access, since+those offsets may be turned into immediates on a register in a MOV instruction.++Given a struct-like type, we don't need to track "bytes serialized so far" like+the general case. We can serialize fields in any order we like, since we know+where they will sit in the resulting bytestring.++This module provides a serializer specifically for these struct-like types.+Maybe GHC can write more efficient code for these super-simple types!+I have no idea. So I'm trying it, and will compare performance.++Notably, this serializer is much less flexible. No monoid! I don't really expect+anyone to write manual stuff with it-- you should just use the generics.+That reminds me, TODO could easily provide some TH too, and again compare.+-}++module Bytezap.Struct where++import GHC.Exts+import Raehik.Compat.Data.Primitive.Types++import Control.Monad.Primitive ( MonadPrim, primitive )+import Data.Word ( Word8 )+import Data.ByteString qualified as BS+import Data.ByteString.Internal qualified as BS++import GHC.Word ( Word8(W8#) )+import Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops ( setAddrRange# )++-- | A struct poker: base address (constant), byte offset, state token.+--+-- We could combine base address and byte offset, but we're aiming for code that+-- stores the address in a register and uses immediates to access fields (like+-- a good C compiler will do for its structs). So by keeping them separate, I'm+-- hoping that we can nudge GHC towards such behaviour.+type Poke# s = Addr# -> Int# -> State# s -> State# s++-- | Poke newtype wrapper.+newtype Poke s = Poke { unPoke :: Poke# s }++-- One may write a valid 'Semigroup' instance, but it's nonsensical, so let's+-- not.++-- | Execute a 'Poke' at a fresh 'BS.ByteString' of the given length.+unsafeRunPokeBS :: Int -> Poke RealWorld -> BS.ByteString+unsafeRunPokeBS len p = BS.unsafeCreate len (unsafeRunPoke p)++-- | Execute a 'Poke' at a pointer. Returns the number of bytes written.+--+-- The pointer must be a mutable buffer with enough space to hold the poke.+-- Absolutely none of this is checked. Use with caution. Sensible uses:+--+-- * implementing pokes to ByteStrings and the like+-- * executing known-length (!!) pokes to known-length (!!) buffers e.g.+--   together with allocaBytes+unsafeRunPoke :: MonadPrim s m => Poke s -> Ptr Word8 -> m ()+unsafeRunPoke (Poke p) (Ptr base#) = primitive $ \s0 -> (# p base# 0# s0, () #)++-- | Poke a type via its 'Prim'' instance.+prim :: forall a s. Prim' a => a -> Poke s+prim a = Poke $ \base# os# s0 -> writeWord8OffAddrAs# base# os# a s0++-- | The empty poke. Provided here as we can't provide it via 'Monoid.empty'.+emptyPoke :: Poke s+emptyPoke = Poke $ \_base# _os# s0 -> s0++-- | Sequence two 'Poke's. We only require the length of the left poke.+sequencePokes :: Poke s -> Int -> Poke s -> Poke s+sequencePokes (Poke pl) (I# ll#) (Poke pr) = Poke $ \base# os# s0 -> do+    case pl base# os# s0 of s1 -> pr base# (os# +# ll#) s1++-- | essentially memset+replicateByte :: Int -> Word8 -> Poke RealWorld+replicateByte (I# len#) (W8# byte#) = Poke $ \base# os# s0 ->+    setAddrRange# (base# `plusAddr#` os#) len# byteAsInt# s0+  where+    byteAsInt# = word2Int# (word8ToWord# byte#)

@@ -0,0 +1,80 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE UndecidableInstances #-} -- thanks to type manipulation++{- TODO+* in some low-level Haskell code (probably bytestring or other GHC lib) I've+  seen a pattern of binding in a certain way in order to hint a value's+  stickiness (whether it will change) to GHC. Probably whether to put it on LHS+  or RHS.+  * yeah, I think see https://wiki.haskell.org/Let_vs._Where+  * and Data.ByteString.Builder.Internal for a purposeful eta expansion+-}++{- | Generics for bytezap's struct serializer.++We can't use my generic-data-functions library, because we're doing more than+just basic monoidal composition. But I still want the same pluggable generics,+where the user provides the class to use for base cases. So I do that. However,+unlike g-d-f, the class info can't be provided via the user-selected monoid,+because you don't select that. Instead, we take a simple "index" type. It's+pretty much the same idea, surprisingly. This way, we can provide a few sensible+"versions" like in g-f-d, while primarily designing for DIY.+-}++module Bytezap.Struct.Generic where++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++-- | Class for holding info on class to use for poking base cases.+--+-- The type is just used to map to class info. It is never instantiated.+-- By packing @KnownSizeOf@ into here, we don't need to enforce a type-level+-- solution! Now it's up to you how you want to track your constant lengths.+--+-- We stay unboxed here because the internals are unboxed, just for convenience.+-- Maybe this is bad, let me know.+class GPokeBase idx where+    -- | The state token of our poker.+    type GPokeBaseSt idx++    -- | 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)++    -- | The type class that provides poked length (known at compile time).+    type KnownSizeOf' idx a :: Constraint++    -- | 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#++class GPoke idx f where gPoke :: f p -> Poke# (GPokeBaseSt idx)++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 idx l, GPoke idx r, GPokeBase idx, KnownSizeOf' idx (UnwrapGenericS1 l))+  => GPoke idx (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++instance (GPokeBase idx, GPokeBaseC idx a) => GPoke idx (S1 c (Rec0 a)) where+    gPoke = gPokeBase @idx . unK1 . unM1++-- | Wow, look! Nothing!+instance GPoke idx U1 where gPoke U1 _base# = \_os# s0 -> s0

@@ -0,0 +1,102 @@+{- | 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

@@ -0,0 +1,319 @@+-- | 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